File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/CPP/geos.x/i/geos/triangulate/DelaunayTriangulationBuilder.h

Criterion	Covered	Total	%
statement	3	3	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	3	3	100.0

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2012 Excensus LLC.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: triangulate/DelaunayTriangulationBuilder.java r524
 *
 **********************************************************************/

#ifndef GEOS_TRIANGULATE_DELAUNAYTRIANGULATIONBUILDER_H
#define GEOS_TRIANGULATE_DELAUNAYTRIANGULATIONBUILDER_H

#include


namespace geos {
  namespace geom{
	  class CoordinateSequence;
	  class Geometry;
	  class MultiLineString;
	  class GeometryCollection;
	  class GeometryFactory;
	  class Envelope;
  }
  namespace triangulate {
    namespace quadedge {
      class QuadEdgeSubdivision;
    }
  }
}

namespace geos {
namespace triangulate { //geos.triangulate


/**
 * A utility class which creates Delaunay Triangulations
 * from collections of points and extract the resulting
 * triangulation edges or triangles as geometries.
 *
 * @author JTS: Martin Davis
 * @author Benjamin Campbell
 *
 */
class GEOS_DLL DelaunayTriangulationBuilder
{
public:
	/**
	 * Extracts the unique {@link Coordinate}s from the given {@link Geometry}.
	 * @param geom the geometry to extract from
	 * @return a List of the unique Coordinates. Caller takes ownership of the returned object.
	 */
	static geom::CoordinateSequence* extractUniqueCoordinates(const geom::Geometry& geom);

	static void unique(geom::CoordinateSequence& coords);

	/**
	 * Converts all {@link Coordinate}s in a collection to {@link Vertex}es.
	 * @param coords the coordinates to convert
	 * @return a List of Vertex objects. Call takes ownership of returned object.
	 */
	static IncrementalDelaunayTriangulator::VertexList* toVertices(const geom::CoordinateSequence &coords);

private:
	geom::CoordinateSequence* siteCoords;
	double tolerance;
	quadedge::QuadEdgeSubdivision *subdiv;

public:
	/**
	 * Creates a new triangulation builder.
	 *
	 */
	DelaunayTriangulationBuilder();

	~DelaunayTriangulationBuilder();

	/**
	 * Sets the sites (vertices) which will be triangulated.
	 * All vertices of the given geometry will be used as sites.
	 *
	 * @param geom the geometry from which the sites will be extracted.
	 */
	void setSites(const geom::Geometry& geom);

	/**
	 * Sets the sites (vertices) which will be triangulated
	 * from a collection of {@link Coordinate}s.
	 *
	 * @param geom a CoordinateSequence.
	 */
	void setSites(const geom::CoordinateSequence& coords);

	/**
	 * Sets the snapping tolerance which will be used
	 * to improved the robustness of the triangulation computation.
	 * A tolerance of 0.0 specifies that no snapping will take place.
	 *
	 * @param tolerance the tolerance distance to use
	 */
	inline void setTolerance(double tolerance)
	{
		this->tolerance = tolerance;
	}

private:
	void create();

public:
	/**
	 * Gets the {@link quadedge::QuadEdgeSubdivision} which models the computed triangulation.
	 *
	 * @return the subdivision containing the triangulation
	 */
	quadedge::QuadEdgeSubdivision& getSubdivision();

	/**
	 * Gets the edges of the computed triangulation as a {@link MultiLineString}.
	 *
	 * @param geomFact the geometry factory to use to create the output
	 * @return the edges of the triangulation. The caller takes ownership of the returned object.
	 */
	std::unique_ptr getEdges(const geom::GeometryFactory &geomFact);

	/**
	 * Gets the faces of the computed triangulation as a {@link GeometryCollection}
	 * of {@link Polygon}.
	 *
	 * @param geomFact the geometry factory to use to create the output
	 * @return the faces of the triangulation. The caller takes ownership of the returned object.
	 */
	std::unique_ptr getTriangles(const geom::GeometryFactory& geomFact);

	/**
	 * Computes the {@link Envelope} of a collection of {@link Coordinate}s.
	 *
	 * @param coords a List of Coordinates
	 * @return the envelope of the set of coordinates
	 */

	static geom::Envelope envelope(const geom::CoordinateSequence& coords);

};

} //namespace geos.triangulate
} //namespace goes

#endif //GEOS_TRIANGULATE_QUADEDGE_DELAUNAYTRIANGULATIONBUILDER_H