|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Coordinate | |
---|---|
com.vividsolutions.jts.algorithm | Contains classes and interfaces implementing fundamental computational geometry algorithms. |
com.vividsolutions.jts.algorithm.distance | Classes to compute distance metrics between geonetries. |
com.vividsolutions.jts.algorithm.locate | Classes to determine the topological location of points in geometries. |
com.vividsolutions.jts.awt | Classes to perform conversions from Java2D shape objects. |
com.vividsolutions.jts.geom | Contains the Geometry interface hierarchy and supporting classes. |
com.vividsolutions.jts.geom.impl | Implementations of interfaces for geometric structures. |
com.vividsolutions.jts.geom.util | Provides classes that parse and modify Geometry objects. |
com.vividsolutions.jts.geomgraph | Contains classes that implement topology graphs. |
com.vividsolutions.jts.geomgraph.index | Contains classes that implement indexes for performing noding on geometry graph edges. |
com.vividsolutions.jts.index.chain | Contains classes that implement Monotone Chains |
com.vividsolutions.jts.index.kdtree | Contains classes which implement a k-D tree index over 2-D point data. |
com.vividsolutions.jts.index.quadtree | Contains classes that implement a Quadtree spatial index |
com.vividsolutions.jts.io | Contains the interfaces for converting JTS objects to and from other formats. |
com.vividsolutions.jts.linearref | Contains classes and interfaces implementing linear referencing on linear geometries |
com.vividsolutions.jts.math | |
com.vividsolutions.jts.noding | Classes to compute nodings for arrangements of line segments and line segment sequences. |
com.vividsolutions.jts.noding.snapround | Contains classes to implement the Snap Rounding algorithm for noding linestrings. |
com.vividsolutions.jts.operation | Provides classes for implementing operations on geometries |
com.vividsolutions.jts.operation.buffer | Provides classes for computing buffers of geometries |
com.vividsolutions.jts.operation.buffer.validate | Classes to perform validation of the results of buffer operations. |
com.vividsolutions.jts.operation.distance | Provides classes for computing the distance between geometries |
com.vividsolutions.jts.operation.distance3d | |
com.vividsolutions.jts.operation.linemerge | Classes to perform line merging. |
com.vividsolutions.jts.operation.overlay | Contains classes that perform a topological overlay to compute boolean spatial functions. |
com.vividsolutions.jts.operation.overlay.snap | Classes to perform snapping on geometries to prepare them for overlay operations. |
com.vividsolutions.jts.operation.overlay.validate | Classes to validate the results of overlay operations. |
com.vividsolutions.jts.operation.relate | Contains classes to implement the computation of the spatial relationships of Geometry s. |
com.vividsolutions.jts.operation.valid | Provides classes for testing the validity of geometries. |
com.vividsolutions.jts.planargraph | Contains classes to implement a planar graph data structure. |
com.vividsolutions.jts.precision | Provides classes for analyzing and manipulating the precision of Geometries. |
com.vividsolutions.jts.shape | |
com.vividsolutions.jts.shape.fractal | |
com.vividsolutions.jts.shape.random | |
com.vividsolutions.jts.triangulate | Classes to compute Delaunay triangulations. |
com.vividsolutions.jts.triangulate.quadedge | Classes to implement a topological subdivision of quadeges, to support creating triangulations and Voronoi diagrams. |
com.vividsolutions.jts.util | Contains support classes for the Java Topology Suite. |
com.vividsolutions.jtsexample.geom |
Uses of Coordinate in com.vividsolutions.jts.algorithm |
---|
Fields in com.vividsolutions.jts.algorithm declared as Coordinate | |
---|---|
protected Coordinate[][] |
LineIntersector.inputLines
|
protected Coordinate[] |
LineIntersector.intPt
|
protected Coordinate |
LineIntersector.pa
|
protected Coordinate |
LineIntersector.pb
|
Methods in com.vividsolutions.jts.algorithm that return Coordinate | |
---|---|
Coordinate |
InteriorPointArea.centre(Envelope envelope)
Returns the centre point of the envelope. |
Coordinate |
MinimumBoundingCircle.getCentre()
Gets the centre point of the computed Minimum Bounding Circle. |
Coordinate |
CentroidPoint.getCentroid()
|
Coordinate |
CentroidLine.getCentroid()
|
Coordinate |
CentroidArea.getCentroid()
|
Coordinate |
HCoordinate.getCoordinate()
|
Coordinate |
LineIntersector.getEndpoint(int segmentIndex,
int ptIndex)
Gets an endpoint of an input segment. |
Coordinate[] |
MinimumBoundingCircle.getExtremalPoints()
Gets the extremal points which define the computed Minimum Bounding Circle. |
Coordinate |
InteriorPointPoint.getInteriorPoint()
|
Coordinate |
InteriorPointLine.getInteriorPoint()
|
Coordinate |
InteriorPointArea.getInteriorPoint()
|
Coordinate |
CentralEndpointIntersector.getIntersection()
|
static Coordinate |
CentralEndpointIntersector.getIntersection(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
|
Coordinate |
LineIntersector.getIntersection(int intIndex)
Returns the intIndex'th intersection point |
Coordinate |
LineIntersector.getIntersectionAlongSegment(int segmentIndex,
int intIndex)
Computes the intIndex'th intersection point in the direction of a specified input line segment |
Coordinate |
MinimumDiameter.getWidthCoordinate()
Gets the Coordinate forming one end of the minimum diameter |
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the (approximate) intersection point between two line segments using homogeneous coordinates. |
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines using DD arithmetic. |
protected Coordinate[] |
ConvexHull.toCoordinateArray(Stack stack)
An alternative to Stack.toArray, which is not present in earlier versions of Java. |
Methods in com.vividsolutions.jts.algorithm with parameters of type Coordinate | |
---|---|
void |
CentroidPoint.add(Coordinate pt)
Adds the length defined by an array of coordinates. |
void |
CentroidLine.add(Coordinate[] pts)
Adds the length defined by an array of coordinates. |
void |
CentroidArea.add(Coordinate[] ring)
Adds the area defined by an array of coordinates. |
static double |
Angle.angle(Coordinate p)
Returns the angle that the vector from (0,0) to p, relative to the positive X-axis. |
static double |
Angle.angle(Coordinate p0,
Coordinate p1)
Returns the angle of the vector from p0 to p1, relative to the positive X-axis. |
static double |
Angle.angleBetween(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Returns the unoriented smallest angle between two vectors. |
static double |
Angle.angleBetweenOriented(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Returns the oriented smallest angle between two vectors. |
static double |
LineIntersector.computeEdgeDistance(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the "edge distance" of an intersection point p along a segment. |
protected int |
RobustLineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
|
protected int |
NonRobustLineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate p3,
Coordinate p4)
|
protected abstract int |
LineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
|
void |
RobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2)
|
void |
NonRobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2)
|
abstract void |
LineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2)
Compute the intersection of a point p and the line p1-p2. |
void |
LineIntersector.computeIntersection(Coordinate p1,
Coordinate p2,
Coordinate p3,
Coordinate p4)
Computes the intersection of the lines p1-p2 and p3-p4. |
static int |
NonRobustCGAlgorithms.computeOrientation(Coordinate p1,
Coordinate p2,
Coordinate q)
Computes the orientation of a point q to the directed line segment p1-p2. |
static int |
CGAlgorithms.computeOrientation(Coordinate p1,
Coordinate p2,
Coordinate q)
Computes the orientation of a point q to the directed line segment p1-p2. |
void |
RayCrossingCounter.countSegment(Coordinate p1,
Coordinate p2)
Counts a segment |
static double |
CGAlgorithms3D.distance(Coordinate p0,
Coordinate p1)
|
static double |
NonRobustCGAlgorithms.distanceLineLine(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance from a line segment AB to a line segment CD Note: NON-ROBUST! |
static double |
CGAlgorithms.distanceLineLine(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance from a line segment AB to a line segment CD Note: NON-ROBUST! |
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments. |
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments. |
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate A,
Coordinate B)
Computes the distance from a point p to a line segment AB Note: NON-ROBUST! |
static double |
CGAlgorithms.distancePointLinePerpendicular(Coordinate p,
Coordinate A,
Coordinate B)
Computes the perpendicular distance from a point p to the (infinite) line containing the points AB |
static double |
CGAlgorithms3D.distancePointSegment(Coordinate p,
Coordinate A,
Coordinate B)
|
static double |
CGAlgorithms3D.distanceSegmentSegment(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance between two 3D segments. |
static Coordinate |
CentralEndpointIntersector.getIntersection(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
|
static double |
Angle.interiorAngle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Computes the interior angle between two segments of a ring. |
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the (approximate) intersection point between two line segments using homogeneous coordinates. |
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines using DD arithmetic. |
boolean |
RectangleLineIntersector.intersects(Coordinate p0,
Coordinate p1)
Tests whether the query rectangle intersects a given line segment. |
boolean |
PointLocator.intersects(Coordinate p,
Geometry geom)
Convenience method to test a point for intersection with a Geometry |
static boolean |
Angle.isAcute(Coordinate p0,
Coordinate p1,
Coordinate p2)
Tests whether the angle between p0-p1-p2 is acute. |
static boolean |
NonRobustCGAlgorithms.isCCW(Coordinate[] ring)
Computes whether a ring defined by an array of Coordinate is
oriented counter-clockwise. |
static boolean |
CGAlgorithms.isCCW(Coordinate[] ring)
Computes whether a ring defined by an array of Coordinate s is
oriented counter-clockwise. |
boolean |
SimplePointInRing.isInside(Coordinate pt)
|
boolean |
PointInRing.isInside(Coordinate pt)
|
boolean |
MCPointInRing.isInside(Coordinate pt)
|
boolean |
LineIntersector.isIntersection(Coordinate pt)
Test whether a point is a intersection point of two line segments. |
static boolean |
Angle.isObtuse(Coordinate p0,
Coordinate p1,
Coordinate p2)
Tests whether the angle between p0-p1-p2 is obtuse. |
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Tests whether a point lies on the line segments defined by a list of coordinates. |
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Tests whether a point lies on the line segments defined by a list of coordinates. |
static boolean |
NonRobustCGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Computes whether a ring defined by an array of Coordinate is
oriented counter-clockwise. |
static boolean |
NonRobustCGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Computes whether a ring defined by an array of Coordinate is
oriented counter-clockwise. |
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring. |
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring. |
int |
PointLocator.locate(Coordinate p,
Geometry geom)
Computes the topological relationship ( Location ) of a single point
to a Geometry. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines the Location of a point in a ring. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines the Location of a point in a ring. |
static int |
CGAlgorithms.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the exterior of a ring. |
static int |
CGAlgorithms.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the exterior of a ring. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
CoordinateSequence ring)
Determines the Location of a point in a ring. |
static double |
LineIntersector.nonRobustComputeEdgeDistance(Coordinate p,
Coordinate p1,
Coordinate p2)
This function is non-robust, since it may compute the square of large numbers. |
static int |
RobustDeterminant.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point q relative to
a vector specified by p1-p2 . |
static int |
NonRobustCGAlgorithms.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point q relative to
a vector specified by p1-p2 . |
static 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 |
CGAlgorithms.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point q relative to
a vector specified by p1-p2 . |
static double |
CGAlgorithms.signedArea(Coordinate[] ring)
Computes the signed area for a ring. |
Constructors in com.vividsolutions.jts.algorithm with parameters of type Coordinate | |
---|---|
CentralEndpointIntersector(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
|
|
ConvexHull(Coordinate[] pts,
GeometryFactory geomFactory)
Create a new convex hull construction for the input Coordinate array. |
|
HCoordinate(Coordinate p)
|
|
HCoordinate(Coordinate p1,
Coordinate p2)
Constructs a homogeneous coordinate which is the intersection of the lines define by the homogenous coordinates represented by two Coordinate s. |
|
HCoordinate(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
|
|
RayCrossingCounter(Coordinate p)
|
Uses of Coordinate in com.vividsolutions.jts.algorithm.distance |
---|
Methods in com.vividsolutions.jts.algorithm.distance that return Coordinate | |
---|---|
Coordinate |
PointPairDistance.getCoordinate(int i)
|
Coordinate[] |
PointPairDistance.getCoordinates()
|
Coordinate[] |
DiscreteHausdorffDistance.getCoordinates()
|
Methods in com.vividsolutions.jts.algorithm.distance with parameters of type Coordinate | |
---|---|
static void |
DistanceToPoint.computeDistance(Geometry geom,
Coordinate pt,
PointPairDistance ptDist)
|
static void |
DistanceToPoint.computeDistance(LineSegment segment,
Coordinate pt,
PointPairDistance ptDist)
|
static void |
DistanceToPoint.computeDistance(LineString line,
Coordinate pt,
PointPairDistance ptDist)
|
static void |
DistanceToPoint.computeDistance(Polygon poly,
Coordinate pt,
PointPairDistance ptDist)
|
void |
DiscreteHausdorffDistance.MaxPointDistanceFilter.filter(Coordinate pt)
|
void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1)
|
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1)
|
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1)
|
Uses of Coordinate in com.vividsolutions.jts.algorithm.locate |
---|
Methods in com.vividsolutions.jts.algorithm.locate with parameters of type Coordinate | |
---|---|
static boolean |
SimplePointInAreaLocator.containsPointInPolygon(Coordinate p,
Polygon poly)
|
int |
SimplePointInAreaLocator.locate(Coordinate p)
|
int |
PointOnGeometryLocator.locate(Coordinate p)
Determines the Location of a point in the Geometry . |
int |
IndexedPointInAreaLocator.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 . |
Uses of Coordinate in com.vividsolutions.jts.awt |
---|
Methods in com.vividsolutions.jts.awt with parameters of type Coordinate | |
---|---|
void |
PointTransformation.transform(Coordinate src,
Point2D dest)
Transforms a Coordinate into a Java2D Point . |
void |
IdentityPointTransformation.transform(Coordinate model,
Point2D view)
|
Constructors in com.vividsolutions.jts.awt with parameters of type Coordinate | |
---|---|
PolygonShape(Coordinate[] shellVertices,
Collection holeVerticesCollection)
Creates a new polygon Shape . |
Uses of Coordinate in com.vividsolutions.jts.geom |
---|
Fields in com.vividsolutions.jts.geom declared as Coordinate | |
---|---|
Coordinate |
Triangle.p0
The coordinates of the vertices of the triangle |
Coordinate |
LineSegment.p0
|
Coordinate |
Triangle.p1
The coordinates of the vertices of the triangle |
Coordinate |
LineSegment.p1
|
Coordinate |
Triangle.p2
The coordinates of the vertices of the triangle |
Methods in com.vividsolutions.jts.geom that return Coordinate | |
---|---|
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment AC. |
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the given amount, or an empty coordinate array. |
Coordinate |
Envelope.centre()
Computes the coordinate of the centre of this envelope (as long as it is non-null |
Coordinate |
Triangle.centroid()
Computes the centroid (centre of mass) of this triangle. |
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle. |
Coordinate |
Triangle.circumcentre()
Computes the circumcentre of this triangle. |
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle. |
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point. |
Coordinate[] |
LineSegment.closestPoints(LineSegment line)
Computes the closest points on two line segments. |
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument Coordinate array. |
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
Extracts a subsequence of the input Coordinate array
from indices start to
end (inclusive). |
Coordinate |
TopologyException.getCoordinate()
|
Coordinate |
Polygon.getCoordinate()
|
Coordinate |
Point.getCoordinate()
|
Coordinate |
LineString.getCoordinate()
|
Coordinate |
GeometryCollection.getCoordinate()
|
abstract Coordinate |
Geometry.getCoordinate()
Returns a vertex of this Geometry
(usually, but not necessarily, the first one). |
protected Coordinate |
MultiPoint.getCoordinate(int n)
Returns the Coordinate at the given position. |
Coordinate |
LineSegment.getCoordinate(int i)
|
Coordinate |
CoordinateSequence.getCoordinate(int i)
Returns (possibly a copy of) the i'th coordinate in this sequence. |
Coordinate |
CoordinateList.getCoordinate(int i)
|
Coordinate |
CoordinateSequence.getCoordinateCopy(int i)
Returns a copy of the i'th coordinate in this sequence. |
Coordinate |
LineString.getCoordinateN(int n)
|
Coordinate[] |
Polygon.getCoordinates()
|
Coordinate[] |
Point.getCoordinates()
|
Coordinate[] |
LineString.getCoordinates()
|
Coordinate[] |
GeometryCollection.getCoordinates()
Collects all coordinates of all subgeometries into an Array. |
abstract Coordinate[] |
Geometry.getCoordinates()
Returns an array containing the values of all the vertices for this geometry. |
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. |
Coordinate |
LineSegment.intersection(LineSegment line)
Computes an intersection point between two line segments, if there is one. |
Coordinate |
LineSegment.lineIntersection(LineSegment line)
Computes the intersection point of the lines of infinite extent defined by two line segments (if there is one). |
Coordinate |
LineSegment.midPoint()
Computes the midpoint of the segment |
static Coordinate |
LineSegment.midPoint(Coordinate p0,
Coordinate p1)
Computes the midpoint of a segment |
static Coordinate |
CoordinateArrays.minCoordinate(Coordinate[] coordinates)
Returns the minimum coordinate, using the usual lexicographic comparison. |
Coordinate |
LineSegment.pointAlong(double segmentLengthFraction)
Computes the Coordinate that lies a given
fraction along the line defined by this segment. |
Coordinate |
LineSegment.pointAlongOffset(double segmentLengthFraction,
double offsetDistance)
Computes the Coordinate that lies a given
fraction along the line defined by this segment and offset from
the segment by a given distance. |
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined by this line segment. |
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points |
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements. |
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points, constructs a new array containing no repeated points. |
Coordinate[] |
CoordinateSequence.toCoordinateArray()
Returns (possibly copies of) the Coordinates in this collection. |
Coordinate[] |
CoordinateList.toCoordinateArray()
Returns the Coordinates in this collection. |
static Coordinate[] |
CoordinateArrays.toCoordinateArray(Collection coordList)
Converts the given Collection of Coordinates into a Coordinate array. |
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated. no longer needed, since internal representation is same as external representation |
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated. use makePrecise instead |
Methods in com.vividsolutions.jts.geom with parameters of type Coordinate | |
---|---|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated)
Adds an array of coordinates to the list. |
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated,
boolean direction)
Adds an array of coordinates to the list. |
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated,
int start,
int end)
Adds a section of an array of coordinates to the list. |
void |
CoordinateList.add(Coordinate coord,
boolean allowRepeated)
Adds a coordinate to the end of the list. |
void |
CoordinateList.add(int i,
Coordinate coord,
boolean allowRepeated)
Inserts the specified coordinate at the specified position in this list. |
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment AC. |
static double |
Triangle.area(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 2D area of a triangle. |
static double |
Triangle.area3D(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 3D area of a triangle. |
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the given amount, or an empty coordinate array. |
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle. |
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle. |
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point. |
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
boolean |
Envelope.contains(Coordinate p)
Tests if the given point lies in or on the envelope. |
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source Coordinate array
into a destination Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source Coordinate array
into a destination Coordinate array. |
boolean |
Envelope.covers(Coordinate p)
Tests if the given point lies in or on the envelope. |
CoordinateSequence |
DefaultCoordinateSequenceFactory.create(Coordinate[] coordinates)
Deprecated. Returns a DefaultCoordinateSequence based on the given array (the array is not copied). |
CoordinateSequence |
CoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns a CoordinateSequence based on the given array. |
LinearRing |
GeometryFactory.createLinearRing(Coordinate[] coordinates)
Creates a LinearRing using the given Coordinate s. |
LineString |
GeometryFactory.createLineString(Coordinate[] coordinates)
Creates a LineString using the given Coordinates; a null or empty array will create an empty LineString. |
MultiPoint |
GeometryFactory.createMultiPoint(Coordinate[] coordinates)
Creates a MultiPoint using the given Coordinate s. |
Point |
GeometryFactory.createPoint(Coordinate coordinate)
Creates a Point using the given Coordinate; a null Coordinate will create an empty Geometry. |
static Point |
GeometryFactory.createPointFromInternalCoord(Coordinate coord,
Geometry exemplar)
|
Polygon |
GeometryFactory.createPolygon(Coordinate[] coordinates)
Constructs a Polygon with the given exterior boundary. |
double |
LineSegment.distance(Coordinate p)
Computes the distance between this line segment and a given point. |
double |
Coordinate.distance(Coordinate p)
Computes the 2-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. |
protected boolean |
Geometry.equal(Coordinate a,
Coordinate b,
double tolerance)
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise equal (as compared using Coordinate#equals) |
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise equal (as compared using Coordinate#equals) |
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2,
Comparator coordinateComparator)
Returns true if the two arrays are identical, both null, or pointwise equal, using a user-defined CoordinateArrays.ForwardComparator for Coordinate s |
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2,
Comparator coordinateComparator)
Returns true if the two arrays are identical, both null, or pointwise equal, using a user-defined CoordinateArrays.ForwardComparator for Coordinate s |
boolean |
Coordinate.equals2D(Coordinate other)
Returns whether the planar projections of the two Coordinate s
are equal. |
boolean |
Coordinate.equals3D(Coordinate other)
Returns true if other has the same values for x,
y and z. |
OctagonalEnvelope |
OctagonalEnvelope.expandToInclude(Coordinate p)
|
void |
Envelope.expandToInclude(Coordinate p)
Enlarges this Envelope so that it contains
the given Coordinate . |
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
Extracts a subsequence of the input Coordinate array
from indices start to
end (inclusive). |
void |
CoordinateFilter.filter(Coordinate coord)
Performs an operation with or on coord . |
void |
CoordinateSequence.getCoordinate(int index,
Coordinate coord)
Copies the i'th coordinate in the sequence to the supplied Coordinate . |
static boolean |
CoordinateArrays.hasRepeatedPoints(Coordinate[] coord)
Returns whether #equals returns true for any two consecutive Coordinates in the given array. |
static Coordinate |
Triangle.inCentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the incentre of a triangle. |
static int |
CoordinateArrays.increasingDirection(Coordinate[] pts)
Determines which orientation of the Coordinate array
is (overall) increasing. |
static int |
CoordinateArrays.indexOf(Coordinate coordinate,
Coordinate[] coordinates)
Returns the index of coordinate in coordinates . |
static int |
CoordinateArrays.indexOf(Coordinate coordinate,
Coordinate[] coordinates)
Returns the index of coordinate in coordinates . |
void |
Envelope.init(Coordinate p)
Initialize an Envelope to a region defined by a single Coordinate. |
void |
Envelope.init(Coordinate p1,
Coordinate p2)
Initialize an Envelope to a region defined by two Coordinates. |
double |
Triangle.interpolateZ(Coordinate p)
Computes the Z-value (elevation) of an XY point on a three-dimensional plane defined by this triangle (whose vertices must have Z-values). |
static double |
Triangle.interpolateZ(Coordinate p,
Coordinate v0,
Coordinate v1,
Coordinate v2)
Computes the Z-value (elevation) of an XY point on a three-dimensional plane defined by a triangle whose vertices have Z-values. |
boolean |
OctagonalEnvelope.intersects(Coordinate p)
|
boolean |
Envelope.intersects(Coordinate p)
Check if the point p
overlaps (lies inside) the region of this Envelope . |
static boolean |
Envelope.intersects(Coordinate p1,
Coordinate p2,
Coordinate q)
Test the point q to see whether it intersects the Envelope defined by p1-p2 |
static boolean |
Envelope.intersects(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Tests whether the envelope defined by p1-p2 and the envelope defined by q1-q2 intersect. |
static boolean |
Triangle.isAcute(Coordinate a,
Coordinate b,
Coordinate c)
Tests whether a triangle is acute. |
boolean |
LineString.isCoordinate(Coordinate pt)
Returns true if the given point is a vertex of this LineString . |
static boolean |
CoordinateArrays.isRing(Coordinate[] pts)
Tests whether an array of Coordinate s forms a ring,
by checking length and closure. |
static double |
Triangle.longestSideLength(Coordinate a,
Coordinate b,
Coordinate c)
Computes the length of the longest side of a triangle |
void |
PrecisionModel.makePrecise(Coordinate coord)
Rounds a Coordinate to the PrecisionModel grid. |
static Coordinate |
LineSegment.midPoint(Coordinate p0,
Coordinate p1)
Computes the midpoint of a segment |
static Coordinate |
CoordinateArrays.minCoordinate(Coordinate[] coordinates)
Returns the minimum coordinate, using the usual lexicographic comparison. |
int |
LineSegment.orientationIndex(Coordinate p)
Determines the orientation index of a Coordinate relative to this segment. |
boolean |
Envelope.overlaps(Coordinate p)
Deprecated. Use #intersects instead. |
static HCoordinate |
Triangle.perpendicularBisector(Coordinate a,
Coordinate b)
Computes the line which is the perpendicular bisector of the line segment a-b. |
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined by this line segment. |
double |
LineSegment.projectionFactor(Coordinate p)
Computes the Projection Factor for the projection of the point p onto this LineSegment. |
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points |
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points |
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements. |
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points, constructs a new array containing no repeated points. |
static void |
CoordinateArrays.reverse(Coordinate[] coord)
Reverses the coordinates in an array in-place. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until firstCoordinate
is first. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until firstCoordinate
is first. |
double |
LineSegment.segmentFraction(Coordinate inputPt)
Computes the fraction of distance (in [0.0, 1.0]) that the projection of a point occurs along this line segment. |
void |
Coordinate.setCoordinate(Coordinate other)
Sets this Coordinate s (x,y,z) values to that of other . |
void |
LineSegment.setCoordinates(Coordinate p0,
Coordinate p1)
|
static double |
Triangle.signedArea(Coordinate a,
Coordinate b,
Coordinate c)
Computes the signed 2D area of a triangle. |
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated. no longer needed, since internal representation is same as external representation |
void |
PrecisionModel.toExternal(Coordinate internal,
Coordinate external)
Deprecated. no longer needed, since internal representation is same as external representation |
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated. use makePrecise instead |
void |
PrecisionModel.toInternal(Coordinate external,
Coordinate internal)
Deprecated. use makePrecise instead |
Constructors in com.vividsolutions.jts.geom with parameters of type Coordinate | |
---|---|
Coordinate(Coordinate c)
Constructs a Coordinate having the same (x,y,z) values as
other . |
|
CoordinateList(Coordinate[] coord)
Constructs a new list from an array of Coordinates, allowing repeated points. |
|
CoordinateList(Coordinate[] coord,
boolean allowRepeated)
Constructs a new list from an array of Coordinates, allowing caller to specify if repeated points are to be removed. |
|
Envelope(Coordinate p)
Creates an Envelope for a region defined by a single Coordinate. |
|
Envelope(Coordinate p1,
Coordinate p2)
Creates an Envelope for a region defined by two Coordinates. |
|
LinearRing(Coordinate[] points,
PrecisionModel precisionModel,
int SRID)
Deprecated. Use GeometryFactory instead |
|
LineSegment(Coordinate p0,
Coordinate p1)
|
|
LineString(Coordinate[] points,
PrecisionModel precisionModel,
int SRID)
Deprecated. Use GeometryFactory instead |
|
OctagonalEnvelope(Coordinate p)
Creates a new null bounding octagon bounding a Coordinate |
|
OctagonalEnvelope(Coordinate p0,
Coordinate p1)
Creates a new null bounding octagon bounding a pair of Coordinate s |
|
Point(Coordinate coordinate,
PrecisionModel precisionModel,
int SRID)
Deprecated. Use GeometryFactory instead |
|
TopologyException(String msg,
Coordinate pt)
|
|
Triangle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Creates a new triangle with the given vertices. |
Uses of Coordinate in com.vividsolutions.jts.geom.impl |
---|
Methods in com.vividsolutions.jts.geom.impl that return Coordinate | |
---|---|
Coordinate |
PackedCoordinateSequence.getCoordinate(int i)
|
Coordinate |
CoordinateArraySequence.getCoordinate(int i)
Get the Coordinate with index i. |
Coordinate |
PackedCoordinateSequence.getCoordinateCopy(int i)
|
Coordinate |
CoordinateArraySequence.getCoordinateCopy(int i)
Get a copy of the Coordinate with index i. |
protected abstract Coordinate |
PackedCoordinateSequence.getCoordinateInternal(int index)
Returns a Coordinate representation of the specified coordinate, by always building a new Coordinate object |
Coordinate |
PackedCoordinateSequence.Double.getCoordinateInternal(int i)
|
Coordinate |
PackedCoordinateSequence.Float.getCoordinateInternal(int i)
|
Coordinate[] |
PackedCoordinateSequence.toCoordinateArray()
|
Coordinate[] |
CoordinateArraySequence.toCoordinateArray()
This method exposes the internal Array of Coordinate Objects |
Methods in com.vividsolutions.jts.geom.impl with parameters of type Coordinate | |
---|---|
CoordinateSequence |
PackedCoordinateSequenceFactory.create(Coordinate[] coordinates)
|
CoordinateSequence |
CoordinateArraySequenceFactory.create(Coordinate[] coordinates)
Returns a CoordinateArraySequence based on the given array (the array is
not copied). |
void |
PackedCoordinateSequence.getCoordinate(int i,
Coordinate coord)
|
void |
CoordinateArraySequence.getCoordinate(int index,
Coordinate coord)
|
Constructors in com.vividsolutions.jts.geom.impl with parameters of type Coordinate | |
---|---|
CoordinateArraySequence(Coordinate[] coordinates)
Constructs a sequence based on the given array of Coordinate s (the
array is not copied). |
|
CoordinateArraySequence(Coordinate[] coordinates,
int dimension)
Constructs a sequence based on the given array of Coordinate s (the
array is not copied). |
|
PackedCoordinateSequence.Double(Coordinate[] coordinates)
Builds a new packed coordinate sequence out of a coordinate array |
|
PackedCoordinateSequence.Double(Coordinate[] coordinates,
int dimension)
Builds a new packed coordinate sequence out of a coordinate array |
|
PackedCoordinateSequence.Float(Coordinate[] coordinates,
int dimension)
Constructs a packed coordinate sequence out of a coordinate array |
Uses of Coordinate in com.vividsolutions.jts.geom.util |
---|
Methods in com.vividsolutions.jts.geom.util that return Coordinate | |
---|---|
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of Coordinate s from a Geometry . |
Coordinate |
AffineTransformation.transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate and places the results in the dest coordinate (which may be the same as the source). |
Methods in com.vividsolutions.jts.geom.util with parameters of type Coordinate | |
---|---|
protected CoordinateSequence |
GeometryTransformer.createCoordinateSequence(Coordinate[] coords)
Convenience method which provides standard way of creating a CoordinateSequence |
static AffineTransformation |
AffineTransformationFactory.createFromBaseLines(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a maping between two baselines. |
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate[] src,
Coordinate[] dest)
Creates an AffineTransformation defined by a set of control vectors. |
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate[] src,
Coordinate[] dest)
Creates an AffineTransformation defined by a set of control vectors. |
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate dest0)
Creates an AffineTransformation defined by a single control vector. |
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a pair of control vectors. |
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Creates a tranformation from a set of three control vectors. |
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of Coordinate s from a Geometry . |
Coordinate |
AffineTransformation.transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate and places the results in the dest coordinate (which may be the same as the source). |
Constructors in com.vividsolutions.jts.geom.util with parameters of type Coordinate | |
---|---|
AffineTransformation(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Constructs a transformation which maps the given source points into the given destination points. |
|
AffineTransformationBuilder(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Constructs a new builder for the transformation defined by the given set of control point mappings. |
Uses of Coordinate in com.vividsolutions.jts.geomgraph |
---|
Fields in com.vividsolutions.jts.geomgraph declared as Coordinate | |
---|---|
protected Coordinate |
Node.coord
|
Coordinate |
EdgeIntersection.coord
|
Methods in com.vividsolutions.jts.geomgraph that return Coordinate | |
---|---|
Coordinate[] |
GeometryGraph.getBoundaryPoints()
|
Coordinate |
Node.getCoordinate()
|
abstract Coordinate |
GraphComponent.getCoordinate()
|
Coordinate |
EdgeIntersection.getCoordinate()
|
Coordinate |
EdgeEndStar.getCoordinate()
|
Coordinate |
EdgeEnd.getCoordinate()
|
Coordinate |
Edge.getCoordinate()
|
Coordinate |
EdgeRing.getCoordinate(int i)
|
Coordinate |
Edge.getCoordinate(int i)
|
Coordinate[] |
Edge.getCoordinates()
|
Coordinate |
EdgeEnd.getDirectedCoordinate()
|
Coordinate |
GeometryGraph.getInvalidPoint()
|
Methods in com.vividsolutions.jts.geomgraph with parameters of type Coordinate | |
---|---|
EdgeIntersection |
EdgeIntersectionList.add(Coordinate intPt,
int segmentIndex,
double dist)
Adds an intersection into the list, if it isn't already there. |
Node |
PlanarGraph.addNode(Coordinate coord)
|
Node |
NodeMap.addNode(Coordinate coord)
This method expects that a node has a coordinate value. |
void |
GeometryGraph.addPoint(Coordinate pt)
Add a point computed externally. |
boolean |
EdgeRing.containsPoint(Coordinate p)
This method will cause the ring to be computed. |
Node |
NodeFactory.createNode(Coordinate coord)
The basic node constructor does not allow for incident edges |
Node |
PlanarGraph.find(Coordinate coord)
|
Node |
NodeMap.find(Coordinate coord)
|
Edge |
PlanarGraph.findEdge(Coordinate p0,
Coordinate p1)
Returns the edge whose first two coordinates are p0 and p1 |
Edge |
PlanarGraph.findEdgeInSameDirection(Coordinate p0,
Coordinate p1)
Returns the edge which starts at p0 and whose first segment is parallel to p1 |
protected void |
EdgeEnd.init(Coordinate p0,
Coordinate p1)
|
boolean |
PlanarGraph.isBoundaryNode(int geomIndex,
Coordinate coord)
|
boolean |
EdgeIntersectionList.isIntersection(Coordinate pt)
Tests if the given point is an edge intersection |
int |
GeometryGraph.locate(Coordinate pt)
Determines the Location of the given Coordinate
in this geometry. |
static int |
Quadrant.quadrant(Coordinate p0,
Coordinate p1)
Returns the quadrant of a directed line segment from p0 to p1. |
Constructors in com.vividsolutions.jts.geomgraph with parameters of type Coordinate | |
---|---|
Edge(Coordinate[] pts)
|
|
Edge(Coordinate[] pts,
Label label)
|
|
EdgeEnd(Edge edge,
Coordinate p0,
Coordinate p1)
|
|
EdgeEnd(Edge edge,
Coordinate p0,
Coordinate p1,
Label label)
|
|
EdgeIntersection(Coordinate coord,
int segmentIndex,
double dist)
|
|
Node(Coordinate coord,
EdgeEndStar edges)
|
Uses of Coordinate in com.vividsolutions.jts.geomgraph.index |
---|
Methods in com.vividsolutions.jts.geomgraph.index that return Coordinate | |
---|---|
Coordinate[] |
MonotoneChainEdge.getCoordinates()
|
Coordinate |
SegmentIntersector.getProperIntersectionPoint()
|
Methods in com.vividsolutions.jts.geomgraph.index with parameters of type Coordinate | |
---|---|
int[] |
MonotoneChainIndexer.getChainStartIndices(Coordinate[] pts)
|
Uses of Coordinate in com.vividsolutions.jts.index.chain |
---|
Methods in com.vividsolutions.jts.index.chain that return Coordinate | |
---|---|
Coordinate[] |
MonotoneChain.getCoordinates()
Return the subsequence of coordinates forming this chain. |
Methods in com.vividsolutions.jts.index.chain with parameters of type Coordinate | |
---|---|
static List |
MonotoneChainBuilder.getChains(Coordinate[] pts)
|
static List |
MonotoneChainBuilder.getChains(Coordinate[] pts,
Object context)
Return a list of the MonotoneChain s
for the given list of coordinates. |
static int[] |
MonotoneChainBuilder.getChainStartIndices(Coordinate[] pts)
Return an array containing lists of start/end indexes of the monotone chains for the given list of coordinates. |
Constructors in com.vividsolutions.jts.index.chain with parameters of type Coordinate | |
---|---|
MonotoneChain(Coordinate[] pts,
int start,
int end,
Object context)
|
Uses of Coordinate in com.vividsolutions.jts.index.kdtree |
---|
Methods in com.vividsolutions.jts.index.kdtree that return Coordinate | |
---|---|
Coordinate |
KdNode.getCoordinate()
Returns the location of this node |
Methods in com.vividsolutions.jts.index.kdtree with parameters of type Coordinate | |
---|---|
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. |
Constructors in com.vividsolutions.jts.index.kdtree with parameters of type Coordinate | |
---|---|
KdNode(Coordinate p,
Object data)
Creates a new KdNode. |
Uses of Coordinate in com.vividsolutions.jts.index.quadtree |
---|
Methods in com.vividsolutions.jts.index.quadtree that return Coordinate | |
---|---|
Coordinate |
Key.getCentre()
|
Coordinate |
Key.getPoint()
|
Uses of Coordinate in com.vividsolutions.jts.io |
---|
Methods in com.vividsolutions.jts.io with parameters of type Coordinate | |
---|---|
static String |
WKTWriter.toLineString(Coordinate p0,
Coordinate p1)
Generates the WKT for a LINESTRING specified by two Coordinate s. |
static String |
WKTWriter.toPoint(Coordinate p0)
Generates the WKT for a POINT specified by a Coordinate . |
Uses of Coordinate in com.vividsolutions.jts.linearref |
---|
Methods in com.vividsolutions.jts.linearref that return Coordinate | |
---|---|
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 com.vividsolutions.jts.linearref with parameters of type Coordinate | |
---|---|
void |
LinearGeometryBuilder.add(Coordinate pt)
Adds a point to the current line. |
void |
LinearGeometryBuilder.add(Coordinate pt,
boolean allowRepeatedPoints)
Adds a point to the current line. |
LinearLocation |
LocationIndexedLine.indexOf(Coordinate pt)
Computes the index for a given point on the line. |
double |
LengthIndexedLine.indexOf(Coordinate pt)
Computes the minimum index for a point on the line. |
double |
LengthIndexedLine.indexOfAfter(Coordinate pt,
double minIndex)
Finds the index for a point on the line which is greater than the given index. |
LinearLocation |
LocationIndexedLine.indexOfAfter(Coordinate pt,
LinearLocation minIndex)
Finds the index for a point on the line which is greater than the given index. |
static Coordinate |
LinearLocation.pointAlongSegmentByFraction(Coordinate p0,
Coordinate p1,
double frac)
Computes the Coordinate of a point a given fraction
along the line segment (p0, p1). |
LinearLocation |
LocationIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point. |
double |
LengthIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point. |
Uses of Coordinate in com.vividsolutions.jts.math |
---|
Methods in com.vividsolutions.jts.math that return Coordinate | |
---|---|
static Coordinate |
Vector3D.normalize(Coordinate v)
|
Coordinate |
Vector2D.toCoordinate()
|
Coordinate |
Vector2D.translate(Coordinate coord)
|
Methods in com.vividsolutions.jts.math with parameters of type Coordinate | |
---|---|
static Vector3D |
Vector3D.create(Coordinate coord)
Creates a vector from a Coordinate . |
static Vector2D |
Vector2D.create(Coordinate coord)
Creates a vector from a Coordinate . |
static Vector2D |
Vector2D.create(Coordinate from,
Coordinate to)
Creates a vector with the direction and magnitude of the difference between the to and from Coordinate s. |
static double |
Vector3D.dot(Coordinate v1,
Coordinate v2)
Computes the 3D dot-product of two Coordinate s. |
static double |
Vector3D.dot(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the dot product of the 3D vectors AB and CD. |
static double |
Vector3D.length(Coordinate v)
|
static Coordinate |
Vector3D.normalize(Coordinate v)
|
double |
Plane3D.orientedDistance(Coordinate p)
Computes the oriented distance from a point to the plane. |
Coordinate |
Vector2D.translate(Coordinate coord)
|
Constructors in com.vividsolutions.jts.math with parameters of type Coordinate | |
---|---|
Plane3D(Vector3D normal,
Coordinate basePt)
|
|
Vector2D(Coordinate v)
|
|
Vector2D(Coordinate from,
Coordinate to)
|
|
Vector3D(Coordinate v)
|
|
Vector3D(Coordinate from,
Coordinate to)
|
Uses of Coordinate in com.vividsolutions.jts.noding |
---|
Fields in com.vividsolutions.jts.noding declared as Coordinate | |
---|---|
Coordinate |
SegmentNode.coord
|
Methods in com.vividsolutions.jts.noding that return Coordinate | |
---|---|
Coordinate |
SegmentNode.getCoordinate()
Gets the Coordinate giving the location of this node. |
Coordinate |
SegmentString.getCoordinate(int i)
|
Coordinate |
NodedSegmentString.getCoordinate(int i)
|
Coordinate |
BasicSegmentString.getCoordinate(int i)
|
Coordinate[] |
SegmentString.getCoordinates()
|
Coordinate[] |
NodedSegmentString.getCoordinates()
|
Coordinate[] |
BasicSegmentString.getCoordinates()
|
Coordinate |
InteriorIntersectionFinder.getInteriorIntersection()
Gets the computed location of the intersection. |
Coordinate |
SegmentIntersectionDetector.getIntersection()
Gets the computed location of the intersection. |
Coordinate[] |
SegmentIntersectionDetector.getIntersectionSegments()
Gets the endpoints of the intersecting segments. |
Coordinate[] |
InteriorIntersectionFinder.getIntersectionSegments()
Gets the endpoints of the intersecting segments. |
Coordinate |
IntersectionAdder.getProperIntersectionPoint()
|
Methods in com.vividsolutions.jts.noding with parameters of type Coordinate | |
---|---|
SegmentNode |
SegmentNodeList.add(Coordinate intPt,
int segmentIndex)
Adds an intersection into the list, if it isn't already there. |
void |
NodedSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string. |
void |
NodableSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string. |
SegmentNode |
NodedSegmentString.addIntersectionNode(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string. |
static int |
SegmentPointComparator.compare(int octant,
Coordinate p0,
Coordinate p1)
Compares two Coordinate s for their relative position along a segment
lying in the specified Octant . |
static int |
Octant.octant(Coordinate p0,
Coordinate p1)
Returns the octant of a directed line segment from p0 to p1. |
Constructors in com.vividsolutions.jts.noding with parameters of type Coordinate | |
---|---|
BasicSegmentString(Coordinate[] pts,
Object data)
Creates a new segment string from a list of vertices. |
|
NodedSegmentString(Coordinate[] pts,
Object data)
Creates a new segment string from a list of vertices. |
|
OrientedCoordinateArray(Coordinate[] pts)
Creates a new OrientedCoordinateArray
for the given Coordinate array. |
|
SegmentNode(NodedSegmentString segString,
Coordinate coord,
int segmentIndex,
int segmentOctant)
|
Uses of Coordinate in com.vividsolutions.jts.noding.snapround |
---|
Methods in com.vividsolutions.jts.noding.snapround that return Coordinate | |
---|---|
Coordinate |
HotPixel.getCoordinate()
Gets the coordinate this hot pixel is based at. |
Methods in com.vividsolutions.jts.noding.snapround with parameters of type Coordinate | |
---|---|
boolean |
HotPixel.intersects(Coordinate p0,
Coordinate p1)
Tests whether the line segment (p0-p1) intersects this hot pixel. |
Constructors in com.vividsolutions.jts.noding.snapround with parameters of type Coordinate | |
---|---|
HotPixel(Coordinate pt,
double scaleFactor,
LineIntersector li)
Creates a new hot pixel, using a given scale factor. |
Uses of Coordinate in com.vividsolutions.jts.operation |
---|
Methods in com.vividsolutions.jts.operation that return Coordinate | |
---|---|
Coordinate |
IsSimpleOp.getNonSimpleLocation()
Gets a coordinate for the location where the geometry fails to be simple. |
Uses of Coordinate in com.vividsolutions.jts.operation.buffer |
---|
Methods in com.vividsolutions.jts.operation.buffer that return Coordinate | |
---|---|
Coordinate |
RightmostEdgeFinder.getCoordinate()
|
Coordinate[] |
OffsetCurveBuilder.getLineCurve(Coordinate[] inputPts,
double distance)
This method handles single points as well as LineStrings. |
Coordinate[] |
OffsetCurveBuilder.getOffsetCurve(Coordinate[] inputPts,
double distance)
|
Coordinate |
BufferSubgraph.getRightmostCoordinate()
Gets the rightmost coordinate in the edges of the subgraph |
Coordinate[] |
OffsetCurveBuilder.getRingCurve(Coordinate[] inputPts,
int side,
double distance)
This method handles the degenerate cases of single points and lines, as well as rings. |
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list. |
Coordinate[] |
BufferInputLineSimplifier.simplify(double distanceTol)
Simplify the input coordinate list. |
Methods in com.vividsolutions.jts.operation.buffer with parameters of type Coordinate | |
---|---|
int |
SubgraphDepthLocater.getDepth(Coordinate p)
|
Coordinate[] |
OffsetCurveBuilder.getLineCurve(Coordinate[] inputPts,
double distance)
This method handles single points as well as LineStrings. |
Coordinate[] |
OffsetCurveBuilder.getOffsetCurve(Coordinate[] inputPts,
double distance)
|
Coordinate[] |
OffsetCurveBuilder.getRingCurve(Coordinate[] inputPts,
int side,
double distance)
This method handles the degenerate cases of single points and lines, as well as rings. |
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list. |
Constructors in com.vividsolutions.jts.operation.buffer with parameters of type Coordinate | |
---|---|
BufferInputLineSimplifier(Coordinate[] inputLine)
|
Uses of Coordinate in com.vividsolutions.jts.operation.buffer.validate |
---|
Methods in com.vividsolutions.jts.operation.buffer.validate that return Coordinate | |
---|---|
Coordinate |
PointPairDistance.getCoordinate(int i)
|
Coordinate[] |
PointPairDistance.getCoordinates()
|
Coordinate |
BufferResultValidator.getErrorLocation()
|
Coordinate |
BufferDistanceValidator.getErrorLocation()
|
Methods in com.vividsolutions.jts.operation.buffer.validate with parameters of type Coordinate | |
---|---|
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 com.vividsolutions.jts.operation.distance |
---|
Methods in com.vividsolutions.jts.operation.distance that return Coordinate | |
---|---|
Coordinate[] |
DistanceOp.closestPoints()
Deprecated. renamed to nearestPoints |
static Coordinate[] |
DistanceOp.closestPoints(Geometry g0,
Geometry g1)
Deprecated. renamed to nearestPoints |
Coordinate |
GeometryLocation.getCoordinate()
Returns the Coordinate of this location. |
Coordinate |
FacetSequence.getCoordinate(int index)
|
Coordinate[] |
DistanceOp.nearestPoints()
Report the coordinates of the nearest points in the input geometries. |
static Coordinate[] |
DistanceOp.nearestPoints(Geometry g0,
Geometry g1)
Compute the the nearest points of two geometries. |
Constructors in com.vividsolutions.jts.operation.distance with parameters of type Coordinate | |
---|---|
GeometryLocation(Geometry component,
Coordinate pt)
Constructs a GeometryLocation specifying a point inside an area geometry. |
|
GeometryLocation(Geometry component,
int segIndex,
Coordinate pt)
Constructs a GeometryLocation specifying a point on a geometry, as well as the segment that the point is on (or GeometryLocation.INSIDE_AREA if the point is not on a segment). |
Uses of Coordinate in com.vividsolutions.jts.operation.distance3d |
---|
Methods in com.vividsolutions.jts.operation.distance3d that return Coordinate | |
---|---|
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 com.vividsolutions.jts.operation.distance3d with parameters of type Coordinate | |
---|---|
void |
AxisPlaneCoordinateSequence.getCoordinate(int index,
Coordinate coord)
|
boolean |
PlanarPolygon3D.intersects(Coordinate intPt)
|
boolean |
PlanarPolygon3D.intersects(Coordinate pt,
LineString ring)
|
Uses of Coordinate in com.vividsolutions.jts.operation.linemerge |
---|
Constructors in com.vividsolutions.jts.operation.linemerge with parameters of type Coordinate | |
---|---|
LineMergeDirectedEdge(Node from,
Node to,
Coordinate directionPt,
boolean edgeDirection)
Constructs a LineMergeDirectedEdge connecting the from node to the
to node. |
Uses of Coordinate in com.vividsolutions.jts.operation.overlay |
---|
Methods in com.vividsolutions.jts.operation.overlay with parameters of type Coordinate | |
---|---|
boolean |
PolygonBuilder.containsPoint(Coordinate p)
Checks the current set of shells (with their associated holes) to see if any of them contain the point. |
Node |
OverlayNodeFactory.createNode(Coordinate coord)
|
boolean |
OverlayOp.isCoveredByA(Coordinate coord)
This method is used to decide if an L edge should be included in the result or not. |
boolean |
OverlayOp.isCoveredByLA(Coordinate coord)
This method is used to decide if a point node should be included in the result or not. |
Uses of Coordinate in com.vividsolutions.jts.operation.overlay.snap |
---|
Methods in com.vividsolutions.jts.operation.overlay.snap that return Coordinate | |
---|---|
Coordinate[] |
GeometrySnapper.extractTargetCoordinates(Geometry g)
|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString to the given set of snap vertices. |
Methods in com.vividsolutions.jts.operation.overlay.snap with parameters of type Coordinate | |
---|---|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString to the given set of snap vertices. |
Constructors in com.vividsolutions.jts.operation.overlay.snap with parameters of type Coordinate | |
---|---|
LineStringSnapper(Coordinate[] srcPts,
double snapTolerance)
Creates a new snapper using the given points as source points to be snapped. |
Uses of Coordinate in com.vividsolutions.jts.operation.overlay.validate |
---|
Methods in com.vividsolutions.jts.operation.overlay.validate that return Coordinate | |
---|---|
Coordinate |
OverlayResultValidator.getInvalidLocation()
|
Methods in com.vividsolutions.jts.operation.overlay.validate with parameters of type Coordinate | |
---|---|
int |
FuzzyPointLocator.getLocation(Coordinate pt)
|
Uses of Coordinate in com.vividsolutions.jts.operation.relate |
---|
Methods in com.vividsolutions.jts.operation.relate with parameters of type Coordinate | |
---|---|
Node |
RelateNodeFactory.createNode(Coordinate coord)
|
Constructors in com.vividsolutions.jts.operation.relate with parameters of type Coordinate | |
---|---|
RelateNode(Coordinate coord,
EdgeEndStar edges)
|
Uses of Coordinate in com.vividsolutions.jts.operation.valid |
---|
Methods in com.vividsolutions.jts.operation.valid that return Coordinate | |
---|---|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt)
|
static Coordinate |
IsValidOp.findPtNotNode(Coordinate[] testCoords,
LinearRing searchRing,
GeometryGraph graph)
Find a point from the list of testCoords that is NOT a node in the edge for the list of searchCoords |
Coordinate |
TopologyValidationError.getCoordinate()
Returns the location of this error (on the Geometry containing the error). |
Coordinate |
RepeatedPointTester.getCoordinate()
|
Coordinate |
ConnectedInteriorTester.getCoordinate()
|
Coordinate |
ConsistentAreaTester.getInvalidPoint()
|
Coordinate |
SweeplineNestedRingTester.getNestedPoint()
|
Coordinate |
SimpleNestedRingTester.getNestedPoint()
|
Coordinate |
QuadtreeNestedRingTester.getNestedPoint()
|
Coordinate |
IndexedNestedRingTester.getNestedPoint()
|
Methods in com.vividsolutions.jts.operation.valid with parameters of type Coordinate | |
---|---|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt)
|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt)
|
static Coordinate |
IsValidOp.findPtNotNode(Coordinate[] testCoords,
LinearRing searchRing,
GeometryGraph graph)
Find a point from the list of testCoords that is NOT a node in the edge for the list of searchCoords |
boolean |
RepeatedPointTester.hasRepeatedPoint(Coordinate[] coord)
|
static boolean |
IsValidOp.isValid(Coordinate coord)
Checks whether a coordinate is valid for processing. |
Constructors in com.vividsolutions.jts.operation.valid with parameters of type Coordinate | |
---|---|
TopologyValidationError(int errorType,
Coordinate pt)
Creates a validation error with the given type and location |
Uses of Coordinate in com.vividsolutions.jts.planargraph |
---|
Fields in com.vividsolutions.jts.planargraph declared as Coordinate | |
---|---|
protected Coordinate |
DirectedEdge.p0
|
protected Coordinate |
DirectedEdge.p1
|
protected Coordinate |
Node.pt
The location of this Node |
Methods in com.vividsolutions.jts.planargraph that return Coordinate | |
---|---|
Coordinate |
Node.getCoordinate()
Returns the location of this Node. |
Coordinate |
DirectedEdgeStar.getCoordinate()
Returns the coordinate for the node at wich this star is based |
Coordinate |
DirectedEdge.getCoordinate()
Returns the coordinate of the from-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 com.vividsolutions.jts.planargraph with parameters of type Coordinate | |
---|---|
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 com.vividsolutions.jts.planargraph with parameters of type Coordinate | |
---|---|
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 com.vividsolutions.jts.precision |
---|
Methods in com.vividsolutions.jts.precision that return Coordinate | |
---|---|
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom)
|
Coordinate |
CommonBitsRemover.getCommonCoordinate()
The common bits of the Coordinates in the supplied Geometries. |
Methods in com.vividsolutions.jts.precision with parameters of type Coordinate | |
---|---|
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom)
|
Uses of Coordinate in com.vividsolutions.jts.shape |
---|
Methods in com.vividsolutions.jts.shape that return Coordinate | |
---|---|
protected Coordinate |
GeometricShapeBuilder.createCoord(double x,
double y)
|
Coordinate |
GeometricShapeBuilder.getCentre()
|
Uses of Coordinate in com.vividsolutions.jts.shape.fractal |
---|
Methods in com.vividsolutions.jts.shape.fractal with parameters of type Coordinate | |
---|---|
void |
KochSnowflakeBuilder.addSide(int level,
Coordinate p0,
Coordinate p1)
|
Uses of Coordinate in com.vividsolutions.jts.shape.random |
---|
Methods in com.vividsolutions.jts.shape.random that return Coordinate | |
---|---|
protected Coordinate |
RandomPointsBuilder.createCoord(double x,
double y)
|
protected Coordinate |
RandomPointsBuilder.createRandomCoord(Envelope env)
|
Methods in com.vividsolutions.jts.shape.random with parameters of type Coordinate | |
---|---|
protected boolean |
RandomPointsBuilder.isInExtent(Coordinate p)
|
Uses of Coordinate in com.vividsolutions.jts.triangulate |
---|
Methods in com.vividsolutions.jts.triangulate that return Coordinate | |
---|---|
Coordinate |
NonEncroachingSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
A basic strategy for finding split points when nothing extra is known about the geometry of the situation. |
Coordinate |
MidpointSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Gets the midpoint of the split segment |
Coordinate |
ConstraintSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Finds a point at which to split an encroached segment to allow the original segment to appear as edges in a constrained Delaunay triangulation. |
Coordinate |
ConstraintEnforcementException.getCoordinate()
Gets the approximate location of this error. |
Coordinate |
Segment.getEnd()
Gets the end coordinate of the segment |
Coordinate |
SplitSegment.getSplitPoint()
|
Coordinate |
Segment.getStart()
Gets the start coordinate of the segment |
Coordinate |
Segment.intersection(Segment s)
Computes the intersection point between this segment and another one. |
static Coordinate |
NonEncroachingSplitPointFinder.projectedSplitPoint(Segment seg,
Coordinate encroachPt)
Computes a split point which is the projection of the encroaching point on the segment |
Methods in com.vividsolutions.jts.triangulate with parameters of type Coordinate | |
---|---|
ConstraintVertex |
ConstraintVertexFactory.createVertex(Coordinate p,
Segment constraintSeg)
|
Coordinate |
NonEncroachingSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
A basic strategy for finding split points when nothing extra is known about the geometry of the situation. |
Coordinate |
MidpointSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Gets the midpoint of the split segment |
Coordinate |
ConstraintSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Finds a point at which to split an encroached segment to allow the original segment to appear as edges in a constrained Delaunay triangulation. |
void |
ConformingDelaunayTriangulator.insertSite(Coordinate p)
Inserts a site into the triangulation, maintaining the conformal Delaunay property. |
static Coordinate |
NonEncroachingSplitPointFinder.projectedSplitPoint(Segment seg,
Coordinate encroachPt)
Computes a split point which is the projection of the encroaching point on the segment |
void |
SplitSegment.splitAt(Coordinate pt)
|
void |
SplitSegment.splitAt(double length,
Coordinate endPt)
|
static CoordinateList |
DelaunayTriangulationBuilder.unique(Coordinate[] coords)
|
Constructors in com.vividsolutions.jts.triangulate with parameters of type Coordinate | |
---|---|
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 com.vividsolutions.jts.triangulate.quadedge |
---|
Methods in com.vividsolutions.jts.triangulate.quadedge that return Coordinate | |
---|---|
Coordinate |
Vertex.getCoordinate()
|
Coordinate |
QuadEdgeTriangle.getCoordinate(int i)
|
Coordinate[] |
QuadEdgeTriangle.getCoordinates()
|
Methods in com.vividsolutions.jts.triangulate.quadedge with parameters of type Coordinate | |
---|---|
boolean |
QuadEdgeTriangle.contains(Coordinate pt)
|
static boolean |
QuadEdgeTriangle.contains(QuadEdge[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3 QuadEdge es. |
static boolean |
QuadEdgeTriangle.contains(Vertex[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3 Vertex es. |
static double |
Vertex.interpolateZ(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the interpolated Z-value for a point p lying on the segment p0-p1 |
static double |
Vertex.interpolateZ(Coordinate p,
Coordinate v0,
Coordinate v1,
Coordinate v2)
Interpolates the Z-value (height) of a point enclosed in a triangle whose vertices all have Z values. |
static boolean |
TrianglePredicate.isInCircleCC(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Computes the inCircle test using distance from the circumcentre. |
static boolean |
TrianglePredicate.isInCircleDDFast(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
|
static boolean |
TrianglePredicate.isInCircleDDNormalized(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
|
static boolean |
TrianglePredicate.isInCircleDDSlow(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by the triangle with vertices a, b, c (oriented counter-clockwise). |
static boolean |
TrianglePredicate.isInCircleNonRobust(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by the triangle with vertices a, b, c (oriented counter-clockwise). |
static boolean |
TrianglePredicate.isInCircleNormalized(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by the triangle with vertices a, b, c (oriented counter-clockwise). |
static boolean |
TrianglePredicate.isInCircleRobust(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by the triangle with vertices a, b, c (oriented counter-clockwise). |
boolean |
QuadEdgeSubdivision.isOnEdge(QuadEdge e,
Coordinate p)
Tests whether a Coordinate lies on a QuadEdge , up to a
tolerance determined by the subdivision tolerance. |
QuadEdge |
QuadEdgeSubdivision.locate(Coordinate p)
Finds a quadedge of a triangle containing a location specified by a Coordinate , if one exists. |
QuadEdge |
QuadEdgeSubdivision.locate(Coordinate p0,
Coordinate p1)
Locates the edge between the given vertices, if it exists in the subdivision. |
static DD |
TrianglePredicate.triAreaDDFast(Coordinate a,
Coordinate b,
Coordinate c)
|
Constructors in com.vividsolutions.jts.triangulate.quadedge with parameters of type Coordinate | |
---|---|
Vertex(Coordinate _p)
|
Uses of Coordinate in com.vividsolutions.jts.util |
---|
Fields in com.vividsolutions.jts.util declared as Coordinate | |
---|---|
Coordinate |
GeometricShapeFactory.Dimensions.base
|
Coordinate |
GeometricShapeFactory.Dimensions.centre
|
Methods in com.vividsolutions.jts.util that return Coordinate | |
---|---|
protected Coordinate |
GeometricShapeFactory.coord(double x,
double y)
|
protected Coordinate |
GeometricShapeFactory.coordTrans(double x,
double y,
Coordinate trans)
|
Coordinate |
GeometricShapeFactory.Dimensions.getBase()
|
Coordinate |
GeometricShapeFactory.Dimensions.getCentre()
|
Coordinate[] |
UniqueCoordinateArrayFilter.getCoordinates()
Returns the gathered Coordinate s. |
Coordinate[] |
CoordinateArrayFilter.getCoordinates()
Returns the gathered Coordinate s. |
Methods in com.vividsolutions.jts.util with parameters of type Coordinate | |
---|---|
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 |
UniqueCoordinateArrayFilter.filter(Coordinate coord)
|
void |
CoordinateCountFilter.filter(Coordinate coord)
|
void |
CoordinateArrayFilter.filter(Coordinate coord)
|
static boolean |
Debug.hasSegment(Geometry geom,
Coordinate p0,
Coordinate p1)
|
void |
GeometricShapeFactory.setBase(Coordinate base)
Sets the location of the shape by specifying the base coordinate (which in most cases is the lower left point of the envelope containing the shape). |
void |
GeometricShapeFactory.Dimensions.setBase(Coordinate base)
|
void |
GeometricShapeFactory.setCentre(Coordinate centre)
Sets the location of the shape by specifying the centre of the shape's bounding box |
void |
GeometricShapeFactory.Dimensions.setCentre(Coordinate centre)
|
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1)
|
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1,
Coordinate p2)
|
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1,
Coordinate p2,
Coordinate p3)
|
Uses of Coordinate in com.vividsolutions.jtsexample.geom |
---|
Subclasses of Coordinate in com.vividsolutions.jtsexample.geom | |
---|---|
class |
ExtendedCoordinate
|
Methods in com.vividsolutions.jtsexample.geom that return Coordinate | |
---|---|
Coordinate |
ExtendedCoordinateSequence.getCoordinate(int i)
|
Coordinate |
ExtendedCoordinateSequence.getCoordinateCopy(int index)
|
Coordinate[] |
ExtendedCoordinateSequence.toCoordinateArray()
|
Methods in com.vividsolutions.jtsexample.geom with parameters of type Coordinate | |
---|---|
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)
|
Constructors in com.vividsolutions.jtsexample.geom with parameters of type Coordinate | |
---|---|
ExtendedCoordinate(Coordinate coord)
|
|
ExtendedCoordinateSequence(Coordinate[] copyCoords)
Constructor that makes a copy of an array of Coordinates. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |