Uses of Class
org.locationtech.jts.geom.Coordinate

Packages that use Coordinate

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 Geometrys.
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.shape.random
org.locationtech.jts.simplify	Classes which implement algorithms for simplifying or generalizing geometries.
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.
org.locationtech.jtsexample.geom
org.locationtech.jtslab.geom.util
org.locationtech.jtstest.clean
org.locationtech.jtstest.testbuilder
org.locationtech.jtstest.testbuilder.controller
org.locationtech.jtstest.testbuilder.geom
org.locationtech.jtstest.testbuilder.model
org.locationtech.jtstest.testbuilder.topostretch
org.locationtech.jtstest.testbuilder.ui
org.locationtech.jtstest.testbuilder.ui.style
org.locationtech.jtstest.testbuilder.ui.tools

Uses of Coordinate in org.locationtech.jts.algorithm

Fields in org.locationtech.jts.algorithm declared as Coordinate

Modifier and Type	Field	Description
protected Coordinate[][]	LineIntersector.inputLines
protected Coordinate[]	LineIntersector.intPt
protected Coordinate	LineIntersector.pa
protected Coordinate	LineIntersector.pb

Methods in org.locationtech.jts.algorithm that return Coordinate

Modifier and Type	Method	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.
static Coordinate	InteriorPoint.getInteriorPoint(Geometry geom)	Computes a location of an interior point in a Geometry.
Coordinate	InteriorPointArea.getInteriorPoint()	Gets the computed interior point.
static Coordinate	InteriorPointArea.getInteriorPoint(Geometry geom)	Computes an interior point for the polygonal components of a Geometry.
Coordinate	InteriorPointLine.getInteriorPoint()
static Coordinate	InteriorPointLine.getInteriorPoint(Geometry geom)	Computes an interior point for the linear components of a Geometry.
Coordinate	InteriorPointPoint.getInteriorPoint()
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	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)	Deprecated. use Intersection.intersection(Coordinate, Coordinate, Coordinate, Coordinate)
static Coordinate	Intersection.intersection(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)	Computes the intersection point of two lines.
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.
protected Coordinate[]	ConvexHull.toCoordinateArray(Stack<Coordinate> stack)	An alternative to Stack.toArray, which is not present in earlier versions of Java.

Methods in org.locationtech.jts.algorithm with parameters of type Coordinate

Modifier and Type	Method	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 int	PolygonNodeTopology.compareAngle(Coordinate origin, Coordinate p, Coordinate q)	Compares the angles of two vectors relative to the positive X-axis at their origin.
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)
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.
void	RobustLineIntersector.computeIntersection(Coordinate p, Coordinate p1, Coordinate p2)
static int	CGAlgorithms.computeOrientation(Coordinate p1, Coordinate p2, Coordinate q)	Deprecated. Use Orientation.index(Coordinate, Coordinate, Coordinate) instead.
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. Use Distance.segmentToSegment(Coordinate, Coordinate, Coordinate, Coordinate) instead.
static double	CGAlgorithms.distancePointLine(Coordinate p, Coordinate[] line)	Deprecated. Use Distance.pointToSegmentString(Coordinate, Coordinate[]) instead.
static double	CGAlgorithms.distancePointLine(Coordinate p, Coordinate A, Coordinate B)	Deprecated. Use Distance.pointToSegment(Coordinate, Coordinate, Coordinate) instead.
static double	CGAlgorithms.distancePointLinePerpendicular(Coordinate p, Coordinate A, Coordinate B)	Deprecated. Use Distance.pointToLinePerpendicular(Coordinate, Coordinate, Coordinate) instead.
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	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)	Deprecated. use Intersection.intersection(Coordinate, Coordinate, Coordinate, Coordinate)
static Coordinate	Intersection.intersection(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)	Computes the intersection point of two lines.
boolean	PointLocator.intersects(Coordinate p, Geometry geom)	Convenience method to test a point for intersection with a Geometry
boolean	RectangleLineIntersector.intersects(Coordinate p0, Coordinate p1)	Tests whether the query rectangle intersects a given line segment.
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 Coordinates is oriented counter-clockwise.
static boolean	Orientation.isCCWArea(Coordinate[] ring)	Tests if a ring defined by an array of Coordinates is oriented counter-clockwise, using the signed area of the ring.
static boolean	PolygonNodeTopology.isCrossing(Coordinate nodePt, Coordinate a0, Coordinate a1, Coordinate b0, Coordinate b1)	Check if four segments at a node cross.
static boolean	PointLocation.isInRing(Coordinate p, Coordinate[] ring)	Tests whether a point lies inside or on a ring.
static boolean	PolygonNodeTopology.isInteriorSegment(Coordinate nodePt, Coordinate a0, Coordinate a1, Coordinate b)	Tests whether an segment node-b lies in the interior or exterior of a corner of a ring formed by the two segments a0-node-a1.
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)	Deprecated. Use PointLocation.isOnLine(Coordinate, Coordinate[]) instead.
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, CoordinateSequence line)	Tests whether a point lies on the line defined by a CoordinateSequence.
static boolean	PointLocation.isOnSegment(Coordinate p, Coordinate p0, Coordinate p1)	Tests whether a point lies on a line segment.
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	CGAlgorithms.locatePointInRing(Coordinate p, Coordinate[] ring)	Deprecated. Use PointLocation.locateInRing(Coordinate, Coordinate[]) instead.
static int	RayCrossingCounter.locatePointInRing(Coordinate p, Coordinate[] ring)	Determines the Location of a point in 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)
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	CGAlgorithms.orientationIndex(Coordinate p1, Coordinate p2, Coordinate q)	Deprecated. Use Orientation.index(Coordinate, Coordinate, Coordinate) instead.
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 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.pointToLinePerpendicularSigned(Coordinate p, Coordinate A, Coordinate B)
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 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.

Method parameters in org.locationtech.jts.algorithm with type arguments of type Coordinate

