E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeGeometryAlgorithms.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_GEOMETRYALGORITHMS_H
#define  __TERRALIB_INTERNAL_GEOMETRYALGORITHMS_H

#include "TeGeometry.h"
#include "TeMultiGeometry.h"

#include "TePrecision.h"
#include "TeProjection.h"

typedef vector<TeCoord2D> TeIntersCoordsVec;


template<class T1, class T2>
inline bool TeEquals(const T1& /*o1*/, const T2& /*o2*/)
{
           return false;
}

template<>
TL_DLL bool TeEquals(const TeCoord2D& c1, const TeCoord2D& c2);

template<>
TL_DLL bool TeEquals(const TePoint& p1, const TePoint& p2);

template<>
TL_DLL bool TeEquals(const TeLine2D& redLine, const TeLine2D& blueLine);

template<>
TL_DLL bool TeEquals(const TePolygon& redPol, const TePolygon& bluePol);

template<>
TL_DLL bool TeEquals( const TePolygonSet& ps1, const TePolygonSet& ps2 );

template<>
TL_DLL bool TeEquals(const TeBox& bx1, const TeBox& bx2);

template<>
TL_DLL bool TeEquals(const TeCell& cell1, const TeCell& cell2);
template<class T1, class T2> 
inline bool TeDisjoint(const T1& o1, const T2& o2)
{
           return TeDisjoint(o2, o1);
}

TL_DLL bool TeDisjoint(const TeCoord2D& c1, const TeCoord2D& c2);

TL_DLL bool TeDisjoint(const TeCoord2D& c, const TeBox& b);

TL_DLL bool TeDisjoint(const TeBox& bx1, const TeBox& bx2);

TL_DLL bool TeDisjoint(const TeCoord2D& c, const TeLine2D& l);

TL_DLL bool TeDisjoint(const TeCoord2D& c, const TePolygon& pol);

TL_DLL bool TeDisjoint(const TePoint& p1, const TePoint& p2);

TL_DLL bool TeDisjoint(const TePoint& p, const TeLine2D& l);

TL_DLL bool TeDisjoint(const TePoint& p, const TePolygon& pol);

TL_DLL bool TeDisjoint(const TeLine2D& redLine, const TeLine2D& blueLine);

TL_DLL bool TeDisjoint(const TeLine2D& l, const TePolygon& pol);

TL_DLL bool TeDisjoint(const TePolygon& redPol, const TePolygon& bluePol);

TL_DLL bool TeDisjoint(const TeCell& cell1, const TeCell& cell2);

TL_DLL bool TeDisjoint(const TeCell& cell, const TeLine2D& line);

TL_DLL bool TeDisjoint(const TeCell& cell, const TePolygon& pol);

TL_DLL bool TeDisjoint(const TeCell& cell, const TePoint& point);


template<class T1, class T2>
bool TeIntersects(const T1& o1, const T2& o2)
{
           return !TeDisjoint(o1, o2);
}

template<>
TL_DLL bool TeIntersects(const TeCoord2D& c, const TeBox& b);

template<>
TL_DLL bool TeIntersects(const TePoint& p, const TeBox& b);

template<>
TL_DLL bool TeIntersects(const TeBox& bx1, const TeBox& bx2);

TL_DLL bool TeTouches(const TeCoord2D& c, const TeLine2D& l);

TL_DLL bool TeTouches(const TeCoord2D& c, const TePolygon& pol);

TL_DLL bool TeTouches(const TePoint& p, const TeLine2D& l);

TL_DLL bool TeTouches(const TePoint& p, const TePolygon& pol);

TL_DLL bool TeTouches(const TeLine2D& redLine, const TeLine2D& blueLine);

TL_DLL bool TeTouches(const TeLine2D& l, const TePolygon& pol);

TL_DLL bool TeTouches(const TePolygon& redPol, const TePolygon& bluePol);

TL_DLL bool TeTouches(const TeBox& bx1, const TeBox& bx2);

TL_DLL bool TeTouches(const TeCell& c1, const TeCell& c2);

TL_DLL bool TeTouches(const TeLine2D& line, const TeCell& cell);

TL_DLL bool TeTouches(const TeCell& c1, const TePolygon& poly);

TL_DLL bool TeTouches( const TePoint& point, const TeCell& c1);

