E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeGeometry.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_GEOMETRY_H
#define __TERRALIB_INTERNAL_GEOMETRY_H

#if defined(_MSC_VER) /* MSVC Compiler */
#pragma warning(disable: 4786)
#endif

#include "TeDefines.h"
#include "TeBox.h"
#include "TeCoord2D.h"
#include "TeComposite.h"
#include "TeMeasure.h"
#include "TeUtils.h"
#include "TeDataTypes.h"

#include <string>
#include <iostream>


using namespace std;


class TL_DLL TeGeometry
{
public:

           TeGeometry(): box_ ( TeMAXFLOAT, TeMAXFLOAT, -TeMAXFLOAT, -TeMAXFLOAT ),
                      geomId_  ( 0 ), objectId_ (""), srid_(-1) {}

           TeGeometry ( const TeGeometry& other ) 
           {
                      box_    = other.box_;
                      geomId_ = other.geomId_;
                      objectId_ = other.objectId_;
                      srid_ = other.srid_;
           }
           
           virtual ~TeGeometry() {}

           void setBox ( const TeBox & box )
           { box_  = box; }
           
           const TeBox& box () const 
           { return box_; }

           TeBox& box ()
           { return box_; }

           int geomId() const
           { return geomId_; }

           void geomId( int id )
           { geomId_ = id; }

           virtual string objectId() const
           { return objectId_; }

           virtual void objectId ( const string& id )
           { objectId_ = id; }

           virtual int srid() const
           { return srid_; }

           virtual void srid(const int& srid)
           { srid_ = srid; }

           virtual unsigned int size() const
           { return 0; }

           ostream& operator<<(ostream& os)
           {
                      os << Te2String(geomId_);
                      return os;
           }

           virtual bool isRing() const
           { return false; }

           virtual TeGeomRep elemType() const 
           { return TeGEOMETRYNONE; }
           
protected:

           TeBox      box_;                 
           int                   geomId_;   
           string     objectId_; 
           int                   srid_;                
};



class TL_DLL TeGeometryNone:  public TeGeometry
{
public: 
           TeGeomRep elemType() const { return TeGEOMETRYNONE; }

           void clear () { return; }
};

class TL_DLL TeVector : public TeGeometry
{
};


template <class T>
class TeGeomSingle : public TeVector
{
public:

           typedef  T value_type;

           TeGeomSingle<T>() {}

           TeGeomSingle<T> (const T& elem ): elem_ ( elem  ) 
           {          updateBox ( box_, elem ); }

           TeGeomSingle ( const TeGeomSingle& other ) : TeVector()
           {
                      box_    = other.box_;
                      geomId_ = other.geomId_;
                      objectId_ = other.objectId_;
                      elem_ = other.elem_;
           }

           TeGeomSingle& operator = ( const TeGeomSingle& other )
           {
                      box_    = other.box_;
                      geomId_ = other.geomId_;
                      objectId_ = other.objectId_;
                      elem_ = other.elem_;
                      return *this;
           }

           virtual ~TeGeomSingle<T>() {}

           void add ( T& elem )
           {
                      elem_ = elem;
                      box_ = TeBox(TeMAXFLOAT, TeMAXFLOAT,-TeMAXFLOAT,-TeMAXFLOAT); // invalidates its box
                      updateBox ( box_, elem );
           }

           T&         location ()
           {          return elem_; }

           const T& location () const
           {          return elem_; }

           T& elem ()
           {          return elem_; }

           const T& elem () const
           {          return elem_; }

           T& operator [] ( int /* i */) 
           {          return elem_; }

           bool operator== (const TeGeomSingle& other) const
           {          return elem_ == other.elem(); }

           int size() { return 1; }

protected:
           T          elem_;

};




template <class T>  
class TeGeomComposite: public TeVector
{
public:

           TeGeomComposite()
           {
                      pImpl_ = new TeComposite<T>;
                      pImpl_->attach();
           }

           virtual ~TeGeomComposite()
           {          pImpl_->detach();     }


           TeGeomComposite ( const TeGeomComposite& other ) : TeVector()
           {
                      pImpl_ = other.pImpl_;
                      pImpl_->attach();
                      box_    = other.box_;
                      geomId_ = other.geomId_;
                      objectId_ = other.objectId_;
           }

           TeGeomComposite& operator= ( const TeGeomComposite& other )
           {
                      if ( this != &other )
                      {          
                                 other.pImpl_->attach();
                                 pImpl_->detach();
                                 pImpl_  = other.pImpl_;
                                 box_    = other.box_;
                                 geomId_ = other.geomId_;
                                 objectId_ = other.objectId_;
                      }
                      return *this;
           }