Modifier and Type	Method	Description
protected Coordinate[]	ConvexHull.toCoordinateArray(Stack<Coordinate> stack)	An alternative to Stack.toArray, which is not present in earlier versions of Java.

Constructors in org.locationtech.jts.algorithm with parameters of type Coordinate

Modifier	Constructor	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 Coordinates.
	HCoordinate(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)
	RayCrossingCounter(Coordinate p)

Uses of Coordinate in org.locationtech.jts.algorithm.distance

Methods in org.locationtech.jts.algorithm.distance that return Coordinate

Modifier and Type	Method	Description
Coordinate	PointPairDistance.getCoordinate(int i)	Gets one of the paired points
Coordinate[]	DiscreteFrechetDistance.getCoordinates()	Gets the pair of Coordinates at which the distance is obtained.
Coordinate[]	DiscreteHausdorffDistance.getCoordinates()
Coordinate[]	PointPairDistance.getCoordinates()	Gets the paired points

Methods in org.locationtech.jts.algorithm.distance with parameters of type Coordinate

Modifier and Type	Method	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)

Uses of Coordinate in org.locationtech.jts.algorithm.locate

Methods in org.locationtech.jts.algorithm.locate with parameters of type Coordinate

Modifier and Type	Method	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	IndexedPointInAreaLocator.locate(Coordinate p)	Determines the Location of a point in an areal Geometry.
int	PointOnGeometryLocator.locate(Coordinate p)	Determines the Location of a point in the Geometry.
int	SimplePointInAreaLocator.locate(Coordinate p)	Determines the Location of a point in an areal Geometry.
static int	SimplePointInAreaLocator.locate(Coordinate p, Geometry geom)	Determines the Location of a point in an areal Geometry.
static int	SimplePointInAreaLocator.locatePointInPolygon(Coordinate p, Polygon poly)	Determines the Location of a point in a Polygon.

Uses of Coordinate in org.locationtech.jts.awt

Methods in org.locationtech.jts.awt with parameters of type Coordinate

Modifier and Type	Method	Description
void	IdentityPointTransformation.transform(Coordinate model, Point2D view)
void	PointTransformation.transform(Coordinate src, Point2D dest)	Transforms a Coordinate into a Java2D Point.

Constructors in org.locationtech.jts.awt with parameters of type Coordinate

Modifier	Constructor	Description
	PolygonShape(Coordinate[] shellVertices, Collection holeVerticesCollection)	Creates a new polygon Shape.

Uses of Coordinate in org.locationtech.jts.edgegraph

Methods in org.locationtech.jts.edgegraph that return Coordinate

Modifier and Type	Method	Description
Coordinate	HalfEdge.dest()	Gets the destination coordinate of this edge.
protected Coordinate	HalfEdge.directionPt()	Gets the direction point of this edge.
Coordinate	HalfEdge.orig()	Gets the origin coordinate of this edge.

Methods in org.locationtech.jts.edgegraph with parameters of type Coordinate

Modifier and Type	Method	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).

Constructors in org.locationtech.jts.edgegraph with parameters of type Coordinate

Modifier	Constructor	Description
	HalfEdge(Coordinate orig)	Creates a half-edge originating from a given coordinate.
	MarkHalfEdge(Coordinate orig)	Creates a new marked edge.

Uses of Coordinate in org.locationtech.jts.geom

Subclasses of Coordinate in org.locationtech.jts.geom

Modifier and Type	Class	Description
class	CoordinateXY	Coordinate subclass supporting XY ordinates.
class	CoordinateXYM	Coordinate subclass supporting XYM ordinates.
class	CoordinateXYZM	Coordinate subclass supporting XYZM ordinates.

Subclasses with type arguments of type Coordinate in org.locationtech.jts.geom

Modifier and Type	Class	Description
class	CoordinateList	A list of Coordinates, which may be set to prevent repeated coordinates from occurring in the list.

Classes in org.locationtech.jts.geom that implement interfaces with type arguments of type Coordinate

Modifier and Type	Class	Description
class	Coordinate	A lightweight class used to store coordinates on the 2-dimensional Cartesian plane.
static class	Coordinate.DimensionalComparator	Compares two Coordinates, allowing for either a 2-dimensional or 3-dimensional comparison, and handling NaN values correctly.

Fields in org.locationtech.jts.geom declared as Coordinate

Modifier and Type	Field	Description
Coordinate	LineSegment.p0
Coordinate	Triangle.p0	The coordinates of the vertices of the triangle
Coordinate	LineSegment.p1
Coordinate	Triangle.p1	The coordinates of the vertices of the triangle
Coordinate	Triangle.p2	The coordinates of the vertices of the triangle

Methods in org.locationtech.jts.geom that return Coordinate

Modifier and Type	Method	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	Coordinate.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.
Coordinate	CoordinateXY.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.
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)	Extracts a subsequence of the input Coordinate array from indices start to end (inclusive).
Coordinate	CoordinateList.getCoordinate(int i)
Coordinate	CoordinateSequence.getCoordinate(int i)	Returns (possibly a copy of) the i'th coordinate in this sequence.
abstract Coordinate	Geometry.getCoordinate()	Returns a vertex of this geometry (usually, but not necessarily, the first one), or null if the geometry is empty.
Coordinate	GeometryCollection.getCoordinate()
Coordinate	LineSegment.getCoordinate(int i)
Coordinate	LineString.getCoordinate()
protected Coordinate	MultiPoint.getCoordinate(int n)	Returns the Coordinate at the given position.
Coordinate	Point.getCoordinate()
Coordinate	Polygon.getCoordinate()
Coordinate	TopologyException.getCoordinate()
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[]	GeometryCollection.getCoordinates()	Collects all coordinates of all subgeometries into an Array.
Coordinate[]	LineString.getCoordinates()
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.
static Coordinate[]	CoordinateArrays.toCoordinateArray(Collection coordList)	Converts the given Collection of Coordinates into a Coordinate array.
Coordinate[]	CoordinateList.toCoordinateArray()	Returns 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).
Coordinate[]	CoordinateSequence.toCoordinateArray()	Returns (possibly copies of) the Coordinates in this collection.
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

