E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeAbstractTheme.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright � 2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_ABSTRACT_THEME_H
#define  __TERRALIB_INTERNAL_ABSTRACT_THEME_H

#include "TeDefines.h"
#include "TeLegendEntry.h"
#include "TeGeometry.h"
#include "TeViewNode.h"
#include "TeAttribute.h"

class TeRasterTransform;
class TeRaster;
class TeDatabase;
class TeView;
struct TeRepresentation;

#include <string>
#include <set>


struct TL_DLL TeGrouping
{
           TeAttributeRep        groupAttribute_;
           
           string     groupNormAttribute_;
           
           TeGroupingMode        groupMode_;                                 
           
           int        groupNumSlices_;      
           
           int        groupPrecision_;

           double     groupStdDev_;

           string     groupFunction_; 

           bool       groupNullAttr_; 

           double groupMinVal_;

           double groupMaxVal_;

           TeChronon groupChronon_;

           TeGrouping(TeAttributeRep att=TeAttributeRep(), const string& normAttr="", 
                                            TeGroupingMode gMode=TeNoGrouping, int numSlice=0, int gPrecision=6,  
                                            double     gStDev=1.0, const string& func="", TeChronon gChronon = TeNOCHRONON): 
                                 groupAttribute_(att),
                                 groupNormAttribute_(normAttr),
                                 groupMode_(gMode),
                                 groupNumSlices_(numSlice),
                                 groupPrecision_(gPrecision),
                                 groupStdDev_(gStDev),
                                 groupFunction_(func),
                                 groupNullAttr_(false),
                                 groupMinVal_(TeMAXFLOAT),
                                 groupMaxVal_(TeMINFLOAT),
                                 groupChronon_(gChronon)
                                 {}

           TeGrouping(const TeGrouping& other)
           {          
                      groupAttribute_                  = other.groupAttribute_;
                      groupNormAttribute_   = other.groupNormAttribute_;
                      groupMode_                       = other.groupMode_;
                      groupNumSlices_                  = other.groupNumSlices_;
                      groupPrecision_                  = other.groupPrecision_;
                      groupStdDev_                     = other.groupStdDev_;
                      groupFunction_                   = other.groupFunction_;
                      groupNullAttr_                   = other.groupNullAttr_;
                      groupMinVal_                     = other.groupMinVal_;
                      groupMaxVal_                     = other.groupMaxVal_;
                      groupChronon_                               = other.groupChronon_;
           }
                                 
           ~TeGrouping() {}
           
           TeGrouping& operator= (const TeGrouping& other)
           {          
                      if ( this != &other )
                      {                     
                                 groupAttribute_                  = other.groupAttribute_;
                                 groupNormAttribute_   = other.groupNormAttribute_;
                                 groupMode_                       = other.groupMode_;
                                 groupNumSlices_                  = other.groupNumSlices_;
                                 groupPrecision_                  = other.groupPrecision_;
                                 groupStdDev_                     = other.groupStdDev_;
                                 groupFunction_                   = other.groupFunction_;
                                 groupNullAttr_                   = other.groupNullAttr_;
                                 groupNullAttr_                   = other.groupNullAttr_;
                                 groupMinVal_                     = other.groupMinVal_;
                                 groupMaxVal_                     = other.groupMaxVal_;
                                 groupChronon_                    = other.groupChronon_;
                      }
                      return *this;
           }
};

using namespace std;


class TL_DLL TeAbstractTheme: public TeViewNode
{

           friend class TeDatabase;
public :
           short temporaryVisibility(void) { return temporaryVisibility_;}
           void temporaryVisibility(short state) { temporaryVisibility_=state;}
           void temporaryRepresentation(int rep) { temporaryRepresentation_=rep;}
           int temporaryRepresentation(void) { return temporaryRepresentation_;}

protected :

           // if theme is visible or not only memory (TeCanvas)
           short                 temporaryVisibility_;
           
           // set the active representation on memory (TeCanvas);
           int                              temporaryRepresentation_;

public:
    TeAbstractTheme(const string& name, TeViewNode* parent, const int& view, const int& id, const TeViewNodeType& nodeType);

           TeAbstractTheme(const TeViewNodeParams& params);

