Uses of Class
org.geotools.geometry.iso.topograph2D.Coordinate

Packages that use Coordinate
org.geotools.geometry.iso An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.index.quadtree An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.operation.overlay An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.operation.relate An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.topograph2D An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.topograph2D.index An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.topograph2D.util An implementation of GeoAPI Geometry interfaces from ISO 19107. 
org.geotools.geometry.iso.util.algorithm2D An implementation of GeoAPI Geometry interfaces from ISO 19107. 
 

Uses of Coordinate in org.geotools.geometry.iso
 

Methods in org.geotools.geometry.iso with parameters of type Coordinate
 void PrecisionModel.makePrecise(Coordinate coord)
          Rounds a Coordinate to the PrecisionModel grid.
 

Uses of Coordinate in org.geotools.geometry.iso.index.quadtree
 

Methods in org.geotools.geometry.iso.index.quadtree that return Coordinate
 Coordinate Key.getCentre()
           
 Coordinate Key.getPoint()
           
 

Methods in org.geotools.geometry.iso.index.quadtree with parameters of type Coordinate
static int NodeBase.getSubnodeIndex(Envelope env, Coordinate centre)
          Returns the index of the subquad that wholly contains the given envelope.
 

Uses of Coordinate in org.geotools.geometry.iso.operation.overlay
 

Methods in org.geotools.geometry.iso.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 org.geotools.geometry.iso.operation.relate
 

Methods in org.geotools.geometry.iso.operation.relate with parameters of type Coordinate
 Node RelateNodeFactory.createNode(Coordinate coord)
           
 

Constructors in org.geotools.geometry.iso.operation.relate with parameters of type Coordinate
RelateNode(Coordinate coord, EdgeEndStar edges)
           
 

Uses of Coordinate in org.geotools.geometry.iso.topograph2D
 

Fields in org.geotools.geometry.iso.topograph2D declared as Coordinate
protected  Coordinate Node.coord
           
 Coordinate EdgeIntersection.coord
           
 

Methods in org.geotools.geometry.iso.topograph2D that return Coordinate
 Coordinate Envelope.centre()
          Computes the coordinate of the centre of this envelope (as long as it is non-null
 Coordinate[] GeometryGraph.getBoundaryPoints()
           
 Coordinate EdgeEnd.getCoordinate()
           
 Coordinate Edge.getCoordinate()
           
abstract  Coordinate GraphComponent.getCoordinate()
           
 Coordinate Node.getCoordinate()
           
 Coordinate EdgeEndStar.getCoordinate()
           
 Coordinate TopologyException.getCoordinate()
           
 Coordinate EdgeRing.getCoordinate(int i)
           
 Coordinate Edge.getCoordinate(int i)
           
 Coordinate CoordinateList.getCoordinate(int i)
           
 Coordinate[] Edge.getCoordinates()
           
 Coordinate EdgeEnd.getDirectedCoordinate()
           
 Coordinate GeometryGraph.getInvalidPoint()
           
 Coordinate[] CoordinateList.toCoordinateArray()
          Returns the Coordinates in this collection.
 

Methods in org.geotools.geometry.iso.topograph2D with parameters of type Coordinate
 boolean CoordinateList.add(Coordinate[] coord, boolean allowRepeated)
          Add an array of coordinates
 boolean CoordinateList.add(Coordinate[] coord, boolean allowRepeated, boolean direction)
          Add an array of coordinates
 void CoordinateList.add(Coordinate coord, boolean allowRepeated)
          Add a 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 Envelope.contains(Coordinate p)
          Returns true if the given point lies in or on the envelope.
 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
 double Coordinate.distance(Coordinate p)
           
 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.
 void Envelope.expandToInclude(Coordinate p)
          Enlarges the boundary of the Envelope so that it contains (x,y).
 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
 void Envelope.init(Coordinate p)
          Initialize an Envelope to a region defined by a single Coordinate.
protected  void EdgeEnd.init(Coordinate p0, Coordinate p1)
           
 void Envelope.init(Coordinate p1, Coordinate p2)
          Initialize an Envelope to a region defined by two Coordinates.
 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)
          Test the envelope defined by p1-p2 for intersection with the envelope defined by q1-q2
 boolean PlanarGraph.isBoundaryNode(int geomIndex, Coordinate coord)
           
 boolean EdgeIntersectionList.isIntersection(Coordinate pt)
          Tests if the given point is an edge intersection
 boolean Envelope.overlaps(Coordinate p)
          Deprecated. Use #intersects instead.
