LandRTools.hpp

Go to the documentation of this file.

/*

  This file is part of OpenFLUID software
  Copyright(c) 2007, INRA - Montpellier SupAgro


 == GNU General Public License Usage ==

  OpenFLUID is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  OpenFLUID is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OpenFLUID. If not, see <http://www.gnu.org/licenses/>.


 == Other Usage ==

  Other Usage means a use of OpenFLUID that is inconsistent with the GPL
  license, and requires a written agreement between You and INRA.
  Licensees for Other Usage of OpenFLUID may use this file in accordance
  with the terms contained in the written agreement between You and INRA.

*/


/**
  @file LandRTools.hpp

  @author Aline LIBRES <aline.libres@gmail.com>
  @author Michael RABOTIN <michael.rabotin@supagro.inra.fr>
*/

#ifndef __OPENFLUID_LANDR_LANDRTOOLS_HPP__
#define __OPENFLUID_LANDR_LANDRTOOLS_HPP__


#include <vector>
#include <list>

#include <geos/geom/CoordinateArraySequenceFactory.h>

#include <openfluid/landr/LineStringGraph.hpp>
#include <openfluid/dllexport.hpp>


namespace geos { namespace geom {
class Geometry;
class LineString;
class Polygon;
} }

namespace openfluid { namespace landr {

class VectorDataset;

/**
  @brief Set of tools to manage LandR elements.
*/
class OPENFLUID_API LandRTools
{
  public:

    enum Relationship
    {
      NONE, INTERSECTS, CONTAINS, EQUALS, TOUCHES
    };

    /**
      @brief Returns a geos::geom::LineString representing the linearized input geos::geom::Geometry.
      @param Geom The geos::geom::Geometry to linearize.
      @return A new allocated geos::geom::LineString representing the linearized input geos::geom::Geometry,
      or 0 if the geos::geom::Geometry cannot be linearized into a single geos::geom::LineString.
    */
    static geos::geom::LineString* computeMergedLineStringFromGeometry(geos::geom::Geometry* Geom);

    /**
      @brief Returns a vector of geos::geom::LineString representing the linearized input geos::geom::Geometry.
      @param Geom The geos::geom::Geometry to linearize.
      @return A new allocated vector of geos::geom::LineString
      representing the maximal linearized input geos::geom::Geometry,
      or 0 if the geos::geom::Geometry is not \"Line\" typed.
    */
    static std::vector<geos::geom::LineString*>* computeMergedLineStringsFromGeometry(geos::geom::Geometry* Geom);

    /**
      @brief Returns all exterior rings of the polygon-typed VectorDataset.
      @param Val A VectorDataset of polygons.
      @return A vector of new allocated geos::geom::LineString representing exterior rings.
      @throw openfluid::base::FrameworkException if the VectorDataset is not polygon-typed.
    */
    static std::vector<geos::geom::LineString*> computeVectorOfExteriorRings(openfluid::landr::VectorDataset& Val);

    /**
      @brief Returns all geos::geom::LineString composing of the linestring-typed VectorDataset.
      @param Val A VectorDataset of linestrings.
      @return A vector of new allocated geos::geom::Geometry representing lines.
      @throw base::FrameworkException if the VectorDataset is not linestring-typed.
    */
    static std::vector<geos::geom::LineString*> computeVectorOfLines(openfluid::landr::VectorDataset& Val);

    /**
      @brief Gets all full noded geos::geom::LineString from intersection between geom1 and geom2, with snap tolerance.
      @param Geom1 The geos::geom::Geometry to node with Geom2.
      @param Geom2 The other geos::geom::Geometry.
      @param SnapTolerance The tolerance to use while computing intersections and equality of lines.
      @param PrecisionReducer The PrecisionModel value for reducing
      coordinates precision, default is 10000000 (7 digits).
      @return A vector of geos::geom::LineString, representing all input lines, cut at each node.
    */
    static std::vector<geos::geom::LineString*>* computeNodedLines(geos::geom::Geometry* Geom1,
                                                                   geos::geom::Geometry* Geom2,
                                                                   double SnapTolerance = 0,
                                                                   double PrecisionReducer=10000000);

    /**
      @brief Same as from geos::operation::overlay::snap::SnapOverlayOp::Union(),
      but with ability to use the wished snap tolerance value.
      @param Geom1 The geos::geom::Geometry to join with Geom2.
      @param Geom2 The other geos::geom::Geometry.
      @param SnapTolerance The tolerance to use, default is 0.
      @return A new geos::geom::Geometry representing the union of Geom1 and Geom2 according to SnapTolerance value.
    */
    static geos::geom::Geometry* computeSnapOverlayUnion(geos::geom::Geometry& Geom1,
                                                         geos::geom::Geometry& Geom2,
                                                         double SnapTolerance = 0);