           virtual string objectId() const
           { return objectId_; }

           virtual void objectId (const string& id )
           { 
                      objectId_ = id; 
                      typename TeComposite<T>::iterator it = pImpl_->begin();
                      while (it != pImpl_->end())
                      {
                                 it->objectId(id);
                                 ++it;
                      }
           }

           void copyElements ( const TeGeomComposite& other )
           {
                      geomId_ = other.geomId_;
                      objectId_ = other.objectId_;

                      for (unsigned int i = 0; i < other.pImpl_->size(); i++)
                                 add (other.pImpl_->operator[](i));
           }

           bool operator== (const TeGeomComposite& other) const
           {          
                      if ( this->size() != other.size() )
                                 return false;

                      for (unsigned int i = 0; i < other.pImpl_->size(); i++)
                                 if ( ! ( pImpl_->operator[]( i ) == other.pImpl_->operator[]( i ) ) )
                                            return false;
      
                      return true; 
           }

           void add ( const T& elem )
           {          
                      pImpl_->add ( elem );
                      updateBox ( box_, elem );
           }

           bool erase ( int i )
           {          
                      bool status = pImpl_->erase (i);

                      if (status)           // recalculates the box
                      {
                                 box_ = TeBox(TeMAXFLOAT, TeMAXFLOAT,-TeMAXFLOAT,-TeMAXFLOAT);
                                 for (unsigned int j = 0; j < pImpl_->size(); j++)
                                            updateBox(box_,pImpl_->operator[](j));
                      }
                      return status;
           }

           bool erase ( T& object )
           {          
                      bool status = pImpl_->erase ( object ); 
                      if (status)           // recalculates the box
                      {
                                 box_ = TeBox(TeMAXFLOAT, TeMAXFLOAT,-TeMAXFLOAT,-TeMAXFLOAT);
                                 for (unsigned int j = 0; j < pImpl_->size(); j++)
                                            updateBox(box_,pImpl_->operator[](j));
                      }
                      return status;
           }

           typename TeComposite<T>::iterator erase(typename TeComposite<T>::iterator it)
           {          
                      typename TeComposite<T>::iterator res = pImpl_->erase(it); 
                      box_ = TeBox(TeMAXFLOAT, TeMAXFLOAT,-TeMAXFLOAT,-TeMAXFLOAT);
                      for (unsigned int j = 0; j < pImpl_->size(); j++)
                                 updateBox(box_,pImpl_->operator[](j));
                      return res;
           }

           void clear ()
           {          
                      pImpl_->clear ();                // remove all elements
                      box_ = TeBox(TeMAXFLOAT, TeMAXFLOAT,-TeMAXFLOAT,-TeMAXFLOAT); // invalidates its box
           }
           
           unsigned int size() const
           {          return ( (unsigned int) pImpl_->size() ); }

           void reserve(int nelem)
           { pImpl_->reserve(nelem); }

           T& operator [] ( int i ) const
           {          return pImpl_->operator[] ( i ); }

           T& first() const
           {          return pImpl_->operator[] ( 0 ); }
           
           T& last() const
           {          return pImpl_->operator[] ( pImpl_->size()-1 ); }
           
           bool empty () const
           {          return pImpl_->empty (); }

           typedef typename TeComposite<T>::iterator iterator;

//         typedef typename T value_type;
           typedef  T value_type;

           typename TeComposite<T>::iterator begin()
           { return pImpl_->begin(); }

           typename TeComposite<T>::iterator const begin() const
           { return pImpl_->begin(); }

           typename TeComposite<T>::iterator end()
           { return pImpl_->end(); }

           typename TeComposite<T>::iterator const end() const
           { return pImpl_->end(); }

           typedef typename TeComposite<T>::reverse_iterator reverse_iterator;

           typename TeComposite<T>::reverse_iterator rbegin()
           { return pImpl_->rbegin(); }

           typename TeComposite<T>::reverse_iterator rend()
           { return pImpl_->rend(); }

protected:

           TeComposite<T> * pImpl_; 
};


class TL_DLL TeLine2D : public TeGeomComposite<TeCoord2D>
{
public:
           bool isRing() const;  

           string objectId() const
           { return objectId_; }
           
           void objectId (const string& id )
           {  objectId_ = id; }

           TeGeomRep elemType() const { return TeLINES; }
};


class TL_DLL TeLineSet: public TeGeomComposite<TeLine2D>
{
public:
           TeGeomRep elemType() const { return TeLINES; }

           void copyElements (const TeLineSet& other ); 
}; 


class TL_DLL TeLinearRing : public TeLine2D  {
public:

