E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeLayer.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_LAYER_H
#define __TERRALIB_INTERNAL_LAYER_H

#include "TeGeometry.h"
#include "TeDataTypes.h"
#include "TeTable.h"
#include "TeRepresentation.h"

#include <string>
#include <list>
#include <map>

class TeRaster;
class TeDatabase;
class TeRasterParams;
class TeProjection;


class TL_DLL TeLayer {

public:

           TeLayer():
                      id_(-1),
                      db_(0),
                      projection_ ( 0 ),
                      raster_(0)
                      { }

                      
           /* 
                      \param name layer name (should be unique)
                      \param db a TerraLib database connection w
                      \param proj layer projection
                      \note 
                                 \par If no database is informed, layer will exist only in memory.
                                 \par If a layer with this name doesn´t exist a layer will be 
                                  created and stored. If no projection is informed a default TeNoProjection
                                  will be used as layer projection.
            \par If a layer with this name already exists it will be retrieved
           */          
           TeLayer(const string& name, TeDatabase* db=0, TeProjection* proj=0);

           /* 
                      \param name layer name (should be unique)
                      \param db TerraLib database connection where layer will be stored
                      \param box layer bounding box
                      \param proj layer projection
                      \note 
                                 \par If no database is informed, layer will exist only in memory.
                                 \par If a layer with this name doesn´t exist a layer will be 
                                  created and stored. If no projection is informed a default TeNoProjection
                                  will be used as layer projection.
            \par If a layer with this name already exists it will be retrieved
           */
           TeLayer(const string& name, TeDatabase* db, TeBox& box, TeProjection* proj = 0);

           virtual ~TeLayer();

           TeLayer ( const TeLayer& other );

           TeLayer& operator= ( const TeLayer& other );
           
           virtual TeDatabase* const database() 
           { return db_; }

           virtual void setDatabase(TeDatabase* db)
           { db_ = db; }

           virtual int id()
           { return id_; } 

           virtual void id(int id)
           { id_ = id; } 

           virtual string name()
           { return name_; }

           virtual void name(const string &name)
           {  name_ = name; }

           virtual void  setProjection ( TeProjection* proj );

           virtual TeProjection* projection()
           {          return projection_; }

           virtual TeBox&        box()
           {          return box_; }

           virtual void setLayerBox ( const TeBox& box );

           virtual void updateLayerBox(const TeBox& box);

           virtual void updateLayerBox();

           virtual int getNewObjectId();


           virtual int nObjects(const string& tName);

           virtual TeAttrTableVector& attrTables () 
           { return attTables_; }

           virtual const TeAttrTableVector& attrTables () const
           { return attTables_; }

           virtual bool createAttributeTable(TeTable& table);

           virtual bool addAttributeTable(TeTable& table);

           virtual bool removeAttributeTable(string tableName);

           virtual void updateAttributeTable(TeTable& table);

           virtual bool loadLayerTables();

           virtual bool saveAttributeTable(TeTable& table);

           virtual bool getAttrTables(TeAttrTableVector& atts, TeAttrTableType attType = TeAllAttrTypes);

           /*
                      \param tableNames a vector that contains the name of the tables that are being searched
                      \param attType type of table that is being searched
                      \param atts returns a vector of tables found
                      \return true if at least one table was found and false otherwise
           */
           virtual bool getAttrTablesByName(vector<string> &tableNames, TeAttrTableVector& atts, TeAttrTableType attType = TeAllAttrTypes);

           /*
                      \param tableName name of the table being searched
                      \param attType type of table being searched
                      \param table returns the table found
                      \return true if table was found and false otherwise
           */
           virtual bool getAttrTablesByName(const string& tableName, TeTable& table, TeAttrTableType attType = TeAllAttrTypes);

           virtual string mediaTable();

           virtual void mediaTable(const string& name);



           virtual TeRaster* raster(const string& objectId="",const char& mode = 'r');

           virtual void raster( TeRaster* raster);

           virtual bool getPolygons(TePolygonSet &ps, const string& whereClause = "");

           virtual bool getLines(TeLineSet &ls, const string& whereClause = "");

           virtual bool getPoints(TePointSet &ps, const string& whereClause = "");

           virtual bool getText(TeTextSet &ts, const string& whereClause = "");

           virtual bool getCells(TeCellSet &cs, const string& whereClause = "");

           virtual bool locatePolygon(TeCoord2D &pt, TePolygon &polygon, const double& tol = 0.0);
           
           virtual bool locateLine(TeCoord2D &pt, TeLine2D &line, const double& tol = 0.0);

           virtual bool locatePoint(TeCoord2D &pt, TePoint &point, const double& tol = 0.0);

           virtual bool locateText(TeCoord2D &pt, TeText &text, const double& tol = 0.0);

           virtual bool locateCell(TeCoord2D &pt, TeCell &cell, const double& tol = 0.0);

           virtual bool loadGeometrySet     (const string& geoid, TePolygonSet &ps);

