LineStringGraph.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 LineStringGraph.hpp

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

#ifndef __OPENFLUID_LANDR_LINESTRINGGRAPH_HPP__
#define __OPENFLUID_LANDR_LINESTRINGGRAPH_HPP__

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

// for covariant return type of getEntity
#include <openfluid/landr/LineStringEntity.hpp>

/**
  Macro for declaration of a loop processing all entities of a graph
  @param[in] loopid ID of the loop
*/
#define DECLARE_ENTITIES_GRAPH_LOOP(loopid) \
        std::list<openfluid::landr::LandREntity*>::iterator _M_##loopid##_it;\
        std::list<openfluid::landr::LandREntity*> _M_##loopid##_uvect; \


/**
  Macro for declaration of a loop processing all entities of a graph, following their OFLD_ID
  @param[in] loopid ID of the loop
*/
#define DECLARE_ENTITIES_ORDERED_LOOP(loopid) \
        std::list<openfluid::landr::LandREntity*>::iterator _M_##loopid##_it;\
        std::list<openfluid::landr::LandREntity*> _M_##loopid##_uvect; \

/**
  Macro for the beginning of a loop processing all entities of a graph
  @param[in] loopid ID of the loop, must match declaration
  @param[in] graph pointer to a openfluid::landr::LineStringGraph
  @param[out] entity pointer to a openfluid::landr::LineStringEntity object, pointing to the current processed entity
*/
#define BEGIN_ENTITIES_GRAPH_LOOP(loopid,graph,entity) \
        if (graph) \
        { \
            _M_##loopid##_uvect = graph->getEntities();\
            for (_M_##loopid##_it=_M_##loopid##_uvect.begin();\
                 _M_##loopid##_it != _M_##loopid##_uvect.end(); ++_M_##loopid##_it) \
            { \
                entity = dynamic_cast<openfluid::landr::LineStringEntity*>(*_M_##loopid##_it); \

/**
  Macro for the beginning of a loop processing all entities of a graph, following their OFLD_ID
  @param[in] loopid ID of the loop, must match declaration
  @param[in] graph pointer to a openfluid::landr::LineStringGraph
  @param[out] entity pointer to a openfluid::landr::LineStringEntity object, pointing to the current processed entity
*/
#define BEGIN_ENTITIES_ORDERED_LOOP(loopid,graph,entity) \
        if (graph) \
        { \
            _M_##loopid##_uvect = graph->getOfldIdOrderedEntities();\
            for (_M_##loopid##_it=_M_##loopid##_uvect.begin();\
                 _M_##loopid##_it != _M_##loopid##_uvect.end(); ++_M_##loopid##_it) \
            { \
                entity = dynamic_cast<openfluid::landr::LineStringEntity*>(*_M_##loopid##_it); \

/**
  Macro for the ending of a loop
*/
#define END_LOOP \
        } \
        }

namespace openfluid { namespace landr {

class VectorDataset;

/**
  @brief A LandRGraph composed of LineStringEntities.
*/
class OPENFLUID_API LineStringGraph: public LandRGraph
{
private:

    LineStringGraph(LineStringGraph& Other);

protected:

    LineStringGraph();

    /**
     @brief Creates a new LineStringGraph initialized from a core::GeoVectorValue.
    */
    LineStringGraph(openfluid::core::GeoVectorValue& Val);

    /**
      @brief Creates a new LineStringGraph initialized from a VectorDataset.
    */
    LineStringGraph(openfluid::landr::VectorDataset& Vect);

    /**
      @brief Adds a LandREntity into this LineStringGraph.
    */
    virtual void addEntity(LandREntity* Entity);

    /**
      @brief Creates a new LineStringEntity.
      @param Geom The geos::geom::Geometry of the new LineStringEntity to create.
      @param OfldId The identifier of the new LineStringEntity.
      @return A new LandREntity.
    */
    virtual LandREntity* createNewEntity(const geos::geom::Geometry* Geom,
            unsigned int OfldId);




public:

    /**
      @brief Creates a new LineStringGraph initialized from a core::GeoVectorValue.
      @param Val A core::GeoVectorValue which must be composed of one or many LineStrings,
      and each of them must contain a "OFLD_ID" attribute.
    */
    static LineStringGraph* create(openfluid::core::GeoVectorValue& Val);

    /**
      @brief Creates a new LineStringGraph initialized from a VectorDataset.
      @param Vect A VectorDataset which must be composed of one or many LineStrings,
      and each of them must contain a "OFLD_ID" attribute.
    */
    static LineStringGraph* create(openfluid::landr::VectorDataset& Vect);

    /**
      @brief Creates a new LineStringGraph initialized with a list of LandREntity.
      @param Entities A list of LandREntity which must be LineStringEntity.
    */
    static LineStringGraph* create(const LandRGraph::Entities_t& Entities);

    virtual ~LineStringGraph();

    /**
      @brief Returns the type of graph.
    */
    LandRGraph::GraphType getType();

    /**
    @brief Returns a LineStringEntity with OFLD_ID, or 0 if it doesn't exist.
    */
    LineStringEntity* entity(int OfldId);

    /**
      @brief Removes from this LineStringGraph the LineStringEntity with OFLD_ID and its associated nodes.
      @param OfldId The identifier.
    */
    virtual void removeEntity(int OfldId);

    /**
      @brief Returns the last LineStringEntity of this LineStringGraph, according to the LineStringEntity orientations,
      ie the one that has no down neighbour.
      @return The last LineStringEntity or 0 if there is zero or more than one LineStringEntity whith no down neighbour.
    */
    LineStringEntity* lastLineStringEntity();

    /**
      @brief Returns a vector of LineStringEntity that have no down neighbour,
      according to the LineStringEntity orientations.
    */
    std::vector<LineStringEntity*> getEndLineStringEntities();

    /**
      @brief Returns a vector of LineStringEntity that have no up neighbour,
      according to the LineStringEntity orientations.
    */
    std::vector<LineStringEntity*> getStartLineStringEntities();

    /**
      @brief Fetch the associated raster value corresponding to the LineStringEntity StartNode coordinate.
      @param Entity The LineStringEntity to get the StartNode coordinate from.
      @return The raster value corresponding to the LineStringEntity StartNode coordinate.
    */
    double getRasterValueForEntityStartNode(LineStringEntity& Entity);

    /**
      @brief Fetch the associated raster value corresponding to the LineStringEntity EndNode coordinate.
      @param Entity The LineStringEntity to get the EndNode coordinate from.
      @return The raster value corresponding to the LineStringEntity EndNode coordinate.
    */
    double getRasterValueForEntityEndNode(LineStringEntity& Entity);

    /**
      @brief Creates a new attribute for these LineStringGraph entities, and set for each LineStringEntity
      this attribute value as the associated raster values corresponding to the StartNode LineStringEntity coordinates.
      @param AttributeName The name of the attribute to create for the StartNode
    */
    void setAttributeFromRasterValueAtStartNode(const std::string& AttributeName);

    /**
      @brief Creates a new attribute for these LineStringGraph entities, and set for each LineStringEntity
      this attribute value as the associated raster values corresponding to the EndNode LineStringEntity coordinates.
      @param AttributeName The name of the attribute to create for the EndNode
    */
    void setAttributeFromRasterValueAtEndNode(const std::string& AttributeName);

    /**
      @brief Reverse a LineStringEntity orientation.
      @param Entity The LineStringEntity to reverse.
    */
    void reverseLineStringEntity(LineStringEntity& Entity);

    /**
      @brief Returns true if this LineStringGraph is an arborescence, false otherwise.
      @details An arborescence is a graph with no loop; edges can be well directed or not.
    */
    bool isLineStringGraphArborescence();

    /**
      @brief Creates a new attribute for this LineStringGraph entities, and set for each LineStringEntity
      this attribute value as the mean of the StartNode altitude and the EndNode altitude.
      @param AttributeName The name of the attribute to create.
    */
    virtual void setAttributeFromMeanRasterValues(const std::string& AttributeName);

    /**
      @brief Merges a LineStringEntity into an other one.
      @details The LineStringEntity to merge is deleted.
      @param Entity An existent LineStringEntity.
      @param EntityToMerge The LineStringEntity which will be merged into Entity and will be deleted.
    */
    void mergeLineStringEntities(LineStringEntity& Entity,
                                 LineStringEntity& EntityToMerge);

    /**
    @brief Gets a map of small LineStringEntity under length threshold
      @param MinLength The length threshold (in map units).
      @param rmDangle : if true, get also dangles under the threshold.
      @param HighDegree : if true, do not get the if StartNode and EndNode of this LineStringEntitiy are Degree>=3.
      @return a multimap of LineStringEntity with key is the length of each LineStringEntity.
    */
    std::multimap<double,LineStringEntity*> getLineStringEntitiesByMinLength(double MinLength,
                                                                             bool rmDangle=true,
                                                                             bool HighDegree=true);

    /**
      @brief Set the orientation of the LineStringGraph with outlet identification by OFLD_ID identifier.
      Only for LineStringGraph of arborescence type
      @param OfldId The identifier of the outlet.
    */
    void setOrientationByOfldId(int OfldId);

    /**
      @brief Merges the entities of this LineStringGraph under length threshold.
      @param MinLength The length threshold (in map units).
      @param rmDangle if true, remove also dangles under the threshold, default is true.
    */
    void mergeLineStringEntitiesByMinLength(double MinLength,bool rmDangle=true);

};

} } // namespace landr, openfluid

#endif /* __OPENFLUID_LANDR_LINESTRINGGRAPH_HPP__ */