           TeLinearRing() : TeLine2D() {}

           TeLinearRing ( TeLine2D& line );
};



class TL_DLL TePolygon: public TeGeomComposite<TeLinearRing>  
{
public:
           
           TeGeomRep elemType() const { return TePOLYGONS; }

           void copyElements ( const TePolygon& other );
};

class TL_DLL TePolygonSet: public TeGeomComposite<TePolygon> 
{
public:
           TeGeomRep elemType() const { return TePOLYGONS; }

           void copyElements ( const TePolygonSet& other );
};

           
class TL_DLL TePoint : public TeGeomSingle<TeCoord2D>
{
public:
           TePoint(const double& x = 0., const double& y = 0. ):
                      TeGeomSingle<TeCoord2D> ( )
           {
                                 elem_ = TeCoord2D(x,y);
                                 setBox(TeBox(x,y,x,y)); // the box of a point is the point itself
           }

           TePoint(const TeCoord2D& c):
                      TeGeomSingle<TeCoord2D> ( )
           {
                                 elem_ = c;
                                 setBox(TeBox(c.x(),c.y(),c.x(),c.y())); // the box of a point is the point itself
           }

           TeGeomRep elemType() const { return TePOINTS; }

           string objectId() const
           { return objectId_; }
           
           void objectId (const string& id )
           {  objectId_ = id; }

};

class TL_DLL TePointSet: public  TeGeomComposite<TePoint> 
{
public:
           TeGeomRep elemType() const { return TePOINTS; }
};

class TL_DLL TeText: public TeGeomSingle<TeCoord2D>
{
public:

           TeText(const string& txt="" ):
                      TeGeomSingle<TeCoord2D> ( ),
                      angle_(0),
                      height_(0),
                      textValue_(txt),
                      alignmentVert_(0),
                      alignmentHoriz_(0)
           {
                      elem_ = TeCoord2D(0,0);
                      setBox(TeBox(0.0,0.0,0.0,0.0));
           }


           TeText( TeCoord2D& location, const string& txt="" ):
                      TeGeomSingle<TeCoord2D> ( location ),
                      angle_(0),
                      height_(0),
                      textValue_(txt),
                      alignmentVert_(0),
                      alignmentHoriz_(0)
           {
                      setBox(TeBox(location,location));
           }

           TeText(const TeText& other ) : TeGeomSingle<TeCoord2D>()
           {
                      angle_ = other.angle_;
                      height_ = other.height_;
                      textValue_ = other.textValue_;
                      alignmentVert_ = other.alignmentVert_;
                      alignmentHoriz_ = other. alignmentHoriz_;
                      setBox(other.box());
                      elem_ = other.elem_;
                      geomId_ = other.geomId_;
                      objectId_ = other.objectId_;
           }

           TeText& operator= ( const TeText& other )
           {
                      if ( this != &other )
                      {          
                                 angle_ = other.angle_;
                                 height_ = other.height_;
                                 textValue_ = other.textValue_;
                                 alignmentVert_ = other.alignmentVert_;
                                 alignmentHoriz_ = other. alignmentHoriz_;
                                 setBox(other.box());
                                 elem_ = other.elem_;
                                 geomId_ = other.geomId_;
                                 objectId_ = other.objectId_;
                      }
                      return *this;
           }

           bool operator== (const TeText& tx) const 
           {
                      return (angle_ == tx.angle_ &&
                                 height_ == tx.height_ &&
                                 textValue_ == tx.textValue_ &&
                                 alignmentVert_ == tx.alignmentVert_ &&
                                 alignmentHoriz_ == tx.alignmentHoriz_ &&
                                 elem_ == tx.elem_ &&
                                 geomId_ == tx.geomId_ &&
                                 objectId_ == tx.objectId_);
           }

           void setLocation(const TeCoord2D& l)
           {          elem_ = l; setBox(TeBox(l,l));   }

           string textValue () const
           { return textValue_; }
           
           void setTextValue (const string &text) 
           { textValue_ = text; }

           double angle () const
           { return angle_; }

           void setAngle (double angle) 
           { angle_ = angle; }

           double height () const
           { return height_ ; }

           void setHeight (double height) 
           { height_ = height; }

           double alignmentVert () const
           { return alignmentVert_ ; }

           void setAlignmentVert (double alig) 
           { alignmentVert_ = alig; }

           double alignmentHoriz () const
           { return alignmentHoriz_ ; }

           void setAlignmentHoriz (double alig) 
           { alignmentHoriz_ = alig; }

           TeGeomRep elemType() const { return TeTEXT; }

private:
           double angle_;        
           double height_;
           string textValue_;
           double alignmentVert_;
           double alignmentHoriz_;
};