           TeAbstractTheme(const TeAbstractTheme& other);

           virtual ~TeAbstractTheme();

           TeAbstractTheme& operator= (const TeAbstractTheme& other); 



           virtual TeProjection* getThemeProjection() = 0;

           virtual double minScale() { return minScale_; }

           virtual void minScale(double s) { minScale_ = s; }

           virtual double maxScale() { return maxScale_; }

           virtual void maxScale(double s) { maxScale_ = s; }


           virtual bool hasRestriction() { return (!(generateAttributeRest_.empty() || 
                                                                                                     generateTemporalRest_.empty()) && hasSpatialRes_); }

           virtual string attributeRest() { return generateAttributeRest_; }

           virtual void attributeRest(const string& s) { generateAttributeRest_ = s; }

           virtual bool hasAttrRest () { return (!generateAttributeRest_.empty());}

           virtual string temporalRest() { return generateTemporalRest_; }

           virtual void temporalRest(const string& t) { generateTemporalRest_ = t; };

           virtual bool hasTemporalRest() { return (!generateTemporalRest_.empty());}

           virtual string spatialRest() { return generateSpatialRest_; }

           virtual void spatialRest(const string& s) { generateSpatialRest_ = s; };
           
           virtual TeSpatialRelation        spatialRelation() { return spatialRelation_;}

           virtual void spatialRelation(TeSpatialRelation s) {spatialRelation_=s;}
           
           virtual bool hasSpatialRest() { return hasSpatialRes_;}

           virtual void hasSpatialRest(bool a) {hasSpatialRes_ = a;}
           
           virtual TeBox boxRestriction() { return boxRest_;}

           virtual void boxRestriction(TeBox& b) {boxRest_ = b;}

           virtual TeGeometry* geomRestriction() { return geomRest_;}

           virtual void geomRestriction(TeGeometry* g) {geomRest_ = g;}

           virtual TeGeomRep geomRepRestriction() { return geomRepRest_; }

           virtual void geomRepRestriction (TeGeomRep& rep) { geomRepRest_ = rep; }

           virtual void setSpatialRest(TeBox& box, TeGeomRep rep, TeSpatialRelation relation = TeWITHIN); 

           virtual void setSpatialRest(TeGeometry* geom, TeGeomRep rep, TeSpatialRelation relation = TeWITHIN); 
           
           


           virtual void visibleRep(int rep) { visibleRep_ = rep; }


           virtual int visibleRep() { return visibleRep_; }

           virtual int visibleGeoRep();

           virtual void setAvailability(const bool& avaiability);

           const bool& isAvailable() const;

           bool isEditable() const;

           void setEditable(const bool& editable);


           virtual int visibility()
           {          return enableVisibility_; }


           virtual void visibility(int v)
           {          enableVisibility_ = v; }
           

           virtual TeGrouping& grouping() { return grouping_; }
           
           virtual void grouping(const TeGrouping& g) 
           { grouping_ = g; }

           virtual TeLegendEntryVector& legend() { return legend_; }

           virtual bool setGroupingVisual(int n, TeVisual* visual, TeGeomRep rep);

           virtual bool setGroupingVisual(int n, TeGeomRepVisualMap& vismap);

           virtual void resetGrouping ();

           virtual void cleanLegend(); 

           virtual bool buildGrouping(const TeGrouping& g, vector<TeSlice>& slices);

           virtual TeSliceVector getSlices();


           virtual void defaultLegend (TeLegendEntry& leg) 
           { defaultLegend_ = leg; }

           virtual TeLegendEntry& defaultLegend () 
           { return defaultLegend_; }

           virtual void setVisualDefault (TeVisual* visual, TeGeomRep rep)
           { defaultLegend_.setVisual(visual, rep); }


           virtual void outOfCollectionLegend (TeLegendEntry &leg) 
           { outOfCollectionLegend_ = leg;}

           virtual TeLegendEntry& outOfCollectionLegend () 
           { return outOfCollectionLegend_; } 
           
           virtual void setVisualOutOfCollection (TeVisual* visual, TeGeomRep rep)
           { outOfCollectionLegend_.setVisual(visual, rep); }


