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/landr/LineStringEntity.hpp>
#include <openfluid/dllexport.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);

};


} }  // namespaces


#endif /* __OPENFLUID_LANDR_LINESTRINGGRAPH_HPP__ */