Methods in org.locationtech.jts.geom with parameters of type Coordinate

Modifier and Type	Method	Description
void	CoordinateList.add(int i, Coordinate coord, boolean allowRepeated)	Inserts the specified coordinate at the specified position in this list.
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.
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.
static double	Triangle.circumradius(Coordinate a, Coordinate b, Coordinate c)	Computes the radius of the circumcircle of a triangle.
Coordinate	LineSegment.closestPoint(Coordinate p)	Computes the closest point on this line segment to another point.
int	Coordinate.DimensionalComparator.compare(Coordinate c1, Coordinate c2)	Compares two Coordinates along to the number of dimensions specified.
static int	CoordinateArrays.compare(Coordinate[] pts1, Coordinate[] pts2)	Compares two Coordinate arrays in the forward direction of their coordinates, using lexicographic ordering.
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.
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 Coordinates.
LineString	GeometryFactory.createLineString(Coordinate[] coordinates)	Creates a LineString using the given Coordinates.
MultiPoint	GeometryFactory.createMultiPoint(Coordinate[] coordinates)	Deprecated. Use GeometryFactory.createMultiPointFromCoords(Coordinate[]) instead
MultiPoint	GeometryFactory.createMultiPointFromCoords(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[] shell)	Constructs a Polygon with the given exterior boundary.
static int	CoordinateArrays.dimension(Coordinate[] pts)	Determine dimension based on subclass of Coordinate.
static int	Coordinates.dimension(Coordinate coordinate)	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.
double	LineSegment.distancePerpendicularOriented(Coordinate p)	Computes the oriented 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.
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, 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, 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.
void	Envelope.expandToInclude(Coordinate p)	Enlarges this Envelope so that it contains the given Coordinate.
OctagonalEnvelope	OctagonalEnvelope.expandToInclude(Coordinate p)
static Coordinate[]	CoordinateArrays.extract(Coordinate[] pts, int start, int end)	Extracts a subsequence of the input Coordinate array from indices start to end (inclusive).
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 Coordinate.equals(Object) returns true for any two consecutive Coordinates in the given array.
static boolean	Coordinates.hasZ(Coordinate coordinate)	Check if coordinate can store Z valye, based on subclass of Coordinate.
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	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	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	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.
boolean	OctagonalEnvelope.intersects(Coordinate p)
static boolean	Triangle.intersects(Coordinate a, Coordinate b, Coordinate c, Coordinate p)	Tests whether a triangle intersects a point.
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 Coordinates 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	CoordinateArrays.measures(Coordinate[] pts)	Determine number of measures based on subclass of Coordinate.
static int	Coordinates.measures(Coordinate coordinate)	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 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, 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	CoordinateArrays.scroll(Coordinate[] coordinates, Coordinate firstCoordinate)	Shifts the positions of the coordinates until firstCoordinate 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	Coordinate.setCoordinate(Coordinate other)	Sets this Coordinates (x,y,z) values to that of other.
void	CoordinateXY.setCoordinate(Coordinate 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

Method parameters in org.locationtech.jts.geom with type arguments of type Coordinate

Modifier and Type	Method	Description
boolean	CoordinateList.addAll(Collection<? extends Coordinate> coll, boolean allowRepeated)	Add an array of coordinates

Constructors in org.locationtech.jts.geom with parameters of type Coordinate

Modifier	Constructor	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 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.

Uses of Coordinate in org.locationtech.jts.geom.impl

Methods in org.locationtech.jts.geom.impl that return Coordinate

Modifier and Type	Method	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)
protected abstract Coordinate	PackedCoordinateSequence.getCoordinateInternal(int index)	Returns a Coordinate representation of the specified coordinate, by always building a new Coordinate object
Coordinate[]	CoordinateArraySequence.toCoordinateArray()	This method exposes the internal Array of Coordinate Objects
Coordinate[]	PackedCoordinateSequence.toCoordinateArray()

Methods in org.locationtech.jts.geom.impl with parameters of type Coordinate

Modifier and Type	Method	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)

Constructors in org.locationtech.jts.geom.impl with parameters of type Coordinate

Modifier	Constructor	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).
	CoordinateArraySequence(Coordinate[] coordinates, int dimension, int measures)	Constructs a sequence based on the given array of Coordinates (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

Uses of Coordinate in org.locationtech.jts.geom.util

Methods in org.locationtech.jts.geom.util that return Coordinate

Modifier and Type	Method	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).

Methods in org.locationtech.jts.geom.util with parameters of type Coordinate

Modifier and Type	Method	Description
static Geometry	SineStarFactory.create(Coordinate origin, double size, int nPts, int nArms, double armLengthRatio)	Creates a sine star with the given parameters.
protected final 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 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 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 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).

Constructors in org.locationtech.jts.geom.util with parameters of type Coordinate

Modifier	Constructor	Description
	AffineTransformation(Coordinate src0, Coordinate src1, Coordinate src2, Coordinate dest0, Coordinate dest1, Coordinate dest2)	Deprecated. use AffineTransformationFactory
	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.

Uses of Coordinate in org.locationtech.jts.geomgraph

Fields in org.locationtech.jts.geomgraph declared as Coordinate

Modifier and Type	Field	Description
Coordinate	EdgeIntersection.coord	Point of intersection
protected Coordinate	Node.coord

Methods in org.locationtech.jts.geomgraph that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	GeometryGraph.getBoundaryPoints()
Coordinate	Edge.getCoordinate()
Coordinate	Edge.getCoordinate(int i)
Coordinate	EdgeEnd.getCoordinate()
Coordinate	EdgeEndStar.getCoordinate()
Coordinate	EdgeIntersection.getCoordinate()
Coordinate	EdgeRing.getCoordinate(int i)
abstract Coordinate	GraphComponent.getCoordinate()
Coordinate	Node.getCoordinate()
Coordinate[]	Edge.getCoordinates()
Coordinate	EdgeEnd.getDirectedCoordinate()
Coordinate	GeometryGraph.getInvalidPoint()

