OverlayOp.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/OverlayOp.java r567 (JTS-1.12+)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.h>
 
#include <geos/algorithm/PointLocator.h> // for composition
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/geom/Location.h>
#include <geos/geomgraph/EdgeList.h> // for composition
#include <geos/geomgraph/PlanarGraph.h> // for inline (GeometryGraph->PlanarGraph)
#include <geos/operation/GeometryGraphOperation.h> // for inheritance
 
#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 Envelope;
class GeometryFactory;
class Polygon;
class LineString;
class Point;
}
namespace geomgraph {
class Label;
class Edge;
class Node;
}
namespace operation {
namespace overlay {
class ElevationMatrix;
}
}
}
 
namespace geos {
namespace operation { // geos::operation
namespace overlay { // geos::operation::overlay
 
class GEOS_DLL OverlayOp: public GeometryGraphOperation {
 
public:
 
    enum OpCode {
        opINTERSECTION = 1,
        opUNION = 2,
        opDIFFERENCE = 3,
        opSYMDIFFERENCE = 4
    };
 
    static geom::Geometry* overlayOp(const geom::Geometry* geom0,
                                     const geom::Geometry* geom1,
                                     OpCode opCode);
    //throw(TopologyException *);
 
    static bool isResultOfOp(const geomgraph::Label& label, OpCode opCode);
 
    static bool isResultOfOp(geom::Location loc0, geom::Location loc1, OpCode opCode);
 
    OverlayOp(const geom::Geometry* g0, const geom::Geometry* g1);
 
    ~OverlayOp() override; // FIXME: virtual ?
 
    geom::Geometry* getResultGeometry(OpCode overlayOpCode);
    // throw(TopologyException *);
 
    geomgraph::PlanarGraph&
    getGraph()
    {
        return graph;
    }
 
    bool isCoveredByLA(const geom::Coordinate& coord);
 
    bool isCoveredByA(const geom::Coordinate& coord);
 
    /*
     * @return true if the coord is located in the interior or boundary of
     * a geometry in the list.
     */
 
    static std::unique_ptr<geom::Geometry> createEmptyResult(
        OverlayOp::OpCode overlayOpCode, const geom::Geometry* a,
        const geom::Geometry* b, const geom::GeometryFactory* geomFact);
 
protected:
 
    void insertUniqueEdge(geomgraph::Edge* e);
 
private:
 
    algorithm::PointLocator ptLocator;
 
    const geom::GeometryFactory* geomFact;
 
    geom::Geometry* resultGeom;
 
    geomgraph::PlanarGraph graph;
 
    geomgraph::EdgeList edgeList;
 
    std::vector<geom::Polygon*>* resultPolyList;
 
    std::vector<geom::LineString*>* resultLineList;
 
    std::vector<geom::Point*>* resultPointList;
 
    void computeOverlay(OpCode opCode); // throw(TopologyException *);
 
    void insertUniqueEdges(std::vector<geomgraph::Edge*>* edges, const geom::Envelope* env = nullptr);
 
    /*
     * If either of the GeometryLocations for the existing label is
     * exactly opposite to the one in the labelToMerge,
     * this indicates a dimensional collapse has happened.
     * In this case, convert the label for that Geometry to a Line label
     */
    //Not needed
    //void checkDimensionalCollapse(geomgraph::Label labelToMerge, geomgraph::Label existingLabel);
 
    void computeLabelsFromDepths();
 
    void replaceCollapsedEdges();
 
    void copyPoints(uint8_t argIndex, const geom::Envelope* env = nullptr);
 
    void computeLabelling(); // throw(TopologyException *);
 
    void mergeSymLabels();
 
    void updateNodeLabelling();
 
    void labelIncompleteNodes();
 
    void labelIncompleteNode(geomgraph::Node* n, uint8_t targetIndex);
 
    void findResultAreaEdges(OpCode opCode);
 
    void cancelDuplicateResultEdges();
 
    bool isCovered(const geom::Coordinate& coord,
                   std::vector<geom::Geometry*>* geomList);
 
    bool isCovered(const geom::Coordinate& coord,
                   std::vector<geom::Polygon*>* geomList);
 
    bool isCovered(const geom::Coordinate& coord,
                   std::vector<geom::LineString*>* geomList);
    static geom::Dimension::DimensionType resultDimension(OverlayOp::OpCode overlayOpCode,
            const geom::Geometry* g0, const geom::Geometry* g1);
 
    geom::Geometry* computeGeometry(
        std::vector<geom::Point*>* nResultPointList,
        std::vector<geom::LineString*>* nResultLineList,
        std::vector<geom::Polygon*>* nResultPolyList,
        OverlayOp::OpCode opCode);
 
    std::vector<geomgraph::Edge*>dupEdges;
 
    int mergeZ(geomgraph::Node* n, const geom::Polygon* poly) const;
 
    int mergeZ(geomgraph::Node* n, const geom::LineString* line) const;
 
    double avgz[2];
    bool avgzcomputed[2];
 
    double getAverageZ(uint8_t targetIndex);
    static double getAverageZ(const geom::Polygon* poly);
 
    ElevationMatrix* elevationMatrix;
 
    void checkObviouslyWrongResult(OpCode opCode);
 
};
 
} // namespace geos::operation::overlay
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif