OverlayOp.h

Go to the documentation of this file.

/**********************************************************************
 *
 * 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+)
 *
 **********************************************************************/

#ifndef GEOS_OP_OVERLAY_OVERLAYOP_H
#define GEOS_OP_OVERLAY_OVERLAYOP_H

#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(int argIndex, const geom::Envelope* env = nullptr);

    void computeLabelling(); // throw(TopologyException *);

    void mergeSymLabels();

    void updateNodeLabelling();

    void labelIncompleteNodes();

    void labelIncompleteNode(geomgraph::Node* n, int 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(int 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

#endif // ndef GEOS_OP_OVERLAY_OVERLAYOP_H