    /**
      @brief Returns true if a geos::geom::LineString is exactly equals
      of an element of a list of geos::geom::LineString, up to a specified tolerance.
      @param Line The geos::geom::LineString to compare.
      @param RefLines The list of geos::geom::LineString to compare to.
      @param Tolerance The tolerance to use.
    */
    static bool exists(geos::geom::LineString* Line,
                       std::list<geos::geom::LineString*> RefLines,
                       double Tolerance = 0);

    /**
      @brief Creates all possible geos::geom::Polygon from a geos::geom::Geometry.
      @param Lines The input vector of geos::geom::Geometry to polygonize.
      @param Polygons The output vector of newly created geos::geom::Polygon.
      @param Dangles The output vector of dangle geos::geom::LineString.
    */
    static void polygonizeGeometry(std::vector<geos::geom::Geometry*>& Lines,
                                   std::vector<geos::geom::Polygon*>& Polygons,
                                   std::vector<const geos::geom::LineString*>& Dangles);

    /**
      @brief Recursive depth first search algorithm in a LineStringGraph and mark visited Nodes
      @param Node the begin geos::planargraph::Node of LineStringGraph
    */
    static void markVisitedNodesUsingDFS(geos::planargraph::Node* Node);

    /**
      @brief Intersection of two geos::geom::Geometry of Polygons.
      @param Geom1 The geos::geom::Geometry to join with Geom2.
      @param Geom2 The other geos::geom::Geometry.
      @return A vector of geos::geom::Polygon representing the intersection of Geom1 and Geom2.
    */
    static std::vector<geos::geom::Polygon*> computeIntersectPolygons(geos::geom::Geometry* Geom1,
                                                                      geos::geom::Geometry* Geom2);

    /**
      @brief Splits a geos::geom::LineString by a geos::geom::Point.
      @param Entity An existent geos::geom::LineString.
      @param Point A geos::geom::Point.
      @param SnapTolerance The threshold distance used to find Point on Line.
      @return a vector of geos::geom::LineString,
      or empty vector if splitting operation is null.
    */
    static std::vector<geos::geom::LineString*> splitLineStringByPoint(geos::geom::LineString& Entity,
                                                                       geos::geom::Point& Point,
                                                                       double SnapTolerance);

    /**
      @brief Recursively split operation on a geos::geom::LineString by a vector of geos::geom::Point.
      @param Entity An existent geos::geom::LineString.
      @param Points A vector of geos::geom::Point.
      @param SnapTolerance The threshold distance used to find Point on Line.
      @param vLines the resulting vector of geos::geom::LineString splitted.
      @param step iterator of the vector of Point; default is 0.
    */
    static void splitLineStringByPoints(geos::geom::LineString& Entity,
                                        std::vector<geos::geom::Point*>& Points,
                                        double SnapTolerance,
                                        std::vector<geos::geom::LineString*>& vLines,
                                        unsigned int step=0);

    /**
      @brief Clean a vector of geos::geom::LineString (break at each intersection and remove duplicate geometry)
      @param vLines An existent vector of geos::geom::LineString.
      @param SnapTolerance The tolerance to use.
      @return a vector of geos::geom::LineString.
    */
    static std::vector<geos::geom::LineString*>* cleanLineStrings(std::vector<geos::geom::LineString*> vLines,
                                                                  double SnapTolerance);

    /**
      @brief Returns the nodes of a vector of geos::geom::LineString.
      @param NodedLines A vector of geos::geom::LineString.
      @return A vector of geos::geom::Point.
    */
    static std::vector<geos::geom::Point*> computeNodesFromVectorOfLines(
                                               std::vector<geos::geom::LineString*>& NodedLines);

    /**
      @brief Returns the inverted openfluid::landr::LineStringEntity of a geos::planargraph using a recursive method.
      @param Node A geos::planargraph::node of a geos::planargraph.
      @param vectIdent A vector which will contain the identifier of each inverted openfluid::landr::LinestringEntity.
    */
    static void markInvertedLineStringEntityUsingDFS(geos::planargraph::Node* Node,std::vector<int>& vectIdent);

    /**
      @brief Returns true if the OGREnvelope intersect, false otherwise
    */
     static bool isExtentsIntersect(std::vector<OGREnvelope> vEnvelope);


};


} } // namespaces


#endif /* __OPENFLUID_LANDR_LANDRTOOLS_HPP__ */