static int Quadrant.quadrant(Coordinate p0, Coordinate p1)
          Returns the quadrant of a directed line segment from p0 to p1.
 void Coordinate.setCoordinate(Coordinate other)
          Sets this Coordinates (x,y,z) values to that of other .
 

Constructors in org.geotools.geometry.iso.topograph2D with parameters of type Coordinate
Coordinate(Coordinate c)
          Constructs a Coordinate having the same (x,y,z) values as other.
CoordinateList(Coordinate[] coord)
          The basic constructor for a CoordinateArray allows repeated points (i.e produces a CoordinateList with exactly the same set of 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.
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)
           
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.
Node(Coordinate coord, EdgeEndStar edges)
           
TopologyException(java.lang.String msg, Coordinate pt)
           
 

Uses of Coordinate in org.geotools.geometry.iso.topograph2D.index
 

Methods in org.geotools.geometry.iso.topograph2D.index that return Coordinate
 Coordinate[] MonotoneChainEdge.getCoordinates()
           
 Coordinate SegmentIntersector.getProperIntersectionPoint()
           
 

Methods in org.geotools.geometry.iso.topograph2D.index with parameters of type Coordinate
 int[] MonotoneChainIndexer.getChainStartIndices(Coordinate[] pts)
           
 

Uses of Coordinate in org.geotools.geometry.iso.topograph2D.util
 

