Uses of Class
com.vividsolutions.jts.geom.Coordinate

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 Geometrys. 
com.vividsolutions.jts.operation.valid Provides classes for testing the validity of geometries. 
com.vividsolutions.jts.planargraph Contains classes to implement a planar graph data structure. 
com.vividsolutions.jts.precision Provides classes for analyzing and manipulating the precision of Geometries. 
com.vividsolutions.jts.shape   
com.vividsolutions.jts.shape.fractal   
com.vividsolutions.jts.shape.random   
com.vividsolutions.jts.triangulate Classes to compute Delaunay triangulations. 
com.vividsolutions.jts.triangulate.quadedge Classes to implement a topological subdivision of quadeges, to support creating triangulations and Voronoi diagrams. 
com.vividsolutions.jts.util Contains support classes for the Java Topology Suite. 
com.vividsolutions.jtsexample.geom   
 

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 Coordinates 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 Coordinates.
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 Coordinates.
 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 Coordinates.
 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 Coordinates 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 Coordinates forms a ring, by checking length and closure.
static double Triangle.longestSideLength(Coordinate a, Coordinate b, Coordinate c)
          Computes the length of the longest side of a triangle
 void PrecisionModel.makePrecise(Coordinate coord)
          Rounds a Coordinate to the PrecisionModel grid.
static Coordinate LineSegment.midPoint(Coordinate p0, Coordinate p1)
          Computes the midpoint of a segment
static Coordinate CoordinateArrays.minCoordinate(Coordinate[] coordinates)
          Returns the minimum coordinate, using the usual lexicographic comparison.
 int LineSegment.orientationIndex(Coordinate p)
          Determines the orientation index of a Coordinate relative to this segment.
 boolean Envelope.overlaps(Coordinate p)
          Deprecated. Use #intersects instead.
static HCoordinate Triangle.perpendicularBisector(Coordinate a, Coordinate b)
          Computes the line which is the perpendicular bisector of the line segment a-b.
 Coordinate LineSegment.project(Coordinate p)
          Compute the projection of a point onto the line determined by this line segment.
 double LineSegment.projectionFactor(Coordinate p)
          Computes the Projection Factor for the projection of the point p onto this LineSegment.
static Coordinate CoordinateArrays.ptNotInList(Coordinate[] testPts, Coordinate[] pts)
          Finds a point in a list of points which is not contained in another list of points
static Coordinate CoordinateArrays.ptNotInList(Coordinate[] testPts, Coordinate[] pts)
          Finds a point in a list of points which is not contained in another list of points
static Coordinate[] CoordinateArrays.removeNull(Coordinate[] coord)
          Collapses a coordinate array to remove all null elements.
static Coordinate[] CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
          If the coordinate array argument has repeated points, constructs a new array containing no repeated points.
static void CoordinateArrays.reverse(Coordinate[] coord)
          Reverses the coordinates in an array in-place.
static void CoordinateArrays.scroll(Coordinate[] coordinates, Coordinate firstCoordinate)
          Shifts the positions of the coordinates until firstCoordinate is first.
static void CoordinateArrays.scroll(Coordinate[] coordinates, Coordinate firstCoordinate)
          Shifts the positions of the coordinates until firstCoordinate is first.
 double LineSegment.segmentFraction(Coordinate inputPt)
          Computes the fraction of distance (in [0.0, 1.0]) that the projection of a point occurs along this line segment.
 void Coordinate.setCoordinate(Coordinate other)
          Sets this Coordinates (x,y,z) values to that of other.
 void LineSegment.setCoordinates(Coordinate p0, Coordinate p1)
           
static double Triangle.signedArea(Coordinate a, Coordinate b, Coordinate c)
          Computes the signed 2D area of a triangle.
 Coordinate PrecisionModel.toExternal(Coordinate internal)
          Deprecated. no longer needed, since internal representation is same as external representation
 void PrecisionModel.toExternal(Coordinate internal, Coordinate external)
          Deprecated. no longer needed, since internal representation is same as external representation
 Coordinate PrecisionModel.toInternal(Coordinate external)
          Deprecated. use makePrecise instead
 void PrecisionModel.toInternal(Coordinate external, Coordinate internal)
          Deprecated. use makePrecise instead
 

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 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 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 Coordinates (the array is not copied).
CoordinateArraySequence(Coordinate[] coordinates, int dimension)
          Constructs a sequence based on the given array of Coordinates (the array is not copied).
PackedCoordinateSequence.Double(Coordinate[] coordinates)
          Builds a new packed coordinate sequence out of a coordinate array
PackedCoordinateSequence.Double(Coordinate[] coordinates, int dimension)
          Builds a new packed coordinate sequence out of a coordinate array
PackedCoordinateSequence.Float(Coordinate[] coordinates, int dimension)
          Constructs a packed coordinate sequence out of a coordinate array
 

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 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 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 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 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 MonotoneChains for the given list of coordinates.
static int[] MonotoneChainBuilder.getChainStartIndices(Coordinate[] pts)
          Return an array containing lists of start/end indexes of the monotone chains for the given list of coordinates.
 

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 Coordinates.
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 Coordinates.
static double Vector3D.dot(Coordinate v1, Coordinate v2)
          Computes the 3D dot-product of two Coordinates.
static double Vector3D.dot(Coordinate A, Coordinate B, Coordinate C, Coordinate D)
          Computes the dot product of the 3D vectors AB and CD.
static double Vector3D.length(Coordinate v)
           
static Coordinate Vector3D.normalize(Coordinate v)
           
 double Plane3D.orientedDistance(Coordinate p)
          Computes the oriented distance from a point to the plane.
 Coordinate Vector2D.translate(Coordinate coord)
           
 

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 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 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 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 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 Coordinates.
 Coordinate[] CoordinateArrayFilter.getCoordinates()
          Returns the gathered Coordinates.
 

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.
 



Copyright © 2012. All Rights Reserved.