| Package | Description |
|---|---|
| com.vividsolutions.jts.algorithm |
Contains classes and interfaces implementing fundamental computational geometry algorithms.
|
| com.vividsolutions.jts.algorithm.distance |
Classes to compute distance metrics between geonetries.
|
| com.vividsolutions.jts.algorithm.locate |
Classes to determine the topological location of points in geometries.
|
| com.vividsolutions.jts.awt |
Classes to perform conversions from Java2D shape objects.
|
| com.vividsolutions.jts.edgegraph | |
| com.vividsolutions.jts.geom |
Contains the
Geometry interface hierarchy and supporting classes. |
| com.vividsolutions.jts.geom.impl |
Implementations of interfaces for geometric structures.
|
| com.vividsolutions.jts.geom.util |
Provides classes that parse and modify Geometry objects.
|
| com.vividsolutions.jts.geomgraph |
Contains classes that implement topology graphs.
|
| com.vividsolutions.jts.geomgraph.index |
Contains classes that implement indexes for performing noding on geometry graph edges.
|
| com.vividsolutions.jts.index.chain |
Contains classes that implement Monotone Chains
|
| com.vividsolutions.jts.index.kdtree |
Contains classes which implement a k-D tree index over 2-D point data.
|
| com.vividsolutions.jts.index.quadtree |
Contains classes that implement a Quadtree spatial index
|
| com.vividsolutions.jts.io |
Contains the interfaces for converting JTS objects to and from other formats.
|
| com.vividsolutions.jts.linearref |
Contains classes and interfaces implementing linear referencing on linear geometries
|
| com.vividsolutions.jts.math | |
| com.vividsolutions.jts.noding |
Classes to compute nodings for arrangements of line segments and line segment sequences.
|
| com.vividsolutions.jts.noding.snapround |
Contains classes to implement the Snap Rounding algorithm for noding linestrings.
|
| com.vividsolutions.jts.operation |
Provides classes for implementing operations on geometries
|
| com.vividsolutions.jts.operation.buffer |
Provides classes for computing buffers of geometries
|
| com.vividsolutions.jts.operation.buffer.validate |
Classes to perform validation of the results of buffer operations.
|
| com.vividsolutions.jts.operation.distance |
Provides classes for computing the distance between geometries
|
| com.vividsolutions.jts.operation.distance3d | |
| com.vividsolutions.jts.operation.linemerge |
Classes to perform line merging.
|
| com.vividsolutions.jts.operation.overlay |
Contains classes that perform a topological overlay to compute boolean spatial functions.
|
| com.vividsolutions.jts.operation.overlay.snap |
Classes to perform snapping on geometries to prepare them for overlay operations.
|
| com.vividsolutions.jts.operation.overlay.validate |
Classes to validate the results of overlay operations.
|
| com.vividsolutions.jts.operation.relate |
Contains classes to implement the computation of the spatial relationships of
Geometrys. |
| com.vividsolutions.jts.operation.valid |
Provides classes for testing the validity of geometries.
|
| com.vividsolutions.jts.planargraph |
Contains classes to implement a planar graph data structure.
|
| com.vividsolutions.jts.precision |
Provides classes for analyzing and
manipulating the precision of Geometries.
|
| com.vividsolutions.jts.shape | |
| com.vividsolutions.jts.shape.fractal | |
| com.vividsolutions.jts.shape.random | |
| com.vividsolutions.jts.triangulate |
Classes to compute Delaunay triangulations.
|
| com.vividsolutions.jts.triangulate.quadedge |
Classes to implement a topological subdivision of quadeges, to support creating triangulations
and Voronoi diagrams.
|
| com.vividsolutions.jts.util |
Contains support classes for the Java Topology Suite.
|
| com.vividsolutions.jtsexample.geom | |
| com.vividsolutions.jtstest.clean | |
| com.vividsolutions.jtstest.testbuilder | |
| com.vividsolutions.jtstest.testbuilder.controller | |
| com.vividsolutions.jtstest.testbuilder.geom | |
| com.vividsolutions.jtstest.testbuilder.model | |
| com.vividsolutions.jtstest.testbuilder.topostretch | |
| com.vividsolutions.jtstest.testbuilder.ui | |
| com.vividsolutions.jtstest.testbuilder.ui.style | |
| com.vividsolutions.jtstest.testbuilder.ui.tools |
| Modifier and Type | Field and Description |
|---|---|
protected Coordinate[][] |
LineIntersector.inputLines |
protected Coordinate[] |
LineIntersector.intPt |
protected Coordinate |
LineIntersector.pa |
protected Coordinate |
LineIntersector.pb |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
InteriorPointArea.centre(Envelope envelope)
Returns the centre point of the envelope.
|
Coordinate |
MinimumBoundingCircle.getCentre()
Gets the centre point of the computed Minimum Bounding Circle.
|
Coordinate |
CentroidLine.getCentroid()
Deprecated.
|
Coordinate |
CentroidPoint.getCentroid()
Deprecated.
|
Coordinate |
CentroidArea.getCentroid()
Deprecated.
|
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 |
InteriorPointArea.getInteriorPoint()
Gets the computed interior point.
|
Coordinate |
InteriorPointPoint.getInteriorPoint() |
Coordinate |
InteriorPointLine.getInteriorPoint() |
Coordinate |
CentralEndpointIntersector.getIntersection()
Deprecated.
|
static Coordinate |
CentralEndpointIntersector.getIntersection(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
Deprecated.
|
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 |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines
using DD arithmetic.
|
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the (approximate) intersection point between two line segments
using homogeneous coordinates.
|
protected Coordinate[] |
ConvexHull.toCoordinateArray(Stack stack)
An alternative to Stack.toArray, which is not present in earlier versions
of Java.
|
| Modifier and Type | Method and Description |
|---|---|
void |
CentroidPoint.add(Coordinate pt)
Deprecated.
Adds the length defined by an array of coordinates.
|
void |
CentroidLine.add(Coordinate[] pts)
Deprecated.
Adds the length defined by an array of coordinates.
|
void |
CentroidArea.add(Coordinate[] ring)
Deprecated.
Adds the area defined by an array of
coordinates.
|
static double |
Angle.angle(Coordinate p)
Returns the angle that 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 |
LineIntersector.computeEdgeDistance(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the "edge distance" of an intersection point p along a segment.
|
protected abstract int |
LineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
protected int |
RobustLineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
protected int |
NonRobustLineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate p3,
Coordinate p4) |
abstract void |
LineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2)
Compute the intersection of a point p and the line p1-p2.
|
void |
RobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2) |
void |
NonRobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate 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)
Computes the orientation of a point q to the directed line segment p1-p2.
|
static int |
NonRobustCGAlgorithms.computeOrientation(Coordinate p1,
Coordinate p2,
Coordinate q)
Computes the orientation of a point q to the directed line segment p1-p2.
|
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)
Computes the distance from a line segment AB to a line segment CD
Note: NON-ROBUST!
|
static double |
NonRobustCGAlgorithms.distanceLineLine(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.distancePointLine(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate A,
Coordinate B)
Computes the distance from a point p to a line segment AB
Note: NON-ROBUST!
|
static double |
CGAlgorithms.distancePointLinePerpendicular(Coordinate p,
Coordinate A,
Coordinate B)
Computes the perpendicular distance from a point p to the (infinite) line
containing the points AB
|
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 Coordinate |
CentralEndpointIntersector.getIntersection(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
Deprecated.
|
static double |
Angle.interiorAngle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Computes the interior angle between two segments of a ring.
|
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines
using DD arithmetic.
|
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the (approximate) intersection point between two line segments
using homogeneous coordinates.
|
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)
Computes whether a ring defined by an array of
Coordinates is
oriented counter-clockwise. |
static boolean |
NonRobustCGAlgorithms.isCCW(Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate is
oriented counter-clockwise. |
boolean |
PointInRing.isInside(Coordinate pt) |
boolean |
MCPointInRing.isInside(Coordinate pt) |
boolean |
SimplePointInRing.isInside(Coordinate pt) |
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 |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Tests whether a point lies on the line segments defined by a list of
coordinates.
|
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Tests whether a point lies on the line segments defined by a list of
coordinates.
|
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
static boolean |
NonRobustCGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate is
oriented counter-clockwise. |
static boolean |
NonRobustCGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate is
oriented counter-clockwise. |
int |
PointLocator.locate(Coordinate p,
Geometry geom)
Computes the topological relationship (
Location) of a single point
to a Geometry. |
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)
Determines whether a point lies in the interior, on the boundary, or in the
exterior of a ring.
|
static int |
CGAlgorithms.locatePointInRing(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,
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 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)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2. |
static int |
NonRobustCGAlgorithms.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 double |
CGAlgorithms.signedArea(Coordinate[] ring)
Computes the signed area for a ring.
|
| Constructor and Description |
|---|
CentralEndpointIntersector(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
Deprecated.
|
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
Coordinates. |
HCoordinate(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
RayCrossingCounter(Coordinate p) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
PointPairDistance.getCoordinate(int i) |
Coordinate[] |
DiscreteHausdorffDistance.getCoordinates() |
Coordinate[] |
PointPairDistance.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) |
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) |
int |
SimplePointInAreaLocator.locate(Coordinate p) |
int |
IndexedPointInAreaLocator.locate(Coordinate p)
|
int |
PointOnGeometryLocator.locate(Coordinate p)
|
static int |
SimplePointInAreaLocator.locate(Coordinate p,
Geometry geom)
|
| 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.
|
protected HalfEdge |
EdgeGraph.createEdge(Coordinate orig)
Creates a single HalfEdge.
|
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 an edge originating from a given coordinate.
|
MarkHalfEdge(Coordinate orig)
Creates a new marked edge.
|
| 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.
|
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.
|
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument
Coordinate array. |
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
|
Coordinate |
Point.getCoordinate() |
Coordinate |
GeometryCollection.getCoordinate() |
Coordinate |
Polygon.getCoordinate() |
abstract Coordinate |
Geometry.getCoordinate()
Returns a vertex of this
Geometry
(usually, but not necessarily, the first one). |
Coordinate |
LineString.getCoordinate() |
Coordinate |
TopologyException.getCoordinate() |
protected Coordinate |
MultiPoint.getCoordinate(int n)
Returns the
Coordinate at the given position. |
Coordinate |
CoordinateSequence.getCoordinate(int i)
Returns (possibly a copy of) the i'th coordinate in this sequence.
|
Coordinate |
LineSegment.getCoordinate(int i) |
Coordinate |
CoordinateList.getCoordinate(int i) |
Coordinate |
CoordinateSequence.getCoordinateCopy(int i)
Returns a copy of the i'th coordinate in this sequence.
|
Coordinate |
LineString.getCoordinateN(int n) |
Coordinate[] |
Point.getCoordinates() |
Coordinate[] |
GeometryCollection.getCoordinates()
Collects all coordinates of all subgeometries into an Array.
|
Coordinate[] |
Polygon.getCoordinates() |
abstract Coordinate[] |
Geometry.getCoordinates()
Returns an array containing the values of all the vertices for
this geometry.
|
Coordinate[] |
LineString.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.
|
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
|
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points,
constructs a new array containing no repeated points.
|
Coordinate[] |
CoordinateSequence.toCoordinateArray()
Returns (possibly copies of) the Coordinates in this collection.
|
Coordinate[] |
CoordinateList.toCoordinateArray()
Returns the Coordinates in this collection.
|
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.
|
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. |
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 |
DefaultCoordinateSequenceFactory.create(Coordinate[] coordinates)
Deprecated.
Returns a DefaultCoordinateSequence based on the given array (the array is
not copied).
|
CoordinateSequence |
CoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns a
CoordinateSequence based on the given array. |
LinearRing |
GeometryFactory.createLinearRing(Coordinate[] coordinates)
Creates a
LinearRing using the given Coordinates. |
LineString |
GeometryFactory.createLineString(Coordinate[] coordinates)
Creates a LineString using the given Coordinates.
|
MultiPoint |
GeometryFactory.createMultiPoint(Coordinate[] coordinates)
Creates a
MultiPoint using the given Coordinates. |
Point |
GeometryFactory.createPoint(Coordinate coordinate)
Creates a Point using the given Coordinate.
|
static Point |
GeometryFactory.createPointFromInternalCoord(Coordinate coord,
Geometry exemplar) |
Polygon |
GeometryFactory.createPolygon(Coordinate[] coordinates)
Constructs a
Polygon with the given exterior boundary. |
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 Envelope |
CoordinateArrays.envelope(Coordinate[] coordinates)
Computes the envelope of the coordinates.
|
protected boolean |
Geometry.equal(Coordinate a,
Coordinate b,
double tolerance) |
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
Coordinates
are equal. |
boolean |
Coordinate.equals2D(Coordinate c,
double tolerance)
Tests if another coordinate has the same values for the X and Y ordinates.
|
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
coord. |
void |
CoordinateSequence.getCoordinate(int index,
Coordinate coord)
Copies the i'th coordinate in the sequence to the supplied
Coordinate. |
static boolean |
CoordinateArrays.hasRepeatedPoints(Coordinate[] coord)
Returns whether #equals 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. |
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)
Check if the point
p
overlaps (lies inside) the region 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 |
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.
|
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
Coordinates forms a ring,
by checking length and closure. |
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 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 Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
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. |
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 |
Coordinate.setCoordinate(Coordinate other)
Sets this
Coordinates (x,y,z) values to that of 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
|
| 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.
|
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
Coordinates |
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) |
protected abstract Coordinate |
PackedCoordinateSequence.getCoordinateInternal(int index)
Returns a Coordinate representation of the specified coordinate, by always
building a new Coordinate object
|
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
Coordinates (the
array is not copied). |
CoordinateArraySequence(Coordinate[] coordinates,
int dimension)
Constructs a sequence based on the given array
of
Coordinates (the
array is not copied). |
PackedCoordinateSequence.Double(Coordinate[] coordinates)
Builds a new packed coordinate sequence out of a coordinate array
|
PackedCoordinateSequence.Double(Coordinate[] coordinates,
int dimension)
Builds a new packed coordinate sequence out of a coordinate array
|
PackedCoordinateSequence.Float(Coordinate[] coordinates,
int dimension)
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
Coordinates 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 |
|---|---|
protected CoordinateSequence |
GeometryTransformer.createCoordinateSequence(Coordinate[] coords)
Convenience method which provides standard way of
creating a
CoordinateSequence |
static AffineTransformation |
AffineTransformationFactory.createFromBaseLines(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a maping 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 tranformation from a set of three control vectors.
|
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of
Coordinates 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 |
|---|---|
protected Coordinate |
Node.coord |
Coordinate |
EdgeIntersection.coord |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
GeometryGraph.getBoundaryPoints() |
abstract Coordinate |
GraphComponent.getCoordinate() |
Coordinate |
Edge.getCoordinate() |
Coordinate |
Node.getCoordinate() |
Coordinate |
EdgeEndStar.getCoordinate() |
Coordinate |
EdgeIntersection.getCoordinate() |
Coordinate |
EdgeEnd.getCoordinate() |
Coordinate |
EdgeRing.getCoordinate(int i) |
Coordinate |
Edge.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) |
Node |
NodeMap.find(Coordinate coord) |
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
|
protected void |
EdgeEnd.init(Coordinate p0,
Coordinate 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. |
static int |
Quadrant.quadrant(Coordinate p0,
Coordinate p1)
Returns the quadrant of a directed line segment from p0 to p1.
|
| 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) |
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) |
| 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) |
static List |
MonotoneChainBuilder.getChains(Coordinate[] pts,
Object context)
Return a list of the
MonotoneChains
for the given list of coordinates. |
static int[] |
MonotoneChainBuilder.getChainStartIndices(Coordinate[] pts)
Return an array containing lists of start/end indexes of the monotone chains
for the given list of coordinates.
|
| Constructor and Description |
|---|
MonotoneChain(Coordinate[] pts,
int start,
int end,
Object context) |
| 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
KdNodes to an array of Coordinates. |
static Coordinate[] |
KdTree.toCoordinates(Collection kdnodes,
boolean includeRepeated)
Converts a collection of
KdNodes
to an array of Coordinates,
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.
|
| 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.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
Coordinates. |
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.
|
double |
LengthIndexedLine.indexOf(Coordinate pt)
Computes the minimum index for a point on the line.
|
LinearLocation |
LocationIndexedLine.indexOf(Coordinate pt)
Computes the index for a given 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). |
double |
LengthIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point.
|
LinearLocation |
LocationIndexedLine.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) |
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
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
Coordinates. |
static double |
Vector3D.dot(Coordinate v1,
Coordinate v2)
Computes the 3D dot-product of two
Coordinates. |
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) |
static Coordinate |
Vector3D.normalize(Coordinate v) |
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) |
Vector3D(Coordinate from,
Coordinate to) |
| 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 |
InteriorIntersectionFinder.getInteriorIntersection()
Gets the computed location of the intersection.
|
Coordinate |
SegmentIntersectionDetector.getIntersection()
Gets the computed location of the intersection.
|
Coordinate[] |
SegmentIntersectionDetector.getIntersectionSegments()
Gets the endpoints of the intersecting segments.
|
Coordinate[] |
InteriorIntersectionFinder.getIntersectionSegments()
Gets the endpoints of the intersecting segments.
|
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 |
NodableSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
void |
NodedSegmentString.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
Coordinates 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 new segment string from a list of vertices.
|
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 |
HotPixel.getCoordinate()
Gets the coordinate this hot pixel is based at.
|
| Modifier and Type | Method and Description |
|---|---|
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,
LineIntersector li)
Creates a new hot pixel, using a given scale factor.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
IsSimpleOp.getNonSimpleLocation()
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 rings.
|
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 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 |
BufferDistanceValidator.getErrorLocation() |
Coordinate |
BufferResultValidator.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.
|
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 |
|---|---|
boolean |
PolygonBuilder.containsPoint(Coordinate p)
Checks the current set of shells (with their associated holes) to
see if any of them contain the point.
|
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 |
|---|---|
Node |
RelateNodeFactory.createNode(Coordinate coord) |
| Constructor and Description |
|---|
RelateNode(Coordinate coord,
EdgeEndStar edges) |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt) |
static Coordinate |
IsValidOp.findPtNotNode(Coordinate[] testCoords,
LinearRing searchRing,
GeometryGraph graph)
Find a point from the list of testCoords
that is NOT a node in the edge for the list of searchCoords
|
Coordinate |
ConnectedInteriorTester.getCoordinate() |
Coordinate |
RepeatedPointTester.getCoordinate() |
Coordinate |
TopologyValidationError.getCoordinate()
Returns the location of this error (on the
Geometry containing the error). |
Coordinate |
ConsistentAreaTester.getInvalidPoint() |
Coordinate |
SweeplineNestedRingTester.getNestedPoint() |
Coordinate |
IndexedNestedRingTester.getNestedPoint() |
Coordinate |
SimpleNestedRingTester.getNestedPoint() |
Coordinate |
QuadtreeNestedRingTester.getNestedPoint() |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt) |
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt) |
static Coordinate |
IsValidOp.findPtNotNode(Coordinate[] testCoords,
LinearRing searchRing,
GeometryGraph graph)
Find a point from the list of testCoords
that is NOT a node in the edge for the list of searchCoords
|
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 | Field and Description |
|---|---|
protected Coordinate |
DirectedEdge.p0 |
protected Coordinate |
DirectedEdge.p1 |
protected Coordinate |
Node.pt
The location of this Node
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
Node.getCoordinate()
Returns the location of this Node.
|
Coordinate |
DirectedEdge.getCoordinate()
Returns the coordinate of the from-node.
|
Coordinate |
DirectedEdgeStar.getCoordinate()
Returns the coordinate for the node at wich this star is based
|
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 |
|---|---|
protected Coordinate |
GeometricShapeBuilder.createCoord(double x,
double y) |
Coordinate |
GeometricShapeBuilder.getCentre() |
| Modifier and Type | Method and Description |
|---|---|
void |
KochSnowflakeBuilder.addSide(int level,
Coordinate p0,
Coordinate p1) |
| Modifier and Type | Method and Description |
|---|---|
protected Coordinate |
RandomPointsBuilder.createCoord(double x,
double y) |
protected Coordinate |
RandomPointsBuilder.createRandomCoord(Envelope env) |
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
RandomPointsBuilder.isInExtent(Coordinate p) |
| Modifier and Type | Method and Description |
|---|---|
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 |
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 |
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 |
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 |
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
|
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 |
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
QuadEdgees. |
static boolean |
QuadEdgeTriangle.contains(Vertex[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3
Vertexes. |
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 | Field and Description |
|---|---|
Coordinate |
GeometricShapeFactory.Dimensions.base |
Coordinate |
GeometricShapeFactory.Dimensions.centre |
| Modifier and Type | Method and Description |
|---|---|
protected Coordinate |
GeometricShapeFactory.coord(double x,
double y) |
protected Coordinate |
GeometricShapeFactory.coordTrans(double x,
double y,
Coordinate trans) |
static Coordinate[] |
UniqueCoordinateArrayFilter.filterCoordinates(Coordinate[] coords)
Convenience method which allows running the filter over an array of
Coordinates. |
Coordinate |
GeometricShapeFactory.Dimensions.getBase() |
Coordinate |
GeometricShapeFactory.Dimensions.getCentre() |
Coordinate[] |
CoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinates. |
Coordinate[] |
UniqueCoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinates. |
| Modifier and Type | Method and Description |
|---|---|
static void |
Debug.breakIfEqual(Coordinate p0,
Coordinate p1,
double tolerance) |
protected Coordinate |
GeometricShapeFactory.coordTrans(double x,
double y,
Coordinate trans) |
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
Coordinates. |
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.Dimensions.setBase(Coordinate base) |
void |
GeometricShapeFactory.setCentre(Coordinate centre)
Sets the location of the shape by specifying the centre of
the shape's bounding box
|
void |
GeometricShapeFactory.Dimensions.setCentre(Coordinate centre) |
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) |
| Modifier and Type | Class and Description |
|---|---|
class |
ExtendedCoordinate |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
ExtendedCoordinateSequence.getCoordinate(int i) |
Coordinate |
ExtendedCoordinateSequence.getCoordinateCopy(int index) |
Coordinate[] |
ExtendedCoordinateSequence.toCoordinateArray() |
| Modifier and Type | Method and Description |
|---|---|
static ExtendedCoordinate[] |
ExtendedCoordinateSequence.copy(Coordinate[] coordinates) |
CoordinateSequence |
ExtendedCoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns an ExtendedCoordinateSequence based on the given array -- the array is used
directly if it is an instance of ExtendedCoordinate[]; otherwise it is
copied.
|
void |
ExtendedCoordinateSequence.getCoordinate(int index,
Coordinate coord) |
| Constructor and Description |
|---|
ExtendedCoordinate(Coordinate coord) |
ExtendedCoordinateSequence(Coordinate[] copyCoords)
Constructor that makes a copy of an array of Coordinates.
|
| Modifier and Type | Method and Description |
|---|---|
static Coordinate[] |
CleanDuplicatePoints.removeDuplicatePoints(Coordinate[] coord) |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate[] |
CleanDuplicatePoints.removeDuplicatePoints(Coordinate[] coord) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
ValidPanel.getMarkPoint() |
| Modifier and Type | Method and Description |
|---|---|
void |
JTSTestBuilderFrame.displayInfo(Coordinate modelPt) |
String |
GeometryEditPanel.getInfo(Coordinate pt) |
void |
GeometryEditPanel.setHighlightPoint(Coordinate pt) |
| Modifier and Type | Method and Description |
|---|---|
static void |
JTSTestBuilderController.copyComponentToClipboard(Coordinate pt) |
static void |
JTSTestBuilderController.extractComponentsToTestCase(Coordinate pt) |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
NearestPointFinder.findNearestPoint(Geometry geom,
Coordinate pt,
double tolerance) |
static Coordinate[] |
AdjacentVertexFinder.findVertices(Geometry geom,
Coordinate testPt) |
Coordinate |
GeometryLocation.getCoordinate() |
Coordinate |
VertexLocater.Location.getCoordinate() |
Coordinate |
NearestPointFinder.getNearestPoint(Coordinate pt,
double tolerance) |
Coordinate |
VertexLocater.getVertex(Coordinate testPt,
double tolerance) |
Coordinate[] |
AdjacentVertexFinder.getVertices(Coordinate testPt) |
static Coordinate |
VertexLocater.locateVertex(Geometry geom,
Coordinate testPt,
double tolerance) |
| Modifier and Type | Method and Description |
|---|---|
Geometry |
GeometryCombiner.addLineString(Geometry orig,
Coordinate[] pts) |
Geometry |
GeometryCombiner.addPoint(Geometry orig,
Coordinate pt) |
Geometry |
GeometryCombiner.addPolygonRing(Geometry orig,
Coordinate[] pts) |
static Coordinate |
NearestPointFinder.findNearestPoint(Geometry geom,
Coordinate pt,
double tolerance) |
static Coordinate[] |
AdjacentVertexFinder.findVertices(Geometry geom,
Coordinate testPt) |
List |
ComponentLocater.getComponents(Coordinate queryPt,
double tolerance) |
GeometryLocation |
GeometryPointLocater.getLocation(Coordinate testPt,
boolean vertexOnly,
double tolerance) |
List |
VertexLocater.getLocations(Coordinate testPt,
double tolerance) |
List |
FacetLocater.getLocations(Coordinate queryPt,
double tolerance) |
Coordinate |
NearestPointFinder.getNearestPoint(Coordinate pt,
double tolerance) |
Coordinate |
VertexLocater.getVertex(Coordinate testPt,
double tolerance) |
Coordinate[] |
AdjacentVertexFinder.getVertices(Coordinate testPt) |
static Geometry |
GeometryVertexInserter.insert(Geometry geom,
LineString line,
int segIndex,
Coordinate newVertex) |
static GeometryLocation |
GeometryPointLocater.locateNonVertexPoint(Geometry geom,
Coordinate testPt,
double tolerance) |
static Coordinate |
VertexLocater.locateVertex(Geometry geom,
Coordinate testPt,
double tolerance) |
static GeometryLocation |
GeometryPointLocater.locateVertex(Geometry geom,
Coordinate testPt,
double tolerance) |
static Geometry |
GeometryVertexMover.move(Geometry geom,
Coordinate fromLoc,
Coordinate toLoc) |
| Constructor and Description |
|---|
GeometryLocation(Geometry parent,
Geometry component,
int[] componentPath,
int segmentIndex,
boolean isVertex,
Coordinate pt) |
GeometryLocation(Geometry parent,
Geometry component,
int segmentIndex,
boolean isVertex,
Coordinate pt) |
GeometryLocation(Geometry parent,
Geometry component,
int index,
Coordinate pt) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
GeometryEditModel.findAdjacentVertices(Coordinate vertex) |
Coordinate |
GeometryEditModel.locateVertexPt(Coordinate testPt,
double tolerance) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
GeometryEditModel.findAdjacentVertices(Coordinate vertex) |
Geometry |
LayerList.getComponent(Coordinate pt,
double tolerance) |
GeometryLocation |
GeometryEditModel.locateNonVertexPoint(Coordinate testPt,
double tolerance)
Locates a non-vertex point on a line segment of the current geometry
within the given tolerance, if any.
|
GeometryLocation |
GeometryEditModel.locateVertex(Coordinate testPt,
double tolerance)
Locates a vertex of the current geometry
within the given tolerance, if any.
|
Coordinate |
GeometryEditModel.locateVertexPt(Coordinate testPt,
double tolerance) |
void |
GeometryEditModel.moveVertex(Coordinate fromLoc,
Coordinate toLoc) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
StretchedVertex.getStretchedVertex(double dist)
Gets the point which this near vertex will be stretched to
(by a given distance)
|
Coordinate |
StretchedVertex.getVertexCoordinate() |
| Constructor and Description |
|---|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
Coordinate nearPt,
Coordinate[] nearPts,
int nearIndex)
Creates a vertex which lies near a vertex
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
Coordinate nearPt,
Coordinate[] nearPts,
int nearIndex)
Creates a vertex which lies near a vertex
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
Coordinate nearPt,
Coordinate[] nearPts,
int nearIndex)
Creates a vertex which lies near a vertex
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
LineSegment nearSeg)
Creates a vertex for a point which lies near a line segment
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
LineSegment nearSeg)
Creates a vertex for a point which lies near a line segment
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
Viewport.toModelCoordinate(Point2D viewPt) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
Viewport.containsInModel(Coordinate p) |
String |
GeometryLocationsWriter.OLDwriteLocation(Geometry geom,
Coordinate p,
double tolerance) |
Point2D |
Viewport.toView(Coordinate modelCoordinate) |
void |
Viewport.transform(Coordinate modelCoordinate,
Point2D point) |
String |
GeometryLocationsWriter.writeComponentLocation(Geometry geom,
Coordinate p,
double tolerance) |
String |
GeometryLocationsWriter.writeFacetLocation(Geometry geom,
Coordinate p,
double tolerance) |
String |
GeometryLocationsWriter.writeLocation(Layer lyr,
Coordinate p,
double tolerance) |
static String |
GeometryLocationsWriter.writeLocation(LayerList layers,
Coordinate pt,
double tolerance) |
String |
GeometryLocationsWriter.writeLocationString(LayerList layers,
Coordinate pt,
double tolerance) |
String |
GeometryLocationsWriter.writeSingleLocation(Layer lyr,
Coordinate p,
double tolerance) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
SegmentStyle.paint(int index,
Coordinate p0,
Coordinate p1,
int lineType,
Viewport viewport,
Graphics2D g) |
| Modifier and Type | Field and Description |
|---|---|
protected Coordinate |
LineBandTool.tentativeCoordinate |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
LineBandTool.lastCoordinate() |
protected Coordinate[] |
LineBandTool.toArray(List coordinates) |
protected Coordinate |
BasicTool.toModelSnapped(Point2D p) |
protected Coordinate |
BasicTool.toModelSnappedIfCloseToViewGrid(Point2D p) |
protected Coordinate |
BasicTool.toModelSnappedToViewGrid(Point2D p) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
LineBandTool.add(Coordinate c) |
Copyright © 2017. All Rights Reserved.