           virtual void withoutDataConnectionLegend (TeLegendEntry &leg) 
           { withoutDataConnectionLegend_ = leg; }

           virtual TeLegendEntry& withoutDataConnectionLegend () 
           { return withoutDataConnectionLegend_; }

           virtual void setVisualWithoutDataConnection (TeVisual* visual, TeGeomRep rep)
           { withoutDataConnectionLegend_.setVisual(visual, rep); }
           
           virtual void pointingLegend (TeLegendEntry &leg) 
           { pointingLegend_ = leg; }

           virtual TeLegendEntry& pointingLegend () 
           { return pointingLegend_; }

           virtual void setVisualPointing (TeVisual* visual, TeGeomRep rep)
           { pointingLegend_.setVisual(visual, rep); }

           virtual void queryLegend (TeLegendEntry &leg) 
           { queryLegend_ = leg; }

           virtual TeLegendEntry& queryLegend () 
           { return queryLegend_; }
           
           virtual void setVisualQuery (TeVisual* visual, TeGeomRep rep)
           { queryLegend_.setVisual(visual, rep); }

           virtual void queryAndPointingLegend (TeLegendEntry &leg) 
           { queryAndPointingLegend_ = leg; }

           virtual TeLegendEntry& queryAndPointingLegend () 
           { return queryAndPointingLegend_; }

           virtual map<string, int>& getObjLegendMap() 
           { return objLegendMap_; }

           virtual map<string, int>& getObjOwnLegendMap() 
           { return objOwnLegendMap_; }

           virtual void setVisualQueryAndPointing (TeVisual* visual, TeGeomRep rep)
           { queryAndPointingLegend_.setVisual(visual, rep); }

           virtual void legend(TeLegendEntry& leg); 


           virtual TeRasterTransform* rasterVisual() 
           { return rasterVisual_; }

           virtual void rasterVisual(TeRasterTransform* r) 
           { rasterVisual_ = r; } 

           virtual void removeRasterVisual();

           virtual void createRasterVisual(TeRaster* rst=0);



           virtual TeBox& getThemeBox()
           {          return themeBox_; }

           virtual void setThemeBox(const TeBox& box)
           {          themeBox_ = box; }

           virtual TeBox& box()
           {          return themeBox_; }

           virtual void setParent (TeViewNode* );
           
           virtual bool operator< (const TeAbstractTheme& r) const
           {          return viewNodeParams_.priority_ < r.viewNodeParams_.priority_; }

           virtual void clearObjectSet()
           { objectSet_.clear(); }

           virtual int getNumLayerObjects()
           { return numLayerObjects_; }

           virtual map<string, int>& getObjStatusMap()
           { return objStatusMap_; }

           virtual void clearObjStatus()
           { objStatusMap_.clear(); }

           virtual void clearItemStatus()
           { itemStatusMap_.clear(); }

           virtual map<string, int>& getItemStatusMap()
           { return itemStatusMap_; }

           virtual void setStatus(vector<string>& oidVec, vector<string>& itemVec, int status);

           virtual void setStatusForItemsToggled(set<string>& oidSet, vector<string>& itemVec);

           virtual void setStatusForObjectToggled(string oid);

           virtual void setStatusForNewObjectsPointed(set<string>& oidSet);

           virtual void setStatusForObjectsAddedByPointing(set<string>& oidSet);

           virtual void setStatusForNewItemsPointed(vector<string>& itemVec);

           virtual void setStatusForItemsAddedByPointing(vector<string>& itemVec);

           virtual void setStatusForNewItemsQueried(set<string>& oidSet, vector<string>& uidVec);

           virtual void setStatusForItemsAddedByQuerying(set<string>& oidSet, vector<string>& uidVec);

           virtual void setStatusForItemsFilteredByQuerying(set<string>& oidSet, vector<string>& uidVec);

           virtual void removePointingColor();

           virtual void removeQueryColor();

           virtual void invertObjectStatus();

           virtual void setObjectsToDefaultStatus();

           virtual TeTime getCreationTime() const;

           virtual void setCreationTime(const TeTime& creationTime);

           virtual bool updateThemeCreationTime(TeDatabase* database);

           virtual bool isUpdated();

           virtual bool save() = 0;