TL_DLL bool TeCrosses(const TeLine2D& redLine, const TeLine2D& blueLine);

TL_DLL bool TeCrosses(const TeLine2D& l, const TePolygon& pol);

TL_DLL bool TeCrosses(const TeLine2D& l, const TeCell& cell);

TL_DLL bool TeWithin(const TeCoord2D& c1, const TeCoord2D& c2);

TL_DLL bool TeWithin(const TeCoord2D& c, const TeBox& b);

TL_DLL bool TeWithin(const TeCoord2D& c, const TeLine2D& l);

TL_DLL bool TeWithin(const TeCoord2D& c, const TePolygon& pol);

TL_DLL bool TeWithin(const TePoint& p1, const TePoint& p2);

TL_DLL bool TeWithin(const TePoint& p, const TeLine2D& l);

TL_DLL bool TeWithin(const TePoint& p, const TePolygon& pol);

TL_DLL bool TeWithin(const TeLine2D& redLine, const TeLine2D& blueLine);

TL_DLL bool TeWithin(const TeLine2D& l, const TePolygon& pol);

TL_DLL bool TeWithin(const TePolygon& redPol, const TePolygon& bluePol);

TL_DLL bool TeWithin(const TeBox& bx1, const TeBox& bx2);

TL_DLL bool TeWithin(const TeCell& cell1, const TeCell& cell2);

TL_DLL bool TeWithin(const TeLine2D& line, const TeCell& cell);

TL_DLL bool TeWithin(const TeCell& cell, const TePolygon& poly);

TL_DLL bool TeWithin(const TePoint& point, const TeCell& cell);

template<class T1, class T2>
inline bool TeContains(const T1& o1, const T2& o2)
{
           return TeWithin(o2, o1);
}

TL_DLL bool TeOverlaps(const TeLine2D& redLine, const TeLine2D& blueLine);

TL_DLL bool TeOverlaps(const TePolygon& redPol, const TePolygon& bluePol);

TL_DLL bool TeOverlaps(const TeCell& cell1, const TeCell& cell2);

TL_DLL bool TeOverlaps(const TeCell& cell, const TePolygon& poly);

TL_DLL bool TeCoveredBy(const TeLine2D& redLine, const TeLine2D& blueLine);

TL_DLL bool TeCoveredBy(const TeLine2D& l, const TePolygon& pol);

TL_DLL bool TeCoveredBy(const TePolygon& redPol, const TePolygon& bluePol);

TL_DLL bool TeCoveredBy(const TeCell& cell1, const TeCell& cell2);

TL_DLL bool TeCoveredBy(const TePolygon& poly, const TeCell& cell);

TL_DLL bool TeCoveredBy(const TeLine2D& line, const TeCell& cell);

template<typename T1, typename T2>
inline bool TeCovers(T1& o1, T2& o2)
{
           return TeCoveredBy(o2, o1);
}
TL_DLL short TeRelation(const TeCoord2D& c, const TeLine2D& l);
 
TL_DLL short TeRelation(const TeCoord2D& c, const TeLinearRing& r);

TL_DLL short TeRelation(const TeCoord2D& c, const TePolygon& pol);

TL_DLL short TeRelation(const TePoint& p, const TePolygon& pol); 

TL_DLL short TeRelation(const TeCoord2D& c, const TePolygonSet& pSet);

TL_DLL short TeRelation(const TeLine2D& lRed, const TeLine2D& lBlue, const short& relation);

TL_DLL short TeRelation(const TeLine2D& line, const TePolygon& pol);

TL_DLL short TeRelation(const TePolygon& pRed, const TePolygon& pBlue);

TL_DLL bool TeDisjointOrTouches(const TeBox& bx1, const TeBox& bx2);

TL_DLL bool TeWithinOrTouches(const TeCoord2D& c, const TeCoord2D& c1, const TeCoord2D& c2);



template<class T1, class T2> 
bool TeWithinOrCoveredByOrEquals(const T1& geom1, const T2& geom2)
{
           short rel = TeRelation(geom1, geom2);

           if((rel&TeINSIDE) || (rel&TeBOUNDARY))
              return true;

           return false;
}

template<>
TL_DLL bool TeWithinOrCoveredByOrEquals(const TeBox& bx1, const TeBox& bx2);

template<>
TL_DLL bool TeWithinOrCoveredByOrEquals(const TeLine2D& line1, const TeLine2D& line2);

