/**********************************************************************

 *

 * GEOS - Geometry Engine Open Source

 * http://geos.osgeo.org

 *

 * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>

 * 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/buffer/BufferCurveSetBuilder.java 4c343e79f (JTS-1.19)

 *

 **********************************************************************/

#pragma once

#include <geos/export.h>

#include <geos/geom/Location.h>

#include <geos/operation/buffer/OffsetCurveBuilder.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 CoordinateSequence;

class PrecisionModel;

class GeometryCollection;

class Point;

class LineString;

class LinearRing;

class Polygon;

}

namespace geomgraph {

class Label;

}

namespace noding {

class SegmentString;

}

namespace operation {

namespace buffer {

class BufferParameters;

}

}

}

namespace geos {

namespace operation { // geos.operation

namespace buffer { // geos.operation.buffer

/**

 * \class BufferCurveSetBuilder

 *

 * \brief

 * Creates all the raw offset curves for a buffer of a Geometry.

 *

 * Raw curves need to be noded together and polygonized to form the

 * final buffer area.

 *

 */

class GEOS_DLL BufferCurveSetBuilder {

    using CoordinateSequence = geos::geom::CoordinateSequence;

    using Envelope = geos::geom::Envelope;

private:

    static constexpr int MAX_INVERTED_RING_SIZE = 9;

    static constexpr int INVERTED_CURVE_VERTEX_FACTOR = 4;

    static constexpr double NEARNESS_FACTOR = 0.99;

    // To keep track of newly-created Labels.

    // Labels will be released by object dtor

    std::vector<geomgraph::Label*> newLabels;

    const geom::Geometry& inputGeom;

    double distance;

    OffsetCurveBuilder curveBuilder;

    /// The raw offset curves computed.

    /// This class holds ownership of std::vector elements.

    ///

    std::vector<noding::SegmentString*> curveList;

    bool isInvertOrientation = false;

    /**

     * Creates a noding::SegmentString for a coordinate list which is a raw

     * offset curve, and adds it to the list of buffer curves.

     * The noding::SegmentString is tagged with a geomgraph::Label

     * giving the topology of the curve.

     * The curve may be oriented in either direction.

     * If the curve is oriented CW, the locations will be:

     * - Left: Location.EXTERIOR

     * - Right: Location.INTERIOR

     *

     * @param coord is raw offset curve, ownership transferred here

     */

    void addCurve(std::unique_ptr<geom::CoordinateSequence> coord, geom::Location leftLoc,

                  geom::Location rightLoc);

    void add(const geom::Geometry& g);

    void addCollection(const geom::GeometryCollection* gc);

    /**

     * Add a Point to the graph.

     */

    void addPoint(const geom::Point* p);

    void addLineString(const geom::LineString* line);

    void addPolygon(const geom::Polygon* p);

    void addLinearRingSides(const geom::CoordinateSequence* coord, double p_distance);

    /**

     * Add an offset curve for a polygon ring.

     * The side and left and right topological location arguments

     * assume that the ring is oriented CW.

     * If the ring is in the opposite orientation,

     * the left and right locations must be interchanged and the side

     * flipped.

     *

     * @param coord the coordinates of the ring (must not contain

     * repeated points)

     * @param offsetDistance the distance at which to create the buffer

     * @param side the side of the ring on which to construct the buffer

     *             line

     * @param cwLeftLoc the location on the L side of the ring

     *                  (if it is CW)

     * @param cwRightLoc the location on the R side of the ring

     *                   (if it is CW)

     */

    void addPolygonRingSide(const geom::CoordinateSequence* coord,

                     double offsetDistance, int side, geom::Location cwLeftLoc,

                     geom::Location cwRightLoc);

    void addRingSide(const geom::CoordinateSequence* coord,

                     double offsetDistance, int side, geom::Location leftLoc,

                     geom::Location rightLoc);

    /**

     * Tests whether the offset curve for a ring is fully inverted.

     * An inverted ("inside-out") curve occurs in some specific situations

     * involving a buffer distance which should result in a fully-eroded (empty) buffer.

     * It can happen that the sides of a small, convex polygon

     * produce offset segments which all cross one another to form

     * a curve with inverted orientation.

     * This happens at buffer distances slightly greater than the distance at

     * which the buffer should disappear.

     * The inverted curve will produce an incorrect non-empty buffer (for a shell)

     * or an incorrect hole (for a hole).

     * It must be discarded from the set of offset curves used in the buffer.

     * Heuristics are used to reduce the number of cases which area checked,

     * for efficiency and correctness.

     * <p>

     * See https://github.com/locationtech/jts/issues/472

     *

     * @param inputPts the input ring

     * @param distance the buffer distance

     * @param curvePts the generated offset curve

     * @return true if the offset curve is inverted

     */