Methods in org.locationtech.jts.geomgraph with parameters of type Coordinate

Modifier and Type	Method	Description
EdgeIntersection	EdgeIntersectionList.add(Coordinate intPt, int segmentIndex, double dist)	Adds an intersection into the list, if it isn't already there.
Node	NodeMap.addNode(Coordinate coord)	This method expects that a node has a coordinate value.
Node	PlanarGraph.addNode(Coordinate coord)
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	NodeMap.find(Coordinate coord)	Find coordinate.
Node	PlanarGraph.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
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.

Constructors in org.locationtech.jts.geomgraph with parameters of type Coordinate

Modifier	Constructor	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)

Uses of Coordinate in org.locationtech.jts.geomgraph.index

Methods in org.locationtech.jts.geomgraph.index that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	MonotoneChainEdge.getCoordinates()
Coordinate	SegmentIntersector.getProperIntersectionPoint()

Methods in org.locationtech.jts.geomgraph.index with parameters of type Coordinate

Modifier and Type	Method	Description
int[]	MonotoneChainIndexer.getChainStartIndices(Coordinate[] pts)
int[]	MonotoneChainIndexer.OLDgetChainStartIndices(Coordinate[] pts)

Uses of Coordinate in org.locationtech.jts.index

Constructors in org.locationtech.jts.index with parameters of type Coordinate

Modifier	Constructor	Description
	VertexSequencePackedRtree(Coordinate[] pts)	Creates a new tree over the given sequence of coordinates.

Uses of Coordinate in org.locationtech.jts.index.chain

Methods in org.locationtech.jts.index.chain that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	MonotoneChain.getCoordinates()	Return the subsequence of coordinates forming this chain.

Methods in org.locationtech.jts.index.chain with parameters of type Coordinate

Modifier and Type	Method	Description
static List	MonotoneChainBuilder.getChains(Coordinate[] pts)	Computes a list of the MonotoneChains for a list of coordinates.
static List	MonotoneChainBuilder.getChains(Coordinate[] pts, Object context)	Computes a list of the MonotoneChains for a list of coordinates, attaching a context data object to each.

Constructors in org.locationtech.jts.index.chain with parameters of type Coordinate

Modifier	Constructor	Description
	MonotoneChain(Coordinate[] pts, int start, int end, Object context)	Creates a new MonotoneChain based on the given array of points.

Uses of Coordinate in org.locationtech.jts.index.kdtree

Methods in org.locationtech.jts.index.kdtree that return Coordinate

Modifier and Type	Method	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.

Methods in org.locationtech.jts.index.kdtree with parameters of type Coordinate

Modifier and Type	Method	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.

Constructors in org.locationtech.jts.index.kdtree with parameters of type Coordinate

Modifier	Constructor	Description
	KdNode(Coordinate p, Object data)	Creates a new KdNode.

Uses of Coordinate in org.locationtech.jts.index.quadtree

Methods in org.locationtech.jts.index.quadtree that return Coordinate

Modifier and Type	Method	Description
Coordinate	Key.getCentre()
Coordinate	Key.getPoint()

Uses of Coordinate in org.locationtech.jts.io

Methods in org.locationtech.jts.io with parameters of type Coordinate

Modifier and Type	Method	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 Coordinates.
static String	WKTWriter.toPoint(Coordinate p0)	Generates the WKT for a POINT specified by a Coordinate.

Uses of Coordinate in org.locationtech.jts.linearref

Methods in org.locationtech.jts.linearref that return Coordinate

Modifier and Type	Method	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).

Methods in org.locationtech.jts.linearref with parameters of type Coordinate

Modifier and Type	Method	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.

Uses of Coordinate in org.locationtech.jts.math

Methods in org.locationtech.jts.math that return Coordinate

Modifier and Type	Method	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)

Methods in org.locationtech.jts.math with parameters of type Coordinate

Modifier and Type	Method	Description
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 Vector3D	Vector3D.create(Coordinate coord)	Creates a vector from a 3D Coordinate.
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)	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)

Constructors in org.locationtech.jts.math with parameters of type Coordinate

Modifier	Constructor	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 Coordinates.

Uses of Coordinate in org.locationtech.jts.noding

Fields in org.locationtech.jts.noding declared as Coordinate

Modifier and Type	Field	Description
final Coordinate	SegmentNode.coord

Methods in org.locationtech.jts.noding that return Coordinate

Modifier and Type	Method	Description
Coordinate	BasicSegmentString.getCoordinate(int i)
Coordinate	NodedSegmentString.getCoordinate(int i)
Coordinate	SegmentNode.getCoordinate()	Gets the Coordinate giving the location of this node.
Coordinate	SegmentString.getCoordinate(int i)	Gets the segment string coordinate at a given index.
Coordinate[]	BasicSegmentString.getCoordinates()
Coordinate[]	NodedSegmentString.getCoordinates()
Coordinate[]	SegmentString.getCoordinates()	Gets the coordinates in this segment string.
Coordinate	NodingIntersectionFinder.getIntersection()	Gets the computed location of the intersection.
Coordinate	SegmentIntersectionDetector.getIntersection()	Gets the computed location of the intersection.
Coordinate[]	NodingIntersectionFinder.getIntersectionSegments()	Gets the endpoints of the intersecting segments.
Coordinate[]	SegmentIntersectionDetector.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.
default Coordinate	SegmentString.nextInRing(int index)	Gets the next vertex in a ring from a vertex index.
default Coordinate	SegmentString.prevInRing(int index)	Gets the previous vertex in a ring from a vertex index.

Methods in org.locationtech.jts.noding with parameters of type Coordinate

Modifier and Type	Method	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.

Constructors in org.locationtech.jts.noding with parameters of type Coordinate

Modifier	Constructor	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)

Uses of Coordinate in org.locationtech.jts.noding.snap

Methods in org.locationtech.jts.noding.snap that return Coordinate