template<>
TL_DLL bool TeWithinOrCoveredByOrEquals(const TeLine2D& line1, const TePolygon& pol);

template<>
TL_DLL bool TeWithinOrCoveredByOrEquals(const TePolygon& pol1, const TePolygon& pol2);
TL_DLL bool TeIntersection(const TeBox& bx1, const TeBox& bx2, TeBox& bout);

TL_DLL TeCoordPairVect           TeGetIntersections(const TePolygon &poly, const double& y);
TL_DLL TeBox TeUnion(const TeBox& bx1, const TeBox& bx2);

TL_DLL bool TePointInPoly(const TeCoord2D& c, const TeLinearRing& r);

TL_DLL bool TeIsOnSegment(const TeCoord2D& c, const TeCoord2D& c1, const TeCoord2D& c2);

TL_DLL bool TeIsOnLine(const TeCoord2D& c, const TeLine2D& l);

TL_DLL bool TeLocateLineSegment(TeCoord2D& pin, TeLine2D& line, int& segment, double tol = 0.0);
TL_DLL void removeDuplicatedCoords(vector<TeCoord2D>& coordSet);

TL_DLL TePolygon TeConvexHull(std::vector<TeCoord2D>& coordSet);

TL_DLL TePolygon TeConvexHull(const TePolygon& p);

TL_DLL TePolygon TeConvexHull(const TePolygonSet& ps);

TL_DLL TePolygon TeConvexHull(const TePointSet& ps);

template<class T>
TePolygon TeConvexHull(const T& coordSet)
{
  // creates an auxiliary line with the points of the ring
  vector<TeCoord2D> aux;
  
  typename T::iterator it = coordSet.begin();
  
  while(it != coordSet.end())
  {
    aux.push_back(*it);
    ++it;
  }
  
  // removes duplicated coords from structs like ring
  removeDuplicatedCoords(aux);
  
  return TeConvexHull(aux);
};


TL_DLL double TeGetPrecision(TeProjection* proj);

class TL_DLL TeGeometryAlgorithmsPrecision
{
           protected:

                      TeGeometryAlgorithmsPrecision();

           public:               

                      static bool IsGreater(const double& d1, const double& d2)
                      {
                                 return ((d1 - d2) > TePrecision::instance().precision());
                      }

                      static bool IsGreaterEqual(const double& d1, const double& d2)
                      {
                                 return ((d1 - d2) >= (-TePrecision::instance().precision()));
                      }

                      static bool IsSmaller(const double& d1, const double& d2)
                      {
                                 return ((d1 - d2) < -(TePrecision::instance().precision()));
                      }

                      static bool IsSmallerEqual(const double& d1, const double& d2)
                      {
                                 return ((d1 - d2) <= TePrecision::instance().precision());
                      }

                      static bool IsEqual(const double& d1, const double& d2)
                      {
                                 return (fabs(d1 - d2) <= TePrecision::instance().precision());
                      }

                      static bool IsDifferent(const double& d1, const double& d2)
                      {
                                 return (fabs(d1 - d2) > TePrecision::instance().precision());
                      }
};

inline void TeRemoveDuplicatedCoordinates(TeLine2D& l)
{
           for(int i = 0; i < (int)l.size() - 1; ++i)
                      if(TeEquals(l[i], l[i + 1]))
                      {
                                 l.erase(l.begin() + i);
                                 --i;
                      }

           return;
}

inline void TeRemoveDuplicatedCoordinates(TePolygon& p)
{
           for(unsigned int i = 0; i < p.size(); ++i)
                      TeRemoveDuplicatedCoordinates(p[i]);                   

           return;
}

inline void TeReverseLine(TeLine2D& lin)
{
           for(unsigned int i=0,j=lin.size()-1 ; i<lin.size()/2 ; ++i,--j)
           {
                      TeCoord2D p = lin[i];
                      lin[i] = lin[j];
                      lin[j] = p;
           }

           return;
}


TL_DLL bool TeIsConvex(const TeLinearRing& ring);

TL_DLL short TeOrientation(const TeLinearRing& r);

TL_DLL void TeGetMiddlePoint(const TeCoord2D& first, const TeCoord2D& last, TeCoord2D& middle);

TL_DLL double TeDistance(const TeCoord2D& c1, const TeCoord2D& c2);

