LineSequencer.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@keybit.net>
 * Copyright (C) 2006 Refractions Research Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation. 
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: operation/linemerge/LineSequencer.java r378 (JTS-1.12)
 *
 **********************************************************************/
 
#ifndef GEOS_OP_LINEMERGE_LINESEQUENCER_H
#define GEOS_OP_LINEMERGE_LINESEQUENCER_H
 
#include <geos/export.h>
 
#include <geos/operation/linemerge/LineMergeGraph.h> // for composition
#include <geos/geom/Geometry.h> // for inlines
#include <geos/geom/LineString.h> // for inlines
 
#include <vector>
#include <list>
#include <memory> // for auto_ptr
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
#endif
 
// Forward declarations 
namespace geos {
        namespace geom { 
                class GeometryFactory;
                class Geometry;
                class LineString;
        }
        namespace planargraph { 
                class DirectedEdge;
                class Subgraph;
                class Node;
        }
}
 
 
namespace geos {
namespace operation { // geos::operation
namespace linemerge { // geos::operation::linemerge

class GEOS_DLL LineSequencer {
 
private:
        typedef std::list<planargraph::DirectedEdge*> DirEdgeList;
        typedef std::vector< DirEdgeList* > Sequences;
 
        LineMergeGraph graph;
        const geom::GeometryFactory *factory;
        unsigned int lineCount;
        bool isRun;
        std::auto_ptr<geom::Geometry> sequencedGeometry;
        bool isSequenceableVar;
 
        void addLine(const geom::LineString *lineString);
        void computeSequence();
        Sequences* findSequences();
        DirEdgeList* findSequence(planargraph::Subgraph& graph);
 
        void delAll( Sequences& );

        static geom::LineString* reverse(const geom::LineString *line);

        geom::Geometry* buildSequencedGeometry(const Sequences& sequences);
 
        static const planargraph::Node* findLowestDegreeNode(
                        const planargraph::Subgraph& graph);
 
        void addReverseSubpath(const planargraph::DirectedEdge *de,
                DirEdgeList& deList,
                DirEdgeList::iterator lit,
                bool expectedClosed);
        
        static const planargraph::DirectedEdge* findUnvisitedBestOrientedDE(
                        const planargraph::Node* node);

        DirEdgeList* orient(DirEdgeList* seq);

        DirEdgeList* reverse(DirEdgeList& seq);

        bool hasSequence(planargraph::Subgraph& graph);
 
public:
 
        static geom::Geometry* sequence(const geom::Geometry& geom)
        {
                LineSequencer sequencer;
                sequencer.add(geom);
                return sequencer.getSequencedLineStrings();
        }
 
        LineSequencer()
                :
                factory(0),
                lineCount(0),
                isRun(false),
                sequencedGeometry(0),
                isSequenceableVar(false)
                {}

        static bool isSequenced(const geom::Geometry* geom);

        bool isSequenceable() {
                computeSequence();
                return isSequenceableVar;
        }

        void add(const geom::Geometry& geometry) {
                geometry.applyComponentFilter(*this);
        }
 
  template <class TargetContainer>
  void add(TargetContainer& geoms)
  {
    for (typename TargetContainer::const_iterator i = geoms.begin(),
         e = geoms.end(); i != e; ++i)
    {
      const geom::Geometry* g = *i;
      add(*g);
    }
  }

        void filter(const geom::Geometry* g)
        {
                if (const geom::LineString *ls=dynamic_cast<const geom::LineString *>(g))
                {
                        addLine(ls);
                }
        }

        geom::Geometry*
        getSequencedLineStrings(bool release=1) {
                computeSequence();
                if (release) return sequencedGeometry.release();
                else return sequencedGeometry.get();
        }
};
 
} // namespace geos::operation::linemerge
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif // GEOS_OP_LINEMERGE_LINESEQUENCER_H