Modifier and Type	Method	Description
Coordinate	SnappingPointIndex.snap(Coordinate p)	Snaps a coordinate to an existing snap point, if it is within the snap tolerance distance.

Methods in org.locationtech.jts.noding.snap with parameters of type Coordinate

Modifier and Type	Method	Description
Coordinate	SnappingPointIndex.snap(Coordinate p)	Snaps a coordinate to an existing snap point, if it is within the snap tolerance distance.

Uses of Coordinate in org.locationtech.jts.noding.snapround

Methods in org.locationtech.jts.noding.snapround that return Coordinate

Modifier and Type	Method	Description
Coordinate	HotPixel.getCoordinate()	Gets the coordinate this hot pixel is based at.

Methods in org.locationtech.jts.noding.snapround that return types with arguments of type Coordinate

Modifier and Type	Method	Description
List<Coordinate>	SnapRoundingIntersectionAdder.getIntersections()	Gets the created intersection nodes, so they can be processed as hot pixels.

Methods in org.locationtech.jts.noding.snapround with parameters of type Coordinate

Modifier and Type	Method	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.

Constructors in org.locationtech.jts.noding.snapround with parameters of type Coordinate

Modifier	Constructor	Description
	HotPixel(Coordinate pt, double scaleFactor)	Creates a new hot pixel centered on a rounded point, using a given scale factor.

Uses of Coordinate in org.locationtech.jts.operation

Methods in org.locationtech.jts.operation that return Coordinate

Modifier and Type	Method	Description
Coordinate	IsSimpleOp.getNonSimpleLocation()	Deprecated. Gets a coordinate for the location where the geometry fails to be simple.

Uses of Coordinate in org.locationtech.jts.operation.buffer

Methods in org.locationtech.jts.operation.buffer that return Coordinate

Modifier and Type	Method	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 line, double distance)	Gets the raw offset curve for a line at a given distance, with default buffer parameters.
static Coordinate[]	OffsetCurve.rawOffset(LineString line, double distance, BufferParameters bufParams)	Gets the raw offset curve for a line at a given distance.
Coordinate[]	BufferInputLineSimplifier.simplify(double distanceTol)	Simplify the input coordinate list.
static Coordinate[]	BufferInputLineSimplifier.simplify(Coordinate[] inputLine, double distanceTol)	Simplify the input coordinate list.

Methods in org.locationtech.jts.operation.buffer with parameters of type Coordinate

Modifier and Type	Method	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.

Constructors in org.locationtech.jts.operation.buffer with parameters of type Coordinate

Modifier	Constructor	Description
	BufferInputLineSimplifier(Coordinate[] inputLine)

Uses of Coordinate in org.locationtech.jts.operation.buffer.validate

Methods in org.locationtech.jts.operation.buffer.validate that return Coordinate

Modifier and Type	Method	Description
Coordinate	PointPairDistance.getCoordinate(int i)
Coordinate[]	PointPairDistance.getCoordinates()
Coordinate	BufferDistanceValidator.getErrorLocation()
Coordinate	BufferResultValidator.getErrorLocation()

Methods in org.locationtech.jts.operation.buffer.validate with parameters of type Coordinate

Modifier and Type	Method	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)

Uses of Coordinate in org.locationtech.jts.operation.distance

Methods in org.locationtech.jts.operation.distance that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	DistanceOp.closestPoints()	Deprecated. renamed to nearestPoints
static Coordinate[]	DistanceOp.closestPoints(Geometry g0, Geometry g1)	Deprecated. renamed to nearestPoints
Coordinate	FacetSequence.getCoordinate(int index)
Coordinate	GeometryLocation.getCoordinate()	Returns the Coordinate of this location.
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.
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.

Constructors in org.locationtech.jts.operation.distance with parameters of type Coordinate

Modifier	Constructor	Description
	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).
	GeometryLocation(Geometry component, Coordinate pt)	Constructs a GeometryLocation specifying a point inside an area geometry.

Uses of Coordinate in org.locationtech.jts.operation.distance3d

Methods in org.locationtech.jts.operation.distance3d that return Coordinate

Modifier and Type	Method	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()

Methods in org.locationtech.jts.operation.distance3d with parameters of type Coordinate

Modifier and Type	Method	Description
void	AxisPlaneCoordinateSequence.getCoordinate(int index, Coordinate coord)
boolean	PlanarPolygon3D.intersects(Coordinate intPt)
boolean	PlanarPolygon3D.intersects(Coordinate pt, LineString ring)

Uses of Coordinate in org.locationtech.jts.operation.linemerge

Constructors in org.locationtech.jts.operation.linemerge with parameters of type Coordinate

Modifier	Constructor	Description
	LineMergeDirectedEdge(Node from, Node to, Coordinate directionPt, boolean edgeDirection)	Constructs a LineMergeDirectedEdge connecting the from node to the to node.

Uses of Coordinate in org.locationtech.jts.operation.overlay

Methods in org.locationtech.jts.operation.overlay with parameters of type Coordinate

Modifier and Type	Method	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.

Uses of Coordinate in org.locationtech.jts.operation.overlay.snap

Methods in org.locationtech.jts.operation.overlay.snap that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	LineStringSnapper.snapTo(Coordinate[] snapPts)	Snaps the vertices and segments of the source LineString to the given set of snap vertices.

Methods in org.locationtech.jts.operation.overlay.snap with parameters of type Coordinate

Modifier and Type	Method	Description
Coordinate[]	LineStringSnapper.snapTo(Coordinate[] snapPts)	Snaps the vertices and segments of the source LineString to the given set of snap vertices.

Constructors in org.locationtech.jts.operation.overlay.snap with parameters of type Coordinate

Modifier	Constructor	Description
	LineStringSnapper(Coordinate[] srcPts, double snapTolerance)	Creates a new snapper using the given points as source points to be snapped.

Uses of Coordinate in org.locationtech.jts.operation.overlay.validate

Methods in org.locationtech.jts.operation.overlay.validate that return Coordinate