    static bool isRingCurveInverted(

        const geom::CoordinateSequence* inputPts, double dist,

        const geom::CoordinateSequence* curvePts);

    /**

     * Tests if there are points on the raw offset curve which may

     * lie on the final buffer curve

     * (i.e. they are (approximately) at the buffer distance from the input ring). 

     * For efficiency this only tests a limited set of points on the curve.

     * 

     * @param inputRing

     * @param distance

     * @param curveRing

     * @return true if the curve contains points lying at the required buffer distance

     */

    static bool hasPointOnBuffer(

        const CoordinateSequence* inputRing, double dist,

        const CoordinateSequence* curveRing);

    /**

     * The ringCoord is assumed to contain no repeated points.

     * It may be degenerate (i.e. contain only 1, 2, or 3 points).

     * In this case it has no area, and hence has a minimum diameter of 0.

     *

     * @param ringCoord

     * @param bufferDistance

     * @return

     */

    bool isRingFullyEroded(const geom::LinearRing* ring, bool isHole,

                            double bufferDistance);

    bool isRingFullyEroded(const CoordinateSequence* ringCoord, const Envelope* env, bool isHole,

                            double bufferDistance);

    /**

     * Tests whether a triangular ring would be eroded completely by

     * the given buffer distance.

     * This is a precise test.  It uses the fact that the inner buffer

     * of a triangle converges on the inCentre of the triangle (the

     * point equidistant from all sides).  If the buffer distance is

     * greater than the distance of the inCentre from a side, the

     * triangle will be eroded completely.

     *

     * This test is important, since it removes a problematic case where

     * the buffer distance is slightly larger than the inCentre distance.

     * In this case the triangle buffer curve "inverts" with incorrect

     * topology, producing an incorrect hole in the buffer.

     *

     * @param triCoord

     * @param bufferDistance

     * @return

     */

    bool isTriangleErodedCompletely(const geom::CoordinateSequence* triCoords,

                                    double bufferDistance);

    // Declare type as noncopyable

    BufferCurveSetBuilder(const BufferCurveSetBuilder& other) = delete;

    BufferCurveSetBuilder& operator=(const BufferCurveSetBuilder& rhs) = delete;

    /**

    * Computes orientation of a ring using a signed-area orientation test.

    * For invalid (self-crossing) rings this ensures the largest enclosed area

    * is taken to be the interior of the ring.

    * This produces a more sensible result when

    * used for repairing polygonal geometry via buffer-by-zero.

    * For buffer, using the lower robustness of orientation-by-area

    * doesn't matter, since narrow or flat rings

    * produce an acceptable offset curve for either orientation.

    *

    * @param coord the ring coordinates

    * @return true if the ring is CCW

    */

    bool isRingCCW(const geom::CoordinateSequence* coords) const;

public:

    /// Constructor

    BufferCurveSetBuilder(

        const geom::Geometry& newInputGeom,

        double newDistance,

        const geom::PrecisionModel* newPm,

        const BufferParameters& newBufParams)

        : inputGeom(newInputGeom)

        , distance(newDistance)

        , curveBuilder(newPm, newBufParams)

        , curveList()

        , isInvertOrientation(false)

        {};

    /// Destructor

    ~BufferCurveSetBuilder();

    /** \brief

     * Computes the set of raw offset curves for the buffer.

     *

     * Each offset curve has an attached {@link geomgraph::Label} indicating

     * its left and right location.

     *

     * @return a Collection of SegmentStrings representing the raw buffer curves

     */

    std::vector<noding::SegmentString*>& getCurves();

    /// \brief Add raw curves for a set of CoordinateSequences.

    ///

    /// @param lineList is a list of CoordinateSequence, ownership

    ///                 of which is transferred here

    /// @param leftLoc left location

    /// @param rightLoc right location

    ///

    void addCurves(std::vector<std::unique_ptr<geom::CoordinateSequence>>& lineList,

                   geom::Location leftLoc, geom::Location rightLoc);

    /**

    * Sets whether the offset curve is generated

    * using the inverted orientation of input rings.

    * This allows generating a buffer(0) polygon from the smaller lobes

    * of self-crossing rings.

    *

    * @param p_isInvertOrientation true if input ring orientation should be inverted

    */

    void setInvertOrientation(bool p_isInvertOrientation) {

        isInvertOrientation = p_isInvertOrientation;

    }

};

} // namespace geos::operation::buffer

} // namespace geos::operation

} // namespace geos

#ifdef _MSC_VER

#pragma warning(pop)

#endif