           virtual bool buildGrouping(const TeGrouping& g, TeSelectedObjects selectedObjects = TeAll,
                                     vector<double>* dValuesVec = 0) = 0;

           virtual bool buildGrouping(const TeGrouping& g, TeChronon chr, vector<map<string, string> >& mapObjValVec) = 0;
           
           
           virtual bool saveGrouping(TeSelectedObjects selectedObjects = TeAll) = 0;

           virtual bool deleteGrouping() = 0; 

           virtual void setLegendsForObjects() = 0;

           virtual void setOwnLegendsForObjects() = 0;

           virtual bool locatePolygon                  (TeCoord2D &pt, TePolygon &polygon, const double& tol = 0.0) = 0;
           virtual bool locatePolygonSet   (TeCoord2D &pt, double tol, TePolygonSet &polygons) = 0;
           virtual bool locateLine                     (TeCoord2D &pt, TeLine2D &line, const double& tol = 0.0) = 0;
           virtual bool locatePoint         (TeCoord2D &pt, TePoint &point, const double& tol = 0.0) = 0;
           virtual bool locateCell                     (TeCoord2D &pt, TeCell &c, const double& tol = 0.0) = 0;

           virtual set<string> getObjects(TeSelectedObjects selectedObjects = TeAll) = 0;

           virtual set<string> getObjects(const vector<string>& itemVec) = 0;

           virtual vector<string> getItemVector(TeSelectedObjects selectedObjects) = 0;

           virtual vector<string> getItemVector(const set<string>& oidSet) = 0;

           virtual unsigned int getNumberOfObjects()=0; 

           virtual bool saveMetadata(TeDatabase* ) = 0;

           TeAbstractTheme* copyTo(TeDatabase* outputDatabase, TeView* view, const std::string& renameTo = "", const int& orderIndex = -1);
                      
protected:
           string                generateAttributeRest_;
           string                generateTemporalRest_;
           string                generateSpatialRest_; //future use

           TeSpatialRelation     spatialRelation_;
           bool                                        hasSpatialRes_;
           TeBox                                       boxRest_;             //box which defines the spatial restriction 
           TeGeometry*                                 geomRest_;            //geometry which defines the spatial restriction 
           TeGeomRep                        geomRepRest_;         //geometry representation of the theme which will be 
                                                                                                              //considered in the spatial restriction  
           // Display scale
           double     minScale_;
           double     maxScale_;

           //representation visible in the theme
           int visibleRep_;

           //Theme status
           int        enableVisibility_;

           // ----------------- grouping information -----------------
           TeGrouping            grouping_;

           // ----------------- legend information -----------------
           TeLegendEntryVector   legend_;

           // Background Legend
           TeLegendEntry                    outOfCollectionLegend_;                                //group(-1) 
           TeLegendEntry                    withoutDataConnectionLegend_;    //group(-2) 
           TeLegendEntry                    defaultLegend_;                                                   //group(-3) 
           TeLegendEntry                    pointingLegend_;                                       //group(-4) 
           TeLegendEntry                    queryLegend_;                                                     //group(-5) 
           TeLegendEntry                    queryAndPointingLegend_;                    //group(-6)

           map<string, int>      objLegendMap_;                                                    // object legend
           map<string, int>      objOwnLegendMap_;                                      // object own legend
                      
           TeRasterTransform*    rasterVisual_;

           bool isAvailable_, 
                      isEditable_;          
           
           TeBox      themeBox_;

           set<string> objectSet_;

           int numLayerObjects_;

           map<string, int> itemStatusMap_;

           map<string, int> objStatusMap_;

           TeTime creationTime_;

public:
           virtual bool loadMetadata(TeDatabase* ) = 0;

protected:

           virtual bool eraseMetadata(TeDatabase* ) = 0;

           virtual bool beforeCopyThemeTo(TeAbstractTheme* absThemeCopy, TeDatabase* outputDatabase);
           
           virtual bool afterCopyThemeTo(TeAbstractTheme* absThemeCopy, TeDatabase* outputDatabase);
};

typedef vector<TeAbstractTheme*> TeThemeVector;

typedef map<int, TeAbstractTheme*>          TeThemeMap;

#endif