Modifier and Type	Method	Description
Coordinate	OverlayResultValidator.getInvalidLocation()

Methods in org.locationtech.jts.operation.overlay.validate with parameters of type Coordinate

Modifier and Type	Method	Description
int	FuzzyPointLocator.getLocation(Coordinate pt)

Uses of Coordinate in org.locationtech.jts.operation.overlayng

Methods in org.locationtech.jts.operation.overlayng that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	RingClipper.clip(Coordinate[] pts)	Clips a list of points to the clipping rectangle box.

Methods in org.locationtech.jts.operation.overlayng with parameters of type Coordinate

Modifier and Type	Method	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.

Uses of Coordinate in org.locationtech.jts.operation.relate

Methods in org.locationtech.jts.operation.relate with parameters of type Coordinate

Modifier and Type	Method	Description
Node	RelateNodeFactory.createNode(Coordinate coord)

Constructors in org.locationtech.jts.operation.relate with parameters of type Coordinate

Modifier	Constructor	Description
	RelateNode(Coordinate coord, EdgeEndStar edges)

Uses of Coordinate in org.locationtech.jts.operation.valid

Methods in org.locationtech.jts.operation.valid that return Coordinate

Modifier and Type	Method	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.

Methods in org.locationtech.jts.operation.valid that return types with arguments of type Coordinate

Modifier and Type	Method	Description
List<Coordinate>	IsSimpleOp.getNonSimpleLocations()	Gets all non-simple intersection locations.

Methods in org.locationtech.jts.operation.valid with parameters of type Coordinate

Modifier and Type	Method	Description
boolean	RepeatedPointTester.hasRepeatedPoint(Coordinate[] coord)
static boolean	IsValidOp.isValid(Coordinate coord)	Checks whether a coordinate is valid for processing.

Constructors in org.locationtech.jts.operation.valid with parameters of type Coordinate

Modifier	Constructor	Description
	TopologyValidationError(int errorType, Coordinate pt)	Creates a validation error with the given type and location

Uses of Coordinate in org.locationtech.jts.planargraph

Fields in org.locationtech.jts.planargraph declared as Coordinate

Modifier and Type	Field	Description
protected Coordinate	DirectedEdge.p0
protected Coordinate	DirectedEdge.p1
protected Coordinate	Node.pt	The location of this Node

Methods in org.locationtech.jts.planargraph that return Coordinate

Modifier and Type	Method	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.

Methods in org.locationtech.jts.planargraph with parameters of type Coordinate

Modifier and Type	Method	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)	Returns the Node at the given location, or null if no Node was there.
Node	NodeMap.remove(Coordinate pt)	Removes the Node at the given location, and returns it (or null if no Node was there).

Constructors in org.locationtech.jts.planargraph with parameters of type Coordinate

Modifier	Constructor	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.

Uses of Coordinate in org.locationtech.jts.precision

Methods in org.locationtech.jts.precision that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates, Geometry geom)
Coordinate	CommonBitsRemover.getCommonCoordinate()	The common bits of the Coordinates in the supplied Geometries.

Methods in org.locationtech.jts.precision with parameters of type Coordinate

Modifier and Type	Method	Description
Coordinate[]	PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates, Geometry geom)

Uses of Coordinate in org.locationtech.jts.shape

Methods in org.locationtech.jts.shape that return Coordinate

Modifier and Type	Method	Description
protected Coordinate	GeometricShapeBuilder.createCoord(double x, double y)
Coordinate	GeometricShapeBuilder.getCentre()

Uses of Coordinate in org.locationtech.jts.shape.fractal

Methods in org.locationtech.jts.shape.fractal that return Coordinate

Modifier and Type	Method	Description
static Coordinate	HilbertCode.decode(int level, int index)	Computes the point on a Hilbert curve of given level for a given code index.
static Coordinate	MortonCode.decode(int index)	Computes the point on the Morton curve for a given index.

Methods in org.locationtech.jts.shape.fractal with parameters of type Coordinate

Modifier and Type	Method	Description
void	KochSnowflakeBuilder.addSide(int level, Coordinate p0, Coordinate p1)

Uses of Coordinate in org.locationtech.jts.shape.random

Methods in org.locationtech.jts.shape.random that return Coordinate

Modifier and Type	Method	Description
protected Coordinate	RandomPointsBuilder.createCoord(double x, double y)
protected Coordinate	RandomPointsBuilder.createRandomCoord(Envelope env)

Methods in org.locationtech.jts.shape.random with parameters of type Coordinate

Modifier and Type	Method	Description
protected boolean	RandomPointsBuilder.isInExtent(Coordinate p)

Uses of Coordinate in org.locationtech.jts.simplify

Methods in org.locationtech.jts.simplify that return Coordinate

Modifier and Type	Method	Description
Coordinate	LinkedLine.getCoordinate(int index)
Coordinate[]	LinkedLine.getCoordinates()
Coordinate	LinkedLine.nextCoordinate(int index)
Coordinate	LinkedLine.prevCoordinate(int index)

Constructors in org.locationtech.jts.simplify with parameters of type Coordinate

Modifier	Constructor	Description
	LinkedLine(Coordinate[] pts)

Uses of Coordinate in org.locationtech.jts.triangulate

Methods in org.locationtech.jts.triangulate that return Coordinate

Modifier and Type	Method	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	MidpointSplitPointFinder.findSplitPoint(Segment seg, Coordinate encroachPt)	Gets the midpoint of the split segment
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	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

Methods in org.locationtech.jts.triangulate with parameters of type Coordinate

Modifier and Type	Method	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	MidpointSplitPointFinder.findSplitPoint(Segment seg, Coordinate encroachPt)	Gets the midpoint of the split segment
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.
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(double length, Coordinate endPt)
void	SplitSegment.splitAt(Coordinate pt)
static CoordinateList	DelaunayTriangulationBuilder.unique(Coordinate[] coords)

Constructors in org.locationtech.jts.triangulate with parameters of type Coordinate