TL_DLL double TeLength(const TeLine2D& l);

TL_DLL double TePerpendicularDistance(const TeCoord2D& first, const TeCoord2D& last, const TeCoord2D& pin, TeCoord2D &pinter);

TL_DLL double TeMinimumDistance (const TeCoord2D& first, const TeCoord2D& last, const TeCoord2D& pin, TeCoord2D& pout, double tol = 0.0);

template<class T>
double TeGeometryArea(const T& /* geom */)
{
           return 0.0;
}

template<>
TL_DLL double TeGeometryArea(const TePolygon& p);

template<>
TL_DLL double TeGeometryArea(const TePolygonSet& ps);

template<>
TL_DLL double TeGeometryArea(const TeBox& b);

template<>
TL_DLL double TeGeometryArea(const TeMultiGeometry& mGeom);
TL_DLL TePolygon TeMakePolygon(const TeBox& b);

TL_DLL TeLinearRing TeSimpleClosedPath(const TePointSet& pSet);
TL_DLL TeCoord2D TeFindCentroid(TeMultiGeometry& mGeom);

TL_DLL TeCoord2D TeFindCentroid(const TePolygon& p);

TL_DLL TeCoord2D TeFindCentroid(const TeLine2D& l);  

TL_DLL TeCoord2D TeFindCentroid(const TeCell& c);

TL_DLL TeCoord2D TeFindCentroid(const TePoint& p);

TL_DLL TeCoord2D TeFindCentroid(const TeText& t);

TL_DLL TeCoord2D TeFindCentroid(const TePolygonSet& s); 

TL_DLL TeCoord2D TeFindCentroid(const TeLineSet& s); 

TL_DLL TeCoord2D TeFindCentroid(const TeCellSet& s);

TL_DLL TeCoord2D TeFindCentroid(TePointSet& ps);

TL_DLL TeCoord2D TeFindCentroid(TeTextSet& ts);

TL_DLL bool TeFindTriangleCenter(const TeCoord2D& vert0, const TeCoord2D& vert1, const TeCoord2D& vert2, TeCoord2D& pc); 
TL_DLL bool TeSegmentsIntersectPoint(const TeCoord2D& fr0, const TeCoord2D& to0, const TeCoord2D& fr1, const TeCoord2D& t1, TeCoord2D& pi); 


TL_DLL bool TeNearest(TeCoord2D& pt, TeNodeSet& ns , int& i, const double& tol = 0.0);

TL_DLL bool TeNearest(TeCoord2D& pt, TePointSet& ps , int& i, const double& tol = 0.0);

TL_DLL bool TeNearest(TeCoord2D& pt, TeTextSet& ts , int& i, const double& tol = 0.0);

TL_DLL bool TeNearest(TeCoord2D& pt, TeLineSet& ls , int& i, TeCoord2D& pi, const double& tol = 0.0);

TL_DLL bool TeNearest (TeCoord2D& pt,TeLineSet& ls, int& lindex, TeCoord2D& pout, double& dmin, const double& tol = 0.0); 

TL_DLL bool TeNearest(TeCoord2D& pt, TePolygonSet& ps , int& i, const double& tol = 0.0);

TL_DLL bool TeNearestByPoints(TeCoord2D& pt, TeLineSet& ls , int& i, double& dist, const double& tol = 0.0);
TL_DLL bool TeGetCenter(TePoint p1, TePoint p2, TePoint p3, TePoint &center);

TL_DLL double TeGetRadius(TePoint &p1, TePoint &p2, TePoint &p3);

TL_DLL bool TeGenerateArc(TePoint& p1, TePoint& p2, TePoint& p3, TeLine2D& arcOut, const short& NPoints);

TL_DLL bool TeGenerateCircle(const TePoint& center, const double& radius, TeLine2D& circle, const short& NPoints);

TL_DLL bool TeLineSimplify(TeLine2D& line, double snap, double maxdist);

TL_DLL bool TeAdjustSegment(TeCoord2D P0, TeCoord2D P1, double d0, TeCoord2D &P0out, TeCoord2D &P1out);

TL_DLL bool TeFindCentroid(const TeLine2D &line, TeCoord2D &p);
 // end of group  GeometryAlgorithms


#endif     // __TERRALIB_INTERNAL_GEOMETRYALGORITHMS_H