All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| AbstractNode |
|
| AbstractSTRtree |
Base class for STRtree and SIRtree.
|
| AffineTransformation |
Represents an affine transformation on the 2D Cartesian plane.
|
| AffineTransformationBuilder |
|
| AffineTransformationFactory |
Supports creating AffineTransformations defined by various kinds of
inputs and transformation mapping rules.
|
| Angle |
Utility functions for working with angles.
|
| Area |
Functions for computing area.
|
| AreaSimilarityMeasure |
Measures the degree of similarity between two Geometrys
using the area of intersection between the geometries.
|
| ArrayListVisitor |
Builds an array of all visited items.
|
| Assert |
A utility for making programming assertions.
|
| AssertionFailedException |
Thrown when the application is in an inconsistent state.
|
| AxisPlaneCoordinateSequence |
A CoordinateSequence wrapper which
projects 3D coordinates into one of the
three Cartesian axis planes,
using the standard orthonormal projection
(i.e.
|
| BasicSegmentString |
Represents a list of contiguous line segments,
and supports noding the segments.
|
| Bintree |
An BinTree (or "Binary Interval Tree")
is a 1-dimensional version of a quadtree.
|
| Boundable |
A spatial object in an AbstractSTRtree.
|
| BoundablePairDistanceComparator |
The Class BoundablePairDistanceComparator.
|
| 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.
|
| BoundaryNodeRule.EndPointBoundaryNodeRule |
A BoundaryNodeRule which specifies that any points which are endpoints
of lineal components are in the boundary of the
parent geometry.
|
| BoundaryNodeRule.Mod2BoundaryNodeRule |
A BoundaryNodeRule specifies that points are in the
boundary of a lineal geometry iff
the point lies on the boundary of an odd number
of components.
|
| BoundaryNodeRule.MonoValentEndPointBoundaryNodeRule |
A BoundaryNodeRule which determines that only
endpoints with valency of exactly 1 are on the boundary.
|
| BoundaryNodeRule.MultiValentEndPointBoundaryNodeRule |
A BoundaryNodeRule which determines that only
endpoints with valency greater than 1 are on the boundary.
|
| BoundaryOp |
|
| BufferCurveMaximumDistanceFinder |
Finds the approximate maximum distance from a buffer curve to
the originating geometry.
|
| BufferCurveMaximumDistanceFinder.MaxMidpointDistanceFilter |
|
| BufferCurveMaximumDistanceFinder.MaxPointDistanceFilter |
|
| BufferDistanceValidator |
Validates that a given buffer curve lies an appropriate distance
from the input generating it.
|
| BufferFunctions |
|
| BufferInputLineSimplifier |
Simplifies a buffer input line to
remove concavities with shallow depth.
|
| BufferOp |
Computes the buffer of a geometry, for both positive and negative buffer distances.
|
| BufferParameters |
A value class containing the parameters which
specify how a buffer should be constructed.
|
| BufferResultValidator |
Validates that the result of a buffer operation
is geometrically correct, within a computed tolerance.
|
| ByteArrayInStream |
Allows an array of bytes to be used as an InStream.
|
| ByteOrderDataInStream |
Allows reading a stream of Java primitive datatypes from an underlying
InStream,
with the representation being in either common byte ordering.
|
| ByteOrderValues |
Methods to read and write primitive Java datatypes from/to byte
sequences, allowing the byte order to be specified
|
| CascadedPolygonUnion |
Provides an efficient method of unioning a collection of
Polygonal geometries.
|
| Centroid |
Computes the centroid of a Geometry of any dimension.
|
| CGAlgorithms |
Deprecated.
|
| CGAlgorithms3D |
Basic computational geometry algorithms
for geometry and coordinates defined in 3-dimensional Cartesian space.
|
| CGAlgorithmsDD |
Implements basic computational geometry algorithms using DD arithmetic.
|
| CollectionUtil |
Utilities for processing Collections.
|
| CollectionUtil.Function |
|
| 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 |
Removes common most-significant mantissa bits
from one or more Geometrys.
|
| ComponentCoordinateExtracter |
|
| ConcaveHull |
|
| ConformingDelaunayTriangulationBuilder |
A utility class which creates Conforming Delaunay Triangulations
from collections of points and linear constraints, and extract the resulting
triangulation edges or triangles as geometries.
|
| ConformingDelaunayTriangulator |
Computes a Conforming Delaunay Triangulation over a set of sites and a set of
linear constraints.
|
| ConnectedElementLocationFilter |
A ConnectedElementPointFilter extracts a single point
from each connected element in a Geometry
(e.g.
|
| ConnectedElementPointFilter |
Extracts a single point
from each connected element in a Geometry
(e.g.
|
| ConnectedInteriorTester |
|
| ConnectedSubgraphFinder |
|
| ConsistentAreaTester |
|
| ConsistentPolygonRingChecker |
Tests whether the polygon rings in a GeometryGraph
are consistent.
|
| ConstraintEnforcementException |
Indicates a failure during constraint enforcement.
|
| ConstraintSplitPointFinder |
An interface for strategies for determining the location of split points on constraint segments.
|
| ConstraintVertex |
A vertex in a Constrained Delaunay Triangulation.
|
| ConstraintVertexFactory |
|
| ConvexHull |
|
| Coordinate |
A lightweight class used to store coordinates on the 2-dimensional Cartesian plane.
|
| Coordinate.DimensionalComparator |
Compares two Coordinates, allowing for either a 2-dimensional
or 3-dimensional comparison, and handling NaN values correctly.
|
| CoordinateArrayFilter |
|
| CoordinateArrays |
Useful utility functions for handling Coordinate arrays
|
| CoordinateArrays.BidirectionalComparator |
A Comparator for Coordinate arrays
modulo their directionality.
|
| CoordinateArrays.ForwardComparator |
A Comparator for Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering.
|
| CoordinateArraySequence |
|
| CoordinateArraySequenceFactory |
|
| CoordinateCountFilter |
|
| CoordinateFilter |
An interface for classes which use the values of the coordinates in a Geometry.
|
| CoordinateList |
A list of Coordinates, which may
be set to prevent repeated coordinates from occurring in the list.
|
| CoordinatePrecisionReducerFilter |
|
| Coordinates |
Useful utility functions for handling Coordinate objects.
|
| CoordinateSequence |
The internal representation of a list of coordinates inside a Geometry.
|
| CoordinateSequenceComparator |
|
| CoordinateSequenceFactory |
|
| CoordinateSequenceFilter |
|
| CoordinateSequences |
|
| CoordinateXY |
Coordinate subclass supporting XY ordinates.
|
| CoordinateXYM |
Coordinate subclass supporting XYM ordinates.
|
| CoordinateXYZM |
Coordinate subclass supporting XYZM ordinates.
|
| DD |
Implements extended-precision floating-point numbers
which maintain 106 bits (approximately 30 decimal digits) of precision.
|
| Debug |
Provides routines to simplify and localize debugging output.
|
| DefaultCoordinateSequenceFactory |
Deprecated.
|
| DelaunayTriangulationBuilder |
A utility class which creates Delaunay Triangulations
from collections of points and extract the resulting
triangulation edges or triangles as geometries.
|
| Densifier |
Densifies a Geometry by inserting extra vertices along the line segments
contained in the geometry.
|
| Depth |
A Depth object records the topological depth of the sides
of an Edge for up to two Geometries.
|
| Dimension |
Provides constants representing the dimensions of a point, a curve and a surface.
|
| DirectedEdge |
|
| DirectedEdge |
|
| DirectedEdgeStar |
A DirectedEdgeStar is an ordered list of outgoing DirectedEdges around a node.
|
| DirectedEdgeStar |
|
| DiscreteHausdorffDistance |
An algorithm for computing a distance metric
which is an approximation to the Hausdorff Distance
based on a discretization of the input Geometry.
|
| DiscreteHausdorffDistance.MaxDensifiedByFractionDistanceFilter |
|
| DiscreteHausdorffDistance.MaxPointDistanceFilter |
|
| Distance |
Functions to compute distance between basic geometric structures.
|
| Distance3DOp |
Find two points on two 3D 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).
|
| DistanceOp |
Find two points on two 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).
|
| DistanceToPoint |
|
| DistanceToPointFinder |
Computes the Euclidean distance (L2 metric) from a Point to a Geometry.
|
| DoubleBits |
DoubleBits manipulates Double numbers
by using bit manipulation and bit-field extraction.
|
| DouglasPeuckerSimplifier |
Simplifies a Geometry using the Douglas-Peucker algorithm.
|
| Edge |
|
| Edge |
|
| EdgeConnectedTriangleTraversal |
A framework to visit sets of edge-connected QuadEdgeTriangles in breadth-first order
|
| EdgeEnd |
Models the end of an edge incident on a node.
|
| EdgeEndBuilder |
|
| EdgeEndBundle |
A collection of EdgeEnds which obey the following invariant:
They originate at the same node and have the same direction.
|
| EdgeEndBundleStar |
|
| EdgeEndStar |
A EdgeEndStar is an ordered list of EdgeEnds around a node.
|
| EdgeGraph |
|
| EdgeGraphBuilder |
Builds an edge graph from geometries containing edges.
|
| 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 Edges is correctly noded.
|
| EdgeRayArea |
|
| EdgeRayFunctions |
|
| EdgeRayIntersectionArea |
|
| EdgeRing |
|
| EdgeSetIntersector |
An EdgeSetIntersector computes all the intersections between the
edges in the set.
|
| EdgeSetNoder |
Nodes a set of edges.
|
| EdgeString |
A sequence of LineMergeDirectedEdges forming one of the lines that will
be output by the line-merging process.
|
| EnhancedPrecisionOp |
Provides versions of Geometry spatial functions which use
enhanced precision techniques to reduce the likelihood of robustness problems.
|
| Envelope |
Defines a rectangular region of the 2D coordinate plane.
|
| FacetSequence |
|
| FacetSequenceTreeBuilder |
|
| FastNodingValidator |
Validates that a collection of SegmentStrings is correctly noded.
|
| FastSegmentSetIntersectionFinder |
|
| FontGlyphReader |
Provides methods to read Font glyphs for strings
into Polygonal geometry.
|
| FuzzyPointLocator |
Finds the most likely Location of a point relative to
the polygonal components of a geometry, using a tolerance value.
|
| GeoJsonConstants |
Constants for GeoJSON objects
|
| GeoJsonReader |
Reads a GeoJson Geometry from a JSON fragment into a Geometry.
|
| GeoJsonWriter |
Writes Geometrys as JSON fragments in GeoJson format.
|
| GeometricShapeBuilder |
|
| GeometricShapeFactory |
Computes various kinds of common geometric shapes.
|
| Geometry |
A representation of a planar, linear vector geometry.
|
| GeometryCollection |
Models a collection of Geometrys of
arbitrary type and dimension.
|
| GeometryCollectionIterator |
Iterates over all Geometrys in a Geometry,
(which may be either a collection or an atomic geometry).
|
| GeometryCollectionMapper |
Maps the members of a GeometryCollection
into another GeometryCollection via a defined
mapping function.
|
| GeometryCollectionShape |
A Shape which contains a heterogeneous collection of other shapes
representing JTS Geometrys.
|
| GeometryCombiner |
|
| GeometryComponentFilter |
Geometry classes support the concept of applying
a GeometryComponentFilter
filter to the Geometry.
|
| GeometryEditor |
A class which supports creating new Geometrys
which are modifications of existing ones,
maintaining the same type structure.
|
| GeometryEditor.CoordinateOperation |
|
| GeometryEditor.CoordinateSequenceOperation |
|
| GeometryEditor.GeometryEditorOperation |
A interface which specifies an edit operation for Geometries.
|
| GeometryEditor.NoOpGeometryOperation |
A GeometryEditorOperation which does not modify
the input geometry.
|
| GeometryEditorEx |
A class which supports creating new Geometrys
which are modifications of existing ones,
maintaining the same type structure.
|
| GeometryEditorEx.CoordinateOperation |
|
| GeometryEditorEx.CoordinateSequenceOperation |
|
| GeometryEditorEx.GeometryEditorOperation |
A interface which specifies an edit operation for Geometries.
|
| GeometryEditorEx.NoOpGeometryOperation |
A GeometryEditorOperation which does not modify
the input geometry.
|
| GeometryExtracter |
Extracts the components of a given type from a Geometry.
|
| GeometryFactory |
Supplies a set of utility methods for building Geometry objects from lists
of Coordinates.
|
| GeometryFilter |
GeometryCollection classes support the concept of
applying a GeometryFilter to the Geometry.
|
| GeometryGraph |
A GeometryGraph is a graph that models a given Geometry
|
| GeometryGraphOperation |
|
| GeometryItemDistance |
|
| GeometryLocation |
Represents the location of a point on a Geometry.
|
| GeometryMapper |
Methods to map various collections
of Geometrys
via defined mapping functions.
|
| GeometryMapper.MapOp |
An interface for geometry functions used for mapping.
|
| GeometryNoder |
|
| GeometryPrecisionReducer |
Reduces the precision of a Geometry
according to the supplied PrecisionModel,
ensuring that the result is topologically valid.
|
| GeometrySnapper |
Snaps the vertices and segments of a Geometry
to another Geometry's vertices.
|
| GeometrySnapRounder |
|
| GeometryStrategies |
Container for GML2 Geometry parsing strategies which can be represented in JTS.
|
| GeometryTransformer |
A framework for processes which transform an input Geometry into
an output Geometry, possibly changing its structure and type(s).
|
| GMLConstants |
Various constant strings associated with GML format.
|
| GMLHandler |
A SAX DefaultHandler which builds Geometrys
from GML2-formatted geometries.
|
| GMLReader |
Reads a GML2 geometry from an XML fragment into a Geometry.
|
| GMLWriter |
Writes Geometrys as XML fragments in GML2 format.
|
| GraphComponent |
A GraphComponent is the parent class for the objects'
that form a graph.
|
| GraphComponent |
The base class for all graph component classes.
|
| HalfEdge |
Represents a directed component of an edge in an EdgeGraph.
|
| HausdorffSimilarityMeasure |
Measures the degree of similarity between two Geometrys
using the Hausdorff distance metric.
|
| HCoordinate |
Represents a homogeneous coordinate in a 2-D coordinate space.
|
| HilbertCode |
Encodes points as the index along finite planar Hilbert curves.
|
| HilbertCurveBuilder |
Generates a LineString representing the Hilbert Curve
at a given level.
|
| HoleRemover |
Removes holes which match a given predicate.
|
| HoleRemover.Predicate |
|
| HotPixel |
Implements a "hot pixel" as used in the Snap Rounding algorithm.
|
| IdentityPointTransformation |
Copies point ordinates with no transformation.
|
| IncrementalDelaunayTriangulator |
Computes a Delaunay Triangulation of a set of Vertexes, using an
incremental insertion algorithm.
|
| IndexedFacetDistance |
Computes the distance between the facets (segments and vertices)
of two Geometrys
using a Branch-and-Bound algorithm.
|
| IndexedNestedRingTester |
Tests whether any of a set of LinearRings are
nested inside another ring in the set, using a spatial
index to speed up the comparisons.
|
| IndexedPointInAreaLocator |
Determines the Location of Coordinates relative to
an areal geometry, using indexing for efficiency.
|
| InputStreamInStream |
An adapter to allow an InputStream to be used as an InStream
|
| InStream |
A interface for classes providing an input stream of bytes.
|
| InteriorIntersectionFinderAdder |
|
| InteriorPoint |
Computes an interior point of a Geometry.
|
| InteriorPointArea |
Computes a point in the interior of an areal geometry.
|
| InteriorPointLine |
Computes a point in the interior of an linear geometry.
|
| InteriorPointPoint |
Computes a point in the interior of an point geometry.
|
| IntersectionAdder |
|
| IntersectionFinderAdder |
Deprecated.
|
| IntersectionMatrix |
Models a Dimensionally Extended Nine-Intersection Model (DE-9IM) matrix.
|
| Interval |
Represents an (1-dimensional) closed interval on the Real number line.
|
| Interval |
A contiguous portion of 1D-space.
|
| IntervalRTreeBranchNode |
|
| IntervalRTreeLeafNode |
|
| IntervalRTreeNode |
|
| IntervalRTreeNode.NodeComparator |
|
| 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.
|
| InvalidHoleRemover |
Removes holes which are invalid due to not being wholly covered by the parent shell.
|
| IsSimpleOp |
Tests whether a Geometry is simple.
|
| IsValidOp |
Implements the algorithms required to compute the isValid() method
for Geometrys.
|
| ItemBoundable |
Boundable wrapper for a non-Boundable spatial object.
|
| ItemDistance |
|
| ItemVisitor |
|
| IteratedNoder |
|
| JTSVersion |
JTS API version information.
|
| KdNode |
A node of a KdTree, which represents one or more points in the same location.
|
| KdNodeVisitor |
|
| KdTree |
An implementation of a 2-D KD-Tree.
|
| Key |
A Key is a unique identifier for a node in a tree.
|
| Key |
A Key is a unique identifier for a node in a quadtree.
|
| KMLWriter |
Writes a formatted string containing the KML representation of a JTS
Geometry.
|
| KochSnowflakeBuilder |
|
| Label |
A Label indicates the topological relationship of a component
of a topology graph to a given Geometry.
|
| LastFoundQuadEdgeLocator |
|
| Length |
Functions for computing length.
|
| LengthIndexedLine |
Supports linear referencing along a linear Geometry
using the length along the line as the index.
|
| LengthLocationMap |
|
| Lineal |
Identifies Geometry subclasses which
are 1-dimensional and have components which are LineStrings.
|
| LinearComponentExtracter |
|
| LinearGeometryBuilder |
|
| LinearIterator |
|
| LinearLocation |
|
| LinearRing |
Models an OGC SFS LinearRing.
|
| LineBuilder |
|
| LineDissolver |
Dissolves the linear components
from a collection of Geometrys
into a set of maximal-length Linestrings
in which every unique segment appears once only.
|
| LineIntersector |
A LineIntersector is an algorithm that can both test whether
two line segments intersect and compute the intersection point(s)
if they do.
|
| LineMergeDirectedEdge |
|
| LineMergeEdge |
|
| LineMergeGraph |
A planar graph of edges that is analyzed to sew the edges together.
|
| LineMerger |
Merges a collection of linear components to form maximal-length linestrings.
|
| LineSegment |
Represents a line segment defined by two Coordinates.
|
| LineSequencer |
Builds a sequence from a set of LineStrings so that
they are ordered end to end.
|
| LineString |
Models an OGC-style LineString.
|
| LineStringExtracter |
|
| LineStringSnapper |
Snaps the vertices and segments of a LineString
to a set of target snap vertices.
|
| LocateFailureException |
|
| Location |
Constants representing the different topological locations
which can occur in a Geometry.
|
| LocationIndexedLine |
|
| MarkHalfEdge |
A HalfEdge which supports
marking edges with a boolean flag.
|
| MathUtil |
Various utility functions for mathematical and numerical operations.
|
| Matrix |
Implements some 2D matrix operations
(in particular, solving systems of linear equations).
|
| MaximalEdgeRing |
A ring of DirectedEdges which may contain nodes of degree > 2.
|
| MCIndexNoder |
|
| MCIndexNoder.SegmentOverlapAction |
|
| MCIndexPointSnapper |
|
| MCIndexPointSnapper.HotPixelSnapAction |
|
| MCIndexSegmentSetMutualIntersector |
|
| MCIndexSegmentSetMutualIntersector.SegmentOverlapAction |
|
| MCIndexSnapRounder |
Uses Snap Rounding to compute a rounded,
fully noded arrangement from a set of SegmentStrings.
|
| Memory |
Utility functions to report JVM memory usage.
|
| MidpointSplitPointFinder |
A simple split point finder which returns the midpoint of the split segment.
|
| MinimalEdgeRing |
A ring of Edges with the property that no node
has degree greater than 2.
|
| MinimumBoundingCircle |
Computes the Minimum Bounding Circle (MBC)
for the points in a Geometry.
|
| MinimumClearance |
Computes the Minimum Clearance of a Geometry.
|
| MinimumDiameter |
Computes the minimum diameter of a Geometry.
|
| MonotoneChain |
|
| MonotoneChain |
Monotone Chains are a way of partitioning the segments of a linestring to
allow for fast searching of intersections.
|
| MonotoneChainBuilder |
|
| 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.
|
| MonotoneChainOverlapAction |
The action for the internal iterator for performing
overlap queries on a MonotoneChain
|
| MonotoneChainSelectAction |
The action for the internal iterator for performing
envelope select queries on a MonotoneChain
|
| MortonCode |
Encodes points as the index along the planar Morton (Z-order) curve.
|
| MortonCurveBuilder |
Generates a LineString representing the Morton Curve
at a given level.
|
| MultiLineString |
|
| MultiPoint |
Models a collection of Points.
|
| MultiPolygon |
|
| NodableSegmentString |
An interface for classes which support adding nodes to
a segment string.
|
| Node |
|
| Node |
|
| Node |
|
| Node |
|
| NodeBase |
The base class for nodes in a Bintree.
|
| NodeBase |
|
| NodedSegmentString |
Represents a list of contiguous line segments,
and supports noding the segments.
|
| NodeFactory |
|
| NodeMap |
A map of nodes, indexed by the coordinate of the node
|
| NodeMap |
A map of Nodes, indexed by the coordinate of the node.
|
| Noder |
Computes all intersections between segments in a set of SegmentStrings.
|
| NodingIntersectionFinder |
Finds non-noded intersections in a set of SegmentStrings,
if any exist.
|
| NodingValidator |
Validates that a collection of SegmentStrings is correctly noded.
|
| NonEncroachingSplitPointFinder |
A strategy for finding constraint split points which attempts to maximise the length of the split
segments while preventing further encroachment.
|
| NoninvertibleTransformationException |
|
| NotRepresentableException |
Indicates that a HCoordinate has been computed which is
not representable on the Cartesian plane.
|
| NumberUtil |
|
| ObjectCounter |
Counts occurrences of objects.
|
| OctagonalEnvelope |
A bounding container for a Geometry which is in the shape of a general octagon.
|
| Octant |
Methods for computing and working with octants of the Cartesian plane
Octants are numbered as follows:
|
| OffsetCurveBuilder |
Computes the raw offset curve for a
single Geometry component (ring, line or point).
|
| OffsetCurveSetBuilder |
Creates all the raw offset curves for a buffer of a Geometry.
|
| OffsetPointGenerator |
Generates points offset by a given distance
from both sides of the midpoint of
all segments in a Geometry.
|
| Ordinate |
An enumeration of possible Well-Known-Text or Well-Known-Binary ordinates.
|
| Orientation |
Functions to compute the orientation of basic geometric structures
including point triplets (triangles) and rings.
|
| OrientedCoordinateArray |
Allows comparing Coordinate arrays
in an orientation-independent way.
|
| OutputStreamOutStream |
An adapter to allow an OutputStream to be used as an OutStream
|
| OutStream |
A interface for classes providing an output stream of bytes.
|
| OverlayNodeFactory |
Creates nodes for use in the PlanarGraphs constructed during
overlay operations.
|
| OverlayOp |
Computes the geometric overlay of two Geometrys.
|
| OverlayResultValidator |
Validates that the result of an overlay operation is
geometrically correct, within a determined tolerance.
|
| PackedCoordinateSequence |
|
| PackedCoordinateSequence.Double |
Packed coordinate sequence implementation based on doubles
|
| PackedCoordinateSequence.Float |
Packed coordinate sequence implementation based on floats
|
| PackedCoordinateSequenceFactory |
Builds packed array coordinate sequences.
|
| ParseException |
Thrown by a WKTReader when a parsing problem occurs.
|
| PlanarGraph |
The computation of the IntersectionMatrix relies on the use of a structure
called a "topology graph".
|
| PlanarGraph |
Represents a directed graph which is embeddable in a planar surface.
|
| PlanarPolygon3D |
Models a polygon lying in a plane in 3-dimensional Cartesian space.
|
| Plane3D |
Models a plane in 3-dimensional Cartesian space.
|
| Point |
Represents a single point.
|
| PointBuilder |
Constructs Points from the nodes of an overlay graph.
|
| PointExtracter |
Extracts all the 0-dimensional ( Point) components from a Geometry.
|
| PointGeometryUnion |
Computes the union of a Puntal geometry with
another arbitrary Geometry.
|
| PointLocation |
Functions for locating points within basic geometric
structures such as lines and rings.
|
| PointLocator |
|
| PointOnGeometryLocator |
|
| PointPairDistance |
Contains a pair of points and the distance between them.
|
| PointPairDistance |
Contains a pair of points and the distance between them.
|
| PointShapeFactory |
|
| PointShapeFactory.BasePointShapeFactory |
|
| PointShapeFactory.Circle |
|
| PointShapeFactory.Cross |
|
| PointShapeFactory.Point |
|
| PointShapeFactory.Square |
|
| PointShapeFactory.Star |
|
| PointShapeFactory.Triangle |
|
| PointShapeFactory.X |
|
| PointTransformation |
Transforms a geometry Coordinate into a Java2D Point,
possibly with a mathematical transformation of the ordinate values.
|
| Polygon |
Represents a polygon with linear edges, which may include holes.
|
| Polygonal |
Identifies Geometry subclasses which
are 2-dimensional
and have components which have Lineal boundaries.
|
| PolygonBuilder |
|
| PolygonCleaner |
|
| PolygonExtracter |
|
| Polygonizer |
Polygonizes a set of Geometrys which contain linework that
represents the edges of a planar graph.
|
| PolygonShape |
A Shape which represents a polygon which may contain holes.
|
| Position |
A Position indicates the position of a Location relative to a graph component
(Node, Edge, or Area).
|
| PrecisionModel |
|
| PrecisionModel.Type |
The types of Precision Model which JTS supports.
|
| PrecisionReducerCoordinateOperation |
|
| PreparedGeometry |
An interface for classes which prepare Geometrys
in order to optimize the performance
of repeated calls to specific geometric operations.
|
| PreparedGeometryFactory |
|
| PreparedLineString |
A prepared version for Lineal geometries.
|
| PreparedPoint |
A prepared version for Puntal geometries.
|
| PreparedPolygon |
|
| PriorityQueue |
A priority queue over a set of Comparable objects.
|
| Puntal |
Identifies Geometry subclasses which
are 0-dimensional and with components which are Points.
|
| 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.
|
| QuadEdgeTriangle |
|
| QuadEdgeUtil |
|
| Quadrant |
Utility functions for working with quadrants, which are numbered as follows:
|
| Quadtree |
A Quadtree is a spatial index structure for efficient range querying
of items bounded by 2D rectangles.
|
| RandomPointsBuilder |
Creates random point sets contained in a
region defined by either a rectangular or a polygonal extent.
|
| RandomPointsInGridBuilder |
Creates random point sets
where the points are constrained to lie in the cells of a grid.
|
| RayCrossingCounter |
Counts the number of segments crossed by a horizontal ray extending to the right
from a given point, in an incremental fashion.
|
| RectangleContains |
Optimized implementation of the contains spatial predicate
for cases where the first Geometry is a rectangle.
|
| RectangleIntersects |
Implementation of the intersects spatial predicate
optimized for the case where one Geometry is a rectangle.
|
| RectangleLineIntersector |
Computes whether a rectangle intersects line segments.
|
| RelateComputer |
Computes the topological relationship between two Geometries.
|
| RelateNode |
Represents a node in the topological graph used to compute spatial relationships.
|
| RelateNodeFactory |
|
| RelateNodeGraph |
Implements the simple graph of Nodes and EdgeEnd which is all that is
required to determine topological relationships between Geometries.
|
| RelateOp |
Implements the SFS relate() generalized spatial predicate on two Geometrys.
|
| RemoverFunctions |
|
| RepeatedPointTester |
Implements the appropriate checks for repeated points
(consecutive identical coordinates) as defined in the
JTS spec.
|
| RobustDeterminant |
Implements an algorithm to compute the
sign of a 2x2 determinant for double precision values robustly.
|
| RobustLineIntersector |
|
| Root |
|
| Root |
QuadRoot is the root of a single Quadtree.
|
| ScaledNoder |
Wraps a Noder and transforms its input
into the integer domain.
|
| Segment |
Models a constraint segment in a triangulation.
|
| SegmentIntersectionDetector |
Detects and records an intersection between two SegmentStrings,
if one exists.
|
| SegmentIntersector |
Computes the intersection of line segments,
and adds the intersection to the edges containing the segments.
|
| SegmentIntersector |
Processes possible intersections detected by a Noder.
|
| SegmentNode |
|
| SegmentNodeList |
|
| 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.
|
| SegmentStringDissolver |
Dissolves a noded collection of SegmentStrings to produce
a set of merged linework with unique segments.
|
| SegmentStringDissolver.SegmentStringMerger |
A merging strategy which can be used to update the context data of SegmentStrings
which are merged during the dissolve process.
|
| SegmentStringUtil |
|
| ShapeCollectionPathIterator |
A PathIterator which provides paths for a collection of Shapes.
|
| ShapeReader |
Converts a Java2D Shape
or the more general PathIterator into a Geometry.
|
| ShapeWriter |
Writes Geometrys into Java2D Shape objects
of the appropriate type.
|
| ShortCircuitedGeometryVisitor |
A visitor to Geometry components, which
allows short-circuiting when a defined condition holds.
|
| SierpinskiCarpetBuilder |
|
| SimilarityMeasure |
An interface for classes which measures the degree of similarity between two Geometrys.
|
| SimilarityMeasureCombiner |
|
| SimpleEdgeSetIntersector |
Finds all intersections in one or two sets of edges,
using the straightforward method of
comparing all segments.
|
| SimpleGeometryPrecisionReducer |
Deprecated.
|
| SimpleMCSweepLineIntersector |
Finds all intersections in one or two sets of edges,
using an x-axis sweepline algorithm in conjunction with Monotone Chains.
|
| SimpleMinimumClearance |
Computes the minimum clearance of a geometry or
set of geometries.
|
| SimpleNoder |
Nodes a set of SegmentStrings by
performing a brute-force comparison of every segment to every other one.
|
| SimplePointInAreaLocator |
Computes the location of points
relative to a Polygonal Geometry,
using a simple O(n) algorithm.
|
| SimpleSegmentSetMutualIntersector |
Intersects two sets of SegmentStrings using
brute-force comparison.
|
| SimpleSnapRounder |
Uses Snap Rounding to compute a rounded,
fully noded arrangement from a set of SegmentStrings.
|
| SimpleSweepLineIntersector |
Finds all intersections in one or two sets of edges,
using a simple x-axis sweepline algorithm.
|
| SineStarFactory |
Creates geometries which are shaped like multi-armed stars
with each arm shaped like a sine wave.
|
| SinglePassNoder |
Base class for Noders which make a single
pass to find intersections.
|
| SIRtree |
One-dimensional version of an STR-packed R-tree.
|
| SmallHoleRemover |
Removes holes which are smaller than a given area.
|
| SnapIfNeededOverlayOp |
Performs an overlay operation using snapping and enhanced precision
to improve the robustness of the result.
|
| SnapOverlayOp |
Performs an overlay operation using snapping and enhanced precision
to improve the robustness of the result.
|
| SnapRoundFunctions |
|
| SnapRoundOverlayFunctions |
|
| SortedPackedIntervalRTree |
A static index on a set of 1-dimensional intervals,
using an R-Tree packed based on the order of the interval midpoints.
|
| SpatialIndex |
The basic operations supported by classes
implementing spatial index algorithms.
|
| SplitSegment |
Models a constraint segment which can be split in two in various ways,
according to certain geometric constraints.
|
| Stopwatch |
Implements a timer function which can compute
elapsed time as well as split times.
|
| StringUtil |
Utility methods for working with Strings.
|
| STRtree |
A query-only R-tree created using the Sort-Tile-Recursive (STR) algorithm.
|
| Subgraph |
|
| SweepLineEvent |
|
| SweepLineEvent |
|
| SweepLineIndex |
A sweepline implements a sorted index on a set of intervals.
|
| SweepLineInterval |
|
| SweepLineOverlapAction |
|
| SweepLineSegment |
|
| TaggedLineStringSimplifier |
Simplifies a TaggedLineString, preserving topology
(in the sense that no new intersections are introduced).
|
| TopologyException |
Indicates an invalid or inconsistent topological situation encountered during processing
|
| TopologyLocation |
A TopologyLocation is the labelling of a
GraphComponent's topological relationship to a single Geometry.
|
| TopologyPreservingSimplifier |
Simplifies a geometry and ensures that
the result is a valid geometry having the
same dimension and number of components as the input,
and with the components having the same topological
relationship.
|
| TopologyValidationError |
Contains information about the nature and location of a Geometry
validation error
|
| TraversalVisitor |
Interface for classes which process triangles visited during traversals of a
QuadEdgeSubdivision
|
| Triangle |
Represents a planar triangle, and provides methods for calculating various
properties of triangles.
|
| TrianglePredicate |
Algorithms for computing values and predicates
associated with triangles.
|
| TriangleVisitor |
|
| UnaryUnionOp |
Unions a Collection of Geometrys or a single Geometry
(which may be a GeoometryCollection) together.
|
| UnionInteracting |
Experimental code to union MultiPolygons
with processing limited to the elements which actually interact.
|
| UniqueCoordinateArrayFilter |
|
| VariableWidthBuffer |
Creates a buffer polygon with variable width along a line.
|
| Vector2D |
A 2-dimensional mathematical vector represented by double-precision X and Y components.
|
| Vector3D |
Represents a vector in 3-dimensional Cartesian space.
|
| Vertex |
|
| VertexTaggedGeometryDataMapper |
Creates a map between the vertex Coordinates of a
set of Geometrys,
and the parent geometry, and transfers the source geometry
data objects to geometry components tagged with the coordinates.
|
| VoronoiDiagramBuilder |
A utility class which creates Voronoi Diagrams
from collections of points.
|
| VWSimplifier |
Simplifies a Geometry using the Visvalingam-Whyatt area-based algorithm.
|
| WKBConstants |
Constant values used by the WKB format
|
| WKBHexFileReader |
Reads a sequence of Geometrys in WKBHex format
from a text file.
|
| WKBReader |
Reads a Geometryfrom a byte stream in Well-Known Binary format.
|
| WKBWriter |
Writes a Geometry into Well-Known Binary format.
|
| WKTFileReader |
Reads a sequence of Geometrys in WKT format
from a text file.
|
| WKTReader |
Converts a geometry in Well-Known Text format to a Geometry.
|
| WKTWriter |
Writes the Well-Known Text representation of a Geometry.
|