Modifier	Constructor	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.

Uses of Coordinate in org.locationtech.jts.triangulate.polygon

Methods in org.locationtech.jts.triangulate.polygon that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	PolygonHoleJoiner.compute()	Computes the joined ring.
static Coordinate[]	PolygonHoleJoiner.join(Polygon polygon)	Joins the shell and holes of a polygon and returns the result as sequence of Coordinates.

Uses of Coordinate in org.locationtech.jts.triangulate.quadedge

Methods in org.locationtech.jts.triangulate.quadedge that return Coordinate

Modifier and Type	Method	Description
Coordinate	QuadEdgeTriangle.getCoordinate(int i)
Coordinate	Vertex.getCoordinate()
Coordinate[]	QuadEdgeTriangle.getCoordinates()

Methods in org.locationtech.jts.triangulate.quadedge with parameters of type Coordinate

Modifier and Type	Method	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)

Constructors in org.locationtech.jts.triangulate.quadedge with parameters of type Coordinate

Modifier	Constructor	Description
	Vertex(Coordinate _p)

Uses of Coordinate in org.locationtech.jts.triangulate.tri

Fields in org.locationtech.jts.triangulate.tri declared as Coordinate

Modifier and Type	Field	Description
protected Coordinate	Tri.p0
protected Coordinate	Tri.p1
protected Coordinate	Tri.p2

Methods in org.locationtech.jts.triangulate.tri that return Coordinate

Modifier and Type	Method	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.

Methods in org.locationtech.jts.triangulate.tri with parameters of type Coordinate

Modifier and Type	Method	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.

Constructors in org.locationtech.jts.triangulate.tri with parameters of type Coordinate

Modifier	Constructor	Description
	Tri(Coordinate p0, Coordinate p1, Coordinate p2)	Creates a triangle with the given vertices.

Uses of Coordinate in org.locationtech.jts.util

Fields in org.locationtech.jts.util declared as Coordinate

Modifier and Type	Field	Description
Coordinate	GeometricShapeFactory.Dimensions.base
Coordinate	GeometricShapeFactory.Dimensions.centre

Methods in org.locationtech.jts.util that return Coordinate

Modifier and Type	Method	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.

Methods in org.locationtech.jts.util with parameters of type Coordinate

Modifier and Type	Method	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	CoordinateArrayFilter.filter(Coordinate coord)
void	CoordinateCountFilter.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.Dimensions.setBase(Coordinate base)
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.setCentre(Coordinate centre)
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)

Uses of Coordinate in org.locationtech.jtsexample.geom

Subclasses of Coordinate in org.locationtech.jtsexample.geom

Modifier and Type	Class	Description
class	ExtendedCoordinate

Methods in org.locationtech.jtsexample.geom that return Coordinate

Modifier and Type	Method	Description
Coordinate	ExtendedCoordinateSequence.createCoordinate()
Coordinate	ExtendedCoordinateSequence.getCoordinate(int i)
Coordinate	ExtendedCoordinateSequence.getCoordinateCopy(int index)
Coordinate[]	ExtendedCoordinateSequence.toCoordinateArray()

Methods in org.locationtech.jtsexample.geom with parameters of type Coordinate

Modifier and Type	Method	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)
void	ExtendedCoordinate.setCoordinate(Coordinate other)

Constructors in org.locationtech.jtsexample.geom with parameters of type Coordinate

Modifier	Constructor	Description
	ExtendedCoordinate(Coordinate coord)
	ExtendedCoordinateSequence(Coordinate[] copyCoords)	Constructor that makes a copy of an array of Coordinates.

Uses of Coordinate in org.locationtech.jtslab.geom.util

Methods in org.locationtech.jtslab.geom.util that return Coordinate

Modifier and Type	Method	Description
abstract Coordinate[]	GeometryEditorEx.CoordinateOperation.edit(Coordinate[] coordinates, Geometry geometry)	Edits the array of Coordinates from a Geometry.

Methods in org.locationtech.jtslab.geom.util with parameters of type Coordinate

Modifier and Type	Method	Description
abstract Coordinate[]	GeometryEditorEx.CoordinateOperation.edit(Coordinate[] coordinates, Geometry geometry)	Edits the array of Coordinates from a Geometry.

Uses of Coordinate in org.locationtech.jtstest.clean

Methods in org.locationtech.jtstest.clean that return Coordinate

Modifier and Type	Method	Description
static Coordinate[]	CleanDuplicatePoints.removeDuplicatePoints(Coordinate[] coord)

Methods in org.locationtech.jtstest.clean with parameters of type Coordinate

Modifier and Type	Method	Description
static Coordinate[]	CleanDuplicatePoints.removeDuplicatePoints(Coordinate[] coord)

Uses of Coordinate in org.locationtech.jtstest.testbuilder

Methods in org.locationtech.jtstest.testbuilder that return Coordinate

Modifier and Type	Method	Description
Coordinate	ValidPanel.getMarkPoint()

Methods in org.locationtech.jtstest.testbuilder with parameters of type Coordinate

Modifier and Type	Method	Description
String	GeometryEditPanel.getInfo(Coordinate pt)
void	GeometryEditPanel.setHighlightPoint(Coordinate pt)

Uses of Coordinate in org.locationtech.jtstest.testbuilder.controller

Methods in org.locationtech.jtstest.testbuilder.controller with parameters of type Coordinate

Modifier and Type	Method	Description
void	JTSTestBuilderController.copyComponentToClipboard(Coordinate pt)
void	JTSTestBuilderController.displayInfo(Coordinate modelPt)
void	JTSTestBuilderController.extractComponentsToTestCase(Coordinate pt)

Uses of Coordinate in org.locationtech.jtstest.testbuilder.geom

Methods in org.locationtech.jtstest.testbuilder.geom that return Coordinate