class TL_DLL TeTextSet : public TeGeomComposite<TeText> 
{
public:
           TeGeomRep elemType() const { return TeTEXT; }

};


class TL_DLL TeNode: public TeGeomSingle<TeCoord2D>
{
public:
           bool operator== (const TeNode& node) const
           {
                      TeCoord2D p1 = elem_;
                      TeCoord2D p2 = node.elem_;
                      return p1==p2;
           }

           ostream& operator<<(ostream& os)
           {
                      os << Te2String(geomId_);
                      return os;
           }

           TeGeomRep elemType() const { return TeNODES; }

};

TL_DLL ostream& operator<<(ostream& os, TeNode& N);

class TL_DLL TeNodeSet : public TeGeomComposite<TeNode> 

{
public:
           TeGeomRep elemType() const { return TeNODES; }

};

class TL_DLL TeArc : public TeVector 
{
public:

           TeArc(): ifrom_ (-1), ito_ (-1){}


           TeArc(TeNode& from, TeNode& to)
           {
                      from_ = from;
                      to_ = to;
                      updateBox ( box_, from );
                      updateBox ( box_, to );
           }


           TeArc(int from, int to): ifrom_ (from), ito_ (to) {}

// -- Methods

           TeNode& fromNode () 
           { return from_; }

           TeNode& toNode () 
           { return to_; }

           int fromId () const
           { return ifrom_; }

           void fromId (int i) 
           { ifrom_ = i; }

           int toId () const
           { return ito_; }

           void toId (int i)
           { ito_ = i; }
           
           void setNodes (TeNode& from, TeNode& to)
           { 
                      from_ = from;
                      to_ = to;
                      updateBox ( box_, from );
                      updateBox ( box_, to );
           }

           TeGeomRep elemType() const { return TeARCS; }

           bool operator== (const TeArc& other) const
           {
                      if((from_ == other.from_) &&
                  (to_ == other.to_) &&
                         (ifrom_ == other.ifrom_) &&
           (ito_ != other.ito_))
                                 return true;

                      return false;
           }

private:

           TeNode     from_, to_;
           int                   ifrom_, ito_;
};

TL_DLL ostream& operator<<(ostream& os, const TeArc& N);


class TL_DLL TeArcSet: public TeGeomComposite <TeArc> 
{
public:
           TeGeomRep elemType() const { return TeARCS; }
};

class TL_DLL TeSample: public TeGeomSingle<TeCoord2D>, public TeMeasure
{
public:

           TeSample ( const TeCoord2D& location, double measure = 0.  ):
                      TeGeomSingle<TeCoord2D> ( location ), TeMeasure ( measure ) {}

           TeGeomRep elemType() const { return TeSAMPLES; }
};

class TL_DLL TeSampleSet: public TeGeomComposite<TeSample>
{
public:
           TeGeomRep elemType() const { return TeSAMPLES; }
};

class TL_DLL TeContourLine: public TeLine2D, public TeMeasure
{
public:

           TeContourLine ( TeLine2D& line, double measure = 0. )
                      : TeLine2D ( line ), TeMeasure ( measure )
           {}
};


class TL_DLL TeContourLineSet: public  TeGeomComposite <TeContourLine> 
{
public:
           TeGeomRep elemType() const { return TeSAMPLES; }
};


class TL_DLL TeCell : public TeVector 
{
           int column_;          
           int line_;            

public:
           TeCell():
             column_(-1),
             line_(-1) {}

           TeCell(TeBox& box, int col, int lin):
             column_(col),
             line_(lin) { setBox(box); }

           int        column () const
           { return column_; }

           void column (int column) 
           { column_ =  column; }

           int        line () const
           { return line_; }

           void line (int line) 
           { line_ =  line; }

           TeGeomRep elemType() const { return TeCELLS; }

           bool operator== (const TeCell& other) const
           {
                      if((column_ == other.column_) &&
                  (line_ == other.line_))
                                 return true;

                      return false;
           }
};

class TL_DLL TeCellSet: public  TeGeomComposite<TeCell> 
{
           double     resX_;     
           double     resY_;     

public:

           TeCellSet() : resX_(0.), resY_(0.) 
           {}

           double resX () const
           { return resX_; }

           double resY () const
           { return resY_; }

           void resX (double reX) 
           { resX_ = reX; }


           void resY (double reY) 
           { resY_ = reY; }

           TeGeomRep elemType() const { return TeCELLS; }

};


TL_DLL TePointSet makePointSet( const TeLinearRing& lr );


TL_DLL TePointSet makePointSet( const TePolygon& p );

#endif