overlay/PolygonBuilder.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * 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/overlay/PolygonBuilder.java rev. 1.20 (JTS-1.10)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.h>
#include <geos/algorithm/locate/IndexedPointInAreaLocator.h>
 
#include <vector>
 
#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 Geometry;
class Coordinate;
class GeometryFactory;
}
namespace geomgraph {
class EdgeRing;
class Node;
class PlanarGraph;
class DirectedEdge;
}
namespace operation {
namespace overlay {
class MaximalEdgeRing;
class MinimalEdgeRing;
}
}
}
 
namespace geos {
namespace operation { // geos::operation
namespace overlay { // geos::operation::overlay
 
class GEOS_DLL PolygonBuilder {
public:
 
    PolygonBuilder(const geom::GeometryFactory* newGeometryFactory);
 
    ~PolygonBuilder();
 
    void add(geomgraph::PlanarGraph* graph);
    // throw(const TopologyException &)
 
    void add(const std::vector<geomgraph::DirectedEdge*>* dirEdges,
             const std::vector<geomgraph::Node*>* nodes);
    // throw(const TopologyException &)
 
    std::vector<std::unique_ptr<geom::Geometry>> getPolygons();
 
private:
 
    const geom::GeometryFactory* geometryFactory;
 
    std::vector<geomgraph::EdgeRing*> shellList;
 
    void buildMaximalEdgeRings(
        const std::vector<geomgraph::DirectedEdge*>* dirEdges,
        std::vector<MaximalEdgeRing*>& maxEdgeRings);
    // throw(const TopologyException &)
 
    void buildMinimalEdgeRings(
        std::vector<MaximalEdgeRing*>& maxEdgeRings,
        std::vector<geomgraph::EdgeRing*>& newShellList,
        std::vector<geomgraph::EdgeRing*>& freeHoleList,
        std::vector<MaximalEdgeRing*>& edgeRings);
 
    geomgraph::EdgeRing* findShell(std::vector<MinimalEdgeRing*>* minEdgeRings);
 
    void placePolygonHoles(geomgraph::EdgeRing* shell,
                           std::vector<MinimalEdgeRing*>* minEdgeRings);
 
    void sortShellsAndHoles(std::vector<MaximalEdgeRing*>& edgeRings,
                            std::vector<geomgraph::EdgeRing*>& newShellList,
                            std::vector<geomgraph::EdgeRing*>& freeHoleList);
 
    struct FastPIPRing {
        geomgraph::EdgeRing* edgeRing;
        algorithm::locate::IndexedPointInAreaLocator* pipLocator;
    };
 
    void placeFreeHoles(std::vector<FastPIPRing>& newShellList,
                        std::vector<geomgraph::EdgeRing*>& freeHoleList);
    // throw(const TopologyException&)
 
    geomgraph::EdgeRing* findEdgeRingContaining(geomgraph::EdgeRing* testEr,
            std::vector<FastPIPRing>& newShellList);
 
    std::vector<std::unique_ptr<geom::Geometry>> computePolygons(
        std::vector<geomgraph::EdgeRing*>& newShellList);
 
};
 
} // namespace geos::operation::overlay
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif