Package | Description |
---|---|
org.locationtech.jts.algorithm |
Contains classes and interfaces implementing fundamental computational geometry algorithms.
|
org.locationtech.jts.algorithm.distance |
Classes to compute distance metrics between geometries.
|
org.locationtech.jts.algorithm.locate |
Classes to determine the topological location of points in geometries.
|
org.locationtech.jts.awt |
Classes to perform conversions from Java2D shape objects.
|
org.locationtech.jts.edgegraph | |
org.locationtech.jts.geom |
Contains the
Geometry interface hierarchy and supporting classes. |
org.locationtech.jts.geom.impl |
Implementations of interfaces for geometric structures.
|
org.locationtech.jts.geom.util |
Provides classes that parse and modify Geometry objects.
|
org.locationtech.jts.geomgraph |
Contains classes that implement topology graphs.
|
org.locationtech.jts.geomgraph.index |
Contains classes that implement indexes for performing noding on geometry graph edges.
|
org.locationtech.jts.index |
Provides classes for various kinds of spatial indexes.
|
org.locationtech.jts.index.chain |
Contains classes that implement Monotone Chains
|
org.locationtech.jts.index.kdtree |
Contains classes which implement a k-D tree index over 2-D point data.
|
org.locationtech.jts.index.quadtree |
Contains classes that implement a Quadtree spatial index
|
org.locationtech.jts.io |
Contains the interfaces for converting JTS objects to and from other formats.
|
org.locationtech.jts.linearref |
Contains classes and interfaces implementing linear referencing on linear geometries
|
org.locationtech.jts.math | |
org.locationtech.jts.noding |
Classes to compute nodings for arrangements of line segments and line segment sequences.
|
org.locationtech.jts.noding.snap | |
org.locationtech.jts.noding.snapround |
Contains classes to implement the Snap Rounding algorithm for noding linestrings.
|
org.locationtech.jts.operation |
Provides classes for implementing operations on geometries
|
org.locationtech.jts.operation.buffer |
Provides classes for computing buffers of geometries
|
org.locationtech.jts.operation.buffer.validate |
Classes to perform validation of the results of buffer operations.
|
org.locationtech.jts.operation.distance |
Provides classes for computing the distance between geometries
|
org.locationtech.jts.operation.distance3d | |
org.locationtech.jts.operation.linemerge |
Classes to perform line merging.
|
org.locationtech.jts.operation.overlay |
Contains classes that perform a topological overlay to compute boolean spatial functions.
|
org.locationtech.jts.operation.overlay.snap |
Classes to perform snapping on geometries to prepare them for overlay operations.
|
org.locationtech.jts.operation.overlay.validate |
Classes to validate the results of overlay operations.
|
org.locationtech.jts.operation.overlayng |
Contains classes that perform vector overlay
to compute boolean set-theoretic spatial functions.
|
org.locationtech.jts.operation.relate |
Contains classes to implement the computation of the spatial relationships of
Geometry s. |
org.locationtech.jts.operation.valid |
Classes for testing the validity and simplicity of geometries,
as defined in the OGC Simple Features specification.
|
org.locationtech.jts.planargraph |
Contains classes to implement a planar graph data structure.
|
org.locationtech.jts.precision |
Provides classes for analyzing and
manipulating the precision of Geometries.
|
org.locationtech.jts.shape | |
org.locationtech.jts.shape.fractal | |
org.locationtech.jts.triangulate |
Classes to compute Delaunay triangulations.
|
org.locationtech.jts.triangulate.polygon |
Classes for triangulating polygons.
|
org.locationtech.jts.triangulate.quadedge |
Classes to implement a topological subdivision of quadeges, to support creating triangulations
and Voronoi diagrams.
|
org.locationtech.jts.triangulate.tri |
Classes for representing a planar triangulation as a set of linked triangles.
|
org.locationtech.jts.util |
Contains support classes for the Java Topology Suite.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
MinimumBoundingCircle.getCentre()
Gets the centre point of the computed Minimum Bounding Circle.
|
Coordinate |
Centroid.getCentroid()
Gets the computed centroid.
|
static Coordinate |
Centroid.getCentroid(Geometry geom)
Computes the centroid point of a geometry.
|
Coordinate |
HCoordinate.getCoordinate() |
Coordinate |
LineIntersector.getEndpoint(int segmentIndex,
int ptIndex)
Gets an endpoint of an input segment.
|
Coordinate[] |
MinimumBoundingCircle.getExtremalPoints()
Gets the extremal points which define the computed Minimum Bounding Circle.
|
Coordinate |
InteriorPointLine.getInteriorPoint() |
Coordinate |
InteriorPointArea.getInteriorPoint()
Gets the computed interior point.
|
Coordinate |
InteriorPointPoint.getInteriorPoint() |
static Coordinate |
InteriorPoint.getInteriorPoint(Geometry geom)
Computes a location of an interior point in a
Geometry . |
static Coordinate |
InteriorPointLine.getInteriorPoint(Geometry geom)
Computes an interior point for the
linear components of a Geometry.
|
static Coordinate |
InteriorPointArea.getInteriorPoint(Geometry geom)
Computes an interior point for the
polygonal components of a Geometry.
|
static Coordinate |
InteriorPointPoint.getInteriorPoint(Geometry geom)
Computes an interior point for the
puntal components of a Geometry.
|
Coordinate |
LineIntersector.getIntersection(int intIndex)
Returns the intIndex'th intersection point
|
Coordinate |
LineIntersector.getIntersectionAlongSegment(int segmentIndex,
int intIndex)
Computes the intIndex'th intersection point in the direction of
a specified input line segment
|
Coordinate |
MinimumDiameter.getWidthCoordinate()
Gets the
Coordinate forming one end of the minimum diameter |
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
|
static Coordinate |
Intersection.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the intersection point of two lines.
|
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines
using DD arithmetic.
|
static Coordinate |
Intersection.lineSegment(Coordinate line1,
Coordinate line2,
Coordinate seg1,
Coordinate seg2)
Computes the intersection point of a line and a line segment (if any).
|
static Coordinate |
Angle.project(Coordinate p,
double angle,
double dist)
Projects a point by a given angle and distance.
|
Modifier and Type | Method and Description |
---|---|
static double |
Angle.angle(Coordinate p)
Returns the angle of the vector from (0,0) to p,
relative to the positive X-axis.
|
static double |
Angle.angle(Coordinate p0,
Coordinate p1)
Returns the angle of the vector from p0 to p1,
relative to the positive X-axis.
|
static double |
Angle.angleBetween(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Returns the unoriented smallest angle between two vectors.
|
static double |
Angle.angleBetweenOriented(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Returns the oriented smallest angle between two vectors.
|
static double |
Angle.bisector(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Computes the angle of the unoriented bisector
of the smallest angle between two vectors.
|
static double |
LineIntersector.computeEdgeDistance(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the "edge distance" of an intersection point p along a segment.
|
void |
RobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2) |
abstract void |
LineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2)
Compute the intersection of a point p and the line p1-p2.
|
void |
LineIntersector.computeIntersection(Coordinate p1,
Coordinate p2,
Coordinate p3,
Coordinate p4)
Computes the intersection of the lines p1-p2 and p3-p4.
|
static int |
CGAlgorithms.computeOrientation(Coordinate p1,
Coordinate p2,
Coordinate q)
Deprecated.
|
void |
RayCrossingCounter.countSegment(Coordinate p1,
Coordinate p2)
Counts a segment
|
static double |
CGAlgorithms3D.distance(Coordinate p0,
Coordinate p1) |
static double |
CGAlgorithms.distanceLineLine(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Deprecated.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Deprecated.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Deprecated.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate A,
Coordinate B)
Deprecated.
|
static double |
CGAlgorithms.distancePointLinePerpendicular(Coordinate p,
Coordinate A,
Coordinate B)
Deprecated.
|
static double |
CGAlgorithms3D.distancePointSegment(Coordinate p,
Coordinate A,
Coordinate B) |
static double |
CGAlgorithms3D.distanceSegmentSegment(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance between two 3D segments.
|
static int |
Orientation.index(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the orientation index of the direction of the point
q relative to
a directed infinite line specified by p1-p2 . |
static double |
Angle.interiorAngle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Computes the interior angle between two segments of a ring.
|
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
|
static Coordinate |
Intersection.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the intersection point of two lines.
|
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines
using DD arithmetic.
|
boolean |
RectangleLineIntersector.intersects(Coordinate p0,
Coordinate p1)
Tests whether the query rectangle intersects a
given line segment.
|
boolean |
PointLocator.intersects(Coordinate p,
Geometry geom)
Convenience method to test a point for intersection with
a Geometry
|
static boolean |
Angle.isAcute(Coordinate p0,
Coordinate p1,
Coordinate p2)
Tests whether the angle between p0-p1-p2 is acute.
|
static boolean |
CGAlgorithms.isCCW(Coordinate[] ring)
Deprecated.
Use
Orientation.isCCW(Coordinate[]) instead. |
static boolean |
Orientation.isCCW(Coordinate[] ring)
Tests if a ring defined by an array of
Coordinate s is
oriented counter-clockwise. |
static boolean |
Orientation.isCCWArea(Coordinate[] ring)
Tests if a ring defined by an array of
Coordinate s is
oriented counter-clockwise, using the signed area of the ring. |
static boolean |
PointLocation.isInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
static boolean |
PointLocation.isInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
boolean |
LineIntersector.isIntersection(Coordinate pt)
Test whether a point is a intersection point of two line segments.
|
static boolean |
Angle.isObtuse(Coordinate p0,
Coordinate p1,
Coordinate p2)
Tests whether the angle between p0-p1-p2 is obtuse.
|
static boolean |
PointLocation.isOnLine(Coordinate p,
Coordinate[] line)
Tests whether a point lies on the line defined by a list of
coordinates.
|
static boolean |
PointLocation.isOnLine(Coordinate p,
Coordinate[] line)
Tests whether a point lies on the line defined by a list of
coordinates.
|
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Deprecated.
Use
PointLocation.isOnLine(Coordinate, Coordinate[])
instead. |
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Deprecated.
Use
PointLocation.isOnLine(Coordinate, Coordinate[])
instead. |
static boolean |
PointLocation.isOnLine(Coordinate p,
CoordinateSequence line)
Tests whether a point lies on the line defined by a
CoordinateSequence . |
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Deprecated.
Use
PointLocation.isInRing(Coordinate, Coordinate[])
instead. |
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Deprecated.
Use
PointLocation.isInRing(Coordinate, Coordinate[])
instead. |
static Coordinate |
Intersection.lineSegment(Coordinate line1,
Coordinate line2,
Coordinate seg1,
Coordinate seg2)
Computes the intersection point of a line and a line segment (if any).
|
int |
PointLocator.locate(Coordinate p,
Geometry geom)
Computes the topological relationship (
Location ) of a single point
to a Geometry. |
static int |
PointLocation.locateInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the
exterior of a ring.
|
static int |
PointLocation.locateInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the
exterior of a ring.
|
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines the
Location of a point in a ring. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines the
Location of a point in a ring. |
static int |
CGAlgorithms.locatePointInRing(Coordinate p,
Coordinate[] ring)
Deprecated.
Use
PointLocation.locateInRing(Coordinate, Coordinate[])
instead. |
static int |
CGAlgorithms.locatePointInRing(Coordinate p,
Coordinate[] ring)
Deprecated.
Use
PointLocation.locateInRing(Coordinate, Coordinate[])
instead. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
CoordinateSequence ring)
Determines the
Location of a point in a ring. |
static double |
LineIntersector.nonRobustComputeEdgeDistance(Coordinate p,
Coordinate p1,
Coordinate p2)
This function is non-robust, since it may compute the square of large numbers.
|
static double |
Area.ofRing(Coordinate[] ring)
Computes the area for a ring.
|
static double |
Area.ofRingSigned(Coordinate[] ring)
Computes the signed area for a ring.
|
static int |
CGAlgorithmsDD.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
static int |
RobustDeterminant.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
static int |
CGAlgorithms.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Deprecated.
|
static double |
Distance.pointToLinePerpendicular(Coordinate p,
Coordinate A,
Coordinate B)
Computes the perpendicular distance from a point p to the (infinite) line
containing the points AB
|
static double |
Distance.pointToSegment(Coordinate p,
Coordinate A,
Coordinate B)
Computes the distance from a point p to a line segment AB
Note: NON-ROBUST!
|
static double |
Distance.pointToSegmentString(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
static double |
Distance.pointToSegmentString(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
static Coordinate |
Angle.project(Coordinate p,
double angle,
double dist)
Projects a point by a given angle and distance.
|
static double |
Distance.segmentToSegment(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance from a line segment AB to a line segment CD
Note: NON-ROBUST!
|
static double |
CGAlgorithms.signedArea(Coordinate[] ring)
Deprecated.
Use
Area.ofRing(Coordinate[]) or
Area.ofRingSigned(Coordinate[]) instead. |
Constructor and Description |
---|
ConvexHull(Coordinate[] pts,
GeometryFactory geomFactory)
Create a new convex hull construction for the input
Coordinate array. |
HCoordinate(Coordinate p) |
HCoordinate(Coordinate p1,
Coordinate p2)
Constructs a homogeneous coordinate which is the intersection of the lines
define by the homogenous coordinates represented by two
Coordinate s. |
HCoordinate(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
RayCrossingCounter(Coordinate p) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
PointPairDistance.getCoordinate(int i)
Gets one of the paired points
|
Coordinate[] |
PointPairDistance.getCoordinates()
Gets the paired points
|
Coordinate[] |
DiscreteFrechetDistance.getCoordinates()
Gets the pair of
Coordinate s at which the distance is obtained. |
Coordinate[] |
DiscreteHausdorffDistance.getCoordinates() |
Modifier and Type | Method and Description |
---|---|
static void |
DistanceToPoint.computeDistance(Geometry geom,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPoint.computeDistance(LineSegment segment,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPoint.computeDistance(LineString line,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPoint.computeDistance(Polygon poly,
Coordinate pt,
PointPairDistance ptDist) |
void |
DiscreteHausdorffDistance.MaxPointDistanceFilter.filter(Coordinate pt) |
void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1)
Initializes the points, computing the distance between them.
|
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1) |
Modifier and Type | Method and Description |
---|---|
static boolean |
SimplePointInAreaLocator.containsPointInPolygon(Coordinate p,
Polygon poly)
Determines whether a point lies in a
Polygon . |
static boolean |
SimplePointInAreaLocator.isContained(Coordinate p,
Geometry geom)
Determines whether a point is contained in a
Geometry ,
or lies on its boundary. |
int |
SimplePointInAreaLocator.locate(Coordinate p)
|
int |
IndexedPointInAreaLocator.locate(Coordinate p)
|
int |
PointOnGeometryLocator.locate(Coordinate p)
|
static int |
SimplePointInAreaLocator.locate(Coordinate p,
Geometry geom)
|
static int |
SimplePointInAreaLocator.locatePointInPolygon(Coordinate p,
Polygon poly)
|
Modifier and Type | Method and Description |
---|---|
void |
IdentityPointTransformation.transform(Coordinate model,
Point2D view) |
void |
PointTransformation.transform(Coordinate src,
Point2D dest)
Transforms a
Coordinate into a Java2D Point . |
Constructor and Description |
---|
PolygonShape(Coordinate[] shellVertices,
Collection holeVerticesCollection)
Creates a new polygon
Shape . |
Modifier and Type | Method and Description |
---|---|
Coordinate |
HalfEdge.dest()
Gets the destination coordinate of this edge.
|
Coordinate |
HalfEdge.orig()
Gets the origin coordinate of this edge.
|
Modifier and Type | Method and Description |
---|---|
HalfEdge |
EdgeGraph.addEdge(Coordinate orig,
Coordinate dest)
Adds an edge between the coordinates orig and dest
to this graph.
|
static HalfEdge |
HalfEdge.create(Coordinate p0,
Coordinate p1)
Creates a HalfEdge pair representing an edge
between two vertices located at coordinates p0 and p1.
|
boolean |
HalfEdge.equals(Coordinate p0,
Coordinate p1)
Tests whether this edge has the given orig and dest vertices.
|
HalfEdge |
HalfEdge.find(Coordinate dest)
Finds the edge starting at the origin of this edge
with the given dest vertex,
if any.
|
HalfEdge |
EdgeGraph.findEdge(Coordinate orig,
Coordinate dest)
Finds an edge in this graph with the given origin
and destination, if one exists.
|
static boolean |
EdgeGraph.isValidEdge(Coordinate orig,
Coordinate dest)
Tests if the given coordinates form a valid edge (with non-zero length).
|
Constructor and Description |
---|
HalfEdge(Coordinate orig)
Creates a half-edge originating from a given coordinate.
|
MarkHalfEdge(Coordinate orig)
Creates a new marked edge.
|
Modifier and Type | Class and Description |
---|---|
class |
CoordinateXY
Coordinate subclass supporting XY ordinates.
|
class |
CoordinateXYM
Coordinate subclass supporting XYM ordinates.
|
class |
CoordinateXYZM
Coordinate subclass supporting XYZM ordinates.
|
Modifier and Type | Field and Description |
---|---|
Coordinate |
Triangle.p0
The coordinates of the vertices of the triangle
|
Coordinate |
LineSegment.p0 |
Coordinate |
Triangle.p1
The coordinates of the vertices of the triangle
|
Coordinate |
LineSegment.p1 |
Coordinate |
Triangle.p2
The coordinates of the vertices of the triangle
|
Modifier and Type | Method and Description |
---|---|
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment
AC.
|
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the
given amount, or an empty coordinate array.
|
Coordinate |
Envelope.centre()
Computes the coordinate of the centre of this envelope (as long as it is non-null
|
Coordinate |
Triangle.centroid()
Computes the centroid (centre of mass) of this triangle.
|
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle.
|
Coordinate |
Triangle.circumcentre()
Computes the circumcentre of this triangle.
|
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
static Coordinate |
Triangle.circumcentreDD(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point.
|
Coordinate[] |
LineSegment.closestPoints(LineSegment line)
Computes the closest points on two line segments.
|
Coordinate |
Coordinate.copy()
Creates a copy of this Coordinate.
|
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument
Coordinate array. |
Coordinate |
CoordinateXY.create()
Create a new Coordinate of the same type as this Coordinate, but with no values.
|
Coordinate |
Coordinate.create()
Create a new Coordinate of the same type as this Coordinate, but with no values.
|
Coordinate |
CoordinateXYM.create()
Create a new Coordinate of the same type as this Coordinate, but with no values.
|
Coordinate |
CoordinateXYZM.create()
Create a new Coordinate of the same type as this Coordinate, but with no values.
|
static Coordinate |
Coordinates.create(int dimension)
Factory method providing access to common Coordinate implementations.
|
static Coordinate |
Coordinates.create(int dimension,
int measures)
Factory method providing access to common Coordinate implementations.
|
default Coordinate |
CoordinateSequence.createCoordinate()
Creates a coordinate for use in this sequence.
|
static Coordinate[] |
CoordinateArrays.enforceConsistency(Coordinate[] array,
int dimension,
int measures)
Utility method ensuring array contents are of the specified dimension and measures.
|
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
|
abstract Coordinate |
Geometry.getCoordinate()
Returns a vertex of this
Geometry
(usually, but not necessarily, the first one). |
Coordinate |
LineString.getCoordinate() |
Coordinate |
TopologyException.getCoordinate() |
Coordinate |
GeometryCollection.getCoordinate() |
Coordinate |
Point.getCoordinate() |
Coordinate |
Polygon.getCoordinate() |
Coordinate |
CoordinateList.getCoordinate(int i) |
Coordinate |
CoordinateSequence.getCoordinate(int i)
Returns (possibly a copy of) the i'th coordinate in this sequence.
|
Coordinate |
LineSegment.getCoordinate(int i) |
Coordinate |
CoordinateSequence.getCoordinateCopy(int i)
Returns a copy of the i'th coordinate in this sequence.
|
Coordinate |
LineString.getCoordinateN(int n) |
abstract Coordinate[] |
Geometry.getCoordinates()
Returns an array containing the values of all the vertices for
this geometry.
|
Coordinate[] |
LineString.getCoordinates() |
Coordinate[] |
GeometryCollection.getCoordinates()
Collects all coordinates of all subgeometries into an Array.
|
Coordinate[] |
Point.getCoordinates() |
Coordinate[] |
Polygon.getCoordinates() |
Coordinate |
Triangle.inCentre()
Computes the incentre of this triangle.
|
static Coordinate |
Triangle.inCentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the incentre of a triangle.
|
static Coordinate[] |
CoordinateArrays.intersection(Coordinate[] coordinates,
Envelope env)
Extracts the coordinates which intersect an
Envelope . |
Coordinate |
LineSegment.intersection(LineSegment line)
Computes an intersection point between two line segments, if there is one.
|
Coordinate |
LineSegment.lineIntersection(LineSegment line)
Computes the intersection point of the lines of infinite extent defined
by two line segments (if there is one).
|
Coordinate |
LineSegment.midPoint()
Computes the midpoint of the segment
|
static Coordinate |
LineSegment.midPoint(Coordinate p0,
Coordinate p1)
Computes the midpoint of a segment
|
static Coordinate |
CoordinateArrays.minCoordinate(Coordinate[] coordinates)
Returns the minimum coordinate, using the usual lexicographic comparison.
|
static Coordinate |
CoordinateSequences.minCoordinate(CoordinateSequence seq)
Returns the minimum coordinate, using the usual lexicographic comparison.
|
Coordinate |
LineSegment.pointAlong(double segmentLengthFraction)
Computes the
Coordinate that lies a given
fraction along the line defined by this segment. |
Coordinate |
LineSegment.pointAlongOffset(double segmentLengthFraction,
double offsetDistance)
Computes the
Coordinate that lies a given
fraction along the line defined by this segment and offset from
the segment by a given distance. |
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined
by this line segment.
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
Coordinate |
LineSegment.reflect(Coordinate p)
Computes the reflection of a point in the line defined
by this line segment.
|
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedOrInvalidPoints(Coordinate[] coord)
If the coordinate array argument has repeated or invalid points,
constructs a new array containing no repeated points.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points,
constructs a new array containing no repeated points.
|
Coordinate[] |
CoordinateList.toCoordinateArray()
Returns the Coordinates in this collection.
|
Coordinate[] |
CoordinateSequence.toCoordinateArray()
Returns (possibly copies of) the Coordinates in this collection.
|
Coordinate[] |
CoordinateList.toCoordinateArray(boolean isForward)
Creates an array containing the coordinates in this list,
oriented in the given direction (forward or reverse).
|
static Coordinate[] |
CoordinateArrays.toCoordinateArray(Collection coordList)
Converts the given Collection of Coordinates into a Coordinate array.
|
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated.
no longer needed, since internal representation is same as external representation
|
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated.
use makePrecise instead
|
Modifier and Type | Method and Description |
---|---|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated)
Adds an array of coordinates to the list.
|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated,
boolean direction)
Adds an array of coordinates to the list.
|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated,
int start,
int end)
Adds a section of an array of coordinates to the list.
|
void |
CoordinateList.add(Coordinate coord,
boolean allowRepeated)
Adds a coordinate to the end of the list.
|
void |
CoordinateList.add(int i,
Coordinate coord,
boolean allowRepeated)
Inserts the specified coordinate at the specified position in this list.
|
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment
AC.
|
static double |
Triangle.area(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 2D area of a triangle.
|
static double |
Triangle.area3D(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 3D area of a triangle.
|
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the
given amount, or an empty coordinate array.
|
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle.
|
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
static Coordinate |
Triangle.circumcentreDD(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point.
|
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two
Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two
Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
int |
Coordinate.DimensionalComparator.compare(Coordinate c1,
Coordinate c2)
Compares two
Coordinate s along to the number of
dimensions specified. |
int |
Coordinate.compareTo(Coordinate o)
Compares this
Coordinate with the specified Coordinate for order. |
boolean |
Envelope.contains(Coordinate p)
Tests if the given point lies in or on the envelope.
|
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument
Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source
Coordinate array
into a destination Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source
Coordinate array
into a destination Coordinate array. |
boolean |
Envelope.covers(Coordinate p)
Tests if the given point lies in or on the envelope.
|
CoordinateSequence |
CoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns a
CoordinateSequence based on the given array. |
LinearRing |
GeometryFactory.createLinearRing(Coordinate[] coordinates)
Creates a
LinearRing using the given Coordinate s. |
LineString |
GeometryFactory.createLineString(Coordinate[] coordinates)
Creates a LineString using the given Coordinates.
|
MultiPoint |
GeometryFactory.createMultiPoint(Coordinate[] coordinates)
Deprecated.
|
MultiPoint |
GeometryFactory.createMultiPointFromCoords(Coordinate[] coordinates)
Creates a
MultiPoint using the given Coordinate s. |
Point |
GeometryFactory.createPoint(Coordinate coordinate)
Creates a Point using the given Coordinate.
|
static Point |
GeometryFactory.createPointFromInternalCoord(Coordinate coord,
Geometry exemplar) |
Polygon |
GeometryFactory.createPolygon(Coordinate[] shell)
Constructs a
Polygon with the given exterior boundary. |
static int |
Coordinates.dimension(Coordinate coordinate)
Determine dimension based on subclass of
Coordinate . |
static int |
CoordinateArrays.dimension(Coordinate[] pts)
Determine dimension based on subclass of
Coordinate . |
double |
Coordinate.distance(Coordinate c)
Computes the 2-dimensional Euclidean distance to another location.
|
double |
LineSegment.distance(Coordinate p)
Computes the distance between this line segment and a given point.
|
double |
Coordinate.distance3D(Coordinate c)
Computes the 3-dimensional Euclidean distance to another location.
|
double |
LineSegment.distancePerpendicular(Coordinate p)
Computes the perpendicular distance between the (infinite) line defined
by this line segment and a point.
|
static void |
CoordinateArrays.enforceConsistency(Coordinate[] array)
Utility method ensuring array contents are of consistent dimension and measures.
|
static Coordinate[] |
CoordinateArrays.enforceConsistency(Coordinate[] array,
int dimension,
int measures)
Utility method ensuring array contents are of the specified dimension and measures.
|
static Envelope |
CoordinateArrays.envelope(Coordinate[] coordinates)
Computes the envelope of the coordinates.
|
boolean |
Coordinate.equalInZ(Coordinate c,
double tolerance)
Tests if another coordinate has the same value for Z, within a tolerance.
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise
equal (as compared using Coordinate#equals)
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise
equal (as compared using Coordinate#equals)
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2,
Comparator coordinateComparator)
Returns true if the two arrays are identical, both null, or pointwise
equal, using a user-defined
Comparator for Coordinate s |
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2,
Comparator coordinateComparator)
Returns true if the two arrays are identical, both null, or pointwise
equal, using a user-defined
Comparator for Coordinate s |
boolean |
Coordinate.equals2D(Coordinate other)
Returns whether the planar projections of the two
Coordinate s
are equal. |
boolean |
Coordinate.equals2D(Coordinate c,
double tolerance)
Tests if another Coordinate has the same values for the X and Y ordinates,
within a specified tolerance value.
|
boolean |
Coordinate.equals3D(Coordinate other)
Tests if another coordinate has the same values for the X, Y and Z ordinates.
|
OctagonalEnvelope |
OctagonalEnvelope.expandToInclude(Coordinate p) |
void |
Envelope.expandToInclude(Coordinate p)
Enlarges this
Envelope so that it contains
the given Coordinate . |
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
|
void |
CoordinateFilter.filter(Coordinate coord)
Performs an operation with the provided
coord . |
void |
CoordinateSequence.getCoordinate(int index,
Coordinate coord)
Copies the i'th coordinate in the sequence to the supplied
Coordinate . |
static boolean |
CoordinateArrays.hasRepeatedOrInvalidPoints(Coordinate[] coord)
Tests whether an array has any repeated or invalid coordinates.
|
static boolean |
CoordinateArrays.hasRepeatedPoints(Coordinate[] coord)
Tests whether
equals(Object) returns true for any two consecutive Coordinates
in the given array. |
static Coordinate |
Triangle.inCentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the incentre of a triangle.
|
static int |
CoordinateArrays.increasingDirection(Coordinate[] pts)
Determines which orientation of the
Coordinate array
is (overall) increasing. |
static int |
CoordinateArrays.indexOf(Coordinate coordinate,
Coordinate[] coordinates)
Returns the index of
coordinate in coordinates . |
static int |
CoordinateArrays.indexOf(Coordinate coordinate,
Coordinate[] coordinates)
Returns the index of
coordinate in coordinates . |
static int |
CoordinateSequences.indexOf(Coordinate coordinate,
CoordinateSequence seq)
Returns the index of
coordinate in a CoordinateSequence
The first position is 0; the second, 1; etc. |
void |
Envelope.init(Coordinate p)
Initialize an
Envelope to a region defined by a single Coordinate. |
void |
Envelope.init(Coordinate p1,
Coordinate p2)
Initialize an
Envelope to a region defined by two Coordinates. |
double |
Triangle.interpolateZ(Coordinate p)
Computes the Z-value (elevation) of an XY point on a three-dimensional
plane defined by this triangle (whose vertices must have Z-values).
|
static double |
Triangle.interpolateZ(Coordinate p,
Coordinate v0,
Coordinate v1,
Coordinate v2)
Computes the Z-value (elevation) of an XY point on a three-dimensional
plane defined by a triangle whose vertices have Z-values.
|
static Coordinate[] |
CoordinateArrays.intersection(Coordinate[] coordinates,
Envelope env)
Extracts the coordinates which intersect an
Envelope . |
boolean |
OctagonalEnvelope.intersects(Coordinate p) |
boolean |
Envelope.intersects(Coordinate p)
Tests if the point
p
intersects (lies inside) the region of this Envelope . |
boolean |
Envelope.intersects(Coordinate a,
Coordinate b)
Tests if the extent defined by two extremal points
intersects the extent of this
Envelope . |
static boolean |
Envelope.intersects(Coordinate p1,
Coordinate p2,
Coordinate q)
Test the point q to see whether it intersects the Envelope defined by p1-p2
|
static boolean |
Triangle.intersects(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests whether a triangle intersects a point.
|
static boolean |
Envelope.intersects(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Tests whether the envelope defined by p1-p2
and the envelope defined by q1-q2
intersect.
|
static boolean |
Triangle.isAcute(Coordinate a,
Coordinate b,
Coordinate c)
Tests whether a triangle is acute.
|
static boolean |
Triangle.isCCW(Coordinate a,
Coordinate b,
Coordinate c)
Tests whether a triangle is oriented counter-clockwise.
|
boolean |
LineString.isCoordinate(Coordinate pt)
Returns true if the given point is a vertex of this
LineString . |
static boolean |
CoordinateArrays.isRing(Coordinate[] pts)
Tests whether an array of
Coordinate s forms a ring,
by checking length and closure. |
static double |
Triangle.length(Coordinate a,
Coordinate b,
Coordinate c)
Compute the length of the perimeter of a triangle
|
static double |
Triangle.longestSideLength(Coordinate a,
Coordinate b,
Coordinate c)
Computes the length of the longest side of a triangle
|
void |
PrecisionModel.makePrecise(Coordinate coord)
Rounds a Coordinate to the PrecisionModel grid.
|
static int |
Coordinates.measures(Coordinate coordinate)
Determine number of measures based on subclass of
Coordinate . |
static int |
CoordinateArrays.measures(Coordinate[] pts)
Determine number of measures based on subclass of
Coordinate . |
static Coordinate |
LineSegment.midPoint(Coordinate p0,
Coordinate p1)
Computes the midpoint of a segment
|
static Coordinate |
CoordinateArrays.minCoordinate(Coordinate[] coordinates)
Returns the minimum coordinate, using the usual lexicographic comparison.
|
int |
LineSegment.orientationIndex(Coordinate p)
Determines the orientation index of a
Coordinate relative to this segment. |
boolean |
Envelope.overlaps(Coordinate p)
Deprecated.
Use #intersects instead.
|
static HCoordinate |
Triangle.perpendicularBisector(Coordinate a,
Coordinate b)
Computes the line which is the perpendicular bisector of the line segment
a-b.
|
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined
by this line segment.
|
double |
LineSegment.projectionFactor(Coordinate p)
Computes the Projection Factor for the projection of the point p
onto this LineSegment.
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static int |
Quadrant.quadrant(Coordinate p0,
Coordinate p1)
Returns the quadrant of a directed line segment from p0 to p1.
|
Coordinate |
LineSegment.reflect(Coordinate p)
Computes the reflection of a point in the line defined
by this line segment.
|
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedOrInvalidPoints(Coordinate[] coord)
If the coordinate array argument has repeated or invalid points,
constructs a new array containing no repeated points.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points,
constructs a new array containing no repeated points.
|
static void |
CoordinateArrays.reverse(Coordinate[] coord)
Reverses the coordinates in an array in-place.
|
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
int indexOfFirstCoordinate)
Shifts the positions of the coordinates until the coordinate
at
firstCoordinate is first. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
int indexOfFirstCoordinate,
boolean ensureRing)
Shifts the positions of the coordinates until the coordinate
at
indexOfFirstCoordinate is first. |
static void |
CoordinateSequences.scroll(CoordinateSequence seq,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
double |
LineSegment.segmentFraction(Coordinate inputPt)
Computes the fraction of distance (in [0.0, 1.0])
that the projection of a point occurs along this line segment.
|
void |
CoordinateXY.setCoordinate(Coordinate other) |
void |
Coordinate.setCoordinate(Coordinate other)
Sets this
Coordinate s (x,y,z) values to that of other . |
void |
CoordinateXYM.setCoordinate(Coordinate other) |
void |
CoordinateXYZM.setCoordinate(Coordinate other) |
void |
LineSegment.setCoordinates(Coordinate p0,
Coordinate p1) |
static double |
Triangle.signedArea(Coordinate a,
Coordinate b,
Coordinate c)
Computes the signed 2D area of a triangle.
|
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated.
no longer needed, since internal representation is same as external representation
|
void |
PrecisionModel.toExternal(Coordinate internal,
Coordinate external)
Deprecated.
no longer needed, since internal representation is same as external representation
|
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated.
use makePrecise instead
|
void |
PrecisionModel.toInternal(Coordinate external,
Coordinate internal)
Deprecated.
use makePrecise instead
|
Modifier and Type | Method and Description |
---|---|
boolean |
CoordinateList.addAll(Collection<? extends Coordinate> coll,
boolean allowRepeated)
Add an array of coordinates
|
Constructor and Description |
---|
Coordinate(Coordinate c)
Constructs a
Coordinate having the same (x,y,z) values as
other . |
CoordinateList(Coordinate[] coord)
Constructs a new list from an array of Coordinates, allowing repeated points.
|
CoordinateList(Coordinate[] coord,
boolean allowRepeated)
Constructs a new list from an array of Coordinates,
allowing caller to specify if repeated points are to be removed.
|
CoordinateXY(Coordinate coord)
Constructs a CoordinateXY instance with the x and y ordinates of the given Coordinate.
|
CoordinateXYM(Coordinate coord)
Constructs a CoordinateXYM instance with the x and y ordinates of the given Coordinate.
|
CoordinateXYZM(Coordinate coord)
Constructs a CoordinateXYZM instance with the ordinates of the given Coordinate.
|
Envelope(Coordinate p)
Creates an
Envelope for a region defined by a single Coordinate. |
Envelope(Coordinate p1,
Coordinate p2)
Creates an
Envelope for a region defined by two Coordinates. |
LinearRing(Coordinate[] points,
PrecisionModel precisionModel,
int SRID)
Deprecated.
Use GeometryFactory instead
|
LineSegment(Coordinate p0,
Coordinate p1) |
LineString(Coordinate[] points,
PrecisionModel precisionModel,
int SRID)
Deprecated.
Use GeometryFactory instead
|
OctagonalEnvelope(Coordinate p)
Creates a new null bounding octagon bounding a
Coordinate |
OctagonalEnvelope(Coordinate p0,
Coordinate p1)
Creates a new null bounding octagon bounding a pair of
Coordinate s |
Point(Coordinate coordinate,
PrecisionModel precisionModel,
int SRID)
Deprecated.
Use GeometryFactory instead
|
TopologyException(String msg,
Coordinate pt) |
Triangle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Creates a new triangle with the given vertices.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
CoordinateArraySequence.getCoordinate(int i)
Get the Coordinate with index i.
|
Coordinate |
PackedCoordinateSequence.getCoordinate(int i) |
Coordinate |
CoordinateArraySequence.getCoordinateCopy(int i)
Get a copy of the Coordinate with index i.
|
Coordinate |
PackedCoordinateSequence.getCoordinateCopy(int i) |
Coordinate |
PackedCoordinateSequence.Double.getCoordinateInternal(int i) |
Coordinate |
PackedCoordinateSequence.Float.getCoordinateInternal(int i) |
Coordinate[] |
CoordinateArraySequence.toCoordinateArray()
This method exposes the internal Array of Coordinate Objects
|
Coordinate[] |
PackedCoordinateSequence.toCoordinateArray() |
Modifier and Type | Method and Description |
---|---|
CoordinateSequence |
CoordinateArraySequenceFactory.create(Coordinate[] coordinates)
Returns a
CoordinateArraySequence based on the given array (the array is
not copied). |
CoordinateSequence |
PackedCoordinateSequenceFactory.create(Coordinate[] coordinates) |
void |
CoordinateArraySequence.getCoordinate(int index,
Coordinate coord) |
void |
PackedCoordinateSequence.getCoordinate(int i,
Coordinate coord) |
Constructor and Description |
---|
CoordinateArraySequence(Coordinate[] coordinates)
Constructs a sequence based on the given array
of
Coordinate s (the
array is not copied). |
CoordinateArraySequence(Coordinate[] coordinates,
int dimension)
Constructs a sequence based on the given array
of
Coordinate s (the
array is not copied). |
CoordinateArraySequence(Coordinate[] coordinates,
int dimension,
int measures)
Constructs a sequence based on the given array
of
Coordinate s (the array is not copied). |
Double(Coordinate[] coordinates)
Builds a new packed coordinate sequence out of a coordinate array
|
Double(Coordinate[] coordinates,
int dimension)
Builds a new packed coordinate sequence out of a coordinate array
|
Double(Coordinate[] coordinates,
int dimension,
int measures)
Builds a new packed coordinate sequence out of a coordinate array
|
Float(Coordinate[] coordinates,
int dimension)
Builds a new packed coordinate sequence out of a coordinate array
|
Float(Coordinate[] coordinates,
int dimension,
int measures)
Constructs a packed coordinate sequence out of a coordinate array
|
Modifier and Type | Method and Description |
---|---|
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of
Coordinate s from a Geometry . |
Coordinate |
AffineTransformation.transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate
and places the results in the dest coordinate
(which may be the same as the source).
|
Modifier and Type | Method and Description |
---|---|
static Geometry |
SineStarFactory.create(Coordinate origin,
double size,
int nPts,
int nArms,
double armLengthRatio)
Creates a sine star with the given parameters.
|
static AffineTransformation |
AffineTransformationFactory.createFromBaseLines(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a mapping between two baselines.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate[] src,
Coordinate[] dest)
Creates an AffineTransformation defined by a set of control vectors.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate[] src,
Coordinate[] dest)
Creates an AffineTransformation defined by a set of control vectors.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate dest0)
Creates an AffineTransformation defined by a single control vector.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a pair of control vectors.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Creates a transformation from a set of three control vectors.
|
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of
Coordinate s from a Geometry . |
Coordinate |
AffineTransformation.transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate
and places the results in the dest coordinate
(which may be the same as the source).
|
Constructor and Description |
---|
AffineTransformation(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Constructs a transformation
which maps the given source
points into the given destination points.
|
AffineTransformationBuilder(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Constructs a new builder for
the transformation defined by the given
set of control point mappings.
|
Modifier and Type | Field and Description |
---|---|
Coordinate |
EdgeIntersection.coord
Point of intersection
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
GeometryGraph.getBoundaryPoints() |
Coordinate |
Edge.getCoordinate() |
Coordinate |
EdgeEnd.getCoordinate() |
abstract Coordinate |
GraphComponent.getCoordinate() |
Coordinate |
EdgeEndStar.getCoordinate() |
Coordinate |
EdgeIntersection.getCoordinate() |
Coordinate |
Node.getCoordinate() |
Coordinate |
Edge.getCoordinate(int i) |
Coordinate |
EdgeRing.getCoordinate(int i) |
Coordinate[] |
Edge.getCoordinates() |
Coordinate |
EdgeEnd.getDirectedCoordinate() |
Coordinate |
GeometryGraph.getInvalidPoint() |
Modifier and Type | Method and Description |
---|---|
EdgeIntersection |
EdgeIntersectionList.add(Coordinate intPt,
int segmentIndex,
double dist)
Adds an intersection into the list, if it isn't already there.
|
Node |
PlanarGraph.addNode(Coordinate coord) |
Node |
NodeMap.addNode(Coordinate coord)
This method expects that a node has a coordinate value.
|
void |
GeometryGraph.addPoint(Coordinate pt)
Add a point computed externally.
|
boolean |
EdgeRing.containsPoint(Coordinate p)
This method will cause the ring to be computed.
|
Node |
NodeFactory.createNode(Coordinate coord)
The basic node constructor does not allow for incident edges
|
Node |
PlanarGraph.find(Coordinate coord)
Find coordinate.
|
Node |
NodeMap.find(Coordinate coord)
Find coordinate.
|
Edge |
PlanarGraph.findEdge(Coordinate p0,
Coordinate p1)
Returns the edge whose first two coordinates are p0 and p1
|
Edge |
PlanarGraph.findEdgeInSameDirection(Coordinate p0,
Coordinate p1)
Returns the edge which starts at p0 and whose first segment is
parallel to p1
|
boolean |
PlanarGraph.isBoundaryNode(int geomIndex,
Coordinate coord) |
boolean |
EdgeIntersectionList.isIntersection(Coordinate pt)
Tests if the given point is an edge intersection
|
int |
GeometryGraph.locate(Coordinate pt)
Determines the
Location of the given Coordinate
in this geometry. |
Constructor and Description |
---|
Edge(Coordinate[] pts) |
Edge(Coordinate[] pts,
Label label) |
EdgeEnd(Edge edge,
Coordinate p0,
Coordinate p1) |
EdgeEnd(Edge edge,
Coordinate p0,
Coordinate p1,
Label label) |
EdgeIntersection(Coordinate coord,
int segmentIndex,
double dist)
EdgeIntersection.
|
Node(Coordinate coord,
EdgeEndStar edges) |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
MonotoneChainEdge.getCoordinates() |
Coordinate |
SegmentIntersector.getProperIntersectionPoint() |
Modifier and Type | Method and Description |
---|---|
int[] |
MonotoneChainIndexer.getChainStartIndices(Coordinate[] pts) |
int[] |
MonotoneChainIndexer.OLDgetChainStartIndices(Coordinate[] pts) |
Constructor and Description |
---|
VertexSequencePackedRtree(Coordinate[] pts)
Creates a new tree over the given sequence of coordinates.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
MonotoneChain.getCoordinates()
Return the subsequence of coordinates forming this chain.
|
Modifier and Type | Method and Description |
---|---|
static List |
MonotoneChainBuilder.getChains(Coordinate[] pts)
Computes a list of the
MonotoneChain s
for a list of coordinates. |
static List |
MonotoneChainBuilder.getChains(Coordinate[] pts,
Object context)
Computes a list of the
MonotoneChain s
for a list of coordinates,
attaching a context data object to each. |
Constructor and Description |
---|
MonotoneChain(Coordinate[] pts,
int start,
int end,
Object context)
Creates a new MonotoneChain based on the given array of points.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
KdNode.getCoordinate()
Returns the location of this node
|
static Coordinate[] |
KdTree.toCoordinates(Collection kdnodes)
Converts a collection of
KdNode s to an array of Coordinate s. |
static Coordinate[] |
KdTree.toCoordinates(Collection kdnodes,
boolean includeRepeated)
Converts a collection of
KdNode s
to an array of Coordinate s,
specifying whether repeated nodes should be represented
by multiple coordinates. |
Modifier and Type | Method and Description |
---|---|
KdNode |
KdTree.insert(Coordinate p)
Inserts a new point in the kd-tree, with no data.
|
KdNode |
KdTree.insert(Coordinate p,
Object data)
Inserts a new point into the kd-tree.
|
KdNode |
KdTree.query(Coordinate queryPt)
Searches for a given point in the index and returns its node if found.
|
Constructor and Description |
---|
KdNode(Coordinate p,
Object data)
Creates a new KdNode.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
Key.getCentre() |
Coordinate |
Key.getPoint() |
Modifier and Type | Method and Description |
---|---|
static String |
WKTWriter.format(Coordinate p) |
static String |
WKTWriter.toLineString(Coordinate[] coord)
Generates the WKT for a LINESTRING
specified by a
CoordinateSequence . |
static String |
WKTWriter.toLineString(Coordinate p0,
Coordinate p1)
Generates the WKT for a LINESTRING
specified by two
Coordinate s. |
static String |
WKTWriter.toPoint(Coordinate p0)
Generates the WKT for a POINT
specified by a
Coordinate . |
Modifier and Type | Method and Description |
---|---|
Coordinate |
LengthIndexedLine.extractPoint(double index)
Computes the
Coordinate for the point
on the line at the given index. |
Coordinate |
LengthIndexedLine.extractPoint(double index,
double offsetDistance)
Computes the
Coordinate for the point
on the line at the given index, offset by the given distance. |
Coordinate |
LocationIndexedLine.extractPoint(LinearLocation index)
Computes the
Coordinate for the point
on the line at the given index. |
Coordinate |
LocationIndexedLine.extractPoint(LinearLocation index,
double offsetDistance)
Computes the
Coordinate for the point
on the line at the given index, offset by the given distance. |
Coordinate |
LinearLocation.getCoordinate(Geometry linearGeom)
Gets the
Coordinate along the
given linear Geometry which is
referenced by this location. |
Coordinate |
LinearGeometryBuilder.getLastCoordinate() |
Coordinate |
LinearIterator.getSegmentEnd()
Gets the second
Coordinate of the current segment. |
Coordinate |
LinearIterator.getSegmentStart()
Gets the first
Coordinate of the current segment. |
static Coordinate |
LinearLocation.pointAlongSegmentByFraction(Coordinate p0,
Coordinate p1,
double frac)
Computes the
Coordinate of a point a given fraction
along the line segment (p0, p1). |
Modifier and Type | Method and Description |
---|---|
void |
LinearGeometryBuilder.add(Coordinate pt)
Adds a point to the current line.
|
void |
LinearGeometryBuilder.add(Coordinate pt,
boolean allowRepeatedPoints)
Adds a point to the current line.
|
LinearLocation |
LocationIndexedLine.indexOf(Coordinate pt)
Computes the index for a given point on the line.
|
double |
LengthIndexedLine.indexOf(Coordinate pt)
Computes the minimum index for a point on the line.
|
double |
LengthIndexedLine.indexOfAfter(Coordinate pt,
double minIndex)
Finds the index for a point on the line
which is greater than the given index.
|
LinearLocation |
LocationIndexedLine.indexOfAfter(Coordinate pt,
LinearLocation minIndex)
Finds the index for a point on the line
which is greater than the given index.
|
static Coordinate |
LinearLocation.pointAlongSegmentByFraction(Coordinate p0,
Coordinate p1,
double frac)
Computes the
Coordinate of a point a given fraction
along the line segment (p0, p1). |
LinearLocation |
LocationIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point.
|
double |
LengthIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point.
|
Modifier and Type | Method and Description |
---|---|
static Coordinate |
Vector3D.normalize(Coordinate v)
Computes a vector having identical direction
but normalized to have length 1.
|
Coordinate |
Vector2D.toCoordinate() |
Coordinate |
Vector2D.translate(Coordinate coord) |
Modifier and Type | Method and Description |
---|---|
static Vector3D |
Vector3D.create(Coordinate coord)
Creates a vector from a 3D
Coordinate . |
static Vector2D |
Vector2D.create(Coordinate coord)
Creates a vector from a
Coordinate . |
static Vector2D |
Vector2D.create(Coordinate from,
Coordinate to)
Creates a vector with the direction and magnitude
of the difference between the
to and from
Coordinate s. |
static double |
Vector3D.dot(Coordinate v1,
Coordinate v2)
Computes the 3D dot-product of two
Coordinate s. |
static double |
Vector3D.dot(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the dot product of the 3D vectors AB and CD.
|
static double |
Vector3D.length(Coordinate v)
Computes the length of a vector.
|
static Coordinate |
Vector3D.normalize(Coordinate v)
Computes a vector having identical direction
but normalized to have length 1.
|
double |
Plane3D.orientedDistance(Coordinate p)
Computes the oriented distance from a point to the plane.
|
Coordinate |
Vector2D.translate(Coordinate coord) |
Constructor and Description |
---|
Plane3D(Vector3D normal,
Coordinate basePt) |
Vector2D(Coordinate v) |
Vector2D(Coordinate from,
Coordinate to) |
Vector3D(Coordinate v)
Creates a new 3D vector from a
Coordinate . |
Vector3D(Coordinate from,
Coordinate to)
Creates a new vector with the direction and magnitude
of the difference between the
to and from
Coordinate s. |
Modifier and Type | Field and Description |
---|---|
Coordinate |
SegmentNode.coord |
Modifier and Type | Method and Description |
---|---|
Coordinate |
SegmentNode.getCoordinate()
Gets the
Coordinate giving the location of this node. |
Coordinate |
SegmentString.getCoordinate(int i) |
Coordinate |
BasicSegmentString.getCoordinate(int i) |
Coordinate |
NodedSegmentString.getCoordinate(int i) |
Coordinate[] |
SegmentString.getCoordinates() |
Coordinate[] |
BasicSegmentString.getCoordinates() |
Coordinate[] |
NodedSegmentString.getCoordinates() |
Coordinate |
SegmentIntersectionDetector.getIntersection()
Gets the computed location of the intersection.
|
Coordinate |
NodingIntersectionFinder.getIntersection()
Gets the computed location of the intersection.
|
Coordinate[] |
SegmentIntersectionDetector.getIntersectionSegments()
Gets the endpoints of the intersecting segments.
|
Coordinate[] |
NodingIntersectionFinder.getIntersectionSegments()
Gets the endpoints of the intersecting segments.
|
Coordinate[] |
NodedSegmentString.getNodedCoordinates()
Gets a list of coordinates with all nodes included.
|
Coordinate |
IntersectionAdder.getProperIntersectionPoint() |
Coordinate[] |
SegmentNodeList.getSplitCoordinates()
Gets the list of coordinates for the fully noded segment string,
including all original segment string vertices and vertices
introduced by nodes in this list.
|
Modifier and Type | Method and Description |
---|---|
SegmentNode |
SegmentNodeList.add(Coordinate intPt,
int segmentIndex)
Adds an intersection into the list, if it isn't already there.
|
void |
NodedSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
void |
NodableSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
SegmentNode |
NodedSegmentString.addIntersectionNode(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
static int |
SegmentPointComparator.compare(int octant,
Coordinate p0,
Coordinate p1)
Compares two
Coordinate s for their relative position along a segment
lying in the specified Octant . |
static int |
Octant.octant(Coordinate p0,
Coordinate p1)
Returns the octant of a directed line segment from p0 to p1.
|
Constructor and Description |
---|
BasicSegmentString(Coordinate[] pts,
Object data)
Creates a new segment string from a list of vertices.
|
NodedSegmentString(Coordinate[] pts,
Object data)
Creates a instance from a list of vertices and optional data object.
|
OrientedCoordinateArray(Coordinate[] pts)
Creates a new
OrientedCoordinateArray
for the given Coordinate array. |
SegmentNode(NodedSegmentString segString,
Coordinate coord,
int segmentIndex,
int segmentOctant) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
SnappingPointIndex.snap(Coordinate p)
Snaps a coordinate to an existing snap point,
if it is within the snap tolerance distance.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
SnappingPointIndex.snap(Coordinate p)
Snaps a coordinate to an existing snap point,
if it is within the snap tolerance distance.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
HotPixel.getCoordinate()
Gets the coordinate this hot pixel is based at.
|
Modifier and Type | Method and Description |
---|---|
List<Coordinate> |
SnapRoundingIntersectionAdder.getIntersections()
Gets the created intersection nodes,
so they can be processed as hot pixels.
|
Modifier and Type | Method and Description |
---|---|
boolean |
HotPixel.intersects(Coordinate p)
Tests whether a coordinate lies in (intersects) this hot pixel.
|
boolean |
HotPixel.intersects(Coordinate p0,
Coordinate p1)
Tests whether the line segment (p0-p1)
intersects this hot pixel.
|
Constructor and Description |
---|
HotPixel(Coordinate pt,
double scaleFactor)
Creates a new hot pixel centered on a rounded point, using a given scale factor.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
IsSimpleOp.getNonSimpleLocation()
Deprecated.
Gets a coordinate for the location where the geometry
fails to be simple.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
OffsetCurveBuilder.getLineCurve(Coordinate[] inputPts,
double distance)
This method handles single points as well as LineStrings.
|
Coordinate[] |
OffsetCurveBuilder.getOffsetCurve(Coordinate[] inputPts,
double distance) |
Coordinate[] |
OffsetCurveBuilder.getRingCurve(Coordinate[] inputPts,
int side,
double distance)
This method handles the degenerate cases of single points and lines,
as well as valid rings.
|
static Coordinate[] |
OffsetCurve.rawOffset(LineString geom,
double distance)
Gets the raw offset line, with default buffer parameters.
|
static Coordinate[] |
OffsetCurve.rawOffset(LineString geom,
double distance,
BufferParameters bufParams)
Gets the raw offset line.
|
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list.
|
Coordinate[] |
BufferInputLineSimplifier.simplify(double distanceTol)
Simplify the input coordinate list.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
OffsetCurveBuilder.getLineCurve(Coordinate[] inputPts,
double distance)
This method handles single points as well as LineStrings.
|
Coordinate[] |
OffsetCurveBuilder.getOffsetCurve(Coordinate[] inputPts,
double distance) |
Coordinate[] |
OffsetCurveBuilder.getRingCurve(Coordinate[] inputPts,
int side,
double distance)
This method handles the degenerate cases of single points and lines,
as well as valid rings.
|
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list.
|
Constructor and Description |
---|
BufferInputLineSimplifier(Coordinate[] inputLine) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
PointPairDistance.getCoordinate(int i) |
Coordinate[] |
PointPairDistance.getCoordinates() |
Coordinate |
BufferResultValidator.getErrorLocation() |
Coordinate |
BufferDistanceValidator.getErrorLocation() |
Modifier and Type | Method and Description |
---|---|
static void |
DistanceToPointFinder.computeDistance(Geometry geom,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPointFinder.computeDistance(LineSegment segment,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPointFinder.computeDistance(LineString line,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPointFinder.computeDistance(Polygon poly,
Coordinate pt,
PointPairDistance ptDist) |
void |
BufferCurveMaximumDistanceFinder.MaxPointDistanceFilter.filter(Coordinate pt) |
void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1) |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
DistanceOp.closestPoints()
Deprecated.
renamed to nearestPoints
|
static Coordinate[] |
DistanceOp.closestPoints(Geometry g0,
Geometry g1)
Deprecated.
renamed to nearestPoints
|
Coordinate |
GeometryLocation.getCoordinate()
Returns the
Coordinate of this location. |
Coordinate |
FacetSequence.getCoordinate(int index) |
Coordinate[] |
DistanceOp.nearestPoints()
Report the coordinates of the nearest points in the input geometries.
|
Coordinate[] |
IndexedFacetDistance.nearestPoints(Geometry g)
Compute the nearest locations on the target geometry
and the given geometry.
|
static Coordinate[] |
IndexedFacetDistance.nearestPoints(Geometry g1,
Geometry g2)
Computes the nearest points of the facets of two geometries.
|
static Coordinate[] |
DistanceOp.nearestPoints(Geometry g0,
Geometry g1)
Compute the the nearest points of two geometries.
|
Constructor and Description |
---|
GeometryLocation(Geometry component,
Coordinate pt)
Constructs a GeometryLocation specifying a point inside an area geometry.
|
GeometryLocation(Geometry component,
int segIndex,
Coordinate pt)
Constructs a GeometryLocation specifying a point on a geometry, as well as the
segment that the point is on
(or
GeometryLocation.INSIDE_AREA if the point is not on a segment). |
Modifier and Type | Method and Description |
---|---|
Coordinate |
AxisPlaneCoordinateSequence.getCoordinate(int i) |
Coordinate |
AxisPlaneCoordinateSequence.getCoordinateCopy(int i) |
Coordinate[] |
Distance3DOp.nearestPoints()
Report the coordinates of the nearest points in the input geometries.
|
static Coordinate[] |
Distance3DOp.nearestPoints(Geometry g0,
Geometry g1)
Compute the the nearest points of two geometries.
|
Coordinate[] |
AxisPlaneCoordinateSequence.toCoordinateArray() |
Modifier and Type | Method and Description |
---|---|
void |
AxisPlaneCoordinateSequence.getCoordinate(int index,
Coordinate coord) |
boolean |
PlanarPolygon3D.intersects(Coordinate intPt) |
boolean |
PlanarPolygon3D.intersects(Coordinate pt,
LineString ring) |
Constructor and Description |
---|
LineMergeDirectedEdge(Node from,
Node to,
Coordinate directionPt,
boolean edgeDirection)
Constructs a LineMergeDirectedEdge connecting the
from node to the
to node. |
Modifier and Type | Method and Description |
---|---|
Node |
OverlayNodeFactory.createNode(Coordinate coord) |
boolean |
OverlayOp.isCoveredByA(Coordinate coord)
Tests if an L edge should be included in the result or not.
|
boolean |
OverlayOp.isCoveredByLA(Coordinate coord)
Tests if a point node should be included in the result or not.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString
to the given set of snap vertices.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString
to the given set of snap vertices.
|
Constructor and Description |
---|
LineStringSnapper(Coordinate[] srcPts,
double snapTolerance)
Creates a new snapper using the given points
as source points to be snapped.
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
OverlayResultValidator.getInvalidLocation() |
Modifier and Type | Method and Description |
---|---|
int |
FuzzyPointLocator.getLocation(Coordinate pt) |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
RingClipper.clip(Coordinate[] pts)
Clips a list of points to the clipping rectangle box.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
RingClipper.clip(Coordinate[] pts)
Clips a list of points to the clipping rectangle box.
|
List<Coordinate[]> |
LineLimiter.limit(Coordinate[] pts)
Limits a list of segments.
|
Modifier and Type | Method and Description |
---|---|
Node |
RelateNodeFactory.createNode(Coordinate coord) |
Constructor and Description |
---|
RelateNode(Coordinate coord,
EdgeEndStar edges) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
RepeatedPointTester.getCoordinate() |
Coordinate |
TopologyValidationError.getCoordinate()
Returns the location of this error (on the
Geometry containing the error). |
Coordinate |
IsSimpleOp.getNonSimpleLocation()
Gets the coordinate for an location where the geometry
fails to be simple.
|
static Coordinate |
IsSimpleOp.getNonSimpleLocation(Geometry geom)
Gets a non-simple location in a geometry, if any.
|
Modifier and Type | Method and Description |
---|---|
List<Coordinate> |
IsSimpleOp.getNonSimpleLocations()
Gets all non-simple intersection locations.
|
Modifier and Type | Method and Description |
---|---|
boolean |
RepeatedPointTester.hasRepeatedPoint(Coordinate[] coord) |
static boolean |
IsValidOp.isValid(Coordinate coord)
Checks whether a coordinate is valid for processing.
|
Constructor and Description |
---|
TopologyValidationError(int errorType,
Coordinate pt)
Creates a validation error with the given type and location
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
DirectedEdge.getCoordinate()
Returns the coordinate of the from-node.
|
Coordinate |
DirectedEdgeStar.getCoordinate()
Returns the coordinate for the node at which this star is based
|
Coordinate |
Node.getCoordinate()
Returns the location of this Node.
|
Coordinate |
DirectedEdge.getDirectionPt()
Returns a point to which an imaginary line is drawn from the from-node to
specify this DirectedEdge's orientation.
|
Modifier and Type | Method and Description |
---|---|
Node |
NodeMap.find(Coordinate coord)
Returns the Node at the given location, or null if no Node was there.
|
Node |
PlanarGraph.findNode(Coordinate pt)
|
Node |
NodeMap.remove(Coordinate pt)
Removes the Node at the given location, and returns it (or null if no Node was there).
|
Constructor and Description |
---|
DirectedEdge(Node from,
Node to,
Coordinate directionPt,
boolean edgeDirection)
Constructs a DirectedEdge connecting the
from node to the
to node. |
Node(Coordinate pt)
Constructs a Node with the given location.
|
Node(Coordinate pt,
DirectedEdgeStar deStar)
Constructs a Node with the given location and collection of outgoing DirectedEdges.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
Coordinate |
CommonBitsRemover.getCommonCoordinate()
The common bits of the Coordinates in the supplied Geometries.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
GeometricShapeBuilder.getCentre() |
Modifier and Type | Method and Description |
---|---|
static Coordinate |
MortonCode.decode(int index)
Computes the point on the Morton curve
for a given index.
|
static Coordinate |
HilbertCode.decode(int level,
int index)
Computes the point on a Hilbert curve
of given level for a given code index.
|
Modifier and Type | Method and Description |
---|---|
void |
KochSnowflakeBuilder.addSide(int level,
Coordinate p0,
Coordinate p1) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
NonEncroachingSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
A basic strategy for finding split points when nothing extra is known about the geometry of
the situation.
|
Coordinate |
MidpointSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Gets the midpoint of the split segment
|
Coordinate |
ConstraintSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Finds a point at which to split an encroached segment to allow the original segment to appear
as edges in a constrained Delaunay triangulation.
|
Coordinate |
ConstraintEnforcementException.getCoordinate()
Gets the approximate location of this error.
|
Coordinate |
Segment.getEnd()
Gets the end coordinate of the segment
|
Coordinate |
SplitSegment.getSplitPoint() |
Coordinate |
Segment.getStart()
Gets the start coordinate of the segment
|
Coordinate |
Segment.intersection(Segment s)
Computes the intersection point between this segment and another one.
|
static Coordinate |
NonEncroachingSplitPointFinder.projectedSplitPoint(Segment seg,
Coordinate encroachPt)
Computes a split point which is the projection of the encroaching point on the segment
|
Modifier and Type | Method and Description |
---|---|
ConstraintVertex |
ConstraintVertexFactory.createVertex(Coordinate p,
Segment constraintSeg) |
Coordinate |
NonEncroachingSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
A basic strategy for finding split points when nothing extra is known about the geometry of
the situation.
|
Coordinate |
MidpointSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Gets the midpoint of the split segment
|
Coordinate |
ConstraintSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Finds a point at which to split an encroached segment to allow the original segment to appear
as edges in a constrained Delaunay triangulation.
|
void |
ConformingDelaunayTriangulator.insertSite(Coordinate p)
Inserts a site into the triangulation, maintaining the conformal Delaunay property.
|
static Coordinate |
NonEncroachingSplitPointFinder.projectedSplitPoint(Segment seg,
Coordinate encroachPt)
Computes a split point which is the projection of the encroaching point on the segment
|
void |
SplitSegment.splitAt(Coordinate pt) |
void |
SplitSegment.splitAt(double length,
Coordinate endPt) |
static CoordinateList |
DelaunayTriangulationBuilder.unique(Coordinate[] coords) |
Constructor and Description |
---|
ConstraintEnforcementException(String msg,
Coordinate pt)
Creates a new instance with a given message and approximate location.
|
ConstraintVertex(Coordinate p)
Creates a new constraint vertex
|
Segment(Coordinate p0,
Coordinate p1)
Creates a new instance for the given points.
|
Segment(Coordinate p0,
Coordinate p1,
Object data)
Creates a new instance for the given points, with associated external data.
|
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
PolygonHoleJoiner.compute()
Computes the joined ring.
|
static Coordinate[] |
PolygonHoleJoiner.join(Polygon inputPolygon) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
Vertex.getCoordinate() |
Coordinate |
QuadEdgeTriangle.getCoordinate(int i) |
Coordinate[] |
QuadEdgeTriangle.getCoordinates() |
Modifier and Type | Method and Description |
---|---|
boolean |
QuadEdgeTriangle.contains(Coordinate pt) |
static boolean |
QuadEdgeTriangle.contains(QuadEdge[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3
QuadEdge es. |
static boolean |
QuadEdgeTriangle.contains(Vertex[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3
Vertex es. |
static double |
Vertex.interpolateZ(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the interpolated Z-value for a point p lying on the segment p0-p1
|
static double |
Vertex.interpolateZ(Coordinate p,
Coordinate v0,
Coordinate v1,
Coordinate v2)
Interpolates the Z-value (height) of a point enclosed in a triangle
whose vertices all have Z values.
|
static boolean |
TrianglePredicate.isInCircleCC(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Computes the inCircle test using distance from the circumcentre.
|
static boolean |
TrianglePredicate.isInCircleDDFast(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p) |
static boolean |
TrianglePredicate.isInCircleDDNormalized(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p) |
static boolean |
TrianglePredicate.isInCircleDDSlow(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
static boolean |
TrianglePredicate.isInCircleNonRobust(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
static boolean |
TrianglePredicate.isInCircleNormalized(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
static boolean |
TrianglePredicate.isInCircleRobust(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
boolean |
QuadEdgeSubdivision.isOnEdge(QuadEdge e,
Coordinate p)
Tests whether a
Coordinate lies on a QuadEdge , up to a
tolerance determined by the subdivision tolerance. |
QuadEdge |
QuadEdgeSubdivision.locate(Coordinate p)
Finds a quadedge of a triangle containing a location
specified by a
Coordinate , if one exists. |
QuadEdge |
QuadEdgeSubdivision.locate(Coordinate p0,
Coordinate p1)
Locates the edge between the given vertices, if it exists in the
subdivision.
|
static DD |
TrianglePredicate.triAreaDDFast(Coordinate a,
Coordinate b,
Coordinate c) |
Constructor and Description |
---|
Vertex(Coordinate _p) |
Modifier and Type | Method and Description |
---|---|
Coordinate |
Tri.getCoordinate(int index)
Gets the coordinate for a vertex.
|
Coordinate |
Tri.midpoint(int edgeIndex)
Computes a coordinate for the midpoint of a triangle edge.
|
Modifier and Type | Method and Description |
---|---|
static Tri |
Tri.create(Coordinate[] pts)
Creates a triangle from an array with three vertex coordinates.
|
static Tri |
Tri.create(Coordinate p0,
Coordinate p1,
Coordinate p2)
Creates a triangle with the given vertices.
|
int |
Tri.getIndex(Coordinate p)
Gets the index of the triangle vertex which has a given coordinate (if any).
|
void |
Tri.setAdjacent(Coordinate pt,
Tri tri)
Sets the triangle adjacent to the edge originating
at a given vertex.
|
Tri |
Tri.split(Coordinate p)
Spits a triangle by a point located inside the triangle.
|
Constructor and Description |
---|
Tri(Coordinate p0,
Coordinate p1,
Coordinate p2)
Creates a triangle with the given vertices.
|
Modifier and Type | Method and Description |
---|---|
static Coordinate[] |
UniqueCoordinateArrayFilter.filterCoordinates(Coordinate[] coords)
Convenience method which allows running the filter over an array of
Coordinate s. |
Coordinate[] |
CoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinate s. |
Coordinate[] |
UniqueCoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinate s. |
Modifier and Type | Method and Description |
---|---|
static void |
Debug.breakIfEqual(Coordinate p0,
Coordinate p1,
double tolerance) |
static boolean |
Debug.equals(Coordinate c1,
Coordinate c2,
double tolerance) |
void |
CoordinateCountFilter.filter(Coordinate coord) |
void |
CoordinateArrayFilter.filter(Coordinate coord) |
void |
UniqueCoordinateArrayFilter.filter(Coordinate coord) |
static Coordinate[] |
UniqueCoordinateArrayFilter.filterCoordinates(Coordinate[] coords)
Convenience method which allows running the filter over an array of
Coordinate s. |
static boolean |
Debug.hasSegment(Geometry geom,
Coordinate p0,
Coordinate p1) |
void |
GeometricShapeFactory.setBase(Coordinate base)
Sets the location of the shape by specifying the base coordinate
(which in most cases is the
lower left point of the envelope containing the shape).
|
void |
GeometricShapeFactory.setCentre(Coordinate centre)
Sets the location of the shape by specifying the centre of
the shape's bounding box
|
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1) |
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1,
Coordinate p2) |
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1,
Coordinate p2,
Coordinate p3) |
Copyright © 2022. All rights reserved.