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