Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

geos | Basic namespace for all GEOS functionalities
geom |
prep | Contains classes and interfaces implementing algorithms that optimize the performance of repeated calls to specific geometric operations
AbstractPreparedPolygonContains | A base class containing the logic for computes the contains and covers spatial relationship predicates for a `PreparedPolygon` relative to all other `Geometry` classes
BasicPreparedGeometry | A base class for `PreparedGeometry` subclasses
PreparedGeometry | An interface for classes which prepare `Geometry`s in order to optimize the performance of repeated calls to specific geometric operations
PreparedGeometryFactory | A factory for creating `PreparedGeometry`s
PreparedLineString | A prepared version of `LinearRing`, `LineString` or `MultiLineString` geometries
PreparedLineStringIntersects | Computes the intersects spatial relationship predicate for a target `PreparedLineString` relative to all other `Geometry` classes
PreparedPoint | A prepared version of `Point` or `MultiPoint` geometries
PreparedPolygon | A prepared version of `Polygon` or `MultiPolygon` geometries
PreparedPolygonContains | Computes the contains spatial relationship predicate for a `PreparedPolygon` relative to all other `Geometry` classes
PreparedPolygonContainsProperly | Computes the containsProperly spatial relationship predicate for `PreparedPolygon`s relative to all other `Geometry` classes
PreparedPolygonCovers | Computes the covers spatial relationship predicate for a `PreparedPolygon` relative to all other `Geometry` classes
PreparedPolygonIntersects | Computes the intersects spatial relationship predicate for `PreparedPolygon`s relative to all other `Geometry` classes
PreparedPolygonPredicate | A base class for predicate operations on `PreparedPolygon`s
util | Provides classes that parse and modify Geometry objects
ComponentCoordinateExtracter | Extracts a single representative `Coordinate` from each connected component of a `Geometry`
CoordinateOperation |
Densifier |
GeometryCombiner | Combines Geometrys to produce a GeometryCollection of the most appropriate type
GeometryEditor |
GeometryEditorOperation |
GeometryExtracter |
GeometryFixer |
GeometryLister |
GeometryMapper |
GeometryTransformer | A framework for processes which transform an input Geometry into an output Geometry, possibly changing its structure and type(s)
LinearComponentExtracter |
PointExtracter |
PolygonalExtracter | Extracts the polygonal (Polygon and MultiPolygon) elements from a Geometry
PolygonExtracter |
ShortCircuitedGeometryVisitor | A visitor to Geometry elements which can be short-circuited by a given condition
SineStarFactory |
CircularArc |
Coordinate | Coordinate is the lightweight class used to store coordinates
CoordinateLessThan | Strict weak ordering Functor for Coordinate
CoordinateFilter | Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geometry
CoordinateList | A list of `Coordinate`s, which may be set to prevent repeated coordinates from occurring in the list
CoordinateSequence | The internal representation of a list of coordinates inside a Geometry
CoordinateSequenceFilter | Interface for classes which provide operations that can be applied to the coordinates in a CoordinateSequence
CoordinateSequences | Utility methods to operate on CoordinateSequences. Methods that do not benefit from access to the CoordinateSequence internals can be placed here
Dimension |
Envelope | An Envelope defines a rectangulare region of the 2D coordinate plane
Geometry | Basic implementation of Geometry, constructed and destructed by GeometryFactory
GeometryCollection | Represents a collection of heterogeneous Geometry objects
GeometryComponentFilter |
GeometryFactory | Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geometry objects
GeometryFilter | Geometry classes support the concept of applying a Geometry filter to the Geometry
IntersectionMatrix | Implementation of Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix
LinearRing | Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple
LineSegment |
LineString |
MultiLineString | Models a collection of LineStrings
MultiPoint |
MultiPolygon |
Point |
Polygon | Represents a linear polygon, which may include holes
Position | A Position indicates the position of a Location relative to a graph component (Node, Edge, or Area)
PrecisionModel | Specifies the precision model of the Coordinate in a Geometry
Quadrant | Utility functions for working with quadrants
Surface |
Triangle | Represents a planar triangle, and provides methods for calculating various properties of triangles
algorithm | Contains classes and interfaces implementing fundamental computational geometry algorithms
construct |
ExactMaxInscribedCircle |
IndexedDistanceToPoint | Computes the distance between a point and a geometry (which may be a collection containing any type of geometry)
IndexedPointInPolygonsLocator | Determines the location of a point in the polygonal elements of a geometry
LargestEmptyCircle |
MaximumInscribedCircle |
distance | Classes to compute distance metrics between geometries
DiscreteFrechetDistance | The Fréchet distance is a measure of similarity between curves. Thus, it can be used like the Hausdorff distance
MatrixStorage |
RectMatrix |
CsrMatrix |
HashMapMatrix |
DiscreteHausdorffDistance | An algorithm for computing a distance metric which is an approximation to the Hausdorff Distance based on a discretization of the input `geom::Geometry`
DistanceToPoint |
PointPairDistance |
hull |
ConcaveHull |
ConcaveHullOfPolygons |
OuterShellsExtracter |
locate | Classes which determine the Location of points in geometries
IndexedPointInAreaLocator | Determines the location of Coordinates relative to an areal geometry, using indexing for efficiency
PointOnGeometryLocator | An interface for classes which determine the Location of points in Polygon or MultiPolygon geometries
SimplePointInAreaLocator | Computes the location of points relative to a polygonal Geometry, using a simple O(n) algorithm
Angle | Utility functions for working with angles
BoundaryNodeRule | 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
CentralEndpointIntersector | Computes an approximate intersection of two line segments by taking the most central of the endpoints of the segments
Centroid | Computes the centroid of a Geometry of any dimension
CGAlgorithmsDD | Implements basic computational geometry algorithms using extended precision float-point arithmetic
ConvexHull | Computes the convex hull of a Geometry
Distance | Functions to compute distance between basic geometric structures
HCoordinate | Represents a homogeneous coordinate in a 2-D coordinate space
InteriorPointArea | Computes a point in the interior of an areal geometry. The point will lie in the geometry interior in all except certain pathological cases
InteriorPointLine | Computes a point in the interior of an linear geometry
InteriorPointPoint | Computes a point in the interior of an point geometry
Intersection | Functions to compute intersection points between lines and line segments
Length | Functions for computing length
LineIntersector | A LineIntersector is an algorithm that can both test whether two line segments intersect and compute the intersection point if they do
MinimumAreaRectangle |
MinimumDiameter | Computes the minimum diameter of a geom::Geometry
NotRepresentableException | Indicates that a HCoordinate has been computed which is not representable on the Cartesian plane
Orientation | Functions to compute the orientation of basic geometric structures including point triplets (triangles) and rings
PointLocation | Functions for locating points within basic geometric structures such as lines and rings
PointLocator | Computes the topological relationship (Location) of a single point to a Geometry
PolygonNodeTopology |
RayCrossingCounter | Counts the number of segments crossed by a horizontal ray extending to the right from a given point, in an incremental fashion
RobustDeterminant | Implements an algorithm to compute the sign of a 2x2 determinant for double precision values robustly
triangulate | Classes to compute Delaunay triangulations
quadedge | Classes to implement a topological subdivision of quadeges, to support creating triangulations and Voronoi diagrams
LastFoundQuadEdgeLocator | Locates `QuadEdge`s in a `QuadEdgeSubdivision`, optimizing the search by starting in the locality of the last edge found
QuadEdge | A class that represents the edge data structure which implements the quadedge algebra
QuadEdgeLocator | 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
QuadEdgeSubdivision | A class that contains the QuadEdges representing a planar subdivision that models a triangulation
TrianglePredicate | Algorithms for computing values and predicates associated with triangles
TriangleVisitor | An interface for algorithms which process the triangles in a `QuadEdgeSubdivision`
Vertex | Models a site (node) in a QuadEdgeSubdivision
tri |
Tri |
TriangulationBuilder |
TriEdge |
TriList |
polygon |
ConstrainedDelaunayTriangulator |
PolygonEarClipper |
PolygonHoleJoiner |
PolygonNoder |
PolygonTriangulator |
TriDelaunayImprover |
DelaunayTriangulationBuilder | A utility class which creates Delaunay Triangulations from collections of points and extract the resulting triangulation edges or triangles as geometries
IncrementalDelaunayTriangulator | Computes a Delauanay Triangulation of a set of `quadedge::Vertex`es, using an incrementatal insertion algorithm
VoronoiDiagramBuilder | A utility class which creates Voronoi Diagrams from collections of points
operation | Provides classes for implementing operations on geometries
relateng |
AdjacentEdgeLocator |
EdgeSegmentOverlapAction | The action for the internal iterator for performing overlap queries on a MonotoneChain
NodeSection |
PolygonNodeConverter |
RelateNG |
RelatePointLocator |
buffer | Provides classes for computing buffers of geometries
BufferBuilder | Builds the buffer geometry for a given input geometry and precision model
BufferCurveSetBuilder | Creates all the raw offset curves for a buffer of a Geometry
BufferInputLineSimplifier | Simplifies a buffer input line to remove concavities with shallow depth
BufferNodeFactory | Creates nodes for use in the geomgraph::PlanarGraph constructed during buffer operations. NOTE: also used by operation::valid
BufferOp | Computes the buffer of a geometry, for both positive and negative buffer distances
BufferParameters | Contains the parameters which describe how a buffer should be constructed
BufferSubgraph | A connected subset of the graph of DirectedEdge and geomgraph::Node
MaximalEdgeRing | A ring of DirectedEdges which may contain nodes of degree > 2
MinimalEdgeRing | A ring of Edges with the property that no node has degree greater than 2
OffsetCurve |
OffsetCurveBuilder | Computes the raw offset curve for a single Geometry component (ring, line or point)
OffsetCurveSection |
OffsetSegmentGenerator |
OffsetSegmentString |
PolygonBuilder | Forms Polygon out of a graph of geomgraph::DirectedEdge
RightmostEdgeFinder | 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.)
SubgraphDepthLocater | Locates a subgraph inside a set of subgraphs, in order to determine the outside depth of the subgraph
distance | Provides classes for computing the distance between geometries
ConnectedElementLocationFilter | 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
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
DistanceOp | Find two points on two `geom::Geometry`s 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)
GeometryLocation | Represents the location of a point on a Geometry
IndexedFacetDistance | Computes the distance between the facets (segments and vertices) of two Geometrys using a Branch-and-Bound algorithm
intersection | Provides classes for computing the intersection of a Geometry and a clipping Rectangle
Rectangle | Clipping rectangle
RectangleIntersection | Speed-optimized clipping of a Geometry with a rectangle
RectangleIntersectionBuilder | Rebuild geometries from subpaths left by clipping with a rectangle
linemerge | Line merging package
EdgeString | A sequence of LineMergeDirectedEdge forming one of the lines that will be output by the line-merging process
LineMergeDirectedEdge | A DirectedEdge of a LineMergeGraph
LineMergeEdge | An edge of a LineMergeGraph. The `marked` field indicates whether this Edge has been logically deleted from the graph
LineMergeGraph | A planar graph of edges that is analyzed to sew the edges together
LineMerger | Sews together a set of fully noded LineStrings
LineSequencer | Builds a sequence from a set of LineStrings so that they are ordered end to end
overlay | Contains classes that perform a topological overlay to compute boolean spatial functions
snap |
GeometrySnapper | Snaps the vertices and segments of a `geom::Geometry` to another Geometry's vertices
LineStringSnapper | Snaps the vertices and segments of a LineString to a set of target snap vertices
SnapOverlayOp | Performs an overlay operation using snapping and enhanced precision to improve the robustness of the result
validate |
FuzzyPointLocator | Finds the most likely Location of a point relative to the polygonal components of a geometry, using a tolerance value
OffsetPointGenerator | Generates points offset from both sides of all segments in a geometry
OverlayResultValidator | Validates that the result of an overlay operation is geometrically correct within a determined tolerance
polygonize | An API for polygonizing sets of lines
BuildArea | Creates an areal geometry formed by the constituent linework of given geometry
EdgeRing | Represents a ring of PolygonizeDirectedEdge which form a ring of a polygon. The ring may be either an outer shell or a hole
HoleAssigner | Assigns hole rings to shell rings during polygonization
PolygonizeDirectedEdge | A DirectedEdge of a PolygonizeGraph, which represents an edge of a polygon formed by the graph
PolygonizeEdge | An edge of a polygonization graph
PolygonizeGraph | 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
Polygonizer | Polygonizes a set of Geometrys which contain linework that represents the edges of a planar graph
predicate | Classes which implement topological predicates optimized for particular kinds of geometries
RectangleContains | Optimized implementation of spatial predicate "contains" for cases where the first Geometry is a rectangle
RectangleIntersects | Optimized implementation of the "intersects" spatial predicate for cases where one Geometry is a rectangle
SegmentIntersectionTester | Tests if any line segments in two sets of CoordinateSequences intersect
relate | Contains classes to implement the computation of the spatial relationships of Geometrys
EdgeEndBuilder | Computes the geomgraph::EdgeEnd objects which arise from a noded geomgraph::Edge
EdgeEndBundle | A collection of geomgraph::EdgeEnd objects which originate at the same point and have the same direction
EdgeEndBundleStar | An ordered list of EdgeEndBundle objects around a RelateNode
RelateComputer | Computes the topological relationship between two Geometries
RelateNode | Represents a node in the topological graph used to compute spatial relationships
RelateNodeFactory | Used by the geomgraph::NodeMap in a RelateNodeGraph to create RelateNode objects
RelateNodeGraph | Implements the simple graph of Nodes and geomgraph::EdgeEnd which is all that is required to determine topological relationships between Geometries
RelateOp | Implements the SFS relate() operation on two geom::Geometry objects
sharedpaths | Find shared paths among two linear Geometry objects
SharedPathsOp | Find shared paths among two linear Geometry objects
geounion | Classes to perform efficient unioning of collections of geometries
ClassicUnionStrategy | Implementation of UnionStrategy that provides overlay using the first generation overlay routines
CascadedPolygonUnion | Provides an efficient method of unioning a collection of polygonal geometries
OverlapUnion | Unions MultiPolygons efficiently by using full topological union only for polygons which may overlap by virtue of intersecting the common area of the inputs
PointGeometryUnion | Computes the union of a puntal geometry with another arbitrary Geometry
UnaryUnionOp | Unions a collection of Geometry or a single Geometry (which may be a collection) together
UnionStrategy |
valid | Provides classes for testing the validity of geometries
ConsistentAreaTester | 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)
IsSimpleOp |
IsValidOp |
MakeValid | The function attempts to create a valid representation of a given invalid geometry without losing any of the input vertices
RepeatedPointRemover |
RepeatedPointTester | Implements the appropriate checks for repeated points (consecutive identical coordinates) as defined in the JTS spec
TopologyValidationError | Contains information about the nature and location of a geom::Geometry validation error
cluster |
AbstractClusterFinder |
DBSCANClusterFinder |
EnvelopeDistanceClusterFinder |
EnvelopeIntersectsClusterFinder |
GeometryDistanceClusterFinder |
GeometryIntersectsClusterFinder |
UnionFind |
grid |
Cell | Stores information about the spatial extent of a Grid cell and any cases where a line crosses that cell (recorded in a Traversal)
GridIntersection | Computes and stores information about intersection of a Grid and a Geometry. For a polygonal geometry, the fraction of each grid cell covered by polygon is stored. For a linear geometry, the length of the line in each grid cell is stored
Traversal | Records the coordinates of a line that are within a grid cell, as well as the Side from which the line entered and exited the cell
overlayng |
CoverageUnion |
Edge |
EdgeKey |
EdgeMerger |
EdgeNodingBuilder |
EdgeSourceInfo |
ElevationModel | A simple elevation model used to populate missing Z values in overlay results
IndexedPointOnLineLocator |
InputGeometry |
IntersectionPointBuilder |
LineBuilder |
LineLimiter |
OverlayEdge |
OverlayGraph |
OverlayLabel |
OverlayMixedPoints |
OverlayNG |
OverlayNGRobust |
OverlayPoints |
OverlayUtil |
PrecisionReducer |
PrecisionUtil |
InherentScaleFilter |
RingClipper |
RobustClipEnvelopeComputer |
UnaryUnionNG |
NGUnionStrategy |
BoundaryOp |
GeometryGraphOperation | The base class for operations that require GeometryGraph
index | Provides classes for various kinds of spatial indexes
quadtree | Contains classes that implement a Quadtree spatial index
IntervalSize | 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
Key | A Key is a unique identifier for a node in a quadtree
Node | Represents a node of a Quadtree
NodeBase | The base class for nodes in a Quadtree
Quadtree | 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
Root | QuadRoot is the root of a single Quadtree. It is centred at the origin, and does not have a defined extent
bintree | Contains classes that implement a Binary Interval Tree index
Bintree | A BinTree (or "Binary Interval Tree") is a 1-dimensional version of a quadtree
Interval | Represents an (1-dimensional) closed interval on the Real number line
Key | A Key is a unique identifier for a node in a tree
Node | A node of a Bintree
NodeBase | The base class for nodes in a Bintree
Root | The root node of a single Bintree
chain | Contains classes that implement Monotone Chains
MonotoneChain | Monotone Chains are a way of partitioning the segments of a linestring to allow for fast searching of intersections
MonotoneChainBuilder | Constructs MonotoneChains for sequences of Coordinates
MonotoneChainOverlapAction | The action for the internal iterator for performing overlap queries on a MonotoneChain
MonotoneChainSelectAction |
intervalrtree | 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
SortedPackedIntervalRTree | A static index on a set of 1-dimensional intervals, using an R-Tree packed based on the order of the interval midpoints
kdtree |
KdNode |
KdTree |
strtree | Contains 2-D and 1-D versions of the Sort-Tile-Recursive (STR) tree, a query-only R-tree
AbstractNode | A node of the STR tree
AbstractSTRtree | Base class for STRtree and SIRtree
IntersectsOp | A test for intersection between two bounds, necessary because subclasses of AbstractSTRtree have different implementations of bounds
Boundable | A spatial object in an AbstractSTRtree
BoundablePair | A pair of Boundables, whose leaf items support a distance metric between them
Interval | A contiguous portion of 1D-space. Used internally by SIRtree
ItemBoundable | Boundable wrapper for a non-Boundable spatial object. Used internally by AbstractSTRtree
ItemDistance | A function method which computes the distance between two ItemBoundables in an STRtree. Used for Nearest Neighbour searches
SimpleSTRnode | A node of the STR tree
SimpleSTRtree | A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For two-dimensional spatial data
SIRtree | One-dimensional version of an STR-packed R-tree
STRtree | A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For two-dimensional spatial data
TemplateSTRtreeImpl | A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm. For one- or two-dimensional spatial data
sweepline | Contains classes which implement a sweepline algorithm for scanning geometric data structures
SweepLineIndex | A sweepline implements a sorted index on a set of intervals
ItemVisitor | A visitor for items in an index
SpatialIndex | Abstract class defines basic insertion and query operations supported by classes implementing spatial index algorithms
VertexSequencePackedRtree |
coverage |
CoverageCleaner |
CoverageEdge |
CoverageGapFinder |
CoveragePolygonValidator |
CoverageRingEdges |
CoverageSimplifier |
CoverageUnion |
CoverageValidator |
InvalidSegmentDetector |
TPVWSimplifier |
simplify | Classes which implement algorithms for simplifying or generalizing geometries
DouglasPeuckerLineSimplifier | Simplifies a linestring (sequence of points) using the standard Douglas-Peucker algorithm
DouglasPeuckerSimplifier | Simplifies a Geometry using the standard Douglas-Peucker algorithm
PolygonHullSimplifier |
TaggedLineSegment | A geom::LineSegment which is tagged with its location in a geom::Geometry
TaggedLinesSimplifier | Simplifies a collection of TaggedLineStrings, preserving topology (in the sense that no new intersections are introduced)
TaggedLineString | Contains and owns a list of TaggedLineSegments
TaggedLineStringSimplifier | Simplifies a TaggedLineString, preserving topology (in the sense that no new intersections are introduced). Uses the recursive Douglas-Peucker algorithm
TopologyPreservingSimplifier | Simplifies a geometry, ensuring that the result is a valid geometry having the same dimension and number of components as the input
noding | Classes to compute nodings for arrangements of line segments and line segment sequences
snapround | Contains classes to implement the Snap Rounding algorithm for noding linestrings
HotPixel | Implements a "hot pixel" as used in the Snap Rounding algorithm
MCIndexPointSnapper | "Snaps" all SegmentStrings in a SpatialIndex containing MonotoneChains to a given HotPixel
MCIndexSnapRounder | Uses Snap Rounding to compute a rounded, fully noded arrangement from a set of SegmentString
SnapRoundingIntersectionAdder |
SnapRoundingNoder |
snap |
SnappingNoder |
BasicSegmentString | Represents a list of contiguous line segments, and supports noding the segments
BoundaryChainNoder |
FastNodingValidator | Validates that a collection of `SegmentString`s is correctly noded
FastSegmentSetIntersectionFinder | Finds if two sets of SegmentStrings intersect
IntersectionAdder | Computes the intersections between two line segments in SegmentString and adds them to each string
IntersectionFinderAdder | Finds proper and interior intersections in a set of SegmentStrings, and adds them as nodes
IteratedNoder | Nodes a set of SegmentStrings completely
MCIndexNoder | Nodes a set of SegmentString using a index based on MonotoneChain and a SpatialIndex
MCIndexSegmentSetMutualIntersector | Intersects two sets of SegmentStrings using a index based on MonotoneChains and a SpatialIndex
NodableSegmentString | An interface for classes which support adding nodes to a segment string
NodedSegmentString | Represents a list of contiguous line segments, and supports noding the segments
Noder | Computes all intersections between segments in a set of SegmentString
NodingIntersectionFinder | Finds non-noded intersections in a set of `SegmentString`s, if any exist
NodingValidator | Validates that a collection of `SegmentString`s is correctly noded. Throws a TopologyException if a noding error is found
Octant | Methods for computing and working with octants of the Cartesian plane
OrientedCoordinateArray | Allows comparing `geom::CoordinateSequence`s in an orientation-independent way
ScaledNoder | Wraps a `Noder` and transforms its input into the integer domain
SegmentExtractingNoder |
SegmentIntersectionDetector | Detects and records an intersection between two `SegmentString`s, if one exists
SegmentIntersector | Processes possible intersections detected by a Noder
SegmentNode | Represents an intersection point between two NodedSegmentString
SegmentNodeList | A list of the SegmentNode present along a NodedSegmentString
SegmentPointComparator | Implements a robust method of comparing the relative position of two points along the same segment
SegmentSetMutualIntersector | An intersector for the red-blue intersection problem
SegmentString | An interface for classes which represent a sequence of contiguous line segments
SegmentStringUtil | Utility methods for processing `SegmentString`s
SimpleNoder | Nodes a set of `SegmentString`s by performing a brute-force comparison of every segment to every other one
SinglePassNoder | Base class for `Noder`s which make a single pass to find intersections
ValidatingNoder |
edgegraph |
EdgeGraph |
EdgeGraphBuilder |
HalfEdge |
dissolve |
LineDissolver |
io | Contains the interfaces for converting JTS objects to and from other formats
ByteOrderDataInStream | Allows reading an stream of primitive datatypes from an underlying istream, with the representation being in either common byte ordering
ByteOrderValues | Methods to read and write primitive datatypes from/to byte sequences, allowing the byte order to be specified
GeoJSONReader | GeoJSON reader class; see also GeoJSONWriter
GeoJSONWriter | Outputs the GeoJSON representation of a Geometry. See also GeoJSONReader for parsing
OrdinateSet | Utility class to manipulate a set of flags indicating whether X, Y, Z, or M dimensions are present. Based on JTS EnumSet<Ordinate>
ParseException | Notifies a parsing error
WKBReader | Reads a Geometry from Well-Known Binary format
WKBWriter | Writes a Geometry into Well-Known Binary format
WKTReader | WKT parser class; see also WKTWriter
WKTWriter | Outputs the textual representation of a Geometry. See also WKTReader
geomgraph | Contains classes that implement topology graphs
index | Contains classes that implement indexes for performing noding on geometry graph edges
EdgeSetIntersector | An EdgeSetIntersector computes all the intersections between the edges in the set
MonotoneChain |
MonotoneChainEdge | MonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections
MonotoneChainIndexer | MonotoneChains are a way of partitioning the segments of an edge to allow for fast searching of intersections
SegmentIntersector | Computes the intersection of line segments, and adds the intersection to the edges containing the segments
SimpleEdgeSetIntersector | Finds all intersections in one or two sets of edges, using the straightforward method of comparing all segments
SimpleMCSweepLineIntersector | Finds all intersections in one or two sets of edges, using an x-axis sweepline algorithm in conjunction with Monotone Chains
SimpleSweepLineIntersector | Finds all intersections in one or two sets of edges, using a simple x-axis sweepline algorithm
Depth | A Depth object records the topological depth of the sides of an Edge for up to two Geometries
DirectedEdge | A directed EdgeEnd
DirectedEdgeStar | A DirectedEdgeStar is an ordered list of outgoing DirectedEdges around a node
Edge |
EdgeEnd | Models the end of an edge incident on a node
EdgeEndStar | A EdgeEndStar is an ordered list of EdgeEnds around a node
EdgeIntersection | Represents a point on an edge which intersects with another edge
EdgeIntersectionList | A list of edge intersections along an Edge
EdgeList | A EdgeList is a list of Edges
EdgeNodingValidator | Validates that a collection of SegmentStrings is correctly noded
EdgeRing |
GeometryGraph | A GeometryGraph is a graph that models a given Geometry
GraphComponent | A GraphComponent is the parent class for the objects' that form a graph
Label | A `Label` indicates the topological relationship of a component of a topology graph to a given `Geometry`
Node | The node component of a geometry graph
PlanarGraph | Represents a directed graph which is embeddable in a planar surface
TopologyLocation | A TopologyLocation is the labelling of a GraphComponent's topological relationship to a single Geometry
linearref | Contains classes and interfaces implementing linear referencing on linear geometries
ExtractLineByLocation | Extracts the subline of a linear Geometry between two `LinearLocation`s on the line
LengthIndexedLine | Supports linear referencing along a linear geom::Geometry using the length along the line as the index
LengthIndexOfPoint | Computes the length index of the point on a linear Geometry nearest a given Coordinate
LengthLocationMap | Computes the LinearLocation for a given length along a linear Geometry
LinearGeometryBuilder | Builds a linear geometry (LineString or MultiLineString) incrementally (point-by-point)
LinearIterator | An iterator over the components and coordinates of a linear geometry (LineString or MultiLineString)
LinearLocation | Represents a location along a LineString or MultiLineString
LocationIndexedLine | Supports linear referencing along a linear Geometry using LinearLocations as the index
LocationIndexOfLine | Determines the location of a subline along a linear Geometry
LocationIndexOfPoint | Computes the LinearLocation of the point on a linear Geometry nearest a given Coordinate
math |
DD | Wrapper for DoubleDouble higher precision mathematics operations
planargraph | Contains classes to implement a planar graph data structure
algorithm | Planargraph algorithms
ConnectedSubgraphFinder | Finds all connected `Subgraph`s of a PlanarGraph
DirectedEdge | Represents a directed edge in a PlanarGraph
DirectedEdgeStar | A sorted collection of DirectedEdge which leave a Node in a PlanarGraph
Edge | Represents an undirected edge of a PlanarGraph
GraphComponent | The base class for all graph component classes
Node | A node in a PlanarGraph is a location where 0 or more Edge meet
NodeMap | A map of Node, indexed by the coordinate of the node
PlanarGraph | Represents a directed graph which is embeddable in a planar surface
Subgraph | A subgraph of a PlanarGraph
precision | Provides classes for manipulating the precision model of Geometries
CommonBits | Determines the maximum number of common most-significant bits in the mantissa of one or numbers
CommonBitsOp | Provides versions of Geometry spatial functions which use common bit removal to reduce the likelihood of robustness problems
CommonBitsRemover | Allow computing and removing common mantissa bits from one or more Geometries
EnhancedPrecisionOp | Provides versions of Geometry spatial functions which use enhanced precision techniques to reduce the likelihood of robustness problems
GeometryPrecisionReducer | Reduces the precision of a `geom::Geometry` according to the supplied `geom::PrecisionModel`, ensuring that the result is valid (unless specified otherwise)
MinimumClearance | Computes the Minimum Clearance of a Geometry
PointwisePrecisionReducerTransformer |
PrecisionReducerTransformer | Reduces the precision of a `geom::Geometry` according to the supplied `geom::PrecisionModel`, without attempting to preserve valid topology
SimpleGeometryPrecisionReducer | Reduces the precision of a `geom::Geometry` according to the supplied `geom::PrecisionModel`, without attempting to preserve valid topology
util | Utility classes for GEOS
AssertionFailedException | Indicates a bug in GEOS code
GeometricShapeFactory | Computes various kinds of common geometric shapes
GEOSException | Base class for all GEOS exceptions
IllegalArgumentException | Indicates one or more illegal arguments
IllegalStateException | Indicates an illegal state
Interrupt | Used to manage interruption requests and callbacks
TopologyException | Indicates an invalid or inconsistent topological situation encountered during processing
UnsupportedOperationException | Indicates that the requested operation is unsupported
shape |
fractal |
HilbertCode |
MortonCode |