Modifier and Type	Method	Description
static Coordinate	NearestPointFinder.findNearestPoint(Geometry geom, Coordinate pt, double tolerance)
static Coordinate[]	AdjacentVertexFinder.findVertices(Geometry geom, Coordinate testPt)
Coordinate	ConstrainedInteriorPoint.getCoordinate()
static Coordinate	ConstrainedInteriorPoint.getCoordinate(Polygon poly)
static Coordinate	ConstrainedInteriorPoint.getCoordinate(Polygon poly, Envelope constraint)
static Coordinate	ConstrainedInteriorPoint.getCoordinate(Polygon poly, Geometry constraint)
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)

Methods in org.locationtech.jtstest.testbuilder.geom with parameters of type Coordinate

Modifier and Type	Method	Description
Geometry	GeometryCombiner.addLineString(Geometry orig, Coordinate[] pts)
Geometry	GeometryCombiner.addPoint(Geometry orig, Coordinate pt)
Geometry	GeometryCombiner.addPolygonRing(Geometry orig, Coordinate[] pts)
LineSegment	EnvelopeClipper.clip(Coordinate p0, Coordinate p1)
static void	SegmentClipper.clip(Coordinate p0, Coordinate p1, Envelope env)
static Coordinate	NearestPointFinder.findNearestPoint(Geometry geom, Coordinate pt, double tolerance)
static Coordinate[]	AdjacentVertexFinder.findVertices(Geometry geom, Coordinate testPt)
List<GeometryLocation>	ComponentLocater.getComponents(Coordinate queryPt, double tolerance)
static List<GeometryLocation>	ComponentLocater.getComponents(Geometry parentGeom, Coordinate queryPt, double tolerance)
GeometryLocation	GeometryPointLocater.getLocation(Coordinate testPt, boolean vertexOnly, double tolerance)
List	FacetLocater.getLocations(Coordinate queryPt, double tolerance)
List	VertexLocater.getLocations(Coordinate testPt, 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.locate(Geometry geom, Coordinate testPt, double tolerance)
static GeometryLocation	GeometryPointLocater.locateNonVertexPoint(Geometry geom, Coordinate testPt, double tolerance)
static GeometryLocation	GeometryPointLocater.locateVertex(Geometry geom, Coordinate testPt, double tolerance)
static Coordinate	VertexLocater.locateVertex(Geometry geom, Coordinate testPt, double tolerance)
static Geometry	GeometryVertexMover.move(Geometry geom, Coordinate fromLoc, Coordinate toLoc)

Constructors in org.locationtech.jtstest.testbuilder.geom with parameters of type Coordinate

Modifier	Constructor	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)

Uses of Coordinate in org.locationtech.jtstest.testbuilder.model

Methods in org.locationtech.jtstest.testbuilder.model that return Coordinate

Modifier and Type	Method	Description
Coordinate[]	GeometryEditModel.findAdjacentVertices(Coordinate vertex)
Coordinate	GeometryEditModel.locateVertexPt(Coordinate testPt, double tolerance)

Methods in org.locationtech.jtstest.testbuilder.model with parameters of type Coordinate

Modifier and Type	Method	Description
Coordinate[]	GeometryEditModel.findAdjacentVertices(Coordinate vertex)
Geometry	LayerList.getComponent(Coordinate pt, double tolerance)
List<GeometryLocation>	GeometryEditModel.getComponents(Coordinate testPt, 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)

Uses of Coordinate in org.locationtech.jtstest.testbuilder.topostretch

Methods in org.locationtech.jtstest.testbuilder.topostretch that return Coordinate

Modifier and Type	Method	Description
Coordinate	StretchedVertex.getStretchedVertex(double dist)	Gets the point which this near vertex will be stretched to (by a given distance)
Coordinate	StretchedVertex.getVertexCoordinate()

Constructors in org.locationtech.jtstest.testbuilder.topostretch with parameters of type Coordinate

Modifier	Constructor	Description
	StretchedVertex(Coordinate vertexPt, Coordinate nearPt, Coordinate[] nearPts, int nearIndex)	Creates a vertex which lies near a vertex
	StretchedVertex(Coordinate vertexPt, LineSegment nearSeg)	Creates a vertex for a point which lies near a line segment

Uses of Coordinate in org.locationtech.jtstest.testbuilder.ui

Methods in org.locationtech.jtstest.testbuilder.ui that return Coordinate

Modifier and Type	Method	Description
Coordinate	Viewport.toModelCoordinate(Point2D viewPt)

Methods in org.locationtech.jtstest.testbuilder.ui with parameters of type Coordinate

Modifier and Type	Method	Description
boolean	Viewport.containsInModel(Coordinate p)
boolean	Viewport.containsInModel(Coordinate p0, Coordinate p1)
boolean	Viewport.intersectsInModel(Coordinate p0, Coordinate p1)
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)
static String	GeometryLocationsWriter.writeLocation(LayerList layers, Coordinate pt, double tolerance)
String	GeometryLocationsWriter.writeLocation(Layer lyr, Coordinate p, double tolerance)
String	GeometryLocationsWriter.writeLocationString(LayerList layers, Coordinate pt, double tolerance)
String	GeometryLocationsWriter.writeSingleLocation(Layer lyr, Coordinate p, double tolerance)

Uses of Coordinate in org.locationtech.jtstest.testbuilder.ui.style

Methods in org.locationtech.jtstest.testbuilder.ui.style with parameters of type Coordinate

Modifier and Type	Method	Description
protected void	SegmentStyle.paint(int index, Coordinate p0, Coordinate p1, int lineType, Viewport viewport, Graphics2D g)

Uses of Coordinate in org.locationtech.jtstest.testbuilder.ui.tools

Fields in org.locationtech.jtstest.testbuilder.ui.tools declared as Coordinate

Modifier and Type	Field	Description
protected Coordinate	LineBandTool.tentativeCoordinate

Methods in org.locationtech.jtstest.testbuilder.ui.tools that return Coordinate

Modifier and Type	Method	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)

Methods in org.locationtech.jtstest.testbuilder.ui.tools with parameters of type Coordinate

Modifier and Type	Method	Description
protected void	LineBandTool.add(Coordinate c)