-
+
NormalizePositive(0.0) 0.0
+ NormalizePositive(-PI)
+ NormalizePositive(-2PI) 0.0
+ NormalizePositive(-3PI)
+ NormalizePositive(-4PI) 0.0
+ NormalizePositive(PI)
+ NormalizePositive(2PI) 0.0
+ NormalizePositive(3PI)
+ NormalizePositive(4PI) 0.0
+
-
+
The angles are assumed to be normalized to the range [-Pi, Pi].
+ The result will be in the range [0, Pi].
+
-
+
> 0 +The ring is oriented clockwise (CW)
+ < 0 +The ring is oriented counter clockwise (CCW)
+ == 0 +The ring is degenerate or flat
+
Algorithm
+-
+
Dimension 2 - the centroid ic computed + as a weighted sum of the centroids + of a decomposition of the area into (possibly overlapping) triangles. + Holes and multipolygons are handled correctly. + See http://www.faqs.org/faqs/graphics/algorithms-faq/ + for further details of the basic approach.
+ Dimension 1 - Computes the average of the midpoints + of all line segments weighted by the segment length. + Zero-length lines are treated as points. +
+ Dimension 0 - Compute the average coordinate over all points. + Repeated points are all included in the average +
+
-
+
1 if q is counter-clockwise (left) from p1-p2
+ -1 if q is clockwise (right) from p1-p2
+ 0 if q is collinear with p1-p2
-
+
1 if q is counter-clockwise (left) from p1-p2
+ -1 if q is clockwise (right) from p1-p2
+ 0 if q is collinear with p1-p2
-
+
-1 if the determinant is negative,
+ 1 if the determinant is positive,
+ 0 if the determinant is 0.
+
-
+
The orientation index if it can be computed safely
+ > 1 if the orientation index cannot be computed safely >
+
Future Enhancements
+-
+
Support polygons as obstacles
+ Support a client-defined boundary polygon
+
Future Enhancements
+-
+
Support a polygonal constraint on placement of center
+
+ Note: Unfortunately not as fast as expected. +
+ for all geometries a, b: DHD(a, b) <= HD(a, b)
+
+ The approximation can be made as close as needed by densifying the input geometries.
+ In the limit, this value will approach the true Hausdorff distance:
+
+ DHD(A, B, densifyFactor) -> HD(A, B) as densifyFactor -> 0.0
+
+ The default approximation is exact or close enough for a large subset of useful cases.
+ -
+
+ computing distance between Linestring s that are roughly parallel to each other, + and roughly equal in length. This occurs in matching linear networks. +
+ Testing similarity of geometries.
+
+ A = LINESTRING (0 0, 100 0, 10 100, 10 100)
+ B = LINESTRING (0 100, 0 10, 80 10)
+
+ DHD(A, B) = 22.360679774997898
+ HD(A, B) ~= 47.8
+
+ -
+
Maximum Edge Length Ratio the length of the longest edge of the hull is no larger + than this value.
+ Maximum Edge Length Factor determine the Maximum Edge Length + as a fraction of the difference between the longest and shortest edge lengths + in the Delaunay Triangulation. + This normalizes the Maximum Edge Length to be scale-free. + A value of 1 produces the convex hull; a value of 0 produces maximum concaveness.
+
-
+
The value 0.0 produces the concave hull of smallest area + that is still connected.
+ Larger values produce less concave results. + A value equal or greater than the longest Delaunay Triangulation edge length + produces the convex hull.
+
-
+
The value 0.0 produces a concave hull of minimum area + that is still connected.
+ The value 1.0 produces the convex hull.
+
+ This avoids the risk of disconnecting the result polygon. + The list is sorted in decreasing order of edge length. +
+ NOTE: this is a relatively slow operation. +
+ Assumption: there are at least 2 tris, they are connected, + and there are no holes. + So each tri has at least one non-border edge, and there is only one border. +
Algorithm
+ The point is chosen to be "close to the center" of the geometry. + The location depends on the dimension of the input: +-
+
Dimension 2 the interior point is constructed in the middle of the longest interior segment + of a line bisecting the area.
+ Dimension 1 the interior point is the interior or boundary vertex closest to the centroid.
+ Dimension 0 the point is the point closest to the centroid.
+
Algorithm:
+ For each input polygon: +-
+
+ Determine a horizontal scan line on which the interior + point will be located. + To increase the chance of the scan line + having non-zero-width intersection with the polygon + the scan line Y ordinate is chosen to be near the centre of the polygon's + Y extent but distinct from all of vertex Y ordinates. +
+ + Compute the sections of the scan line + which lie in the interior of the polygon. +
+ + Choose the widest interior section + and take its midpoint as the interior point. +
+
KNOWN BUGS
+-
+
+ If a fixed precision model is used, + in some cases this method may return a point + which does not lie in the interior. +
+ + If the input polygon is extremely narrow the computed point + may not lie in the interior of the polygon. +
+
-
+
the segment does not intersect the line
+ the line or the segment are degenerate (have zero length)
+
-
+
- the segments do not intersect
+ - the segments intersect in a single point
+ - the segments are collinear and they intersect in a line segment
+
-
+
-
+
if the point is in the geometry interior
+ if the point lies exactly on the boundary
+ if the point is outside the geometry
+
+ Location.Exterior != Locate(p, geom)
+
+ -
+
if the point is in the geometry interior
+ if the point lies exactly on the boundary
+ if the point is outside the geometry
+
-
+
As a centre point and a radius
+ By the set of points defining the circle. + Depending on the number of points in the input + and their relative positions, this set + contains from 0 to 3 points. + -
+
0 or 1 points indicate an empty or trivial input point arrangement.
+ 2 points define the diameter of the minimum bounding circle.
+ 3 points define an inscribed triangle of the minimum bounding circle.
+
-
+
a LineString between the two farthest points of the input
+ a empty LineString if the input is empty
+ a Point if the input is a point
+
-
+
the diameter line of the Minimum Bounding Circle
+ an empty line if the input is empty
+ a Point if the input is a point
+
-
+
0 or 1 points indicate an empty or trivial input point arrangement.
+ 2 points define the diameter of the Minimum Bounding Circle.
+ 3 points define an inscribed triangle of which the Minimum Bounding Circle is the circumcircle. + The longest chords of the circle are the line segments [0-1] and[1 - 2]
+
-
+
The centre point of the Minimum Bounding Circle or
+ null if the input is empty
+
-
+
-
+
, is collinear with p1->p2
+ -
+
, is clockwise (right) from p1->p2
+ -
+
, is counter-clockwise (left) from p1->p2
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments (in particular, along the top of the ring).
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments (in particular, along the top of the ring).
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments + (in particular, along the top of the ring).
+ This handles rings which are invalid due to self-intersection
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments + (in particular, along the top of the ring).
+ This handles rings which are invalid due to self-intersection
+
-
+
s do not enclose any area - points inside the ring are still in the EXTERIOR of the ring.
+
-
+
touch the ray
+ lie in in any ring which may contain the point
+
-
+
-1 if the determinant is negative,
+ 1 if the determinant is positive,
+ 0 if the determinant is null.
+
-
+
1 if q is counter-clockwise (left) from p1-p2
+ -1 if q is clockwise (right) from p1-p2
+ 0 if q is collinear with p1-p2
+ If necessary, val1 and val2 are exchanged. +
Note: JTS name
Note: JTS name
+ If the origin vertex has degree
-
+
at least one of the labels is a line label
+ any labels which are not line labels have all Location = Exterior.
+
-
+
first compare the quadrant. If the quadrants + are different, it it trivial to determine which vector is "greater".
+ if the vectors lie in the same quadrant, the computeOrientation function + can be used to decide the relative orientation of the vectors.
+
-
+
On on the edge
+ Left left-hand side of the edge
+ Right right-hand side
+
-
+
Coordinate -parameter and -parameter are silently dropped.
+ CoordinateZ -parameter is silently dropped.
+ CoordinateM -parameter is silently dropped.
+ CoordinateZM No parameter is dropped.
+
-
+
For sequence measures is zero
+ For sequence measure is one
+ For sequence measure is zero
+ For sequence measure is one
+ Values greater than one are supported
+
+ For
+ For
Binary Predicates:
+ Because it is not clear at this time what semantics for spatial + analysis methods involvingOverlay Methods:
+ The spatial analysis methods will + return the most specific class possible to represent the result. If the + result is homogeneous, aGeometry Equality
+ There are two ways of comparing geometries for equality: + structural equality and topological equality. +Structural Equality
+ Structural Equality is provided by the +Topological Equality
+ Topological Equality is provided by the ++ For JTS v1.17 the values in this enum have been renamed to 'TYPECODE...' + In order not to break binary compatibility we did not follow. +
-
+
Valid polygonal geometries are simple, since their rings + must not self-intersect. IsSimple + tests for this condition and reportsfalse if it is not met. + (This is a looser test than checking for validity).
+ Linear rings have the same semantics.
+ Linear geometries are simple if they do not self-intersect at points + other than boundary points.
+ Zero-dimensional geometries (points) are simple if they have no + repeated points.
+ Empty Geometry s are always simple.
+
+ A collection containing only empty elements is reported as empty.
+ To check structural emptiness use
-
+
empty, returns an empty Point
+ a point, returns a Point
+ a line parallel to an axis, a two-vertex LineString ,
+ otherwise, returns a + Polygon whose vertices are (minx, miny), (maxx, miny), + (maxx, maxy), (minx, maxy), (minx, miny).
+
-
+
The DE-9IM intersection matrix for the two geometries matches FF*FF**** .
+ !g.intersects(this) == true
(Disjoint is the inverse ofIntersects )
+
-
+
The geometries have at least one point in common, + but their interiors do not intersect
+ The DE-9IM Intersection Matrix for the two geometries matches + at least one of the following patterns + -
+
FT******* ,
+ F**T***** or
+ F***T**** .
+
+
-
+
The two geometries have at least one point in common
+ The DE-9IM Intersection Matrix for the two geometries matches
+[T********] or
+[*T*******] or
+[***T*****] or
+[****T****]
+ !g.disjoint(this)
+ (Intersects is the inverse ofDisjoint )
+
-
+
- The geometries have some but not all interior points in common. +
- The DE-9IM Intersection Matrix for the two geometries matches
+ one of the following patterns:
+
-
+
[T*T******] for P/L, P/A, and L/A situations
+ [T*****T**] for L/P, A/P, and A/L situations)
+ [0********] for L/L situations
+
Code Description
+
-
+
+ Every point of this geometry is a point of the other geometry, + and the interiors of the two geometries have at least one point in common. +
+ The DE-9IM Intersection Matrix for the two geometries matches [T*F**F***]
+ g.contains(this) == true
(Within is the converse of)
+
-
+
Every point of the other geometry is a point of this geometry, + and the interiors of the two geometries have at least one point in common.
+ The DE-9IM Intersection Matrix for the two geometries matches the pattern + [T*****FF*]
+ g.within(this)
+ (Contains is the converse of)
+
-
+
The geometries have at least one point each not shared by the other (or equivalently neither covers the other), + they have the same dimension, + and the intersection of the interiors of the two geometries has + the same dimension as the geometries themselves.
+ The DE-9IM Intersection Matrix for the two geometries matches + [T*T***T**] (for two points or two surfaces) + or[1*T***T**] (for two curves)
+
-
+
Every point of the other geometry is a point of this geometry.
+ The DE-9IM Intersection Matrix for the two geometries matches at least + one of the following patterns: + -
+
[T*****FF*] or
+ [*T****FF*] or
+ [***T**FF*] or
+ [****T*FF*]
+
+ g.CoveredBy(this) == true
+ (covers is the converse of)
+
-
+
Every point of this geometry is a point of the other geometry.
+ The DE-9IM Intersection Matrix for the two geometries matches + at least one of the following patterns: + -
+
[T*F**F***]
+ [*TF**F***]
+ [**FT*F***]
+ [**F*TF***]
+ g.Covers(this) == true
+ (CoveredBy is the converse of) +
+
-
+
0 (dimension 0)
+ 1 (dimension 1)
+ 2 (dimension 2)
+ T ( matches 0, 1 or 2)
+ F ( matches FALSE)
+ * ( matches any value)
+
-
+
The two geometries have at least one point in common, + and no point of either geometry lies in the exterior of the other geometry.
+ The DE-9IM Intersection Matrix for the two geometries matches + the pattern T*F**FFF* + + T*F + **F + FF* +
+
-
+
- (default) a semi-circle
+ - a straight line perpendicular to the end segment
+ - a half-square
+
-
+
- (default) a semi-circle
+ - a straight line perpendicular to the end segment
+ - a half-square
+
-
+
- (default) a semi-circle
+ - a straight line perpendicular to the end segment
+ - a half-square
+
-
+
Unioning a set of s has the effect of fully noding and dissolving the linework.
+ Unioning a set of s always returns a geometry + (unlike ), which may return geometries of lower dimension if a topology + collapse occurred).
+
-
+
they have the same class,
+ they have the same values of Coordinates, + within the given tolerance distance, in their internal + Coordinate lists, in exactly the same order.
+
-
+
they have the same class,
+ they have the same values of Coordinates in their internal + Coordinate lists, in exactly the same order.
+
-
+
Point (lowest),
+ MultiPoint,
+ LineString,
+ LinearRing,
+ MultiLineString,
+ Polygon,
+ MultiPolygon,
+ GeometryCollection (highest).
+
-
+
Point (lowest),
+ MultiPoint,
+ LineString,
+ LinearRing,
+ MultiLineString,
+ Polygon,
+ MultiPolygon,
+ GeometryCollection (highest).
+ ///
-
+
Point (lowest),
+ MultiPoint,
+ LineString,
+ LinearRing,
+ MultiLineString,
+ Polygon,
+ MultiPolygon,
+ GeometryCollection (highest).
+
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
-
+
- null returns an empty
- a point returns a non-empty
- a line returns a two-point
- a rectangle returns a
whose points are (minx, maxy), (minx, maxy), (maxx, maxy), (maxx, miny).
+
+ If
+ If
+ If
+ When used to represent a matrix pattern entries can have the additional values +
-
+
OGC 99-049 OpenGIS Simple Features Specification for SQL.
+ + OGC 06-103r4 OpenGIS Implementation Standard for Geographic information - Simple feature access - Part 1: Common architecture, + Section 6.1.15 (which provides some further details on certain predicate specifications).
+ Wikipedia article on DE-9IM
+
-
+
set and query the elements of the matrix in a convenient fashion
+ convert to and from the standard string representation(specified in SFS Section 2.1.13.2).
+ test if a matrix matches a given pattern string.
+ test if a matrix(possibly with geometry dimensions) matches a standard named spatial predicate
+
-
+
The geometries have some but not all interior points in common.
+ The DE-9IM Intersection Matrix for the two geometries matches
+ [T*T******] (for P/L, P/A, and L/A situations)
+ [T*****T**] (for L/P, L/A, and A/L situations)
+ [0********] (for L/L situations)
+
-
+
-
+
[T*T***T**] (for two points or two surfaces)
+ [1*T***T**] (for two curves)
+
+ A ring with 3 points is invalid, because it is collapsed + and thus has a self-intersection. It is allowed to be constructed + so that it can be represented, and repaired if needed. +
+ For JTS v1.17 this property's getter has been renamed to
-
+
1 if p is to the left of this segment
+ -1 if p is to the right of this segment
+ 0 if p is collinear with this segment
+
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
The
-
+
The coordinate which defines it if any) is a valid coordinate + (i.e. does not have an NaN X- or Y-ordinate
+
+ For JTS v1.17 this property's getter has been renamed to
-
+
the coordinates which define it are valid coordinates
+ the linear rings for the shell and holes are valid + (i.e. are closed and do not self-intersect)
+ holes touch the shell or another hole at at most one point + (which implies that the rings of the shell and holes must not cross)
+ the interior of the polygon is connected, + or equivalently no sequence of touching holes + makes the interior of the polygon disconnected + (i.e. effectively split the polygon into two pieces).
+
+ For JTS v1.17 this property's getter has been renamed to
+ Three types of precision model are supported: +
-
+
Floating Represents full double precision floating point. + This is the default precision model used in NTS
+ FloatingSingle Represents single precision floating point
+ Fixed Represents a model with a fixed number of decimal places. + A Fixed Precision Model is specified by a scale factor. + The scale factor specifies the size of the grid which numbers are rounded to.
+
-
+
jtsPt.X = Math.Round( inputPt.X * scale, MidPointRounding.AwayFromZero ) / scale )
+ jtsPt.Y = Math.Round( inputPt.Y * scale, MidPointRounding.AwayFromZero ) / scale )
+
-
+
Every point of the other geometry is a point of this geometry's interior.
+ The DE-9IM Intersection Matrix for the two geometries matches >[T**FF*FF*]
+
-
+
Every point of the other geometry is a point of this geometry's interior.
+ The DE-9IM Intersection Matrix for the two geometries matches >[T**FF*FF*]
+
+ Used when short-circuit tests are not conclusive. +
+ Uses short-circuit tests and indexing to improve performance. +
+ 1 - NW | 0 - NE
+ -------+-------
+ 2 - SW | 3 - SE
+
+ -
+
- reflection (through a line) +
- rotation (around the origin) +
- scaling (relative to the origin) +
- shearing (in both the X and Y directions) +
- translation +
+ T = | m00 m01 m02 |
+ | m10 m11 m12 |
+ | 0 0 1 |
+
+ | x' | = T x | x |
+ | y' | | y |
+ | 1 | | 1 |
+ Transformation Composition
+++ A.compose(B) = TB x TA +
Transformation Inversion
+
+ | 1 0 0 |
+ | 0 1 0 |
+ | 0 0 1 |
+ + m00, m01, m02, m10, m11, m12 ++
+ | m00 m01 m02 |
+ | m10 m11 m12 | = m00 * m11 - m01 * m10
+ | 0 0 1 |
+
+ 1
+ inverse(A) = --- x adjoint(A)
+ det
+
+
+ = 1 | m11 -m01 m01*m12-m02*m11 |
+ --- x | -m10 m00 -m00*m12+m10*m02 |
+ det | 0 0 m00*m11-m10*m01 |
+
+
+
+ = | m11/det -m01/det m01*m12-m02*m11/det |
+ | -m10/det m00/det -m00*m12+m10*m02/det |
+ | 0 0 1 |
+
+ d = sqrt(x2 + y2)
+ sin = x / d;
+ cos = x / d;
+ Tref = Trot(sin, cos) x Tscale(1, -1) x Trot(-sin, cos)
+ ++ | cos(theta) -sin(theta) 0 | + | sin(theta) cos(theta) 0 | + | 0 0 1 | +
++ | cosTheta -sinTheta 0 | + | sinTheta cosTheta 0 | + | 0 0 1 | +
++ | cosTheta -sinTheta x-x*cos+y*sin | + | sinTheta cosTheta y-x*sin-y*cos | + | 0 0 1 | +
++ | cosTheta -sinTheta x-x*cos+y*sin | + | sinTheta cosTheta y-x*sin-y*cos | + | 0 0 1 | +
++ | xScale 0 dx | + | 0 yScale dy | + | 0 0 1 | +
+ Note that a shear of (1, 1) is not + equal to shear(1, 0) composed with shear(0, 1). + Instead, shear(1, 1) corresponds to a mapping onto the + line x = y. ++ | 1 xShear 0 | + | yShear 1 0 | + | 0 0 1 | +
++ | 1 0 dx | + | 1 0 dy | + | 0 0 1 | +
++ A.compose(B) = TB x TA +
++ A.composeBefore(B) = TA x TB +
+ AffineTransformation[[m00, m01, m02], [m10, m11, m12]]
+
+ -
+
a translation from the start point of the source baseline to the start point of the destination baseline,
+ a rotation through the angle between the baselines about the destination start point,
+ and a scaling equal to the ratio of the baseline lengths.
+
-
+
+ The values of the coordinates may be changed. + The editor does not check whether changing coordinate values makes the result Geometry invalid +
+ + The coordinate lists may be changed (e.g. by adding, deleting or modifying coordinates). + The modified coordinate lists must be consistent with their original parent component + (e.g. a LinearRing must always have at least 4 coordinates, and the first and last + coordinate must be equal). +
+ + Components of the original point may be deleted + (e.g. holes may be removed from a Polygon, or LineStrings removed from a MultiLineString). + Deletions will be propagated up the component tree appropriately. +
-
+
The resulting Geometry is not checked for validity. + If validity needs to be enforced, the new Geometry's + method should be called.
+ By default the UserData of the input geometry is not copied to the result.
+
Semantic Rules
+-
+
Vertices with non-finite X or Y ordinates are removed (as per )
+ Repeated points are reduced to a single point
+ Empty atomic geometries are valid and are returned unchanged
+ Empty elements are removed from collections
+ Point : keep valid coordinate, or EMPTY
+ LineString : coordinates are fixed
+ LinearRing : coordinates are feixed, keep valid ring or else convert intoLineString
+ Polygon : transform into a valid polygon, + preserving as much of the extent and vertices as possible. +-
+
Rings are fixed to ensure they are valid
+ Holes intersection the shell are subtracted from the shell
+ Holes outside the shell are converted into polygons
+
+ MultiPolygon : each polygon is fixed, + then result made non - overlapping (via union)
+ GeometryCollection : each element is fixed
+ Collapsed lines and polygons are handled as follows, + depending on the keepCollapsed setting: +-
+
false : (default) collapses are converted to empty geometries + (and removed if they are elements of collections)
+ true : collapses are converted to a valid geometry of lower dimension
+
+
+ In order to avoid overhead the algorithm runs in-place + on A - if A should not be modified the client must supply a copy. +
-
+
A vector containing the solution (if any)
+ null if the system has no or no unique solution
+
+ If
-
+
the segments within a monotone chain never intersect each other
+ the envelope of any contiguous subset of the segments in a monotone chain + is equal to the envelope of the endpoints of the subset.
+
-
+
- Envelope select
- Overlap
-
+
The items/nodes of the previous are partitioned into blocks of size nodeCapacity
+ For each block a layer node is created with range equal to the envelope of the items/nodess in the block
+
-
+
the best matching node
+ null if no match was found
+
-
+
The data for the point
+ The created node
+
+ or -1 if no subquad wholly contains the envelope
+
+ Any type of object can also be indexed, as long as it has an extent that can be + represented by an
-
+
- empty +
an interior node containing child s
+ a leaf node containing data items ( s).
+
+ Items may be removed from the tree using
-
+
- It is consistent in all locales (in particular, the decimal separator is always a period) +
Scientific notation is never output, even for very large numbers. This means that it is possible that output can contain a large number of digits.
+ The maximum number of decimal places reflects the available precision
+ NaN values are represented as "NaN"
+ Inf values are represented as "Inf" or "-Inf"
+
+ If an
+ If an
+ If an
-
+
s are written as s.
+ Empty geometries are output as follows + -
+
Point A WKBPoint withdouble.NaN ordinate values
+ LineString A WKBLineString with zero points
+ Polygon currently output as a WKBPolygon with oneLinearRing with zero points. + Note: This is different to other systems. It will change to aWKBPolygon with zeroLinearRing s.
+ Multi geometries A WKBMulti with zero elements
+ GeometryCollection A WKBGeometryCollection with zero elements
+
-
+
0x80000000 flag if geometry's z-ordinate values are written
+ 0x40000000 flag if geometry's m-ordinate values are written
+ 0x20000000 flag if geometry's SRID value is written
-
+
-
+
-
+
+ append 'Z' if in +the value is included. +
+ -
+
+ append 'M' if in +the value is included. +
+ -
+
+ append 'ZM' if in +the and + values are included. +
+
+ The referenced geometry is not maintained within this location, + but must be provided for operations which require it. + Various methods are provided to manipulate the location value + and query the geometry it references. +
+ |x.lo| <= 0.5*ulp(x.hi) ++ and ulp(y) means "unit in the last place of y". + The basic arithmetic operations are implemented using + convenient properties of IEEE-754 floating-point arithmetic. +
References
+-
+
Priest, D., Algorithms for Arbitrary Precision Floating Point Arithmetic, + in P. Kornerup and D. Matula, Eds., Proc. 10th Symposium on Computer Arithmetic, + IEEE Computer Society Press, Los Alamitos, Calif., 1991.
+ Yozo Hida, Xiaoye S. Li and David H. Bailey, + Quad-Double Arithmetic: Algorithms, Implementation, and Application, + manuscript, Oct 2000; Lawrence Berkeley National Laboratory Report BNL-46996.
+ David Bailey, High Precision Software Directory; + http://crd.lbl.gov/~dhbailey/mpdist/index.html
+
-
+
If this value is NaN, returns NaN.
+
-
+
If this value is NaN, returns NaN.
+
-
+
if this value is > 0, returns 1
+ if this value is < 0, returns -1
+ if this value is = 0, returns 0
+ if this value is NaN, returns 0
+
-
+
If this value is NaN, returns NaN.
+
-
+
If this value is NaN, returns NaN.
+
-
+
if this value is NaN, it is returned.
+
+ or
+ [+|-] {digit} [ . {digit} ] [ ( e | E ) [+|-] {digit}+
+
+ -
+
If the argument is NaN or less than zero, then the result is NaN.
+ If the argument is positive infinity, then the result is positive infinity.
+ If the argument is positive zero or negative zero, then the result is negative infinity.
+
or
+ The distance is: +
-
+
positive if the point lies above the plane (relative to the plane normal)
+ zero if the point is on the plane
+ negative if the point lies below the plane (relative to the plane normal)
+
+ sum = frac * this + (1 - frac) * v ++
-
+
Proper intersections between segments (i.e. the intersection is interior to both segments)
+ Intersections at an interior vertex (i.e. with an endpoint or another interior vertex)
+
+ Note that some clients (such as
+ Note that some clients (such as
-
+
Interior intersections which lie in the interior of a segment + (with another segment interior or with a vertex or endpoint)
+ Vertex intersections which occur at vertices in the interior of s + (with a segment string endpoint or with another interior vertex)
+
+ Note that some clients (such as
+ or
+ 0 the two objects are equal;
+ 1 this one is greater. +
+ 0 this SegmentNode is at the argument location;
+ 1 this SegmentNode is located after the argument location. +
+ 0 if the two nodes are equal, or
+ 1 if node1 occurs first. +
-
+
the only intersection between any two linestrings occurs at their endpoints.
+
+ The
+ The
+ If the point has been added already, it is marked as a node. +
KNOWN BUGS
+ This implementation is not fully robust. + instead. +-
+
CoordinateSequenceFactory A factory to create coordinate sequences
+ PrecisionModel A precision model
+ int spatial reference id (srid)
+ GeometryOverlay A class that bundles an overlay operation function set
+ CoordinateEqualityComparer A class that performs checks s for equality.
+
+ No
+ The
+ No
+ The default precision model is defined by
+ The
+ A value of
+ The default precision model is defined by
+ The
+ No
+ The default coordinate sequence factory is defined by
+ The
+ The semantics are: +
-
+
Empty geometries do not have boundaries.
+ Points do not have boundaries.
+ For linear geometries the existence of the boundary + is determined by the .
+ Non-empty polygons always have a boundary.
+
+ This happens at buffer distances slightly greater than the distance at + which the buffer should disappear.
+ The inverted curve will produce an incorrect non-empty buffer (for a shell) + or an incorrect hole (for a hole). + It must be discarded from the set of offset curves used in the buffer. + Heuristics are used to reduce the number of cases which area checked, + for efficiency and correctness. +
+ or
-
+
- the usual round end caps
+ - end caps are truncated flat at the line ends
+ - end caps are squared off at the buffer distance beyond the line ends
+
-
+
- the usual round join
+ - corners are "sharp" (up to a distance limit})
+ - corners are beveled (clipped off)
+
-
+
Quadrant segments (accuracy of approximation for circular arcs)
+ End Cap style
+ Join style
+ Mitre limit
+ whether the buffer is single-sided
+
+ A value of 8 gives less than 2% max error in the buffer distance.
+ A value of 8 gives less than 2% max error in the buffer distance.
+ The default value of 8 gives less than 2% error in the buffer distance.
-
+
a positive distance indicates the left-hand side
+ a negative distance indicates the right-hand side
+
-
+
For self-intersecting lines, the buffer boundary includes + offset lines for both left and right sides of the input line. + Only a single contiguous portion on the specified side is returned.
+ If the offset corresponds to buffer holes, only the largest hole is used.
+
+ or
-
+
the distance is zero
+ the distance is negative, except for the case of singled-sided buffers
+
+ or
+ or
+ This happens at buffer distances slightly greater than the distance at + which the buffer should disappear.
+ The inverted curve will produce an incorrect non-empty buffer (for a shell) + or an incorrect hole (for a hole). + It must be discarded from the set of offset curves used in the buffer. + Heuristics are used to reduce the number of cases which area checked, + for efficiency and correctness. +
-
+
A closingSegFactor of 0 results in lines to the corner vertex
+ A closingSegFactor of 1 results in lines halfway to the corner vertex
+ A closingSegFactor of 80 results in lines 1/81 of the way to the corner vertex + (this option is reasonable for the very common default situation of round joins + and quadrantSegs >= 8)
+
+ This is chosen to be a small fraction of the offset distance. +
+ In some cases (particularly for round joins with default-or-better + quantization) the closing segments can be made quite short. + This substantially improves performance (due to fewer intersections being created). +
+ A closingSegFactor of 0 results in lines to the corner vertex
+ A closingSegFactor of 1 results in lines halfway to the corner vertex
+ A closingSegFactor of 80 results in lines 1/81 of the way to the corner vertex + (this option is reasonable for the very common default situation of round joins + and quadrantSegs >= 8) +
-
+
-1 if DS1.seg is left of or below DS2.seg (DS1 < DS2).
+ 1 if DS1.seg is right of or above DS2.seg (DS1 > DS2).
+ 0 if the segments are identical
+
-
+
The logic does not obey the contract. + This is acceptable for the intended usage, but may cause problems if used with some + utilities in the .Net standard library (e.g. .
+
+ or
+ or
+ or
-
+
a base point for the plane is determined from the average of all vertices
+ the normal vector is determined by computing the area of the projections on each of the axis planes
+
+ If the sequence lies in a single plane, + the computed point also lies in the plane. +
+ or
-
+
+ Performance is dramatically improved due to the use of the + R-tree index + and the pruning due to the Branch-and-Bound approach + + The spatial index on the target geometry is cached + which allow reuse in an repeated query situation.
+
-
+
+ A Geometry is simple if and only if the only self-intersections are at boundary points. +
+
-
+
Valid geometries are simple by definition, so + IsSimple trivially returns true.
+ (Note: this means that IsSimple cannot be used to test + for (invalid) self-intersections in Polygons. + In order to check if a Polygonal geometry has self-intersections, + use).
+ geometries are simple if and only if they do not self-intersect at interior points + (i.e. points other than boundary points). + This is equivalent to saying that no two linear components satisfy the SFS + predicate.
+ Zero-dimensional ( ) geometries are simple if and only if they have no + repeated points.
+ Empty s are always simple by definition.
+
-
+
Vector-clean Line segments within the collection + must either be identical or intersect only at endpoints.
+ Non-overlapping No two polygons + may overlap. Equivalently, polygons must be interior-disjoint.
+
+ Merged edges can occur in the following situations +
-
+
Due to coincident edges of polygonal or linear geometries.
+ Due to topology collapse caused by snapping or rounding + of polygonal geometries.
+
-
+
If the edge is not part of the input, the label is left as
+ If input is an Area and the edge is on the boundary (which may include some collapses), edge is marked as an edge and side locations are assigned
+ If input is an Area and the edge is collapsed (depth delta = 0), the label is set to . The location will be determined later by evaluating the final graph topology.
+ If input is a Line edge is set to a edge. For line edges the line location is not significant (since there is no parent area for which to determine location).
+
-
+
Coincident edges from different input geometries have their labels combined
+ Coincident edges from the same area geometry indicate a topology collapse. + In this case the topology locations are "summed" to provide a final + assignment of side location
+ Coincident edges from the same linear geometry can simply be merged + using the same ON location
+
-
+
Extracts input edges, and attaches topological information
+ if clipping is enabled, handles clipping or limiting input geometry
+ chooses a based on provided precision model, unless a custom one is supplied
+ calls the chosen Noder, with precision model
+ removes any fully collapsed noded edges
+ builds s and merges them
+
+ This is one of: +
-
+
Fixed precision: a snap-rounding noder (which should be fully robust)
+ Floating precision: a conventional noder (which may be non-robust). + In this case, a validation step is applied to the output from the noder.
+
+ True provides the original JTS semantics. +
-
+
Linework is fully noded
+ Lines are as long as possible between nodes
+
+ True provides the original JTS semantics. +
+ True provides the original JTS semantics. +
-
+
they belong to an area (i.e.they have sides)
+ they are marked as being in the result
+
+ - This edge is in the result
+ - This edge is not yet linked
+ - The edge and its sym are NOT both marked as being in the result +
+
+ The label must be interpreted accordingly. +
+ If the origin vertex has degree 1 then this is the edge itself. +
+ The shell is the ring itself if it is not a hole, otherwise its parent shell. +
+ ring A contains ring B if envelope(ring A) contains envelope(ring B) +
+ This routine is only safe to use if the chosen point of the hole + is known to be properly contained in a shell + (which is guaranteed to be the case if the hole does not touch its shell) +
+ The other edges around the node can be found by following the next and prev links. +
+ Only valid edges can be added (in particular, zero-length segments cannot be added) +
-
+
A Boundary edge of an Area (polygon) + +-
+
dim = DIM_BOUNDARY
+ locLeft, locRight : the locations of the edge sides for the Area
+ locLine : INTERIOR
+ isHole : whether the edge is in a shell or a hole (the ring role)
+
+ A Collapsed edge of an input Area + (formed by merging two or more parent edges) + +-
+
dim = DIM_COLLAPSE
+ locLine : the location of the edge relative to the effective input Area + (a collapsed spike is EXTERIOR, a collapsed gore or hole is INTERIOR)
+ isHole :true if all parent edges are in holes; +false if some parent edge is in a shell
+
+
+ A Line edge from an input line + +-
+
dim = DIM_LINE
+ locLine : the location of the edge relative to the Line. + Initialized to LOC_UNKNOWN to simplify logic.
+
+ An edge which is Not Part of an input geometry + (and thus must be part of the other geometry). + +-
+
dim = NOT_PART
+
+
-
+
an edge cannot be both a Collapse edge and a Line edge in the same input geometry, + because each input geometry must be homogeneous.
+ an edge may be an Boundary edge in one input geometry + and a Line or Collapse edge in the other input.
+
+ This is used to set the locations for linear edges + encountered during area label propagation. +
+ They can be now located based on their parent ring role(shell or hole). + (This cannot be done earlier, because the location + based on the boundary edges must take precedence.
+ There are situations where a collapsed edge has a location + which is different to its ring role - + e.g.a narrow gore in a polygon, which is in + the interior of the reduced polygon, but whose + ring role would imply the location EXTERIOR.) +
+ This must be because they are NOT_PART edges for that geometry, + and are disconnected from any edges of that geometry. + An example of this is rings of one geometry wholly contained + in another geometry.
+ The location must be fully determined to compute a + correct result for all overlay operations. +
-
+
Duplicates are removed from Point output
+ Non-point output is rounded and noded using the given precision model
+
-
+
An empty result is an empty atomic geometry + with dimension determined by the inputs and the operation as per overlay semantics +
+
-
+
Input points are not included in the noding of the non-point input geometry + (in particular, they do not participate in snap-rounding if that is used).
+ If the non-point input geometry is not included in the output + it is not rounded and noded.This means that points + are compared to the non-rounded geometry. + This will be apparent in the result.
+
-
+
all points which lie in both geometries
+ all points which lie in at least one geometry
+ all points which lie in the first geometry but not the second
+ all points which lie in one geometry but not both
+
-
+
Lines and Points resulting from topology collapses are not included in the result
+ Result geometry is homogeneous + for the and operations.
+ Result geometry is homogeneous + for the and operations + if the inputs have the same dimension
+
-
+
Results are simpler
+ Overlay operations are easily chainable + without needing to remove lower-dimension elements
+
+ - An Intersection result can be mixed-dimension, + due to inclusion of intersection components of all dimensions
+ - Results can include lines caused by Area topology collapse +
-
+
For + a snap-rounding noder is used, and the computation is robust.
+ For + a non-snapping noder is used, + and this computation may not be robust. + If errors occur a is thrown.
+
-
+
For + a snap - rounding noder is used, and the computation is robust.
+ For a non - snapping noder is used, + and this computation may not be robust.
+ If errors occur a
-
+
Lines resulting from topology collapse are not included
+ Result geometry is homogeneous for the + and + operations.
+ Result geometry is homogeneous for the + and + operations if the inputs have the same dimension
+
-
+
A simple fast noder using precision
+ A using an automatically-determined snap tolerance
+ First snapping each geometry to itself, and then overlaying them wih a
+ The above two strategies are repeated with increasing snap tolerance, up to a limit
+ Finally a is used with a automatically-determined scale factor.
+
-
+
Points are rounded to the precision model if provided
+ Points with identical XY values are merged to a single point
+ Extended ordinate values are preserved in the output, apart from merging
+ An empty result is returned as POINT EMPTY
+
-
+
result envelope is the intersection of the input envelopes
+ result envelope is the envelope of the A input geometry
+
-
+
result has the dimension of the lowest input dimension
+ result has the dimension of the highest input dimension
+ result has the dimension of the left-hand input
+ result has the dimension of the highest input dimension + (since the Symmetric Difference is the Union of the Differences).
+
+ (e.g. ) +
-
+
it is faster than using a point-in-polygon check later on.
+ it ensures correctness, since if the PIP test was used the point + chosen might lie on the shell, which might return an incorrect result from the + PIP test
+
+ The input geometry must be polygonal or linear. +
+ num = round( num, inherentScale(num) )
+
+ + For unary union using floating precision, +
-
+
- result has the dimension of the lowest input dimension
+ - result has the dimension of the highest input dimension
+ - result has the dimension of the left-hand input
+ - result has the dimension of the highest input dimension + (since symDifference is the union of the differences).
+
or +
or +
+ or -1 if no segment snaps to the snap point.
+ or
-
+
ring A contains ring B if envelope(ring A) contains envelope(ring B)
+
-
+
Dangles edges which have one or both ends which are not incident on another edge endpoint
+ edges which are connected at both ends but which do not form part of polygon
+ edges which form rings which are invalid + (e.g. the component lines contain a self-intersection) +
+ or
+ The class supports specifying a custom
Algorithm
+ The overlap region is determined as the common envelope of intersection. + The input polygons are partitioned into two sets: +-
+
Overlapping Polygons which intersect the overlap region, and thus potentially overlap each other
+ Disjoint Polygons which are disjoint from (lie wholly outside) the overlap region
+
Discussion
+ In general the Overlapping set of polygons will + extend beyond the overlap envelope. This means that the union result + will extend beyond the overlap region. + There is a small chance that the topological + union of the overlap region will shift the result linework enough + that the result geometry intersects one of the Disjoint geometries. + This situation is detected and if it occurs + is remedied by falling back to performing a full union of the original inputs. + Detection is done by a fairly efficient comparison of edge segments which + extend beyond the overlap region. If any segments have changed + then there is a risk of introduced intersections, and full union is performed. +-
+
Unioning a set of s has the effect of merging the areas (i.e. the same effect as iteratively unioning all individual polygons together).
+ Unioning a set of s has the effect of fully noding + and dissolving the input linework. + In this context "fully noded" means that there will be + an endpoint or node in the result + for every endpoint or line segment crossing in the input. + "Dissolved" means that any duplicate (e.g. coincident) line segments or portions + of line segments will be reduced to a single line segment in the output. + This is consistent with the semantics of the + operation. + If merged linework is required, the class can be used.
+ Unioning a set of s has the effect of merging all identical points (producing a set with no duplicates).
-
+
If the input is empty and a dimension can be + determined (i.e. an empty geometry is present), + an empty atomic geometry of that dimension is returned.
+ If no input geometries were provided but a was provided, + an empty is returned.
+ Otherwise, the return value is null .
+
-
+
Point geometries are simple.
+ MultiPoint geometries are simple if every point is unique
+ LineString geometries are simple if they do not self-intersect at interior points + (i.e.points other than the endpoints).
+ MultiLineString geometries are simple if + their elements are simple and they intersect only at points + which are boundary points of both elements. + (The notion of boundary points can be user-specified - see below).
+ Polygonal geometries have no definition of simplicity. + The IsSimple code checks if all polygon rings are simple. + (Note: this means thatIsSimple cannot be used to test + for all self-intersections in Polygon s. + In order to check if a IPolygonal geometry has self-intersections, + use.
+ GeometryCollection geometries are simple if all their elements are simple.
+ Empty geometries are simple
+
-
+
the shell ring self-touches to create a hole touching the shell
+ a hole ring self-touches to create two holes touching at a point
+
-
+
exverted ("bow-tie") shells which self-touch at a single point
+ inverted shells with the inversion touching the shell at another point
+ exverted holes with exversion touching the hole at another point
+ inverted ("C-shaped") holes which self-touch at a single point causing an island to be formed
+ inverted shells or exverted holes which form part of a chain of touching rings + (which disconnect the interior)
+
+ - The shell ring self-touches to create a hole touching the shell.
+ - A hole ring self-touches to create two holes touching at a point.
+
+ Almost anything goes for
+
+
+
+
-
+
shells do not partially overlap
+ shells do not touch along an edge
+ no duplicate rings exist
-
+
The segment intersects the ring only at the endpoints
+ One, none or both of the segment endpoints may lie on the ring
+ The ring does not self-cross, but it may self-touch
+
-
+
The segment does not intersect the ring other than at the endpoints
+ The segment vertex p0 lies on the ring
+ The ring does not self-cross, but it may self-touch
+
+ If true, the disconnection location is available from +
+
+ or
Topological Precision Reduction
+ The default mode of operation ensures the reduced result is topologically valid + (i.e.Pointwise Precision Reduction
+ Alternatively, geometry can be reduced pointwise by using {@link #setPointwise(boolean)}. + Linear and point geometry are always reduced pointwise(i.e.without further change to + topology or structure), since this does not change validity. + Invalid inputs are allowed. + Duplicate vertices are preserved. + Collapsed components are always included in the result. + The result geometry may be invalid. +-
+
No two distinct vertices of G are closer than r.
+ No vertex of G is closer than r to an edge of G of which the vertex is not an endpoint
+
References
+-
+
[Mi88] Milenkovic, V. J., + Verifiable implementations of geometric algorithms + using finite precision arithmetic. + in Artificial Intelligence, 377-401. 1988
+ [TV06] Thompson, Rod and van Oosterom, Peter, + Interchange of Spatial Data-Inhibiting Factors, + Agile 2006, Visegrad, Hungary. 2006
+
+ or
+ or
+ or
+ dist(p1, p2) =
+ p1 != p2 : p1.distance(p2)
+ p1 == p2 : Double.MAX
+
+ dist(p, seg) =
+ p != seq.p1 && p != seg.p2
+ ? seg.distance(p)
+ : Double.MaxValue
+
+ Also computes the values of the nearest points, if any.
+ + Repeated points are removed. + If geometry elements collapse below their valid length, + they may be removed + by specifying
2 * npts - 2).
+ 2 * npts - 2).
+ -
+
valid topology is not required
+ fixing topology is a relative expensive operation
+ in some pathological cases the topology fixing operation may either fail or run for too long
+
+ If the input is empty or is not polygonal, + this ensures that POLYGON EMPTY is returned. +
+ Points closer than this tolerance to a simplified segment may + be removed. +
-
+
The result has the same number of shells and holes as the input, + with the same topological structure
+ The result rings touch at no more than the number of touching points in the input + (although they may touch at fewer points). + The key implication of this statement is that if the + input is topologically valid, so is the simplified output.
+
KNOWN BUGS
+-
+
May create invalid topology if there are components which are small + relative to the tolerance value. + In particular, if a small hole is very near an edge, + it is possible for the edge to be moved by a relatively large tolerance value + and end up with the hole outside the result shell (or inside another hole). + Similarly, it is possible for a small polygon component to end up inside + a nearby larger polygon. + A workaround is to test for this situation in post-processing and remove + any invalid holes or polygons.
+
+ Points closer than this tolerance to a simplified segment may + be removed. +
+ ConformingDelaunayTriangulator cdt = new ConformingDelaunayTriangulator(sites, tolerance);
+
+ // optional
+ cdt.SplitPointFinder = splitPointFinder;
+ cdt.VertexFactory = vertexFactory;
+
+ cdt.SetConstraints(segments, new List<Vertex>(vertexMap.Values));
+ cdt.FormInitialDelaunay();
+ cdt.EnforceConstraints();
+ subdiv = cdt.Subdivision;
+
+ -
+
- The projection of the encroaching point on the segment +
- A point on the segment which will produce two segments which will not be further encroached +
- The point on the segment which is the same distance from an endpoint as the encroaching + point +
+ or null if no such triangle exists +
+ or
+ or -1 if the edge is not an edge of this triangle +
+ or -1 if the vertex is not in the triangle +
+ LINESTRING (1507029.9878 518325.7547, 1507022.1120341457 518332.8225183258, + 1507029.9833 518325.7458, 1507029.9896965567 518325.744909031) ++
+ The set of Tris containing boundary edges are called the triangulation border. +
+ The vertices of the adjacent triangles are + assumed to match the appropriate vertices in this triangle. +
+ The vertices of the adjacent triangles are + assumed to match the appropriate vertices in this triangle. +
+ The vertices of the adjacent triangle are + assumed to match the appropriate vertices in this triangle. +
-
+
opp0-adj0 edge
+ opp0-adj1 edge
+ opp1-adj0 edge
+ opp1-adj1 edge
+
-
+
-
+
an envelope supplied by +.
+ -
+
an envelope determined by the input sites. +
+
-
+
null if the list is null or empty
+ [0] if the list contains one single item.
+ a ifis a GeometryCollection.
+ a Multi-geometry in all other cases.
+
-
+
null if the list is null or empty
+ [0] if the list contains one single item.
+ a ifis a GeometryCollection.
+ a Multi-geometry in all other cases.
+
+ StreamTokenizer tokenizer = new StreamTokenizer();
+ tokenizer.GrabWhitespace = true;
+ tokenizer.Verbosity = VerbosityLevel.Debug; // just for debugging
+ tokenizer.TextReader = File.OpenText(fileName);
+ Token token;
+ while (tokenizer.NextToken(out token)) log.Info("Token = '{0}'", token);
+
+
+ StreamTokenizer tokenizer = new StreamTokenizer("some string");
+ ArrayList tokens = new ArrayList();
+ if (!tokenizer.Tokenize(tokens))
+ {
+ // error handling
+ }
+ foreach (Token t in tokens) Console.WriteLine("t = {0}", t);
+
+ -
+
NormalizePositive(0.0) 0.0
+ NormalizePositive(-PI)
+ NormalizePositive(-2PI) 0.0
+ NormalizePositive(-3PI)
+ NormalizePositive(-4PI) 0.0
+ NormalizePositive(PI)
+ NormalizePositive(2PI) 0.0
+ NormalizePositive(3PI)
+ NormalizePositive(4PI) 0.0
+
-
+
The angles are assumed to be normalized to the range [-Pi, Pi].
+ The result will be in the range [0, Pi].
+
-
+
> 0 +The ring is oriented clockwise (CW)
+ < 0 +The ring is oriented counter clockwise (CCW)
+ == 0 +The ring is degenerate or flat
+
Algorithm
+-
+
Dimension 2 - the centroid ic computed + as a weighted sum of the centroids + of a decomposition of the area into (possibly overlapping) triangles. + Holes and multipolygons are handled correctly. + See http://www.faqs.org/faqs/graphics/algorithms-faq/ + for further details of the basic approach.
+ Dimension 1 - Computes the average of the midpoints + of all line segments weighted by the segment length. + Zero-length lines are treated as points. +
+ Dimension 0 - Compute the average coordinate over all points. + Repeated points are all included in the average +
+
-
+
1 if q is counter-clockwise (left) from p1-p2
+ -1 if q is clockwise (right) from p1-p2
+ 0 if q is collinear with p1-p2
-
+
1 if q is counter-clockwise (left) from p1-p2
+ -1 if q is clockwise (right) from p1-p2
+ 0 if q is collinear with p1-p2
-
+
-1 if the determinant is negative,
+ 1 if the determinant is positive,
+ 0 if the determinant is 0.
+
-
+
The orientation index if it can be computed safely
+ > 1 if the orientation index cannot be computed safely >
+
Future Enhancements
+-
+
Support polygons as obstacles
+ Support a client-defined boundary polygon
+
Future Enhancements
+-
+
Support a polygonal constraint on placement of center
+
+ Note: Unfortunately not as fast as expected. +
+ for all geometries a, b: DHD(a, b) <= HD(a, b)
+
+ The approximation can be made as close as needed by densifying the input geometries.
+ In the limit, this value will approach the true Hausdorff distance:
+
+ DHD(A, B, densifyFactor) -> HD(A, B) as densifyFactor -> 0.0
+
+ The default approximation is exact or close enough for a large subset of useful cases.
+ -
+
+ computing distance between Linestring s that are roughly parallel to each other, + and roughly equal in length. This occurs in matching linear networks. +
+ Testing similarity of geometries.
+
+ A = LINESTRING (0 0, 100 0, 10 100, 10 100)
+ B = LINESTRING (0 100, 0 10, 80 10)
+
+ DHD(A, B) = 22.360679774997898
+ HD(A, B) ~= 47.8
+
+ -
+
Maximum Edge Length Ratio the length of the longest edge of the hull is no larger + than this value.
+ Maximum Edge Length Factor determine the Maximum Edge Length + as a fraction of the difference between the longest and shortest edge lengths + in the Delaunay Triangulation. + This normalizes the Maximum Edge Length to be scale-free. + A value of 1 produces the convex hull; a value of 0 produces maximum concaveness.
+
-
+
The value 0.0 produces the concave hull of smallest area + that is still connected.
+ Larger values produce less concave results. + A value equal or greater than the longest Delaunay Triangulation edge length + produces the convex hull.
+
-
+
The value 0.0 produces a concave hull of minimum area + that is still connected.
+ The value 1.0 produces the convex hull.
+
+ This avoids the risk of disconnecting the result polygon. + The list is sorted in decreasing order of edge length. +
+ NOTE: this is a relatively slow operation. +
+ Assumption: there are at least 2 tris, they are connected, + and there are no holes. + So each tri has at least one non-border edge, and there is only one border. +
Algorithm
+ The point is chosen to be "close to the center" of the geometry. + The location depends on the dimension of the input: +-
+
Dimension 2 the interior point is constructed in the middle of the longest interior segment + of a line bisecting the area.
+ Dimension 1 the interior point is the interior or boundary vertex closest to the centroid.
+ Dimension 0 the point is the point closest to the centroid.
+
Algorithm:
+ For each input polygon: +-
+
+ Determine a horizontal scan line on which the interior + point will be located. + To increase the chance of the scan line + having non-zero-width intersection with the polygon + the scan line Y ordinate is chosen to be near the centre of the polygon's + Y extent but distinct from all of vertex Y ordinates. +
+ + Compute the sections of the scan line + which lie in the interior of the polygon. +
+ + Choose the widest interior section + and take its midpoint as the interior point. +
+
KNOWN BUGS
+-
+
+ If a fixed precision model is used, + in some cases this method may return a point + which does not lie in the interior. +
+ + If the input polygon is extremely narrow the computed point + may not lie in the interior of the polygon. +
+
-
+
the segment does not intersect the line
+ the line or the segment are degenerate (have zero length)
+
-
+
- the segments do not intersect
+ - the segments intersect in a single point
+ - the segments are collinear and they intersect in a line segment
+
-
+
-
+
if the point is in the geometry interior
+ if the point lies exactly on the boundary
+ if the point is outside the geometry
+
+ Location.Exterior != Locate(p, geom)
+
+ -
+
if the point is in the geometry interior
+ if the point lies exactly on the boundary
+ if the point is outside the geometry
+
-
+
As a centre point and a radius
+ By the set of points defining the circle. + Depending on the number of points in the input + and their relative positions, this set + contains from 0 to 3 points. + -
+
0 or 1 points indicate an empty or trivial input point arrangement.
+ 2 points define the diameter of the minimum bounding circle.
+ 3 points define an inscribed triangle of the minimum bounding circle.
+
-
+
a LineString between the two farthest points of the input
+ a empty LineString if the input is empty
+ a Point if the input is a point
+
-
+
the diameter line of the Minimum Bounding Circle
+ an empty line if the input is empty
+ a Point if the input is a point
+
-
+
0 or 1 points indicate an empty or trivial input point arrangement.
+ 2 points define the diameter of the Minimum Bounding Circle.
+ 3 points define an inscribed triangle of which the Minimum Bounding Circle is the circumcircle. + The longest chords of the circle are the line segments [0-1] and[1 - 2]
+
-
+
The centre point of the Minimum Bounding Circle or
+ null if the input is empty
+
-
+
-
+
, is collinear with p1->p2
+ -
+
, is clockwise (right) from p1->p2
+ -
+
, is counter-clockwise (left) from p1->p2
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments (in particular, along the top of the ring).
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments (in particular, along the top of the ring).
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments + (in particular, along the top of the ring).
+ This handles rings which are invalid due to self-intersection
+
-
+
The list of points is assumed to have the first and last points equal.
+ This handles coordinate lists which contain repeated points.
+ This handles rings which contain collapsed segments + (in particular, along the top of the ring).
+ This handles rings which are invalid due to self-intersection
+
-
+
s do not enclose any area - points inside the ring are still in the EXTERIOR of the ring.
+
-
+
touch the ray
+ lie in in any ring which may contain the point
+
-
+
-1 if the determinant is negative,
+ 1 if the determinant is positive,
+ 0 if the determinant is null.
+
-
+
1 if q is counter-clockwise (left) from p1-p2
+ -1 if q is clockwise (right) from p1-p2
+ 0 if q is collinear with p1-p2
+ If necessary, val1 and val2 are exchanged. +
Note: JTS name
Note: JTS name
+ If the origin vertex has degree
-
+
at least one of the labels is a line label
+ any labels which are not line labels have all Location = Exterior.
+
-
+
first compare the quadrant. If the quadrants + are different, it it trivial to determine which vector is "greater".
+ if the vectors lie in the same quadrant, the computeOrientation function + can be used to decide the relative orientation of the vectors.
+
-
+
On on the edge
+ Left left-hand side of the edge
+ Right right-hand side
+
-
+
Coordinate -parameter and -parameter are silently dropped.
+ CoordinateZ -parameter is silently dropped.
+ CoordinateM -parameter is silently dropped.
+ CoordinateZM No parameter is dropped.
+
-
+
For sequence measures is zero
+ For sequence measure is one
+ For sequence measure is zero
+ For sequence measure is one
+ Values greater than one are supported
+
+ For
+ For
Binary Predicates:
+ Because it is not clear at this time what semantics for spatial + analysis methods involvingOverlay Methods:
+ The spatial analysis methods will + return the most specific class possible to represent the result. If the + result is homogeneous, aGeometry Equality
+ There are two ways of comparing geometries for equality: + structural equality and topological equality. +Structural Equality
+ Structural Equality is provided by the +Topological Equality
+ Topological Equality is provided by the ++ For JTS v1.17 the values in this enum have been renamed to 'TYPECODE...' + In order not to break binary compatibility we did not follow. +
-
+
Valid polygonal geometries are simple, since their rings + must not self-intersect. IsSimple + tests for this condition and reportsfalse if it is not met. + (This is a looser test than checking for validity).
+ Linear rings have the same semantics.
+ Linear geometries are simple if they do not self-intersect at points + other than boundary points.
+ Zero-dimensional geometries (points) are simple if they have no + repeated points.
+ Empty Geometry s are always simple.
+
+ A collection containing only empty elements is reported as empty.
+ To check structural emptiness use
-
+
empty, returns an empty Point
+ a point, returns a Point
+ a line parallel to an axis, a two-vertex LineString ,
+ otherwise, returns a + Polygon whose vertices are (minx, miny), (maxx, miny), + (maxx, maxy), (minx, maxy), (minx, miny).
+
-
+
The DE-9IM intersection matrix for the two geometries matches FF*FF**** .
+ !g.intersects(this) == true
(Disjoint is the inverse ofIntersects )
+
-
+
The geometries have at least one point in common, + but their interiors do not intersect
+ The DE-9IM Intersection Matrix for the two geometries matches + at least one of the following patterns + -
+
FT******* ,
+ F**T***** or
+ F***T**** .
+
+
-
+
The two geometries have at least one point in common
+ The DE-9IM Intersection Matrix for the two geometries matches
+[T********] or
+[*T*******] or
+[***T*****] or
+[****T****]
+ !g.disjoint(this)
+ (Intersects is the inverse ofDisjoint )
+
-
+
- The geometries have some but not all interior points in common. +
- The DE-9IM Intersection Matrix for the two geometries matches
+ one of the following patterns:
+
-
+
[T*T******] for P/L, P/A, and L/A situations
+ [T*****T**] for L/P, A/P, and A/L situations)
+ [0********] for L/L situations
+
Code Description
+
-
+
+ Every point of this geometry is a point of the other geometry, + and the interiors of the two geometries have at least one point in common. +
+ The DE-9IM Intersection Matrix for the two geometries matches [T*F**F***]
+ g.contains(this) == true
(Within is the converse of)
+
-
+
Every point of the other geometry is a point of this geometry, + and the interiors of the two geometries have at least one point in common.
+ The DE-9IM Intersection Matrix for the two geometries matches the pattern + [T*****FF*]
+ g.within(this)
+ (Contains is the converse of)
+
-
+
The geometries have at least one point each not shared by the other (or equivalently neither covers the other), + they have the same dimension, + and the intersection of the interiors of the two geometries has + the same dimension as the geometries themselves.
+ The DE-9IM Intersection Matrix for the two geometries matches + [T*T***T**] (for two points or two surfaces) + or[1*T***T**] (for two curves)
+
-
+
Every point of the other geometry is a point of this geometry.
+ The DE-9IM Intersection Matrix for the two geometries matches at least + one of the following patterns: + -
+
[T*****FF*] or
+ [*T****FF*] or
+ [***T**FF*] or
+ [****T*FF*]
+
+ g.CoveredBy(this) == true
+ (covers is the converse of)
+
-
+
Every point of this geometry is a point of the other geometry.
+ The DE-9IM Intersection Matrix for the two geometries matches + at least one of the following patterns: + -
+
[T*F**F***]
+ [*TF**F***]
+ [**FT*F***]
+ [**F*TF***]
+ g.Covers(this) == true
+ (CoveredBy is the converse of) +
+
-
+
0 (dimension 0)
+ 1 (dimension 1)
+ 2 (dimension 2)
+ T ( matches 0, 1 or 2)
+ F ( matches FALSE)
+ * ( matches any value)
+
-
+
The two geometries have at least one point in common, + and no point of either geometry lies in the exterior of the other geometry.
+ The DE-9IM Intersection Matrix for the two geometries matches + the pattern T*F**FFF* + + T*F + **F + FF* +
+
-
+
- (default) a semi-circle
+ - a straight line perpendicular to the end segment
+ - a half-square
+
-
+
- (default) a semi-circle
+ - a straight line perpendicular to the end segment
+ - a half-square
+
-
+
- (default) a semi-circle
+ - a straight line perpendicular to the end segment
+ - a half-square
+
-
+
Unioning a set of s has the effect of fully noding and dissolving the linework.
+ Unioning a set of s always returns a geometry + (unlike ), which may return geometries of lower dimension if a topology + collapse occurred).
+
-
+
they have the same class,
+ they have the same values of Coordinates, + within the given tolerance distance, in their internal + Coordinate lists, in exactly the same order.
+
-
+
they have the same class,
+ they have the same values of Coordinates in their internal + Coordinate lists, in exactly the same order.
+
-
+
Point (lowest),
+ MultiPoint,
+ LineString,
+ LinearRing,
+ MultiLineString,
+ Polygon,
+ MultiPolygon,
+ GeometryCollection (highest).
+
-
+
Point (lowest),
+ MultiPoint,
+ LineString,
+ LinearRing,
+ MultiLineString,
+ Polygon,
+ MultiPolygon,
+ GeometryCollection (highest).
+ ///
-
+
Point (lowest),
+ MultiPoint,
+ LineString,
+ LinearRing,
+ MultiLineString,
+ Polygon,
+ MultiPolygon,
+ GeometryCollection (highest).
+
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
-
+
- null returns an empty
- a point returns a non-empty
- a line returns a two-point
- a rectangle returns a
whose points are (minx, maxy), (minx, maxy), (maxx, maxy), (maxx, miny).
+
+ If
+ If
+ If
+ When used to represent a matrix pattern entries can have the additional values +
-
+
OGC 99-049 OpenGIS Simple Features Specification for SQL.
+ + OGC 06-103r4 OpenGIS Implementation Standard for Geographic information - Simple feature access - Part 1: Common architecture, + Section 6.1.15 (which provides some further details on certain predicate specifications).
+ Wikipedia article on DE-9IM
+
-
+
set and query the elements of the matrix in a convenient fashion
+ convert to and from the standard string representation(specified in SFS Section 2.1.13.2).
+ test if a matrix matches a given pattern string.
+ test if a matrix(possibly with geometry dimensions) matches a standard named spatial predicate
+
-
+
The geometries have some but not all interior points in common.
+ The DE-9IM Intersection Matrix for the two geometries matches
+ [T*T******] (for P/L, P/A, and L/A situations)
+ [T*****T**] (for L/P, L/A, and A/L situations)
+ [0********] (for L/L situations)
+
-
+
-
+
[T*T***T**] (for two points or two surfaces)
+ [1*T***T**] (for two curves)
+
+ A ring with 3 points is invalid, because it is collapsed + and thus has a self-intersection. It is allowed to be constructed + so that it can be represented, and repaired if needed. +
+ For JTS v1.17 this property's getter has been renamed to
-
+
1 if p is to the left of this segment
+ -1 if p is to the right of this segment
+ 0 if p is collinear with this segment
+
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
+ For JTS v1.17 this property's getter has been renamed to
The
-
+
The coordinate which defines it if any) is a valid coordinate + (i.e. does not have an NaN X- or Y-ordinate
+
+ For JTS v1.17 this property's getter has been renamed to
-
+
the coordinates which define it are valid coordinates
+ the linear rings for the shell and holes are valid + (i.e. are closed and do not self-intersect)
+ holes touch the shell or another hole at at most one point + (which implies that the rings of the shell and holes must not cross)
+ the interior of the polygon is connected, + or equivalently no sequence of touching holes + makes the interior of the polygon disconnected + (i.e. effectively split the polygon into two pieces).
+
+ For JTS v1.17 this property's getter has been renamed to
+ Three types of precision model are supported: +
-
+
Floating Represents full double precision floating point. + This is the default precision model used in NTS
+ FloatingSingle Represents single precision floating point
+ Fixed Represents a model with a fixed number of decimal places. + A Fixed Precision Model is specified by a scale factor. + The scale factor specifies the size of the grid which numbers are rounded to.
+
-
+
jtsPt.X = Math.Round( inputPt.X * scale, MidPointRounding.AwayFromZero ) / scale )
+ jtsPt.Y = Math.Round( inputPt.Y * scale, MidPointRounding.AwayFromZero ) / scale )
+
-
+
Every point of the other geometry is a point of this geometry's interior.
+ The DE-9IM Intersection Matrix for the two geometries matches >[T**FF*FF*]
+
-
+
Every point of the other geometry is a point of this geometry's interior.
+ The DE-9IM Intersection Matrix for the two geometries matches >[T**FF*FF*]
+
+ Used when short-circuit tests are not conclusive. +
+ Uses short-circuit tests and indexing to improve performance. +
+ 1 - NW | 0 - NE
+ -------+-------
+ 2 - SW | 3 - SE
+
+ -
+
- reflection (through a line) +
- rotation (around the origin) +
- scaling (relative to the origin) +
- shearing (in both the X and Y directions) +
- translation +
+ T = | m00 m01 m02 |
+ | m10 m11 m12 |
+ | 0 0 1 |
+
+ | x' | = T x | x |
+ | y' | | y |
+ | 1 | | 1 |
+ Transformation Composition
+++ A.compose(B) = TB x TA +
Transformation Inversion
+
+ | 1 0 0 |
+ | 0 1 0 |
+ | 0 0 1 |
+ + m00, m01, m02, m10, m11, m12 ++
+ | m00 m01 m02 |
+ | m10 m11 m12 | = m00 * m11 - m01 * m10
+ | 0 0 1 |
+
+ 1
+ inverse(A) = --- x adjoint(A)
+ det
+
+
+ = 1 | m11 -m01 m01*m12-m02*m11 |
+ --- x | -m10 m00 -m00*m12+m10*m02 |
+ det | 0 0 m00*m11-m10*m01 |
+
+
+
+ = | m11/det -m01/det m01*m12-m02*m11/det |
+ | -m10/det m00/det -m00*m12+m10*m02/det |
+ | 0 0 1 |
+
+ d = sqrt(x2 + y2)
+ sin = x / d;
+ cos = x / d;
+ Tref = Trot(sin, cos) x Tscale(1, -1) x Trot(-sin, cos)
+ ++ | cos(theta) -sin(theta) 0 | + | sin(theta) cos(theta) 0 | + | 0 0 1 | +
++ | cosTheta -sinTheta 0 | + | sinTheta cosTheta 0 | + | 0 0 1 | +
++ | cosTheta -sinTheta x-x*cos+y*sin | + | sinTheta cosTheta y-x*sin-y*cos | + | 0 0 1 | +
++ | cosTheta -sinTheta x-x*cos+y*sin | + | sinTheta cosTheta y-x*sin-y*cos | + | 0 0 1 | +
++ | xScale 0 dx | + | 0 yScale dy | + | 0 0 1 | +
+ Note that a shear of (1, 1) is not + equal to shear(1, 0) composed with shear(0, 1). + Instead, shear(1, 1) corresponds to a mapping onto the + line x = y. ++ | 1 xShear 0 | + | yShear 1 0 | + | 0 0 1 | +
++ | 1 0 dx | + | 1 0 dy | + | 0 0 1 | +
++ A.compose(B) = TB x TA +
++ A.composeBefore(B) = TA x TB +
+ AffineTransformation[[m00, m01, m02], [m10, m11, m12]]
+
+ -
+
a translation from the start point of the source baseline to the start point of the destination baseline,
+ a rotation through the angle between the baselines about the destination start point,
+ and a scaling equal to the ratio of the baseline lengths.
+
-
+
+ The values of the coordinates may be changed. + The editor does not check whether changing coordinate values makes the result Geometry invalid +
+ + The coordinate lists may be changed (e.g. by adding, deleting or modifying coordinates). + The modified coordinate lists must be consistent with their original parent component + (e.g. a LinearRing must always have at least 4 coordinates, and the first and last + coordinate must be equal). +
+ + Components of the original point may be deleted + (e.g. holes may be removed from a Polygon, or LineStrings removed from a MultiLineString). + Deletions will be propagated up the component tree appropriately. +
-
+
The resulting Geometry is not checked for validity. + If validity needs to be enforced, the new Geometry's + method should be called.
+ By default the UserData of the input geometry is not copied to the result.
+
Semantic Rules
+-
+
Vertices with non-finite X or Y ordinates are removed (as per )
+ Repeated points are reduced to a single point
+ Empty atomic geometries are valid and are returned unchanged
+ Empty elements are removed from collections
+ Point : keep valid coordinate, or EMPTY
+ LineString : coordinates are fixed
+ LinearRing : coordinates are feixed, keep valid ring or else convert intoLineString
+ Polygon : transform into a valid polygon, + preserving as much of the extent and vertices as possible. +-
+
Rings are fixed to ensure they are valid
+ Holes intersection the shell are subtracted from the shell
+ Holes outside the shell are converted into polygons
+
+ MultiPolygon : each polygon is fixed, + then result made non - overlapping (via union)
+ GeometryCollection : each element is fixed
+ Collapsed lines and polygons are handled as follows, + depending on the keepCollapsed setting: +-
+
false : (default) collapses are converted to empty geometries + (and removed if they are elements of collections)
+ true : collapses are converted to a valid geometry of lower dimension
+
+
+ In order to avoid overhead the algorithm runs in-place + on A - if A should not be modified the client must supply a copy. +
-
+
A vector containing the solution (if any)
+ null if the system has no or no unique solution
+
+ If
-
+
the segments within a monotone chain never intersect each other
+ the envelope of any contiguous subset of the segments in a monotone chain + is equal to the envelope of the endpoints of the subset.
+
-
+
- Envelope select
- Overlap
-
+
The items/nodes of the previous are partitioned into blocks of size nodeCapacity
+ For each block a layer node is created with range equal to the envelope of the items/nodess in the block
+
-
+
the best matching node
+ null if no match was found
+
-
+
The data for the point
+ The created node
+
+ or -1 if no subquad wholly contains the envelope
+
+ Any type of object can also be indexed, as long as it has an extent that can be + represented by an
-
+
- empty +
an interior node containing child s
+ a leaf node containing data items ( s).
+
+ Items may be removed from the tree using
-
+
- It is consistent in all locales (in particular, the decimal separator is always a period) +
Scientific notation is never output, even for very large numbers. This means that it is possible that output can contain a large number of digits.
+ The maximum number of decimal places reflects the available precision
+ NaN values are represented as "NaN"
+ Inf values are represented as "Inf" or "-Inf"
+
+ If an
+ If an
+ If an
-
+
s are written as s.
+ Empty geometries are output as follows + -
+
Point A WKBPoint withdouble.NaN ordinate values
+ LineString A WKBLineString with zero points
+ Polygon currently output as a WKBPolygon with oneLinearRing with zero points. + Note: This is different to other systems. It will change to aWKBPolygon with zeroLinearRing s.
+ Multi geometries A WKBMulti with zero elements
+ GeometryCollection A WKBGeometryCollection with zero elements
+
-
+
0x80000000 flag if geometry's z-ordinate values are written
+ 0x40000000 flag if geometry's m-ordinate values are written
+ 0x20000000 flag if geometry's SRID value is written
-
+
-
+
-
+
+ append 'Z' if in +the value is included. +
+ -
+
+ append 'M' if in +the value is included. +
+ -
+
+ append 'ZM' if in +the and + values are included. +
+
+ The referenced geometry is not maintained within this location, + but must be provided for operations which require it. + Various methods are provided to manipulate the location value + and query the geometry it references. +
+ |x.lo| <= 0.5*ulp(x.hi) ++ and ulp(y) means "unit in the last place of y". + The basic arithmetic operations are implemented using + convenient properties of IEEE-754 floating-point arithmetic. +
References
+-
+
Priest, D., Algorithms for Arbitrary Precision Floating Point Arithmetic, + in P. Kornerup and D. Matula, Eds., Proc. 10th Symposium on Computer Arithmetic, + IEEE Computer Society Press, Los Alamitos, Calif., 1991.
+ Yozo Hida, Xiaoye S. Li and David H. Bailey, + Quad-Double Arithmetic: Algorithms, Implementation, and Application, + manuscript, Oct 2000; Lawrence Berkeley National Laboratory Report BNL-46996.
+ David Bailey, High Precision Software Directory; + http://crd.lbl.gov/~dhbailey/mpdist/index.html
+
-
+
If this value is NaN, returns NaN.
+
-
+
If this value is NaN, returns NaN.
+
-
+
if this value is > 0, returns 1
+ if this value is < 0, returns -1
+ if this value is = 0, returns 0
+ if this value is NaN, returns 0
+
-
+
If this value is NaN, returns NaN.
+
-
+
If this value is NaN, returns NaN.
+
-
+
if this value is NaN, it is returned.
+
+ or
+ [+|-] {digit} [ . {digit} ] [ ( e | E ) [+|-] {digit}+
+
+ -
+
If the argument is NaN or less than zero, then the result is NaN.
+ If the argument is positive infinity, then the result is positive infinity.
+ If the argument is positive zero or negative zero, then the result is negative infinity.
+
or
+ The distance is: +
-
+
positive if the point lies above the plane (relative to the plane normal)
+ zero if the point is on the plane
+ negative if the point lies below the plane (relative to the plane normal)
+
+ sum = frac * this + (1 - frac) * v ++
-
+
Proper intersections between segments (i.e. the intersection is interior to both segments)
+ Intersections at an interior vertex (i.e. with an endpoint or another interior vertex)
+
+ Note that some clients (such as
+ Note that some clients (such as
-
+
Interior intersections which lie in the interior of a segment + (with another segment interior or with a vertex or endpoint)
+ Vertex intersections which occur at vertices in the interior of s + (with a segment string endpoint or with another interior vertex)
+
+ Note that some clients (such as
+ or
+ 0 the two objects are equal;
+ 1 this one is greater. +
+ 0 this SegmentNode is at the argument location;
+ 1 this SegmentNode is located after the argument location. +
+ 0 if the two nodes are equal, or
+ 1 if node1 occurs first. +
-
+
the only intersection between any two linestrings occurs at their endpoints.
+
+ The
+ The
+ If the point has been added already, it is marked as a node. +
KNOWN BUGS
+ This implementation is not fully robust. + instead. +-
+
CoordinateSequenceFactory A factory to create coordinate sequences
+ PrecisionModel A precision model
+ int spatial reference id (srid)
+ GeometryOverlay A class that bundles an overlay operation function set
+ CoordinateEqualityComparer A class that performs checks s for equality.
+
+ No
+ The
+ No
+ The default precision model is defined by
+ The
+ A value of
+ The default precision model is defined by
+ The
+ No
+ The default coordinate sequence factory is defined by
+ The
+ The semantics are: +
-
+
Empty geometries do not have boundaries.
+ Points do not have boundaries.
+ For linear geometries the existence of the boundary + is determined by the .
+ Non-empty polygons always have a boundary.
+
+ This happens at buffer distances slightly greater than the distance at + which the buffer should disappear.
+ The inverted curve will produce an incorrect non-empty buffer (for a shell) + or an incorrect hole (for a hole). + It must be discarded from the set of offset curves used in the buffer. + Heuristics are used to reduce the number of cases which area checked, + for efficiency and correctness. +
+ or
-
+
- the usual round end caps
+ - end caps are truncated flat at the line ends
+ - end caps are squared off at the buffer distance beyond the line ends
+
-
+
- the usual round join
+ - corners are "sharp" (up to a distance limit})
+ - corners are beveled (clipped off)
+
-
+
Quadrant segments (accuracy of approximation for circular arcs)
+ End Cap style
+ Join style
+ Mitre limit
+ whether the buffer is single-sided
+
+ A value of 8 gives less than 2% max error in the buffer distance.
+ A value of 8 gives less than 2% max error in the buffer distance.
+ The default value of 8 gives less than 2% error in the buffer distance.
-
+
a positive distance indicates the left-hand side
+ a negative distance indicates the right-hand side
+
-
+
For self-intersecting lines, the buffer boundary includes + offset lines for both left and right sides of the input line. + Only a single contiguous portion on the specified side is returned.
+ If the offset corresponds to buffer holes, only the largest hole is used.
+
+ or
-
+
the distance is zero
+ the distance is negative, except for the case of singled-sided buffers
+
+ or
+ or
+ This happens at buffer distances slightly greater than the distance at + which the buffer should disappear.
+ The inverted curve will produce an incorrect non-empty buffer (for a shell) + or an incorrect hole (for a hole). + It must be discarded from the set of offset curves used in the buffer. + Heuristics are used to reduce the number of cases which area checked, + for efficiency and correctness. +
-
+
A closingSegFactor of 0 results in lines to the corner vertex
+ A closingSegFactor of 1 results in lines halfway to the corner vertex
+ A closingSegFactor of 80 results in lines 1/81 of the way to the corner vertex + (this option is reasonable for the very common default situation of round joins + and quadrantSegs >= 8)
+
+ This is chosen to be a small fraction of the offset distance. +
+ In some cases (particularly for round joins with default-or-better + quantization) the closing segments can be made quite short. + This substantially improves performance (due to fewer intersections being created). +
+ A closingSegFactor of 0 results in lines to the corner vertex
+ A closingSegFactor of 1 results in lines halfway to the corner vertex
+ A closingSegFactor of 80 results in lines 1/81 of the way to the corner vertex + (this option is reasonable for the very common default situation of round joins + and quadrantSegs >= 8) +
-
+
-1 if DS1.seg is left of or below DS2.seg (DS1 < DS2).
+ 1 if DS1.seg is right of or above DS2.seg (DS1 > DS2).
+ 0 if the segments are identical
+
-
+
The logic does not obey the contract. + This is acceptable for the intended usage, but may cause problems if used with some + utilities in the .Net standard library (e.g. .
+
+ or
+ or
+ or
-
+
a base point for the plane is determined from the average of all vertices
+ the normal vector is determined by computing the area of the projections on each of the axis planes
+
+ If the sequence lies in a single plane, + the computed point also lies in the plane. +
+ or
-
+
+ Performance is dramatically improved due to the use of the + R-tree index + and the pruning due to the Branch-and-Bound approach + + The spatial index on the target geometry is cached + which allow reuse in an repeated query situation.
+
-
+
+ A Geometry is simple if and only if the only self-intersections are at boundary points. +
+
-
+
Valid geometries are simple by definition, so + IsSimple trivially returns true.
+ (Note: this means that IsSimple cannot be used to test + for (invalid) self-intersections in Polygons. + In order to check if a Polygonal geometry has self-intersections, + use).
+ geometries are simple if and only if they do not self-intersect at interior points + (i.e. points other than boundary points). + This is equivalent to saying that no two linear components satisfy the SFS + predicate.
+ Zero-dimensional ( ) geometries are simple if and only if they have no + repeated points.
+ Empty s are always simple by definition.
+
-
+
Vector-clean Line segments within the collection + must either be identical or intersect only at endpoints.
+ Non-overlapping No two polygons + may overlap. Equivalently, polygons must be interior-disjoint.
+
+ Merged edges can occur in the following situations +
-
+
Due to coincident edges of polygonal or linear geometries.
+ Due to topology collapse caused by snapping or rounding + of polygonal geometries.
+
-
+
If the edge is not part of the input, the label is left as
+ If input is an Area and the edge is on the boundary (which may include some collapses), edge is marked as an edge and side locations are assigned
+ If input is an Area and the edge is collapsed (depth delta = 0), the label is set to . The location will be determined later by evaluating the final graph topology.
+ If input is a Line edge is set to a edge. For line edges the line location is not significant (since there is no parent area for which to determine location).
+
-
+
Coincident edges from different input geometries have their labels combined
+ Coincident edges from the same area geometry indicate a topology collapse. + In this case the topology locations are "summed" to provide a final + assignment of side location
+ Coincident edges from the same linear geometry can simply be merged + using the same ON location
+
-
+
Extracts input edges, and attaches topological information
+ if clipping is enabled, handles clipping or limiting input geometry
+ chooses a based on provided precision model, unless a custom one is supplied
+ calls the chosen Noder, with precision model
+ removes any fully collapsed noded edges
+ builds s and merges them
+
+ This is one of: +
-
+
Fixed precision: a snap-rounding noder (which should be fully robust)
+ Floating precision: a conventional noder (which may be non-robust). + In this case, a validation step is applied to the output from the noder.
+
+ True provides the original JTS semantics. +
-
+
Linework is fully noded
+ Lines are as long as possible between nodes
+
+ True provides the original JTS semantics. +
+ True provides the original JTS semantics. +
-
+
they belong to an area (i.e.they have sides)
+ they are marked as being in the result
+
+ - This edge is in the result
+ - This edge is not yet linked
+ - The edge and its sym are NOT both marked as being in the result +
+
+ The label must be interpreted accordingly. +
+ If the origin vertex has degree 1 then this is the edge itself. +
+ The shell is the ring itself if it is not a hole, otherwise its parent shell. +
+ ring A contains ring B if envelope(ring A) contains envelope(ring B) +
+ This routine is only safe to use if the chosen point of the hole + is known to be properly contained in a shell + (which is guaranteed to be the case if the hole does not touch its shell) +
+ The other edges around the node can be found by following the next and prev links. +
+ Only valid edges can be added (in particular, zero-length segments cannot be added) +
-
+
A Boundary edge of an Area (polygon) + +-
+
dim = DIM_BOUNDARY
+ locLeft, locRight : the locations of the edge sides for the Area
+ locLine : INTERIOR
+ isHole : whether the edge is in a shell or a hole (the ring role)
+
+ A Collapsed edge of an input Area + (formed by merging two or more parent edges) + +-
+
dim = DIM_COLLAPSE
+ locLine : the location of the edge relative to the effective input Area + (a collapsed spike is EXTERIOR, a collapsed gore or hole is INTERIOR)
+ isHole :true if all parent edges are in holes; +false if some parent edge is in a shell
+
+
+ A Line edge from an input line + +-
+
dim = DIM_LINE
+ locLine : the location of the edge relative to the Line. + Initialized to LOC_UNKNOWN to simplify logic.
+
+ An edge which is Not Part of an input geometry + (and thus must be part of the other geometry). + +-
+
dim = NOT_PART
+
+
-
+
an edge cannot be both a Collapse edge and a Line edge in the same input geometry, + because each input geometry must be homogeneous.
+ an edge may be an Boundary edge in one input geometry + and a Line or Collapse edge in the other input.
+
+ This is used to set the locations for linear edges + encountered during area label propagation. +
+ They can be now located based on their parent ring role(shell or hole). + (This cannot be done earlier, because the location + based on the boundary edges must take precedence.
+ There are situations where a collapsed edge has a location + which is different to its ring role - + e.g.a narrow gore in a polygon, which is in + the interior of the reduced polygon, but whose + ring role would imply the location EXTERIOR.) +
+ This must be because they are NOT_PART edges for that geometry, + and are disconnected from any edges of that geometry. + An example of this is rings of one geometry wholly contained + in another geometry.
+ The location must be fully determined to compute a + correct result for all overlay operations. +
-
+
Duplicates are removed from Point output
+ Non-point output is rounded and noded using the given precision model
+
-
+
An empty result is an empty atomic geometry + with dimension determined by the inputs and the operation as per overlay semantics +
+
-
+
Input points are not included in the noding of the non-point input geometry + (in particular, they do not participate in snap-rounding if that is used).
+ If the non-point input geometry is not included in the output + it is not rounded and noded.This means that points + are compared to the non-rounded geometry. + This will be apparent in the result.
+
-
+
all points which lie in both geometries
+ all points which lie in at least one geometry
+ all points which lie in the first geometry but not the second
+ all points which lie in one geometry but not both
+
-
+
Lines and Points resulting from topology collapses are not included in the result
+ Result geometry is homogeneous + for the and operations.
+ Result geometry is homogeneous + for the and operations + if the inputs have the same dimension
+
-
+
Results are simpler
+ Overlay operations are easily chainable + without needing to remove lower-dimension elements
+
+ - An Intersection result can be mixed-dimension, + due to inclusion of intersection components of all dimensions
+ - Results can include lines caused by Area topology collapse +
-
+
For + a snap-rounding noder is used, and the computation is robust.
+ For + a non-snapping noder is used, + and this computation may not be robust. + If errors occur a is thrown.
+
-
+
For + a snap - rounding noder is used, and the computation is robust.
+ For a non - snapping noder is used, + and this computation may not be robust.
+ If errors occur a
-
+
Lines resulting from topology collapse are not included
+ Result geometry is homogeneous for the + and + operations.
+ Result geometry is homogeneous for the + and + operations if the inputs have the same dimension
+
-
+
A simple fast noder using precision
+ A using an automatically-determined snap tolerance
+ First snapping each geometry to itself, and then overlaying them wih a
+ The above two strategies are repeated with increasing snap tolerance, up to a limit
+ Finally a is used with a automatically-determined scale factor.
+
-
+
Points are rounded to the precision model if provided
+ Points with identical XY values are merged to a single point
+ Extended ordinate values are preserved in the output, apart from merging
+ An empty result is returned as POINT EMPTY
+
-
+
result envelope is the intersection of the input envelopes
+ result envelope is the envelope of the A input geometry
+
-
+
result has the dimension of the lowest input dimension
+ result has the dimension of the highest input dimension
+ result has the dimension of the left-hand input
+ result has the dimension of the highest input dimension + (since the Symmetric Difference is the Union of the Differences).
+
+ (e.g. ) +
-
+
it is faster than using a point-in-polygon check later on.
+ it ensures correctness, since if the PIP test was used the point + chosen might lie on the shell, which might return an incorrect result from the + PIP test
+
+ The input geometry must be polygonal or linear. +
+ num = round( num, inherentScale(num) )
+
+ + For unary union using floating precision, +
-
+
- result has the dimension of the lowest input dimension
+ - result has the dimension of the highest input dimension
+ - result has the dimension of the left-hand input
+ - result has the dimension of the highest input dimension + (since symDifference is the union of the differences).
+
or +
or +
+ or -1 if no segment snaps to the snap point.
+ or
-
+
ring A contains ring B if envelope(ring A) contains envelope(ring B)
+
-
+
Dangles edges which have one or both ends which are not incident on another edge endpoint
+ edges which are connected at both ends but which do not form part of polygon
+ edges which form rings which are invalid + (e.g. the component lines contain a self-intersection) +
+ or
+ The class supports specifying a custom
Algorithm
+ The overlap region is determined as the common envelope of intersection. + The input polygons are partitioned into two sets: +-
+
Overlapping Polygons which intersect the overlap region, and thus potentially overlap each other
+ Disjoint Polygons which are disjoint from (lie wholly outside) the overlap region
+
Discussion
+ In general the Overlapping set of polygons will + extend beyond the overlap envelope. This means that the union result + will extend beyond the overlap region. + There is a small chance that the topological + union of the overlap region will shift the result linework enough + that the result geometry intersects one of the Disjoint geometries. + This situation is detected and if it occurs + is remedied by falling back to performing a full union of the original inputs. + Detection is done by a fairly efficient comparison of edge segments which + extend beyond the overlap region. If any segments have changed + then there is a risk of introduced intersections, and full union is performed. +-
+
Unioning a set of s has the effect of merging the areas (i.e. the same effect as iteratively unioning all individual polygons together).
+ Unioning a set of s has the effect of fully noding + and dissolving the input linework. + In this context "fully noded" means that there will be + an endpoint or node in the result + for every endpoint or line segment crossing in the input. + "Dissolved" means that any duplicate (e.g. coincident) line segments or portions + of line segments will be reduced to a single line segment in the output. + This is consistent with the semantics of the + operation. + If merged linework is required, the class can be used.
+ Unioning a set of s has the effect of merging all identical points (producing a set with no duplicates).
-
+
If the input is empty and a dimension can be + determined (i.e. an empty geometry is present), + an empty atomic geometry of that dimension is returned.
+ If no input geometries were provided but a was provided, + an empty is returned.
+ Otherwise, the return value is null .
+
-
+
Point geometries are simple.
+ MultiPoint geometries are simple if every point is unique
+ LineString geometries are simple if they do not self-intersect at interior points + (i.e.points other than the endpoints).
+ MultiLineString geometries are simple if + their elements are simple and they intersect only at points + which are boundary points of both elements. + (The notion of boundary points can be user-specified - see below).
+ Polygonal geometries have no definition of simplicity. + The IsSimple code checks if all polygon rings are simple. + (Note: this means thatIsSimple cannot be used to test + for all self-intersections in Polygon s. + In order to check if a IPolygonal geometry has self-intersections, + use.
+ GeometryCollection geometries are simple if all their elements are simple.
+ Empty geometries are simple
+
-
+
the shell ring self-touches to create a hole touching the shell
+ a hole ring self-touches to create two holes touching at a point
+
-
+
exverted ("bow-tie") shells which self-touch at a single point
+ inverted shells with the inversion touching the shell at another point
+ exverted holes with exversion touching the hole at another point
+ inverted ("C-shaped") holes which self-touch at a single point causing an island to be formed
+ inverted shells or exverted holes which form part of a chain of touching rings + (which disconnect the interior)
+
+ - The shell ring self-touches to create a hole touching the shell.
+ - A hole ring self-touches to create two holes touching at a point.
+
+ Almost anything goes for
+
+
+
+
-
+
shells do not partially overlap
+ shells do not touch along an edge
+ no duplicate rings exist
-
+
The segment intersects the ring only at the endpoints
+ One, none or both of the segment endpoints may lie on the ring
+ The ring does not self-cross, but it may self-touch
+
-
+
The segment does not intersect the ring other than at the endpoints
+ The segment vertex p0 lies on the ring
+ The ring does not self-cross, but it may self-touch
+
+ If true, the disconnection location is available from +
+
+ or
Topological Precision Reduction
+ The default mode of operation ensures the reduced result is topologically valid + (i.e.Pointwise Precision Reduction
+ Alternatively, geometry can be reduced pointwise by using {@link #setPointwise(boolean)}. + Linear and point geometry are always reduced pointwise(i.e.without further change to + topology or structure), since this does not change validity. + Invalid inputs are allowed. + Duplicate vertices are preserved. + Collapsed components are always included in the result. + The result geometry may be invalid. +-
+
No two distinct vertices of G are closer than r.
+ No vertex of G is closer than r to an edge of G of which the vertex is not an endpoint
+
References
+-
+
[Mi88] Milenkovic, V. J., + Verifiable implementations of geometric algorithms + using finite precision arithmetic. + in Artificial Intelligence, 377-401. 1988
+ [TV06] Thompson, Rod and van Oosterom, Peter, + Interchange of Spatial Data-Inhibiting Factors, + Agile 2006, Visegrad, Hungary. 2006
+
+ or
+ or
+ or
+ dist(p1, p2) =
+ p1 != p2 : p1.distance(p2)
+ p1 == p2 : Double.MAX
+
+ dist(p, seg) =
+ p != seq.p1 && p != seg.p2
+ ? seg.distance(p)
+ : Double.MaxValue
+
+ Also computes the values of the nearest points, if any.
+ + Repeated points are removed. + If geometry elements collapse below their valid length, + they may be removed + by specifying
2 * npts - 2).
+ 2 * npts - 2).
+ -
+
valid topology is not required
+ fixing topology is a relative expensive operation
+ in some pathological cases the topology fixing operation may either fail or run for too long
+
+ If the input is empty or is not polygonal, + this ensures that POLYGON EMPTY is returned. +
+ Points closer than this tolerance to a simplified segment may + be removed. +
-
+
The result has the same number of shells and holes as the input, + with the same topological structure
+ The result rings touch at no more than the number of touching points in the input + (although they may touch at fewer points). + The key implication of this statement is that if the + input is topologically valid, so is the simplified output.
+
KNOWN BUGS
+-
+
May create invalid topology if there are components which are small + relative to the tolerance value. + In particular, if a small hole is very near an edge, + it is possible for the edge to be moved by a relatively large tolerance value + and end up with the hole outside the result shell (or inside another hole). + Similarly, it is possible for a small polygon component to end up inside + a nearby larger polygon. + A workaround is to test for this situation in post-processing and remove + any invalid holes or polygons.
+
+ Points closer than this tolerance to a simplified segment may + be removed. +
+ ConformingDelaunayTriangulator cdt = new ConformingDelaunayTriangulator(sites, tolerance);
+
+ // optional
+ cdt.SplitPointFinder = splitPointFinder;
+ cdt.VertexFactory = vertexFactory;
+
+ cdt.SetConstraints(segments, new List<Vertex>(vertexMap.Values));
+ cdt.FormInitialDelaunay();
+ cdt.EnforceConstraints();
+ subdiv = cdt.Subdivision;
+
+ -
+
- The projection of the encroaching point on the segment +
- A point on the segment which will produce two segments which will not be further encroached +
- The point on the segment which is the same distance from an endpoint as the encroaching + point +
+ or null if no such triangle exists +
+ or
+ or -1 if the edge is not an edge of this triangle +
+ or -1 if the vertex is not in the triangle +
+ LINESTRING (1507029.9878 518325.7547, 1507022.1120341457 518332.8225183258, + 1507029.9833 518325.7458, 1507029.9896965567 518325.744909031) ++
+ The set of Tris containing boundary edges are called the triangulation border. +
+ The vertices of the adjacent triangles are + assumed to match the appropriate vertices in this triangle. +
+ The vertices of the adjacent triangles are + assumed to match the appropriate vertices in this triangle. +
+ The vertices of the adjacent triangle are + assumed to match the appropriate vertices in this triangle. +
-
+
opp0-adj0 edge
+ opp0-adj1 edge
+ opp1-adj0 edge
+ opp1-adj1 edge
+
-
+
-
+
an envelope supplied by +.
+ -
+
an envelope determined by the input sites. +
+
-
+
null if the list is null or empty
+ [0] if the list contains one single item.
+ a ifis a GeometryCollection.
+ a Multi-geometry in all other cases.
+
-
+
null if the list is null or empty
+ [0] if the list contains one single item.
+ a ifis a GeometryCollection.
+ a Multi-geometry in all other cases.
+
+ StreamTokenizer tokenizer = new StreamTokenizer();
+ tokenizer.GrabWhitespace = true;
+ tokenizer.Verbosity = VerbosityLevel.Debug; // just for debugging
+ tokenizer.TextReader = File.OpenText(fileName);
+ Token token;
+ while (tokenizer.NextToken(out token)) log.Info("Token = '{0}'", token);
+
+
+ StreamTokenizer tokenizer = new StreamTokenizer("some string");
+ ArrayList tokens = new ArrayList();
+ if (!tokenizer.Tokenize(tokens))
+ {
+ // error handling
+ }
+ foreach (Token t in tokens) Console.WriteLine("t = {0}", t);
+
+ + This function checks the following: +
-
+
-
+
Check for a codepage file (CPG) and read the encoding from its content. +
+ -
+
Try to get an encoding based on the language driver id. +
+ This is based on the code pages listed in the ArcGIS v11.5, ArcPad Reference Guide + http://downloads.esri.com/support/documentation/pad_/ArcPad_RefGuide_1105.pdf +
+ Use the default encoding.
+
-
+
,
+ ,
+ ,
+
+ foreach(object obj in shpDataReader)
+ {
+ if (obj.GetType().Name!="RowStructure")
+ {
+ // this proves the type returned by shpDataReader
+ }
+ }
+
+ -
+
- For LineStrings with only one point provided, duplicate that point to have at least two points. +
- For LinearRings with unclosed coordinate sequence, close the sequence by adding a clone of the first coordinate +
- ... +
- For Holes in polygon, use +
Tracks how many words (1 word = 2 bytes) we have read and that we do not over read. +
Tracks how many words (1 word = 2 bytes) we have read and than we do not over read. +
-
+
-
+
-
+
,
+ ,
+ ,
+ ,
+
-
+
,
+ ,
+ ,
+ ,
+
+ Do not throw an exception! +
-
+ ///
Shell Clockwise, Shapefile's left-hand-rule
+ /// Hole Counter-Clockwise, Shapefile's right-hand-rule
+ ///
-
+ ///
- Considering all rings as a potential shell, search the valid holes for any possible shell. + ///
- Check if the ring is inside any shell: if
true , it can be considered a potential hole for the shell.
+ /// - Check if the ring is inside any hole of the shell: if
true , this means that is actually a shell of a distinct geometry, + /// and NOT a valid hole for the shell; a hole inside another hole is not allowed.
+ ///