Coordinate with which this Coordinate is being compared return
- * -1, zero, or 1 as this Coordinate is less than, equal to, or greater than the
- * specified Coordinate
+ * -1, zero, or 1 as this Coordinate is less than, equal to, or greater than the
+ * specified Coordinate
*/
override def compareTo(o: Coordinate): Int = {
val other = o.asInstanceOf[Coordinate]
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateArrays.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateArrays.scala
index 40f8eecf..64e2c189 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateArrays.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateArrays.scala
@@ -169,9 +169,9 @@ object CoordinateArrays {
* Finds a point in a list of points which is not contained in another list of points
*
* @param testPts
- * the { @link Coordinate}s to test
+ * the {@link Coordinate} s to test
* @param pts
- * an array of { @link Coordinate}s to test the input points against return a { @link
+ * an array of {@link Coordinate} s to test the input points against return a { @link
* Coordinate} from testPts which is not in pts, ' or
* null
*/
@@ -514,8 +514,8 @@ object CoordinateArrays {
/**
* Shifts the positions of the coordinates until the coordinate at
- * indexOfFirstCoordinate is first. If {@code ensureRing} is {@code true}, first
- * and last coordinate of the returned array are equal.
+ * indexOfFirstCoordinate is first. If {@code ensureRing} is {@code true} ,
+ * first and last coordinate of the returned array are equal.
*
* @param coordinates
* the array to rearrange
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequence.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequence.scala
index eea8ed3a..8c7a8391 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequence.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequence.scala
@@ -92,7 +92,7 @@ trait CoordinateSequence extends Cloneable {
* Checks {link #getDimension()} and {link #getMeasures()} to determine if {link #getZ(int)} is
* supported.
*
- * return true if { @link #getZ(int)} is supported.
+ * return true if {@link #getZ(int)} is supported.
*/
def hasZ: Boolean = (getDimension - getMeasures) > 2
@@ -101,7 +101,7 @@ trait CoordinateSequence extends Cloneable {
* if {link #getMeasures()} > 0. See {link #getMeasures()} to determine the number of measures
* present.
*
- * return true if { @link #getM(int)} is supported.
+ * return true if {@link #getM(int)} is supported.
* @see
* #getMeasures()
* @see
@@ -147,7 +147,7 @@ trait CoordinateSequence extends Cloneable {
* @param index
* the index of the coordinate to copy
* @param coord
- * a { @link Coordinate} to receive the value
+ * a {@link Coordinate} to receive the value
*/
def getCoordinate(index: Int, coord: Coordinate): Unit
@@ -243,7 +243,7 @@ trait CoordinateSequence extends Cloneable {
*
* return a copy of the coordinate sequence containing copies of all points
* @deprecated
- * Recommend { @link #copy()}
+ * Recommend {@link #copy()}
*/
protected def clone: Object
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequenceComparator.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequenceComparator.scala
index 16000907..e45adb39 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequenceComparator.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequenceComparator.scala
@@ -74,9 +74,9 @@ class CoordinateSequenceComparator(dimensionLimit: Int = Int.MaxValue)
* Compares two {link CoordinateSequence}s for relative order.
*
* @param o1
- * a { @link CoordinateSequence}
+ * a {@link CoordinateSequence}
* @param o2
- * a { @link CoordinateSequence} return -1, 0, or 1 depending on whether o1 is less than, equal
+ * a {@link CoordinateSequence} return -1, 0, or 1 depending on whether o1 is less than, equal
* to, or greater than o2
*/
override def compare(s1: CoordinateSequence, s2: CoordinateSequence): Int = {
@@ -113,9 +113,9 @@ class CoordinateSequenceComparator(dimensionLimit: Int = Int.MaxValue)
* dimensions.
*
* @param s1
- * a { @link CoordinateSequence}
+ * a {@link CoordinateSequence}
* @param s2
- * a { @link CoordinateSequence}
+ * a {@link CoordinateSequence}
* @param i
* the index of the coordinate to test
* @param dimension
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequences.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequences.scala
index fcd2ea5c..cc05bf16 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequences.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/CoordinateSequences.scala
@@ -292,7 +292,7 @@ object CoordinateSequences {
/**
* Returns the index of the minimum coordinate of a part of the coordinate sequence (defined by
- * {@code from} and {@code to}, using the usual lexicographic comparison.
+ * {@code from} and {@code to} , using the usual lexicographic comparison.
*
* @param seq
* the coordinate sequence to search
@@ -357,7 +357,7 @@ object CoordinateSequences {
* @param indexOfFirstCoordinate
* the index of the coordinate to make first
* @param ensureRing
- * makes sure that { @code } will be a closed ring upon exit
+ * makes sure that {@code} will be a closed ring upon exit
*/
def scroll(seq: CoordinateSequence, indexOfFirstCoordinate: Int, ensureRing: Boolean): Unit = {
val i = indexOfFirstCoordinate
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/Geometry.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/Geometry.scala
index d388d572..87b303c8 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/Geometry.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/Geometry.scala
@@ -299,7 +299,7 @@ abstract class Geometry(
* The returned coordinate should not be assumed to be an actual Coordinate object used in the
* internal representation.
*
- * return a { @link Coordinate} which is a vertex of this Geometry. return null if
+ * return a {@link Coordinate} which is a vertex of this Geometry. return null if
* this Geometry is empty
*/
def getCoordinate: Coordinate
@@ -422,7 +422,7 @@ abstract class Geometry(
* contribute zero "weight" to the centroid). The centroid of an empty geometry is POINT
* EMPTY.
*
- * return a { @link Point} which is the centroid of this Geometry
+ * return a {@link Point} which is the centroid of this Geometry
*/
def getCentroid: Point = {
if (isEmpty) return factory.createPoint
@@ -436,7 +436,7 @@ abstract class Geometry(
* Otherwise, the point may lie on the boundary of the geometry.
The interior point of an
* empty geometry is POINT EMPTY.
*
- * return a { @link Point} which is in the interior of this Geometry
+ * return a {@link Point} which is in the interior of this Geometry
*/
def getInteriorPoint: Point = {
if (isEmpty) return factory.createPoint
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryCollection.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryCollection.scala
index 8cacbf02..9ba1ff03 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryCollection.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryCollection.scala
@@ -272,7 +272,7 @@ class GeometryCollection(
* Creates a {link GeometryCollection} with every component reversed. The order of the components
* in the collection are not reversed.
*
- * return a { @link GeometryCollection} in the reverse order
+ * return a {@link GeometryCollection} in the reverse order
*/
override def reverse: GeometryCollection = super.reverse.asInstanceOf[GeometryCollection]
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryFactory.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryFactory.scala
index 5d761169..f34a0b3b 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryFactory.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/GeometryFactory.scala
@@ -368,7 +368,7 @@ class GeometryFactory(
* an array (without null elements), or an empty array, or null return a MultiPoint
* object
* @deprecated
- * Use { @link GeometryFactory#createMultiPointFromCoords} instead
+ * Use {@link GeometryFactory#createMultiPointFromCoords} instead
*/
def createMultiPoint(coordinates: Array[Coordinate]): MultiPoint = createMultiPoint(
if (coordinates != null) getCoordinateSequenceFactory.create(coordinates)
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/LineSegment.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/LineSegment.scala
index 6e9ed428..f7ab7891 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/LineSegment.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/LineSegment.scala
@@ -128,8 +128,8 @@ class LineSegment(var p0: Coordinate, var p1: Coordinate)
*
* @param seg
* the LineSegment to compare return 1 if seg is to the left of this segment return
- * -1 if seg is to the right of this segment return 0 if seg is
- * collinear to or crosses this segment
+ * -1 if seg is to the right of this segment return 0 if seg is
+ * collinear to or crosses this segment
*/
def orientationIndex(seg: LineSegment): Int = {
val orient0 = Orientation.index(p0, p1, seg.p0)
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/LineString.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/LineString.scala
index c7fbe4ac..14b8433b 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/LineString.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/LineString.scala
@@ -128,7 +128,7 @@ class LineString(fac: GeometryFactory) extends Geometry(fac) with Lineal {
/**
* Creates a {link LineString} whose coordinates are in the reverse order of this objects
*
- * return a { @link LineString} with coordinates in the reverse order
+ * return a {@link LineString} with coordinates in the reverse order
* @deprecated
*/
override def reverse: LineString = super.reverse.asInstanceOf[LineString]
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/MultiLineString.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/MultiLineString.scala
index ea1e4ca6..ab8929ed 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/MultiLineString.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/MultiLineString.scala
@@ -88,7 +88,7 @@ class MultiLineString(lineStrings: Array[LineString], factory: GeometryFactory)
* Creates a {link MultiLineString} in the reverse order to this object. Both the order of the
* component LineStrings and the order of their coordinate sequences are reversed.
*
- * return a { @link MultiLineString} in the reverse order
+ * return a {@link MultiLineString} in the reverse order
* @deprecated
*/
override def reverse: MultiLineString = super.reverse.asInstanceOf[MultiLineString]
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/impl/PackedCoordinateSequence.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/impl/PackedCoordinateSequence.scala
index cc067fab..4b63bf7e 100644
--- a/modules/jts/src/main/scala/org/locationtech/jts/geom/impl/PackedCoordinateSequence.scala
+++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/impl/PackedCoordinateSequence.scala
@@ -57,9 +57,9 @@ object PackedCoordinateSequence {
* @param coords
* an array of
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 | + * \= 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 | diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryEditor.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryEditor.scala index 1a99c184..83d24e47 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryEditor.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryEditor.scala @@ -201,7 +201,7 @@ class GeometryEditor(var factory: GeometryFactory) { * @param geometry * the Geometry to edit * @param operation - * the edit operation to carry out return a new { @link Geometry} which is the result of the + * the edit operation to carry out return a new {@link Geometry} which is the result of the * editing (which may be empty) */ def edit(geometry: Geometry, operation: GeometryEditor.GeometryEditorOperation): Geometry = { // nothing to do diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryExtracter.scala b/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryExtracter.scala index a73b42bb..ad3cf478 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryExtracter.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/geom/util/GeometryExtracter.scala @@ -78,7 +78,7 @@ object GeometryExtracter { /** * Extracts the components of geometryType from a {@link Geometry} and adds them to the - * provided {@link List}. + * provided {@link List} . * * @param geom * the geometry from which to extract diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/EdgeList.scala b/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/EdgeList.scala index be01f047..e725a5a5 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/EdgeList.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/EdgeList.scala @@ -69,8 +69,7 @@ class EdgeList() { /** * If the edge e is already in the list, return its index. * - * return index, if e is already in the list - * -1 otherwise + * return index, if e is already in the list -1 otherwise */ def findEdgeIndex(e: Edge): Int = { var i = 0 diff --git a/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/Quadrant.scala b/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/Quadrant.scala index 0ab9874b..f97dfec7 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/Quadrant.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/geomgraph/Quadrant.scala @@ -19,8 +19,8 @@ package org.locationtech.jts.geom */ /** - * Utility functions for working with quadrants, which are numbered as follows:1 | 0 - * --+-- 2 | 3+ * Utility functions for working with quadrants, which are numbered as follows:1 | 0 --+-- 2 + * \| 3* * @version 1.7 */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNode.scala b/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNode.scala index 73d837de..e77ec00a 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNode.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNode.scala @@ -18,7 +18,7 @@ import org.locationtech.jts.geom.Coordinate */ /** - * A node of a {@link KdTree}, which represents one or more points in the same location. + * A node of a {@link KdTree} , which represents one or more points in the same location. * * @author * dskea diff --git a/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNodeVisitor.scala b/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNodeVisitor.scala index 144b4899..864760cc 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNodeVisitor.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdNodeVisitor.scala @@ -16,7 +16,7 @@ package org.locationtech.jts.index.kdtree */ /** - * A visitor for {@link KdNode}s in a {@link KdTree} index. + * A visitor for {@link KdNode} s in a {@link KdTree} index. * * @version 1.7 */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdTree.scala b/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdTree.scala index 88c1454f..1e14d04f 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdTree.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/index/kdtree/KdTree.scala @@ -39,7 +39,7 @@ import java.util object KdTree { /** - * Converts a collection of {@link KdNode}s to an array of {@link Coordinate}s. + * Converts a collection of {@link KdNode} s to an array of {@link Coordinate} s. * * @param kdnodes * a collection of nodes @@ -49,8 +49,8 @@ object KdTree { def toCoordinates(kdnodes: util.Collection[_]): Array[Coordinate] = toCoordinates(kdnodes, false) /** - * Converts a collection of {@link KdNode}s to an array of {@link Coordinate}s, specifying whether - * repeated nodes should be represented by multiple coordinates. + * Converts a collection of {@link KdNode} s to an array of {@link Coordinate} s, specifying + * whether repeated nodes should be represented by multiple coordinates. * * @param kdnodes * a collection of nodes diff --git a/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/AbstractSTRtree.scala b/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/AbstractSTRtree.scala index f83b3337..9dc2973e 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/AbstractSTRtree.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/AbstractSTRtree.scala @@ -382,7 +382,7 @@ abstract class AbstractSTRtree(var nodeCapacity: Int) /** * @param level - * -1 to get items + * -1 to get items */ private def boundablesAtLevel( level: Int, diff --git a/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/STRtree.scala b/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/STRtree.scala index c949c4bf..ba0a3d85 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/STRtree.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/index/strtree/STRtree.scala @@ -396,7 +396,7 @@ class STRtree(val nodeCapacityArg: Int) } /** - * Finds k items in this tree which are the top k nearest neighbors to the given {@code item}, + * Finds k items in this tree which are the top k nearest neighbors to the given {@code item} , * using {@code itemDist} as the distance metric. A Branch-and-Bound tree traversal algorithm is * used to provide an efficient search. This method implements the KNN algorithm described in the * following paper:Roussopoulos, Nick, Stephen Kelley, and Frédéric Vincent. "Nearest diff --git a/modules/jts/src/main/scala/org/locationtech/jts/io/Ordinate.scala b/modules/jts/src/main/scala/org/locationtech/jts/io/Ordinate.scala index 3d1c9a58..fbd98a08 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/io/Ordinate.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/io/Ordinate.scala @@ -17,8 +17,8 @@ package org.locationtech.jts.io /** * An enumeration of possible Well-Known-Text or Well-Known-Binary ordinates.
Intended to be - * used as an {@code EnumSet
}, optimized create methods have been provided for {@link # - * createXY ( )}, {@link # createXYM ( )}, {@link # createXYZ ( )} and {@link # createXYZM ( )}. + * used as an {@code EnumSet } , optimized create methods have been provided for {@link # + * createXY ( )}, {@link # createXYM ( )} , {@link # createXYZ ( )} and {@link # createXYZM ( )} . */ object Ordinate extends Enumeration { type Ordinate = Value diff --git a/modules/jts/src/main/scala/org/locationtech/jts/io/WKTWriter.scala b/modules/jts/src/main/scala/org/locationtech/jts/io/WKTWriter.scala index f620eb53..210ac43e 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/io/WKTWriter.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/io/WKTWriter.scala @@ -36,7 +36,7 @@ import scala.annotation.nowarn */ /** - * Writes the Well-Known Text representation of a {@link Geometry}. The Well-Known Text format is + * Writes the Well-Known Text representation of a {@link Geometry} . The Well-Known Text format is * defined in the OGC Simple Features * Specification for SQL. See {@link WKTReader} for a formal specification of the format * syntax. The
WKTWriteroutputs coordinates rounded to the precision model. Only @@ -53,7 +53,7 @@ import scala.annotation.nowarn object WKTWriter { /** - * Generates the WKT for a POINT specified by a {@link Coordinate}. + * Generates the WKT for a POINT specified by a {@link Coordinate} . * * @param p0 * the point coordinate @@ -63,7 +63,7 @@ object WKTWriter { def toPoint(p0: Coordinate): String = WKTConstants.POINT + " ( " + format(p0) + " )" /** - * Generates the WKT for a LINESTRING specified by a {@link CoordinateSequence}. + * Generates the WKT for a LINESTRING specified by a {@link CoordinateSequence} . * * @param seq * the sequence to write @@ -87,7 +87,7 @@ object WKTWriter { } /** - * Generates the WKT for a LINESTRING specified by a {@link CoordinateSequence}. + * Generates the WKT for a LINESTRING specified by a {@link CoordinateSequence} . * * @param coord * the sequence to write @@ -111,7 +111,7 @@ object WKTWriter { } /** - * Generates the WKT for a LINESTRING specified by two {@link Coordinate}s. + * Generates the WKT for a LINESTRING specified by two {@link Coordinate} s. * * @param p0 * the first coordinate @@ -174,7 +174,7 @@ object WKTWriter { class WKTWriter(val outputDimension: Int) { /** - * Creates a writer that writes {@link Geometry}s with the given output dimension (2 to 4). The + * Creates a writer that writes {@link Geometry} s with the given output dimension (2 to 4). The * output follows the following rules:
- If the specified output dimension is 3 and * the z is measure flag is set to true, the Z value of coordinates will be written if it * is present (i.e. if it is not
Double.NaN)- If the specified output @@ -232,7 +232,7 @@ class WKTWriter(val outputDimension: Int) { * Gets the evaluated ordinate bit-pattern * * @return - * A bit-pattern of ordinates with valid values masked by {@link # checkOrdinateFlags}. + * A bit-pattern of ordinates with valid values masked by {@link # checkOrdinateFlags} . */ private[io] def getOutputOrdinates = outputOrdinates } @@ -332,7 +332,7 @@ class WKTWriter(val outputDimension: Int) { *
Note: The precision model is applied to all ordinate values, not just x and y.
* * @param precisionModel - * the flag indicating if {@link Coordinate# z}/{} is actually a measure value. + * the flag indicating if {@link Coordinate# z} /{} is actually a measure value. */ def setPrecisionModel(precisionModel: PrecisionModel): Unit = { this.precisionModel = precisionModel @@ -835,7 +835,7 @@ class WKTWriter(val outputDimension: Int) { /** * Appends the i'th coordinate from the sequence to the writerIf the {@code seq} has - * coordinates that are {@link double.NAN}, these are not written, even though {@link # + * coordinates that are {@link double.NAN} , these are not written, even though {@link # * outputDimension} suggests this. * * @param seq diff --git a/modules/jts/src/main/scala/org/locationtech/jts/math/DD.scala b/modules/jts/src/main/scala/org/locationtech/jts/math/DD.scala index 40c5b989..215a1c66 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/math/DD.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/math/DD.scala @@ -37,11 +37,10 @@ import java.io.Serializable *
For example, the following code example constructs three DD instances: two to hold the input * values and one to hold the result of the addition.
DD a = new DD(2.0); DD b = new DD(3.0); * DD c = a.add(b);In contrast, the following approach uses only one object:DD a = - * new DD(2.0); - * a.selfAdd(3.0);This implementation uses algorithms originally designed variously by - * Knuth, Kahan, Dekker, and Linnainmaa. Douglas Priest developed the first C implementation of - * these techniques. Other more recent C++ implementation are due to Keith M. Briggs and David - * Bailey et al. + * new DD(2.0); a.selfAdd(3.0);
This implementation uses algorithms originally designed + * variously by Knuth, Kahan, Dekker, and Linnainmaa. Douglas Priest developed the first C + * implementation of these techniques. Other more recent C++ implementation are due to Keith M. + * Briggs and David Bailey et al. * *
References
- Priest, D., Algorithms for Arbitrary Precision Floating Point * Arithmetic, in P. Kornerup and D. Matula, Eds., Proc. 10th Symposium on Computer Arithmetic, diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/FastNodingValidator.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/FastNodingValidator.scala index 6a5ebb9e..1ac13fa8 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/FastNodingValidator.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/FastNodingValidator.scala @@ -66,7 +66,7 @@ class FastNodingValidator(val segStrings: util.Collection[SegmentString]) { * Creates a new noding validator for a given set of linework. * * @param segStrings - * a collection of { @link SegmentString}s + * a collection of {@link SegmentString} s */ private val li = new RobustLineIntersector private var findAllIntersections = false diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/NodedSegmentString.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/NodedSegmentString.scala index 9b74ffd5..6ecc4ae5 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/NodedSegmentString.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/NodedSegmentString.scala @@ -80,7 +80,7 @@ class NodedSegmentString(val pts: Array[Coordinate], var data: Any) private val nodeList = new SegmentNodeList(this) /** - * Creates a new instance from a {@link SegmentString}. + * Creates a new instance from a {@link SegmentString} . * * @param segString * the segment string to use diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/NodingIntersectionFinder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/NodingIntersectionFinder.scala index 2a485bde..fcd24cea 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/NodingIntersectionFinder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/NodingIntersectionFinder.scala @@ -238,7 +238,7 @@ class NodingIntersectionFinder(var li: LineIntersector) /** * Gets the intersections found. * - * return a List of { @link Coordinate} + * return a List of {@link Coordinate} */ def getIntersections: util.ArrayList[_] = intersections diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/Octant.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/Octant.scala index fa84d586..1bb6d649 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/Octant.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/Octant.scala @@ -18,9 +18,8 @@ import org.locationtech.jts.geom.Coordinate /** * Methods for computing and working with octants of the Cartesian plane Octants are numbered as - * follows:
\2|1/ 3 \|/ 0 - * ---+-- 4 /|\ 7 /5|6\If line segments lie along a coordinate axis, the octant is the lower - * of the two possible values. + * follows:\2|1/ 3 \|/ 0 ---+-- 4 /|\ 7 /5|6\If line segments lie along a coordinate + * axis, the octant is the lower of the two possible values. * * @version 1.7 */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/SegmentExtractingNoder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/SegmentExtractingNoder.scala index 42b09a54..4f344984 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/SegmentExtractingNoder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/SegmentExtractingNoder.scala @@ -22,7 +22,7 @@ import java.util.List import scala.jdk.CollectionConverters._ /** - * A noder which extracts all line segments as {@link SegmentString}s. This enables fast overlay of + * A noder which extracts all line segments as {@link SegmentString} s. This enables fast overlay of * geometries which are known to be already fully noded. In particular, it provides fast union of * polygonal and linear coverages. Unioning a noded set of lines is an effective way to perform line * merging and line dissolving.No precision reduction is carried out. If that is required, diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/SinglePassNoder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/SinglePassNoder.scala index cca61b73..57d66810 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/SinglePassNoder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/SinglePassNoder.scala @@ -45,7 +45,7 @@ abstract class SinglePassNoder[A](var segInt: SegmentIntersector) extends Noder[ * the input SegmentStrings; others may only add some or none at all. * * @param segStrings - * a collection of { @link SegmentString}s to node + * a collection of {@link SegmentString} s to node */ override def computeNodes(segStrings: util.Collection[A]): Unit diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/ValidatingNoder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/ValidatingNoder.scala index ba12db6f..8336191d 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/ValidatingNoder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/ValidatingNoder.scala @@ -6,7 +6,7 @@ package org.locationtech.jts.noding import java.util /** - * A wrapper for {@link Noder}s which validates the output arrangement is correctly noded. An + * A wrapper for {@link Noder} s which validates the output arrangement is correctly noded. An * arrangement of line segments is fully noded if there is no line segment which has another segment * intersecting its interior. If the noding is not correct, a {@link TopologyException} is thrown * with details of the first invalid location found. diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingIntersectionAdder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingIntersectionAdder.scala index 55ef44b1..de11f400 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingIntersectionAdder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingIntersectionAdder.scala @@ -74,7 +74,7 @@ class SnappingIntersectionAdder(var snapTolerance: Double, var snapPointIndex: S /** * This method is called by clients of the {@link SegmentIntersector} class to process - * intersections for two segments of the {@link SegmentString}s being intersected. Note that some + * intersections for two segments of the {@link SegmentString} s being intersected. Note that some * clients (such as
MonotoneChains) may optimize away this call for segment pairs * which they have determined do not intersect (e.g. by an disjoint envelope test). */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingNoder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingNoder.scala index 42165088..95202fc3 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingNoder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/snap/SnappingNoder.scala @@ -59,7 +59,7 @@ import scala.jdk.CollectionConverters._ * of the segment coordinates.With an appropriate snap tolerance this algorithm appears to be * very robust. So far no failure cases have been found, given a small enough snap tolerance.
* The correctness of the output is not verified by this noder. If required this can be done by - * {@link ValidatingNoder}. + * {@link ValidatingNoder} . * * @version 1.17 */ @@ -106,8 +106,8 @@ class SnappingNoder(var snapTolerance: Double) extends Noder[SegmentString] { } /** - * Computes all interior intersections in the collection of {@link SegmentString}s, and returns - * their {@link Coordinate}s. + * Computes all interior intersections in the collection of {@link SegmentString} s, and returns + * their {@link Coordinate} s. * * Also adds the intersection nodes to the segments. * diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/HotPixelIndex.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/HotPixelIndex.scala index 1e78cb03..d7c145c7 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/HotPixelIndex.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/HotPixelIndex.scala @@ -26,8 +26,8 @@ import scala.jdk.CollectionConverters._ */ /** - * An index which creates {@link HotPixel}s for provided points, and allows performing range queries - * on them. + * An index which creates {@link HotPixel} s for provided points, and allows performing range + * queries on them. * * @author * mdavis @@ -133,7 +133,7 @@ class HotPixelIndex(var precModel: PrecisionModel) { object HotPixelIndex { /** - * Utility class to shuffle an array of {@link Coordinate}s using the Fisher-Yates shuffle + * Utility class to shuffle an array of {@link Coordinate} s using the Fisher-Yates shuffle * algorithm * * @see @@ -145,7 +145,7 @@ object HotPixelIndex { * Creates an instance of this class * * @param pts - * An array of {@link Coordinate}s. + * An array of {@link Coordinate} s. */ extends util.Iterator[Coordinate] { final private val rnd = new Random(13) diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/MCIndexPointSnapper.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/MCIndexPointSnapper.scala index 62bc5437..00a77415 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/MCIndexPointSnapper.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/MCIndexPointSnapper.scala @@ -25,8 +25,8 @@ import org.locationtech.jts.noding.SegmentString */ /** - * "Snaps" all {@link SegmentString}s in a {@link SpatialIndex} containing {@link MonotoneChain}s to - * a given {@link HotPixel}. + * "Snaps" all {@link SegmentString} s in a {@link SpatialIndex} containing {@link MonotoneChain} s + * to a given {@link HotPixel} . * * @version 1.7 */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingIntersectionNodder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingIntersectionNodder.scala index ea1a4c3f..4efcb460 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingIntersectionNodder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingIntersectionNodder.scala @@ -78,7 +78,7 @@ class SnapRoundingIntersectionAdder(var precModel: PrecisionModel) /** * This method is called by clients of the {@link SegmentIntersector} class to process - * intersections for two segments of the {@link SegmentString}s being intersected. Note that some + * intersections for two segments of the {@link SegmentString} s being intersected. Note that some * clients (such as
MonotoneChains) may optimize away this call for segment pairs * which they have determined do not intersect (e.g. by an disjoint envelope test). */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingNorder.scala b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingNorder.scala index 46cfdc51..2a4792b1 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingNorder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/noding/snaprounder/SnapRoundingNorder.scala @@ -34,7 +34,7 @@ import scala.jdk.CollectionConverters._ * SegmentString}s, in a performant way, and avoiding unnecessary noding.Implements the Snap * Rounding technique described in the papers by Hobby, Guibas & Marimont, and Goodrich et al. * Snap Rounding enforces that all output vertices lie on a uniform grid, which is determined by the - * provided {@link PrecisionModel}.
Input vertices do not have to be rounded to the grid + * provided {@link PrecisionModel} .
Input vertices do not have to be rounded to the grid * beforehand; this is done during the snap-rounding process. In fact, rounding cannot be done a * priori, since rounding vertices by themselves can distort the rounded topology of the arrangement * (i.e. by moving segments away from hot pixels that would otherwise intersect them, or by moving @@ -42,7 +42,7 @@ import scala.jdk.CollectionConverters._ * Noder avoids creating nodes at edge vertices if there is no intersection or snap at that * location. However, if two different input edges contain identical segments, each of the segment * vertices will be noded. This still provides fully-noded output. This is the same behaviour - * provided by other noders, such as {@link MCIndexNoder} and {@link SnappingNoder}. + * provided by other noders, such as {@link MCIndexNoder} and {@link SnappingNoder} . * * @version 1.7 */ @@ -85,7 +85,7 @@ class SnapRoundingNoder(val pm: PrecisionModel) extends Noder[SegmentString] { } /** - * Detects interior intersections in the collection of {@link SegmentString}s, and adds nodes for + * Detects interior intersections in the collection of {@link SegmentString} s, and adds nodes for * them to the segment strings. Also creates HotPixel nodes for the intersection points. * * @param segStrings diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.scala index 05a88a60..1eec4fc3 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.scala @@ -98,7 +98,7 @@ class OffsetCurveBuilder(var precisionModel: PrecisionModel, var bufParams: Buff * @param inputPts * the coordinates of the ring (must not contain repeated points) * @param side - * side the side { @link Position} of the ring on which to construct the buffer line + * side the side {@link Position} of the ring on which to construct the buffer line * @param distance * the positive distance at which to create the offset return a Coordinate array representing * the curve, or null if the curve is empty diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveSetBuilder.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveSetBuilder.scala index a6d949b6..257df14d 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveSetBuilder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/OffsetCurveSetBuilder.scala @@ -193,7 +193,7 @@ class OffsetCurveSetBuilder( * @param offsetDistance * the positive distance at which to create the buffer * @param side - * the side { @link Position} of the ring on which to construct the buffer line + * the side {@link Position} of the ring on which to construct the buffer line * @param cwLeftLoc * the location on the L side of the ring (if it is CW) * @param cwRightLoc diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/SubgraphDepthLocater.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/SubgraphDepthLocater.scala index ff4d2c46..bcd51887 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/SubgraphDepthLocater.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/buffer/SubgraphDepthLocater.scala @@ -114,8 +114,8 @@ class SubgraphDepthLocater(var subgraphs: util.Collection[BufferSubgraph]) { * to the right of stabbingRayLeftPt. * * @param stabbingRayLeftPt - * the left-hand origin of the stabbing line return a List of { @link DepthSegments} - * intersecting the stabbing line + * the left-hand origin of the stabbing line return a List of {@link DepthSegments} intersecting + * the stabbing line */ private def findStabbedSegments(stabbingRayLeftPt: Coordinate): util.List[DepthSegment] = { val stabbedSegments = new util.ArrayList[DepthSegment] @@ -138,7 +138,7 @@ class SubgraphDepthLocater(var subgraphs: util.Collection[BufferSubgraph]) { * @param stabbingRayLeftPt * the left-hand origin of the stabbing line * @param stabbedSegments - * the current list of { @link DepthSegments} intersecting the stabbing line + * the current list of {@link DepthSegments} intersecting the stabbing line */ private def findStabbedSegments( stabbingRayLeftPt: Coordinate, @@ -166,7 +166,7 @@ class SubgraphDepthLocater(var subgraphs: util.Collection[BufferSubgraph]) { * @param stabbingRayLeftPt * the left-hand origin of the stabbing line * @param stabbedSegments - * the current list of { @link DepthSegments} intersecting the stabbing line + * the current list of {@link DepthSegments} intersecting the stabbing line */ private def findStabbedSegments( stabbingRayLeftPt: Coordinate, diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/DistanceOp.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/DistanceOp.scala index f0169329..89711f0a 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/DistanceOp.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/DistanceOp.scala @@ -31,7 +31,7 @@ import org.locationtech.jts.geom.util.PolygonExtracter import java.util /** - * Find two points on two {@link Geometry}s which lie within a given distance, or else are the + * Find two points on two {@link Geometry} s which lie within a given distance, or else are the * nearest points on the geometries (in which case this also provides the distance between the * geometries).
The distance computation also finds a pair of points in the input geometries * which have the minimum distance between them. If a point lies in the interior of a line segment, @@ -171,7 +171,7 @@ class DistanceOp(val g0: Geometry, val g1: Geometry, val terminateDistance: Doub * in the same order as the input Geometries. * * @return - * a pair of {@link Coordinate}s of the nearest points + * a pair of {@link Coordinate} s of the nearest points */ def nearestPoints: Array[Coordinate] = { computeMinDistance() @@ -182,7 +182,7 @@ class DistanceOp(val g0: Geometry, val g1: Geometry, val terminateDistance: Doub /** * @return - * a pair of {@link Coordinate}s of the nearest points + * a pair of {@link Coordinate} s of the nearest points * @deprecated * renamed to nearestPoints */ @@ -194,7 +194,7 @@ class DistanceOp(val g0: Geometry, val g1: Geometry, val terminateDistance: Doub * in the same order as the input Geometries. * * @return - * a pair of {@link GeometryLocation}s for the nearest points + * a pair of {@link GeometryLocation} s for the nearest points */ def nearestLocations: Array[GeometryLocation] = { computeMinDistance() @@ -203,7 +203,7 @@ class DistanceOp(val g0: Geometry, val g1: Geometry, val terminateDistance: Doub /** * @return - * a pair of {@link GeometryLocation}s for the nearest points + * a pair of {@link GeometryLocation} s for the nearest points * @deprecated * renamed to nearestLocations */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/FacetSequence.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/FacetSequence.scala index f36834a2..c24f2b21 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/FacetSequence.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/distance/FacetSequence.scala @@ -139,7 +139,7 @@ class FacetSequence(val geom: Geometry, val pts: CoordinateSequence, val start: * Computes the locations of the nearest points between this sequence and another sequence. The * locations are presented in the same order as the input sequences. * - * return a pair of { @link GeometryLocation}s for the nearest points + * return a pair of {@link GeometryLocation} s for the nearest points */ def nearestLocations(facetSeq: FacetSequence): Array[GeometryLocation] = { val visPoint = isPoint diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/CoverageUnion.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/CoverageUnion.scala index a5b5fb6c..a7e22d49 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/CoverageUnion.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/CoverageUnion.scala @@ -19,11 +19,11 @@ import org.locationtech.jts.noding.SegmentExtractingNoder /** * Unions a valid coverage of polygons or lines in an efficient way.
A valid polygonal coverage - * is a collection of {@link Polygon}s which satisfy the following conditions:
+ * is a collection of {@link Polygon} s which satisfy the following conditions:
*
- 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.
A valid linear coverage is a - * collection of {@link LineString}s which satisfies the Vector-clean condition. Note that + * collection of {@link LineString} s which satisfies the Vector-clean condition. Note that * this does not require the LineStrings to be fully noded * - i.e. they may contain coincident linework. Coincident line segments are dissolved by the * union. Currently linear output is not merged (this may be added in a future release.)
diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeNodingBuilder.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeNodingBuilder.scala index 527dfbde..5c0c7b47 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeNodingBuilder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeNodingBuilder.scala @@ -45,7 +45,7 @@ import scala.jdk.CollectionConverters._ * performs the following steps:
* * @author @@ -203,7 +203,7 @@ class EdgeNodingBuilder(var pm: PrecisionModel, var customNoder: Noder[SegmentSt } /** - * Nodes a set of segment strings and creates {@link Edge}s from the result. The input segment + * Nodes a set of segment strings and creates {@link Edge} s from the result. The input segment * strings each carry a {@link EdgeSourceInfo} object, which is used to provide source topology * info to the constructed Edges (and is then discarded). * diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeSourceInfo.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeSourceInfo.scala index 57cb0606..5d243d8d 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeSourceInfo.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/EdgeSourceInfo.scala @@ -21,8 +21,8 @@ import org.locationtech.jts.geom.Dimension * Records topological information about an edge representing a piece of linework (lineString or * polygon ring) from a single source geometry. This information is carried through the noding * process (which may result in many noded edges sharing the same information object). It is then - * used to populate the topology info fields in {@link Edge}s (possibly via merging). That - * information is used to construct the topology graph {@link OverlayLabel}s. + * used to populate the topology info fields in {@link Edge} s (possibly via merging). That + * information is used to construct the topology graph {@link OverlayLabel} s. * * @author * mdavis diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineBuilder.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineBuilder.scala index 6edc7b7f..12b91b12 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineBuilder.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineBuilder.scala @@ -189,8 +189,8 @@ class LineBuilder( } /** - * Omit edge which is a collapse along a boundary. - * I.e a result line edge must be from a input line OR two coincident area boundaries. + * Omit edge which is a collapse along a boundary. I.e a result line edge must be from a input + * line OR two coincident area boundaries. * * This logic is only used if not including collapse lines in result. */ diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineLimiter.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineLimiter.scala index 456335f8..27fab798 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineLimiter.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/LineLimiter.scala @@ -51,7 +51,7 @@ import java.util * topology, and it happens in the overlay in any case. This can substantially reduce the number of * vertices which need to be processed during overlay.
- Extracts input edges, and attaches topological information *
- if clipping is enabled, handles clipping or limiting input geometry
- chooses a {@link * Noder} 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 {@link Edge}s + * Noder, with precision model
- removes any fully collapsed noded edges
- builds {@link Edge} s * and merges them
This optimization is only applicable to * Line geometries, since it does not maintain the closed topology of rings. Polygonal geometries - * are optimized using the {@link RingClipper}. + * are optimized using the {@link RingClipper} . * * @author * Martin Davis diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayEdgeRing.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayEdgeRing.scala index 3b2fcb8c..2ecdd4b9 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayEdgeRing.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayEdgeRing.scala @@ -122,7 +122,7 @@ class OverlayEdgeRing(var startEdge: OverlayEdge, val geometryFactory: GeometryF * once only and cached. * * @return - * an array of the {@link Coordinate}s in this ring + * an array of the {@link Coordinate} s in this ring */ private def getCoordinates = ringPts diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayGraph.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayGraph.scala index dd045125..0bdca492 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayGraph.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayGraph.scala @@ -22,7 +22,7 @@ import scala.jdk.CollectionConverters._ /** * A planar graph of edges, representing the topology resulting from an overlay operation. Each - * source edge is represented by a pair of {@link OverlayEdge}s, with opposite (symmetric) + * source edge is represented by a pair of {@link OverlayEdge} s, with opposite (symmetric) * orientation. The pair of OverlayEdges share the edge coordinates and a single {@link * OverlayLabel}. * @@ -39,7 +39,7 @@ class OverlayGraph() { /** * Gets the set of edges in this graph. Only one of each symmetric pair of OverlayEdges is - * included. The opposing edge can be found by using {@link OverlayEdge# sym ( )}. + * included. The opposing edge can be found by using {@link OverlayEdge# sym ( )} . * * @return * the collection of representative edges in this graph @@ -86,7 +86,7 @@ class OverlayGraph() { /** * Adds a new edge to this graph, for the given linework and topology information. A pair of - * {@link OverlayEdge}s with opposite (symmetric) orientation is added, sharing the same {@link + * {@link OverlayEdge} s with opposite (symmetric) orientation is added, sharing the same {@link * OverlayLabel}. * * @param pts diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabel.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabel.scala index 4625f4b8..b0757fe2 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabel.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabel.scala @@ -20,9 +20,9 @@ import org.locationtech.jts.geom.Position /** * A structure recording the topological situation for an edge in a topology graph used during - * overlay processing. A label contains the topological {@link Location}s for one or two input + * overlay processing. A label contains the topological {@link Location} s for one or two input * geometries to an overlay operation. An input geometry may be either a Line or an Area. The label - * locations for each input geometry are populated with the {@Location }s for the edge {@link + * locations for each input geometry are populated with the {@Location} s for the edge {@link * Position}s when they are created or once they are computed by topological evaluation. A label * also records the (effective) dimension of each input geometry. For area edges the role (shell or * hole) of the originating ring is recorded, to allow determination of edge handling in collapse @@ -321,7 +321,7 @@ class OverlayLabel() { /** * Sets the location for a collapsed edge (the Line position) for an input geometry, depending on * the ring role recorded in the label. If the input geometry edge is from a shell, the location - * is {@link Location# EXTERIOR}, if it is a hole it is {@link Location# INTERIOR}. + * is {@link Location# EXTERIOR} , if it is a hole it is {@link Location# INTERIOR} . * * @param index * the index of the input geometry @@ -543,7 +543,7 @@ class OverlayLabel() { return dimension(index) == OverlayLabel.DIM_COLLAPSE /** - * Tests if a label is a Collapse has location {@link Location# INTERIOR}, to at least one source + * Tests if a label is a Collapse has location {@link Location# INTERIOR} , to at least one source * geometry. * * @return diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabeller.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabeller.scala index a81e955b..cdb134d8 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabeller.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayLabeller.scala @@ -24,7 +24,7 @@ import scala.jdk.CollectionConverters._ */ /** - * Implements the logic to compute the full labeling for the edges in an {@link OverlayGraph}. + * Implements the logic to compute the full labeling for the edges in an {@link OverlayGraph} . * * @author * mdavis diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNG.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNG.scala index 41cd3cbc..03113202 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNG.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNG.scala @@ -31,7 +31,7 @@ import scala.jdk.CollectionConverters._ */ /** - * Computes the geometric overlay of two {@link Geometry}s, using an explicit precision model to + * Computes the geometric overlay of two {@link Geometry} s, using an explicit precision model to * allow robust computation. The overlay can be used to determine any of the following set-theoretic * operations (boolean combinations) of the geometries:
- {@link INTERSECTION} - all points * which lie in both geometries
- {@link UNION} - all points which lie in at least one geometry @@ -42,12 +42,12 @@ import scala.jdk.CollectionConverters._ * precision model of the input geometry. The main use for this is to allow using a fixed precision * for geometry with a floating precision model. This does two things: ensures robust computation; * and forces the output to be validly rounded to the precision model.
For fixed precision - * models noding is performed using a {@link SnapRoundingNoder}. This provides robust computation + * models noding is performed using a {@link SnapRoundingNoder} . This provides robust computation * (as long as precision is limited to around 13 decimal digits).
For floating precision an * {@link MCIndexNoder} is used. This is not fully robust, so can sometimes result in {@link - * TopologyException}s being thrown. For robust full-precision overlay see {@link OverlayNGRobust}. + * TopologyException}s being thrown. For robust full-precision overlay see {@link OverlayNGRobust} . *
A custom {@link Noder} can be supplied. This allows using a more performant noding strategy - * in specific cases, for instance in {@link CoverageUnion}.
Note: Note: * Optionally the overlay computation can process using strict mode (via {@link # setStrictMode ( @@ -113,7 +113,7 @@ object OverlayNG { } /** - * Tests whether a point with given {@link Location}s relative to two geometries would be + * Tests whether a point with given {@link Location} s relative to two geometries would be * contained in the result of overlaying the geometries using a given overlay operation. This is * used to determine whether components computed during the overlay process should be included in * the result geometry.
The method handles arguments of {@link Location# NONE} correctly. @@ -165,7 +165,7 @@ object OverlayNG { } /** - * Computes an overlay operation on the given geometry operands, using a supplied {@link Noder}. + * Computes an overlay operation on the given geometry operands, using a supplied {@link Noder} . * * @param geom0 * the first geometry argument @@ -194,7 +194,7 @@ object OverlayNG { } /** - * Computes an overlay operation on the given geometry operands, using a supplied {@link Noder}. + * Computes an overlay operation on the given geometry operands, using a supplied {@link Noder} . * * @param geom0 * the first geometry argument @@ -245,7 +245,7 @@ object OverlayNG { * Computes a union operation on the given geometry, with the supplied precision model. The * primary use for this is to perform precision reduction (round the geometry to the supplied * precision).
The input must be a valid geometry. Collections must be homogeneous.
To - * union an overlapping set of polygons in a more performant way use {@link UnaryUnionNG}. To + * union an overlapping set of polygons in a more performant way use {@link UnaryUnionNG} . To * union a polyonal coverage or linear network in a more performant way, use {@link * CoverageUnion}. * diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNGRobust.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNGRobust.scala index 95c3a586..47f2d930 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNGRobust.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayNGRobust.scala @@ -23,7 +23,7 @@ import org.locationtech.jts.operation.union.UnionStrategy */ /** - * Performs an overlay operation using {@link OverlayNG}, providing full robustness by using a + * Performs an overlay operation using {@link OverlayNG} , providing full robustness by using a * series of increasingly robust (but slower) noding strategies.
The noding strategies used are: *
- A simple, fast noder using FLOATING precision.
- A {@link SnappingNoder} using an * automatically-determined snap tolerance
- First snapping each geometry to itself, and then @@ -139,7 +139,7 @@ object OverlayNGRobust { } /** - * Attempt overlay using a {@link SnappingNoder}. + * Attempt overlay using a {@link SnappingNoder} . * * @param geom0 * @param geom1 diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayUtil.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayUtil.scala index d69688f3..d79ffe76 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayUtil.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/OverlayUtil.scala @@ -73,7 +73,7 @@ object OverlayUtil { * Computes a clipping envelope for overlay input geometries. The clipping envelope encloses all * geometry line segments which might participate in the overlay, with a buffer to account for * numerical precision (in particular, rounding due to a precision model. The clipping envelope is - * used in both the {@link RingClipper} and in the {@link LineLimiter}.
Some overlay + * used in both the {@link RingClipper} and in the {@link LineLimiter} .
Some overlay * operations (i.e. {@link OverlayNG# UNION and OverlayNG#SYMDIFFERENCE} cannot use clipping as an * optimization, since the result envelope is the full extent of the two input geometries. In this * case the returned envelope is
nullto indicate this. diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/PrecisionUtil.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/PrecisionUtil.scala index c6c8f000..5437cae1 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/PrecisionUtil.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/PrecisionUtil.scala @@ -26,7 +26,7 @@ import org.locationtech.jts.math.MathUtil /** * Functions for computing precision model scale factors that ensure robust geometry operations. In * particular, these can be used to automatically determine appropriate scale factors for operations - * using limited-precision noding (such as {@link OverlayNG}).WARNING: the + * using limited-precision noding (such as {@link OverlayNG} ).
WARNING: the *
inherentScaleandrobustScalefunctions can be very slow, due to the * method used to determine number of decimal places of a number. These are not recommended for * production use. diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RingClipper.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RingClipper.scala index 261ede95..a3d0fd4e 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RingClipper.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RingClipper.scala @@ -27,9 +27,9 @@ import org.locationtech.jts.geom.Envelope * coincident linework due to the need to handle topology collapse under precision reduction).* Because of the likelihood of creating extraneous line segments along the clipping rectangle * sides, this class is not suitable for clipping linestrings.
The clipping envelope should be - * generated using {@link RobustClipEnvelopeComputer}, to ensure that intersecting line segments are - * not perturbed by clipping. This is required to ensure that the overlay of the clipped geometry is - * robust and correct (i.e. the same as if clipping was not used). + * generated using {@link RobustClipEnvelopeComputer} , to ensure that intersecting line segments + * are not perturbed by clipping. This is required to ensure that the overlay of the clipped + * geometry is robust and correct (i.e. the same as if clipping was not used). * * @see * LineLimiter diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RobustClipEnvelopComputer.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RobustClipEnvelopComputer.scala index 81041ef3..430fff4d 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RobustClipEnvelopComputer.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/overlayng/RobustClipEnvelopComputer.scala @@ -27,7 +27,7 @@ import org.locationtech.jts.geom.Polygon * Computes a robust clipping envelope for a pair of polygonal geometries. The envelope is computed * to be large enough to include the full length of all geometry line segments which intersect a * given target envelope. This ensures that line segments which might intersect are not perturbed - * when clipped using {@link RingClipper}. + * when clipped using {@link RingClipper} . * * @author * Martin Davis diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/relate/EdgeEndBundle.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/relate/EdgeEndBundle.scala index 01f6d814..4903aa6f 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/relate/EdgeEndBundle.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/relate/EdgeEndBundle.scala @@ -120,12 +120,11 @@ class EdgeEndBundle(val boundaryNodeRule: BoundaryNodeRule, val e: EdgeEnd) /* * To compute the summary label for a side, the algorithm is: FOR all edges IF any edge's location * is INTERIOR for the side, side location = INTERIOR ELSE IF there is at least one EXTERIOR * attribute, side location = EXTERIOR ELSE side location = NULL
Note that it is possible for - * two sides to have apparently contradictory information - * i.e. one edge side may indicate that it is in the interior of a geometry, while another edge - * side may indicate the exterior of the same geometry. This is not an incompatibility - - * GeometryCollections may contain two Polygons that touch along an edge. This is the reason for - * Interior-primacy rule above - it results in the summary label having the Geometry interior on - * both sides. + * two sides to have apparently contradictory information i.e. one edge side may indicate that it + * is in the interior of a geometry, while another edge side may indicate the exterior of the same + * geometry. This is not an incompatibility - GeometryCollections may contain two Polygons that + * touch along an edge. This is the reason for Interior-primacy rule above - it results in the + * summary label having the Geometry interior on both sides. */ private def computeLabelSide(geomIndex: Int, side: Int): Unit = { val it = iterator diff --git a/modules/jts/src/main/scala/org/locationtech/jts/operation/union/CascadedPolygonUnion.scala b/modules/jts/src/main/scala/org/locationtech/jts/operation/union/CascadedPolygonUnion.scala index f10df473..d9788f54 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/operation/union/CascadedPolygonUnion.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/operation/union/CascadedPolygonUnion.scala @@ -47,7 +47,7 @@ import scala.annotation.nowarn object CascadedPolygonUnion { /** - * A union strategy that uses the classic JTS {@link SnapIfNeededOverlayOp}, and for polygonal + * A union strategy that uses the classic JTS {@link SnapIfNeededOverlayOp} , and for polygonal * geometries a robustness fallback usingbuffer(0). */ private[union] val CLASSIC_UNION = new UnionStrategy() { @@ -80,10 +80,10 @@ object CascadedPolygonUnion { } /** - * Computes the union of a collection of {@link Polygonal} {@link Geometry}s. + * Computes the union of a collection of {@link Polygonal} {@link Geometry} s. * * @param polys - * a collection of {@link Polygonal} {@link Geometry}s + * a collection of {@link Polygonal} {@link Geometry} s */ def union(polys: util.Collection[Geometry]): Geometry = { val op = new CascadedPolygonUnion(polys) @@ -135,10 +135,10 @@ object CascadedPolygonUnion { } /** - * Creates a new instance to union the given collection of {@link Geometry}s. + * Creates a new instance to union the given collection of {@link Geometry} s. * * @param polys - * a collection of {@link Polygonal} {@link Geometry}s + * a collection of {@link Polygonal} {@link Geometry} s */ class CascadedPolygonUnion(var inputPolys: util.Collection[Geometry], var unionFun: UnionStrategy) { diff --git a/modules/jts/src/main/scala/org/locationtech/jts/precision/GeometryPrecisionReducer.scala b/modules/jts/src/main/scala/org/locationtech/jts/precision/GeometryPrecisionReducer.scala index 0d8f98fc..b74110ec 100644 --- a/modules/jts/src/main/scala/org/locationtech/jts/precision/GeometryPrecisionReducer.scala +++ b/modules/jts/src/main/scala/org/locationtech/jts/precision/GeometryPrecisionReducer.scala @@ -46,17 +46,17 @@ import org.locationtech.jts.operation.overlayng.PrecisionReducer */ /** - * Reduces the precision of a {@link Geometry} according to the supplied {@link PrecisionModel}, + * Reduces the precision of a {@link Geometry} according to the supplied {@link PrecisionModel} , * ensuring that the result is valid (unless specified otherwise). By default the reduced result * is topologically valid (i.e. {@link Geometry# isValid ( )} is true). To ensure this a polygonal * geometry is reduced in a topologically valid fashion (technically, by using snap-rounding). It - * can be forced to be reduced pointwise by using {@link # setPointwise ( boolean )}. Note that in + * can be forced to be reduced pointwise by using {@link # setPointwise ( boolean )} . Note that in * this case the result geometry may be invalid. Linear and point geometry is always reduced * pointwise (i.e. without further change to its topology or stucture), since this does not change * validity.
By default the geometry precision model is not changed. This can be overridden by - * using {@link # setChangePrecisionModel ( boolean )}.
Normally collapsed components (e.g. + * using {@link # setChangePrecisionModel ( boolean )} .
Normally collapsed components (e.g. * lines collapsing to a point) are not included in the result. This behavior can be changed by - * using {@link # setRemoveCollapsedComponents ( boolean )}. + * using {@link # setRemoveCollapsedComponents ( boolean )} . * * @version 1.12 */