Methods in org.geotools.geometry.iso.topograph2D.util that return Coordinate
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[] CoordinateArrays.copyDeep(Coordinate[] coordinates)
          Creates a deep copy of the argument {@link 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[] UniqueCoordinateArrayFilter.getCoordinates()
          Returns the gathered Coordinates.
static Coordinate CoordinateArrays.minCoordinate(Coordinate[] coordinates)
          Returns the minimum coordinate, using the usual lexicographic comparison.
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.removeRepeatedPoints(Coordinate[] coord)
          If the coordinate array argument has repeated points, constructs a new array containing no repeated points.
static Coordinate[] CoordinateArrays.toCoordinateArray(java.util.Collection coordList)
          Converts the given Collection of Coordinates into a Coordinate array.
static Coordinate[] CoordinateArrays.toCoordinateArray(java.util.List<org.opengis.geometry.DirectPosition> aPositions)
          SJ TODO faellt evtl weg, wenn coordinate durch DirectPosition ausgetauscht wird
 

Methods in org.geotools.geometry.iso.topograph2D.util with parameters of type Coordinate
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 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.
static Coordinate[] CoordinateArrays.copyDeep(Coordinate[] coordinates)
          Creates a deep copy of the argument {@link Coordinate) array.
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, java.util.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, java.util.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 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 UniqueCoordinateArrayFilter.filter(Coordinate coord)
           
static boolean CoordinateArrays.hasRepeatedPoints(Coordinate[] coord)
          Returns whether #equals returns true for any two consecutive Coordinates in the given array.
static int CoordinateArrays.increasingDirection(Coordinate[] pts)
          Determines which orientation of the Coordinate array is (overall) increasing.
static int CoordinateArrays.indexOf(Coordinate coordinate, Coordinate[] coordinates)
          Returns the index of coordinate in coordinates.
static int CoordinateArrays.indexOf(Coordinate coordinate, Coordinate[] coordinates)
          Returns the index of coordinate in coordinates.
static Coordinate CoordinateArrays.minCoordinate(Coordinate[] coordinates)
          Returns the minimum coordinate, using the usual lexicographic comparison.
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.removeRepeatedPoints(Coordinate[] coord)
          If the coordinate array argument has repeated points, constructs a new array containing no repeated points.
static void CoordinateArrays.reverse(Coordinate[] coord)
          Reverses the coordinates in an array in-place.
static void CoordinateArrays.scroll(Coordinate[] coordinates, Coordinate firstCoordinate)
          Shifts the positions of the coordinates until firstCoordinate is first.
static void CoordinateArrays.scroll(Coordinate[] coordinates, Coordinate firstCoordinate)
          Shifts the positions of the coordinates until firstCoordinate is first.
static java.util.List<DirectPositionImpl> CoordinateArrays.toDirectPositionList(org.opengis.referencing.crs.CoordinateReferenceSystem crs, Coordinate[] coordArray)
          Converts a Coordinate array into a list of DirectPositions
static java.util.List<org.opengis.geometry.coordinate.Position> CoordinateArrays.toPositionList(org.opengis.referencing.crs.CoordinateReferenceSystem crs, Coordinate[] coordArray)
          Converts a Coordinate array into a list of Positions SJ: faellt evtl weg, wenn coordinate durch DirectPosition ausgetauscht wird
 

Uses of Coordinate in org.geotools.geometry.iso.util.algorithm2D
 

Fields in org.geotools.geometry.iso.util.algorithm2D declared as Coordinate
protected  Coordinate[][] LineIntersector.inputLines
           
protected  Coordinate[] LineIntersector.intPt
           
protected  Coordinate LineIntersector.pa
           
protected  Coordinate LineIntersector.pb
           
 

Methods in org.geotools.geometry.iso.util.algorithm2D that return Coordinate
 Coordinate HCoordinate.getCoordinate()
           
 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
static Coordinate HCoordinate.intersection(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)
          Computes the (approximate) intersection point between two line segments using homogeneous coordinates.
protected  Coordinate[] ConvexHull.toCoordinateArray(java.util.Stack stack)
          An alternative to Stack.toArray, which is not present in earlier versions of Java.
 

Methods in org.geotools.geometry.iso.util.algorithm2D with parameters of type Coordinate
static double LineIntersector.computeEdgeDistance(Coordinate p, Coordinate p0, Coordinate p1)
          Computes the "edge distance" of an intersection point p along a segment.
protected abstract  int LineIntersector.computeIntersect(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)
           
protected  int RobustLineIntersector.computeIntersect(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)
           
abstract  void LineIntersector.computeIntersection(Coordinate p, Coordinate p1, Coordinate p2)
          Compute the intersection of a point p and the line p1-p2.
 void RobustLineIntersector.computeIntersection(Coordinate p, Coordinate p1, Coordinate p2)
           
 void LineIntersector.computeIntersection(Coordinate p1, Coordinate p2, Coordinate p3, Coordinate p4)
          Computes the intersection of the lines p1-p2 and p3-p4.
static int CGAlgorithms.computeOrientation(Coordinate p1, Coordinate p2, Coordinate q)
          Computes the orientation of a point q to the directed line segment p1-p2.
static boolean SimplePointInAreaLocator.containsPointInPolygon(Coordinate p, SurfaceImpl aSurface)
           
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 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 Coordinate HCoordinate.intersection(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)
          Computes the (approximate) intersection point between two line segments using homogeneous coordinates.
 boolean PointLocator.intersects(Coordinate p, GeometryImpl geom)
          Convenience method to test a point for intersection with a Geometry
static boolean CGAlgorithms.isCCW(Coordinate[] ring)
          Computes whether a ring defined by an array of Coordinate is oriented counter-clockwise.
 boolean LineIntersector.isIntersection(Coordinate pt)
          Test whether a point is a intersection point of two line segments.
static boolean CGAlgorithms.isOnLine(Coordinate p, Coordinate[] pt)
          Test whether a point lies on the line segments defined by a list of coordinates.
static boolean CGAlgorithms.isOnLine(Coordinate p, Coordinate[] pt)
          Test whether a point lies on the line segments defined by a list of coordinates.
static boolean CGAlgorithms.isPointInRing(Coordinate p, Coordinate[] ring)
          Test whether a point lies inside a ring.
static boolean CGAlgorithms.isPointInRing(Coordinate p, Coordinate[] ring)
          Test whether a point lies inside a ring.
static int SimplePointInAreaLocator.locate(Coordinate p, GeometryImpl geom)
          locate is the main location function.
 int PointLocator.locate(Coordinate p, GeometryImpl geom)
          Computes the topological relationship (Location) of a single point to a Geometry.
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 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)
          Returns the signed area for a ring.
 

Constructors in org.geotools.geometry.iso.util.algorithm2D with parameters of type Coordinate
ConvexHull(Coordinate[] pts, org.opengis.referencing.crs.CoordinateReferenceSystem crs)
          Create a new convex hull construction for the input Coordinate array.
HCoordinate(Coordinate p)
           
 



Copyright © 1996-2010 Geotools. All Rights Reserved.