           virtual bool loadGeometrySet (const string& geoid, TeLineSet &ls);

           virtual bool loadGeometrySet (const string& geoid, TePointSet &ps);

           virtual bool loadGeometrySet (const string& geoid, TeCellSet &cs);

           virtual bool loadGeometrySet (const string& geoid, TeTextSet &cs);
           
           virtual bool addGeometrySet(TePolygonSet& polySet, const string& /* tName */ = "")
           { return addPolygons(polySet); }

           virtual bool addGeometrySet(TeLineSet& lineSet, const string& /* tName */ = "")
           { return addLines(lineSet); }

           virtual bool addGeometrySet(TePointSet& pointSet, const string& /* tName */ = "")
           { return addPoints(pointSet); }

           virtual bool addGeometrySet(TeTextSet& textSet, const string& tName = "")
           { return addText(textSet,tName); }
           
           virtual bool addGeometrySet(TeCellSet& cellSet, const string& /* tName */ = "")
           { return addCells(cellSet); }

           virtual bool addPolygons(TePolygonSet& polySet);

           virtual bool addLines (TeLineSet& lineSet);

           virtual bool addPoints (TePointSet& pointSet);

           virtual bool addText (TeTextSet& textSet,const string& tName);
           
           virtual bool addCells(TeCellSet& cellSet);

           virtual bool updatePolygons(TePolygonSet& polySet);

           virtual bool updateLines (TeLineSet& lineSet);

           virtual bool updatePoints (TePointSet& pointSet);

           virtual bool updateText (TeTextSet& textSet,const string& tName);
           
           virtual bool updateCells(TeCellSet& cellSet);

           virtual bool removeGeometries(const std::vector<int>& vecGeomIds, const TeGeomRep& rep);



           virtual bool removeGeometry (TeGeomRep repType, const string& tName="");

           virtual bool hasGeometry (TeGeomRep rep);


           virtual string tableName(TeGeomRep rep); 


           virtual int nGeometries(TeGeomRep rep);

           virtual bool getRepresentation(TeGeomRep repType, TeRepresPointerVector& result);


           virtual TeRepresentation* getRepresentation(TeGeomRep repType, const string& tableName="");
    
           /*
                      \param repType the geometrical representation being searched
                      \param tableName name of the table that will stored the geometries
                      \param desc description of the representation
                      \return true if success and false otherwise
           */
           virtual bool addGeometry ( TeGeomRep repType, const string& tableName="", const string& desc = "");

           /*
                      \param par raster parameters
                      \param objectId identifier of the object that has the raster geometry
                      \param tableName name of the table that will stored the geometries
                      \param desc description of the representation
                      \return true if success and false otherwise
           */
           virtual bool addRasterGeometry(TeRasterParams& par, const string& objectId, 
                                                                     const string& tableName="", const string& desc="");

           /*
                      \param raster a pointer to a raster object
                      \param objectId identifier of the object that has the raster geometry
                      \param tableName the name of the table that will store the geometry (optional)
                      \return true if success and false otherwise
                      \note if there is already raster geometry associated to the object with id
                      object id, this reference is deleted.
           */         
           bool addRasterGeometry(TeRaster* raster, const string& objectId="");

           /*
                      \param raster a pointer to a raster object
                      \param objectId identifier of the object that has the raster geometry
                      \param desc the description of the geometry (optional)
                      \return true if success and false otherwise
                      \note if there is already raster geometry associated to the object with id
                      object id, this reference is deleted.
           */         
           bool addRasterFileGeometry(TeRaster* raster, const string& objectId="", const string& desc="");


           /*
                      \param objectIds a vector to return the identification of the objects with a raster representation
                      \param tilingType used to express that only some types of representations are looked for: 
                                    0 any kind, 1 only the expansible and 2 only the non-expansible
                      \param box box spatial restriction
                      \return true if layer has at least one raster object and false otherwise
           */
           virtual bool getRasterGeometries(vector<string>& objectIds, unsigned int tilingType=0, const TeBox& box = TeBox());

           virtual int geomRep();

           virtual void addVectRepres(TeRepresentation* rep)
           {          repVector_.push_back(rep); }

           virtual TeRepresPointerVector& vectRepres()
           {          return repVector_; }

  virtual const TeRepresPointerVector& vectRepres() const
           {          return repVector_; }

           virtual TeTime getEditionTime() const;

           virtual void setEditionTime(const TeTime& editionTime);

           virtual bool updateLayerEditionTime(const bool& setEditionToNow = true);

           virtual bool reloadLayerEditionTime();


private:

// -- Members

// -- General Description of a layer

           string                name_;                                                 
           int                              id_;                                                   
           TeDatabase*           db_;                                                   
           TeProjection*         projection_;                     
           TeBox                 box_;                                                  
           TeRaster*  raster_;                                    

           TeAttrTableVector     attTables_;           
           TeRepresPointerVector repVector_;           
           TeTime                editionTime_;                               
};

typedef map<int,TeLayer*> TeLayerMap;

#endif