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.densify |
Classes to perform densification on geometries.
|
org.locationtech.jts.dissolve | |
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.io.gml2 |
Classes to read and write the GML2 geometry format.
|
org.locationtech.jts.io.kml | |
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.polygonize |
An API for polygonizing sets of lines.
|
org.locationtech.jts.operation.predicate |
Classes which implement topological predicates optimized for particular kinds of geometries.
|
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.shape.random | |
org.locationtech.jts.simplify |
Classes which implement algorithms for simplifying or generalizing geometries.
|
org.locationtech.jts.triangulate |
Classes to compute Delaunay triangulations.
|
org.locationtech.jts.triangulate.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.jtsexample.geom | |
org.locationtech.jtsexample.technique | |
org.locationtech.jtstest.clean | |
org.locationtech.jtstest.function | |
org.locationtech.jtstest.geomop | |
org.locationtech.jtstest.testbuilder | |
org.locationtech.jtstest.testbuilder.controller | |
org.locationtech.jtstest.testbuilder.geom | |
org.locationtech.jtstest.testbuilder.io.shapefile | |
org.locationtech.jtstest.testbuilder.model | |
org.locationtech.jtstest.testbuilder.topostretch | |
org.locationtech.jtstest.testbuilder.ui | |
org.locationtech.jtstest.testbuilder.ui.render | |
org.locationtech.jtstest.testbuilder.ui.style | |
org.locationtech.jtstest.testbuilder.ui.tools | |
org.locationtech.jtstest.util.io |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
Centroid.areaBasePt |
private Coordinate |
MinimumBoundingCircle.centre |
private Coordinate |
InteriorPointPoint.centroid |
private Coordinate |
InteriorPointLine.centroid |
private Coordinate |
Centroid.cg3 |
private Coordinate[] |
MinimumDiameter.convexHullPts |
private Coordinate |
RectangleLineIntersector.diagDown0 |
private Coordinate |
RectangleLineIntersector.diagDown1 |
private Coordinate |
RectangleLineIntersector.diagUp0 |
private Coordinate |
RectangleLineIntersector.diagUp1 |
private Coordinate[] |
MinimumBoundingCircle.extremalPts |
protected Coordinate[][] |
LineIntersector.inputLines |
private Coordinate[] |
ConvexHull.inputPts |
private Coordinate |
InteriorPointPoint.interiorPoint |
private Coordinate |
InteriorPointLine.interiorPoint |
private Coordinate |
InteriorPointArea.interiorPoint |
protected Coordinate[] |
LineIntersector.intPt |
private Coordinate |
Centroid.lineCentSum |
private Coordinate |
MinimumDiameter.minWidthPt |
private Coordinate |
ConvexHull.RadialComparator.origin |
private Coordinate |
RayCrossingCounter.p |
protected Coordinate |
LineIntersector.pa |
protected Coordinate |
LineIntersector.pb |
private Coordinate |
Centroid.ptCentSum |
private Coordinate |
Centroid.triangleCent3 |
Modifier and Type | Method and Description |
---|---|
static Coordinate |
InteriorPointArea.centre(Envelope envelope)
Returns the centre point of the envelope.
|
private Coordinate[] |
ConvexHull.cleanRing(Coordinate[] original) |
private Coordinate[] |
ConvexHull.computeOctPts(Coordinate[] inputPts) |
private Coordinate[] |
ConvexHull.computeOctRing(Coordinate[] inputPts) |
private static Coordinate[] |
ConvexHull.extractCoordinates(Geometry geom) |
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 |
InteriorPointPoint.getInteriorPoint() |
Coordinate |
InteriorPointLine.getInteriorPoint() |
Coordinate |
InteriorPointArea.getInteriorPoint()
Gets the computed interior point.
|
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 |
private Coordinate |
RobustLineIntersector.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
This method computes the actual value of the intersection point.
|
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.
|
private Coordinate |
RobustLineIntersector.intersectionWithNormalization(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
private static Coordinate |
MinimumBoundingCircle.lowestPoint(Coordinate[] pts) |
private static Coordinate |
RobustLineIntersector.nearestEndpoint(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Finds the endpoint of the segments P and Q which
is closest to the other segment.
|
private Coordinate[] |
ConvexHull.padArray3(Coordinate[] pts) |
private static Coordinate |
MinimumBoundingCircle.pointWithMinAngleWithSegment(Coordinate[] pts,
Coordinate P,
Coordinate Q) |
private static Coordinate |
MinimumBoundingCircle.pointWitMinAngleWithX(Coordinate[] pts,
Coordinate P) |
private Coordinate[] |
ConvexHull.preSort(Coordinate[] pts) |
private Coordinate[] |
ConvexHull.reduce(Coordinate[] inputPts)
Uses a heuristic to reduce the number of points scanned
to compute the hull.
|
private Coordinate |
RobustLineIntersector.safeHCoordinateIntersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes a segment intersection 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.
|
Modifier and Type | Method and Description |
---|---|
private void |
InteriorPointPoint.add(Coordinate point) |
private void |
InteriorPointLine.add(Coordinate point) |
private void |
InteriorPointLine.addEndpoints(Coordinate[] pts) |
private void |
Centroid.addHole(Coordinate[] pts) |
private void |
InteriorPointLine.addInterior(Coordinate[] pts) |
private void |
Centroid.addLineSegments(Coordinate[] pts)
Adds the line segments defined by an array of coordinates
to the linear centroid accumulators.
|
private void |
Centroid.addPoint(Coordinate pt)
Adds a point to the point centroid accumulator.
|
private void |
Centroid.addShell(Coordinate[] pts) |
private void |
Centroid.addTriangle(Coordinate p0,
Coordinate p1,
Coordinate p2,
boolean isPositiveArea) |
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.
|
private static double |
Centroid.area2(Coordinate p1,
Coordinate p2,
Coordinate p3)
Returns twice the signed area of the triangle p1-p2-p3.
|
private static void |
Centroid.centroid3(Coordinate p1,
Coordinate p2,
Coordinate p3,
Coordinate c)
Computes three times the centroid of the triangle p1-p2-p3.
|
private void |
RobustLineIntersector.checkDD(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2,
Coordinate intPt) |
private Coordinate[] |
ConvexHull.cleanRing(Coordinate[] original) |
private static double |
MinimumDiameter.computeC(double a,
double b,
Coordinate p) |
private int |
RobustLineIntersector.computeCollinearIntersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
private void |
MinimumDiameter.computeConvexRingMinDiameter(Coordinate[] pts)
Compute the width information for a ring of
Coordinate s. |
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 abstract int |
LineIntersector.computeIntersect(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
void |
RobustLineIntersector.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.
|
private void |
PointLocator.computeLocation(Coordinate p,
Geometry geom) |
private Coordinate[] |
ConvexHull.computeOctPts(Coordinate[] inputPts) |
private Coordinate[] |
ConvexHull.computeOctRing(Coordinate[] inputPts) |
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[] 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.
|
private int |
MinimumDiameter.findMaxPerpDistance(Coordinate[] pts,
LineSegment seg,
int startIndex) |
private java.util.Stack |
ConvexHull.grahamScan(Coordinate[] c)
Uses the Graham Scan algorithm to compute the convex hull vertices.
|
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.
|
private Coordinate |
RobustLineIntersector.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
This method computes the actual value of the intersection point.
|
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.
|
private Coordinate |
RobustLineIntersector.intersectionWithNormalization(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
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.
|
private boolean |
ConvexHull.isBetween(Coordinate c1,
Coordinate c2,
Coordinate c3) |
static boolean |
Orientation.isCCW(Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate s is
oriented counter-clockwise. |
static boolean |
CGAlgorithms.isCCW(Coordinate[] ring)
Deprecated.
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.
|
static boolean |
PointLocation.isInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
private boolean |
RobustLineIntersector.isInSegmentEnvelopes(Coordinate intPt)
Tests whether a point lies in the envelopes of both input segments.
|
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 |
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,
Coordinate[] line)
Tests whether a point lies on the line defined by a list of
coordinates.
|
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 |
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,
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.
|
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Deprecated.
Tests whether a point lies inside or on a ring.
|
private Geometry |
ConvexHull.lineOrPolygon(Coordinate[] coordinates) |
int |
PointLocator.locate(Coordinate p,
Geometry geom)
Computes the topological relationship (
Location ) of a single point
to a Geometry. |
private int |
PointLocator.locateInPolygon(Coordinate p,
Polygon poly) |
private int |
PointLocator.locateInPolygonRing(Coordinate p,
LinearRing ring) |
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 |
PointLocation.locateInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the
exterior of a ring.
|
private int |
PointLocator.locateOnLineString(Coordinate p,
LineString l) |
private int |
PointLocator.locateOnPoint(Coordinate p,
Point pt) |
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)
Deprecated.
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,
CoordinateSequence ring)
Determines the
Location of a point in a ring. |
private static Coordinate |
MinimumBoundingCircle.lowestPoint(Coordinate[] pts) |
private static Coordinate |
RobustLineIntersector.nearestEndpoint(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Finds the endpoint of the segments P and Q which
is closest to the other segment.
|
private static int |
MinimumDiameter.nextIndex(Coordinate[] pts,
int index) |
static double |
LineIntersector.nonRobustComputeEdgeDistance(Coordinate p,
Coordinate p1,
Coordinate p2)
This function is non-robust, since it may compute the square of large numbers.
|
private void |
RobustLineIntersector.normalizeToEnvCentre(Coordinate n00,
Coordinate n01,
Coordinate n10,
Coordinate n11,
Coordinate normPt)
Normalize the supplied coordinates to
so that the midpoint of their intersection envelope
lies at the origin.
|
private void |
RobustLineIntersector.normalizeToMinimum(Coordinate n1,
Coordinate n2,
Coordinate n3,
Coordinate n4,
Coordinate normPt)
Normalize the supplied coordinates so that
their minimum ordinate values lie at the origin.
|
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 |
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 |
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)
Deprecated.
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
private static int |
CGAlgorithmsDD.orientationIndexFilter(Coordinate pa,
Coordinate pb,
Coordinate pc)
A filter for computing the orientation index of three coordinates.
|
private Coordinate[] |
ConvexHull.padArray3(Coordinate[] pts) |
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.pointToSegmentString(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
private static Coordinate |
MinimumBoundingCircle.pointWithMinAngleWithSegment(Coordinate[] pts,
Coordinate P,
Coordinate Q) |
private static Coordinate |
MinimumBoundingCircle.pointWithMinAngleWithSegment(Coordinate[] pts,
Coordinate P,
Coordinate Q) |
private static Coordinate |
MinimumBoundingCircle.pointWitMinAngleWithX(Coordinate[] pts,
Coordinate P) |
private static Coordinate |
MinimumBoundingCircle.pointWitMinAngleWithX(Coordinate[] pts,
Coordinate P) |
private static int |
ConvexHull.RadialComparator.polarCompare(Coordinate o,
Coordinate p,
Coordinate q)
Given two points p and q compare them with respect to their radial
ordering about point o.
|
private Coordinate[] |
ConvexHull.preSort(Coordinate[] pts) |
private Coordinate[] |
ConvexHull.reduce(Coordinate[] inputPts)
Uses a heuristic to reduce the number of points scanned
to compute the hull.
|
private Coordinate |
RobustLineIntersector.safeHCoordinateIntersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes a segment intersection using homogeneous coordinates.
|
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!
|
private void |
Centroid.setAreaBasePoint(Coordinate basePt) |
static double |
CGAlgorithms.signedArea(Coordinate[] ring)
Deprecated.
Computes the signed area for a ring.
|
Constructor and 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) |
RadialComparator(Coordinate origin) |
RayCrossingCounter(Coordinate p) |
Modifier and Type | Field and Description |
---|---|
private Coordinate[] |
PointPairDistance.pt |
Modifier and Type | Method and Description |
---|---|
Coordinate |
PointPairDistance.getCoordinate(int i) |
Coordinate[] |
PointPairDistance.getCoordinates() |
Coordinate[] |
DiscreteHausdorffDistance.getCoordinates() |
Modifier and Type | Method and 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) |
private void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1,
double distance)
Initializes the points, avoiding recomputing the distance.
|
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1) |
Modifier and Type | Method and Description |
---|---|
private void |
IndexedPointInAreaLocator.IntervalIndexedGeometry.addLine(Coordinate[] pts) |
static boolean |
SimplePointInAreaLocator.containsPointInPolygon(Coordinate p,
Polygon poly)
Determines whether a point lies in a
Polygon . |
int |
SimplePointInAreaLocator.locate(Coordinate p) |
int |
PointOnGeometryLocator.locate(Coordinate p)
|
int |
IndexedPointInAreaLocator.locate(Coordinate p)
|
static int |
SimplePointInAreaLocator.locate(Coordinate p,
Geometry geom)
|
private static int |
SimplePointInAreaLocator.locateInGeometry(Coordinate p,
Geometry geom) |
static int |
SimplePointInAreaLocator.locatePointInPolygon(Coordinate p,
Polygon poly)
|
private static int |
SimplePointInAreaLocator.locatePointInRing(Coordinate p,
LinearRing ring)
Determines whether a point lies in a LinearRing,
using the ring envelope to short-circuit if possible.
|
Modifier and Type | Method and Description |
---|---|
private static Coordinate[] |
ShapeReader.nextCoordinateArray(java.awt.geom.PathIterator pathIt) |
Modifier and Type | Method and Description |
---|---|
private void |
ShapeWriter.appendRing(PolygonShape poly,
Coordinate[] coords) |
private boolean |
ShapeReader.isHole(Coordinate[] pts) |
private java.awt.geom.GeneralPath |
PolygonShape.toPath(Coordinate[] coordinates)
Creates a GeneralPath representing a polygon ring
having the given coordinate sequence.
|
void |
PointTransformation.transform(Coordinate src,
java.awt.geom.Point2D dest)
Transforms a
Coordinate into a Java2D Point . |
void |
IdentityPointTransformation.transform(Coordinate model,
java.awt.geom.Point2D view) |
private java.awt.geom.Point2D |
ShapeWriter.transformPoint(Coordinate model) |
private java.awt.geom.Point2D |
ShapeWriter.transformPoint(Coordinate model,
java.awt.geom.Point2D view) |
Constructor and Description |
---|
PolygonShape(Coordinate[] shellVertices,
java.util.Collection holeVerticesCollection)
Creates a new polygon
Shape . |
Modifier and Type | Method and Description |
---|---|
private static Coordinate[] |
Densifier.densifyPoints(Coordinate[] pts,
double distanceTolerance,
PrecisionModel precModel)
Densifies a coordinate sequence.
|
Modifier and Type | Method and Description |
---|---|
private static Coordinate[] |
Densifier.densifyPoints(Coordinate[] pts,
double distanceTolerance,
PrecisionModel precModel)
Densifies a coordinate sequence.
|
Modifier and Type | Method and Description |
---|---|
protected HalfEdge |
DissolveEdgeGraph.createEdge(Coordinate p0) |
Constructor and Description |
---|
DissolveHalfEdge(Coordinate orig) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
HalfEdge.orig |
Modifier and Type | Method and 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 and 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.
|
private HalfEdge |
EdgeGraph.create(Coordinate p0,
Coordinate p1) |
protected HalfEdge |
EdgeGraph.createEdge(Coordinate orig)
Creates a single HalfEdge.
|
boolean |
HalfEdge.equals(Coordinate p0,
Coordinate p1)
Tests whether this edge has the given orig and dest vertices.
|
HalfEdge |
HalfEdge.find(Coordinate dest)
Finds the edge starting at the origin of this edge
with the given dest vertex,
if any.
|
HalfEdge |
EdgeGraph.findEdge(Coordinate orig,
Coordinate dest)
Finds an edge in this graph with the given origin
and destination, if one exists.
|
private HalfEdge |
EdgeGraph.insert(Coordinate orig,
Coordinate dest,
HalfEdge eAdj)
Inserts an edge not already present into the graph.
|
static boolean |
EdgeGraph.isValidEdge(Coordinate orig,
Coordinate dest)
Tests if the given coordinates form a valid edge (with non-zero length).
|
Constructor and Description |
---|
HalfEdge(Coordinate orig)
Creates an edge originating from a given coordinate.
|
MarkHalfEdge(Coordinate orig)
Creates a new marked edge.
|
Modifier and Type | Field and Description |
---|---|
private static Coordinate[] |
CoordinateList.coordArrayType |
private static Coordinate[] |
CoordinateArrays.coordArrayType |
private Coordinate[] |
DefaultCoordinateSequence.coordinates
Deprecated.
|
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
|
private Coordinate |
TopologyException.pt |
Modifier and Type | Method and 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 |
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 |
DefaultCoordinateSequence.getCoordinate(int i)
Deprecated.
Get the Coordinate with index i.
|
Coordinate |
CoordinateSequence.getCoordinate(int i)
Returns (possibly a copy of) the i'th coordinate in this sequence.
|
Coordinate |
CoordinateList.getCoordinate(int i) |
Coordinate |
DefaultCoordinateSequence.getCoordinateCopy(int i)
Deprecated.
Get a copy of the Coordinate with index 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.
|
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.
|
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[] |
DefaultCoordinateSequence.toCoordinateArray()
Deprecated.
This method exposes the internal Array of Coordinate Objects
|
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(java.util.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
|
Modifier and Type | Method and Description |
---|---|
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.
|
void |
CoordinateList.add(int i,
Coordinate coord,
boolean allowRepeated)
Inserts the specified coordinate at the specified position in this list.
|
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment
AC.
|
static double |
Triangle.area(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 2D area of a triangle.
|
static double |
Triangle.area3D(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 3D area of a triangle.
|
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the
given amount, or an empty coordinate array.
|
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle.
|
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point.
|
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two
Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two
Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
boolean |
Envelope.contains(Coordinate p)
Tests if the given point lies in or on the envelope.
|
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument
Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source
Coordinate array
into a destination Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source
Coordinate array
into a destination Coordinate array. |
boolean |
Envelope.covers(Coordinate p)
Tests if the given point lies in or on the envelope.
|
CoordinateSequence |
DefaultCoordinateSequenceFactory.create(Coordinate[] coordinates)
Deprecated.
Returns a DefaultCoordinateSequence based on the given array (the array is
not copied).
|
CoordinateSequence |
CoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns a
CoordinateSequence based on the given array. |
LinearRing |
GeometryFactory.createLinearRing(Coordinate[] coordinates)
Creates a
LinearRing using the given Coordinate s. |
LineString |
GeometryFactory.createLineString(Coordinate[] coordinates)
Creates a LineString using the given Coordinates.
|
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) |
private Point |
Geometry.createPointFromInternalCoord(Coordinate coord,
Geometry exemplar) |
Polygon |
GeometryFactory.createPolygon(Coordinate[] shell)
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 c)
Computes the 2-dimensional Euclidean distance to another location.
|
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.
|
protected boolean |
Geometry.equal(Coordinate a,
Coordinate b,
double tolerance) |
boolean |
Coordinate.equalInZ(Coordinate c,
double tolerance)
Tests if another coordinate has the same value for Z, within a tolerance.
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise
equal (as compared using Coordinate#equals)
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
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 |
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.
|
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)
|
void |
CoordinateFilter.filter(Coordinate coord)
Performs an operation with the
coord . |
void |
DefaultCoordinateSequence.getCoordinate(int index,
Coordinate coord)
Deprecated.
|
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.
|
static Coordinate[] |
CoordinateArrays.intersection(Coordinate[] coordinates,
Envelope env)
Extracts the coordinates which intersect an
Envelope . |
boolean |
OctagonalEnvelope.intersects(Coordinate p) |
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.
|
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 . |
private static boolean |
CoordinateArrays.isEqualReversed(Coordinate[] pts1,
Coordinate[] pts2)
Determines whether two
Coordinate arrays of equal length
are equal in opposite directions. |
private static boolean |
CoordinateArrays.isEqualReversed(Coordinate[] pts1,
Coordinate[] pts2)
Determines whether two
Coordinate arrays of equal length
are equal in opposite directions. |
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.
|
private static java.lang.String |
TopologyException.msgWithCoord(java.lang.String msg,
Coordinate pt) |
int |
LineSegment.orientationIndex(Coordinate p)
Determines the orientation index of a
Coordinate relative to this segment. |
boolean |
Envelope.overlaps(Coordinate p)
Deprecated.
Use #intersects instead.
|
static HCoordinate |
Triangle.perpendicularBisector(Coordinate a,
Coordinate b)
Computes the line which is the perpendicular bisector of the line segment
a-b.
|
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined
by this line segment.
|
double |
LineSegment.projectionFactor(Coordinate p)
Computes the Projection Factor for the projection of the point p
onto this LineSegment.
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points,
constructs a new array containing no repeated points.
|
static void |
CoordinateArrays.reverse(Coordinate[] coord)
Reverses the coordinates in an array in-place.
|
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
double |
LineSegment.segmentFraction(Coordinate inputPt)
Computes the fraction of distance (in [0.0, 1.0])
that the projection of a point occurs along this line segment.
|
void |
Coordinate.setCoordinate(Coordinate other)
Sets this
Coordinate s (x,y,z) values to that of other . |
void |
LineSegment.setCoordinates(Coordinate p0,
Coordinate p1) |
static double |
Triangle.signedArea(Coordinate a,
Coordinate b,
Coordinate c)
Computes the signed 2D area of a triangle.
|
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated.
no longer needed, since internal representation is same as external representation
|
void |
PrecisionModel.toExternal(Coordinate internal,
Coordinate external)
Deprecated.
no longer needed, since internal representation is same as external representation
|
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated.
use makePrecise instead
|
void |
PrecisionModel.toInternal(Coordinate external,
Coordinate internal)
Deprecated.
use makePrecise instead
|
Constructor and 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.
|
DefaultCoordinateSequence(Coordinate[] coordinates)
Deprecated.
Constructs a DefaultCoordinateSequence based on the given array (the
array is not copied).
|
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,
GeometryFactory factory)
This method is ONLY used to avoid deprecation warnings.
|
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 | Field and Description |
---|---|
private Coordinate[] |
CoordinateArraySequence.coordinates |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
PackedCoordinateSequence.getCachedCoords() |
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
|
Modifier and Type | Method and Description |
---|---|
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) |
Constructor and 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 | Field and Description |
---|---|
private Coordinate |
AffineTransformationBuilder.dest0 |
private Coordinate |
AffineTransformationBuilder.dest1 |
private Coordinate |
AffineTransformationBuilder.dest2 |
private Coordinate |
AffineTransformationBuilder.src0 |
private Coordinate |
AffineTransformationBuilder.src1 |
private Coordinate |
AffineTransformationBuilder.src2 |
Modifier and Type | Method and 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 and Description |
---|---|
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 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[] 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 and 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 and Description |
---|---|
protected Coordinate |
Node.coord |
Coordinate |
EdgeIntersection.coord |
private Coordinate |
GeometryGraph.invalidPoint |
private Coordinate |
EdgeEnd.p0 |
private Coordinate |
EdgeEnd.p1 |
(package private) Coordinate[] |
Edge.pts |
Modifier and Type | Method and Description |
---|---|
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() |
Modifier and Type | Method and Description |
---|---|
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.
|
private void |
GeometryGraph.addSelfIntersectionNode(int argIndex,
Coordinate coord,
int loc)
Add a node for a self-intersection.
|
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
|
private int |
EdgeEndStar.getLocation(int geomIndex,
Coordinate p,
GeometryGraph[] geom) |
protected void |
EdgeEnd.init(Coordinate p0,
Coordinate p1) |
private void |
GeometryGraph.insertBoundaryPoint(int argIndex,
Coordinate coord)
Adds candidate boundary points using the current
BoundaryNodeRule . |
private void |
GeometryGraph.insertPoint(int argIndex,
Coordinate coord,
int onLocation) |
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. |
private boolean |
PlanarGraph.matchInSameDirection(Coordinate p0,
Coordinate p1,
Coordinate ep0,
Coordinate ep1)
The coordinate pairs match if they define line segments lying in the same direction.
|
static int |
Quadrant.quadrant(Coordinate p0,
Coordinate p1)
Returns the quadrant of a directed line segment from p0 to p1.
|
Constructor and 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 | Field and Description |
---|---|
private Coordinate |
SegmentIntersector.properIntersectionPoint |
(package private) Coordinate[] |
SweepLineSegment.pts |
(package private) Coordinate[] |
MonotoneChainEdge.pts |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
MonotoneChainEdge.getCoordinates() |
Coordinate |
SegmentIntersector.getProperIntersectionPoint() |
Modifier and Type | Method and Description |
---|---|
private int |
MonotoneChainIndexer.findChainEnd(Coordinate[] pts,
int start) |
int[] |
MonotoneChainIndexer.getChainStartIndices(Coordinate[] pts) |
Modifier and Type | Field and Description |
---|---|
private Coordinate[] |
MonotoneChain.pts |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
MonotoneChain.getCoordinates()
Return the subsequence of coordinates forming this chain.
|
Modifier and Type | Method and Description |
---|---|
private static int |
MonotoneChainBuilder.findChainEnd(Coordinate[] pts,
int start)
Finds the index of the last point in a monotone chain
starting at a given point.
|
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 and Description |
---|
MonotoneChain(Coordinate[] pts,
int start,
int end,
java.lang.Object context) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
KdTree.BestMatchVisitor.p |
private Coordinate |
KdNode.p |
Modifier and Type | Method and 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 and Description |
---|---|
private KdNode |
KdTree.findBestMatchNode(Coordinate p)
Finds the node in the tree which is the best match for a point
being inserted.
|
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.
|
private KdNode |
KdTree.insertExact(Coordinate p,
java.lang.Object data)
Inserts a point known to be beyond the distance tolerance of any existing node.
|
Constructor and Description |
---|
BestMatchVisitor(Coordinate p,
double tolerance) |
KdNode(Coordinate p,
java.lang.Object data)
Creates a new KdNode.
|
Modifier and Type | Field and Description |
---|---|
private static Coordinate |
Root.origin |
private Coordinate |
Key.pt |
Modifier and Type | Method and Description |
---|---|
Coordinate |
Key.getCentre() |
Coordinate |
Key.getPoint() |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
WKTReader.getCoordinates()
Returns the next array of
Coordinate s in the stream. |
private Coordinate[] |
WKTReader.getCoordinatesNoLeftParen() |
private Coordinate |
WKTReader.getPreciseCoordinate() |
Modifier and Type | Method and Description |
---|---|
private void |
WKTWriter.appendCoordinate(Coordinate coordinate,
java.io.Writer writer)
Converts a
Coordinate to <Point> format,
then appends it to the writer. |
private void |
WKTWriter.appendPointTaggedText(Coordinate coordinate,
int level,
java.io.Writer writer,
PrecisionModel precisionModel)
Converts a
Coordinate to <Point Tagged Text> format,
then appends it to the writer. |
private void |
WKTWriter.appendPointText(Coordinate coordinate,
int level,
java.io.Writer writer,
PrecisionModel precisionModel)
Converts a
Coordinate to <Point Text> format, then
appends it to the writer. |
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 . |
private Point[] |
WKTReader.toPoints(Coordinate[] coordinates)
Creates an array of
Point s having the given Coordinate
s. |
Modifier and Type | Method and Description |
---|---|
private void |
GMLWriter.write(Coordinate[] coords,
java.io.Writer writer,
int level)
Takes a list of coordinates and converts it to GML.
2d and 3d aware. |
Modifier and Type | Method and Description |
---|---|
private void |
KMLWriter.write(Coordinate[] coords,
int level,
java.lang.StringBuffer buf)
Takes a list of coordinates and converts it to KML.
2d and 3d aware. |
private void |
KMLWriter.write(Coordinate p,
java.lang.StringBuffer buf) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
LinearGeometryBuilder.lastPt |
Modifier and Type | Method and 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). |
private Coordinate[] |
LinearGeometryBuilder.validCoordinateSequence(Coordinate[] pts) |
Modifier and Type | Method and 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.
|
LinearLocation |
LocationIndexedLine.indexOf(Coordinate pt)
Computes the index for a given point on the line.
|
LinearLocation |
LocationIndexOfPoint.indexOf(Coordinate inputPt)
Find the nearest location along a linear
Geometry to a given point. |
double |
LengthIndexedLine.indexOf(Coordinate pt)
Computes the minimum index for a point on the line.
|
double |
LengthIndexOfPoint.indexOf(Coordinate inputPt)
Find the nearest location along a linear
Geometry to a given point. |
static LinearLocation |
LocationIndexOfPoint.indexOf(Geometry linearGeom,
Coordinate inputPt) |
static double |
LengthIndexOfPoint.indexOf(Geometry linearGeom,
Coordinate inputPt) |
double |
LengthIndexedLine.indexOfAfter(Coordinate pt,
double minIndex)
Finds the index for a point on the line
which is greater than the given index.
|
double |
LengthIndexOfPoint.indexOfAfter(Coordinate inputPt,
double minIndex)
Finds the nearest index along the linear
Geometry
to a given Coordinate
after the specified minimum index. |
LinearLocation |
LocationIndexedLine.indexOfAfter(Coordinate pt,
LinearLocation minIndex)
Finds the index for a point on the line
which is greater than the given index.
|
LinearLocation |
LocationIndexOfPoint.indexOfAfter(Coordinate inputPt,
LinearLocation minIndex)
Find the nearest
LinearLocation along the linear Geometry
to a given Coordinate
after the specified minimum LinearLocation . |
static double |
LengthIndexOfPoint.indexOfAfter(Geometry linearGeom,
Coordinate inputPt,
double minIndex) |
static LinearLocation |
LocationIndexOfPoint.indexOfAfter(Geometry linearGeom,
Coordinate inputPt,
LinearLocation minIndex) |
private double |
LengthIndexOfPoint.indexOfFromStart(Coordinate inputPt,
double minIndex) |
private LinearLocation |
LocationIndexOfPoint.indexOfFromStart(Coordinate inputPt,
LinearLocation minIndex) |
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.
|
private double |
LengthIndexOfPoint.segmentNearestMeasure(LineSegment seg,
Coordinate inputPt,
double segmentStartMeasure) |
private Coordinate[] |
LinearGeometryBuilder.validCoordinateSequence(Coordinate[] pts) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
Plane3D.basePt |
Modifier and Type | Method and Description |
---|---|
static Coordinate |
Vector3D.normalize(Coordinate v) |
Coordinate |
Vector2D.toCoordinate() |
Coordinate |
Vector2D.translate(Coordinate coord) |
Modifier and Type | Method and Description |
---|---|
static Vector3D |
Vector3D.create(Coordinate coord)
Creates a vector from a
Coordinate . |
static Vector2D |
Vector2D.create(Coordinate coord)
Creates a vector from a
Coordinate . |
static Vector2D |
Vector2D.create(Coordinate from,
Coordinate to)
Creates a vector with the direction and magnitude
of the difference between the
to and from
Coordinate s. |
static double |
Vector3D.dot(Coordinate v1,
Coordinate v2)
Computes the 3D dot-product of two
Coordinate s. |
static double |
Vector3D.dot(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the dot product of the 3D vectors AB and CD.
|
static double |
Vector3D.length(Coordinate v) |
static Coordinate |
Vector3D.normalize(Coordinate v) |
double |
Plane3D.orientedDistance(Coordinate p)
Computes the oriented distance from a point to the plane.
|
Coordinate |
Vector2D.translate(Coordinate coord) |
Constructor and 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 and Description |
---|---|
Coordinate |
SegmentNode.coord |
private Coordinate |
InteriorIntersectionFinder.interiorIntersection |
private Coordinate |
SegmentIntersectionDetector.intPt |
private Coordinate[] |
SegmentIntersectionDetector.intSegments |
private Coordinate[] |
InteriorIntersectionFinder.intSegments |
private Coordinate |
IntersectionAdder.properIntersectionPoint |
private Coordinate[] |
OrientedCoordinateArray.pts |
private Coordinate[] |
NodedSegmentString.pts |
private Coordinate[] |
BasicSegmentString.pts |
Modifier and Type | Method and Description |
---|---|
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() |
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.
|
private Coordinate[] |
ScaledNoder.scale(Coordinate[] pts) |
Modifier and Type | Method and Description |
---|---|
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.
|
private void |
NodingValidator.checkCollapse(Coordinate p0,
Coordinate p1,
Coordinate p2) |
private void |
NodingValidator.checkEndPtVertexIntersections(Coordinate testPt,
java.util.Collection segStrings) |
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 . |
private static int |
OrientedCoordinateArray.compareOriented(Coordinate[] pts1,
boolean orientation1,
Coordinate[] pts2,
boolean orientation2) |
private static int |
OrientedCoordinateArray.compareOriented(Coordinate[] pts1,
boolean orientation1,
Coordinate[] pts2,
boolean orientation2) |
private boolean |
NodingValidator.hasInteriorIntersection(LineIntersector li,
Coordinate p0,
Coordinate p1) |
static int |
Octant.octant(Coordinate p0,
Coordinate p1)
Returns the octant of a directed line segment from p0 to p1.
|
private static boolean |
OrientedCoordinateArray.orientation(Coordinate[] pts)
Computes the canonical orientation for a coordinate array.
|
private void |
ScaledNoder.rescale(Coordinate[] pts) |
private int |
NodedSegmentString.safeOctant(Coordinate p0,
Coordinate p1) |
private Coordinate[] |
ScaledNoder.scale(Coordinate[] pts) |
Constructor and 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 | Field and Description |
---|---|
private Coordinate[] |
HotPixel.corner
The corners of the hot pixel, in the order:
10
23
|
private Coordinate |
HotPixel.originalPt |
private Coordinate |
HotPixel.p0Scaled |
private Coordinate |
HotPixel.p1Scaled |
private Coordinate |
HotPixel.pt |
private Coordinate |
HotPixel.ptScaled |
Modifier and Type | Method and Description |
---|---|
Coordinate |
HotPixel.getCoordinate()
Gets the coordinate this hot pixel is based at.
|
Modifier and Type | Method and Description |
---|---|
private void |
HotPixel.copyScaled(Coordinate p,
Coordinate pScaled) |
private void |
HotPixel.initCorners(Coordinate pt) |
boolean |
HotPixel.intersects(Coordinate p0,
Coordinate p1)
Tests whether the line segment (p0-p1)
intersects this hot pixel.
|
private boolean |
HotPixel.intersectsPixelClosure(Coordinate p0,
Coordinate p1)
Test whether the given segment intersects
the closure of this hot pixel.
|
private boolean |
HotPixel.intersectsScaled(Coordinate p0,
Coordinate p1) |
private boolean |
HotPixel.intersectsToleranceSquare(Coordinate p0,
Coordinate p1)
Tests whether the segment p0-p1 intersects the hot pixel tolerance square.
|
Constructor and Description |
---|
HotPixel(Coordinate pt,
double scaleFactor,
LineIntersector li)
Creates a new hot pixel, using a given scale factor.
|
Modifier and Type | Field and Description |
---|---|
private Coordinate |
IsSimpleOp.nonSimpleLocation |
(package private) Coordinate |
IsSimpleOp.EndpointInfo.pt |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
BoundaryOp.computeBoundaryCoordinates(MultiLineString mLine) |
Coordinate |
IsSimpleOp.EndpointInfo.getCoordinate() |
Coordinate |
IsSimpleOp.getNonSimpleLocation()
Gets a coordinate for the location where the geometry
fails to be simple.
|
Modifier and Type | Method and Description |
---|---|
private void |
BoundaryOp.addEndpoint(Coordinate pt) |
private void |
IsSimpleOp.addEndpoint(java.util.Map endPoints,
Coordinate p,
boolean isClosed)
Add an endpoint to the map, creating an entry for it if none exists
|
Constructor and Description |
---|
EndpointInfo(Coordinate pt) |
Modifier and Type | Field and Description |
---|---|
private static Coordinate[] |
OffsetSegmentString.COORDINATE_ARRAY_TYPE |
private Coordinate[] |
BufferInputLineSimplifier.inputLine |
private Coordinate |
RightmostEdgeFinder.minCoord |
private Coordinate |
BufferSubgraph.rightMostCoord |
private Coordinate |
OffsetSegmentGenerator.s0 |
private Coordinate |
OffsetSegmentGenerator.s1 |
private Coordinate |
OffsetSegmentGenerator.s2 |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
BufferInputLineSimplifier.collapseLine() |
private static Coordinate[] |
OffsetCurveBuilder.copyCoordinates(Coordinate[] pts) |
Coordinate |
RightmostEdgeFinder.getCoordinate() |
Coordinate[] |
OffsetSegmentString.getCoordinates() |
Coordinate[] |
OffsetSegmentGenerator.getCoordinates() |
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.
|
Modifier and Type | Method and Description |
---|---|
private void |
OffsetSegmentGenerator.addCornerFillet(Coordinate p,
Coordinate p0,
Coordinate p1,
int direction,
double radius)
Add points for a circular fillet around a reflex corner.
|
private void |
OffsetCurveSetBuilder.addCurve(Coordinate[] coord,
int leftLoc,
int rightLoc)
Creates a
SegmentString for a coordinate list which is a raw offset curve,
and adds it to the list of buffer curves. |
private void |
OffsetSegmentGenerator.addDirectedFillet(Coordinate p,
double startAngle,
double endAngle,
int direction,
double radius)
Adds points for a circular fillet arc
between two specified angles.
|
void |
OffsetSegmentGenerator.addLineEndCap(Coordinate p0,
Coordinate p1)
Add an end cap around point p1, terminating a line segment coming from p0
|
private void |
OffsetSegmentGenerator.addMitreJoin(Coordinate p,
LineSegment offset0,
LineSegment offset1,
double distance)
Adds a mitre join connecting the two reflex offset segments.
|
void |
OffsetSegmentGenerator.addNextSegment(Coordinate p,
boolean addStartPoint) |
private void |
OffsetCurveSetBuilder.addPolygonRing(Coordinate[] coord,
double offsetDistance,
int side,
int cwLeftLoc,
int cwRightLoc)
Adds an offset curve for a polygon ring.
|
void |
OffsetSegmentString.addPt(Coordinate pt) |
void |
OffsetSegmentString.addPts(Coordinate[] pt,
boolean isForward) |
void |
OffsetSegmentGenerator.addSegments(Coordinate[] pt,
boolean isForward) |
private void |
OffsetCurveBuilder.computeLineBufferCurve(Coordinate[] inputPts,
OffsetSegmentGenerator segGen) |
private void |
OffsetCurveBuilder.computeOffsetCurve(Coordinate[] inputPts,
boolean isRightSide,
OffsetSegmentGenerator segGen) |
private void |
OffsetCurveBuilder.computePointCurve(Coordinate pt,
OffsetSegmentGenerator segGen) |
private void |
OffsetCurveBuilder.computeRingBufferCurve(Coordinate[] inputPts,
int side,
OffsetSegmentGenerator segGen) |
private void |
OffsetCurveBuilder.computeSingleSidedBufferCurve(Coordinate[] inputPts,
boolean isRightSide,
OffsetSegmentGenerator segGen) |
private static Coordinate[] |
OffsetCurveBuilder.copyCoordinates(Coordinate[] pts) |
void |
OffsetSegmentGenerator.createCircle(Coordinate p)
Creates a CW circle around a point
|
void |
OffsetSegmentGenerator.createSquare(Coordinate p)
Creates a CW square around a point
|
private java.util.List |
SubgraphDepthLocater.findStabbedSegments(Coordinate stabbingRayLeftPt)
Finds all non-horizontal segments intersecting the stabbing line.
|
private void |
SubgraphDepthLocater.findStabbedSegments(Coordinate stabbingRayLeftPt,
DirectedEdge dirEdge,
java.util.List stabbedSegments)
Finds all non-horizontal segments intersecting the stabbing line
in the input dirEdge.
|
private void |
SubgraphDepthLocater.findStabbedSegments(Coordinate stabbingRayLeftPt,
java.util.List dirEdges,
java.util.List stabbedSegments)
Finds all non-horizontal segments intersecting the stabbing line
in the list of dirEdges.
|
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.
|
void |
OffsetSegmentGenerator.initSideSegments(Coordinate s1,
Coordinate s2,
int side) |
private boolean |
BufferInputLineSimplifier.isConcave(Coordinate p0,
Coordinate p1,
Coordinate p2) |
private boolean |
OffsetSegmentString.isRedundant(Coordinate pt)
Tests whether the given point is redundant
relative to the previous
point in the list (up to tolerance).
|
private boolean |
BufferInputLineSimplifier.isShallow(Coordinate p0,
Coordinate p1,
Coordinate p2,
double distanceTol) |
private boolean |
BufferInputLineSimplifier.isShallowConcavity(Coordinate p0,
Coordinate p1,
Coordinate p2,
double distanceTol) |
private boolean |
BufferInputLineSimplifier.isShallowSampled(Coordinate p0,
Coordinate p2,
int i0,
int i2,
double distanceTol)
Checks for shallowness over a sample of points in the given section.
|
private boolean |
OffsetCurveSetBuilder.isTriangleErodedCompletely(Coordinate[] triangleCoord,
double bufferDistance)
Tests whether a triangular ring would be eroded completely by the given
buffer distance.
|
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list.
|
Constructor and Description |
---|
BufferInputLineSimplifier(Coordinate[] inputLine) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
BufferResultValidator.errorLocation |
private Coordinate |
BufferDistanceValidator.errorLocation |
private Coordinate[] |
PointPairDistance.pt |
Modifier and Type | Method and Description |
---|---|
Coordinate |
PointPairDistance.getCoordinate(int i) |
Coordinate[] |
PointPairDistance.getCoordinates() |
Coordinate |
BufferResultValidator.getErrorLocation() |
Coordinate |
BufferDistanceValidator.getErrorLocation() |
Modifier and Type | Method and 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) |
private void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1,
double distance)
Initializes the points, avoiding recomputing the distance.
|
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
FacetSequence.p0 |
private Coordinate |
FacetSequence.p1 |
private Coordinate |
GeometryLocation.pt |
private Coordinate |
FacetSequence.pt |
private Coordinate |
FacetSequence.q0 |
private Coordinate |
FacetSequence.q1 |
private Coordinate |
FacetSequence.seqPt |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
private double |
FacetSequence.computePointLineDistance(Coordinate pt,
FacetSequence facetSeq) |
Constructor and Description |
---|
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). |
Modifier and Type | Method and Description |
---|---|
private Coordinate |
PlanarPolygon3D.averagePoint(CoordinateSequence seq)
Computes a point which is the average of all coordinates
in a sequence.
|
Coordinate |
AxisPlaneCoordinateSequence.getCoordinate(int i) |
Coordinate |
AxisPlaneCoordinateSequence.getCoordinateCopy(int i) |
private Coordinate |
Distance3DOp.intersection(PlanarPolygon3D poly,
LineString line) |
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.
|
private static Coordinate |
PlanarPolygon3D.project(Coordinate p,
int facingPlane) |
private static Coordinate |
Distance3DOp.segmentPoint(Coordinate p0,
Coordinate p1,
double d0,
double d1)
Computes a point at a distance along a segment
specified by two relatively proportional values.
|
Coordinate[] |
AxisPlaneCoordinateSequence.toCoordinateArray() |
Modifier and Type | Method and Description |
---|---|
void |
AxisPlaneCoordinateSequence.getCoordinate(int index,
Coordinate coord) |
boolean |
PlanarPolygon3D.intersects(Coordinate intPt) |
boolean |
PlanarPolygon3D.intersects(Coordinate pt,
LineString ring) |
private int |
PlanarPolygon3D.locate(Coordinate pt,
LineString ring) |
private static Coordinate |
PlanarPolygon3D.project(Coordinate p,
int facingPlane) |
private static Coordinate |
Distance3DOp.segmentPoint(Coordinate p0,
Coordinate p1,
double d0,
double d1)
Computes a point at a distance along a segment
specified by two relatively proportional values.
|
Modifier and Type | Field and Description |
---|---|
private Coordinate[] |
EdgeString.coordinates |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
EdgeString.getCoordinates() |
Modifier and Type | Method and Description |
---|---|
private Node |
LineMergeGraph.getNode(Coordinate coordinate) |
Constructor and 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 and Description |
---|---|
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) |
private boolean |
OverlayOp.isCovered(Coordinate coord,
java.util.List geomList) |
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 | Field and Description |
---|---|
private Coordinate[] |
SnapTransformer.snapPts |
private Coordinate[] |
LineStringSnapper.srcPts |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
GeometrySnapper.extractTargetCoordinates(Geometry g) |
private Coordinate |
LineStringSnapper.findSnapForVertex(Coordinate pt,
Coordinate[] snapPts) |
private Coordinate[] |
SnapTransformer.snapLine(Coordinate[] srcPts,
Coordinate[] snapPts) |
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 and Description |
---|---|
private double |
GeometrySnapper.computeMinimumSegmentLength(Coordinate[] pts) |
private double |
GeometrySnapper.computeSnapTolerance(Coordinate[] ringPts)
Computes the snap tolerance based on the input geometries.
|
private int |
LineStringSnapper.findSegmentIndexToSnap(Coordinate snapPt,
CoordinateList srcCoords)
Finds a src segment which snaps to (is close to) the given snap point.
|
private Coordinate |
LineStringSnapper.findSnapForVertex(Coordinate pt,
Coordinate[] snapPts) |
private Coordinate |
LineStringSnapper.findSnapForVertex(Coordinate pt,
Coordinate[] snapPts) |
private static boolean |
LineStringSnapper.isClosed(Coordinate[] pts) |
private Coordinate[] |
SnapTransformer.snapLine(Coordinate[] srcPts,
Coordinate[] snapPts) |
private Coordinate[] |
SnapTransformer.snapLine(Coordinate[] srcPts,
Coordinate[] snapPts) |
private void |
LineStringSnapper.snapSegments(CoordinateList srcCoords,
Coordinate[] snapPts)
Snap segments of the source to nearby snap vertices.
|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString
to the given set of snap vertices.
|
private void |
LineStringSnapper.snapVertices(CoordinateList srcCoords,
Coordinate[] snapPts)
Snap source vertices to vertices in the target.
|
Constructor and Description |
---|
LineStringSnapper(Coordinate[] srcPts,
double snapTolerance)
Creates a new snapper using the given points
as source points to be snapped.
|
SnapTransformer(double snapTolerance,
Coordinate[] snapPts) |
SnapTransformer(double snapTolerance,
Coordinate[] snapPts,
boolean isSelfSnap) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
OverlayResultValidator.invalidLocation |
Modifier and Type | Method and Description |
---|---|
Coordinate |
OverlayResultValidator.getInvalidLocation() |
Modifier and Type | Method and Description |
---|---|
private boolean |
OverlayResultValidator.checkValid(int overlayOp,
Coordinate pt) |
private void |
OffsetPointGenerator.computeOffsetPoints(Coordinate p0,
Coordinate p1,
double offsetDistance,
java.util.List offsetPts)
Generates the two points which are offset from the
midpoint of the segment (p0, p1) by the
offsetDistance.
|
int |
FuzzyPointLocator.getLocation(Coordinate pt) |
private boolean |
FuzzyPointLocator.isWithinToleranceOfBoundary(Coordinate pt) |
Modifier and Type | Field and Description |
---|---|
private Coordinate[] |
EdgeRing.ringPts |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
EdgeRing.getCoordinates()
Computes the list of coordinates which are contained in this ring.
|
static Coordinate |
EdgeRing.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Deprecated.
Use CoordinateArrays.ptNotInList instead
|
Modifier and Type | Method and Description |
---|---|
private static void |
EdgeRing.addEdge(Coordinate[] coords,
boolean isForward,
CoordinateList coordList) |
private Node |
PolygonizeGraph.getNode(Coordinate pt) |
static boolean |
EdgeRing.isInList(Coordinate pt,
Coordinate[] pts)
Deprecated.
|
static boolean |
EdgeRing.isInList(Coordinate pt,
Coordinate[] pts)
Deprecated.
|
static Coordinate |
EdgeRing.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Deprecated.
Use CoordinateArrays.ptNotInList instead
|
static Coordinate |
EdgeRing.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Deprecated.
Use CoordinateArrays.ptNotInList instead
|
Constructor and Description |
---|
PolygonizeDirectedEdge(Node from,
Node to,
Coordinate directionPt,
boolean edgeDirection)
Constructs a directed edge connecting the
from node to the
to node. |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
RectangleIntersectsSegmentVisitor.p0 |
private Coordinate |
RectangleIntersectsSegmentVisitor.p1 |
Modifier and Type | Method and Description |
---|---|
private boolean |
RectangleContains.isLineSegmentContainedInBoundary(Coordinate p0,
Coordinate p1)
Tests if a line segment is contained in the boundary of the target rectangle.
|
private boolean |
RectangleContains.isPointContainedInBoundary(Coordinate pt)
Tests if a point is contained in the boundary of the target rectangle.
|
Modifier and Type | Field and Description |
---|---|
private Coordinate |
RelateComputer.invalidPoint |
Modifier and Type | Method and Description |
---|---|
Node |
RelateNodeFactory.createNode(Coordinate coord) |
Constructor and Description |
---|
RelateNode(Coordinate coord,
EdgeEndStar edges) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
ConnectedInteriorTester.disconnectedRingcoord |
private Coordinate |
ConsistentAreaTester.invalidPoint |
private Coordinate |
IndexedNestedRingTester.nestedPt |
private Coordinate |
TopologyValidationError.pt |
private Coordinate |
RepeatedPointTester.repeatedCoord |
Modifier and Type | Method and Description |
---|---|
private Coordinate |
IsValidOp.checkShellInsideHole(LinearRing shell,
LinearRing hole,
GeometryGraph graph)
This routine checks to see if a shell is properly contained in a hole.
|
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 |
IndexedNestedRingTester.getNestedPoint() |
Modifier and Type | Method and Description |
---|---|
private void |
IsValidOp.checkInvalidCoordinates(Coordinate[] coords) |
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.
|
Constructor and Description |
---|
TopologyValidationError(int errorType,
Coordinate pt)
Creates a validation error with the given type and location
|
Modifier and Type | Field and Description |
---|---|
protected Coordinate |
DirectedEdge.p0 |
protected Coordinate |
DirectedEdge.p1 |
protected Coordinate |
Node.pt
The location of this Node
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
Node.getCoordinate()
Returns the location of this Node.
|
Coordinate |
DirectedEdgeStar.getCoordinate()
Returns the coordinate for the node at which 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.
|
Modifier and Type | Method and 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 and 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 | Field and Description |
---|---|
private Coordinate |
CommonBitsRemover.commonCoord |
private Coordinate[] |
SimpleMinimumClearance.minClearancePts |
private Coordinate[] |
MinimumClearance.minClearancePts |
private Coordinate[] |
MinimumClearance.MinClearanceDistance.minPts |
private Coordinate |
SimpleMinimumClearance.ComputeMCCoordinateSequenceFilter.queryPt |
(package private) Coordinate |
CommonBitsRemover.Translater.trans |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
SimpleGeometryPrecisionReducer.PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
Coordinate |
CommonBitsRemover.getCommonCoordinate()
The common bits of the Coordinates in the supplied Geometries.
|
Coordinate |
CommonBitsRemover.CommonCoordinateFilter.getCommonCoordinate() |
Coordinate[] |
MinimumClearance.MinClearanceDistance.getCoordinates() |
Modifier and Type | Method and Description |
---|---|
private void |
SimpleMinimumClearance.ComputeMCCoordinateSequenceFilter.checkSegmentDistance(Coordinate seg0,
Coordinate seg1) |
private void |
SimpleMinimumClearance.ComputeMCCoordinateSequenceFilter.checkVertexDistance(Coordinate vertex) |
Coordinate[] |
SimpleGeometryPrecisionReducer.PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
void |
SimpleMinimumClearance.VertexCoordinateFilter.filter(Coordinate coord) |
void |
CommonBitsRemover.CommonCoordinateFilter.filter(Coordinate coord) |
private void |
SimpleMinimumClearance.updateClearance(double candidateValue,
Coordinate p0,
Coordinate p1) |
private void |
SimpleMinimumClearance.updateClearance(double candidateValue,
Coordinate p,
Coordinate seg0,
Coordinate seg1) |
private void |
MinimumClearance.MinClearanceDistance.updatePts(Coordinate p,
Coordinate seg0,
Coordinate seg1) |
Constructor and Description |
---|
ComputeMCCoordinateSequenceFilter(SimpleMinimumClearance smc,
Coordinate queryPt) |
Translater(Coordinate trans) |
Modifier and Type | Method and Description |
---|---|
protected Coordinate |
GeometricShapeBuilder.createCoord(double x,
double y) |
Coordinate |
GeometricShapeBuilder.getCentre() |
Modifier and Type | Method and Description |
---|---|
private Coordinate[] |
KochSnowflakeBuilder.getBoundary(int level,
Coordinate origin,
double width) |
Modifier and Type | Method and Description |
---|---|
private void |
KochSnowflakeBuilder.addSegment(Coordinate p0,
Coordinate p1) |
void |
KochSnowflakeBuilder.addSide(int level,
Coordinate p0,
Coordinate p1) |
private Coordinate[] |
KochSnowflakeBuilder.getBoundary(int level,
Coordinate origin,
double width) |
Modifier and Type | Method and Description |
---|---|
protected Coordinate |
RandomPointsBuilder.createCoord(double x,
double y) |
protected Coordinate |
RandomPointsBuilder.createRandomCoord(Envelope env) |
private Coordinate |
RandomPointsInGridBuilder.randomPointInCell(double orgX,
double orgY,
double xLen,
double yLen) |
private static Coordinate |
RandomPointsInGridBuilder.randomPointInCircle(double orgX,
double orgY,
double width,
double height) |
private Coordinate |
RandomPointsInGridBuilder.randomPointInGridCell(double orgX,
double orgY,
double xLen,
double yLen) |
Modifier and Type | Method and Description |
---|---|
protected boolean |
RandomPointsBuilder.isInExtent(Coordinate p) |
Modifier and Type | Field and Description |
---|---|
private Coordinate[] |
TaggedLineStringSimplifier.linePts |
private Coordinate |
VWLineSimplifier.VWVertex.pt |
private Coordinate[] |
VWLineSimplifier.pts |
private Coordinate[] |
DouglasPeuckerLineSimplifier.pts |
Modifier and Type | Method and Description |
---|---|
private static Coordinate[] |
TaggedLineString.extractCoordinates(java.util.List segs) |
Coordinate[] |
VWLineSimplifier.VWVertex.getCoordinates() |
Coordinate[] |
TaggedLineString.getParentCoordinates() |
Coordinate[] |
TaggedLineString.getResultCoordinates() |
Coordinate[] |
VWLineSimplifier.simplify() |
Coordinate[] |
DouglasPeuckerLineSimplifier.simplify() |
static Coordinate[] |
VWLineSimplifier.simplify(Coordinate[] pts,
double distanceTolerance) |
static Coordinate[] |
DouglasPeuckerLineSimplifier.simplify(Coordinate[] pts,
double distanceTolerance) |
Modifier and Type | Method and Description |
---|---|
static VWLineSimplifier.VWVertex |
VWLineSimplifier.VWVertex.buildLine(Coordinate[] pts) |
private int |
TaggedLineStringSimplifier.findFurthestPoint(Coordinate[] pts,
int i,
int j,
double[] maxDistance) |
static Coordinate[] |
VWLineSimplifier.simplify(Coordinate[] pts,
double distanceTolerance) |
static Coordinate[] |
DouglasPeuckerLineSimplifier.simplify(Coordinate[] pts,
double distanceTolerance) |
Constructor and Description |
---|
DouglasPeuckerLineSimplifier(Coordinate[] pts) |
TaggedLineSegment(Coordinate p0,
Coordinate p1) |
TaggedLineSegment(Coordinate p0,
Coordinate p1,
Geometry parent,
int index) |
VWLineSimplifier(Coordinate[] pts,
double distanceTolerance) |
VWVertex(Coordinate pt) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
ConstraintEnforcementException.pt |
private Coordinate |
SplitSegment.splitPt |
private Coordinate |
ConformingDelaunayTriangulator.splitPt |
Modifier and Type | Method and Description |
---|---|
private Coordinate |
ConformingDelaunayTriangulator.findNonGabrielPoint(Segment seg)
Given a set of points stored in the kd-tree and a line segment defined by
two points in this set, finds a
Coordinate in the circumcircle of
the line segment, if one exists. |
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
|
private Coordinate[] |
ConformingDelaunayTriangulator.getPointArray() |
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.
|
private static Coordinate |
SplitSegment.pointAlongReverse(LineSegment seg,
double segmentLengthFraction)
Computes the
Coordinate that lies a given fraction along the line defined by the
reverse of the given segment. |
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 and Description |
---|---|
private ConstraintVertex |
ConformingDelaunayTriangulator.createVertex(Coordinate p) |
ConstraintVertex |
ConstraintVertexFactory.createVertex(Coordinate p,
Segment constraintSeg) |
private ConstraintVertex |
ConformingDelaunayTriangulator.createVertex(Coordinate p,
Segment seg)
Creates a vertex on a constraint 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 |
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.
|
private void |
VertexTaggedGeometryDataMapper.loadVertices(Coordinate[] pts,
java.lang.Object data) |
private static java.lang.String |
ConstraintEnforcementException.msgWithCoord(java.lang.String msg,
Coordinate pt) |
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) |
Constructor and 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 | Field and Description |
---|---|
private Coordinate |
Vertex.p |
Modifier and Type | Method and Description |
---|---|
Coordinate |
Vertex.getCoordinate() |
Coordinate |
QuadEdgeTriangle.getCoordinate(int i) |
Coordinate[] |
QuadEdgeTriangle.getCoordinates() |
Modifier and Type | Method and Description |
---|---|
private static void |
TrianglePredicate.checkRobustInCircle(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Checks if the computed value for isInCircle is correct, using
double-double precision arithmetic.
|
private void |
QuadEdgeSubdivision.TriangleCoordinatesVisitor.checkTriangleSize(Coordinate[] pts) |
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.
|
private static double |
TrianglePredicate.triArea(Coordinate a,
Coordinate b,
Coordinate c)
Computes twice the area of the oriented triangle (a, b, c), i.e., the area is positive if the
triangle is oriented counterclockwise.
|
static DD |
TrianglePredicate.triAreaDDFast(Coordinate a,
Coordinate b,
Coordinate c) |
Constructor and Description |
---|
Vertex(Coordinate _p) |
Modifier and Type | Field and Description |
---|---|
Coordinate |
GeometricShapeFactory.Dimensions.base |
Coordinate |
GeometricShapeFactory.Dimensions.centre |
private Coordinate |
Debug.SegmentFindingFilter.p0 |
private Coordinate |
Debug.SegmentFindingFilter.p1 |
(package private) Coordinate[] |
CoordinateArrayFilter.pts |
Modifier and Type | Method and Description |
---|---|
protected Coordinate |
GeometricShapeFactory.coord(double x,
double y) |
protected Coordinate |
GeometricShapeFactory.coordTrans(double x,
double y,
Coordinate trans) |
static Coordinate[] |
UniqueCoordinateArrayFilter.filterCoordinates(Coordinate[] coords)
Convenience method which allows running the filter over an array of
Coordinate s. |
Coordinate |
GeometricShapeFactory.Dimensions.getBase() |
Coordinate |
GeometricShapeFactory.Dimensions.getCentre() |
Coordinate[] |
UniqueCoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinate s. |
Coordinate[] |
CoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinate s. |
Modifier and Type | Method and Description |
---|---|
static void |
Debug.breakIfEqual(Coordinate p0,
Coordinate p1,
double tolerance) |
protected Coordinate |
GeometricShapeFactory.coordTrans(double x,
double y,
Coordinate trans) |
static boolean |
Debug.equals(Coordinate c1,
Coordinate c2,
double tolerance) |
void |
UniqueCoordinateArrayFilter.filter(Coordinate coord) |
void |
CoordinateCountFilter.filter(Coordinate coord) |
void |
CoordinateArrayFilter.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.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) |
Constructor and Description |
---|
SegmentFindingFilter(Coordinate p0,
Coordinate p1) |
Modifier and Type | Class and Description |
---|---|
class |
ExtendedCoordinate |
Modifier and Type | Method and Description |
---|---|
Coordinate |
ExtendedCoordinateSequence.getCoordinate(int i) |
Coordinate |
ExtendedCoordinateSequence.getCoordinateCopy(int index) |
Coordinate[] |
ExtendedCoordinateSequence.toCoordinateArray() |
Modifier and Type | Method and Description |
---|---|
static ExtendedCoordinate[] |
ExtendedCoordinateSequence.copy(Coordinate[] coordinates) |
CoordinateSequence |
ExtendedCoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns an ExtendedCoordinateSequence based on the given array -- the array is used
directly if it is an instance of ExtendedCoordinate[]; otherwise it is
copied.
|
void |
ExtendedCoordinateSequence.getCoordinate(int index,
Coordinate coord) |
Constructor and Description |
---|
ExtendedCoordinate(Coordinate coord) |
ExtendedCoordinateSequence(Coordinate[] copyCoords)
Constructor that makes a copy of an array of Coordinates.
|
Modifier and Type | Method and Description |
---|---|
(package private) static Geometry |
SearchUsingPreparedGeometryIndex.createCircle(Coordinate centre,
double radius) |
Modifier and Type | Method and Description |
---|---|
static Coordinate[] |
CleanDuplicatePoints.removeDuplicatePoints(Coordinate[] coord) |
Modifier and Type | Method and Description |
---|---|
static Coordinate[] |
CleanDuplicatePoints.removeDuplicatePoints(Coordinate[] coord) |
Modifier and Type | Method and Description |
---|---|
private static Coordinate |
AffineTransformationFunctions.envelopeCentre(Geometry g) |
private static Coordinate |
AffineTransformationFunctions.envelopeLowerLeft(Geometry g) |
(package private) static Coordinate[] |
OrientationFunctions.getRing(Geometry g) |
private static Coordinate |
CreateRandomShapeFunctions.randomPointInTriangle(Coordinate p0,
Coordinate p1,
Coordinate p2) |
private static Coordinate |
CreateRandomShapeFunctions.randomPtInRectangleAround(Coordinate centre,
double width,
double height) |
private static Coordinate[] |
TriangleFunctions.trianglePts(Geometry g) |
Modifier and Type | Method and Description |
---|---|
private static Coordinate |
CreateRandomShapeFunctions.randomPointInTriangle(Coordinate p0,
Coordinate p1,
Coordinate p2) |
private static Coordinate |
CreateRandomShapeFunctions.randomPtInRectangleAround(Coordinate centre,
double width,
double height) |
Modifier and Type | Method and Description |
---|---|
private void |
BufferValidatedGeometryOperation.reportError(java.lang.String msg,
Coordinate loc) |
Modifier and Type | Field and Description |
---|---|
(package private) Coordinate |
GeometryPopupMenu.clickCoord |
(package private) Coordinate |
CoordinateNode.coord |
private Coordinate |
ValidPanel.markPoint |
(package private) Coordinate |
GeometryEditPanel.markPoint |
Modifier and Type | Method and Description |
---|---|
Coordinate |
ValidPanel.getMarkPoint() |
(package private) Coordinate |
ValidPanel.parseXY(java.lang.String xyStr) |
private Coordinate |
JTSTestBuilderFrame.pickOffset(Geometry a,
Geometry b) |
Modifier and Type | Method and Description |
---|---|
static CoordinateNode |
CoordinateNode.create(Coordinate p) |
static CoordinateNode |
CoordinateNode.create(Coordinate p,
int i,
double distPrev) |
void |
JTSTestBuilderFrame.displayInfo(Coordinate modelPt) |
private void |
GeometryEditPanel.drawHighlightedVertex(java.awt.Graphics2D g,
Coordinate pt,
java.awt.Color clr) |
private void |
GeometryEditPanel.drawVertexShadow(java.awt.Graphics2D g,
Coordinate pt,
java.awt.Color clr) |
java.lang.String |
GeometryEditPanel.getInfo(Coordinate pt) |
private static java.lang.String |
CoordinateNode.label(Coordinate coord,
int i,
double distPrev) |
private void |
LineStringNode.populateChildren(Coordinate[] pt) |
void |
GeometryEditPanel.setHighlightPoint(Coordinate pt) |
private void |
ValidPanel.setMarkPoint(Coordinate coord) |
Constructor and Description |
---|
CoordinateNode(Coordinate coord) |
CoordinateNode(Coordinate coord,
int i,
double distPrev) |
Modifier and Type | Method and Description |
---|---|
static void |
JTSTestBuilderController.copyComponentToClipboard(Coordinate pt) |
static void |
JTSTestBuilderController.extractComponentsToTestCase(Coordinate pt) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
VertexLocater.NearestVertexFilter.basePt |
private Coordinate |
NearestPointFinder.NearestPointFilter.basePt |
private Coordinate |
AdjacentVertexFinder.AdjacentVertexFilter.basePt |
private Coordinate |
GeometryVertexMover.MoveVertexOperation.fromLoc |
private Coordinate |
GeometryPointLocater.locationPt |
private Coordinate |
VertexLocater.NearestVertexFilter.nearestPt |
private Coordinate |
NearestPointFinder.NearestPointFilter.nearestPt |
private Coordinate |
GeometryPointLocater.NearestSegmentLocationFilter.nearestPt |
private Coordinate |
GeometryVertexInserter.InsertVertexOperation.newVertex |
private Coordinate |
GeometryVertexDeleter.DeleteVertexOperation.newVertex |
private Coordinate |
VertexLocater.Location.pt |
private Coordinate |
GeometryLocation.pt
The actual coordinate for the location
|
private Coordinate |
VertexLocater.NearVerticesFilter.queryPt |
private Coordinate |
FacetLocater.queryPt |
private Coordinate |
GeometryPointLocater.NearestSegmentLocationFilter.testPt |
private Coordinate |
GeometryVertexMover.MoveVertexOperation.toLoc |
private Coordinate |
VertexLocater.vertexPt |
private Coordinate |
AdjacentVertexFinder.vertexPt |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
GeometryVertexMover.MoveVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
Coordinate[] |
GeometryVertexInserter.InsertVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
Coordinate[] |
GeometryVertexDeleter.DeleteVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
Coordinate[] |
GeometryBoxDeleter.BoxDeleteVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
static Coordinate |
NearestPointFinder.findNearestPoint(Geometry geom,
Coordinate pt,
double tolerance) |
static Coordinate[] |
AdjacentVertexFinder.findVertices(Geometry geom,
Coordinate testPt) |
Coordinate |
VertexLocater.Location.getCoordinate() |
Coordinate |
GeometryPointLocater.NearestSegmentLocationFilter.getCoordinate() |
Coordinate |
GeometryLocation.getCoordinate() |
Coordinate |
NearestPointFinder.NearestPointFilter.getNearestPoint() |
Coordinate |
NearestPointFinder.getNearestPoint(Coordinate pt,
double tolerance) |
Coordinate |
VertexLocater.NearestVertexFilter.getVertex() |
Coordinate |
VertexLocater.getVertex(Coordinate testPt,
double tolerance) |
Coordinate[] |
AdjacentVertexFinder.AdjacentVertexFilter.getVertices() |
Coordinate[] |
AdjacentVertexFinder.getVertices(Coordinate testPt) |
static Coordinate |
VertexLocater.locateVertex(Geometry geom,
Coordinate testPt,
double tolerance) |
Modifier and Type | Method and Description |
---|---|
Geometry |
GeometryCombiner.addLineString(Geometry orig,
Coordinate[] pts) |
Geometry |
GeometryCombiner.addPoint(Geometry orig,
Coordinate pt) |
Geometry |
GeometryCombiner.addPolygonRing(Geometry orig,
Coordinate[] pts) |
private Geometry |
ComponentLocater.createAOI(Coordinate queryPt,
double tolerance) |
Coordinate[] |
GeometryVertexMover.MoveVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
Coordinate[] |
GeometryVertexInserter.InsertVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
Coordinate[] |
GeometryVertexDeleter.DeleteVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
Coordinate[] |
GeometryBoxDeleter.BoxDeleteVertexOperation.edit(Coordinate[] coords,
Geometry geometry) |
static Coordinate |
NearestPointFinder.findNearestPoint(Geometry geom,
Coordinate pt,
double tolerance) |
private static Polygon |
GeometryCombiner.findPolygonContaining(Geometry geom,
Coordinate pt) |
static Coordinate[] |
AdjacentVertexFinder.findVertices(Geometry geom,
Coordinate testPt) |
java.util.List |
ComponentLocater.getComponents(Coordinate queryPt,
double tolerance) |
GeometryLocation |
GeometryPointLocater.getLocation(Coordinate testPt,
boolean vertexOnly,
double tolerance) |
java.util.List |
VertexLocater.getLocations(Coordinate testPt,
double tolerance) |
java.util.List |
FacetLocater.getLocations(Coordinate queryPt,
double tolerance) |
Coordinate |
NearestPointFinder.getNearestPoint(Coordinate pt,
double tolerance) |
Coordinate |
VertexLocater.getVertex(Coordinate testPt,
double tolerance) |
Coordinate[] |
AdjacentVertexFinder.getVertices(Coordinate testPt) |
private boolean |
GeometryBoxDeleter.BoxDeleteVertexOperation.hasVertexInBox(Coordinate[] coords) |
static Geometry |
GeometryVertexInserter.insert(Geometry geom,
LineString line,
int segIndex,
Coordinate newVertex) |
static GeometryLocation |
GeometryPointLocater.locateNonVertexPoint(Geometry geom,
Coordinate testPt,
double tolerance) |
static Coordinate |
VertexLocater.locateVertex(Geometry geom,
Coordinate testPt,
double tolerance) |
static GeometryLocation |
GeometryPointLocater.locateVertex(Geometry geom,
Coordinate testPt,
double tolerance) |
static Geometry |
GeometryVertexMover.move(Geometry geom,
Coordinate fromLoc,
Coordinate toLoc) |
Constructor and Description |
---|
AdjacentVertexFilter(Coordinate basePt) |
GeometryLocation(Geometry parent,
Geometry component,
int[] componentPath,
int segmentIndex,
boolean isVertex,
Coordinate pt) |
GeometryLocation(Geometry parent,
Geometry component,
int segmentIndex,
boolean isVertex,
Coordinate pt) |
GeometryLocation(Geometry parent,
Geometry component,
int index,
Coordinate pt) |
InsertVertexOperation(LineString line,
int segIndex,
Coordinate newVertex) |
Location(Coordinate pt,
int index) |
MoveVertexOperation(Coordinate fromLoc,
Coordinate toLoc) |
NearestPointFilter(Coordinate basePt,
double tolerance) |
NearestSegmentLocationFilter(Coordinate testPt,
boolean vertexOnly,
double tolerance) |
NearestVertexFilter(Coordinate basePt,
double tolerance) |
NearVerticesFilter(Coordinate queryPt,
double tolerance) |
Modifier and Type | Method and Description |
---|---|
(package private) boolean |
PolygonHandler.pointInList(Coordinate testPoint,
Coordinate[] pointList) |
(package private) boolean |
PolygonHandler.pointInList(Coordinate testPoint,
Coordinate[] pointList) |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
GeometryEditModel.findAdjacentVertices(Coordinate vertex) |
private static Coordinate[] |
GeometryEditModel.getRing(java.util.List coordList) |
Coordinate |
GeometryEditModel.locateVertexPt(Coordinate testPt,
double tolerance) |
Modifier and Type | Method and Description |
---|---|
Coordinate[] |
GeometryEditModel.findAdjacentVertices(Coordinate vertex) |
Geometry |
LayerList.getComponent(Coordinate pt,
double tolerance) |
GeometryLocation |
GeometryEditModel.locateNonVertexPoint(Coordinate testPt,
double tolerance)
Locates a non-vertex point on a line segment of the current geometry
within the given tolerance, if any.
|
GeometryLocation |
GeometryEditModel.locateVertex(Coordinate testPt,
double tolerance)
Locates a vertex of the current geometry
within the given tolerance, if any.
|
Coordinate |
GeometryEditModel.locateVertexPt(Coordinate testPt,
double tolerance) |
void |
GeometryEditModel.moveVertex(Coordinate fromLoc,
Coordinate toLoc) |
Modifier and Type | Field and Description |
---|---|
private Coordinate |
StretchedVertex.nearPt |
private Coordinate[] |
StretchedVertex.nearPts |
private Coordinate[] |
StretchedVertex.parentLine |
private Coordinate |
StretchedVertex.stretchedPt |
private Coordinate |
StretchedVertex.vertexPt |
Modifier and Type | Method and Description |
---|---|
private Coordinate |
StretchedVertex.displaceFromCorner(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist) |
private Coordinate |
StretchedVertex.displaceFromCornerAwayFromArms(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist)
Displaces a vertex from a corner,
with angle limiting
used to ensure that the displacement is not close to the arms of the corner.
|
private Coordinate |
StretchedVertex.displaceFromCornerOriginal(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist) |
private Coordinate |
StretchedVertex.displaceFromFlatCorner(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist) |
private Coordinate |
StretchedVertex.displaceFromPoint(Coordinate nearPt,
double dist) |
private Coordinate |
StretchedVertex.displaceFromSeg(LineSegment nearSeg,
double dist) |
private Coordinate |
StretchedVertex.displaceFromVertex(Coordinate nearPt,
double dist) |
Coordinate[] |
GeometryVerticesMover.MoveVerticesOperation.edit(Coordinate[] coords,
Geometry geometry) |
private Coordinate |
StretchedVertex.getNearRingPoint(int i) |
Coordinate |
StretchedVertex.getStretchedVertex(double dist)
Gets the point which this near vertex will be stretched to
(by a given distance)
|
Coordinate |
StretchedVertex.getVertexCoordinate() |
private Coordinate |
GeometryVerticesMover.MoveVerticesOperation.movedPt(Coordinate orig) |
private static Coordinate[] |
StretchedVertex.orientCorner(Coordinate p0,
Coordinate p1,
Coordinate p2)
Returns an array of pts such that p0 - p[0] - [p1] is CW.
|
private static Coordinate |
StretchedVertex.rotateToQuadrant(Coordinate v,
int quadrant) |
Modifier and Type | Method and Description |
---|---|
private static boolean |
StretchedVertexFinder.contains(Envelope env,
Coordinate p0,
Coordinate p1) |
private Coordinate |
StretchedVertex.displaceFromCorner(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist) |
private Coordinate |
StretchedVertex.displaceFromCornerAwayFromArms(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist)
Displaces a vertex from a corner,
with angle limiting
used to ensure that the displacement is not close to the arms of the corner.
|
private Coordinate |
StretchedVertex.displaceFromCornerOriginal(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist) |
private Coordinate |
StretchedVertex.displaceFromFlatCorner(Coordinate nearPt,
Coordinate p1,
Coordinate p2,
double dist) |
private Coordinate |
StretchedVertex.displaceFromPoint(Coordinate nearPt,
double dist) |
private Coordinate |
StretchedVertex.displaceFromVertex(Coordinate nearPt,
double dist) |
private static double |
StretchedVertexFinder.distanceToSeg(Coordinate p,
Coordinate p0,
Coordinate p1) |
Coordinate[] |
GeometryVerticesMover.MoveVerticesOperation.edit(Coordinate[] coords,
Geometry geometry) |
void |
TopologyStretcher.VertexInMaskCountCoordinateFilter.filter(Coordinate coord) |
private void |
StretchedVertexFinder.findNearVertex(Coordinate[] linePts,
int index) |
private void |
StretchedVertexFinder.findNearVertex(Coordinate[] targetPts,
int index,
LineString testLine)
Finds a single near vertex.
|
private static int |
StretchedVertexFinder.geomPointsLen(Coordinate[] pts) |
private static boolean |
StretchedVertex.isFlat(Coordinate p,
Coordinate p1,
Coordinate p2) |
private boolean |
StretchedVertex.isInsideCorner(Coordinate queryPt,
Coordinate base,
Coordinate p1,
Coordinate p2) |
private static boolean |
StretchedVertexFinder.isPointNearButNotOnSeg(Coordinate p,
Coordinate p0,
Coordinate p1,
double distTol) |
private Coordinate |
GeometryVerticesMover.MoveVerticesOperation.movedPt(Coordinate orig) |
private static Vector2D |
StretchedVertex.normalizedOffset(Coordinate p0,
Coordinate p1,
Coordinate p2)
Returns an array of pts such that p0 - p[0] - [p1] is CW.
|
private static Coordinate[] |
StretchedVertex.orientCorner(Coordinate p0,
Coordinate p1,
Coordinate p2)
Returns an array of pts such that p0 - p[0] - [p1] is CW.
|
private static int |
StretchedVertex.quadrant(Coordinate pt,
Coordinate cornerBase,
Coordinate[] corner) |
private static int |
StretchedVertex.quadrant(Coordinate pt,
Coordinate cornerBase,
Coordinate[] corner) |
private static Coordinate |
StretchedVertex.rotateToQuadrant(Coordinate v,
int quadrant) |
Constructor and Description |
---|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
Coordinate nearPt,
Coordinate[] nearPts,
int nearIndex)
Creates a vertex which lies near a vertex
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
Coordinate nearPt,
Coordinate[] nearPts,
int nearIndex)
Creates a vertex which lies near a vertex
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
Coordinate nearPt,
Coordinate[] nearPts,
int nearIndex)
Creates a vertex which lies near a vertex
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
LineSegment nearSeg)
Creates a vertex for a point which lies near a line segment
|
StretchedVertex(Coordinate vertexPt,
Coordinate[] parentLine,
int parentIndex,
LineSegment nearSeg)
Creates a vertex for a point which lies near a line segment
|
Modifier and Type | Method and Description |
---|---|
Coordinate |
Viewport.toModelCoordinate(java.awt.geom.Point2D viewPt) |
Modifier and Type | Method and Description |
---|---|
boolean |
Viewport.containsInModel(Coordinate p) |
java.lang.String |
GeometryLocationsWriter.OLDwriteLocation(Geometry geom,
Coordinate p,
double tolerance) |
java.awt.geom.Point2D |
Viewport.toView(Coordinate modelCoordinate) |
void |
Viewport.transform(Coordinate modelCoordinate,
java.awt.geom.Point2D point) |
java.lang.String |
GeometryLocationsWriter.writeComponentLocation(Geometry geom,
Coordinate p,
double tolerance) |
java.lang.String |
GeometryLocationsWriter.writeFacetLocation(Geometry geom,
Coordinate p,
double tolerance) |
java.lang.String |
GeometryLocationsWriter.writeLocation(Layer lyr,
Coordinate p,
double tolerance) |
static java.lang.String |
GeometryLocationsWriter.writeLocation(LayerList layers,
Coordinate pt,
double tolerance) |
java.lang.String |
GeometryLocationsWriter.writeLocationString(LayerList layers,
Coordinate pt,
double tolerance) |
java.lang.String |
GeometryLocationsWriter.writeSingleLocation(Layer lyr,
Coordinate p,
double tolerance) |
Modifier and Type | Field and Description |
---|---|
private static Coordinate |
GridRenderer.MODEL_ORIGIN |
Modifier and Type | Method and Description |
---|---|
private void |
LineStringEndpointStyle.paint(Coordinate terminal,
Coordinate next,
Viewport viewport,
java.awt.Graphics2D graphics) |
protected void |
SegmentStyle.paint(int index,
Coordinate p0,
Coordinate p1,
int lineType,
Viewport viewport,
java.awt.Graphics2D g) |
Modifier and Type | Field and Description |
---|---|
private Coordinate[] |
EditVertexTool.adjVertices |
(package private) Coordinate |
EditVertexTool.currentVertexLoc |
private Coordinate |
EditVertexTool.selectedVertexLocation |
protected Coordinate |
LineBandTool.tentativeCoordinate |
Modifier and Type | Method and Description |
---|---|
Coordinate |
LineBandTool.lastCoordinate() |
protected Coordinate[] |
LineBandTool.toArray(java.util.List coordinates) |
(package private) Coordinate |
BasicTool.toModelCoordinate(java.awt.Point viewPt) |
protected Coordinate |
BasicTool.toModelSnapped(java.awt.geom.Point2D p) |
protected Coordinate |
BasicTool.toModelSnappedIfCloseToViewGrid(java.awt.geom.Point2D p) |
protected Coordinate |
BasicTool.toModelSnappedToViewGrid(java.awt.geom.Point2D p) |
Modifier and Type | Method and Description |
---|---|
protected void |
LineBandTool.add(Coordinate c) |
(package private) java.awt.geom.Point2D |
BasicTool.toView(Coordinate modePt) |
Modifier and Type | Method and Description |
---|---|
private void |
SVGWriter.appendCoordinate(Coordinate coordinate,
java.io.Writer writer)
Converts a
Coordinate to <Point> format,
then appends it to the writer. |
private void |
SVGWriter.appendPoint(Coordinate coordinate,
int level,
java.io.Writer writer,
PrecisionModel precisionModel)
Converts a
Coordinate to <Point Text> format, then
appends it to the writer. |
private void |
SVGWriter.appendPointTaggedText(Coordinate coordinate,
int level,
java.io.Writer writer,
PrecisionModel precisionModel)
Converts a
Coordinate to <Point Tagged Text> format,
then appends it to the writer. |