| ▼Ngeos | Basic namespace for all GEOS functionalities |
| ►Nalgorithm | Contains classes and interfaces implementing fundamental computational geometry algorithms |
| ►Nconstruct | |
| CIndexedDistanceToPoint | Computes the distance between a point and a geometry (which may be a collection containing any type of geometry) |
| CIndexedPointInPolygonsLocator | Determines the location of a point in the polygonal elements of a geometry |
| CLargestEmptyCircle | |
| CMaximumInscribedCircle | |
| ►Ndistance | Classes to compute distance metrics between geometries |
| CDiscreteFrechetDistance | An algorithm for computing a distance metric which is an approximation to the Frechet Distance based on a discretization of the input geom::Geometry |
| CDiscreteHausdorffDistance | An algorithm for computing a distance metric which is an approximation to the Hausdorff Distance based on a discretization of the input geom::Geometry |
| CDistanceToPoint | |
| CPointPairDistance | |
| ►Nhull | |
| CConcaveHull | |
| CConcaveHullOfPolygons | |
| ►Nlocate | Classes which determine the Location of points in geometries |
| CIndexedPointInAreaLocator | Determines the location of Coordinates relative to an areal geometry, using indexing for efficiency |
| CPointOnGeometryLocator | An interface for classes which determine the Location of points in Polygon or MultiPolygon geometries |
| CSimplePointInAreaLocator | Computes the location of points relative to a polygonal Geometry, using a simple O(n) algorithm |
| CAngle | Utility functions for working with angles |
| CBoundaryNodeRule | An interface for rules which determine whether node points which are in boundaries of lineal geometry components are in the boundary of the parent geometry collection |
| CCentralEndpointIntersector | Computes an approximate intersection of two line segments by taking the most central of the endpoints of the segments |
| CCentroid | Computes the centroid of a Geometry of any dimension |
| CCGAlgorithmsDD | Implements basic computational geometry algorithms using extended precision float-point arithmetic |
| CConvexHull | Computes the convex hull of a Geometry |
| CDistance | Functions to compute distance between basic geometric structures |
| CHCoordinate | Represents a homogeneous coordinate in a 2-D coordinate space |
| CInteriorPointArea | Computes a point in the interior of an areal geometry. The point will lie in the geometry interior in all except certain pathological cases |
| CInteriorPointLine | Computes a point in the interior of an linear geometry |
| CInteriorPointPoint | Computes a point in the interior of an point geometry |
| CIntersection | Functions to compute intersection points between lines and line segments |
| CLength | Functions for computing length |
| CLineIntersector | A LineIntersector is an algorithm that can both test whether two line segments intersect and compute the intersection point if they do |
| CMinimumAreaRectangle | |
| CMinimumDiameter | Computes the minimum diameter of a geom::Geometry |
| CNotRepresentableException | Indicates that a HCoordinate has been computed which is not representable on the Cartesian plane |
| COrientation | Functions to compute the orientation of basic geometric structures including point triplets (triangles) and rings |
| CPointLocation | Functions for locating points within basic geometric structures such as lines and rings |
| CPointLocator | Computes the topological relationship (Location) of a single point to a Geometry |
| CPolygonNodeTopology | |
| CRayCrossingCounter | Counts the number of segments crossed by a horizontal ray extending to the right from a given point, in an incremental fashion |
| CRobustDeterminant | Implements an algorithm to compute the sign of a 2x2 determinant for double precision values robustly |
| ►Ncoverage | |
| CCoverageEdge | |
| CCoverageGapFinder | |
| CCoveragePolygonValidator | |
| CCoverageRingEdges | |
| CCoverageSimplifier | |
| CCoverageUnion | |
| CCoverageValidator | |
| CInvalidSegmentDetector | |
| CTPVWSimplifier | |
| Ndetail | |
| ►Nedgegraph | |
| CEdgeGraph | |
| CEdgeGraphBuilder | |
| CHalfEdge | |
| ►Ngeom | |
| ►Nprep | Contains classes and interfaces implementing algorithms that optimize the performance of repeated calls to specific geometric operations |
| CAbstractPreparedPolygonContains | A base class containing the logic for computes the contains and covers spatial relationship predicates for a PreparedPolygon relative to all other Geometry classes |
| CBasicPreparedGeometry | A base class for PreparedGeometry subclasses |
| CPreparedGeometry | An interface for classes which prepare Geometrys in order to optimize the performance of repeated calls to specific geometric operations |
| CPreparedGeometryFactory | A factory for creating PreparedGeometrys |
| CPreparedLineString | A prepared version of LinearRing, LineString or MultiLineString geometries |
| CPreparedLineStringIntersects | Computes the intersects spatial relationship predicate for a target PreparedLineString relative to all other Geometry classes |
| CPreparedPoint | A prepared version of Point or MultiPoint geometries |
| CPreparedPolygon | A prepared version of Polygon or MultiPolygon geometries |
| CPreparedPolygonContains | Computes the contains spatial relationship predicate for a PreparedPolygon relative to all other Geometry classes |
| CPreparedPolygonContainsProperly | Computes the containsProperly spatial relationship predicate for PreparedPolygons relative to all other Geometry classes |
| CPreparedPolygonCovers | Computes the covers spatial relationship predicate for a PreparedPolygon relative to all other Geometry classes |
| CPreparedPolygonIntersects | Computes the intersects spatial relationship predicate for PreparedPolygons relative to all other Geometry classes |
| CPreparedPolygonPredicate | A base class for predicate operations on PreparedPolygons |
| ►Nutil | Provides classes that parse and modify Geometry objects |
| CComponentCoordinateExtracter | Extracts a single representative Coordinate from each connected component of a Geometry |
| CCoordinateOperation | |
| CDensifier | |
| CGeometryCombiner | Combines Geometrys to produce a GeometryCollection of the most appropriate type |
| CGeometryEditor | |
| CGeometryEditorOperation | |
| CGeometryExtracter | |
| CGeometryFixer | |
| CGeometryMapper | |
| CGeometryTransformer | A framework for processes which transform an input Geometry into an output Geometry, possibly changing its structure and type(s) |
| CLinearComponentExtracter | |
| CPointExtracter | |
| CPolygonalExtracter | Extracts the polygonal (Polygon and MultiPolygon) elements from a Geometry |
| CPolygonExtracter | |
| CShortCircuitedGeometryVisitor | A visitor to Geometry elements which can be short-circuited by a given condition |
| CSineStarFactory | |
| CCoordinate | Coordinate is the lightweight class used to store coordinates |
| CCoordinateLessThan | Strict weak ordering Functor for Coordinate |
| CCoordinateFilter | Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geometry |
| CCoordinateList | A list of Coordinates, which may be set to prevent repeated coordinates from occuring in the list |
| CCoordinateSequence | The internal representation of a list of coordinates inside a Geometry |
| CCoordinateSequenceFilter | Interface for classes which provide operations that can be applied to the coordinates in a CoordinateSequence |
| CCoordinateSequences | Utility methods to operate on CoordinateSequences. Methods that do not benefit from access to the CoordinateSequence internals can be placed here |
| CDimension | |
| CEnvelope | An Envelope defines a rectangulare region of the 2D coordinate plane |
| CGeometry | Basic implementation of Geometry, constructed and destructed by GeometryFactory |
| CGeometryCollection | Represents a collection of heterogeneous Geometry objects |
| CGeometryComponentFilter | |
| CGeometryFactory | Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geometry objects |
| CGeometryFilter | Geometry classes support the concept of applying a Geometry filter to the Geometry |
| CIntersectionMatrix | Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix |
| CLinearRing | Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple |
| CLineSegment | |
| CLineString | |
| CMultiLineString | Models a collection of LineStrings |
| CMultiPoint | |
| CMultiPolygon | |
| CPoint | |
| CPolygon | Represents a linear polygon, which may include holes |
| CPosition | A Position indicates the position of a Location relative to a graph component (Node, Edge, or Area) |
| CPrecisionModel | Specifies the precision model of the Coordinate in a Geometry |
| CQuadrant | Utility functions for working with quadrants |
| CTriangle | Represents a planar triangle, and provides methods for calculating various properties of triangles |
| ►Ngeomgraph | Contains classes that implement topology graphs |
| ►Nindex | Contains classes that implement indexes for performing noding on geometry graph edges |
| CEdgeSetIntersector | An EdgeSetIntersector computes all the intersections between the edges in the set |
| CMonotoneChain | |
| CMonotoneChainEdge | MonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections |
| CMonotoneChainIndexer | MonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections |
| CSegmentIntersector | Computes the intersection of line segments, and adds the intersection to the edges containing the segments |
| CSimpleEdgeSetIntersector | Finds all intersections in one or two sets of edges, using the straightforward method of comparing all segments |
| CSimpleMCSweepLineIntersector | Finds all intersections in one or two sets of edges, using an x-axis sweepline algorithm in conjunction with Monotone Chains |
| CSimpleSweepLineIntersector | Finds all intersections in one or two sets of edges, using a simple x-axis sweepline algorithm |
| CDepth | A Depth object records the topological depth of the sides of an Edge for up to two Geometries |
| CDirectedEdge | A directed EdgeEnd |
| CDirectedEdgeStar | A DirectedEdgeStar is an ordered list of outgoing DirectedEdges around a node |
| CEdge | |
| CEdgeEnd | Models the end of an edge incident on a node |
| CEdgeEndStar | A EdgeEndStar is an ordered list of EdgeEnds around a node |
| CEdgeIntersection | Represents a point on an edge which intersects with another edge |
| CEdgeIntersectionList | A list of edge intersections along an Edge |
| CEdgeList | A EdgeList is a list of Edges |
| CEdgeNodingValidator | Validates that a collection of SegmentStrings is correctly noded |
| CEdgeRing | |
| CGeometryGraph | A GeometryGraph is a graph that models a given Geometry |
| CGraphComponent | A GraphComponent is the parent class for the objects' that form a graph |
| CLabel | A Label indicates the topological relationship of a component of a topology graph to a given Geometry |
| CNode | The node component of a geometry graph |
| CPlanarGraph | Represents a directed graph which is embeddable in a planar surface |
| CTopologyLocation | A TopologyLocation is the labelling of a GraphComponent's topological relationship to a single Geometry |
| ►Nindex | Provides classes for various kinds of spatial indexes |
| ►Nbintree | Contains classes that implement a Binary Interval Tree index |
| CBintree | A BinTree (or "Binary Interval Tree") is a 1-dimensional version of a quadtree |
| CInterval | Represents an (1-dimensional) closed interval on the Real number line |
| CKey | A Key is a unique identifier for a node in a tree |
| CNode | A node of a Bintree |
| CNodeBase | The base class for nodes in a Bintree |
| CRoot | The root node of a single Bintree |
| ►Nchain | Contains classes that implement Monotone Chains |
| CMonotoneChain | Monotone Chains are a way of partitioning the segments of a linestring to allow for fast searching of intersections |
| CMonotoneChainBuilder | Constructs MonotoneChains for sequences of Coordinates |
| CMonotoneChainOverlapAction | The action for the internal iterator for performing overlap queries on a MonotoneChain |
| CMonotoneChainSelectAction | |
| ►Nintervalrtree | Contains classes that implement a static index on a set of 1-dimensional intervals, using an R-Tree packed based on the order of the interval midpoints |
| CSortedPackedIntervalRTree | A static index on a set of 1-dimensional intervals, using an R-Tree packed based on the order of the interval midpoints |
| ►Nkdtree | |
| CKdNode | |
| CKdTree | |
| ►Nquadtree | Contains classes that implement a Quadtree spatial index |
| CIntervalSize | Provides a test for whether an interval is so small it should be considered as zero for the purposes of inserting it into a binary tree |
| CKey | A Key is a unique identifier for a node in a quadtree |
| CNode | Represents a node of a Quadtree |
| CNodeBase | The base class for nodes in a Quadtree |
| CQuadtree | A Quadtree is a spatial index structure for efficient querying of 2D rectangles. If other kinds of spatial objects need to be indexed they can be represented by their envelopes |
| CRoot | QuadRoot is the root of a single Quadtree. It is centred at the origin, and does not have a defined extent |
| ►Nstrtree | Contains 2-D and 1-D versions of the Sort-Tile-Recursive (STR) tree, a query-only R-tree |
| CAbstractNode | A node of the STR tree |
| ►CAbstractSTRtree | Base class for STRtree and SIRtree |
| CIntersectsOp | A test for intersection between two bounds, necessary because subclasses of AbstractSTRtree have different implementations of bounds |
| CBoundable | A spatial object in an AbstractSTRtree |
| CBoundablePair | A pair of Boundables, whose leaf items support a distance metric between them |
| CInterval | A contiguous portion of 1D-space. Used internally by SIRtree |
| CItemBoundable | Boundable wrapper for a non-Boundable spatial object. Used internally by AbstractSTRtree |
| CItemDistance | A function method which computes the distance between two ItemBoundables in an STRtree. Used for Nearest Neighbour searches |
| CSimpleSTRnode | A node of the STR tree |
| CSimpleSTRtree | A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For two-dimensional spatial data |
| CSIRtree | One-dimensional version of an STR-packed R-tree |
| CSTRtree | A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For two-dimensional spatial data |
| CTemplateSTRtreeImpl | A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For one- or two-dimensional spatial data |
| ►Nsweepline | Contains classes which implement a sweepline algorithm for scanning geometric data structures |
| CSweepLineIndex | A sweepline implements a sorted index on a set of intervals |
| CItemVisitor | A visitor for items in an index |
| CSpatialIndex | Abstract class defines basic insertion and query operations supported by classes implementing spatial index algorithms |
| CVertexSequencePackedRtree | |
| ►Nio | Contains the interfaces for converting JTS objects to and from other formats |
| NWKBConstants | Constant values used by the WKB format |
| CByteOrderDataInStream | Allows reading an stream of primitive datatypes from an underlying istream, with the representation being in either common byte ordering |
| CByteOrderValues | Methods to read and write primitive datatypes from/to byte sequences, allowing the byte order to be specified |
| CGeoJSONReader | GeoJSON reader class; see also GeoJSONWriter |
| CGeoJSONWriter | Outputs the GeoJSON representation of a Geometry. See also GeoJSONReader for parsing |
| COrdinateSet | Utility class to manipulate a set of flags indicating whether X, Y, Z, or M dimensions are present. Based on JTS EnumSet<Ordinate> |
| CParseException | Notifies a parsing error |
| CWKBReader | Reads a Geometry from Well-Known Binary format |
| CWKBWriter | Writes a Geometry into Well-Known Binary format |
| CWKTReader | WKT parser class; see also WKTWriter |
| CWKTWriter | Outputs the textual representation of a Geometry. See also WKTReader |
| ►Nlinearref | Contains classes and interfaces implementing linear referencing on linear geometries |
| CExtractLineByLocation | Extracts the subline of a linear Geometry between two LinearLocations on the line |
| CLengthIndexedLine | Supports linear referencing along a linear geom::Geometry using the length along the line as the index |
| CLengthIndexOfPoint | Computes the length index of the point on a linear Geometry nearest a given Coordinate |
| CLengthLocationMap | Computes the LinearLocation for a given length along a linear Geometry |
| CLinearGeometryBuilder | Builds a linear geometry (LineString or MultiLineString) incrementally (point-by-point) |
| CLinearIterator | An iterator over the components and coordinates of a linear geometry (LineString or MultiLineString) |
| CLinearLocation | Represents a location along a LineString or MultiLineString |
| CLocationIndexedLine | Supports linear referencing along a linear Geometry using LinearLocations as the index |
| CLocationIndexOfLine | Determines the location of a subline along a linear Geometry |
| CLocationIndexOfPoint | Computes the LinearLocation of the point on a linear Geometry nearest a given Coordinate |
| ►Nmath | |
| CDD | Wrapper for DoubleDouble higher precision mathematics operations |
| ►Nnoding | Classes to compute nodings for arrangements of line segments and line segment sequences |
| ►Nsnap | |
| CSnappingNoder | |
| ►Nsnapround | Contains classes to implement the Snap Rounding algorithm for noding linestrings |
| CHotPixel | Implements a "hot pixel" as used in the Snap Rounding algorithm |
| CMCIndexPointSnapper | "Snaps" all SegmentStrings in a SpatialIndex containing MonotoneChains to a given HotPixel |
| CMCIndexSnapRounder | Uses Snap Rounding to compute a rounded, fully noded arrangement from a set of SegmentString |
| CSnapRoundingIntersectionAdder | |
| CSnapRoundingNoder | |
| CBasicSegmentString | Represents a list of contiguous line segments, and supports noding the segments |
| CBoundaryChainNoder | |
| CFastNodingValidator | Validates that a collection of SegmentStrings is correctly noded |
| CFastSegmentSetIntersectionFinder | Finds if two sets of SegmentStrings intersect |
| CIntersectionAdder | Computes the intersections between two line segments in SegmentString and adds them to each string |
| CIntersectionFinderAdder | Finds proper and interior intersections in a set of SegmentStrings, and adds them as nodes |
| CIteratedNoder | Nodes a set of SegmentStrings completely |
| CMCIndexNoder | Nodes a set of SegmentString using a index based on MonotoneChain and a SpatialIndex |
| CMCIndexSegmentSetMutualIntersector | Intersects two sets of SegmentStrings using a index based on MonotoneChains and a SpatialIndex |
| CNodableSegmentString | An interface for classes which support adding nodes to a segment string |
| CNodedSegmentString | Represents a list of contiguous line segments, and supports noding the segments |
| CNoder | Computes all intersections between segments in a set of SegmentString |
| CNodingIntersectionFinder | Finds non-noded intersections in a set of SegmentStrings, if any exist |
| CNodingValidator | Validates that a collection of SegmentStrings is correctly noded. Throws a TopologyException if a noding error is found |
| COctant | Methods for computing and working with octants of the Cartesian plane |
| COrientedCoordinateArray | Allows comparing geom::CoordinateSequences in an orientation-independent way |
| CScaledNoder | Wraps a Noder and transforms its input into the integer domain |
| CSegmentExtractingNoder | |
| CSegmentIntersectionDetector | Detects and records an intersection between two SegmentStrings, if one exists |
| CSegmentIntersector | Processes possible intersections detected by a Noder |
| CSegmentNode | Represents an intersection point between two NodedSegmentString |
| CSegmentNodeList | A list of the SegmentNode present along a NodedSegmentString |
| CSegmentPointComparator | Implements a robust method of comparing the relative position of two points along the same segment |
| CSegmentSetMutualIntersector | An intersector for the red-blue intersection problem |
| CSegmentString | An interface for classes which represent a sequence of contiguous line segments |
| CSegmentStringUtil | Utility methods for processing SegmentStrings |
| CSimpleNoder | Nodes a set of SegmentStrings by performing a brute-force comparison of every segment to every other one |
| CSinglePassNoder | Base class for Noders which make a single pass to find intersections |
| CValidatingNoder | |
| ►Noperation | Provides classes for implementing operations on geometries |
| ►Nbuffer | Provides classes for computing buffers of geometries |
| CBufferBuilder | Builds the buffer geometry for a given input geometry and precision model |
| CBufferCurveSetBuilder | Creates all the raw offset curves for a buffer of a Geometry |
| CBufferInputLineSimplifier | Simplifies a buffer input line to remove concavities with shallow depth |
| CBufferOp | Computes the buffer of a geometry, for both positive and negative buffer distances |
| CBufferParameters | Contains the parameters which describe how a buffer should be constructed |
| CBufferSubgraph | A connected subset of the graph of DirectedEdge and geomgraph::Node |
| COffsetCurve | |
| COffsetCurveBuilder | Computes the raw offset curve for a single Geometry component (ring, line or point) |
| COffsetCurveSection | |
| COffsetSegmentGenerator | |
| COffsetSegmentString | |
| CRightmostEdgeFinder | A RightmostEdgeFinder find the geomgraph::DirectedEdge in a list which has the highest coordinate, and which is oriented L to R at that point. (I.e. the right side is on the RHS of the edge.) |
| CSubgraphDepthLocater | Locates a subgraph inside a set of subgraphs, in order to determine the outside depth of the subgraph |
| ►Ncluster | |
| CAbstractClusterFinder | |
| CDBSCANClusterFinder | |
| CEnvelopeDistanceClusterFinder | |
| CEnvelopeIntersectsClusterFinder | |
| CGeometryDistanceClusterFinder | |
| CGeometryIntersectsClusterFinder | |
| CUnionFind | |
| ►Ndistance | Provides classes for computing the distance between geometries |
| CConnectedElementLocationFilter | A ConnectedElementPointFilter extracts a single point from each connected element in a Geometry (e.g. a polygon, linestring or point) and returns them in a list. Empty geometries do not provide a location item |
| CConnectedElementPointFilter | Extracts a single point from each connected element in a Geometry (e.g. a polygon, linestring or point) and returns them in a list |
| CDistanceOp | Find two points on two geom::Geometrys which lie within a given distance, or else are the nearest points on the geometries (in which case this also provides the distance between the geometries) |
| CGeometryLocation | Represents the location of a point on a Geometry |
| CIndexedFacetDistance | Computes the distance between the facets (segments and vertices) of two Geometrys using a Branch-and-Bound algorithm |
| ►Ngeounion | Classes to perform efficient unioning of collections of geometries |
| CClassicUnionStrategy | Implementation of UnionStrategy that provides overlay using the first generation overlay routines |
| CCascadedPolygonUnion | Provides an efficient method of unioning a collection of polygonal geometries |
| COverlapUnion | Unions MultiPolygons efficiently by using full topological union only for polygons which may overlap by virtue of intersecting the common area of the inputs |
| CPointGeometryUnion | Computes the union of a puntal geometry with another arbitrary Geometry |
| CUnaryUnionOp | Unions a collection of Geometry or a single Geometry (which may be a collection) together |
| CUnionStrategy | |
| ►Nintersection | Provides classes for computing the intersection of a Geometry and a clipping Rectangle |
| CRectangle | Clipping rectangle |
| CRectangleIntersection | Speed-optimized clipping of a Geometry with a rectangle |
| CRectangleIntersectionBuilder | Rebuild geometries from subpaths left by clipping with a rectangle |
| ►Nlinemerge | Line merging package |
| CEdgeString | A sequence of LineMergeDirectedEdge forming one of the lines that will be output by the line-merging process |
| CLineMergeDirectedEdge | A DirectedEdge of a LineMergeGraph |
| CLineMergeEdge | An edge of a LineMergeGraph. The marked field indicates whether this Edge has been logically deleted from the graph |
| CLineMergeGraph | A planar graph of edges that is analyzed to sew the edges together |
| CLineMerger | Sews together a set of fully noded LineStrings |
| CLineSequencer | Builds a sequence from a set of LineStrings so that they are ordered end to end |
| ►Noverlay | Contains classes that perform a topological overlay to compute boolean spatial functions |
| ►Nsnap | |
| CGeometrySnapper | Snaps the vertices and segments of a geom::Geometry to another Geometry's vertices |
| CLineStringSnapper | Snaps the vertices and segments of a LineString to a set of target snap vertices |
| CSnapOverlayOp | Performs an overlay operation using snapping and enhanced precision to improve the robustness of the result |
| ►Nvalidate | |
| CFuzzyPointLocator | Finds the most likely Location of a point relative to the polygonal components of a geometry, using a tolerance value |
| COffsetPointGenerator | Generates points offset from both sides of all segments in a geometry |
| COverlayResultValidator | Validates that the result of an overlay operation is geometrically correct within a determined tolerance |
| CMaximalEdgeRing | A ring of DirectedEdges which may contain nodes of degree > 2 |
| CMinimalEdgeRing | A ring of Edges with the property that no node has degree greater than 2 |
| COverlayNodeFactory | Creates nodes for use in the geomgraph::PlanarGraph constructed during overlay operations. NOTE: also used by operation::valid |
| CPolygonBuilder | Forms Polygon out of a graph of geomgraph::DirectedEdge |
| ►Noverlayng | |
| CCoverageUnion | |
| CEdge | |
| CEdgeKey | |
| CEdgeMerger | |
| CEdgeNodingBuilder | |
| CEdgeSourceInfo | |
| CElevationModel | A simple elevation model used to populate missing Z values in overlay results |
| CIndexedPointOnLineLocator | |
| CIntersectionPointBuilder | |
| CLineBuilder | |
| CLineLimiter | |
| COverlayEdge | |
| COverlayGraph | |
| COverlayLabel | |
| COverlayMixedPoints | |
| COverlayNG | |
| COverlayNGRobust | |
| COverlayPoints | |
| COverlayUtil | |
| CPrecisionReducer | |
| ►CPrecisionUtil | |
| CInherentScaleFilter | |
| CRingClipper | |
| CRobustClipEnvelopeComputer | |
| ►CUnaryUnionNG | |
| CNGUnionStrategy | |
| ►Npolygonize | An API for polygonizing sets of lines |
| CBuildArea | Creates an areal geometry formed by the constituent linework of given geometry |
| CEdgeRing | Represents a ring of PolygonizeDirectedEdge which form a ring of a polygon. The ring may be either an outer shell or a hole |
| CHoleAssigner | Assigns hole rings to shell rings during polygonization |
| CPolygonizeDirectedEdge | A DirectedEdge of a PolygonizeGraph, which represents an edge of a polygon formed by the graph |
| CPolygonizeEdge | An edge of a polygonization graph |
| CPolygonizeGraph | Represents a planar graph of edges that can be used to compute a polygonization, and implements the algorithms to compute the EdgeRings formed by the graph |
| CPolygonizer | Polygonizes a set of Geometrys which contain linework that represents the edges of a planar graph |
| ►Npredicate | Classes which implement topological predicates optimized for particular kinds of geometries |
| CRectangleContains | Optimized implementation of spatial predicate "contains" for cases where the first Geometry is a rectangle |
| CRectangleIntersects | Optimized implementation of the "intersects" spatial predicate for cases where one Geometry is a rectangle |
| CSegmentIntersectionTester | Tests if any line segments in two sets of CoordinateSequences intersect |
| ►Nrelate | Contains classes to implement the computation of the spatial relationships of Geometrys |
| CEdgeEndBuilder | Computes the geomgraph::EdgeEnd objects which arise from a noded geomgraph::Edge |
| CEdgeEndBundle | A collection of geomgraph::EdgeEnd objects which originate at the same point and have the same direction |
| CEdgeEndBundleStar | An ordered list of EdgeEndBundle objects around a RelateNode |
| CRelateComputer | Computes the topological relationship between two Geometries |
| CRelateNode | Represents a node in the topological graph used to compute spatial relationships |
| CRelateNodeFactory | Used by the geomgraph::NodeMap in a RelateNodeGraph to create RelateNode objects |
| CRelateNodeGraph | Implements the simple graph of Nodes and geomgraph::EdgeEnd which is all that is required to determine topological relationships between Geometries |
| CRelateOp | Implements the SFS relate() operation on two geom::Geometry objects |
| ►Nsharedpaths | Find shared paths among two linear Geometry objects |
| CSharedPathsOp | Find shared paths among two linear Geometry objects |
| ►Nvalid | Provides classes for testing the validity of geometries |
| CConsistentAreaTester | Checks that a geomgraph::GeometryGraph representing an area (a geom::Polygon or geom::MultiPolygon) has consistent semantics for area geometries. This check is required for any reasonable polygonal model (including the OGC-SFS model, as well as models which allow ring self-intersection at single points) |
| CIsSimpleOp | |
| CIsValidOp | |
| CMakeValid | The function attempts to create a valid representation of a given invalid geometry without losing any of the input vertices |
| CRepeatedPointRemover | |
| CRepeatedPointTester | Implements the appropriate checks for repeated points (consecutive identical coordinates) as defined in the JTS spec |
| CTopologyValidationError | Contains information about the nature and location of a geom::Geometry validation error |
| CBoundaryOp | |
| CGeometryGraphOperation | The base class for operations that require GeometryGraph |
| ►Nplanargraph | Contains classes to implement a planar graph data structure |
| ►Nalgorithm | Planargraph algorithms |
| CConnectedSubgraphFinder | Finds all connected Subgraphs of a PlanarGraph |
| CDirectedEdge | Represents a directed edge in a PlanarGraph |
| CDirectedEdgeStar | A sorted collection of DirectedEdge which leave a Node in a PlanarGraph |
| CEdge | Represents an undirected edge of a PlanarGraph |
| CGraphComponent | The base class for all graph component classes |
| CNode | A node in a PlanarGraph is a location where 0 or more Edge meet |
| CNodeMap | A map of Node, indexed by the coordinate of the node |
| CPlanarGraph | Represents a directed graph which is embeddable in a planar surface |
| CSubgraph | A subgraph of a PlanarGraph |
| ►Nprecision | Provides classes for manipulating the precision model of Geometries |
| CCommonBits | Determines the maximum number of common most-significant bits in the mantissa of one or numbers |
| CCommonBitsOp | Provides versions of Geometry spatial functions which use common bit removal to reduce the likelihood of robustness problems |
| CCommonBitsRemover | Allow computing and removing common mantissa bits from one or more Geometries |
| CEnhancedPrecisionOp | Provides versions of Geometry spatial functions which use enhanced precision techniques to reduce the likelihood of robustness problems |
| CGeometryPrecisionReducer | Reduces the precision of a geom::Geometry according to the supplied geom::PrecisionModel, ensuring that the result is valid (unless specified otherwise) |
| CMinimumClearance | Computes the Minimum Clearance of a Geometry |
| CPointwisePrecisionReducerTransformer | |
| CPrecisionReducerTransformer | Reduces the precision of a geom::Geometry according to the supplied geom::PrecisionModel, without attempting to preserve valid topology |
| CSimpleGeometryPrecisionReducer | Reduces the precision of a geom::Geometry according to the supplied geom::PrecisionModel, without attempting to preserve valid topology |
| ►Nshape | |
| ►Nfractal | |
| CHilbertCode | |
| CMortonCode | |
| ►Nsimplify | Classes which implement algorithms for simplifying or generalizing geometries |
| CDouglasPeuckerLineSimplifier | Simplifies a linestring (sequence of points) using the standard Douglas-Peucker algorithm |
| CDouglasPeuckerSimplifier | Simplifies a Geometry using the standard Douglas-Peucker algorithm |
| CPolygonHullSimplifier | |
| CTaggedLineSegment | A geom::LineSegment which is tagged with its location in a geom::Geometry |
| CTaggedLinesSimplifier | Simplifies a collection of TaggedLineStrings, preserving topology (in the sense that no new intersections are introduced) |
| CTaggedLineString | Contains and owns a list of TaggedLineSegments |
| CTaggedLineStringSimplifier | Simplifies a TaggedLineString, preserving topology (in the sense that no new intersections are introduced). Uses the recursive Douglas-Peucker algorithm |
| CTopologyPreservingSimplifier | Simplifies a geometry, ensuring that the result is a valid geometry having the same dimension and number of components as the input |
| ►Ntriangulate | Classes to compute Delaunay triangulations |
| ►Npolygon | |
| CConstrainedDelaunayTriangulator | |
| CPolygonEarClipper | |
| CPolygonHoleJoiner | |
| CPolygonNoder | |
| CPolygonTriangulator | |
| CTriDelaunayImprover | |
| ►Nquadedge | Classes to implement a topological subdivision of quadeges, to support creating triangulations and Voronoi diagrams |
| CLastFoundQuadEdgeLocator | Locates QuadEdges in a QuadEdgeSubdivision, optimizing the search by starting in the locality of the last edge found |
| CQuadEdge | A class that represents the edge data structure which implements the quadedge algebra |
| CQuadEdgeLocator | An interface for classes which locate an edge in a QuadEdgeSubdivision which either contains a given Vertex V or is an edge of a triangle which contains V |
| CQuadEdgeSubdivision | A class that contains the QuadEdges representing a planar subdivision that models a triangulation |
| CTrianglePredicate | Algorithms for computing values and predicates associated with triangles |
| CTriangleVisitor | An interface for algorithms which process the triangles in a QuadEdgeSubdivision |
| CVertex | Models a site (node) in a QuadEdgeSubdivision |
| ►Ntri | |
| CTri | |
| CTriangulationBuilder | |
| CTriEdge | |
| CTriList | |
| CDelaunayTriangulationBuilder | A utility class which creates Delaunay Triangulations from collections of points and extract the resulting triangulation edges or triangles as geometries |
| CIncrementalDelaunayTriangulator | Computes a Delauanay Triangulation of a set of quadedge::Vertexes, using an incrementatal insertion algorithm |
| CVoronoiDiagramBuilder | A utility class which creates Voronoi Diagrams from collections of points |
| ►Nutil | Utility classes for GEOS |
| CAssertionFailedException | Indicates a bug in GEOS code |
| CGeometricShapeFactory | Computes various kinds of common geometric shapes |
| CGEOSException | Base class for all GEOS exceptions |
| CIllegalArgumentException | Indicates one or more illegal arguments |
| CIllegalStateException | Indicates an illegal state |
| CInterrupt | Used to manage interruption requests and callbacks |
| CTopologyException | Indicates an invalid or inconsistent topological situation encountered during processing |
| CUnsupportedOperationException | Indicates that the requested operation is unsupported |
