DYT/Tool/OpenSceneGraph-3.6.5/include/geos/geomgraph/DirectedEdgeStar.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
 * Copyright (C) 2005-2006 Refractions Research Inc.
 * Copyright (C) 2001-2002 Vivid Solutions 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: geomgraph/DirectedEdgeStar.java r428 (JTS-1.12+)
 *
 **********************************************************************/


#pragma once

#include <memory>
#include <geos/export.h>
#include <set>
#include <string>
#include <vector>

#include <geos/geomgraph/EdgeEndStar.h>  // for inheritance
#include <geos/geomgraph/Label.h>  // for private member
#include <geos/geom/Coordinate.h>  // for p0,p1


// Forward declarations
namespace geos {
namespace geomgraph {
class DirectedEdge;
class EdgeRing;
}
}

namespace geos {
namespace geomgraph { // geos.geomgraph

/**
 * \brief
 * A DirectedEdgeStar is an ordered list of **outgoing** DirectedEdges around a node.
 *
 * It supports labelling the edges as well as linking the edges to form both
 * MaximalEdgeRings and MinimalEdgeRings.
 *
 */
class GEOS_DLL DirectedEdgeStar: public EdgeEndStar {

public:

    DirectedEdgeStar()
        :
        EdgeEndStar(),
        label(),
        resultAreaEdgesComputed(false)
    {}

    ~DirectedEdgeStar() override = default;

    /// Insert a directed edge in the list
    void insert(EdgeEnd* ee) override;

    Label&
    getLabel()
    {
        return label;
    }

    int getOutgoingDegree();

    int getOutgoingDegree(EdgeRing* er);

    DirectedEdge* getRightmostEdge();

    /** \brief
     * Compute the labelling for all dirEdges in this star, as well as the overall labelling
     */
    void computeLabelling(const std::vector<std::unique_ptr<GeometryGraph>>&geom) override; // throw(TopologyException *);

    /** \brief
     * For each dirEdge in the star, merge the label from the sym dirEdge into the label
     */
    void mergeSymLabels();

    /// \brief Update incomplete dirEdge labels from the labelling for the node
    void updateLabelling(const Label& nodeLabel);


    /** \brief
     * Traverse the star of DirectedEdges, linking the included edges together.
     *
     * To link two dirEdges, the `next` pointer for an incoming dirEdge
     * is set to the next outgoing edge.
     *
     * DirEdges are only linked if:
     *
     * - they belong to an area (i.e. they have sides)
     * - they are marked as being in the result
     *
     * Edges are linked in CCW order (the order they are stored). This means
     * that rings have their face on the Right (in other words, the topological
     * location of the face is given by the RHS label of the DirectedEdge)
     *
     * PRECONDITION: No pair of dirEdges are both marked as being in the result
     */
    void linkResultDirectedEdges(); // throw(TopologyException *);

    void linkMinimalDirectedEdges(EdgeRing* er);

    void linkAllDirectedEdges();

    /** \brief
     * Traverse the star of edges, maintaining the current location in the result
     * area at this node (if any).
     *
     * If any L edges are found in the interior of the result, mark them as covered.
     */
    void findCoveredLineEdges();

    /** \brief
     * Compute the DirectedEdge depths for a subsequence of the edge array.
     */
    void computeDepths(DirectedEdge* de);

    std::string print() const override;

private:

    /**
     * A list of all outgoing edges in the result, in CCW order
     */
    std::vector<DirectedEdge*> resultAreaEdgeList;

    Label label;

    bool resultAreaEdgesComputed;

    /// \brief
    /// Returned vector is owned by DirectedEdgeStar object, but
    /// lazily created
    const std::vector<DirectedEdge*>& getResultAreaEdges();


    /// States for linResultDirectedEdges
    enum {
        SCANNING_FOR_INCOMING = 1,
        LINKING_TO_OUTGOING
    };

    int computeDepths(EdgeEndStar::iterator startIt,
                      EdgeEndStar::iterator endIt, int startDepth);
};


} // namespace geos.geomgraph
} // namespace geos