You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sis.apache.org by de...@apache.org on 2019/06/11 15:13:27 UTC
[sis] branch geoapi-4.0 updated (9640679 -> e36a238)
This is an automated email from the ASF dual-hosted git repository.
desruisseaux pushed a change to branch geoapi-4.0
in repository https://gitbox.apache.org/repos/asf/sis.git.
from 9640679 StorageConnector.getStorageAs(…) should not try to open a channel on directory. This is a workaround for https://bugs.openjdk.java.net/browse/JDK-8080629
new 3ebdf21 Replace "ordinate" term by "coordinate" for compliance with ISO 19111 terminology. https://issues.apache.org/jira/browse/SIS-461
new 78c8c1a Override equals(Object) in GeneralDirectPosition with a more efficient implementation.
new e36a238 Remove Formulas.pow3(int), replaced by the more generic MathFunctions.pow(long, int).
The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../org/apache/sis/console/TransformCommand.java | 18 +-
.../org/apache/sis/openoffice/Transformer.java | 4 +-
.../sis/coverage/grid/GridCoordinatesView.java | 18 +-
.../java/org/apache/sis/internal/feature/ESRI.java | 8 +-
.../apache/sis/internal/feature/Geometries.java | 18 +-
.../java/org/apache/sis/internal/feature/JTS.java | 10 +-
.../org/apache/sis/internal/feature/Java2D.java | 14 +-
.../apache/sis/internal/feature/MovingFeature.java | 4 +-
.../org/apache/sis/internal/feature/Resources.java | 4 +-
.../sis/internal/feature/Resources.properties | 2 +-
.../sis/internal/feature/Resources_fr.properties | 2 +-
.../sis/coverage/grid/GridDerivationTest.java | 2 +-
.../sis/internal/metadata/ReferencingServices.java | 4 +-
.../iso/extent/DefaultGeographicBoundingBox.java | 4 +-
.../gazetteer/GeohashReferenceSystem.java | 4 +-
.../gazetteer/MilitaryGridReferenceSystem.java | 4 +-
.../sis/referencing/gazetteer/SimpleLocation.java | 8 +-
.../sis/geometry/AbstractDirectPosition.java | 63 +++--
.../org/apache/sis/geometry/AbstractEnvelope.java | 80 +++---
.../org/apache/sis/geometry/ArrayEnvelope.java | 146 +++++------
.../org/apache/sis/geometry/CoordinateFormat.java | 56 ++---
.../org/apache/sis/geometry/CurveExtremum.java | 8 +-
.../org/apache/sis/geometry/DirectPosition1D.java | 50 ++--
.../org/apache/sis/geometry/DirectPosition2D.java | 32 +--
.../java/org/apache/sis/geometry/Envelope2D.java | 86 +++----
.../java/org/apache/sis/geometry/Envelopes.java | 57 +++--
.../apache/sis/geometry/GeneralDirectPosition.java | 145 ++++++-----
.../org/apache/sis/geometry/GeneralEnvelope.java | 268 ++++++++++-----------
.../org/apache/sis/geometry/ImmutableEnvelope.java | 14 +-
.../java/org/apache/sis/geometry/Shapes2D.java | 16 +-
.../java/org/apache/sis/geometry/SubEnvelope.java | 54 ++---
.../java/org/apache/sis/geometry/package-info.java | 2 +-
.../internal/referencing/CoordinateOperations.java | 2 +-
.../internal/referencing/DirectPositionView.java | 60 ++---
.../internal/referencing/EPSGParameterDomain.java | 2 +-
.../apache/sis/internal/referencing/Formulas.java | 26 +-
.../internal/referencing/PositionTransformer.java | 2 +-
.../internal/referencing/ServicesForMetadata.java | 4 +-
.../referencing/j2d/IntervalRectangle.java | 76 +++---
.../java/org/apache/sis/parameter/Verifier.java | 2 +-
.../apache/sis/referencing/cs/AxesConvention.java | 6 +-
.../cs/DefaultCoordinateSystemAxis.java | 8 +-
.../apache/sis/referencing/cs/DefaultLinearCS.java | 2 +-
.../org/apache/sis/referencing/cs/Normalizer.java | 6 +-
.../sis/referencing/datum/DefaultEllipsoid.java | 2 +-
.../referencing/factory/sql/EPSGDataAccess.java | 2 +-
.../operation/AbstractCoordinateOperation.java | 8 +-
.../operation/CoordinateOperationFinder.java | 6 +-
.../operation/DefaultPassThroughOperation.java | 16 +-
.../sis/referencing/operation/matrix/Matrices.java | 24 +-
.../referencing/operation/matrix/MatrixSIS.java | 18 +-
.../operation/matrix/NonSquareMatrix.java | 16 +-
.../sis/referencing/operation/matrix/Solver.java | 2 +-
.../operation/projection/NormalizedProjection.java | 8 +-
.../operation/projection/package-info.java | 2 +-
.../operation/transform/AbstractMathTransform.java | 30 +--
.../transform/AbstractMathTransform1D.java | 28 +--
.../operation/transform/ContextualParameters.java | 4 +-
.../operation/transform/CopyTransform.java | 10 +-
.../transform/DefaultMathTransformFactory.java | 10 +-
.../transform/InterpolatedGeocentricTransform.java | 2 +-
.../transform/InterpolatedMolodenskyTransform.java | 2 +-
.../operation/transform/IterationStrategy.java | 4 +-
.../operation/transform/LinearTransform.java | 2 +-
.../operation/transform/MathTransforms.java | 4 +-
.../operation/transform/MolodenskyTransform.java | 4 +-
.../operation/transform/PassThroughTransform.java | 2 +-
.../operation/transform/ProjectiveTransform.java | 4 +-
.../operation/transform/ScaleTransform.java | 6 +-
.../operation/transform/TranslationTransform.java | 4 +-
.../apache/sis/geometry/AbstractEnvelopeTest.java | 14 +-
.../org/apache/sis/geometry/ArrayEnvelopeTest.java | 12 +-
.../apache/sis/geometry/CoordinateFormatTest.java | 4 +-
.../apache/sis/geometry/DirectPosition1DTest.java | 4 +-
.../apache/sis/geometry/DirectPosition2DTest.java | 6 +-
.../org/apache/sis/geometry/EnvelopesTest.java | 4 +-
.../sis/geometry/GeneralDirectPositionTest.java | 6 +-
.../apache/sis/geometry/GeneralEnvelopeTest.java | 14 +-
.../org/apache/sis/geometry/SubEnvelopeTest.java | 30 +--
.../sis/internal/referencing/FormulasTest.java | 12 -
.../provider/GeographicOffsetsTest.java | 2 +-
.../apache/sis/referencing/cs/HardCodedAxes.java | 44 ++--
.../referencing/datum/TimeDependentBWPTest.java | 2 +-
.../operation/CoordinateOperationFinderTest.java | 2 +-
.../operation/HardCodedConversions.java | 6 +-
.../builder/LinearTransformBuilderTest.java | 4 +-
.../referencing/operation/matrix/MatricesTest.java | 2 +-
.../operation/projection/AlbersEqualAreaTest.java | 12 +-
.../transform/AbstractMathTransformTest.java | 2 +-
.../operation/transform/CoordinateDomain.java | 66 ++---
.../operation/transform/CoordinateDomainTest.java | 6 +-
.../operation/transform/CopyTransformTest.java | 2 +-
.../operation/transform/PseudoTransform.java | 2 +-
.../org/apache/sis/test/ReferencingAssert.java | 12 +-
.../apache/sis/math/CompoundDirectPositions.java | 26 +-
.../src/main/java/org/apache/sis/math/Line.java | 12 +-
.../src/main/java/org/apache/sis/math/Plane.java | 6 +-
.../main/java/org/apache/sis/measure/Latitude.java | 4 +-
.../java/org/apache/sis/measure/Longitude.java | 4 +-
.../java/org/apache/sis/util/resources/Errors.java | 10 +-
.../apache/sis/util/resources/Errors.properties | 2 +-
.../apache/sis/util/resources/Errors_fr.properties | 2 +-
.../java/org/apache/sis/test/TestUtilities.java | 4 +-
.../storage/earthobservation/LandsatReader.java | 6 +-
.../src/main/c/org_apache_sis_storage_gdal_PJ.c | 4 +-
.../sis/storage/geotiff/GridGeometryBuilder.java | 6 +-
.../apache/sis/storage/geotiff/Localization.java | 12 +-
.../apache/sis/internal/netcdf/impl/GridInfo.java | 2 +-
.../sis/internal/netcdf/ucar/GridWrapper.java | 2 +-
.../sis/internal/storage/MetadataBuilder.java | 10 +-
.../org/apache/sis/internal/storage/csv/Store.java | 2 +-
111 files changed, 1003 insertions(+), 1002 deletions(-)
[sis] 02/03: Override equals(Object) in GeneralDirectPosition with
a more efficient implementation.
Posted by de...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
desruisseaux pushed a commit to branch geoapi-4.0
in repository https://gitbox.apache.org/repos/asf/sis.git
commit 78c8c1ae74ef33ac7bd3883b05bbb565e16d28b3
Author: Martin Desruisseaux <ma...@geomatys.com>
AuthorDate: Tue Jun 11 17:02:39 2019 +0200
Override equals(Object) in GeneralDirectPosition with a more efficient implementation.
---
.../org/apache/sis/geometry/AbstractDirectPosition.java | 4 ++--
.../org/apache/sis/geometry/GeneralDirectPosition.java | 15 +++++++++++++++
2 files changed, 17 insertions(+), 2 deletions(-)
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
index 6d62407..2a3b779 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
@@ -381,7 +381,7 @@ parse: while (i < length) {
}
/**
- * Returns a hash value for this coordinate. This method returns a value compliant
+ * Returns a hash value for this coordinate tuple. This method returns a value compliant
* with the contract documented in the {@link DirectPosition#hashCode()} javadoc.
* Consequently, it should be possible to mix different {@code DirectPosition}
* implementations in the same hash map.
@@ -400,7 +400,7 @@ parse: while (i < length) {
/**
* Returns {@code true} if the specified object is also a {@code DirectPosition}
- * with equal coordinate and equal CRS.
+ * with equal coordinates and equal CRS.
*
* This method performs the comparison as documented in the {@link DirectPosition#equals(Object)}
* javadoc. In particular, the given object is not required to be of the same implementation class.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
index b88cb7b..6a43ae4 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
@@ -351,4 +351,19 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
assert code == super.hashCode();
return code;
}
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals(final Object object) {
+ if (object == this) {
+ return true;
+ }
+ if (object instanceof GeneralDirectPosition) {
+ final GeneralDirectPosition that = (GeneralDirectPosition) object;
+ return Arrays.equals(coordinates, that.coordinates) && Objects.equals(crs, that.crs);
+ }
+ return super.equals(object); // Comparison of other implementation classes.
+ }
}
[sis] 01/03: Replace "ordinate" term by "coordinate" for compliance
with ISO 19111 terminology. https://issues.apache.org/jira/browse/SIS-461
Posted by de...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
desruisseaux pushed a commit to branch geoapi-4.0
in repository https://gitbox.apache.org/repos/asf/sis.git
commit 3ebdf21d34aee52e8231b9e1744521813dc9323b
Author: Martin Desruisseaux <ma...@geomatys.com>
AuthorDate: Tue Jun 11 16:35:57 2019 +0200
Replace "ordinate" term by "coordinate" for compliance with ISO 19111 terminology.
https://issues.apache.org/jira/browse/SIS-461
---
.../org/apache/sis/console/TransformCommand.java | 18 +-
.../org/apache/sis/openoffice/Transformer.java | 4 +-
.../sis/coverage/grid/GridCoordinatesView.java | 18 +-
.../java/org/apache/sis/internal/feature/ESRI.java | 8 +-
.../apache/sis/internal/feature/Geometries.java | 18 +-
.../java/org/apache/sis/internal/feature/JTS.java | 10 +-
.../org/apache/sis/internal/feature/Java2D.java | 14 +-
.../apache/sis/internal/feature/MovingFeature.java | 4 +-
.../org/apache/sis/internal/feature/Resources.java | 4 +-
.../sis/internal/feature/Resources.properties | 2 +-
.../sis/internal/feature/Resources_fr.properties | 2 +-
.../sis/coverage/grid/GridDerivationTest.java | 2 +-
.../sis/internal/metadata/ReferencingServices.java | 4 +-
.../iso/extent/DefaultGeographicBoundingBox.java | 4 +-
.../gazetteer/GeohashReferenceSystem.java | 4 +-
.../gazetteer/MilitaryGridReferenceSystem.java | 4 +-
.../sis/referencing/gazetteer/SimpleLocation.java | 8 +-
.../sis/geometry/AbstractDirectPosition.java | 59 +++--
.../org/apache/sis/geometry/AbstractEnvelope.java | 80 +++---
.../org/apache/sis/geometry/ArrayEnvelope.java | 146 +++++------
.../org/apache/sis/geometry/CoordinateFormat.java | 56 ++---
.../org/apache/sis/geometry/CurveExtremum.java | 8 +-
.../org/apache/sis/geometry/DirectPosition1D.java | 50 ++--
.../org/apache/sis/geometry/DirectPosition2D.java | 32 +--
.../java/org/apache/sis/geometry/Envelope2D.java | 86 +++----
.../java/org/apache/sis/geometry/Envelopes.java | 53 ++--
.../apache/sis/geometry/GeneralDirectPosition.java | 130 +++++-----
.../org/apache/sis/geometry/GeneralEnvelope.java | 268 ++++++++++-----------
.../org/apache/sis/geometry/ImmutableEnvelope.java | 14 +-
.../java/org/apache/sis/geometry/Shapes2D.java | 16 +-
.../java/org/apache/sis/geometry/SubEnvelope.java | 54 ++---
.../java/org/apache/sis/geometry/package-info.java | 2 +-
.../internal/referencing/CoordinateOperations.java | 2 +-
.../internal/referencing/DirectPositionView.java | 60 ++---
.../internal/referencing/EPSGParameterDomain.java | 2 +-
.../apache/sis/internal/referencing/Formulas.java | 6 +-
.../internal/referencing/PositionTransformer.java | 2 +-
.../internal/referencing/ServicesForMetadata.java | 4 +-
.../referencing/j2d/IntervalRectangle.java | 76 +++---
.../java/org/apache/sis/parameter/Verifier.java | 2 +-
.../apache/sis/referencing/cs/AxesConvention.java | 6 +-
.../cs/DefaultCoordinateSystemAxis.java | 8 +-
.../apache/sis/referencing/cs/DefaultLinearCS.java | 2 +-
.../org/apache/sis/referencing/cs/Normalizer.java | 6 +-
.../sis/referencing/datum/DefaultEllipsoid.java | 2 +-
.../referencing/factory/sql/EPSGDataAccess.java | 2 +-
.../operation/AbstractCoordinateOperation.java | 8 +-
.../operation/CoordinateOperationFinder.java | 6 +-
.../operation/DefaultPassThroughOperation.java | 16 +-
.../sis/referencing/operation/matrix/Matrices.java | 24 +-
.../referencing/operation/matrix/MatrixSIS.java | 18 +-
.../operation/matrix/NonSquareMatrix.java | 16 +-
.../sis/referencing/operation/matrix/Solver.java | 2 +-
.../operation/projection/NormalizedProjection.java | 8 +-
.../operation/projection/package-info.java | 2 +-
.../operation/transform/AbstractMathTransform.java | 30 +--
.../transform/AbstractMathTransform1D.java | 28 +--
.../operation/transform/ContextualParameters.java | 4 +-
.../operation/transform/CopyTransform.java | 10 +-
.../transform/DefaultMathTransformFactory.java | 10 +-
.../transform/InterpolatedGeocentricTransform.java | 2 +-
.../transform/InterpolatedMolodenskyTransform.java | 2 +-
.../operation/transform/IterationStrategy.java | 4 +-
.../operation/transform/LinearTransform.java | 2 +-
.../operation/transform/MathTransforms.java | 4 +-
.../operation/transform/MolodenskyTransform.java | 4 +-
.../operation/transform/PassThroughTransform.java | 2 +-
.../operation/transform/ProjectiveTransform.java | 4 +-
.../operation/transform/ScaleTransform.java | 6 +-
.../operation/transform/TranslationTransform.java | 4 +-
.../apache/sis/geometry/AbstractEnvelopeTest.java | 14 +-
.../org/apache/sis/geometry/ArrayEnvelopeTest.java | 12 +-
.../apache/sis/geometry/CoordinateFormatTest.java | 4 +-
.../apache/sis/geometry/DirectPosition1DTest.java | 4 +-
.../apache/sis/geometry/DirectPosition2DTest.java | 6 +-
.../org/apache/sis/geometry/EnvelopesTest.java | 4 +-
.../sis/geometry/GeneralDirectPositionTest.java | 6 +-
.../apache/sis/geometry/GeneralEnvelopeTest.java | 14 +-
.../org/apache/sis/geometry/SubEnvelopeTest.java | 30 +--
.../provider/GeographicOffsetsTest.java | 2 +-
.../apache/sis/referencing/cs/HardCodedAxes.java | 44 ++--
.../referencing/datum/TimeDependentBWPTest.java | 2 +-
.../operation/CoordinateOperationFinderTest.java | 2 +-
.../operation/HardCodedConversions.java | 6 +-
.../builder/LinearTransformBuilderTest.java | 4 +-
.../referencing/operation/matrix/MatricesTest.java | 2 +-
.../operation/projection/AlbersEqualAreaTest.java | 12 +-
.../transform/AbstractMathTransformTest.java | 2 +-
.../operation/transform/CoordinateDomain.java | 66 ++---
.../operation/transform/CoordinateDomainTest.java | 6 +-
.../operation/transform/CopyTransformTest.java | 2 +-
.../operation/transform/PseudoTransform.java | 2 +-
.../org/apache/sis/test/ReferencingAssert.java | 12 +-
.../apache/sis/math/CompoundDirectPositions.java | 26 +-
.../src/main/java/org/apache/sis/math/Line.java | 12 +-
.../src/main/java/org/apache/sis/math/Plane.java | 6 +-
.../main/java/org/apache/sis/measure/Latitude.java | 4 +-
.../java/org/apache/sis/measure/Longitude.java | 4 +-
.../java/org/apache/sis/util/resources/Errors.java | 10 +-
.../apache/sis/util/resources/Errors.properties | 2 +-
.../apache/sis/util/resources/Errors_fr.properties | 2 +-
.../java/org/apache/sis/test/TestUtilities.java | 4 +-
.../storage/earthobservation/LandsatReader.java | 6 +-
.../src/main/c/org_apache_sis_storage_gdal_PJ.c | 4 +-
.../sis/storage/geotiff/GridGeometryBuilder.java | 6 +-
.../apache/sis/storage/geotiff/Localization.java | 12 +-
.../apache/sis/internal/netcdf/impl/GridInfo.java | 2 +-
.../sis/internal/netcdf/ucar/GridWrapper.java | 2 +-
.../sis/internal/storage/MetadataBuilder.java | 10 +-
.../org/apache/sis/internal/storage/csv/Store.java | 2 +-
110 files changed, 984 insertions(+), 966 deletions(-)
diff --git a/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java b/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java
index ad036bd..8c8cbe0 100644
--- a/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java
+++ b/application/sis-console/src/main/java/org/apache/sis/console/TransformCommand.java
@@ -110,17 +110,17 @@ final class TransformCommand extends FormattedOutputCommand {
private NumberFormat coordinateFormat;
/**
- * Width of ordinate values, in number of characters in ordinate {@link String} representations.
+ * Width of coordinate values, in number of characters in coordinate {@link String} representations.
*/
- private int ordinateWidth;
+ private int coordinateWidth;
/**
- * Suggested number of fraction digits for each ordinate values.
+ * Suggested number of fraction digits for each coordinate values.
*/
private int[] numFractionDigits;
/**
- * We will switch to scientific notation if the ordinate value to format is greater than this value.
+ * We will switch to scientific notation if the coordinate value to format is greater than this value.
*/
private double[] thresholdForScientificNotation;
@@ -245,7 +245,7 @@ final class TransformCommand extends FormattedOutputCommand {
* compute the number of digits to format and perform the actual coordinate operations.
*/
if (!points.isEmpty()) {
- ordinateWidth = 15; // Must be set before computeNumFractionDigits(…).
+ coordinateWidth = 15; // Must be set before computeNumFractionDigits(…).
coordinateFormat = NumberFormat.getInstance(Locale.US);
coordinateFormat.setGroupingUsed(false);
computeNumFractionDigits(operation.getTargetCRS().getCoordinateSystem());
@@ -476,7 +476,7 @@ final class TransformCommand extends FormattedOutputCommand {
if (!unit.isEmpty()) {
name = name + " (" + unit + ')';
}
- printQuotedText(name, ordinateWidth, X364.FOREGROUND_CYAN);
+ printQuotedText(name, coordinateWidth, X364.FOREGROUND_CYAN);
}
}
@@ -507,7 +507,7 @@ final class TransformCommand extends FormattedOutputCommand {
if (precision > 0) {
numFractionDigits[i] = Math.max(DecimalFunctions.fractionDigitsForDelta(precision, false) + 1, 0);
}
- thresholdForScientificNotation[i] = MathFunctions.pow10(ordinateWidth - 1 - numFractionDigits[i]);
+ thresholdForScientificNotation[i] = MathFunctions.pow10(coordinateWidth - 1 - numFractionDigits[i]);
}
}
@@ -599,7 +599,7 @@ final class TransformCommand extends FormattedOutputCommand {
}
/*
* At this point we got the coordinates and they have the expected number of dimensions.
- * Now perform the coordinate operation and print each ordinate values. We will switch
+ * Now perform the coordinate operation and print each coordinate values. We will switch
* to scientific notation if the coordinate is much larger than expected.
*/
mt.transform(coordinates, 0, result, 0, 1);
@@ -616,7 +616,7 @@ final class TransformCommand extends FormattedOutputCommand {
coordinateFormat.setMaximumFractionDigits(numFractionDigits[i]);
s = coordinateFormat.format(value);
}
- out.print(CharSequences.spaces(ordinateWidth - s.length()));
+ out.print(CharSequences.spaces(coordinateWidth - s.length()));
out.print(s);
}
/*
diff --git a/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java b/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java
index e4e087c..f9a74bb 100644
--- a/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java
+++ b/application/sis-openoffice/src/main/java/org/apache/sis/openoffice/Transformer.java
@@ -160,8 +160,8 @@ final class Transformer {
for (int j=0; j<points.length; j++) {
final double[] coords = points[j];
if (coords != null) { // Paranoiac check.
- for (int i=sourcePt.ordinates.length; --i>=0;) {
- sourcePt.ordinates[i] = (i < coords.length) ? coords[i] : 0;
+ for (int i=sourcePt.coordinates.length; --i>=0;) {
+ sourcePt.coordinates[i] = (i < coords.length) ? coords[i] : 0;
}
try {
result[j] = mt.transform(sourcePt, targetPt).getCoordinate();
diff --git a/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java b/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java
index 1e9dadd..efbb0ab 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/coverage/grid/GridCoordinatesView.java
@@ -35,10 +35,10 @@ final class GridCoordinatesView implements GridCoordinates {
/**
* A reference to the coordinate array of the enclosing grid envelope.
*/
- private final long[] ordinates;
+ private final long[] coordinates;
/**
- * Index of the first value in the {@link #ordinates} array.
+ * Index of the first value in the {@link #coordinates} array.
* This is 0 for low values, or {@link #getDimension()} for high values.
*/
private final int offset;
@@ -46,8 +46,8 @@ final class GridCoordinatesView implements GridCoordinates {
/**
* Creates a new view over the low or high coordinates.
*/
- GridCoordinatesView(final long[] ordinates, final int offset) {
- this.ordinates = ordinates;
+ GridCoordinatesView(final long[] coordinates, final int offset) {
+ this.coordinates = coordinates;
this.offset = offset;
}
@@ -56,7 +56,7 @@ final class GridCoordinatesView implements GridCoordinates {
*/
@Override
public final int getDimension() {
- return ordinates.length >>> 1;
+ return coordinates.length >>> 1;
}
/**
@@ -64,7 +64,7 @@ final class GridCoordinatesView implements GridCoordinates {
*/
@Override
public final long[] getCoordinateValues() {
- return Arrays.copyOfRange(ordinates, offset, offset + getDimension());
+ return Arrays.copyOfRange(coordinates, offset, offset + getDimension());
}
/**
@@ -73,7 +73,7 @@ final class GridCoordinatesView implements GridCoordinates {
@Override
public final long getCoordinateValue(final int index) {
ArgumentChecks.ensureValidIndex(getDimension(), index);
- return ordinates[offset + index];
+ return coordinates[offset + index];
}
/**
@@ -100,7 +100,7 @@ final class GridCoordinatesView implements GridCoordinates {
long code = -3; // Arbitrary seed for differentiating from Arrays.hashCode(long[]).
final int end = offset + getDimension();
for (int i=offset; i<end; i++) {
- code = 31 * code + ordinates[i];
+ code = 31 * code + coordinates[i];
}
return Long.hashCode(code);
}
@@ -126,7 +126,7 @@ final class GridCoordinatesView implements GridCoordinates {
if (dimension == that.getDimension()) {
// TODO: use Arrays.equals(...) with JDK9 instead.
for (int i=0; i<dimension; i++) {
- if (ordinates[offset + i] != that.ordinates[that.offset + i]) {
+ if (coordinates[offset + i] != that.coordinates[that.offset + i]) {
return false;
}
}
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java
index b7acd42..bbd8780 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/ESRI.java
@@ -123,17 +123,17 @@ final class ESRI extends Geometries<Geometry> {
}
/**
- * Creates a polyline from the given ordinate values.
- * Each {@link Double#NaN} ordinate value starts a new path.
+ * Creates a polyline from the given coordinate values.
+ * Each {@link Double#NaN} coordinate value starts a new path.
*/
@Override
- public Geometry createPolyline(final int dimension, final Vector... ordinates) {
+ public Geometry createPolyline(final int dimension, final Vector... coordinates) {
if (dimension != 2) {
throw unsupported(dimension);
}
boolean lineTo = false;
final Polyline path = new Polyline();
- for (final Vector v : ordinates) {
+ for (final Vector v : coordinates) {
if (v != null) {
final int size = v.size();
for (int i=0; i<size;) {
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java
index c6950d7..a30b2a2 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Geometries.java
@@ -259,27 +259,27 @@ public abstract class Geometries<G> {
* Creates a two-dimensional point from the given coordinate. If the CRS is geographic, then the
* (x,y) values should be (longitude, latitude) for compliance with usage in ESRI and JTS libraries.
*
- * @param x the first ordinate value.
- * @param y the second ordinate value.
- * @return the point for the given ordinate values.
+ * @param x the first coordinate value.
+ * @param y the second coordinate value.
+ * @return the point for the given coordinate values.
*
* @see #getCoordinate(Object)
*/
public abstract Object createPoint(double x, double y);
/**
- * Creates a path or polyline from the given ordinate values.
- * The array of ordinate vectors will be handled as if all vectors were concatenated in a single vector,
+ * Creates a path or polyline from the given coordinate values.
+ * The array of coordinate values will be handled as if all vectors were concatenated in a single vector,
* ignoring {@code null} array elements.
- * Each {@link Double#NaN} ordinate value in the concatenated vector starts a new path.
+ * Each {@link Double#NaN} coordinate value in the concatenated vector starts a new path.
* The implementation returned by this method is an instance of {@link #rootClass}.
*
- * @param dimension the number of dimensions (2 or 3).
- * @param ordinates sequence of (x,y) or (x,y,z) tuples.
+ * @param dimension the number of dimensions (2 or 3).
+ * @param coordinates sequence of (x,y) or (x,y,z) tuples.
* @return the geometric object for the given points.
* @throws UnsupportedOperationException if the geometry library can not create the requested path.
*/
- public abstract G createPolyline(int dimension, Vector... ordinates);
+ public abstract G createPolyline(int dimension, Vector... coordinates);
/**
* Merges a sequence of polyline instances if the first instance is an implementation of this library.
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java
index 39c998f..20e2f6d 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/JTS.java
@@ -141,7 +141,7 @@ final class JTS extends Geometries<Geometry> {
/**
* Creates a two-dimensional point from the given coordinate.
*
- * @return the point for the given ordinate values.
+ * @return the point for the given coordinate values.
*/
@Override
public Object createPoint(final double x, final double y) {
@@ -149,20 +149,20 @@ final class JTS extends Geometries<Geometry> {
}
/**
- * Creates a polyline from the given ordinate values.
- * Each {@link Double#NaN} ordinate value starts a new path.
+ * Creates a polyline from the given coordinate values.
+ * Each {@link Double#NaN} coordinate value starts a new path.
*
* @return the geometric object for the given points.
*/
@Override
- public Geometry createPolyline(final int dimension, final Vector... ordinates) {
+ public Geometry createPolyline(final int dimension, final Vector... coords) {
final boolean is3D = (dimension == 3);
if (!is3D && dimension != 2) {
throw unsupported(dimension);
}
final List<Coordinate> coordinates = new ArrayList<>(32);
final List<LineString> lines = new ArrayList<>();
- for (final Vector v : ordinates) {
+ for (final Vector v : coords) {
if (v != null) {
final int size = v.size();
for (int i=0; i<size;) {
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java
index 7691b60..f0a70f3 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Java2D.java
@@ -111,13 +111,13 @@ final class Java2D extends Geometries<Shape> {
}
/**
- * Creates a path from the given ordinate values.
- * Each {@link Double#NaN} ordinate value starts a new path.
+ * Creates a path from the given coordinate values.
+ * Each {@link Double#NaN} coordinate value starts a new path.
* The geometry may be backed by {@code float} or {@code double} primitive type,
* depending on the type used by the given vectors.
*/
@Override
- public Shape createPolyline(final int dimension, final Vector... ordinates) {
+ public Shape createPolyline(final int dimension, final Vector... coordinates) {
if (dimension != 2) {
throw unsupported(dimension);
}
@@ -127,7 +127,7 @@ final class Java2D extends Geometries<Shape> {
*/
int length = 0;
boolean isFloat = true;
- for (final Vector v : ordinates) {
+ for (final Vector v : coordinates) {
if (v != null) {
length = Math.addExact(length, v.size());
if (isFloat) {
@@ -139,8 +139,8 @@ final class Java2D extends Geometries<Shape> {
* Note: Point2D is not an instance of Shape, so we can not make a special case for it.
*/
length /= 2;
- if (length == 2 && ordinates.length == 1) {
- final Vector v = ordinates[0];
+ if (length == 2 && coordinates.length == 1) {
+ final Vector v = coordinates[0];
final double x1, y1, x2, y2;
if (!Double.isNaN(x1 = v.doubleValue(0)) &&
!Double.isNaN(y1 = v.doubleValue(1)) &&
@@ -155,7 +155,7 @@ final class Java2D extends Geometries<Shape> {
final Path2D path = isFloat ? new Path2D.Float (Path2D.WIND_NON_ZERO, length)
: new Path2D.Double(Path2D.WIND_NON_ZERO, length);
boolean lineTo = false;
- for (final Vector v : ordinates) {
+ for (final Vector v : coordinates) {
final int size = v.size();
for (int i=0; i<size;) {
final double x = v.doubleValue(i++);
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java
index ffd79c7..c60dbd9 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/MovingFeature.java
@@ -239,12 +239,12 @@ public final class MovingFeature {
p = p.previous;
}
warningListener.accept(Resources.forLocale(null).getLogRecord(Level.WARNING,
- Resources.Keys.UnexpectedNumberOfOrdinates_4, featureName, new Date(p.startTime), dimension, length));
+ Resources.Keys.UnexpectedNumberOfCoordinates_4, featureName, new Date(p.startTime), dimension, length));
}
continue;
}
/*
- * At this point we have a non-empty valid sequence of ordinate values. If the first point of current
+ * At this point we have a non-empty valid sequence of coordinate values. If the first point of current
* vector is equals to the last point of previous vector, assume that they form a continuous polyline.
*/
if (previous != null) {
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java
index 9f35c4e..2181205 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.java
@@ -300,9 +300,9 @@ public final class Resources extends IndexedResourceBundle {
public static final short UnexpectedNumberOfComponents_4 = 17;
/**
- * The “{0}” feature at {1} has a {3} ordinate values, while we expected a multiple of {2}.
+ * The “{0}” feature at {1} has a {3} coordinate values, while we expected a multiple of {2}.
*/
- public static final short UnexpectedNumberOfOrdinates_4 = 22;
+ public static final short UnexpectedNumberOfCoordinates_4 = 22;
/**
* Raster data type ‘{0}’ is unknown or unsupported.
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties
index 6f6a38e..d0bcc90 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources.properties
@@ -65,7 +65,7 @@ TooManyQualitatives = Too many qualitative categories.
UnavailableGeometryLibrary_1 = The {0} geometry library is not available in current runtime environment.
UnexpectedNumberOfBands_2 = Expected {0} bands but got {1}.
UnexpectedNumberOfComponents_4 = The \u201c{1}\u201d value given to \u201c{0}\u201d property should be separable in {2} components, but we got {3}.
-UnexpectedNumberOfOrdinates_4 = The \u201c{0}\u201d feature at {1} has a {3} ordinate values, while we expected a multiple of {2}.
+UnexpectedNumberOfCoordinates_4 = The \u201c{0}\u201d feature at {1} has a {3} coordinate values, while we expected a multiple of {2}.
UnknownDataType_1 = Raster data type \u2018{0}\u2019 is unknown or unsupported.
UnresolvedFeatureName_1 = Feature named \u201c{0}\u201d has not yet been resolved.
UnspecifiedCRS = Coordinate reference system is unspecified.
diff --git a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties
index 773f28c..b6eccd1 100644
--- a/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties
+++ b/core/sis-feature/src/main/java/org/apache/sis/internal/feature/Resources_fr.properties
@@ -71,7 +71,7 @@ TooManyQualitatives = Trop de cat\u00e9gories qualitatives.
UnavailableGeometryLibrary_1 = La biblioth\u00e8que de g\u00e9om\u00e9tries {0} n\u2019est pas disponible dans l\u2019environnement d\u2019ex\u00e9cution actuel.
UnexpectedNumberOfBands_2 = On attendait {0} bandes mais {1} ont \u00e9t\u00e9 sp\u00e9cifi\u00e9es.
UnexpectedNumberOfComponents_4 = La valeur \u00ab\u202f{1}\u202f\u00bb donn\u00e9e \u00e0 la propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb devrait \u00eatre s\u00e9parable en {2} composantes, mais on en a obtenus {3}.
-UnexpectedNumberOfOrdinates_4 = L\u2019entit\u00e9 nomm\u00e9e \u00ab\u202f{0}\u202f\u00bb \u00e0 {1} contient {3} ordonn\u00e9es, alors qu\u2019on attendait un multiple de {2}.
+UnexpectedNumberOfCoordinates_4 = L\u2019entit\u00e9 nomm\u00e9e \u00ab\u202f{0}\u202f\u00bb \u00e0 {1} contient {3} coordonn\u00e9es, alors qu\u2019on attendait un multiple de {2}.
UnknownDataType_1 = Le type de donn\u00e9es raster \u2018{0}\u2019 est inconnu ou non-support\u00e9.
UnresolvedFeatureName_1 = L\u2019entit\u00e9 nomm\u00e9e \u00ab\u202f{0}\u202f\u00bb n\u2019a pas encore \u00e9t\u00e9 r\u00e9solue.
UnspecifiedCRS = Le syst\u00e8me de r\u00e9f\u00e9rence des coordonn\u00e9es n\u2019a pas \u00e9t\u00e9 sp\u00e9cifi\u00e9.
diff --git a/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java b/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java
index 58a197a..290c260 100644
--- a/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java
+++ b/core/sis-feature/src/test/java/org/apache/sis/coverage/grid/GridDerivationTest.java
@@ -334,7 +334,7 @@ public final strictfp class GridDerivationTest extends TestCase {
final GeneralDirectPosition geo3dUpperCorner = new GeneralDirectPosition(geo3d.getUpperCorner());
IntStream.range(0, geo3dUpperCorner.getDimension())
- .forEach(idx -> geo3dUpperCorner.ordinates[idx] -= 1e-7);
+ .forEach(idx -> geo3dUpperCorner.coordinates[idx] -= 1e-7);
slice = base.derive()
.slice(geo3dUpperCorner)
diff --git a/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java b/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java
index fbf8d7c..a56a050 100644
--- a/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java
+++ b/core/sis-metadata/src/main/java/org/apache/sis/internal/metadata/ReferencingServices.java
@@ -223,7 +223,7 @@ public class ReferencingServices extends OptionalDependency {
/**
* Sets a vertical extent with the value inferred from the given envelope.
- * Only the vertical ordinates are extracted; all other ordinates are ignored.
+ * Only the vertical coordinates are extracted; all other coordinates are ignored.
*
* @param envelope the source envelope.
* @param target the target vertical extent.
@@ -236,7 +236,7 @@ public class ReferencingServices extends OptionalDependency {
/**
* Sets a temporal extent with the value inferred from the given envelope.
- * Only the temporal ordinates are extracted; all other ordinates are ignored.
+ * Only the temporal coordinates are extracted; all other coordinates are ignored.
*
* @param envelope the source envelope.
* @param target the target temporal extent.
diff --git a/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java b/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java
index a8738ee..f913f50 100644
--- a/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java
+++ b/core/sis-metadata/src/main/java/org/apache/sis/metadata/iso/extent/DefaultGeographicBoundingBox.java
@@ -428,7 +428,7 @@ public class DefaultGeographicBoundingBox extends AbstractGeographicExtent imple
throws IllegalArgumentException
{
if (southBoundLatitude > northBoundLatitude) { // Accept NaN.
- throw new IllegalArgumentException(Errors.format(Errors.Keys.IllegalOrdinateRange_3,
+ throw new IllegalArgumentException(Errors.format(Errors.Keys.IllegalCoordinateRange_3,
new Latitude(southBoundLatitude), new Latitude(northBoundLatitude),
Vocabulary.format(Vocabulary.Keys.Latitude)));
}
@@ -552,7 +552,7 @@ public class DefaultGeographicBoundingBox extends AbstractGeographicExtent imple
/*
* IMPLEMENTATION NOTE: For the handling of anti-meridian spanning in union and intersection operations,
* this class applies a different strategy than GeneralEnvelope. Instead than trying to work directly with
- * the ordinate values without adding or removing offset (which may cause rounding errors), we apply a ±360°
+ * the coordinate values without adding or removing offset (which may cause rounding errors), we apply a ±360°
* shift on longitude values. This simpler strategy is okay here because the range is fixed in the code (not
* an arbitrarily high range), and GeographicBoundingBox are approximations by definition anyway.
*/
diff --git a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java
index 253501c..f675f6c 100644
--- a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java
+++ b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/GeohashReferenceSystem.java
@@ -286,7 +286,7 @@ public class GeohashReferenceSystem extends ReferencingByIdentifiers {
/*
* The current implementation assumes a two-dimensional coordinates. The 'isEven' boolean takes
* the 'true' value for longitude, and 'false' for latitude. We could extend this algorithm to
- * the multi-dimensional case by replacing 'isEven' by a counter over the ordinate dimension.
+ * the multi-dimensional case by replacing 'isEven' by a counter over the coordinate dimension.
*/
boolean isEven = true;
double xmin = Longitude.MIN_VALUE, ymin = Latitude.MIN_VALUE;
@@ -381,7 +381,7 @@ public class GeohashReferenceSystem extends ReferencingByIdentifiers {
/*
* The current implementation assumes a two-dimensional coordinates. The 'isEven' boolean takes
* the 'true' value for longitude, and 'false' for latitude. We could extend this algorithm to
- * the multi-dimensional case by replacing 'isEven' by a counter over the ordinate dimension.
+ * the multi-dimensional case by replacing 'isEven' by a counter over the coordinate dimension.
*/
boolean isEven = true;
minX = Longitude.MIN_VALUE;
diff --git a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java
index 7667c0a..b176415 100644
--- a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java
+++ b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/MilitaryGridReferenceSystem.java
@@ -642,7 +642,7 @@ public class MilitaryGridReferenceSystem extends ReferencingByIdentifiers {
* The Coordinate Reference System (CRS) associated to the returned position depends on the given reference.
*
* @param reference MGRS string to decode.
- * @return a new position with the longitude at ordinate 0 and latitude at ordinate 1.
+ * @return a new position with the longitude at coordinate 0 and latitude at coordinate 1.
* @throws TransformException if an error occurred while parsing the given string.
*/
public Location decode(final CharSequence reference) throws TransformException {
@@ -1482,7 +1482,7 @@ public class MilitaryGridReferenceSystem extends ReferencingByIdentifiers {
final int zone = isUTM ? ZONER.zone(φ, λ) : POLE;
final int signedZone = MathFunctions.isNegative(φ) ? -zone : zone;
if (signedZone == 0) {
- // Zero value at this point is the result of NaN of infinite ordinate value.
+ // Zero value at this point is the result of NaN of infinite coordinate value.
throw new GazetteerException(Errors.format(Errors.Keys.NotANumber_1, "longitude"));
}
/*
diff --git a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java
index 276f8f5..7a98cbd 100644
--- a/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java
+++ b/core/sis-referencing-by-identifiers/src/main/java/org/apache/sis/referencing/gazetteer/SimpleLocation.java
@@ -157,7 +157,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
}
/**
- * Returns the centroid ordinate value for the specified dimension.
+ * Returns the centroid coordinate value for the specified dimension.
*/
@Override
public final double getOrdinate(final int dimension) {
@@ -165,7 +165,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
}
/**
- * Returns the minimal ordinate value for the specified dimension.
+ * Returns the minimal coordinate value for the specified dimension.
*/
@Override
public final double getMinimum(final int dimension) {
@@ -177,7 +177,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
}
/**
- * Returns the maximal ordinate value for the specified dimension.
+ * Returns the maximal coordinate value for the specified dimension.
*/
@Override
public final double getMaximum(final int dimension) {
@@ -189,7 +189,7 @@ class SimpleLocation extends AbstractLocation implements DirectPosition, Envelop
}
/**
- * Returns the median ordinate value for the specified dimension.
+ * Returns the median coordinate value for the specified dimension.
*/
@Override
public final double getMedian(final int dimension) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
index f512d0a..6d62407 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractDirectPosition.java
@@ -98,23 +98,22 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
}
/**
- * Returns a sequence of numbers that hold the coordinate of this position in its
- * reference system.
+ * Returns a sequence of numbers that hold the coordinate of this position in its reference system.
*
* @return the coordinates.
*/
@Override
public double[] getCoordinate() {
- final double[] ordinates = new double[getDimension()];
- for (int i=0; i<ordinates.length; i++) {
- ordinates[i] = getOrdinate(i);
+ final double[] coordinates = new double[getDimension()];
+ for (int i=0; i<coordinates.length; i++) {
+ coordinates[i] = getOrdinate(i);
}
- return ordinates;
+ return coordinates;
}
/**
* Sets this direct position to the given position. If the given position is
- * {@code null}, then all ordinate values are set to {@link Double#NaN NaN}.
+ * {@code null}, then all coordinate values are set to {@link Double#NaN NaN}.
*
* <p>If this position and the given position have a non-null CRS, then the default implementation
* requires the CRS to be {@linkplain Utilities#equalsIgnoreMetadata equals (ignoring metadata)},
@@ -150,19 +149,19 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
/**
* Ensures that the position is contained in the coordinate system domain.
- * For each dimension, this method compares the ordinate values against the
+ * For each dimension, this method compares the coordinate values against the
* limits of the coordinate system axis for that dimension.
- * If some ordinates are out of range, then there is a choice depending on the
+ * If some coordinates are out of range, then there is a choice depending on the
* {@linkplain CoordinateSystemAxis#getRangeMeaning() axis range meaning}:
*
* <ul>
- * <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> ordinates), then values
+ * <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> coordinates), then values
* greater than the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximal value}
* are replaced by the axis maximum, and values smaller than the
* {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimal value}
* are replaced by the axis minimum.</li>
*
- * <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> ordinates), then
+ * <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> coordinates), then
* a multiple of the axis range (e.g. 360° for longitudes) is added or subtracted.</li>
* </ul>
*
@@ -178,24 +177,24 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
final int dimension = getDimension();
final CoordinateSystem cs = crs.getCoordinateSystem();
for (int i=0; i<dimension; i++) {
- double ordinate = getOrdinate(i);
+ double coordinate = getOrdinate(i);
final CoordinateSystemAxis axis = cs.getAxis(i);
final double minimum = axis.getMinimumValue();
final double maximum = axis.getMaximumValue();
final RangeMeaning rm = axis.getRangeMeaning();
if (RangeMeaning.EXACT.equals(rm)) {
- if (ordinate < minimum) ordinate = minimum;
- else if (ordinate > maximum) ordinate = maximum;
+ if (coordinate < minimum) coordinate = minimum;
+ else if (coordinate > maximum) coordinate = maximum;
else continue;
} else if (RangeMeaning.WRAPAROUND.equals(rm)) {
final double csSpan = maximum - minimum;
- final double shift = Math.floor((ordinate - minimum) / csSpan) * csSpan;
+ final double shift = Math.floor((coordinate - minimum) / csSpan) * csSpan;
if (shift == 0) {
continue;
}
- ordinate -= shift;
+ coordinate -= shift;
}
- setOrdinate(i, ordinate);
+ setOrdinate(i, coordinate);
changed = true;
}
}
@@ -205,7 +204,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
/**
* Formats this position in the <cite>Well Known Text</cite> (WKT) format.
* The format is like below, where {@code x₀}, {@code x₁}, {@code x₂}, <i>etc.</i>
- * are the ordinate values at index 0, 1, 2, <i>etc.</i>:
+ * are the coordinate values at index 0, 1, 2, <i>etc.</i>:
*
* {@preformat wkt
* POINT[x₀ x₁ x₂ …]
@@ -232,7 +231,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
/**
* Formats this position in the <cite>Well Known Text</cite> (WKT) format.
* The returned string is like below, where {@code x₀}, {@code x₁}, {@code x₂}, <i>etc.</i>
- * are the ordinate values at index 0, 1, 2, <i>etc.</i>:
+ * are the coordinate values at index 0, 1, 2, <i>etc.</i>:
*
* {@preformat wkt
* POINT(x₀ x₁ x₂ …)
@@ -255,7 +254,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
* (WKT) format.
*
* @param position the position to format.
- * @param isSinglePrecision {@code true} if every ordinate values can be casted to {@code float}.
+ * @param isSinglePrecision {@code true} if every coordinate values can be casted to {@code float}.
* @return the point as a {@code POINT} in WKT format.
*
* @see ArraysExt#isSinglePrecision(double[])
@@ -269,11 +268,11 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
char separator = '(';
for (int i=0; i<dimension; i++) {
buffer.append(separator);
- final double ordinate = position.getOrdinate(i);
+ final double coordinate = position.getOrdinate(i);
if (isSinglePrecision) {
- buffer.append((float) ordinate);
+ buffer.append((float) coordinate);
} else {
- buffer.append(ordinate);
+ buffer.append(coordinate);
}
trimFractionalPart(buffer);
separator = ' ';
@@ -287,7 +286,7 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
* Parses the given WKT.
*
* @param wkt the WKT to parse.
- * @return the ordinates, or {@code null} if none.
+ * @return the coordinates, or {@code null} if none.
* @throws NumberFormatException if a number can not be parsed.
* @throws IllegalArgumentException if the parenthesis are not balanced.
*/
@@ -342,10 +341,10 @@ public abstract class AbstractDirectPosition extends FormattableObject implement
}
/*
* Index i is either at the beginning of a number or at the closing parenthesis.
- * Now process every space-separated ordinates until we reach the closing parenthesis
+ * Now process every space-separated coordinates until we reach the closing parenthesis
* or the end of string.
*/
- double[] ordinates = new double[2];
+ double[] coordinates = new double[2];
int dimension = 0;
parse: while (i < length) {
final int start = i;
@@ -362,10 +361,10 @@ parse: while (i < length) {
* IllegalArgumentException subclass, so we are compliant with the contract.
*/
final double value = Double.parseDouble(wkt.subSequence(start, i).toString());
- if (dimension == ordinates.length) {
- ordinates = Arrays.copyOf(ordinates, dimension*2);
+ if (dimension == coordinates.length) {
+ coordinates = Arrays.copyOf(coordinates, dimension*2);
}
- ordinates[dimension++] = value;
+ coordinates[dimension++] = value;
/*
* Skip whitespaces. If we reach the end of string without finding
* the closing parenthesis, check if we were suppose to have any.
@@ -378,7 +377,7 @@ parse: while (i < length) {
c = Character.codePointAt(wkt, i);
}
}
- return ArraysExt.resize(ordinates, dimension);
+ return ArraysExt.resize(coordinates, dimension);
}
/**
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java
index 77f14b1..6a55239 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/AbstractEnvelope.java
@@ -264,7 +264,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * A coordinate position consisting of all the lower ordinate values.
+ * A coordinate position consisting of all the lower coordinate values.
* The default implementation returns a view over the {@link #getLower(int)} method,
* so changes in this envelope will be immediately reflected in the returned direct position.
* If the particular case of the {@code GeneralEnvelope} subclass, the returned position
@@ -279,7 +279,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
* lower corner longitude greater than the upper corner longitude. Such extended interpretation applies
* mostly to axes having {@code WRAPAROUND} range meaning.</div>
*
- * @return a view over the lower corner, typically (but not necessarily) containing minimal ordinate values.
+ * @return a view over the lower corner, typically (but not necessarily) containing minimal coordinate values.
*/
@Override
public DirectPosition getLowerCorner() {
@@ -289,7 +289,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * A coordinate position consisting of all the upper ordinate values.
+ * A coordinate position consisting of all the upper coordinate values.
* The default implementation returns a view over the {@link #getUpper(int)} method,
* so changes in this envelope will be immediately reflected in the returned direct position.
* If the particular case of the {@code GeneralEnvelope} subclass, the returned position
@@ -304,7 +304,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
* upper corner longitude less than the lower corner longitude. Such extended interpretation applies
* mostly to axes having {@code WRAPAROUND} range meaning.</div>
*
- * @return a view over the upper corner, typically (but not necessarily) containing maximal ordinate values.
+ * @return a view over the upper corner, typically (but not necessarily) containing maximal coordinate values.
*/
@Override
public DirectPosition getUpperCorner() {
@@ -314,7 +314,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * A coordinate position consisting of all the median ordinate values.
+ * A coordinate position consisting of all the median coordinate values.
* The default implementation returns a view over the {@link #getMedian(int)} method,
* so changes in this envelope will be immediately reflected in the returned direct position.
*
@@ -327,38 +327,38 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * Returns the limit in the direction of decreasing ordinate values in the specified dimension.
+ * Returns the limit in the direction of decreasing coordinate values in the specified dimension.
* This is usually the algebraic {@linkplain #getMinimum(int) minimum}, except if this envelope
* spans the anti-meridian.
*
- * @param dimension the dimension for which to obtain the ordinate value.
- * @return the starting ordinate value at the given dimension.
+ * @param dimension the dimension for which to obtain the coordinate value.
+ * @return the starting coordinate value at the given dimension.
* @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
* than the {@linkplain #getDimension() envelope dimension}.
*/
public abstract double getLower(int dimension) throws IndexOutOfBoundsException;
/**
- * Returns the limit in the direction of increasing ordinate values in the specified dimension.
+ * Returns the limit in the direction of increasing coordinate values in the specified dimension.
* This is usually the algebraic {@linkplain #getMaximum(int) maximum}, except if this envelope
* spans the anti-meridian.
*
- * @param dimension the dimension for which to obtain the ordinate value.
- * @return the starting ordinate value at the given dimension.
+ * @param dimension the dimension for which to obtain the coordinate value.
+ * @return the starting coordinate value at the given dimension.
* @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
* than the {@linkplain #getDimension() envelope dimension}.
*/
public abstract double getUpper(int dimension) throws IndexOutOfBoundsException;
/**
- * Returns the minimal ordinate value for the specified dimension. In the typical case
+ * Returns the minimal coordinate value for the specified dimension. In the typical case
* of non-empty envelopes <em>not</em> spanning the anti-meridian, this method returns the
* {@link #getLower(int)} value verbatim. In the case of envelope spanning the anti-meridian,
* this method returns the {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimum value}.
* If the range in the given dimension is invalid, then this method returns {@code NaN}.
*
- * @param dimension the dimension for which to obtain the ordinate value.
- * @return the minimal ordinate value at the given dimension.
+ * @param dimension the dimension for which to obtain the coordinate value.
+ * @return the minimal coordinate value at the given dimension.
* @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
* than the {@linkplain #getDimension() envelope dimension}.
*/
@@ -373,14 +373,14 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * Returns the maximal ordinate value for the specified dimension. In the typical case
+ * Returns the maximal coordinate value for the specified dimension. In the typical case
* of non-empty envelopes <em>not</em> spanning the anti-meridian, this method returns the
* {@link #getUpper(int)} value verbatim. In the case of envelope spanning the anti-meridian,
* this method returns the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximum value}.
* If the range in the given dimension is invalid, then this method returns {@code NaN}.
*
- * @param dimension the dimension for which to obtain the ordinate value.
- * @return the maximal ordinate value at the given dimension.
+ * @param dimension the dimension for which to obtain the coordinate value.
+ * @return the maximal coordinate value at the given dimension.
* @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
* than the {@linkplain #getDimension() envelope dimension}.
*/
@@ -395,7 +395,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * Returns the median ordinate along the specified dimension.
+ * Returns the median coordinate along the specified dimension.
* In most cases, the result is equals (minus rounding error) to:
*
* {@preformat java
@@ -412,8 +412,8 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
* space. If the axis range meaning is not {@code WRAPAROUND}, then this method returns
* {@link Double#NaN NaN}.
*
- * @param dimension the dimension for which to obtain the ordinate value.
- * @return the median ordinate at the given dimension, or {@link Double#NaN}.
+ * @param dimension the dimension for which to obtain the coordinate value.
+ * @return the median coordinate at the given dimension, or {@link Double#NaN}.
* @throws IndexOutOfBoundsException if the given index is negative or is equals or greater
* than the {@linkplain #getDimension() envelope dimension}.
*/
@@ -588,7 +588,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
envelopes[0] = this;
} else {
/*
- * Need to create at least 2 envelopes. Instantiate now all envelopes with ordinate values
+ * Need to create at least 2 envelopes. Instantiate now all envelopes with coordinate values
* initialized to a copy of this envelope. We will write directly in their internal arrays later.
*/
double[] c = new double[dimension * 2];
@@ -596,26 +596,26 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
c[i ] = getLower(i);
c[i + dimension] = getUpper(i);
}
- final double[][] ordinates = new double[envelopes.length][];
+ final double[][] coordinates = new double[envelopes.length][];
for (int i=0; i<envelopes.length; i++) {
final GeneralEnvelope envelope = new GeneralEnvelope(i == 0 ? c : c.clone());
envelope.crs = crs;
envelopes[i] = envelope;
- ordinates[i] = envelope.ordinates;
+ coordinates[i] = envelope.coordinates;
}
/*
- * Assign the minimum and maximum ordinate values in the dimension where a wraparound has been found.
+ * Assign the minimum and maximum coordinate values in the dimension where a wraparound has been found.
* The 'for' loop below iterates only over the 'i' values for which the 'isWrapAround' bit is set to 1.
*/
- int mask = 1; // For identifying whether we need to set the lower or the upper ordinate.
+ int mask = 1; // For identifying whether we need to set the lower or the upper coordinate.
@SuppressWarnings("null")
final CoordinateSystem cs = crs.getCoordinateSystem(); // Should not be null at this point.
for (int i; (i = Long.numberOfTrailingZeros(isWrapAround)) != Long.SIZE; isWrapAround &= ~(1L << i)) {
final CoordinateSystemAxis axis = cs.getAxis(i);
final double min = axis.getMinimumValue();
final double max = axis.getMaximumValue();
- for (int j=0; j<ordinates.length; j++) {
- c = ordinates[j];
+ for (int j=0; j<coordinates.length; j++) {
+ c = coordinates[j];
if ((j & mask) == 0) {
c[i + dimension] = max;
} else {
@@ -662,7 +662,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * Returns {@code false} if at least one ordinate value is not {@linkplain Double#NaN NaN}.
+ * Returns {@code false} if at least one coordinate value is not {@linkplain Double#NaN NaN}.
* This {@code isAllNaN()} check is different than the {@link #isEmpty()} check since it
* returns {@code false} for a partially initialized envelope, while {@code isEmpty()}
* returns {@code false} only after all dimensions have been initialized.
@@ -696,7 +696,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
/**
* Tests if a specified coordinate is inside the boundary of this envelope.
* Both lower and upper values of this envelope are considered inclusive.
- * If it least one ordinate value in the given point is {@link Double#NaN NaN},
+ * If it least one coordinate value in the given point is {@link Double#NaN NaN},
* then this method returns {@code false}.
*
* <div class="section">Pre-conditions</div>
@@ -735,7 +735,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
* "Spanning the anti-meridian" case: if we reach this point, then the
* [upper...lower] range (note the 'lower' and 'upper' interchanging)
* is actually a space outside the envelope and we have checked that
- * the ordinate value is outside that space.
+ * the coordinate value is outside that space.
*/
continue;
}
@@ -980,7 +980,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * Returns {@code true} if at least one ordinate in the given envelope
+ * Returns {@code true} if at least one coordinate in the given envelope
* is {@link Double#NaN}. This is used for assertions only.
*/
static boolean hasNaN(final Envelope envelope) {
@@ -988,7 +988,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
}
/**
- * Returns {@code true} if at least one ordinate in the given position
+ * Returns {@code true} if at least one coordinate in the given position
* is {@link Double#NaN}. This is used for assertions only.
*/
static boolean hasNaN(final DirectPosition position) {
@@ -1025,7 +1025,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
* To be considered equal, the two envelopes must have the same {@linkplain #getDimension() dimension}
* and their CRS must be {@linkplain org.apache.sis.util.Utilities#equalsIgnoreMetadata equals,
* ignoring metadata}. If at least one envelope has a null CRS, then the CRS are ignored and the
- * ordinate values are compared as if the CRS were equal.
+ * coordinate values are compared as if the CRS were equal.
*
* @param other the envelope to compare with.
* @param eps the tolerance value to use for numerical comparisons.
@@ -1175,11 +1175,11 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
do { // Executed exactly twice.
for (int i=0; i<dimension; i++) {
buffer.append(i == 0 && !isUpper ? '(' : ' ');
- final double ordinate = (isUpper ? upperCorner : lowerCorner).getOrdinate(i);
+ final double coordinate = (isUpper ? upperCorner : lowerCorner).getOrdinate(i);
if (isSinglePrecision) {
- buffer.append((float) ordinate);
+ buffer.append((float) coordinate);
} else {
- buffer.append(ordinate);
+ buffer.append(coordinate);
}
trimFractionalPart(buffer);
}
@@ -1261,7 +1261,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
return getLower(dimension);
}
- /** Sets the ordinate value along the specified dimension. */
+ /** Sets the coordinate value along the specified dimension. */
@Override public void setOrdinate(final int dimension, final double value) {
setRange(dimension, value, getUpper(dimension));
}
@@ -1277,7 +1277,7 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
return getUpper(dimension);
}
- /** Sets the ordinate value along the specified dimension. */
+ /** Sets the coordinate value along the specified dimension. */
@Override public void setOrdinate(final int dimension, final double value) {
setRange(dimension, getLower(dimension), value);
}
@@ -1309,8 +1309,8 @@ public abstract class AbstractEnvelope extends FormattableObject implements Enve
* preserving the immutable aspect of {@link ImmutableEnvelope} subclass among others.</p>
*
* @param dimension the dimension to set.
- * @param lower the limit in the direction of decreasing ordinate values.
- * @param upper the limit in the direction of increasing ordinate values.
+ * @param lower the limit in the direction of decreasing coordinate values.
+ * @param upper the limit in the direction of increasing coordinate values.
* @throws UnmodifiableGeometryException if this envelope is not modifiable.
* @throws IndexOutOfBoundsException if the given index is out of bounds.
* @throws IllegalArgumentException if {@code lower > upper}, this envelope has a CRS
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java
index 14bbab6..9e87038 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ArrayEnvelope.java
@@ -44,11 +44,11 @@ import static org.apache.sis.internal.referencing.Formulas.isPoleToPole;
/**
- * Base class of envelopes backed by an array. The ordinate values are stored in the {@link #ordinates} array.
- * The ordinate values of the lower corner are stored in the array portion from index {@link #beginIndex()}
- * inclusive to index {@link #endIndex()} exclusive. The ordinate values of the upper corner are stored in
+ * Base class of envelopes backed by an array. The coordinate values are stored in the {@link #coordinates} array.
+ * The coordinate values of the lower corner are stored in the array portion from index {@link #beginIndex()}
+ * inclusive to index {@link #endIndex()} exclusive. The coordinate values of the upper corner are stored in
* the array portion from index {@code beginIndex() + d} inclusive to index {@code endIndex() + d} exclusive
- * where {@code d = ordinates.length >>> 1}.
+ * where {@code d = coordinates.length >>> 1}.
*
* <p>Unless otherwise indicated by a "{@code // Must be overridden in SubEnvelope}" comment, every methods
* in {@code ArrayEnvelope} and subclasses must take in account the {@code beginIndex} and {@code endIndex}
@@ -64,14 +64,14 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
/**
* Serial number for inter-operability with different versions.
*/
- private static final long serialVersionUID = 1657970968782634545L;
+ private static final long serialVersionUID = 3685400961133848112L;
/**
- * Ordinate values of lower and upper corners. Except for {@link SubEnvelope}, the length of
- * this array is twice the number of dimensions. The first half contains the lower corner,
+ * Coordinate values of lower and upper corners. Except for {@link SubEnvelope}, the length
+ * of this array is twice the number of dimensions. The first half contains the lower corner,
* while the second half contains the upper corner.
*/
- final double[] ordinates;
+ final double[] coordinates;
/**
* The coordinate reference system, or {@code null}.
@@ -79,14 +79,14 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
CoordinateReferenceSystem crs;
/**
- * Creates a new envelope using the given array of ordinate values. This constructor stores
+ * Creates a new envelope using the given array of coordinate values. This constructor stores
* the given reference directly; it does <strong>not</strong> clone the given array. This is
* the desired behavior for proper working of {@link SubEnvelope}.
*
- * @param ordinates the array of ordinate values to store directly (not cloned).
+ * @param coordinates the array of coordinate values to store directly (not cloned).
*/
- ArrayEnvelope(final double[] ordinates) {
- this.ordinates = ordinates;
+ ArrayEnvelope(final double[] coordinates) {
+ this.coordinates = coordinates;
}
/*
@@ -99,8 +99,8 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
* If at least one corner is associated to a CRS, then the new envelope will also
* be associated to that CRS.
*
- * @param lowerCorner the limits in the direction of decreasing ordinate values for each dimension.
- * @param upperCorner the limits in the direction of increasing ordinate values for each dimension.
+ * @param lowerCorner the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upperCorner the limits in the direction of increasing coordinate values for each dimension.
* @throws MismatchedDimensionException if the two positions do not have the same dimension.
* @throws MismatchedReferenceSystemException if the CRS of the two position are not equal.
*/
@@ -111,49 +111,49 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
final int dimension = lowerCorner.getDimension();
ensureDimensionMatches("crs", dimension, crs);
ensureSameDimension(dimension, upperCorner.getDimension());
- ordinates = new double[dimension * 2];
+ coordinates = new double[dimension * 2];
for (int i=0; i<dimension; i++) {
- ordinates[i ] = lowerCorner.getOrdinate(i);
- ordinates[i + dimension] = upperCorner.getOrdinate(i);
+ coordinates[i ] = lowerCorner.getOrdinate(i);
+ coordinates[i + dimension] = upperCorner.getOrdinate(i);
}
- verifyRanges(crs, ordinates);
+ verifyRanges(crs, coordinates);
}
/**
- * Constructs an envelope defined by two corners given as sequences of ordinate values.
+ * Constructs an envelope defined by two corners given as sequences of coordinate values.
* The Coordinate Reference System is initially {@code null}.
*
- * @param lowerCorner the limits in the direction of decreasing ordinate values for each dimension.
- * @param upperCorner the limits in the direction of increasing ordinate values for each dimension.
+ * @param lowerCorner the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upperCorner the limits in the direction of increasing coordinate values for each dimension.
* @throws MismatchedDimensionException if the two sequences do not have the same length.
*/
public ArrayEnvelope(final double[] lowerCorner, final double[] upperCorner) throws MismatchedDimensionException {
ensureNonNull("lowerCorner", lowerCorner);
ensureNonNull("upperCorner", upperCorner);
ensureSameDimension(lowerCorner.length, upperCorner.length);
- ordinates = Arrays.copyOf(lowerCorner, lowerCorner.length + upperCorner.length);
- System.arraycopy(upperCorner, 0, ordinates, lowerCorner.length, upperCorner.length);
+ coordinates = Arrays.copyOf(lowerCorner, lowerCorner.length + upperCorner.length);
+ System.arraycopy(upperCorner, 0, coordinates, lowerCorner.length, upperCorner.length);
}
/**
- * Constructs an empty envelope of the specified dimension. All ordinates
+ * Constructs an empty envelope of the specified dimension. All coordinates
* are initialized to 0 and the coordinate reference system is undefined.
*
* @param dimension the envelope dimension.
*/
public ArrayEnvelope(final int dimension) {
- ordinates = new double[dimension * 2];
+ coordinates = new double[dimension * 2];
}
/**
* Constructs an empty envelope with the specified coordinate reference system.
- * All ordinate values are initialized to 0.
+ * All coordinate values are initialized to 0.
*
* @param crs the coordinate reference system.
*/
public ArrayEnvelope(final CoordinateReferenceSystem crs) {
ensureNonNull("crs", crs);
- ordinates = new double[crs.getCoordinateSystem().getDimension() * 2];
+ coordinates = new double[crs.getCoordinateSystem().getDimension() * 2];
this.crs = crs;
}
@@ -166,14 +166,14 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
ensureNonNull("envelope", envelope);
crs = envelope.getCoordinateReferenceSystem();
final int dimension = envelope.getDimension();
- ordinates = new double[dimension * 2];
+ coordinates = new double[dimension * 2];
final DirectPosition lowerCorner = envelope.getLowerCorner();
final DirectPosition upperCorner = envelope.getUpperCorner();
for (int i=0; i<dimension; i++) {
- ordinates[i] = lowerCorner.getOrdinate(i);
- ordinates[i+dimension] = upperCorner.getOrdinate(i);
+ coordinates[i] = lowerCorner.getOrdinate(i);
+ coordinates[i+dimension] = upperCorner.getOrdinate(i);
}
- verifyRanges(crs, ordinates);
+ verifyRanges(crs, coordinates);
}
/**
@@ -186,20 +186,20 @@ class ArrayEnvelope extends AbstractEnvelope implements Serializable {
*/
public ArrayEnvelope(final GeographicBoundingBox box) {
ensureNonNull("box", box);
- ordinates = new double[] {
+ coordinates = new double[] {
box.getWestBoundLongitude(),
box.getSouthBoundLatitude(),
box.getEastBoundLongitude(),
box.getNorthBoundLatitude()
};
if (Boolean.FALSE.equals(box.getInclusion())) {
- ArraysExt.swap(ordinates, 0, ordinates.length >>> 1);
- if (!isPoleToPole(ordinates[1], ordinates[3])) {
- ArraysExt.swap(ordinates, 1, (ordinates.length >>> 1) + 1);
+ ArraysExt.swap(coordinates, 0, coordinates.length >>> 1);
+ if (!isPoleToPole(coordinates[1], coordinates[3])) {
+ ArraysExt.swap(coordinates, 1, (coordinates.length >>> 1) + 1);
}
}
crs = CommonCRS.defaultGeographic();
- verifyRanges(crs, ordinates);
+ verifyRanges(crs, coordinates);
}
/**
@@ -297,8 +297,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
}
if (levelParenth != 0) fail(wkt, ')');
if (levelBracket != 0) fail(wkt, ']');
- ordinates = ArraysExt.resize(minimum, maxDimension << 1);
- System.arraycopy(maximum, 0, ordinates, maxDimension, maxDimension);
+ coordinates = ArraysExt.resize(minimum, maxDimension << 1);
+ System.arraycopy(maximum, 0, coordinates, maxDimension, maxDimension);
}
/**
@@ -320,7 +320,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
}
/**
- * Verifies the validity of the range of ordinates values in the given array.
+ * Verifies the validity of the range of coordinates values in the given array.
* If the given CRS is null, then this method conservatively does nothing.
* Otherwise this method performs the following verifications:
*
@@ -328,7 +328,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
* <li>{@code lower > upper} is allowed only for axes having {@link RangeMeaning#WRAPAROUND}.</li>
* </ul>
*
- * This method does <strong>not</strong> verify if the ordinate values are between the axis minimum and
+ * This method does <strong>not</strong> verify if the coordinate values are between the axis minimum and
* maximum values. This is because out-of-range values exist in practice but do not impact the working
* of {@code add(…)}, {@code intersect(…)}, {@code contains(…)} and similar methods. This in contrast
* with the checks listed above, where failure to met those conditions will cause the methods to
@@ -342,15 +342,15 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
* <li>{@link SubEnvelope#setRange(int, double, double)}</li>
* </ul>
*
- * @param crs the coordinate reference system, or {@code null}.
- * @param ordinates the array of ordinate values to verify.
+ * @param crs the coordinate reference system, or {@code null}.
+ * @param coordinates the array of coordinate values to verify.
*/
- static void verifyRanges(final CoordinateReferenceSystem crs, final double[] ordinates) {
+ static void verifyRanges(final CoordinateReferenceSystem crs, final double[] coordinates) {
if (crs != null) {
- final int dimension = ordinates.length >>> 1;
+ final int dimension = coordinates.length >>> 1;
for (int i=0; i<dimension; i++) {
- final double lower = ordinates[i];
- final double upper = ordinates[i + dimension];
+ final double lower = coordinates[i];
+ final double upper = coordinates[i + dimension];
if (lower > upper && !isWrapAround(crs, i)) {
throw new IllegalArgumentException(illegalRange(crs, i, lower, upper));
}
@@ -359,7 +359,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
}
/**
- * Creates an error message for an illegal ordinates range at the given dimension.
+ * Creates an error message for an illegal coordinates range at the given dimension.
* This is used for formatting the exception message.
*/
static String illegalRange(final CoordinateReferenceSystem crs,
@@ -369,11 +369,11 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
if (name == null) {
name = dimension; // Paranoiac fallback (name should never be null).
}
- return Errors.format(Errors.Keys.IllegalOrdinateRange_3, lower, upper, name);
+ return Errors.format(Errors.Keys.IllegalCoordinateRange_3, lower, upper, name);
}
/**
- * Returns the index of the first valid ordinate value of the lower corner in the {@link #ordinates} array.
+ * Returns the index of the first valid coordinate value of the lower corner in the {@link #coordinates} array.
* This is always 0, unless this envelope is a {@link SubEnvelope}.
*
* <p>See {@link #endIndex()} for the list of methods that need to be also overridden
@@ -384,8 +384,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
}
/**
- * Returns the index after the last valid ordinate value of the lower corner in the {@link #ordinates} array.
- * This is always {@code ordinates.length >>> 1}, unless this envelope is a {@link SubEnvelope}.
+ * Returns the index after the last valid coordinate value of the lower corner in the {@link #coordinates} array.
+ * This is always {@code coordinates.length >>> 1}, unless this envelope is a {@link SubEnvelope}.
*
* <p>Unless otherwise indicated by a "{@code // Must be overridden in SubEnvelope}" comment, every methods
* in {@code ArrayEnvelope} and subclasses must take in account the {@code beginIndex} and {@code endIndex}
@@ -402,7 +402,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
* </ul>
*/
int endIndex() {
- return ordinates.length >>> 1;
+ return coordinates.length >>> 1;
}
/**
@@ -414,7 +414,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
*/
@Override // Must also be overridden in SubEnvelope
public int getDimension() {
- return ordinates.length >>> 1;
+ return coordinates.length >>> 1;
}
/**
@@ -435,8 +435,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
*/
@Override // Must also be overridden in SubEnvelope
public double getLower(final int dimension) throws IndexOutOfBoundsException {
- ensureValidIndex(ordinates.length >>> 1, dimension);
- return ordinates[dimension];
+ ensureValidIndex(coordinates.length >>> 1, dimension);
+ return coordinates[dimension];
}
/**
@@ -444,9 +444,9 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
*/
@Override // Must also be overridden in SubEnvelope
public double getUpper(final int dimension) throws IndexOutOfBoundsException {
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
ensureValidIndex(d, dimension);
- return ordinates[dimension + d];
+ return coordinates[dimension + d];
}
/**
@@ -456,8 +456,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
public double getMinimum(final int dimension) throws IndexOutOfBoundsException {
ensureValidIndex(endIndex(), dimension);
final int i = dimension + beginIndex();
- double lower = ordinates[i];
- if (isNegative(ordinates[i + (ordinates.length >>> 1)] - lower)) { // Special handling for -0.0
+ double lower = coordinates[i];
+ if (isNegative(coordinates[i + (coordinates.length >>> 1)] - lower)) { // Special handling for -0.0
final CoordinateSystemAxis axis = getAxis(crs, dimension);
lower = isWrapAround(axis) ? axis.getMinimumValue() : Double.NaN;
}
@@ -471,8 +471,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
public double getMaximum(final int dimension) throws IndexOutOfBoundsException {
ensureValidIndex(endIndex(), dimension);
final int i = dimension + beginIndex();
- double upper = ordinates[i + (ordinates.length >>> 1)];
- if (isNegative(upper - ordinates[i])) { // Special handling for -0.0
+ double upper = coordinates[i + (coordinates.length >>> 1)];
+ if (isNegative(upper - coordinates[i])) { // Special handling for -0.0
final CoordinateSystemAxis axis = getAxis(crs, dimension);
upper = isWrapAround(axis) ? axis.getMaximumValue() : Double.NaN;
}
@@ -486,8 +486,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
public double getMedian(final int dimension) throws IndexOutOfBoundsException {
ensureValidIndex(endIndex(), dimension);
final int i = dimension + beginIndex();
- final double minimum = ordinates[i];
- final double maximum = ordinates[i + (ordinates.length >>> 1)];
+ final double minimum = coordinates[i];
+ final double maximum = coordinates[i + (coordinates.length >>> 1)];
double median = 0.5 * (minimum + maximum);
if (isNegative(maximum - minimum)) { // Special handling for -0.0
median = fixMedian(getAxis(crs, dimension), median);
@@ -502,7 +502,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
public double getSpan(final int dimension) throws IndexOutOfBoundsException {
ensureValidIndex(endIndex(), dimension);
final int i = dimension + beginIndex();
- double span = ordinates[i + (ordinates.length >>> 1)] - ordinates[i];
+ double span = coordinates[i + (coordinates.length >>> 1)] - coordinates[i];
if (isNegative(span)) { // Special handling for -0.0
span = fixSpan(getAxis(crs, dimension), span);
}
@@ -519,9 +519,9 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
if (beginIndex == endIndex) {
return true;
}
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=beginIndex; i<endIndex; i++) {
- final double span = ordinates[i+d] - ordinates[i];
+ final double span = coordinates[i+d] - coordinates[i];
if (!(span > 0)) { // Use '!' in order to catch NaN
if (!(isNegative(span) && isWrapAround(crs, i - beginIndex))) {
return true;
@@ -537,8 +537,8 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
*/
@Override // Must also be overridden in SubEnvelope
public boolean isAllNaN() {
- for (int i=0; i<ordinates.length; i++) {
- if (!Double.isNaN(ordinates[i])) {
+ for (int i=0; i<coordinates.length; i++) {
+ if (!Double.isNaN(coordinates[i])) {
return false;
}
}
@@ -551,7 +551,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
*/
@Override // Must also be overridden in SubEnvelope
public int hashCode() {
- int code = Arrays.hashCode(ordinates);
+ int code = Arrays.hashCode(coordinates);
if (crs != null) {
code += crs.hashCode();
}
@@ -561,7 +561,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
/**
* Computes the hash code value using the public API instead than direct access to the
- * {@link #ordinates} array. This method is invoked from {@link SubEnvelope}.
+ * {@link #coordinates} array. This method is invoked from {@link SubEnvelope}.
*/
final int hashCodeByAPI() {
return super.hashCode();
@@ -574,7 +574,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
public boolean equals(final Object object) {
if (object != null && object.getClass() == getClass()) {
final ArrayEnvelope that = (ArrayEnvelope) object;
- return Arrays.equals(this.ordinates, that.ordinates) &&
+ return Arrays.equals(this.coordinates, that.coordinates) &&
Objects.equals(this.crs, that.crs);
}
return false;
@@ -582,7 +582,7 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
/**
* Compares the given object for equality using the public API instead than direct access
- * to the {@link #ordinates} array. This method is invoked from {@link SubEnvelope}.
+ * to the {@link #coordinates} array. This method is invoked from {@link SubEnvelope}.
*/
final boolean equalsByAPI(final Object object) {
return super.equals(object);
@@ -593,6 +593,6 @@ scanNumber: while ((i += Character.charCount(c)) < length) {
*/
@Override
public String toString() {
- return toString(this, ArraysExt.isSinglePrecision(ordinates));
+ return toString(this, ArraysExt.isSinglePrecision(coordinates));
}
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java
index 7e851f9..3ea8468 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CoordinateFormat.java
@@ -62,13 +62,13 @@ import org.apache.sis.io.CompoundFormat;
/**
* Formats spatiotemporal coordinates using number, angle and date formats inferred from the coordinate system.
- * The format for each ordinate is inferred from the
+ * The format for each coordinate is inferred from the
* {@linkplain org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis#getUnit() coordinate system units}
* using the following rules:
*
* <ul>
- * <li>Ordinate values in angular units are formatted as angles using {@link AngleFormat}.</li>
- * <li>Ordinate values in temporal units are formatted as dates using {@link DateFormat}.</li>
+ * <li>Coordinate values in angular units are formatted as angles using {@link AngleFormat}.</li>
+ * <li>Coordinate values in temporal units are formatted as dates using {@link DateFormat}.</li>
* <li>Other values are formatted as numbers using {@link NumberFormat} followed by the unit symbol
* formatted by {@link org.apache.sis.measure.UnitFormat}.</li>
* </ul>
@@ -163,13 +163,13 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
private transient UnitConverter[] toFormatUnit;
/**
- * Units symbols. Used only for ordinate to be formatted as ordinary numbers.
- * Non-null only if at least one ordinate is to be formatted that way.
+ * Units symbols. Used only for coordinate to be formatted as ordinary numbers.
+ * Non-null only if at least one coordinate is to be formatted that way.
*/
private transient String[] unitSymbols;
/**
- * Flags the ordinate values that need to be inverted before to be formatted.
+ * Flags the coordinate values that need to be inverted before to be formatted.
* This is needed for example if the axis is oriented toward past instead than future,
* or toward west instead than east.
*
@@ -178,7 +178,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
private transient long negate;
/**
- * The time epochs. Non-null only if the at least on ordinate is to be formatted as a date.
+ * The time epochs. Non-null only if the at least on coordinate is to be formatted as a date.
*/
private transient long[] epochs;
@@ -365,7 +365,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
}
/**
- * Remembers that ordinate values at the given dimension will need to have their sign reverted.
+ * Remembers that coordinate values at the given dimension will need to have their sign reverted.
*/
private void negate(final int dimension) {
if (dimension >= Long.SIZE) {
@@ -575,7 +575,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
* <tr><td>{@link Date}</td> <td>{@link DateFormat}</td> <td>{@link SimpleDateFormat}</td></tr>
* </table>
*
- * @param valueType the base type of ordinate values to parse and format:
+ * @param valueType the base type of coordinate values to parse and format:
* {@code Number.class}, {@code Angle.class} or {@code Date.class}.
* @return the pattern for fields of the given type, or {@code null} if not applicable.
*
@@ -600,17 +600,17 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
*
* <ul>
* <li>If {@code valueType} is {@code Number.class}, then the pattern syntax shall be as described in the
- * {@link DecimalFormat} class. This pattern may be used for any ordinate to be formatted as plain number,
+ * {@link DecimalFormat} class. This pattern may be used for any coordinate to be formatted as plain number,
* for example in {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian coordinate system}.</li>
* <li>If {@code valueType} is {@code Angle.class}, then the pattern syntax shall be as described in the
- * {@link AngleFormat} class. This pattern may be used for any ordinate to be formatted as latitude or longitude,
+ * {@link AngleFormat} class. This pattern may be used for any coordinate to be formatted as latitude or longitude,
* for example in {@linkplain org.apache.sis.referencing.cs.DefaultEllipsoidalCS ellipsoidal coordinate system}.</li>
* <li>If {@code valueType} is {@code Date.class}, then the pattern syntax shall be as described in the
- * {@link SimpleDateFormat} class. This pattern may be used for any ordinate to be formatted as date and time,
+ * {@link SimpleDateFormat} class. This pattern may be used for any coordinate to be formatted as date and time,
* for example in {@linkplain org.apache.sis.referencing.cs.DefaultTimeCS time coordinate system}.</li>
* </ul>
*
- * @param valueType the base type of ordinate values to parse and format:
+ * @param valueType the base type of coordinate values to parse and format:
* {@code Number.class}, {@code Angle.class} or {@code Date.class}.
* @param pattern the pattern as specified in {@link DecimalFormat}, {@link AngleFormat}
* or {@link SimpleDateFormat} javadoc.
@@ -703,11 +703,11 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
dummy = new FieldPosition(0);
}
/*
- * The format to use for each ordinate has been computed by 'initialize'. The format array length
+ * The format to use for each coordinate has been computed by 'initialize'. The format array length
* should match the number of dimensions in the given position if the DirectPosition is consistent
* with its CRS, but we will nevertheless verify has a paranoiac check. If there is no CRS, or if
* the DirectPosition dimension is (illegally) greater than the CRS dimension, then we will format
- * the ordinate as a number.
+ * the coordinate as a number.
*/
final int dimension = position.getDimension();
for (int i=0; i < dimension; i++) {
@@ -759,7 +759,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
* Parses a coordinate from the given character sequence.
* This method presumes that the coordinate reference system is the {@linkplain #getDefaultCRS() default CRS}.
* The parsing begins at the {@linkplain ParsePosition#getIndex() index} given by the {@code pos} argument.
- * If parsing succeeds, then the {@code pos} index is updated to the index after the last ordinate value and
+ * If parsing succeeds, then the {@code pos} index is updated to the index after the last coordinate value and
* the parsed coordinate is returned. Otherwise (if parsing fails), the {@code pos} index is left unchanged,
* the {@code pos} {@linkplain ParsePosition#getErrorIndex() error index} is set to the index of the first
* unparsable character and an exception is thrown with a similar {@linkplain ParseException#getErrorOffset()
@@ -794,28 +794,28 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
asString = text.subSequence(start, Math.min(start + READ_AHEAD_LIMIT, length)).toString();
}
/*
- * The Format instances to be used for each ordinate values is determined by the default CRS.
+ * The Format instances to be used for each coordinate values is determined by the default CRS.
* If no such CRS has been specified, then we will parse everything as plain numbers.
*/
if (lastCRS != defaultCRS) {
initialize(defaultCRS);
}
- final double[] ordinates;
+ final double[] coordinates;
Format format;
final Format[] formats = this.formats;
if (formats != null) {
format = null;
- ordinates = new double[formats.length];
+ coordinates = new double[formats.length];
} else {
format = getFormat(Number.class);
- ordinates = new double[DEFAULT_DIMENSION];
+ coordinates = new double[DEFAULT_DIMENSION];
}
/*
- * For each ordinate value except the first one, we need to skip the separator.
+ * For each coordinate value except the first one, we need to skip the separator.
* If we do not find the separator, we may consider that we reached the coordinate
* end ahead of time. We currently allow that only for coordinate without CRS.
*/
- for (int i=0; i < ordinates.length; i++) {
+ for (int i=0; i < coordinates.length; i++) {
if (i != 0) {
final int end = subPos.getIndex();
int index = offset + end;
@@ -829,7 +829,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
}
if (formats == null) {
pos.setIndex(index);
- return new GeneralDirectPosition(Arrays.copyOf(ordinates, i));
+ return new GeneralDirectPosition(Arrays.copyOf(coordinates, i));
}
pos.setIndex(start);
pos.setErrorIndex(index);
@@ -839,7 +839,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
subPos.setIndex(index + parseSeparator.length() - offset);
}
/*
- * At this point 'subPos' is set to the beginning of the next ordinate to parse in 'asString'.
+ * At this point 'subPos' is set to the beginning of the next coordinate to parse in 'asString'.
* Parse the value as a number, angle or date, as determined from the coordinate system axis.
*/
if (formats != null) {
@@ -849,7 +849,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
final Object object = format.parseObject(asString, subPos);
if (object == null) {
/*
- * If we failed to parse, build an error message with the type that was expected for that ordinate.
+ * If we failed to parse, build an error message with the type that was expected for that coordinate.
* If the given CharSequence was not a String, we may need to update the error index since we tried
* to parse only a substring.
*/
@@ -879,7 +879,7 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
/*
* The conversions and sign reversal applied below shall be in exact reverse order than
* in the 'format(…)' method. However we have one additional step compared to format(…):
- * the unit written after the ordinate value may not be the same than the unit declared
+ * the unit written after the coordinate value may not be the same than the unit declared
* in the CRS axis, so we have to parse the unit and convert the value before to apply
* the reverse of 'format(…)' steps.
*/
@@ -926,9 +926,9 @@ public class CoordinateFormat extends CompoundFormat<DirectPosition> {
if (isNegative(i)) {
value = -value;
}
- ordinates[i] = value;
+ coordinates[i] = value;
}
- final GeneralDirectPosition position = new GeneralDirectPosition(ordinates);
+ final GeneralDirectPosition position = new GeneralDirectPosition(coordinates);
position.setCoordinateReferenceSystem(defaultCRS);
return position;
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java
index 442dc9f..367a58f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/CurveExtremum.java
@@ -63,11 +63,11 @@ final class CurveExtremum {
* Finds the extremum of the unique cubic curve which fit the two given points and derivatives.
* See class javadoc for more information.
*
- * @param x1 the <var>x</var> ordinate of the first point.
- * @param y1 the <var>y</var> ordinate of the first point.
+ * @param x1 the <var>x</var> coordinate of the first point.
+ * @param y1 the <var>y</var> coordinate of the first point.
* @param dy1 the ∂<var>x</var>/∂<var>y</var> value at the first point.
- * @param x2 the <var>x</var> ordinate of the second point.
- * @param y2 the <var>y</var> ordinate of the second point.
+ * @param x2 the <var>x</var> coordinate of the second point.
+ * @param y2 the <var>y</var> coordinate of the second point.
* @param dy2 the ∂<var>x</var>/∂<var>y</var> value at the second point.
*/
void resolve(double x1, double y1, final double dy1,
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java
index 8a7d41e..653b092 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition1D.java
@@ -35,7 +35,7 @@ import static org.apache.sis.util.ArgumentChecks.ensureDimensionMatches;
* A one-dimensional position within some coordinate reference system.
*
* @author Martin Desruisseaux (IRD, Geomatys)
- * @version 0.3
+ * @version 1.0
*
* @see DirectPosition2D
* @see GeneralDirectPosition
@@ -48,7 +48,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
/**
* Serial number for inter-operability with different versions.
*/
- private static final long serialVersionUID = -9196647508968517838L;
+ private static final long serialVersionUID = -8318842301025970006L;
/**
* The coordinate reference system for this position;
@@ -56,9 +56,9 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
private CoordinateReferenceSystem crs;
/**
- * The ordinate value.
+ * The coordinate value.
*/
- public double ordinate;
+ public double coordinate;
/**
* Constructs a position initialized to (0) with a {@code null}
@@ -78,12 +78,12 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
}
/**
- * Constructs a 1D position from the specified ordinate.
+ * Constructs a 1D position from the specified coordinate.
*
- * @param ordinate the ordinate value.
+ * @param coordinate the coordinate value.
*/
- public DirectPosition1D(final double ordinate) {
- this.ordinate = ordinate;
+ public DirectPosition1D(final double coordinate) {
+ this.coordinate = coordinate;
}
/**
@@ -103,13 +103,13 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
* @see CoordinateFormat
*/
public DirectPosition1D(final CharSequence wkt) throws IllegalArgumentException {
- final double[] ordinates = parse(wkt);
- if (ordinates == null) {
+ final double[] coordinates = parse(wkt);
+ if (coordinates == null) {
throw new IllegalArgumentException(Errors.format(
Errors.Keys.UnparsableStringForClass_2, "POINT", wkt));
}
- ensureDimensionMatches("wkt", 1, ordinates);
- ordinate = ordinates[0];
+ ensureDimensionMatches("wkt", 1, coordinates);
+ coordinate = coordinates[0];
}
/**
@@ -149,45 +149,45 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
* Returns a sequence of numbers that hold the coordinate of this position in its reference system.
*
* <div class="note"><b>API note:</b>
- * This method is final for ensuring consistency with the {@link #ordinate} field, which is public.</div>
+ * This method is final for ensuring consistency with the {@link #coordinate} field, which is public.</div>
*
* @return the coordinates.
*/
@Override
public final double[] getCoordinate() {
- return new double[] {ordinate};
+ return new double[] {coordinate};
}
/**
- * Returns the ordinate at the specified dimension.
+ * Returns the coordinate at the specified dimension.
*
* <div class="note"><b>API note:</b>
- * This method is final for ensuring consistency with the {@link #ordinate} field, which is public.</div>
+ * This method is final for ensuring consistency with the {@link #coordinate} field, which is public.</div>
*
* @param dimension the dimension, which must be 0.
- * @return the {@linkplain #ordinate}.
+ * @return the {@link #coordinate}.
* @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
*/
@Override
public final double getOrdinate(final int dimension) throws IndexOutOfBoundsException {
if (dimension == 0) {
- return ordinate;
+ return coordinate;
} else {
throw new IndexOutOfBoundsException(Errors.format(Errors.Keys.IndexOutOfBounds_1, dimension));
}
}
/**
- * Sets the ordinate value along the specified dimension.
+ * Sets the coordinate value along the specified dimension.
*
* @param dimension the dimension, which must be 0.
- * @param value the ordinate value.
+ * @param value the coordinate value.
* @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
*/
@Override
public void setOrdinate(int dimension, double value) throws IndexOutOfBoundsException {
if (dimension == 0) {
- ordinate = value;
+ coordinate = value;
} else {
throw new IndexOutOfBoundsException(Errors.format(Errors.Keys.IndexOutOfBounds_1, dimension));
}
@@ -205,7 +205,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
public void setLocation(final DirectPosition position) throws MismatchedDimensionException {
ensureDimensionMatches("position", 1, position);
setCoordinateReferenceSystem(position.getCoordinateReferenceSystem());
- ordinate = position.getOrdinate(0);
+ coordinate = position.getOrdinate(0);
}
/**
@@ -213,7 +213,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
* The output is like below:
*
* {@preformat wkt
- * POINT(ordinate)
+ * POINT(coordinate)
* }
*
* The string returned by this method can be {@linkplain #DirectPosition1D(CharSequence) parsed}
@@ -221,7 +221,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
*/
@Override
public String toString() {
- return toString(this, ordinate == (float) ordinate);
+ return toString(this, coordinate == (float) coordinate);
}
/**
@@ -244,7 +244,7 @@ public class DirectPosition1D extends AbstractDirectPosition implements Serializ
*/
@Override
public int hashCode() {
- final int code = 31 + Double.hashCode(ordinate) + Objects.hashCode(crs);
+ final int code = 31 + Double.hashCode(coordinate) + Objects.hashCode(crs);
assert code == super.hashCode();
return code;
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java
index 8152d6e..5dcd775 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/DirectPosition2D.java
@@ -37,7 +37,7 @@ import static org.apache.sis.util.ArgumentChecks.ensureDimensionMatches;
* <p>This class inherits {@linkplain #x x} and {@linkplain #y y} fields.
* But despite their names, they don't need to be oriented toward {@linkplain AxisDirection#EAST East} and
* {@linkplain AxisDirection#NORTH North} respectively. The (<var>x</var>,<var>y</var>) axis can have any
- * direction and should be understood as <cite>ordinate 0</cite> and <cite>ordinate 1</cite> values instead.
+ * direction and should be understood as <cite>coordinate 0</cite> and <cite>coordinate 1</cite> values instead.
* This is not specific to this implementation; in Java2D too, the visual axis orientation depend
* on the {@linkplain java.awt.Graphics2D#getTransform() affine transform in the graphics context}.</p>
*
@@ -97,21 +97,21 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
}
/**
- * Constructs a 2D position from the specified ordinates. Despite their names,
+ * Constructs a 2D position from the specified coordinates. Despite their names,
* the (<var>x</var>,<var>y</var>) coordinates don't need to be oriented toward
* ({@linkplain AxisDirection#EAST East}, {@linkplain AxisDirection#NORTH North}).
* Those parameter names simply match the {@linkplain #x x} and {@linkplain #y y} fields.
* See the <a href="#skip-navbar_top">class javadoc</a> for details.
*
- * @param x the first ordinate value (not necessarily horizontal).
- * @param y the second ordinate value (not necessarily vertical).
+ * @param x the first coordinate value (not necessarily horizontal).
+ * @param y the second coordinate value (not necessarily vertical).
*/
public DirectPosition2D(final double x, final double y) {
super(x, y);
}
/**
- * Constructs a 2D position from the specified ordinates in the specified CRS.
+ * Constructs a 2D position from the specified coordinates in the specified CRS.
* Despite their names, the (<var>x</var>,<var>y</var>) coordinates don't need to be oriented
* toward ({@linkplain AxisDirection#EAST East}, {@linkplain AxisDirection#NORTH North}).
* Those parameter names simply match the {@linkplain #x x} and {@linkplain #y y} fields.
@@ -119,8 +119,8 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
* See the <a href="#skip-navbar_top">class javadoc</a> for details.
*
* @param crs the coordinate reference system, or {@code null}.
- * @param x the first ordinate value (not necessarily horizontal).
- * @param y the second ordinate value (not necessarily vertical).
+ * @param x the first coordinate value (not necessarily horizontal).
+ * @param y the second coordinate value (not necessarily vertical).
*/
public DirectPosition2D(final CoordinateReferenceSystem crs, final double x, final double y) {
super(x, y);
@@ -161,14 +161,14 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
* @see CoordinateFormat
*/
public DirectPosition2D(final CharSequence wkt) throws IllegalArgumentException {
- final double[] ordinates = AbstractDirectPosition.parse(wkt);
- if (ordinates == null) {
+ final double[] coordinates = AbstractDirectPosition.parse(wkt);
+ if (coordinates == null) {
throw new IllegalArgumentException(Errors.format(
Errors.Keys.UnparsableStringForClass_2, "POINT", wkt));
}
- ensureDimensionMatches("wkt", 2, ordinates);
- x = ordinates[0];
- y = ordinates[1];
+ ensureDimensionMatches("wkt", 2, coordinates);
+ x = coordinates[0];
+ y = coordinates[1];
}
/**
@@ -227,7 +227,7 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
}
/**
- * Returns the ordinate at the specified dimension.
+ * Returns the coordinate at the specified dimension.
*
* <div class="note"><b>API note:</b>
* This method is final for ensuring consistency with the {@code x} and {@code y} fields, which are public.</div>
@@ -246,10 +246,10 @@ public class DirectPosition2D extends Point2D.Double implements DirectPosition,
}
/**
- * Sets the ordinate value along the specified dimension.
+ * Sets the coordinate value along the specified dimension.
*
- * @param dimension the dimension for the ordinate of interest.
- * @param value the ordinate value of interest.
+ * @param dimension the dimension for the coordinate of interest.
+ * @param value the coordinate value of interest.
* @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
*/
@Override
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java
index 8188e29..dc0ac1d 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelope2D.java
@@ -57,7 +57,7 @@ import static org.apache.sis.geometry.AbstractEnvelope.isNegativeUnsafe;
* <p>This class inherits {@linkplain #x x} and {@linkplain #y y} fields.
* But despite their names, they don't need to be oriented toward {@linkplain AxisDirection#EAST East} and
* {@linkplain AxisDirection#NORTH North} respectively. The (<var>x</var>,<var>y</var>) axis can have any
- * direction and should be understood as <cite>ordinate 0</cite> and <cite>ordinate 1</cite> values instead.
+ * direction and should be understood as <cite>coordinate 0</cite> and <cite>coordinate 1</cite> values instead.
* This is not specific to this implementation; in Java2D too, the visual axis orientation depend
* on the {@linkplain java.awt.Graphics2D#getTransform() affine transform in the graphics context}.</p>
*
@@ -316,8 +316,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * The limits in the direction of decreasing ordinate values for the two dimensions.
- * This is typically a coordinate position consisting of the minimal ordinates for
+ * The limits in the direction of decreasing coordinate values for the two dimensions.
+ * This is typically a coordinate position consisting of the minimal coordinates for
* the two dimensions for all points within the {@code Envelope}.
*
* <p>The object returned by this method is a copy. Change in the returned position
@@ -331,7 +331,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
* lower corner longitude greater than the upper corner longitude. Such extended interpretation applies
* mostly to axes having {@code WRAPAROUND} range meaning.</div>
*
- * @return a copy of the lower corner, typically (but not necessarily) containing minimal ordinate values.
+ * @return a copy of the lower corner, typically (but not necessarily) containing minimal coordinate values.
*/
@Override
public DirectPosition2D getLowerCorner() {
@@ -339,8 +339,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * The limits in the direction of increasing ordinate values for the two dimensions.
- * This is typically a coordinate position consisting of the maximal ordinates for
+ * The limits in the direction of increasing coordinate values for the two dimensions.
+ * This is typically a coordinate position consisting of the maximal coordinates for
* the two dimensions for all points within the {@code Envelope}.
*
* <p>The object returned by this method is a copy. Change in the returned position
@@ -354,7 +354,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
* upper corner longitude less than the lower corner longitude. Such extended interpretation applies
* mostly to axes having {@code WRAPAROUND} range meaning.</div>
*
- * @return a copy of the upper corner, typically (but not necessarily) containing maximal ordinate values.
+ * @return a copy of the upper corner, typically (but not necessarily) containing maximal coordinate values.
*/
@Override
public DirectPosition2D getUpperCorner() {
@@ -369,12 +369,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the minimal ordinate along the specified dimension. This method handles
+ * Returns the minimal coordinate along the specified dimension. This method handles
* anti-meridian spanning as documented in the {@link AbstractEnvelope#getMinimum(int)}
* method.
*
* @param dimension the dimension to query.
- * @return the minimal ordinate value along the given dimension.
+ * @return the minimal coordinate value along the given dimension.
* @throws IndexOutOfBoundsException if the given index is out of bounds.
*/
@Override
@@ -393,12 +393,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the maximal ordinate along the specified dimension. This method handles
+ * Returns the maximal coordinate along the specified dimension. This method handles
* anti-meridian spanning as documented in the {@link AbstractEnvelope#getMaximum(int)}
* method.
*
* @param dimension the dimension to query.
- * @return the maximal ordinate value along the given dimension.
+ * @return the maximal coordinate value along the given dimension.
* @throws IndexOutOfBoundsException if the given index is out of bounds.
*/
@Override
@@ -417,12 +417,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the median ordinate along the specified dimension. This method handles
+ * Returns the median coordinate along the specified dimension. This method handles
* anti-meridian spanning as documented in the {@link AbstractEnvelope#getMedian(int)}
* method.
*
* @param dimension the dimension to query.
- * @return the mid ordinate value along the given dimension.
+ * @return the mid coordinate value along the given dimension.
* @throws IndexOutOfBoundsException if the given index is out of bounds.
*/
@Override
@@ -465,12 +465,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
// Do not override getX() and getY() - their default implementations is okay.
/**
- * Returns the {@linkplain #getMinimum(int) minimal} ordinate value for dimension 0.
+ * Returns the {@linkplain #getMinimum(int) minimal} coordinate value for dimension 0.
* The default implementation invokes <code>{@linkplain #getMinimum(int) getMinimum}(0)</code>.
* The result is the standard {@link Rectangle2D} value (namely {@linkplain #x x})
* only if the envelope is not spanning the anti-meridian.
*
- * @return the minimal ordinate value for dimension 0.
+ * @return the minimal coordinate value for dimension 0.
*/
@Override
public double getMinX() {
@@ -478,12 +478,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the {@linkplain #getMinimum(int) minimal} ordinate value for dimension 1.
+ * Returns the {@linkplain #getMinimum(int) minimal} coordinate value for dimension 1.
* The default implementation invokes <code>{@linkplain #getMinimum(int) getMinimum}(1)</code>.
* The result is the standard {@link Rectangle2D} value (namely {@linkplain #y y})
* only if the envelope is not spanning the anti-meridian.
*
- * @return the minimal ordinate value for dimension 1.
+ * @return the minimal coordinate value for dimension 1.
*/
@Override
public double getMinY() {
@@ -491,12 +491,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the {@linkplain #getMaximum(int) maximal} ordinate value for dimension 0.
+ * Returns the {@linkplain #getMaximum(int) maximal} coordinate value for dimension 0.
* The default implementation invokes <code>{@linkplain #getMaximum(int) getMinimum}(0)</code>.
* The result is the standard {@link Rectangle2D} value (namely {@linkplain #x x} + {@linkplain #width width})
* only if the envelope is not spanning the anti-meridian.
*
- * @return the maximal ordinate value for dimension 0.
+ * @return the maximal coordinate value for dimension 0.
*/
@Override
public double getMaxX() {
@@ -504,12 +504,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the {@linkplain #getMaximum(int) maximal} ordinate value for dimension 1.
+ * Returns the {@linkplain #getMaximum(int) maximal} coordinate value for dimension 1.
* The default implementation invokes <code>{@linkplain #getMaximum(int) getMinimum}(1)</code>.
* The result is the standard {@link Rectangle2D} value (namely {@linkplain #y y} + {@linkplain #height height})
* only if the envelope is not spanning the anti-meridian.
*
- * @return the maximal ordinate value for dimension 1.
+ * @return the maximal coordinate value for dimension 1.
*/
@Override
public double getMaxY() {
@@ -517,12 +517,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the {@linkplain #getMedian(int) median} ordinate value for dimension 0.
+ * Returns the {@linkplain #getMedian(int) median} coordinate value for dimension 0.
* The default implementation invokes <code>{@linkplain #getMedian(int) getMedian}(0)</code>.
* The result is the standard {@link Rectangle2D} value (namely {@linkplain #x x} + {@linkplain #width width}/2)
* only if the envelope is not spanning the anti-meridian.
*
- * @return the median ordinate value for dimension 0.
+ * @return the median coordinate value for dimension 0.
*/
@Override
public double getCenterX() {
@@ -530,12 +530,12 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
}
/**
- * Returns the {@linkplain #getMedian(int) median} ordinate value for dimension 1.
+ * Returns the {@linkplain #getMedian(int) median} coordinate value for dimension 1.
* The default implementation invokes <code>{@linkplain #getMedian(int) getMedian}(1)</code>.
* The result is the standard {@link Rectangle2D} value (namely {@linkplain #y y} + {@linkplain #height height}/2)
* only if the envelope is not spanning the anti-meridian.
*
- * @return the median ordinate value for dimension 1.
+ * @return the median coordinate value for dimension 1.
*/
@Override
public double getCenterY() {
@@ -687,15 +687,15 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
/**
* Tests if a specified coordinate is inside the boundary of this envelope. If it least one
- * of the given ordinate value is {@link java.lang.Double#NaN NaN}, then this method returns
+ * of the given coordinate value is {@link java.lang.Double#NaN NaN}, then this method returns
* {@code false}.
*
* <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
* This method supports anti-meridian spanning in the same way than
* {@link AbstractEnvelope#contains(DirectPosition)}.
*
- * @param px the first ordinate value of the point to text.
- * @param py the second ordinate value of the point to text.
+ * @param px the first coordinate value of the point to text.
+ * @param py the second coordinate value of the point to text.
* @return {@code true} if the specified coordinate is inside the boundary of this envelope;
* {@code false} otherwise.
*/
@@ -744,8 +744,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
* This method supports anti-meridian spanning in the same way than
* {@link AbstractEnvelope#contains(Envelope)}.
*
- * @param rx the <var>x</var> ordinate of the lower corner of the rectangle to test for inclusion.
- * @param ry the <var>y</var> ordinate of the lower corner of the rectangle to test for inclusion.
+ * @param rx the <var>x</var> coordinate of the lower corner of the rectangle to test for inclusion.
+ * @param ry the <var>y</var> coordinate of the lower corner of the rectangle to test for inclusion.
* @param rw the width of the rectangle to test for inclusion. May be negative if the rectangle spans the anti-meridian.
* @param rh the height of the rectangle to test for inclusion. May be negative.
* @return {@code true} if this envelope completely encloses the specified one.
@@ -816,8 +816,8 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
* This method supports anti-meridian spanning in the same way than
* {@link AbstractEnvelope#intersects(Envelope)}.
*
- * @param rx the <var>x</var> ordinate of the lower corner of the rectangle to test for intersection.
- * @param ry the <var>y</var> ordinate of the lower corner of the rectangle to test for intersection.
+ * @param rx the <var>x</var> coordinate of the lower corner of the rectangle to test for intersection.
+ * @param ry the <var>y</var> coordinate of the lower corner of the rectangle to test for intersection.
* @param rw the width of the rectangle to test for inclusion. May be negative if the rectangle spans the anti-meridian.
* @param rh the height of the rectangle to test for inclusion. May be negative.
* @return {@code true} if this envelope intersects the specified rectangle.
@@ -897,10 +897,10 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
*/
if (isSameSign(span0, span1)) { // Always 'false' if any value is NaN.
if ((min1 > max0 || max1 < min0) && !isNegativeUnsafe(span0)) {
- continue; // No intersection: leave ordinate values to NaN
+ continue; // No intersection: leave coordinate values to NaN
}
} else if (isNaN(span0) || isNaN(span1)) {
- continue; // Leave ordinate values to NaN
+ continue; // Leave coordinate values to NaN
} else {
int intersect = 0; // A bitmask of intersections (two bits).
if (isNegativeUnsafe(span0)) {
@@ -919,7 +919,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
min = min1;
max = max1;
} else {
- continue; // Leave ordinate values to NaN
+ continue; // Leave coordinate values to NaN
}
}
}
@@ -981,13 +981,13 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
double max = Math.max(max0, max1);
/*
* See GeneralEnvelope.add(Envelope) for an explanation of the algorithm applied below.
- * Note that the "continue" statement has reverse meaning: ordinates are left to NaN.
+ * Note that the "continue" statement has reverse meaning: coordinates are left to NaN.
*/
final boolean sp0 = isNegative(span0);
final boolean sp1 = isNegative(span1);
if (sp0 == sp1) {
if (sp0 && !isNegativeUnsafe(max - min)) {
- continue; // Leave ordinates to NaN.
+ continue; // Leave coordinates to NaN.
}
} else if (sp0) {
if (max1 <= max0 || min1 >= min0) {
@@ -997,7 +997,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
final double left = min1 - max0;
final double right = min0 - max1;
if (!(left > 0 || right > 0)) {
- continue; // Leave ordinates to NaN.
+ continue; // Leave coordinates to NaN.
}
if (left > right) {min = min1; max = max0;}
if (right > left) {min = min0; max = max1;}
@@ -1010,7 +1010,7 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
final double left = min0 - max1;
final double right = min1 - max0;
if (!(left > 0 || right > 0)) {
- continue; // Leave ordinates to NaN.
+ continue; // Leave coordinates to NaN.
}
if (left > right) {min = min0; max = max1;}
if (right > left) {min = min1; max = max0;}
@@ -1044,15 +1044,15 @@ public class Envelope2D extends Rectangle2D.Double implements Envelope, Emptiabl
* contains both the original rectangle and the specified point.
* <p>
* After adding a point, a call to {@link #contains(double, double)} with the added point
- * as an argument will return {@code true}, except if one of the point ordinates was
- * {@link java.lang.Double#NaN} in which case the corresponding ordinate has been ignored.
+ * as an argument will return {@code true}, except if one of the point coordinates was
+ * {@link java.lang.Double#NaN} in which case the corresponding coordinate has been ignored.
*
* <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
* This method supports anti-meridian spanning in the same way than
* {@link GeneralEnvelope#add(DirectPosition)}.
*
- * @param px the first ordinate of the point to add.
- * @param py the second ordinate of the point to add.
+ * @param px the first coordinate of the point to add.
+ * @param py the second coordinate of the point to add.
*/
@Override
public void add(final double px, final double py) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
index 71a4530..36177e0 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
@@ -411,11 +411,10 @@ public final class Envelopes extends Static {
sourceDim, envelope.getDimension()));
}
/*
- * Allocates all needed objects. The value '3' below is because the following 'while'
- * loop uses a 'pointIndex' to be interpreted as a number in base 3 (see the comment
- * inside the loop). The coordinate to transform must be initialized to the minimal
- * ordinate values. This coordinate will be updated in the 'switch' statement inside
- * the 'while' loop.
+ * Allocates all needed objects. The power of 3 below is because the following `while` loop
+ * uses a `pointIndex` to be interpreted as a number in base 3 (see the comment inside the loop).
+ * The coordinate tuple to transform must be initialized to the minimal coordinate values.
+ * This coordinate will be updated in the `switch` statement inside the `while` loop.
*/
if (sourceDim >= 20) { // Maximal value supported by Formulas.pow3(int) is 19.
throw new IllegalArgumentException(Errors.format(Errors.Keys.ExcessiveNumberOfDimensions_1));
@@ -424,15 +423,15 @@ public final class Envelopes extends Static {
boolean isDerivativeSupported = true;
GeneralEnvelope transformed = null;
final Matrix[] derivatives = new Matrix[Formulas.pow3(sourceDim)];
- final double[] ordinates = new double[derivatives.length * targetDim];
+ final double[] coordinates = new double[derivatives.length * targetDim];
final double[] sourcePt = new double[sourceDim];
for (int i=sourceDim; --i>=0;) {
sourcePt[i] = envelope.getMinimum(i);
}
- // A window over a single coordinate in the 'ordinates' array.
- final DirectPositionView ordinatesView = new DirectPositionView.Double(ordinates, 0, targetDim);
+ // A window over a single coordinate in the `coordinates` array.
+ final DirectPositionView ordinatesView = new DirectPositionView.Double(coordinates, 0, targetDim);
/*
- * Iterates over every minimal, maximal and median ordinate values (3 points) along each
+ * Iterates over every minimal, maximal and median coordinate values (3 points) along each
* dimension. The total number of iterations is 3 ^ (number of source dimensions).
*/
transformPoint: while (true) {
@@ -449,13 +448,13 @@ public final class Envelopes extends Static {
final int offset = pointIndex * targetDim;
try {
derivatives[pointIndex] = derivativeAndTransform(transform,
- sourcePt, ordinates, offset, isDerivativeSupported);
+ sourcePt, coordinates, offset, isDerivativeSupported);
} catch (TransformException e) {
if (!isDerivativeSupported) {
throw e; // Derivative were already disabled, so something went wrong.
}
isDerivativeSupported = false;
- transform.transform(sourcePt, 0, ordinates, offset, 1);
+ transform.transform(sourcePt, 0, coordinates, offset, 1);
recoverableException(Envelopes.class, e); // Log only if the above call was successful.
}
/*
@@ -465,7 +464,7 @@ public final class Envelopes extends Static {
if (transformed == null) {
transformed = new GeneralEnvelope(targetDim);
for (int i=0; i<targetDim; i++) {
- final double value = ordinates[offset + i];
+ final double value = coordinates[offset + i];
transformed.setRange(i, value, value);
}
} else {
@@ -476,7 +475,7 @@ public final class Envelopes extends Static {
* Get the next point coordinate. The 'coordinateIndex' variable is an index in base 3
* having a number of digits equals to the number of source dimensions. For example a
* 4-D space have indexes ranging from "0000" to "2222" (numbers in base 3). The digits
- * are then mapped to minimal (0), maximal (1) or central (2) ordinates. The outer loop
+ * are then mapped to minimal (0), maximal (1) or central (2) coordinates. The outer loop
* stops when the counter roll back to "0000". Note that 'targetPt' must keep the value
* of the last projected point, which must be the envelope center identified by "2222"
* in the 4-D case.
@@ -523,8 +522,8 @@ public final class Envelopes extends Static {
final int offset1 = targetDim * pointIndex;
final int offset2 = targetDim * medianIndex;
for (int j=0; j<targetDim; j++) {
- extremum.resolve(x1, ordinates[offset1 + j], D1.getElement(j,i),
- x2, ordinates[offset2 + j], D2.getElement(j,i));
+ extremum.resolve(x1, coordinates[offset1 + j], D1.getElement(j,i),
+ x2, coordinates[offset2 + j], D2.getElement(j,i));
boolean isP2 = false;
do { // Executed exactly twice, one for each extremum point.
final double x = isP2 ? extremum.ex2 : extremum.ex1;
@@ -541,16 +540,16 @@ public final class Envelopes extends Static {
* on the envelope border which is located vis-à-vis the extremum.
*/
for (int ib3 = pointIndex, dim = sourceDim; --dim >= 0; ib3 /= 3) {
- final double ordinate;
+ final double coordinate;
if (dim == i) {
- ordinate = x; // Position of the extremum.
+ coordinate = x; // Position of the extremum.
} else switch (ib3 % 3) {
- case 0: ordinate = envelope.getMinimum(dim); break;
- case 1: ordinate = envelope.getMaximum(dim); break;
- case 2: ordinate = envelope.getMedian (dim); break;
- default: throw new AssertionError(ib3); // Should never happen
+ case 0: coordinate = envelope.getMinimum(dim); break;
+ case 1: coordinate = envelope.getMaximum(dim); break;
+ case 2: coordinate = envelope.getMedian (dim); break;
+ default: throw new AssertionError(ib3); // Should never happen.
}
- sourcePt[dim] = ordinate;
+ sourcePt[dim] = coordinate;
}
temporary = transform.transform(sourceView, temporary);
transformed.add(temporary);
@@ -566,7 +565,7 @@ public final class Envelopes extends Static {
}
if (targetPt != null) {
// Copy the coordinate of the center point.
- System.arraycopy(ordinates, ordinates.length - targetDim, targetPt, 0, targetDim);
+ System.arraycopy(coordinates, coordinates.length - targetDim, targetPt, 0, targetDim);
}
return transformed;
}
@@ -712,8 +711,8 @@ public final class Envelopes extends Static {
*
* 3) If step #2 added the point, iterate over all other axes. If an other bounded axis
* is found and that axis is of kind "WRAPAROUND", test for inclusion the same point
- * than the point tested at step #1, except for the ordinate of the axis found in this
- * step. That ordinate is set to the minimal and maximal values of that axis.
+ * than the point tested at step #1, except for the coordinate of the axis found in
+ * this step. That coordinate is set to the minimal and maximal values of that axis.
*
* Example: If the above steps found that the point (90°S, 30°W) need to be included,
* then this step #3 will also test the points (90°S, 180°W) and (90°S, 180°E).
@@ -847,7 +846,7 @@ poles: for (int i=0; i<dimension; i++, dimensionBitMask <<= 1) {
*/
for (int c=0; c<4; c++) {
/*
- * Set the ordinate value along the axis having the singularity point
+ * Set the coordinate value along the axis having the singularity point
* (cases c=0 and c=2). If the envelope did not included that point,
* then skip completely this case and the next one, i.e. skip c={0,1}
* or skip c={2,3}.
@@ -882,7 +881,7 @@ poles: for (int i=0; i<dimension; i++, dimensionBitMask <<= 1) {
}
}
/*
- * At this point we finished envelope transformation. Verify if some ordinates need to be "wrapped around"
+ * At this point we finished envelope transformation. Verify if some coordinates need to be "wrapped around"
* as a result of the coordinate operation. This is usually the longitude axis where the source CRS uses
* the [-180 … +180]° range and the target CRS uses the [0 … 360]° range, or the converse. We do not wrap
* around if the source and target axes use the same range (e.g. the longitude stay [-180 … +180]°) in order
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
index 4a81c2f..b88cb7b 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralDirectPosition.java
@@ -39,7 +39,7 @@ import static org.apache.sis.util.ArgumentChecks.ensureDimensionMatches;
/**
* A mutable {@code DirectPosition} (the coordinates of a position) of arbitrary dimension.
* This particular implementation of {@code DirectPosition} is said "General" because it
- * uses an {@linkplain #ordinates array of ordinates} of an arbitrary length. If the direct
+ * uses an {@link #coordinates array of coordinates} of an arbitrary length. If the direct
* position is known to be always two-dimensional, then {@link DirectPosition2D} provides
* a more efficient implementation.
*
@@ -65,19 +65,27 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
/**
* Serial number for inter-operability with different versions.
*/
- private static final long serialVersionUID = -5524426558018300122L;
+ private static final long serialVersionUID = -1775358214919832302L;
/**
- * Used for setting the {@link #ordinates} field during a {@link #clone()} operation only.
+ * Used for setting the {@link #coordinates} field during a {@link #clone()} operation only.
* Will be fetch when first needed.
*/
- private static volatile Field ordinatesField;
+ private static volatile Field coordinatesField;
/**
- * The ordinates of the direct position. The length of this array is the
+ * The coordinates of the direct position. The length of this array is the
* {@linkplain #getDimension() dimension} of this direct position.
*/
- public final double[] ordinates;
+ public final double[] coordinates;
+
+ /**
+ * @deprecated Renamed {@link #coordinates}.
+ *
+ * @see <a href="https://issues.apache.org/jira/browse/SIS-461">SIS-461</a>
+ */
+ @Deprecated
+ public transient double[] ordinates;
/**
* The coordinate reference system for this position, or {@code null}.
@@ -102,29 +110,31 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
* @throws NegativeArraySizeException if {@code dimension} is negative.
*/
public GeneralDirectPosition(final int dimension) throws NegativeArraySizeException {
- ordinates = new double[dimension];
+ coordinates = new double[dimension];
+ ordinates = coordinates;
}
/**
- * Constructs a position with the specified ordinates.
- * This constructor assigns the given array directly (without clone) to the {@link #ordinates} field.
+ * Constructs a position with the specified coordinates.
+ * This constructor assigns the given array directly (without clone) to the {@link #coordinates} field.
* Consequently, callers shall not recycle the same array for creating many instances.
*
* <div class="note"><b>Implementation note:</b>
* the array is not cloned because this is usually not needed, especially in the context of variable
- * argument lengths since the array is often created implicitly. Furthermore the {@link #ordinates}
+ * argument lengths since the array is often created implicitly. Furthermore the {@link #coordinates}
* field is public, so cloning the array would not protect the state of this object anyway.</div>
*
* <p><b>Caution:</b> if only one number is specified, make sure that the number type is {@code double},
* {@code float} or {@code long} otherwise the {@link #GeneralDirectPosition(int)} constructor would be
* invoked with a very different meaning. For example for creating a one-dimensional coordinate initialized
- * to the ordinate value 100, use <code>new GeneralDirectPosition(100<u>.0</u>)</code>, <strong>not</strong>
+ * to the coordinate value 100, use <code>new GeneralDirectPosition(100<u>.0</u>)</code>, <strong>not</strong>
* {@code new GeneralDirectPosition(100)}, because the later would actually create a position with 100 dimensions.</p>
*
- * @param ordinates the ordinate values. This array is <strong>not</strong> cloned.
+ * @param coordinates the coordinate values. This array is <strong>not</strong> cloned.
*/
- public GeneralDirectPosition(final double... ordinates) {
- this.ordinates = ordinates;
+ public GeneralDirectPosition(final double... coordinates) {
+ this.coordinates = coordinates;
+ ordinates = coordinates;
}
/**
@@ -134,9 +144,10 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
* @param point the position to copy.
*/
public GeneralDirectPosition(final DirectPosition point) {
- ordinates = point.getCoordinate(); // Should already be cloned.
+ coordinates = point.getCoordinate(); // Should already be cloned.
crs = point.getCoordinateReferenceSystem();
- ensureDimensionMatches("crs", ordinates.length, crs);
+ ensureDimensionMatches("crs", coordinates.length, crs);
+ ordinates = coordinates;
}
/**
@@ -157,21 +168,22 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
* @see CoordinateFormat
*/
public GeneralDirectPosition(final CharSequence wkt) throws IllegalArgumentException {
- if ((ordinates = parse(wkt)) == null) {
+ if ((coordinates = parse(wkt)) == null) {
throw new IllegalArgumentException(Errors.format(
Errors.Keys.UnparsableStringForClass_2, "POINT", wkt));
}
+ ordinates = coordinates;
}
/**
- * The length of ordinate sequence (the number of entries).
- * This is always equals to the length of the {@link #ordinates} array.
+ * The length of coordinate sequence (the number of entries).
+ * This is always equals to the length of the {@link #coordinates} array.
*
* @return the dimensionality of this position.
*/
@Override
public final int getDimension() {
- return ordinates.length;
+ return coordinates.length;
}
/**
@@ -203,57 +215,57 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
* Returns a sequence of numbers that hold the coordinate of this position in its reference system.
*
* <div class="note"><b>API note:</b>
- * This method is final for ensuring consistency with the {@link #ordinates}, array field, which is public.</div>
+ * This method is final for ensuring consistency with the {@link #coordinates}, array field, which is public.</div>
*
- * @return a copy of the {@linkplain #ordinates ordinates} array.
+ * @return a copy of the {@link #coordinates coordinates} array.
*/
@Override
public final double[] getCoordinate() {
- return ordinates.clone();
+ return coordinates.clone();
}
/**
- * Sets the ordinate values along all dimensions.
+ * Sets the coordinate values along all dimensions.
*
- * @param ordinates the new ordinates values, or a {@code null} array for
- * setting all ordinate values to {@link Double#NaN NaN}.
+ * @param coordinates the new coordinates values, or a {@code null} array for
+ * setting all coordinate values to {@link Double#NaN NaN}.
* @throws MismatchedDimensionException if the length of the specified array is not
* equals to the {@linkplain #getDimension() dimension} of this position.
*/
- public void setCoordinate(final double... ordinates) throws MismatchedDimensionException {
- if (ordinates == null) {
- Arrays.fill(this.ordinates, Double.NaN);
+ public void setCoordinate(final double... coordinates) throws MismatchedDimensionException {
+ if (coordinates == null) {
+ Arrays.fill(this.coordinates, Double.NaN);
} else {
- ensureDimensionMatches("ordinates", this.ordinates.length, ordinates);
- System.arraycopy(ordinates, 0, this.ordinates, 0, ordinates.length);
+ ensureDimensionMatches("coordinates", this.coordinates.length, coordinates);
+ System.arraycopy(coordinates, 0, this.coordinates, 0, coordinates.length);
}
}
/**
- * Returns the ordinate at the specified dimension.
+ * Returns the coordinate at the specified dimension.
*
* <div class="note"><b>API note:</b>
- * This method is final for ensuring consistency with the {@link #ordinates}, array field, which is public.</div>
+ * This method is final for ensuring consistency with the {@link #coordinates}, array field, which is public.</div>
*
* @param dimension the dimension in the range 0 to {@linkplain #getDimension() dimension}-1.
- * @return the ordinate at the specified dimension.
+ * @return the coordinate at the specified dimension.
* @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
*/
@Override
public final double getOrdinate(final int dimension) throws IndexOutOfBoundsException {
- return ordinates[dimension];
+ return coordinates[dimension];
}
/**
- * Sets the ordinate value along the specified dimension.
+ * Sets the coordinate value along the specified dimension.
*
- * @param dimension the dimension for the ordinate of interest.
- * @param value the ordinate value of interest.
+ * @param dimension the dimension for the coordinate of interest.
+ * @param value the coordinate value of interest.
* @throws IndexOutOfBoundsException if the specified dimension is out of bounds.
*/
@Override
public void setOrdinate(final int dimension, final double value) throws IndexOutOfBoundsException {
- ordinates[dimension] = value;
+ coordinates[dimension] = value;
}
/**
@@ -262,18 +274,18 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
* be set to the CRS of the specified position.
*
* @param position the new position for this point,
- * or {@code null} for setting all ordinate values to {@link Double#NaN NaN}.
+ * or {@code null} for setting all coordinate values to {@link Double#NaN NaN}.
* @throws MismatchedDimensionException if the given position does not have the expected dimension.
*/
@Override
public void setLocation(final DirectPosition position) throws MismatchedDimensionException {
if (position == null) {
- Arrays.fill(ordinates, Double.NaN);
+ Arrays.fill(coordinates, Double.NaN);
} else {
- ensureDimensionMatches("position", ordinates.length, position);
+ ensureDimensionMatches("position", coordinates.length, position);
setCoordinateReferenceSystem(position.getCoordinateReferenceSystem());
- for (int i=0; i<ordinates.length; i++) {
- ordinates[i] = position.getOrdinate(i);
+ for (int i=0; i<coordinates.length; i++) {
+ coordinates[i] = position.getOrdinate(i);
}
}
}
@@ -283,15 +295,15 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
*/
@Override
public String toString() {
- return toString(this, ArraysExt.isSinglePrecision(ordinates));
+ return toString(this, ArraysExt.isSinglePrecision(coordinates));
}
/**
- * Returns the {@code "ordinates"} field of the given class and gives write permission to it.
+ * Returns the {@code "coordinates"} field of the given class and gives write permission to it.
* This method should be invoked only from {@link #clone()} method.
*/
- static Field getOrdinatesField(final Class<?> type) throws NoSuchFieldException {
- final Field field = type.getDeclaredField("ordinates");
+ static Field getCoordinatesField(final Class<?> type) throws NoSuchFieldException {
+ final Field field = type.getDeclaredField("coordinates");
AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
field.setAccessible(true);
return null;
@@ -307,27 +319,35 @@ public class GeneralDirectPosition extends AbstractDirectPosition implements Ser
@Override
public GeneralDirectPosition clone() {
try {
- Field field = ordinatesField;
+ Field field = coordinatesField;
if (field == null) {
- ordinatesField = field = getOrdinatesField(GeneralDirectPosition.class);
+ coordinatesField = field = getCoordinatesField(GeneralDirectPosition.class);
}
GeneralDirectPosition e = (GeneralDirectPosition) super.clone();
- field.set(e, ordinates.clone());
+ field.set(e, coordinates.clone());
+ e.ordinates = e.coordinates;
return e;
} catch (ReflectiveOperationException | CloneNotSupportedException exception) {
- // Should not happen, since we are cloneable.
- // Should not happen, since the "ordinates" field exists.
- // etc...
+ /*
+ * Should not happen, since we are cloneable.
+ * Should not happen, since the "coordinates" field exists.
+ * etc…
+ */
throw new AssertionError(exception);
}
}
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ in.defaultReadObject();
+ ordinates = coordinates;
+ }
+
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
- final int code = Arrays.hashCode(ordinates) + Objects.hashCode(getCoordinateReferenceSystem());
+ final int code = Arrays.hashCode(coordinates) + Objects.hashCode(getCoordinateReferenceSystem());
assert code == super.hashCode();
return code;
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java
index f4d7a9b..bd7f9d3 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/GeneralEnvelope.java
@@ -59,7 +59,7 @@ import static org.apache.sis.math.MathFunctions.isNegativeZero;
*
* <p>A {@code GeneralEnvelope} can be created in various ways:</p>
* <ul>
- * <li>{@linkplain #GeneralEnvelope(int) From a given number of dimension}, with all ordinates initialized to 0.</li>
+ * <li>{@linkplain #GeneralEnvelope(int) From a given number of dimension}, with all coordinates initialized to 0.</li>
* <li>{@linkplain #GeneralEnvelope(double[], double[]) From two coordinate points}.</li>
* <li>{@linkplain #GeneralEnvelope(Envelope) From a an other envelope} (copy constructor).</li>
* <li>{@linkplain #GeneralEnvelope(GeographicBoundingBox) From a geographic bounding box}.</li>
@@ -105,7 +105,7 @@ import static org.apache.sis.math.MathFunctions.isNegativeZero;
* system axis range meaning} is {@code WRAPAROUND}.</li>
* </ul>
*
- * Note that this class does <em>not</em> require the ordinate values to be between the axis minimum and
+ * Note that this class does <em>not</em> require the coordinate values to be between the axis minimum and
* maximum values. This flexibility exists because out-of-range values happen in practice, while they do
* not hurt the working of {@code add(…)}, {@code intersect(…)}, {@code contains(…)} and similar methods.
* This in contrast with the {@code lower > upper} case, which cause the above-cited methods to behave in
@@ -128,20 +128,20 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
private static final long serialVersionUID = 3796799507279068254L;
/**
- * Used for setting the {@link #ordinates} field during a {@link #clone()} operation only.
+ * Used for setting the {@link #coordinates} field during a {@link #clone()} operation only.
* Will be fetch when first needed.
*/
- private static volatile Field ordinatesField;
+ private static volatile Field coordinatesField;
/**
- * Creates a new envelope using the given array of ordinate values. This constructor stores
+ * Creates a new envelope using the given array of coordinate values. This constructor stores
* the given reference directly; it does <strong>not</strong> clone the given array. This is
* the desired behavior for proper working of {@link SubEnvelope}.
*
- * @param ordinates the array of ordinate values to store directly (not cloned).
+ * @param coordinates the array of coordinate values to store directly (not cloned).
*/
- GeneralEnvelope(final double[] ordinates) {
- super(ordinates);
+ GeneralEnvelope(final double[] coordinates) {
+ super(coordinates);
}
/**
@@ -149,8 +149,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* If at least one corner is associated to a CRS, then the new envelope will also
* be associated to that CRS.
*
- * @param lowerCorner the limits in the direction of decreasing ordinate values for each dimension.
- * @param upperCorner the limits in the direction of increasing ordinate values for each dimension.
+ * @param lowerCorner the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upperCorner the limits in the direction of increasing coordinate values for each dimension.
* @throws MismatchedDimensionException if the two positions do not have the same dimension.
* @throws MismatchedReferenceSystemException if the CRS of the two position are not equal.
*/
@@ -161,11 +161,11 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
}
/**
- * Constructs an envelope defined by two corners given as sequences of ordinate values.
+ * Constructs an envelope defined by two corners given as sequences of coordinate values.
* The Coordinate Reference System is initially {@code null}.
*
- * @param lowerCorner the limits in the direction of decreasing ordinate values for each dimension.
- * @param upperCorner the limits in the direction of increasing ordinate values for each dimension.
+ * @param lowerCorner the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upperCorner the limits in the direction of increasing coordinate values for each dimension.
* @throws MismatchedDimensionException if the two sequences do not have the same length.
*/
public GeneralEnvelope(final double[] lowerCorner, final double[] upperCorner) throws MismatchedDimensionException {
@@ -173,7 +173,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
}
/**
- * Constructs an empty envelope of the specified dimension. All ordinates
+ * Constructs an empty envelope of the specified dimension. All coordinates
* are initialized to 0 and the coordinate reference system is undefined.
*
* @param dimension the envelope dimension.
@@ -184,7 +184,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
/**
* Constructs an empty envelope with the specified coordinate reference system.
- * All ordinate values are initialized to 0.
+ * All coordinate values are initialized to 0.
*
* @param crs the coordinate reference system.
*/
@@ -231,8 +231,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* <ul>
* <li>Character sequences complying to the rules of Java identifiers are skipped.</li>
* <li>Coordinates are separated by a coma ({@code ,}) character.</li>
- * <li>The ordinates in a coordinate are separated by a space.</li>
- * <li>Ordinate numbers are assumed formatted in US locale.</li>
+ * <li>The coordinates in a coordinate tuple are separated by a space.</li>
+ * <li>Coordinate numbers are assumed formatted in US locale.</li>
* <li>The coordinate having the highest dimension determines the dimension of this envelope.</li>
* </ul>
*
@@ -289,7 +289,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*
* @param crs the new coordinate reference system, or {@code null}.
* @throws MismatchedDimensionException if the specified CRS doesn't have the expected number of dimensions.
- * @throws IllegalStateException if a range of ordinate values in this envelope is compatible with the given CRS.
+ * @throws IllegalStateException if a range of coordinate values in this envelope is compatible with the given CRS.
* See <cite>Envelope validation</cite> in class javadoc for more details.
*/
public void setCoordinateReferenceSystem(final CoordinateReferenceSystem crs)
@@ -298,16 +298,16 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
if (crs != null) {
ensureDimensionMatches("crs", getDimension(), crs);
/*
- * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, ordinates)
- * except that it may verify only a subset of the ordinate array and throws a different kind
+ * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, coordinates)
+ * except that it may verify only a subset of the coordinate array and throws a different kind
* of exception in case of failure.
*/
final int beginIndex = beginIndex();
final int endIndex = endIndex();
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=beginIndex; i<endIndex; i++) {
- final double lower = ordinates[i];
- final double upper = ordinates[i + d];
+ final double lower = coordinates[i];
+ final double upper = coordinates[i + d];
if (lower > upper) {
final int j = i - beginIndex;
if (!isWrapAround(crs, j)) {
@@ -323,8 +323,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* Sets the envelope range along the specified dimension.
*
* @param dimension the dimension to set.
- * @param lower the limit in the direction of decreasing ordinate values.
- * @param upper the limit in the direction of increasing ordinate values.
+ * @param lower the limit in the direction of decreasing coordinate values.
+ * @param upper the limit in the direction of increasing coordinate values.
* @throws IndexOutOfBoundsException if the given index is out of bounds.
* @throws IllegalArgumentException if {@code lower > upper} and the axis range meaning at the given dimension
* is not "wraparound". See <cite>Envelope validation</cite> in class javadoc for more details.
@@ -333,17 +333,17 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
public void setRange(final int dimension, final double lower, final double upper)
throws IndexOutOfBoundsException
{
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
ensureValidIndex(d, dimension);
/*
- * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, ordinates),
+ * The check performed here shall be identical to ArrayEnvelope.verifyRanges(crs, coordinates),
* except that there is no loop.
*/
if (lower > upper && crs != null && !isWrapAround(crs, dimension)) {
throw new IllegalArgumentException(illegalRange(crs, dimension, lower, upper));
}
- ordinates[dimension + d] = upper;
- ordinates[dimension] = lower;
+ coordinates[dimension + d] = upper;
+ coordinates[dimension] = lower;
}
/**
@@ -357,20 +357,20 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* <var>x</var><sub>max</sub>, <var>y</var><sub>max</sub>, <var>z</var><sub>max</sub>)
* </div>
*
- * @param corners ordinates of the new lower corner followed by the new upper corner.
+ * @param corners coordinates of the new lower corner followed by the new upper corner.
*/
public void setEnvelope(final double... corners) {
- verifyArrayLength(ordinates.length >>> 1, corners);
+ verifyArrayLength(coordinates.length >>> 1, corners);
verifyRanges(crs, corners);
- System.arraycopy(corners, 0, ordinates, 0, ordinates.length);
+ System.arraycopy(corners, 0, coordinates, 0, coordinates.length);
}
/**
- * Verifies that the given array of ordinate values has the expected length
+ * Verifies that the given array of coordinate values has the expected length
* for the given number of dimensions.
*
* @param dimension the dimension of the envelope.
- * @param corners the user-provided array of ordinate values.
+ * @param corners the user-provided array of coordinate values.
*/
static void verifyArrayLength(final int dimension, final double[] corners) {
if ((corners.length & 1) != 0) {
@@ -380,7 +380,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
final int d = corners.length >>> 1;
if (d != dimension) {
throw new MismatchedDimensionException(Errors.format(
- Errors.Keys.MismatchedDimension_3, "ordinates", dimension, d));
+ Errors.Keys.MismatchedDimension_3, "coordinates", dimension, d));
}
}
@@ -401,16 +401,16 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
final int beginIndex = beginIndex();
final int dimension = endIndex() - beginIndex;
ensureDimensionMatches("envelope", dimension, envelope);
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
if (envelope instanceof ArrayEnvelope) {
/*
* Optimization for a common case. This code path is used by Envelopes.compound(…).
* The main intent is to avoid the creation of temporary DirectPosition objects.
*/
- final double[] source = ((ArrayEnvelope) envelope).ordinates;
+ final double[] source = ((ArrayEnvelope) envelope).coordinates;
final int srcOffset = ((ArrayEnvelope) envelope).beginIndex();
- System.arraycopy(source, srcOffset, ordinates, beginIndex, dimension);
- System.arraycopy(source, srcOffset + (source.length >>> 1), ordinates, beginIndex + d, dimension);
+ System.arraycopy(source, srcOffset, coordinates, beginIndex, dimension);
+ System.arraycopy(source, srcOffset + (source.length >>> 1), coordinates, beginIndex + d, dimension);
} else {
@SuppressWarnings("null")
final DirectPosition lower = envelope.getLowerCorner();
@@ -418,8 +418,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
for (int i=0; i<dimension; i++) {
final int iLower = beginIndex + i;
final int iUpper = iLower + d;
- ordinates[iLower] = lower.getOrdinate(i);
- ordinates[iUpper] = upper.getOrdinate(i);
+ coordinates[iLower] = lower.getOrdinate(i);
+ coordinates[iUpper] = upper.getOrdinate(i);
}
}
final CoordinateReferenceSystem envelopeCRS = envelope.getCoordinateReferenceSystem();
@@ -439,20 +439,20 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
public void setToInfinite() {
final int beginIndex = beginIndex();
final int endIndex = endIndex();
- final int d = ordinates.length >>> 1;
- Arrays.fill(ordinates, beginIndex, endIndex, Double.NEGATIVE_INFINITY);
- Arrays.fill(ordinates, beginIndex+d, endIndex+d, Double.POSITIVE_INFINITY);
+ final int d = coordinates.length >>> 1;
+ Arrays.fill(coordinates, beginIndex, endIndex, Double.NEGATIVE_INFINITY);
+ Arrays.fill(coordinates, beginIndex+d, endIndex+d, Double.POSITIVE_INFINITY);
}
/**
- * Sets all ordinate values to {@linkplain Double#NaN NaN}.
+ * Sets all coordinate values to {@linkplain Double#NaN NaN}.
* The {@linkplain #getCoordinateReferenceSystem() coordinate reference system}
* (if any) stay unchanged.
*
* @see #isAllNaN()
*/
public void setToNaN() { // Must be overridden in SubEnvelope
- Arrays.fill(ordinates, Double.NaN);
+ Arrays.fill(coordinates, Double.NaN);
assert isAllNaN() : this;
}
@@ -474,11 +474,11 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
ensureNonNull("vector", vector);
final int beginIndex = beginIndex();
ensureDimensionMatches("vector", endIndex() - beginIndex, vector);
- final int upperIndex = beginIndex + (ordinates.length >>> 1);
+ final int upperIndex = beginIndex + (coordinates.length >>> 1);
for (int i=0; i<vector.length; i++) {
final double t = vector[i];
- ordinates[beginIndex + i] += t;
- ordinates[upperIndex + i] += t;
+ coordinates[beginIndex + i] += t;
+ coordinates[upperIndex + i] += t;
}
}
@@ -487,15 +487,15 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* This method does not check for anti-meridian spanning. It is invoked only
* by the {@link Envelopes} transform methods, which build "normal" envelopes.
*
- * @param array the array which contains the ordinate values.
- * @param offset index of the first valid ordinate value in the given array.
+ * @param array the array which contains the coordinate values.
+ * @param offset index of the first valid coordinate value in the given array.
*/
final void addSimple(final double[] array, final int offset) {
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=0; i<d; i++) {
final double value = array[offset + i];
- if (value < ordinates[i ]) ordinates[i ] = value;
- if (value > ordinates[i+d]) ordinates[i+d] = value;
+ if (value < coordinates[i ]) coordinates[i ] = value;
+ if (value > coordinates[i+d]) coordinates[i+d] = value;
}
}
@@ -505,7 +505,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*
* <p>After adding a point, a call to {@link #contains(DirectPosition) contains(DirectPosition)}
* with the added point as an argument will return {@code true}, except if one of the point
- * ordinates was {@link Double#NaN} in which case the corresponding ordinate has been ignored.</p>
+ * coordinates was {@link Double#NaN} in which case the corresponding coordinate has been ignored.</p>
*
* <div class="section">Pre-conditions</div>
* This method assumes that the specified point uses the same CRS than this envelope.
@@ -533,16 +533,16 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
final int dimension = endIndex() - beginIndex;
ensureDimensionMatches("position", dimension, position);
assert equalsIgnoreMetadata(crs, position.getCoordinateReferenceSystem(), true) : position;
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=0; i<dimension; i++) {
final int iLower = beginIndex + i;
final int iUpper = iLower + d;
final double value = position.getOrdinate(i);
- final double min = ordinates[iLower];
- final double max = ordinates[iUpper];
+ final double min = coordinates[iLower];
+ final double max = coordinates[iUpper];
if (!isNegative(max - min)) { // Standard case, or NaN.
- if (value < min) ordinates[iLower] = value;
- if (value > max) ordinates[iUpper] = value;
+ if (value < min) coordinates[iLower] = value;
+ if (value > max) coordinates[iUpper] = value;
} else {
/*
* Spanning the anti-meridian. The [max…min] range (not that min/max are
@@ -565,8 +565,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* ─────┘ └─────
* }
*
- * @param i the dimension of the ordinate
- * @param value the ordinate value to add to this envelope.
+ * @param i the dimension of the coordinate
+ * @param value the coordinate value to add to this envelope.
* @param left the border on the left side, which is the <em>max</em> value (yes, this is confusing!)
* @param right the border on the right side, which is the <em>min</em> value (yes, this is confusing!)
*/
@@ -576,9 +576,9 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
right -= value;
if (right > 0) {
if (right > left) {
- i += (ordinates.length >>> 1);
+ i += (coordinates.length >>> 1);
}
- ordinates[i] = value;
+ coordinates[i] = value;
}
}
}
@@ -594,7 +594,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
* This method supports envelopes spanning the anti-meridian. If one or both envelopes span
* the anti-meridian, then the result of the {@code add} operation may be an envelope expanding
- * to infinities. In such case, the ordinate range will be either [−∞…∞] or [0…−0] depending on
+ * to infinities. In such case, the coordinate range will be either [−∞…∞] or [0…−0] depending on
* whatever the original range span the anti-meridian or not.
*
* @param envelope the {@code Envelope} to add to this envelope.
@@ -612,12 +612,12 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
assert equalsIgnoreMetadata(crs, envelope.getCoordinateReferenceSystem(), true) : envelope;
final DirectPosition lower = envelope.getLowerCorner();
final DirectPosition upper = envelope.getUpperCorner();
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=0; i<dimension; i++) {
final int iLower = beginIndex + i;
final int iUpper = iLower + d;
- final double min0 = ordinates[iLower];
- final double max0 = ordinates[iUpper];
+ final double min0 = coordinates[iLower];
+ final double max0 = coordinates[iUpper];
final double min1 = lower.getOrdinate(i);
final double max1 = upper.getOrdinate(i);
final boolean sp0 = isNegative(max0 - min0);
@@ -637,9 +637,9 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* ──┘ │ │ └── ────┼──┼─┘└─
* ────┘ └──── ────┘ └────
*/
- if (min1 < min0) ordinates[iLower] = min1;
- if (max1 > max0) ordinates[iUpper] = max1;
- if (!sp0 || isNegativeUnsafe(ordinates[iUpper] - ordinates[iLower])) {
+ if (min1 < min0) coordinates[iLower] = min1;
+ if (max1 > max0) coordinates[iUpper] = max1;
+ if (!sp0 || isNegativeUnsafe(coordinates[iUpper] - coordinates[iLower])) {
continue; // We are done, go to the next dimension.
}
// If we were spanning the anti-meridian before the union but
@@ -672,8 +672,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
if (left > 0 || right > 0) {
// The < and > checks below are not completly redundant.
// The difference is when a value is NaN.
- if (left > right) ordinates[iLower] = min1;
- if (right > left) ordinates[iUpper] = max1; // This is the case illustrated above.
+ if (left > right) coordinates[iLower] = min1;
+ if (right > left) coordinates[iUpper] = max1; // This is the case illustrated above.
continue; // We are done, go to the next dimension.
}
// If we reach this point, the given envelope fills completly the "exclusion area"
@@ -685,15 +685,15 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* given envelope spans to infinities.
*/
if (max0 <= max1 || min0 >= min1) {
- ordinates[iLower] = min1;
- ordinates[iUpper] = max1;
+ coordinates[iLower] = min1;
+ coordinates[iUpper] = max1;
continue;
}
final double left = min0 - max1;
final double right = min1 - max0;
if (left > 0 || right > 0) {
- if (left > right) ordinates[iUpper] = max1;
- if (right > left) ordinates[iLower] = min1;
+ if (left > right) coordinates[iUpper] = max1;
+ if (right > left) coordinates[iLower] = min1;
continue;
}
}
@@ -703,11 +703,11 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* the "normal" / "anti-meridian spanning" state.
*/
if (sp0) {
- ordinates[iLower] = +0.0;
- ordinates[iUpper] = -0.0;
+ coordinates[iLower] = +0.0;
+ coordinates[iUpper] = -0.0;
} else {
- ordinates[iLower] = Double.NEGATIVE_INFINITY;
- ordinates[iUpper] = Double.POSITIVE_INFINITY;
+ coordinates[iLower] = Double.NEGATIVE_INFINITY;
+ coordinates[iUpper] = Double.POSITIVE_INFINITY;
}
}
assert contains(envelope) || isEmpty() || hasNaN(envelope) : this;
@@ -738,12 +738,12 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
assert equalsIgnoreMetadata(crs, envelope.getCoordinateReferenceSystem(), true) : envelope;
final DirectPosition lower = envelope.getLowerCorner();
final DirectPosition upper = envelope.getUpperCorner();
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=beginIndex; i<dimension; i++) {
final int iLower = beginIndex + i;
final int iUpper = iLower + d;
- final double min0 = ordinates[iLower];
- final double max0 = ordinates[iUpper];
+ final double min0 = coordinates[iLower];
+ final double max0 = coordinates[iUpper];
final double min1 = lower.getOrdinate(i);
final double max1 = upper.getOrdinate(i);
final double span0 = max0 - min0;
@@ -760,19 +760,19 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
/*
* The check for !isNegative(span0) is because if both envelopes span the
* anti-merdian, then there is always an intersection on both side no matter
- * what envelope ordinates are because both envelopes extend toward infinities:
+ * what envelope coordinates are because both envelopes extend toward infinities:
* ────┐ ┌──── ────┐ ┌────
* ──┐ │ │ ┌── or ────┼──┼─┐┌─
* ──┘ │ │ └── ────┼──┼─┘└─
* ────┘ └──── ────┘ └────
* Since we excluded the above case, entering in this block means that the
- * envelopes are "normal" and do not intersect, so we set ordinates to NaN.
+ * envelopes are "normal" and do not intersect, so we set coordinates to NaN.
* ┌────┐
* │ │ ┌────┐
* │ │ └────┘
* └────┘
*/
- ordinates[iLower] = ordinates[iUpper] = Double.NaN;
+ coordinates[iLower] = coordinates[iUpper] = Double.NaN;
continue;
}
} else {
@@ -787,18 +787,18 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* └─┼────┘ │ └────┘ │ │
* ─────┘ └───── ──────────┘ └─────
*/
- if (min1 <= max0) {intersect = 1; ordinates[iLower] = min1;}
- if (max1 >= min0) {intersect |= 2; ordinates[iUpper] = max1;}
+ if (min1 <= max0) {intersect = 1; coordinates[iLower] = min1;}
+ if (max1 >= min0) {intersect |= 2; coordinates[iUpper] = max1;}
} else {
// Same than above, but with indices 0 and 1 interchanged.
- // No need to set ordinate values since they would be the same.
+ // No need to set coordinate values since they would be the same.
if (min0 <= max1) {intersect = 1;}
if (max0 >= min1) {intersect |= 2;}
}
}
/*
* Cases 0 and 3 are illustrated below. In case 1 and 2, we will set
- * only the ordinate value which has not been set by the above code.
+ * only the coordinate value which has not been set by the above code.
*
* [intersect=0] [intersect=3]
* ─────┐ ┌───── ─────┐ ┌─────
@@ -813,8 +813,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*/
switch (intersect) {
default: throw new AssertionError(intersect);
- case 1: if (max1 < max0) ordinates[iUpper] = max1; break;
- case 2: if (min1 > min0) ordinates[iLower] = min1; break;
+ case 1: if (max1 < max0) coordinates[iUpper] = max1; break;
+ case 2: if (min1 > min0) coordinates[iLower] = min1; break;
case 3: // Fall through
case 0: {
/*
@@ -833,15 +833,15 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
min = Double.NaN;
max = Double.NaN;
}
- ordinates[iLower] = min;
- ordinates[iUpper] = max;
+ coordinates[iLower] = min;
+ coordinates[iUpper] = max;
break;
}
}
continue;
}
- if (min1 > min0) ordinates[iLower] = min1;
- if (max1 < max0) ordinates[iUpper] = max1;
+ if (min1 > min0) coordinates[iLower] = min1;
+ if (max1 < max0) coordinates[iUpper] = max1;
}
// Tests only if the interection result is non-empty.
assert isEmpty() || AbstractEnvelope.castOrCopy(envelope).contains(this) : this;
@@ -849,19 +849,19 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
/**
* Ensures that the envelope is contained in the coordinate system domain.
- * For each dimension, this method compares the ordinate values against the
+ * For each dimension, this method compares the coordinate values against the
* limits of the coordinate system axis for that dimension.
- * If some ordinates are out of range, then there is a choice depending on the
+ * If some coordinates are out of range, then there is a choice depending on the
* {@linkplain CoordinateSystemAxis#getRangeMeaning() axis range meaning}:
*
* <ul class="verbose">
- * <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> ordinates), then values
+ * <li>If {@link RangeMeaning#EXACT} (typically <em>latitudes</em> coordinates), then values
* greater than the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximal value}
* are replaced by the axis maximum, and values smaller than the
* {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimal value}
* are replaced by the axis minimum.</li>
*
- * <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> ordinates), then
+ * <li>If {@link RangeMeaning#WRAPAROUND} (typically <em>longitudes</em> coordinates), then
* a multiple of the axis range (e.g. 360° for longitudes) is added or subtracted.
* Example:
* <ul>
@@ -874,7 +874,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*
* <div class="section">Spanning the anti-meridian of a Geographic CRS</div>
* If the envelope is spanning the anti-meridian, then some {@linkplain #getLower(int) lower}
- * ordinate values may become greater than their {@linkplain #getUpper(int) upper} counterpart
+ * coordinate values may become greater than their {@linkplain #getUpper(int) upper} counterpart
* as a result of this method call. If such effect is undesirable, then this method may be
* combined with {@link #simplify()} as below:
*
@@ -895,7 +895,7 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* or {@linkplain #intersect(Envelope) intersection} of envelopes, in order to ensure that
* both envelopes are defined in the same domain. This method may also be invoked before
* to project an envelope, since some projections produce {@link Double#NaN} numbers when
- * given an ordinate value out of bounds.
+ * given an coordinate value out of bounds.
*
* @return {@code true} if this envelope has been modified as a result of this method call,
* or {@code false} if no change has been done.
@@ -913,17 +913,17 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
/**
* Normalizes only the dimensions returned by the given iterator, or all dimensions if the iterator is null.
* This is used for normalizing the result of a coordinate operation where a wrap around axis does not
- * necessarily means that the ordinates need to be normalized along that axis.
+ * necessarily means that the coordinates need to be normalized along that axis.
*
* @param cs the coordinate system of this envelope CRS (as an argument because sometime already known).
- * @param beginIndex index of the first ordinate value in {@link #ordinates} array. Non-zero for sub-envelopes.
+ * @param beginIndex index of the first coordinate value in {@link #coordinates} array. Non-zero for sub-envelopes.
* @param count number of coordinates, i.e. this envelope dimensions.
* @param dimensions the dimensions to check for normalization, or {@code null} for all dimensions.
* @return {@code true} if this envelope has been modified as a result of this method call.
*/
final boolean normalize(final CoordinateSystem cs, final int beginIndex, final int count, final Iterator<Integer> dimensions) {
boolean changed = false;
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int j=0; j<count; j++) {
final int i = (dimensions != null) ? dimensions.next() : j;
final int iLower = beginIndex + i;
@@ -933,13 +933,13 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
final double maximum = axis.getMaximumValue();
final RangeMeaning rm = axis.getRangeMeaning();
if (RangeMeaning.EXACT.equals(rm)) {
- if (ordinates[iLower] < minimum) {ordinates[iLower] = minimum; changed = true;}
- if (ordinates[iUpper] > maximum) {ordinates[iUpper] = maximum; changed = true;}
+ if (coordinates[iLower] < minimum) {coordinates[iLower] = minimum; changed = true;}
+ if (coordinates[iUpper] > maximum) {coordinates[iUpper] = maximum; changed = true;}
} else if (RangeMeaning.WRAPAROUND.equals(rm)) {
final double csSpan = maximum - minimum;
if (csSpan > 0 && csSpan < Double.POSITIVE_INFINITY) {
- double o1 = ordinates[iLower];
- double o2 = ordinates[iUpper];
+ double o1 = coordinates[iLower];
+ double o2 = coordinates[iUpper];
if (Math.abs(o2-o1) >= csSpan) {
/*
* If the range exceed the CS span, then we have to replace it by the
@@ -952,19 +952,19 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*/
if (o1 != minimum || o2 != maximum) {
if ((o1 % csSpan) == 0 && (o2 % csSpan) == 0) {
- ordinates[iLower] = +0.0;
- ordinates[iUpper] = -0.0;
+ coordinates[iLower] = +0.0;
+ coordinates[iUpper] = -0.0;
} else {
- ordinates[iLower] = minimum;
- ordinates[iUpper] = maximum;
+ coordinates[iLower] = minimum;
+ coordinates[iUpper] = maximum;
}
changed = true;
}
} else {
o1 = Math.floor((o1 - minimum) / csSpan) * csSpan;
o2 = Math.floor((o2 - minimum) / csSpan) * csSpan;
- if (o1 != 0) {ordinates[iLower] -= o1; changed = true;}
- if (o2 != 0) {ordinates[iUpper] -= o2; changed = true;}
+ if (o1 != 0) {coordinates[iLower] -= o1; changed = true;}
+ if (o2 != 0) {coordinates[iUpper] -= o2; changed = true;}
}
}
}
@@ -974,13 +974,13 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
/**
* Ensures that <var>lower</var> ≦ <var>upper</var> for every dimensions.
- * If a {@linkplain #getUpper(int) upper ordinate value} is less than a
- * {@linkplain #getLower(int) lower ordinate value}, then there is a choice:
+ * If a {@linkplain #getUpper(int) upper coordinate value} is less than a
+ * {@linkplain #getLower(int) lower coordinate value}, then there is a choice:
*
* <ul>
* <li>If the axis has {@link RangeMeaning#WRAPAROUND}, then:<ul>
- * <li>the lower ordinate value is set to the {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimum value}, and</li>
- * <li>the upper ordinate value is set to the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximum value}.</li>
+ * <li>the lower coordinate value is set to the {@linkplain CoordinateSystemAxis#getMinimumValue() axis minimum value}, and</li>
+ * <li>the upper coordinate value is set to the {@linkplain CoordinateSystemAxis#getMaximumValue() axis maximum value}.</li>
* </ul></li>
* <li>Otherwise an {@link IllegalStateException} is thrown.</li>
* </ul>
@@ -990,29 +990,29 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*
* @return {@code true} if this envelope has been modified as a result of this method call,
* or {@code false} if no change has been done.
- * @throws IllegalStateException if a upper ordinate value is less than a lower ordinate
+ * @throws IllegalStateException if a upper coordinate value is less than a lower coordinate
* value on an axis which does not have the {@code WRAPAROUND} range meaning.
*
* @see #toSimpleEnvelopes()
*/
public boolean simplify() throws IllegalStateException {
boolean changed = false;
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
final int beginIndex = beginIndex();
final int dimension = endIndex() - beginIndex;
for (int i=0; i<dimension; i++) {
final int iLower = beginIndex + i;
final int iUpper = iLower + d;
- final double lower = ordinates[iLower];
- final double upper = ordinates[iUpper];
+ final double lower = coordinates[iLower];
+ final double upper = coordinates[iUpper];
if (isNegative(upper - lower)) { // Use 'isNegative' for catching [+0 … -0] range.
final CoordinateSystemAxis axis = getAxis(crs, i);
if (isWrapAround(axis)) {
- ordinates[iLower] = axis.getMinimumValue();
- ordinates[iUpper] = axis.getMaximumValue();
+ coordinates[iLower] = axis.getMinimumValue();
+ coordinates[iUpper] = axis.getMaximumValue();
changed = true;
} else {
- throw new IllegalStateException(Errors.format(Errors.Keys.IllegalOrdinateRange_3,
+ throw new IllegalStateException(Errors.format(Errors.Keys.IllegalCoordinateRange_3,
lower, upper, (axis != null) ? axis.getName() : i));
}
}
@@ -1042,8 +1042,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
* This method does not compute a sub-CRS because it may not be needed, or the sub-CRS may be already
* known by the caller.
*
- * @param beginIndex the index of the first valid ordinate value of the corners.
- * @param endIndex the index after the last valid ordinate value of the corners.
+ * @param beginIndex the index of the first valid coordinate value of the corners.
+ * @param endIndex the index after the last valid coordinate value of the corners.
* @return the sub-envelope of dimension {@code endIndex - beginIndex}.
* @throws IndexOutOfBoundsException if an index is out of bounds.
*
@@ -1051,8 +1051,8 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
*/
// Must be overridden in SubEnvelope
public GeneralEnvelope subEnvelope(final int beginIndex, final int endIndex) throws IndexOutOfBoundsException {
- ensureValidIndexRange(ordinates.length >>> 1, beginIndex, endIndex);
- return new SubEnvelope(ordinates, beginIndex, endIndex);
+ ensureValidIndexRange(coordinates.length >>> 1, beginIndex, endIndex);
+ return new SubEnvelope(coordinates, beginIndex, endIndex);
/*
* Do not check if we could return "this" as an optimization, in order to keep
* the method contract simpler (i.e. the returned envelope CRS is always null).
@@ -1067,12 +1067,12 @@ public class GeneralEnvelope extends ArrayEnvelope implements Cloneable, Seriali
@Override
public GeneralEnvelope clone() {
try {
- Field field = ordinatesField;
+ Field field = coordinatesField;
if (field == null) {
- ordinatesField = field = GeneralDirectPosition.getOrdinatesField(ArrayEnvelope.class);
+ coordinatesField = field = GeneralDirectPosition.getCoordinatesField(ArrayEnvelope.class);
}
GeneralEnvelope e = (GeneralEnvelope) super.clone();
- field.set(e, ordinates.clone());
+ field.set(e, coordinates.clone());
return e;
} catch (CloneNotSupportedException | ReflectiveOperationException exception) {
/*
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java
index e546d5f..e2384e6 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/ImmutableEnvelope.java
@@ -57,8 +57,8 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
* Constructs an envelope defined by two corners given as direct positions.
* The envelope CRS will be the CRS of the given positions.
*
- * @param lowerCorner the limits in the direction of decreasing ordinate values for each dimension.
- * @param upperCorner the limits in the direction of increasing ordinate values for each dimension.
+ * @param lowerCorner the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upperCorner the limits in the direction of increasing coordinate values for each dimension.
* @throws MismatchedDimensionException if the two positions do not have the same dimension.
* @throws MismatchedReferenceSystemException if the CRS of the two position are not equal.
*/
@@ -69,10 +69,10 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
}
/**
- * Constructs an envelope defined by two corners given as sequences of ordinate values.
+ * Constructs an envelope defined by two corners given as sequences of coordinate values.
*
- * @param lowerCorner the limits in the direction of decreasing ordinate values for each dimension.
- * @param upperCorner the limits in the direction of increasing ordinate values for each dimension.
+ * @param lowerCorner the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upperCorner the limits in the direction of increasing coordinate values for each dimension.
* @param crs the CRS to assign to this envelope, or {@code null}.
* @throws MismatchedDimensionException if the two sequences do not have the same length, or
* if the dimension of the given CRS is not equals to the dimension of the given corners.
@@ -112,7 +112,7 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
}
/**
- * Creates an immutable envelope with the ordinate values of the given envelope but
+ * Creates an immutable envelope with the coordinate values of the given envelope but
* a different CRS. This method does <strong>not</strong> reproject the given envelope.
* It just assign the given CRS to this envelope without any check, except for the CRS
* dimension.
@@ -121,7 +121,7 @@ public final class ImmutableEnvelope extends ArrayEnvelope implements Serializab
* copy has a null CRS.</p>
*
* @param crs the CRS to assign to this envelope, or {@code null}.
- * @param envelope the envelope from which to copy ordinate values.
+ * @param envelope the envelope from which to copy coordinate values.
* @throws MismatchedDimensionException if the dimension of the given CRS is not equals
* to the dimension of the given envelope.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java
index d88b9da..a2ee98e 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Shapes2D.java
@@ -203,8 +203,8 @@ public final class Shapes2D extends Static {
double ymax = Double.NEGATIVE_INFINITY;
/*
* Notation (as if we were applying a map projection, but this is not necessarily the case):
- * - (λ,φ) are ordinate values before projection.
- * - (x,y) are ordinate values after projection.
+ * - (λ,φ) are coordinate values before projection.
+ * - (x,y) are coordinate values after projection.
* - D[00|01|10|11] are the ∂x/∂λ, ∂x/∂φ, ∂y/∂λ and ∂y/∂φ derivatives respectively.
* - Variables with indice 0 are for the very first point in iteration order.
* - Variables with indice 1 are for the values of the previous iteration.
@@ -280,8 +280,8 @@ public final class Shapes2D extends Static {
* to use the information provided by derivatives at those points, if available.
* For the following block, notation is:
*
- * - s are ordinate values in the source space (λ or φ)
- * - t are ordinate values in the target space (x or y)
+ * - s are coordinate values in the source space (λ or φ)
+ * - t are coordinate values in the target space (x or y)
*
* They are not necessarily in the same dimension. For example would could have
* s=λ while t=y. This is typically the case when inspecting the top or bottom
@@ -292,7 +292,7 @@ public final class Shapes2D extends Static {
*/
if (D1 != null && D2 != null) {
final int srcDim;
- final double s1, s2; // Ordinate values in source space (before projection)
+ final double s1, s2; // Coordinate values in source space (before projection)
switch (i) {
case 1: case 2: case 5: case 6: {assert φ2==φ1; srcDim=0; s1=λ1; s2=λ2; break;} // Horizontal segment
case 3: case 4: case 7: case 8: {assert λ2==λ1; srcDim=1; s1=φ1; s2=φ2; break;} // Vertical segment
@@ -309,7 +309,7 @@ public final class Shapes2D extends Static {
* At this point we found the extremum of the projected line segment
* using a cubic curve t = A + Bs + Cs² + Ds³ approximation. Before
* to add those extremum into the projected bounding box, we need to
- * ensure that the source ordinate is inside the the original
+ * ensure that the source coordinate is inside the the original
* (unprojected) bounding box.
*/
boolean isP2 = false;
@@ -574,8 +574,8 @@ public final class Shapes2D extends Static {
}
}
/*
- * At this point we finished envelope transformation. Verify if some ordinates need to be "wrapped around"
- * as a result of the coordinate operation. This is usually the longitude axis where the source CRS uses
+ * At this point we finished envelope transformation. Verify if some coordinates need to be "wrapped around"
+ * as a result of the coordinate operation. This is usually the longitude axis where the source CRS uses
* the [-180 … +180]° range and the target CRS uses the [0 … 360]° range, or the converse. In such case we
* set the rectangle to the full range (we do not use the mechanism documented in Envelope2D) because most
* Rectangle2D implementations do not support spanning the anti-meridian. This results in larger rectangle
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java
index 511cbd3..7b586d7 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/SubEnvelope.java
@@ -44,14 +44,14 @@ final class SubEnvelope extends GeneralEnvelope {
private static final long serialVersionUID = 7241242611077979466L;
/**
- * The index of the first valid ordinate value of the lower corner in the {@link #ordinates} array.
+ * The index of the first valid coordinate value of the lower corner in the {@link #coordinates} array.
*
* @see ArrayEnvelope#beginIndex()
*/
private final int beginIndex;
/**
- * The index after the last valid ordinate value of the lower corner in the {@link #ordinates} array.
+ * The index after the last valid coordinate value of the lower corner in the {@link #coordinates} array.
*
* @see ArrayEnvelope#endIndex()
*/
@@ -62,18 +62,18 @@ final class SubEnvelope extends GeneralEnvelope {
* reference directly; it does <strong>not</strong> clone the given array. This is the desired
* behavior for allowing the {@code SubEnvelope} view to be "live".
*
- * @param ordinates the array of ordinate values to store directly (not cloned).
- * @param beginIndex the index of the first valid ordinate value of the lower corner in the ordinates array.
- * @param endIndex the index after the last valid ordinate value of the lower corner in the ordinates array.
+ * @param coordinates the array of coordinate values to store directly (not cloned).
+ * @param beginIndex the index of the first valid coordinate value of the lower corner in the coordinates array.
+ * @param endIndex the index after the last valid coordinate value of the lower corner in the coordinates array.
*/
- SubEnvelope(final double[] ordinates, final int beginIndex, final int endIndex) {
- super(ordinates);
+ SubEnvelope(final double[] coordinates, final int beginIndex, final int endIndex) {
+ super(coordinates);
this.beginIndex = beginIndex;
this.endIndex = endIndex;
}
/**
- * Returns the index of the first valid ordinate value of the lower corner in the ordinates array.
+ * Returns the index of the first valid coordinate value of the lower corner in the coordinates array.
* This information is used by super-class methods.
*/
@Override
@@ -82,7 +82,7 @@ final class SubEnvelope extends GeneralEnvelope {
}
/**
- * Returns the index after the last valid ordinate value of the lower corner in the ordinates array.
+ * Returns the index after the last valid coordinate value of the lower corner in the coordinates array.
* This information is used by super-class methods.
*/
@Override
@@ -105,7 +105,7 @@ final class SubEnvelope extends GeneralEnvelope {
@Override
public double getLower(final int dimension) throws IndexOutOfBoundsException {
ensureValidIndex(endIndex, dimension);
- return ordinates[dimension + beginIndex];
+ return coordinates[dimension + beginIndex];
}
/**
@@ -115,7 +115,7 @@ final class SubEnvelope extends GeneralEnvelope {
@Override
public double getUpper(final int dimension) throws IndexOutOfBoundsException {
ensureValidIndex(endIndex, dimension);
- return ordinates[dimension + beginIndex + (ordinates.length >>> 1)];
+ return coordinates[dimension + beginIndex + (coordinates.length >>> 1)];
}
/**
@@ -128,14 +128,14 @@ final class SubEnvelope extends GeneralEnvelope {
ensureValidIndex(endIndex, dimension);
/*
* The check performed here shall be identical to the super-class method, which is itself
- * identical to ArrayEnvelope.verifyRanges(crs, ordinates) except that there is no loop.
+ * identical to ArrayEnvelope.verifyRanges(crs, coordinates) except that there is no loop.
*/
if (lower > upper && crs != null && !isWrapAround(crs, dimension)) {
throw new IllegalArgumentException(illegalRange(crs, dimension, lower, upper));
}
dimension += beginIndex;
- ordinates[dimension + (ordinates.length >>> 1)] = upper;
- ordinates[dimension] = lower;
+ coordinates[dimension + (coordinates.length >>> 1)] = upper;
+ coordinates[dimension] = lower;
}
/**
@@ -146,9 +146,9 @@ final class SubEnvelope extends GeneralEnvelope {
final int dimension = getDimension();
verifyArrayLength(dimension, corners);
verifyRanges(crs, corners);
- final int d = ordinates.length >>> 1;
- System.arraycopy(corners, 0, ordinates, beginIndex, dimension);
- System.arraycopy(corners, dimension, ordinates, beginIndex + d, dimension);
+ final int d = coordinates.length >>> 1;
+ System.arraycopy(corners, 0, coordinates, beginIndex, dimension);
+ System.arraycopy(corners, dimension, coordinates, beginIndex + d, dimension);
}
/**
@@ -156,9 +156,9 @@ final class SubEnvelope extends GeneralEnvelope {
*/
@Override
public boolean isAllNaN() {
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
for (int i=beginIndex; i<endIndex; i++) {
- if (!Double.isNaN(ordinates[i]) || !Double.isNaN(ordinates[i+d])) {
+ if (!Double.isNaN(coordinates[i]) || !Double.isNaN(coordinates[i+d])) {
return false;
}
}
@@ -171,9 +171,9 @@ final class SubEnvelope extends GeneralEnvelope {
*/
@Override
public void setToNaN() {
- final int d = ordinates.length >>> 1;
- Arrays.fill(ordinates, beginIndex, endIndex, Double.NaN);
- Arrays.fill(ordinates, beginIndex+d, endIndex+d, Double.NaN);
+ final int d = coordinates.length >>> 1;
+ Arrays.fill(coordinates, beginIndex, endIndex, Double.NaN);
+ Arrays.fill(coordinates, beginIndex+d, endIndex+d, Double.NaN);
assert isAllNaN() : this;
}
@@ -200,20 +200,20 @@ final class SubEnvelope extends GeneralEnvelope {
@Override
public GeneralEnvelope subEnvelope(final int b, final int e) throws IndexOutOfBoundsException {
ensureValidIndexRange(endIndex - beginIndex, b, e);
- return new SubEnvelope(ordinates, b + beginIndex, e + beginIndex);
+ return new SubEnvelope(coordinates, b + beginIndex, e + beginIndex);
}
/**
- * If the user wants a clone, copy only the relevant part of the ordinates array.
+ * If the user wants a clone, copy only the relevant part of the coordinates array.
*/
@Override
@SuppressWarnings("CloneDoesntCallSuperClone")
public GeneralEnvelope clone() {
- final int d = ordinates.length >>> 1;
+ final int d = coordinates.length >>> 1;
final int dimension = endIndex - beginIndex;
final GeneralEnvelope copy = new GeneralEnvelope(endIndex - beginIndex);
- System.arraycopy(ordinates, beginIndex, copy.ordinates, 0, dimension);
- System.arraycopy(ordinates, beginIndex + d, copy.ordinates, dimension, dimension);
+ System.arraycopy(coordinates, beginIndex, copy.coordinates, 0, dimension);
+ System.arraycopy(coordinates, beginIndex + d, copy.coordinates, dimension, dimension);
copy.crs = crs;
return copy;
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java
index c983b78..8bd3a8f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/package-info.java
@@ -69,7 +69,7 @@
* <center><img src="doc-files/AntiMeridian.png" alt="Envelope spannning the anti-meridian"></center>
*
* In SIS, every envelopes defined in this package support the extended bounding box interpretation:
- * for any dimension, ordinate values such that <var>upper</var> < <var>lower</var> are handled
+ * for any dimension, coordinate values such that <var>upper</var> < <var>lower</var> are handled
* in a special way. This handling is slightly different for two groups of methods:
*
* <ul>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java
index 7d82422..4327a87 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/CoordinateOperations.java
@@ -192,7 +192,7 @@ public final class CoordinateOperations extends SystemListener {
}
/**
- * Returns the packed indices of target dimensions where ordinate values may need to be wrapped around.
+ * Returns the packed indices of target dimensions where coordinate values may need to be wrapped around.
* This method matches target coordinate system axes having {@link RangeMeaning#WRAPAROUND} with source
* axes, then verifies if the range of values changed (taking unit conversions in account). A target
* dimension {@code i} may need to "wrap around" the coordinate values if the {@code 1 << i} bit is set.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java
index 7bdf5e4..a9f9ec0 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/DirectPositionView.java
@@ -35,21 +35,21 @@ import org.opengis.geometry.UnmodifiableGeometryException;
*/
public abstract class DirectPositionView extends AbstractDirectPosition {
/**
- * The index of the first value in the ordinates array.
+ * The index of the first value in the coordinates array.
* This field is non-final in order to allow the caller to move the view over an array of coordinates.
*/
public int offset;
/**
- * The number of valid ordinate values.
+ * The number of valid coordinate values.
*/
final int dimension;
/**
* Creates a new direct position wrapping the given array.
*
- * @param offset the first value index in the ordinates array.
- * @param dimension the number of valid ordinate values.
+ * @param offset the first value index in the coordinates array.
+ * @param dimension the number of valid coordinate values.
*/
DirectPositionView(final int offset, final int dimension) {
this.offset = offset;
@@ -92,54 +92,54 @@ public abstract class DirectPositionView extends AbstractDirectPosition {
*/
public static final class Double extends DirectPositionView {
/**
- * The ordinate values. This is a direct reference to the array given to the constructor.
+ * The coordinate values. This is a direct reference to the array given to the constructor.
* The length of this array may be greater then the number of dimensions.
*/
- private final double[] ordinates;
+ private final double[] coordinates;
/**
* Creates a new direct position wrapping the given array.
*
- * @param ordinates the ordinate values.
+ * @param coordinates the coordinate values.
*/
- public Double(final double[] ordinates) {
- super(0, ordinates.length);
- this.ordinates = ordinates;
+ public Double(final double[] coordinates) {
+ super(0, coordinates.length);
+ this.coordinates = coordinates;
}
/**
* Creates a new direct position wrapping the given array.
*
- * @param ordinates the ordinate values.
- * @param offset the first value index in the ordinates array.
- * @param dimension the number of valid ordinate values.
+ * @param coordinates the coordinate values.
+ * @param offset the first value index in the coordinates array.
+ * @param dimension the number of valid coordinate values.
*/
- public Double(final double[] ordinates, final int offset, final int dimension) {
+ public Double(final double[] coordinates, final int offset, final int dimension) {
super(offset, dimension);
- this.ordinates = ordinates;
+ this.coordinates = coordinates;
}
/**
- * Returns the ordinate at the given index.
+ * Returns the coordinate at the given index.
* <strong>This implementation does not check index validity</strong>, unless assertions are enabled.
*
- * @param dim the dimension of the ordinate to get fetch.
+ * @param dim the dimension of the coordinate to get fetch.
* @return the coordinate value at the given dimension.
*/
@Override
public double getOrdinate(final int dim) {
assert dim >= 0 && dim < dimension : dim;
- return ordinates[offset + dim];
+ return coordinates[offset + dim];
}
/**
- * Returns all ordinate values.
+ * Returns all coordinate values.
*
* @return all coordinate values.
*/
@Override
public double[] getCoordinate() {
- return Arrays.copyOfRange(ordinates, offset, offset + dimension);
+ return Arrays.copyOfRange(coordinates, offset, offset + dimension);
}
}
@@ -148,34 +148,34 @@ public abstract class DirectPositionView extends AbstractDirectPosition {
*/
public static final class Float extends DirectPositionView {
/**
- * The ordinate values. This is a direct reference to the array given to the constructor.
+ * The coordinate values. This is a direct reference to the array given to the constructor.
* The length of this array may be greater then the number of dimensions.
*/
- private final float[] ordinates;
+ private final float[] coordinates;
/**
* Creates a new direct position wrapping the given array.
*
- * @param ordinates the ordinate values.
- * @param offset the first value index in the ordinates array.
- * @param dimension the number of valid ordinate values.
+ * @param coordinates the coordinate values.
+ * @param offset the first value index in the coordinates array.
+ * @param dimension the number of valid coordinate values.
*/
- public Float(final float[] ordinates, final int offset, final int dimension) {
+ public Float(final float[] coordinates, final int offset, final int dimension) {
super(offset, dimension);
- this.ordinates = ordinates;
+ this.coordinates = coordinates;
}
/**
- * Returns the ordinate at the given index.
+ * Returns the coordinate at the given index.
* <strong>This implementation does not check index validity</strong>, unless assertions are enabled.
*
- * @param dim the dimension of the ordinate to get fetch.
+ * @param dim the dimension of the coordinate to get fetch.
* @return the coordinate value at the given dimension.
*/
@Override
public double getOrdinate(final int dim) {
assert dim >= 0 && dim < dimension : dim;
- return ordinates[offset + dim];
+ return coordinates[offset + dim];
}
}
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java
index aeea24b..9c12b04 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/EPSGParameterDomain.java
@@ -24,7 +24,7 @@ import org.apache.sis.internal.util.CollectionsExt;
/**
* The domain of values of an EPSG parameter which accepts different units.
- * An example is the EPSG:8617 (<cite>Ordinate 1 of evaluation point</cite>) parameter,
+ * An example is the EPSG:8617 (<cite>Coordinate 1 of evaluation point</cite>) parameter,
* which may be used in the EPSG database with either metres or degrees units.
*
* @author Martin Desruisseaux (Geomatys)
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
index 95f8fb0..9c145a2 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
@@ -39,7 +39,7 @@ import static org.apache.sis.internal.metadata.ReferencingServices.NAUTICAL_MILE
*/
public final class Formulas extends Static {
/**
- * Default tolerance threshold for comparing ordinate values in a projected CRS,
+ * Default tolerance threshold for comparing coordinate values in a projected CRS,
* assuming that the unit of measurement is metre. This constant determines also
* (indirectly) the minimum accuracy of iterative methods in map projections.
*
@@ -49,7 +49,7 @@ public final class Formulas extends Static {
public static final double LINEAR_TOLERANCE = 0.01;
/**
- * Default tolerance threshold for comparing ordinate values in a geographic CRS,
+ * Default tolerance threshold for comparing coordinate values in a geographic CRS,
* assuming that the unit of measurement is decimal degrees and using the standard
* nautical mile length.
*
@@ -61,7 +61,7 @@ public final class Formulas extends Static {
public static final double ANGULAR_TOLERANCE = LINEAR_TOLERANCE / (NAUTICAL_MILE * 60);
/**
- * Default tolerance threshold for comparing ordinate values in temporal CRS,
+ * Default tolerance threshold for comparing coordinate values in temporal CRS,
* assuming that the unit of measurement is second. Current value is arbitrary
* and may change in any future Apache SIS version.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java
index 6ad5976..ba51d6d 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/PositionTransformer.java
@@ -263,6 +263,6 @@ public final class PositionTransformer extends GeneralDirectPosition {
* @throws TransformException if a coordinate transformation was required and failed.
*/
public Matrix inverseTransform(final double[] target) throws TransformException {
- return MathTransforms.derivativeAndTransform(inverse(), ordinates, 0, target, 0);
+ return MathTransforms.derivativeAndTransform(inverse(), coordinates, 0, target, 0);
}
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java
index 839177b..f5e455d 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ServicesForMetadata.java
@@ -326,7 +326,7 @@ public final class ServicesForMetadata extends ReferencingServices {
/**
* Sets a vertical extent with the value inferred from the given envelope.
- * Only the vertical ordinates are extracted; all other ordinates are ignored.
+ * Only the vertical coordinates are extracted; all other coordinates are ignored.
*
* @param envelope the source envelope.
* @param target the target vertical extent where to store envelope information.
@@ -344,7 +344,7 @@ public final class ServicesForMetadata extends ReferencingServices {
/**
* Sets a temporal extent with the value inferred from the given envelope.
- * Only the vertical ordinates are extracted; all other ordinates are ignored.
+ * Only the vertical coordinates are extracted; all other coordinates are ignored.
*
* @param envelope the source envelope.
* @param target the target temporal extent where to store envelope information.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java
index 620e314..346222a 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/j2d/IntervalRectangle.java
@@ -59,10 +59,10 @@ import org.apache.sis.internal.util.Strings;
*/
@SuppressWarnings("CloneableClassWithoutClone")
public class IntervalRectangle extends Rectangle2D {
- /** Minimal <var>x</var> ordinate value. */ public double xmin;
- /** Minimal <var>y</var> ordinate value. */ public double ymin;
- /** Maximal <var>x</var> ordinate value. */ public double xmax;
- /** Maximal <var>y</var> ordinate value. */ public double ymax;
+ /** Minimal <var>x</var> coordinate value. */ public double xmin;
+ /** Minimal <var>y</var> coordinate value. */ public double ymin;
+ /** Maximal <var>x</var> coordinate value. */ public double xmax;
+ /** Maximal <var>y</var> coordinate value. */ public double ymax;
/**
* Constructs a default rectangle initialized to {@code (0,0,0,0)}.
@@ -97,14 +97,14 @@ public class IntervalRectangle extends Rectangle2D {
/**
* Constructs a rectangle initialized to the two first dimensions of the given corners.
- * This constructor unconditionally assigns {@code lower} ordinates to {@link #xmin}, {@link #ymin} and
- * {@code upper} ordinates to {@link #xmax}, {@link #ymax} regardless of their values; this constructor
- * does not verify if {@code lower} ordinates are smaller than {@code upper} ordinates.
+ * This constructor unconditionally assigns {@code lower} coordinates to {@link #xmin}, {@link #ymin} and
+ * {@code upper} coordinates to {@link #xmax}, {@link #ymax} regardless of their values; this constructor
+ * does not verify if {@code lower} coordinates are smaller than {@code upper} coordinates.
* This is sometime useful for creating a rectangle spanning the anti-meridian,
* even if {@code IntervalRectangle} class does not support such rectangles by itself.
*
- * @param lower the limits in the direction of decreasing ordinate values for each dimension.
- * @param upper the limits in the direction of increasing ordinate values for each dimension.
+ * @param lower the limits in the direction of decreasing coordinate values for each dimension.
+ * @param upper the limits in the direction of increasing coordinate values for each dimension.
*
* @see Envelope#getLowerCorner()
* @see Envelope#getUpperCorner()
@@ -120,10 +120,10 @@ public class IntervalRectangle extends Rectangle2D {
* Creates a rectangle using maximal <var>x</var> and <var>y</var> values rather than width and height.
* This constructor avoid the problem of NaN values when extremum are infinite numbers.
*
- * @param xmin minimal <var>x</var> ordinate value.
- * @param ymin minimal <var>y</var> ordinate value.
- * @param xmax maximal <var>x</var> ordinate value.
- * @param ymax maximal <var>y</var> ordinate value.
+ * @param xmin minimal <var>x</var> coordinate value.
+ * @param ymin minimal <var>y</var> coordinate value.
+ * @param xmax maximal <var>x</var> coordinate value.
+ * @param ymax maximal <var>y</var> coordinate value.
*/
public IntervalRectangle(final double xmin, final double ymin, final double xmax, final double ymax) {
this.xmin = xmin;
@@ -144,9 +144,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the minimal <var>x</var> ordinate value.
+ * Returns the minimal <var>x</var> coordinate value.
*
- * @return the minimal <var>x</var> ordinate value.
+ * @return the minimal <var>x</var> coordinate value.
*/
@Override
public final double getX() {
@@ -154,9 +154,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the minimal <var>y</var> ordinate value.
+ * Returns the minimal <var>y</var> coordinate value.
*
- * @return the minimal <var>y</var> ordinate value.
+ * @return the minimal <var>y</var> coordinate value.
*/
@Override
public final double getY() {
@@ -186,9 +186,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the minimal <var>x</var> ordinate value.
+ * Returns the minimal <var>x</var> coordinate value.
*
- * @return the minimal <var>x</var> ordinate value.
+ * @return the minimal <var>x</var> coordinate value.
*/
@Override
public final double getMinX() {
@@ -196,9 +196,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the minimal <var>y</var> ordinate value.
+ * Returns the minimal <var>y</var> coordinate value.
*
- * @return the minimal <var>y</var> ordinate value.
+ * @return the minimal <var>y</var> coordinate value.
*/
@Override
public final double getMinY() {
@@ -206,9 +206,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the maximal <var>x</var> ordinate value.
+ * Returns the maximal <var>x</var> coordinate value.
*
- * @return the maximal <var>x</var> ordinate value.
+ * @return the maximal <var>x</var> coordinate value.
*/
@Override
public final double getMaxX() {
@@ -216,9 +216,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the maximal <var>y</var> ordinate value.
+ * Returns the maximal <var>y</var> coordinate value.
*
- * @return the maximal <var>y</var> ordinate value.
+ * @return the maximal <var>y</var> coordinate value.
*/
@Override
public final double getMaxY() {
@@ -226,9 +226,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the <var>x</var> ordinate of the center of the rectangle.
+ * Returns the <var>x</var> coordinate of the center of the rectangle.
*
- * @return the median <var>x</var> ordinate value.
+ * @return the median <var>x</var> coordinate value.
*/
@Override
public final double getCenterX() {
@@ -236,9 +236,9 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the <var>y</var> ordinate of the center of the rectangle.
+ * Returns the <var>y</var> coordinate of the center of the rectangle.
*
- * @return the median <var>y</var> ordinate value.
+ * @return the median <var>y</var> coordinate value.
*/
@Override
public final double getCenterY() {
@@ -248,8 +248,8 @@ public class IntervalRectangle extends Rectangle2D {
/**
* Sets the location and size of this rectangle to the specified values.
*
- * @param x the <var>x</var> minimal ordinate value.
- * @param y the <var>y</var> minimal ordinate value.
+ * @param x the <var>x</var> minimal coordinate value.
+ * @param y the <var>y</var> minimal coordinate value.
* @param width the rectangle width.
* @param height the rectangle height.
*/
@@ -292,8 +292,8 @@ public class IntervalRectangle extends Rectangle2D {
* The edges are considered exclusive; this method returns {@code false} if the two rectangles just touch to each
* other.
*
- * @param x the <var>x</var> minimal ordinate value.
- * @param y the <var>y</var> minimal ordinate value.
+ * @param x the <var>x</var> minimal coordinate value.
+ * @param y the <var>y</var> minimal coordinate value.
* @param width the rectangle width.
* @param height the rectangle height.
* @return {@code true} if this rectangle intersects the interior of the specified set of rectangular coordinates.
@@ -331,8 +331,8 @@ public class IntervalRectangle extends Rectangle2D {
/**
* Tests if the interior of this rectangle entirely contains the specified set of rectangular coordinates.
*
- * @param x the <var>x</var> minimal ordinate value.
- * @param y the <var>y</var> minimal ordinate value.
+ * @param x the <var>x</var> minimal coordinate value.
+ * @param y the <var>y</var> minimal coordinate value.
* @param width the rectangle width.
* @param height the rectangle height.
* @return {@code true} if this rectangle entirely contains specified set of rectangular coordinates.
@@ -476,8 +476,8 @@ public class IntervalRectangle extends Rectangle2D {
* added point falls on the left or bottom edge of the enlarged rectangle, {@code contains}
* returns {@code false} for that point.</p>
*
- * @param x x ordinate value of the point to add.
- * @param y y ordinate value of the point to add.
+ * @param x x coordinate value of the point to add.
+ * @param y y coordinate value of the point to add.
*/
@Override
public final void add(final double x, final double y) {
@@ -503,7 +503,7 @@ public class IntervalRectangle extends Rectangle2D {
}
/**
- * Returns the {@code String} representation of this {@code Rectangle2D}. The ordinate order is
+ * Returns the {@code String} representation of this {@code Rectangle2D}. The coordinate order is
* (<var>x</var><sub>min</sub>, <var>y</var><sub>min</sub>, <var>x</var><sub>max</sub>, <var>y</var><sub>max</sub>),
* which is consistent with the {@link #IntervalRectangle(double, double, double, double)} constructor
* and with the {@code BBOX} <cite>Well Known Text</cite> (WKT) syntax.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java b/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java
index cde64bc..2e95ee4 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/parameter/Verifier.java
@@ -334,7 +334,7 @@ final class Verifier {
/**
* If the given domain of values accepts units of incompatible dimensions, return the unit which is compatible
* with the given units. This is a non-public mechanism handling a few parameters in the EPSG database, like
- * <cite>Ordinate 1 of evaluation point</cite> (EPSG:8617).
+ * <cite>Coordinate 1 of evaluation point</cite> (EPSG:8617).
*/
private static Unit<?> getCompatibleUnit(final Range<?> valueDomain, final Unit<?> unit) {
if (valueDomain instanceof EPSGParameterDomain) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java
index 410c7b6..d5a4cd5 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/AxesConvention.java
@@ -233,9 +233,9 @@ public enum AxesConvention implements AxisFilter {
},
/**
- * Axes are ordered for a <cite>right-handed</cite> coordinate system. Axis directions, ranges or ordinate values
- * and units of measurement are unchanged. In the two-dimensional case, the handedness is defined from the point
- * of view of an observer above the plane of the system.
+ * Axes are ordered for a <cite>right-handed</cite> coordinate system. Axis directions, ranges or coordinate values
+ * and units of measurement are unchanged. In the two-dimensional case, the handedness is defined from the point of
+ * view of an observer above the plane of the system.
*
* <p>Note that a right-handed coordinate system does not guarantee that longitude or <var>x</var> axis
* will be first in every cases. The most notable exception is the case of (West, North) orientations.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java
index 47541c7..fed9355 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultCoordinateSystemAxis.java
@@ -432,11 +432,11 @@ public class DefaultCoordinateSystemAxis extends AbstractIdentifiedObject implem
}
/**
- * Returns the unit of measure used for this coordinate system axis. If this {@code CoordinateSystemAxis}
- * was given by <code>{@link AbstractCS#getAxis(int) CoordinateSystem.getAxis}(i)</code>, then all ordinate
+ * Returns the unit of measure used for this coordinate system axis. If this {@code CoordinateSystemAxis} was
+ * given by <code>{@link AbstractCS#getAxis(int) CoordinateSystem.getAxis}(i)</code>, then all coordinate
* values at dimension <var>i</var> in a coordinate tuple shall be recorded using this unit of measure.
*
- * @return the unit of measure used for ordinate values along this coordinate system axis.
+ * @return the unit of measure used for coordinate values along this coordinate system axis.
*/
@Override
@XmlAttribute(name= "uom", required = true)
@@ -627,7 +627,7 @@ public class DefaultCoordinateSystemAxis extends AbstractIdentifiedObject implem
/*
* At this point the comparison is in "ignore metadata" mode. We compare the axis range
* only if the range meaning is "wraparound" for both axes, because only in such case a
- * coordinate operation may shift some ordinate values (typically ±360° on longitudes).
+ * coordinate operation may shift some coordinate values (typically ±360° on longitudes).
*/
final CoordinateSystemAxis that = (CoordinateSystemAxis) object;
if (!equalsIgnoreMetadata(that, mode, RangeMeaning.WRAPAROUND.equals(this.getRangeMeaning()) &&
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java
index 62c144b..9b186ee 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/DefaultLinearCS.java
@@ -29,7 +29,7 @@ import org.apache.sis.measure.Units;
/**
* A 1-dimensional coordinate system for points that lie on a single axis (not necessarily a straight line).
- * Ordinate values are distances from the axis origin to the point along the axis.
+ * Coordinate values are distances from the axis origin to the point along the axis.
* A typical example is an axis for representing the points along a road.
*
* <table class="sis">
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java
index fc5b5e2..6a7106f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/cs/Normalizer.java
@@ -378,9 +378,9 @@ final class Normalizer implements Comparable<Normalizer> {
*
* <p>This method shifts the axis {@linkplain CoordinateSystemAxis#getMinimumValue() minimum} and
* {@linkplain CoordinateSystemAxis#getMaximumValue() maximum} values by a multiple of half the range
- * (typically 180°). This method does not change the meaning of ordinate values. For example a longitude
- * of -60° still locate the same point in the old and the new coordinate system. But the preferred way
- * to locate that point become the 300° value if the longitude range has been shifted to positive values.</p>
+ * (typically 180°). This method does not change the meaning of coordinate values. For example a longitude
+ * of -60° still locate the same point in the old and the new coordinate system. But the preferred way to
+ * locate that point become the 300° value if the longitude range has been shifted to positive values.</p>
*
* @return a coordinate system using the given kind of longitude range, or {@code null} if no change is needed.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
index e98c4b0..0a363f6 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/datum/DefaultEllipsoid.java
@@ -609,7 +609,7 @@ public class DefaultEllipsoid extends AbstractIdentifiedObject implements Ellips
if (abs(φ1) <= COMPARISON_THRESHOLD && abs(φ2) <= COMPARISON_THRESHOLD) {
return abs(λ1-λ2) * getSemiMajorAxis(); // Points are on the equator.
}
- // At least one input ordinate is NaN.
+ // At least one input coordinate is NaN.
if (isNaN(λ1) || isNaN(φ1) || isNaN(λ2) || isNaN(φ2)) {
return NaN;
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
index f5fdebe..f895aff 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
@@ -2527,7 +2527,7 @@ codes: for (int i=0; i<codes.length; i++) {
* Search for units. We typically have many different units but all of the same dimension
* (for example metres, kilometres, feet, etc.). In such case, the units Set will have only
* one element and that element will be the most frequently used unit. But some parameters
- * accept units of different dimensions. For example the "Ordinate 1 of evaluation point"
+ * accept units of different dimensions. For example the "Coordinate 1 of evaluation point"
* (EPSG:8617) parameter value may be in metres or in degrees. In such case the units Set
* will have two elements.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java
index c421576..691f8ca 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/AbstractCoordinateOperation.java
@@ -321,12 +321,12 @@ public class AbstractCoordinateOperation extends AbstractIdentifiedObject implem
* target dimension}, minus the dimension of the {@code interpolationCRS} (if any).</li>
* </ul>
*
- * If the {@code interpolationCRS} is non-null, then the given {@code transform} shall expect input ordinates
+ * If the {@code interpolationCRS} is non-null, then the given {@code transform} shall expect input coordinates
* in the following order:
*
* <ol>
- * <li>Ordinates of the interpolation CRS. Example: (<var>x</var>,<var>y</var>) in a vertical transform.</li>
- * <li>Ordinates of the source CRS. Example: (<var>z</var>) in a vertical transform.</li>
+ * <li>Coordinates of the interpolation CRS. Example: (<var>x</var>,<var>y</var>) in a vertical transform.</li>
+ * <li>Coordinates of the source CRS. Example: (<var>z</var>) in a vertical transform.</li>
* </ol>
*
* The math transform shall let the interpolation coordinates {@linkplain DefaultPassThroughOperation pass through
@@ -664,7 +664,7 @@ check: for (int isTarget=0; ; isTarget++) { // 0 == source check; 1
* <div class="section">Use with interpolation CRS</div>
* If the {@linkplain #getInterpolationCRS() interpolation CRS} is non-null, then the math transform
* input coordinates shall by (<var>interpolation</var>, <var>source</var>) tuples: for each value
- * to transform, the interpolation point ordinates shall be first, followed by the source coordinates.
+ * to transform, the interpolation point coordinates shall be first, followed by the source coordinates.
*
* <div class="note"><b>Example:</b>
* in a transformation between two {@linkplain org.apache.sis.referencing.crs.DefaultVerticalCRS vertical CRS},
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
index 0ec2e3f..1944f8f 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
@@ -899,8 +899,8 @@ public class CoordinateOperationFinder extends CoordinateOperationRegistry {
final CoordinateReferenceSystem[] stepComponents = new CoordinateReferenceSystem[infos.length];
/*
* Operations found are stored in 'infos', but are not yet wrapped in PassThroughOperations.
- * We need to know first if some ordinate values need reordering for matching the target CRS
- * order. We also need to know if any source ordinates should be dropped.
+ * We need to know first if some coordinate values need reordering for matching the target CRS
+ * order. We also need to know if any source coordinates should be dropped.
*/
for (int i=0; i<infos.length; i++) {
if ((infos[i] = SubOperationInfo.create(this, sourceIsUsed, sourceComponents, targetComponents.get(i))) == null) {
@@ -975,7 +975,7 @@ public class CoordinateOperationFinder extends CoordinateOperationRegistry {
final int startAtDimension = endAtDimension;
endAtDimension += delta;
/*
- * Constructs the pass through transform only if there is at least one ordinate to pass.
+ * Constructs the pass through transform only if there is at least one coordinate to pass.
* Actually the code below would work inconditionally, but we perform this check anyway
* for avoiding the creation of intermediate objects.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java
index 9decaff..c493207 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/DefaultPassThroughOperation.java
@@ -336,23 +336,23 @@ public class DefaultPassThroughOperation extends AbstractCoordinateOperation imp
/**
* Invoked by JAXB at unmarshalling time for setting the modified coordinates.
*/
- private void setIndices(final int[] ordinates) {
+ private void setIndices(final int[] coordinates) {
String missing = "sourceCRS";
final CoordinateReferenceSystem sourceCRS = super.getSourceCRS();
if (sourceCRS != null) {
missing = "modifiedCoordinate";
- if (ordinates != null && ordinates.length != 0) {
+ if (coordinates != null && coordinates.length != 0) {
missing = "coordOperation";
if (operation != null) {
- for (int i=1; i<ordinates.length; i++) {
- final int previous = ordinates[i-1];
- if (previous < 1 || ordinates[i] != previous + 1) {
+ for (int i=1; i<coordinates.length; i++) {
+ final int previous = coordinates[i-1];
+ if (previous < 1 || coordinates[i] != previous + 1) {
throw new IllegalArgumentException(Errors.format(
- Errors.Keys.CanNotAssign_2, missing, Arrays.toString(ordinates)));
+ Errors.Keys.CanNotAssign_2, missing, Arrays.toString(coordinates)));
}
}
- transform = MathTransforms.passThrough(ordinates[0] - 1, operation.getMathTransform(),
- ReferencingUtilities.getDimension(sourceCRS) - ordinates[ordinates.length - 1]);
+ transform = MathTransforms.passThrough(coordinates[0] - 1, operation.getMathTransform(),
+ ReferencingUtilities.getDimension(sourceCRS) - coordinates[coordinates.length - 1]);
return;
}
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java
index cb1844c..df4d943 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Matrices.java
@@ -254,8 +254,8 @@ public final class Matrices extends Static {
/*
* Maps source axes to destination axes. If no axis is moved (for example if the user
* want to transform (NORTH,EAST) to (SOUTH,EAST)), then source and destination index
- * will be equal. If some axes are moved (for example if the user want to transform
- * (NORTH,EAST) to (EAST,NORTH)), then ordinates at index {@code srcIndex} will have
+ * will be equal. If some axes are moved (for example if the user want to transform
+ * (NORTH,EAST) to (EAST,NORTH)), then coordinates at index {@code srcIndex} will have
* to be moved at index {@code dstIndex}.
*/
for (int dstIndex = 0; dstIndex < dstAxes.length; dstIndex++) {
@@ -397,7 +397,7 @@ public final class Matrices extends Static {
*
* <ul>
* <li>If some {@code srcAxes} directions can not be mapped to {@code dstAxes} directions, then the transform
- * will silently drops the ordinates associated to those extra source axis directions.</li>
+ * will silently drops the coordinates associated to those extra source axis directions.</li>
* <li>If some {@code dstAxes} directions can not be mapped to {@code srcAxes} directions,
* then an exception will be thrown.</li>
* </ul>
@@ -480,14 +480,14 @@ public final class Matrices extends Static {
* }
*
* will return the following square matrix. The transform of a corner is given as an example.
- * Note that the input ordinate values are swapped because of the (<i>North</i>, <i>West</i>) axis directions,
+ * Note that the input coordinate values are swapped because of the (<i>North</i>, <i>West</i>) axis directions,
* and the lower-left corner of the destination envelope is the lower-<em>right</em> corner of the source envelope
* because of the opposite axis direction.
*
* {@preformat math
* ┌ ┐ ┌ ┐ ┌ ┐
* │ -10 │ │ 0 -3.0 350 │ │ -40 │
- * │ -25 │ = │ 2.5 0 75 │ × │ 120 │ // 120 is the westernmost source ordinate: (x=20) + (width=100)
+ * │ -25 │ = │ 2.5 0 75 │ × │ 120 │ // 120 is the westernmost source coordinate: (x=20) + (width=100)
* │ 1 │ │ 0 0 1 │ │ 1 │
* └ ┘ └ ┘ └ ┘
* }
@@ -519,7 +519,7 @@ public final class Matrices extends Static {
}
/**
- * Creates a matrix for a transform that keep only a subset of source ordinate values.
+ * Creates a matrix for a transform that keep only a subset of source coordinate values.
* The matrix size will be ({@code selectedDimensions.length} + 1) × ({@code sourceDimensions} + 1).
* The matrix will contain only zero elements, except for the following cells which will contain 1:
*
@@ -529,9 +529,9 @@ public final class Matrices extends Static {
* </ul>
*
* <div class="note"><b>Example:</b>
- * given (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>) ordinate values, if one wants to keep
- * (<var>y</var>,<var>x</var>,<var>t</var>) ordinates (note the <var>x</var> ↔ <var>y</var> swapping)
- * and discard the <var>z</var> values, then the indices of source ordinates to select are 1 for <var>y</var>,
+ * given (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>) coordinate values, if one wants to keep
+ * (<var>y</var>,<var>x</var>,<var>t</var>) coordinates (note the <var>x</var> ↔ <var>y</var> swapping)
+ * and discard the <var>z</var> values, then the indices of source coordinates to select are 1 for <var>y</var>,
* 0 for <var>x</var> and 3 for <var>t</var>. One can use the following method call:
*
* {@preformat java
@@ -556,7 +556,7 @@ public final class Matrices extends Static {
* Other dimensions will work as expected.
*
* @param sourceDimensions the number of dimensions in source coordinates.
- * @param selectedDimensions the 0-based indices of source ordinate values to keep.
+ * @param selectedDimensions the 0-based indices of source coordinate values to keep.
* The length of this array will be the number of dimensions in target coordinates.
* @return an affine transform matrix keeping only the given source dimensions, and discarding all others.
* @throws IllegalArgumentException if a value of {@code selectedDimensions} is lower than 0
@@ -577,7 +577,7 @@ public final class Matrices extends Static {
}
/**
- * Creates a matrix which converts a subset of ordinates using the transform given by another matrix.
+ * Creates a matrix which converts a subset of coordinates using the transform given by another matrix.
* For example giving (<var>latitude</var>, <var>longitude</var>, <var>height</var>) coordinates,
* a pass through operation can convert the height values from feet to metres without affecting
* the (<var>latitude</var>, <var>longitude</var>) values.
@@ -617,7 +617,7 @@ public final class Matrices extends Static {
* }
*
* Then a call to {@code Matrices.createPassThrough(2, subMatrix, 1)} will return the following matrix,
- * which can be used for converting the height (<var>z</var>) without affecting the other ordinate values
+ * which can be used for converting the height (<var>z</var>) without affecting the other coordinate values
* (<var>x</var>,<var>y</var>,<var>t</var>):
*
* {@preformat math
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java
index 28ef560..ac044c8 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/MatrixSIS.java
@@ -419,7 +419,7 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
* <p>This method is useful when the matrix is a
* {@linkplain org.opengis.referencing.operation.MathTransform#derivative transform derivative}.
* In such matrix, each column is a vector representing the displacement in target space when an
- * ordinate in the source space is increased by one. Invoking this method turns those vectors
+ * coordinate in the source space is increased by one. Invoking this method turns those vectors
* into unitary vectors, which is useful for forming the basis of a new coordinate system.</p>
*
* @throws UnsupportedOperationException if this matrix is unmodifiable.
@@ -450,7 +450,7 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
/**
* Assuming that this matrix represents an affine transform, concatenates a scale and a translation on the
* given dimension. Converting a point with the resulting matrix is equivalent to first convert the point
- * with {@code ordinates[srcDim] = ordinates[srcDim] * scale + offset}, then apply the original matrix.
+ * with {@code coordinates[srcDim] = coordinates[srcDim] * scale + offset}, then apply the original matrix.
*
* <div class="section">Equivalence between this method and Java2D {@code AffineTransform} methods</div>
* If this matrix was an instance of Java2D {@link AffineTransform}, then invoking this method would
@@ -471,9 +471,9 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
* </tr>
* </table>
*
- * @param srcDim the dimension of the ordinate to rescale in the source coordinates.
- * @param scale the amount by which to multiply the source ordinate value before to apply the transform, or {@code null} if none.
- * @param offset the amount by which to translate the source ordinate value before to apply the transform, or {@code null} if none.
+ * @param srcDim the dimension of the coordinate to rescale in the source coordinates.
+ * @param scale the amount by which to multiply the source coordinate value before to apply the transform, or {@code null} if none.
+ * @param offset the amount by which to translate the source coordinate value before to apply the transform, or {@code null} if none.
* @throws UnsupportedOperationException if this matrix is unmodifiable.
*
* @see AffineTransform#concatenate(AffineTransform)
@@ -504,11 +504,11 @@ public abstract class MatrixSIS implements Matrix, LenientComparable, Cloneable,
/**
* Assuming that this matrix represents an affine transform, pre-concatenates a scale and a translation on the
* given dimension. Converting a point with the resulting matrix is equivalent to first convert the point with
- * the original matrix, then convert the result with {@code ordinates[tgtDim] = ordinates[tgtDim] * scale + offset}.
+ * the original matrix, then convert the result with {@code coordinates[tgtDim] = coordinates[tgtDim] * scale + offset}.
*
- * @param tgtDim the dimension of the ordinate to rescale in the target coordinates.
- * @param scale the amount by which to multiply the target ordinate value after this transform, or {@code null} if none.
- * @param offset the amount by which to translate the target ordinate value after this transform, or {@code null} if none.
+ * @param tgtDim the dimension of the coordinate to rescale in the target coordinates.
+ * @param scale the amount by which to multiply the target coordinate value after this transform, or {@code null} if none.
+ * @param offset the amount by which to translate the target coordinate value after this transform, or {@code null} if none.
* @throws UnsupportedOperationException if this matrix is unmodifiable.
*
* @see AffineTransform#preConcatenate(AffineTransform)
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java
index f2cafbb..8def848 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/NonSquareMatrix.java
@@ -127,7 +127,7 @@ final class NonSquareMatrix extends GeneralMatrix {
* If this matrix has more columns than rows, then this method can invert that matrix if and only if
* some columns contain only 0 elements. In such case, the dimensions corresponding to those columns are
* considered independent of all other dimensions. This happen typically with the dimension of <var>z</var>
- * and <var>t</var> ordinate values.</p>
+ * and <var>t</var> coordinate values.</p>
*
* <p><b>Example:</b> in a conversion from (x₁,y₁,z,t) to (x₂,y₂), if the (x,y) dimensions are independent
* of z and t dimensions, then we do not need those (z,t) dimensions for calculating the inverse of (x₁,y₁)
@@ -159,7 +159,7 @@ final class NonSquareMatrix extends GeneralMatrix {
* <p>Conversely, if the matrix has more rows than columns (in a system of linear equations, the system would
* be <cite>overdetermined</cite>), then we omit the rows containing only zero or NaN values. After the matrix
* inversion, we insert columns having only zero values for the dimensions associated to those rows.
- * Semantically, the inverse matrix is a (x₁,y₁,z,t) → (x₂,y₂) transform that just discards the ordinate values
+ * Semantically, the inverse matrix is a (x₁,y₁,z,t) → (x₂,y₂) transform that just discards the coordinate values
* at the dimensions corresponding to those rows.</p>
*/
@Override
@@ -172,8 +172,8 @@ final class NonSquareMatrix extends GeneralMatrix {
}
/**
- * Inverses a matrix for a transform where target points have fewer ordinates than source points.
- * If a column contains only zero values, then this means that the ordinate at the corresponding
+ * Inverses a matrix for a transform where target points have fewer coordinates than source points.
+ * If a column contains only zero values, then this means that the coordinate at the corresponding
* column is simply deleted. We can omit that column. We check the last columns before the first
* columns on the assumption that last dimensions are more likely to be independent dimensions
* like time.
@@ -212,13 +212,13 @@ next: do {
}
squareMatrix = (GeneralMatrix) Solver.inverse(squareMatrix, false);
/*
- * Create a new matrix with new rows added for the omitted ordinates.
+ * Create a new matrix with new rows added for the omitted coordinates.
* From this point, the meaning of 'numCol' and 'numRow' are interchanged.
*/
final NonSquareMatrix inverse = new NonSquareMatrix(numCol, numRow, false, 2);
for (oi=0, j=0, i=0; i<numCol; i++) {
if (oi != omitted.length && i == omitted[oi]) {
- inverse.setElement(i, numRow-1, Double.NaN); // Translation term to NaN, remaining to 0.
+ inverse.setElement(i, numRow-1, Double.NaN); // Translation term to NaN, remaining to 0.
oi++;
} else {
copyRow(squareMatrix, j++, inverse, i);
@@ -228,8 +228,8 @@ next: do {
}
/**
- * Inverses a matrix for a transform where target points has more ordinates than source points.
- * In other words, the target matrices will be a transform that discard some ordinate values.
+ * Inverses a matrix for a transform where target points has more coordinates than source points.
+ * In other words, the target matrices will be a transform that discard some coordinate values.
* We will discard the ones for which the row contains only 0 or NaN elements.
*
* <p>In the special case where the last row is of the form [0 0 … 0 1] as in affine transforms,
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
index 3b19b9c..917ea42 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
@@ -153,7 +153,7 @@ final class Solver implements Matrix { // Not Cloneable
* Implementation of {@code solve} and {@code inverse} methods, with filtering of NaN values.
* This method searches for NaN values before to attempt solving or inverting the matrix.
* If some NaN values are found but the matrix is written in such a way that each NaN value
- * is used for exactly one ordinate value (i.e. a matrix row is used for a one-dimensional
+ * is used for exactly one coordinate value (i.e. a matrix row is used for a one-dimensional
* conversion which is independent of all other dimensions), then we will edit the matrix in
* such a way that this NaN value does not prevent the inverse matrix to be computed.
*
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
index 1b6974e..81788f4 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/NormalizedProjection.java
@@ -657,7 +657,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
* transform derivative if requested.
*
* <div class="section">Normalization</div>
- * The input ordinates are (<var>λ</var>,<var>φ</var>) (the variable names for <var>longitude</var> and
+ * The input coordinates are (<var>λ</var>,<var>φ</var>) (the variable names for <var>longitude</var> and
* <var>latitude</var> respectively) angles in radians, eventually pre-multiplied by projection-specific factors.
* Input coordinate shall have the <cite>central meridian</cite> removed from the longitude by the caller
* before this method is invoked. After this method is invoked, the caller will need to multiply the output
@@ -687,7 +687,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
* angles in <strong>radians</strong>.
* @param srcOff the offset of the single coordinate to be converted in the source array.
* @param dstPts the array into which the converted coordinate is returned (may be the same than {@code srcPts}).
- * Ordinates will be expressed in a dimensionless unit, as a linear distance on a unit sphere or ellipse.
+ * Coordinates will be expressed in a dimensionless unit, as a linear distance on a unit sphere or ellipse.
* @param dstOff the offset of the location of the converted coordinate that is stored in the destination array.
* @param derivate {@code true} for computing the derivative, or {@code false} if not needed.
* @return the matrix of the projection derivative at the given source position,
@@ -700,7 +700,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
/**
* Inverse converts the single coordinate in {@code srcPts} at the given offset and stores the result in
- * {@code ptDst} at the given offset. The output ordinates are (<var>longitude</var>, <var>latitude</var>)
+ * {@code ptDst} at the given offset. The output coordinates are (<var>longitude</var>, <var>latitude</var>)
* angles in radians, usually (but not necessarily) in the range [-π … π] and [-π/2 … π/2] respectively.
*
* <div class="section">Normalization</div>
@@ -717,7 +717,7 @@ public abstract class NormalizedProjection extends AbstractMathTransform2D imple
* @param srcPts the array containing the source point coordinate, as linear distance on a unit sphere or ellipse.
* @param srcOff the offset of the point to be converted in the source array.
* @param dstPts the array into which the converted point coordinate is returned (may be the same than {@code srcPts}).
- * Ordinates will be (<var>longitude</var>, <var>latitude</var>) angles in <strong>radians</strong>.
+ * Coordinates will be (<var>longitude</var>, <var>latitude</var>) angles in <strong>radians</strong>.
* @param dstOff the offset of the location of the converted point that is stored in the destination array.
* @throws ProjectionException if the point can not be converted.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java
index cc25be2..9f29dc5 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/projection/package-info.java
@@ -89,7 +89,7 @@
* use grads instead of decimal degrees, and often the base geographic coordinate reference system is
* (<var>latitude</var>, <var>longitude</var>) instead of (<var>longitude</var>, <var>latitude</var>).
* This means that the cartographic projected transform is often used as a single step in a series of transforms,
- * where the other steps change units and swap ordinates.
+ * where the other steps change units and swap coordinates.
* </blockquote>
*
* The Apache SIS implementation extends this rule to axis directions as well, i.e. (<var>x</var>, <var>y</var>) coordinates
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
index 9d857db..7099c5e 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform.java
@@ -99,15 +99,15 @@ public abstract class AbstractMathTransform extends FormattableObject
/**
* Maximum amount of {@link TransformException} to catch while transforming a block of
- * {@value #MAXIMUM_BUFFER_SIZE} ordinate values in an array. The default implementation of
+ * {@value #MAXIMUM_BUFFER_SIZE} coordinate values in an array. The default implementation of
* {@code transform} methods set un-transformable coordinates to {@linkplain Double#NaN NaN}
* before to let the exception propagate. However if more then {@value} exceptions occur in
- * a block of {@value #MAXIMUM_BUFFER_SIZE} <em>ordinates</em> (not coordinates), then we
- * will give up. We put a limit in order to avoid slowing down the application too much if
- * a whole array is not transformable.
+ * a block of {@value #MAXIMUM_BUFFER_SIZE} <em>coordinates</em> (not coordinate tuples),
+ * then we will give up. We put a limit in order to avoid slowing down the application
+ * too much if a whole array is not transformable.
*
* <p>Note that in case of failure, the first {@code TransformException} is still propagated;
- * we do not "eat" it. We just set the ordinates to {@code NaN} before to let the propagation
+ * we do not "eat" it. We just set the coordinates to {@code NaN} before to let the propagation
* happen. If no exception handling should be performed at all, then {@code MAXIMUM_FAILURES}
* can be set to 0.</p>
*
@@ -287,19 +287,19 @@ public abstract class AbstractMathTransform extends FormattableObject
} else {
/*
* Destination not set. We are going to create the destination here. Since we know that the
- * destination will be the SIS implementation, write directly into the 'ordinates' array.
+ * destination will be the SIS implementation, write directly into the `coordinates` array.
*/
final GeneralDirectPosition destination = new GeneralDirectPosition(dimTarget);
final double[] source;
if (dimSource <= dimTarget) {
- source = destination.ordinates;
+ source = destination.coordinates;
for (int i=0; i<dimSource; i++) {
source[i] = ptSrc.getOrdinate(i);
}
} else {
source = ptSrc.getCoordinate();
}
- transform(source, 0, destination.ordinates, 0, false);
+ transform(source, 0, destination.coordinates, 0, false);
ptDst = destination;
}
return ptDst;
@@ -313,8 +313,8 @@ public abstract class AbstractMathTransform extends FormattableObject
* {@preformat java
* Matrix derivative = null;
* if (derivate) {
- * double[] ordinates = Arrays.copyOfRange(srcPts, srcOff, srcOff + getSourceDimensions());
- * derivative = this.derivative(new GeneralDirectPosition(ordinates));
+ * double[] coordinates = Arrays.copyOfRange(srcPts, srcOff, srcOff + getSourceDimensions());
+ * derivative = this.derivative(new GeneralDirectPosition(coordinates));
* }
* this.transform(srcPts, srcOff, dstPts, dstOff, 1); // May overwrite srcPts.
* return derivative;
@@ -335,7 +335,7 @@ public abstract class AbstractMathTransform extends FormattableObject
*
* <div class="section">Note for implementors</div>
* The source and destination may overlap. Consequently, implementors must read all source
- * ordinate values before to start writing the transformed ordinates in the destination array.
+ * coordinate values before to start writing the transformed coordinates in the destination array.
*
* @param srcPts the array containing the source coordinate (can not be {@code null}).
* @param srcOff the offset to the point to be transformed in the source array.
@@ -359,7 +359,7 @@ public abstract class AbstractMathTransform extends FormattableObject
* Transforms a list of coordinate points. This method is provided for efficiently transforming many points.
* The supplied array of coordinate values will contain packed coordinate values.
*
- * <div class="note"><b>Example:</b> if the source dimension is 3, then the ordinates will be packed in this order:
+ * <div class="note"><b>Example:</b> if the source dimension is 3, then the coordinates will be packed in this order:
* (<var>x₀</var>,<var>y₀</var>,<var>z₀</var>,
* <var>x₁</var>,<var>y₁</var>,<var>z₁</var> …).
* </div>
@@ -422,11 +422,11 @@ public abstract class AbstractMathTransform extends FormattableObject
}
/*
* Now apply the coordinate transformation, invoking the user-overrideable method
- * for each individual point. In case of failure, we will set the ordinates to NaN
+ * for each individual point. In case of failure, we will set the coordinates to NaN
* and continue with other points, up to some maximal amount of failures.
*/
TransformException failure = null;
- int failureCount = 0; // Count ordinates, not coordinates.
+ int failureCount = 0; // Count coordinates, not coordinate tuples.
int blockStart = 0;
do {
try {
@@ -442,7 +442,7 @@ public abstract class AbstractMathTransform extends FormattableObject
throw failure;
}
/*
- * Otherwise set the ordinate values to NaN and count the number of exceptions,
+ * Otherwise set the coordinate values to NaN and count the number of exceptions,
* so we know when to give up if there is too much of them. The first exception
* will be propagated at the end of this method.
*/
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java
index 0fa954c..320b400 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/AbstractMathTransform1D.java
@@ -102,11 +102,11 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
final double[] dstPts, final int dstOff,
final boolean derivate) throws TransformException
{
- final double ordinate = srcPts[srcOff];
+ final double coordinate = srcPts[srcOff];
if (dstPts != null) {
- dstPts[dstOff] = transform(ordinate);
+ dstPts[dstOff] = transform(coordinate);
}
- return derivate ? new Matrix1(derivative(ordinate)) : null;
+ return derivate ? new Matrix1(derivative(coordinate)) : null;
}
/**
@@ -131,14 +131,14 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
*/
@Override
public Matrix derivative(final DirectPosition point) throws TransformException {
- final double ordinate;
+ final double coordinate;
if (point == null) {
- ordinate = Double.NaN;
+ coordinate = Double.NaN;
} else {
ensureDimensionMatches("point", 1, point);
- ordinate = point.getOrdinate(0);
+ coordinate = point.getOrdinate(0);
}
- return new Matrix1(derivative(ordinate));
+ return new Matrix1(derivative(coordinate));
}
/**
@@ -193,11 +193,11 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
final double[] dstPts, final int dstOff,
final boolean derivate) throws TransformException
{
- final double ordinate = srcPts[srcOff];
+ final double coordinate = srcPts[srcOff];
if (dstPts != null) {
- dstPts[dstOff] = transform(ordinate);
+ dstPts[dstOff] = transform(coordinate);
}
- return derivate ? new Matrix1(derivative(ordinate)) : null;
+ return derivate ? new Matrix1(derivative(coordinate)) : null;
}
/**
@@ -211,14 +211,14 @@ public abstract class AbstractMathTransform1D extends AbstractMathTransform impl
*/
@Override
public Matrix derivative(final DirectPosition point) throws TransformException {
- final double ordinate;
+ final double coordinate;
if (point == null) {
- ordinate = Double.NaN;
+ coordinate = Double.NaN;
} else {
ensureDimensionMatches("point", 1, point);
- ordinate = point.getOrdinate(0);
+ coordinate = point.getOrdinate(0);
}
- return new Matrix1(derivative(ordinate));
+ return new Matrix1(derivative(coordinate));
}
}
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java
index 99e9d3c..b417614 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ContextualParameters.java
@@ -430,7 +430,7 @@ public class ContextualParameters extends Parameters implements Serializable {
}
/**
- * Prepends a normalization step converting input ordinates in the two first dimensions from degrees to radians.
+ * Prepends a normalization step converting input coordinates in the two first dimensions from degrees to radians.
* The normalization can optionally subtract the given λ₀ value (in degrees) from the longitude.
*
* <p>Invoking this method is equivalent to {@linkplain java.awt.geom.AffineTransform#concatenate concatenating}
@@ -463,7 +463,7 @@ public class ContextualParameters extends Parameters implements Serializable {
}
/**
- * Appends a denormalization step after the non-linear kernel, which will convert input ordinates
+ * Appends a denormalization step after the non-linear kernel, which will convert input coordinates
* in the two first dimensions from radians to degrees. After this conversion, the denormalization
* can optionally add the given λ₀ value (in degrees) to the longitude.
*
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java
index 4a65c3b..edf2ee7 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/CopyTransform.java
@@ -25,12 +25,12 @@ import org.apache.sis.referencing.operation.matrix.Matrices;
/**
- * A transform which copy the ordinates in the source array to different locations in the target array.
+ * A transform which copy the coordinates in the source array to different locations in the target array.
* This is a special case of {@link ProjectiveTransform} where the matrix coefficients are zero everywhere,
* except one value by row which is set to 1 and is not the translation term. Those transforms are used for
* swapping axis order, or selecting the dimension to retain when converting from a large dimension to a smaller one.
* This transform has the particularity to involve no floating point operation - just copy of values with no change -
- * and consequently works well with NaN ordinate values.
+ * and consequently works well with NaN coordinate values.
*
* <p>We do not provide a subclass for the 2D case because our policy is to use
* an {@link java.awt.geom.AffineTransform} for every 2D affine conversions.</p>
@@ -53,7 +53,7 @@ final class CopyTransform extends AbstractLinearTransform {
private final int srcDim;
/**
- * The indices of ordinates to copy in the source array.
+ * The indices of coordinates to copy in the source array.
* The length of this array is the target dimension.
*/
private final int[] indices;
@@ -63,7 +63,7 @@ final class CopyTransform extends AbstractLinearTransform {
*
* @param srcDim the dimension of source coordinates.
* Must be greater than the highest value in {@code indices}.
- * @param indices the indices of ordinates to copy in the source array.
+ * @param indices the indices of coordinates to copy in the source array.
* The length of this array is the target dimension.
*/
CopyTransform(final int srcDim, final int[] indices) {
@@ -103,7 +103,7 @@ final class CopyTransform extends AbstractLinearTransform {
}
}
if (!found) {
- // Target ordinate unconditionally set to 0 (not a copy).
+ // Target coordinate unconditionally set to 0 (not a copy).
return null;
}
}
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
index 5bdb172..f5337df 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/DefaultMathTransformFactory.java
@@ -966,7 +966,7 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
* the source or target CRS, if those parameters are not explicitly given and if they are relevant
* for the coordinate operation method.</li>
* <li>{@linkplain #createConcatenatedTransform Concatenating} the parameterized transform
- * with any other transforms required for performing units changes and ordinates swapping.</li>
+ * with any other transforms required for performing units changes and coordinates swapping.</li>
* </ol>
*
* The complete group of parameters, including {@code "semi_major"}, {@code "semi_minor"} or other calculated values,
@@ -1078,7 +1078,7 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
* Given a transform between normalized spaces,
* creates a transform taking in account axis directions, units of measurement and longitude rotation.
* This method {@linkplain #createConcatenatedTransform concatenates} the given parameterized transform
- * with any other transform required for performing units changes and ordinates swapping.
+ * with any other transform required for performing units changes and coordinates swapping.
*
* <p>The given {@code parameterized} transform shall expect
* {@linkplain org.apache.sis.referencing.cs.AxesConvention#NORMALIZED normalized} input coordinates and
@@ -1263,7 +1263,7 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
* Creates an affine transform from a matrix. If the transform input dimension is {@code M},
* and output dimension is {@code N}, then the matrix will have size {@code [N+1][M+1]}. The
* +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation. The
- * {@code [M][j]} element of the matrix will be the j'th ordinate of the moved origin. The
+ * {@code [M][j]} element of the matrix will be the j'th coordinate of the moved origin. The
* {@code [i][N]} element of the matrix will be 0 for <var>i</var> less than {@code M}, and 1
* for <var>i</var> equals {@code M}.
*
@@ -1316,8 +1316,8 @@ public class DefaultMathTransformFactory extends AbstractFactory implements Math
}
/**
- * Creates a transform which passes through a subset of ordinates to another transform.
- * This allows transforms to operate on a subset of ordinates.
+ * Creates a transform which passes through a subset of coordinates to another transform.
+ * This allows transforms to operate on a subset of coordinates.
*
* <div class="note"><b>Example:</b>
* Giving (<var>latitude</var>, <var>longitude</var>, <var>height</var>) coordinates,
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java
index 170bc57..0b3d4fe 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedGeocentricTransform.java
@@ -166,7 +166,7 @@ public class InterpolatedGeocentricTransform extends DatumShiftTransform {
/**
* Creates a transform from the specified parameters.
- * This {@code InterpolatedGeocentricTransform} class expects ordinate values in the following order and units:
+ * This {@code InterpolatedGeocentricTransform} class expects coordinate values in the following order and units:
* <ol>
* <li>longitudes in <strong>radians</strong> relative to the prime meridian (usually Greenwich),</li>
* <li>latitudes in <strong>radians</strong>,</li>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java
index d731805..8ef89da 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/InterpolatedMolodenskyTransform.java
@@ -110,7 +110,7 @@ public class InterpolatedMolodenskyTransform extends MolodenskyFormula {
/**
* Creates a transform from the specified parameters.
- * This {@code InterpolatedMolodenskyTransform} class expects ordinate values in the following order and units:
+ * This {@code InterpolatedMolodenskyTransform} class expects coordinate values in the following order and units:
* <ol>
* <li>longitudes in <strong>radians</strong> relative to the prime meridian (usually Greenwich),</li>
* <li>latitudes in <strong>radians</strong>,</li>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java
index 586a1b4..31768c0 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/IterationStrategy.java
@@ -96,7 +96,7 @@ public enum IterationStrategy {
/**
* Copy the points to transform in a temporary array before to apply the transform.
- * The temporary array will be used for fetching the source ordinates.
+ * The temporary array will be used for fetching the source coordinates.
*
* <p>This algorithm can be used as a fallback for any unknown enumeration.</p>
*/
@@ -132,7 +132,7 @@ public enum IterationStrategy {
*
* <ul>
* <li>Source and target array are the same.</li>
- * <li>For each coordinate to be transformed, all ordinate values are read before the
+ * <li>For each coordinate to be transformed, all coordinate values are read before the
* transformation process starts. For example if a transform goes from geographic
* to projected CRS, the (<var>longitude</var>, <var>latitude</var>, <var>height</var>)
* tuple must be completely read before to start writing the
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java
index dc40bad..deb3c93 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/LinearTransform.java
@@ -88,7 +88,7 @@ public interface LinearTransform extends MathTransform {
/**
* Returns the coefficients of this linear transform as a matrix.
* Converting a coordinate with this {@code MathTransform} is equivalent to multiplying the
- * returned matrix by a vector containing the ordinate values with an additional 1 in the last row.
+ * returned matrix by a vector containing the coordinate values with an additional 1 in the last row.
* See {@link LinearTransform} class Javadoc for more details.
*
* @return the coefficients of this linear transform as a matrix.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java
index 8d3d046..04895bf 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MathTransforms.java
@@ -179,7 +179,7 @@ public final class MathTransforms extends Static {
* <p>If the transform input dimension is {@code M}, and output dimension is {@code N},
* then the given matrix shall have size {@code [N+1][M+1]}.
* The +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation.
- * The {@code [M][j]} element of the matrix will be the <var>j</var>'th ordinate of the moved origin.</p>
+ * The {@code [M][j]} element of the matrix will be the <var>j</var>'th coordinate of the moved origin.</p>
*
* @param matrix the matrix used to define the linear transform.
* @return the linear (usually affine) transform.
@@ -361,7 +361,7 @@ public final class MathTransforms extends Static {
}
/**
- * Puts together a list of independent math transforms, each of them operating on a subset of ordinate values.
+ * Puts together a list of independent math transforms, each of them operating on a subset of coordinate values.
* This method is often used for defining 4-dimensional (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>)
* transform as an aggregation of 3 simpler transforms operating on (<var>x</var>,<var>y</var>), (<var>z</var>)
* and (<var>t</var>) values respectively.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
index bb7a1a5..657cfa5 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/MolodenskyTransform.java
@@ -53,7 +53,7 @@ import static java.lang.Math.*;
* height (typically non-zero even if the input height was zero) is lost.</li>
* </ul>
*
- * The transform expect ordinate values if the following order:
+ * The transform expect coordinate values if the following order:
* <ol>
* <li>longitudes (λ) relative to the prime meridian (usually Greenwich),</li>
* <li>latitudes (φ),</li>
@@ -110,7 +110,7 @@ public class MolodenskyTransform extends MolodenskyFormula {
/**
* Creates a Molodensky transform from the specified parameters.
- * This {@code MolodenskyTransform} class expects ordinate values in the following order and units:
+ * This {@code MolodenskyTransform} class expects coordinate values in the following order and units:
* <ol>
* <li>longitudes in <strong>radians</strong> relative to the prime meridian (usually Greenwich),</li>
* <li>latitudes in <strong>radians</strong>,</li>
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
index d5f812d..c123458 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/PassThroughTransform.java
@@ -513,7 +513,7 @@ public class PassThroughTransform extends AbstractMathTransform implements Seria
ensureDimensionMatches("point", transDim + nSkipped, point);
final GeneralDirectPosition subPoint = new GeneralDirectPosition(transDim);
for (int i=0; i<transDim; i++) {
- subPoint.ordinates[i] = point.getOrdinate(i + firstAffectedCoordinate);
+ subPoint.coordinates[i] = point.getOrdinate(i + firstAffectedCoordinate);
}
return expand(MatrixSIS.castOrCopy(subTransform.derivative(subPoint)),
firstAffectedCoordinate, numTrailingCoordinates, 0);
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java
index fe6fec3..a4efca3 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ProjectiveTransform.java
@@ -238,7 +238,7 @@ class ProjectiveTransform extends AbstractLinearTransform implements ExtendedPre
@Override
public final void transform(double[] srcPts, int srcOff, final double[] dstPts, int dstOff, int numPts) {
final int srcDim, dstDim;
- int srcInc = srcDim = numCol - 1; // The last ordinate will be assumed equal to 1.
+ int srcInc = srcDim = numCol - 1; // The last coordinate will be assumed equal to 1.
int dstInc = dstDim = numRow - 1;
if (srcPts == dstPts) {
switch (IterationStrategy.suggest(srcOff, srcDim, dstOff, dstDim, numPts)) {
@@ -269,7 +269,7 @@ class ProjectiveTransform extends AbstractLinearTransform implements ExtendedPre
if (e != 0) {
/*
* The purpose of the test for non-zero value is not performance (it is actually more likely
- * to slow down the calculation), but to get a valid sum even if some source ordinates are NaN.
+ * to slow down the calculation), but to get a valid sum even if some source coordinates are NaN.
* This occurs when the ProjectiveTransform is used for excluding some dimensions, for example
* getting 2D points from 3D points. In such case, the fact that the excluded dimensions had
* NaN values should not force the retained dimensions to get NaN values.
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java
index fc9bb4d..6a98aad 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/ScaleTransform.java
@@ -27,7 +27,7 @@ import org.apache.sis.util.ArraysExt;
/**
- * An affine transform that multiply the ordinate values by constant values, and optionally drop the last ordinates.
+ * An affine transform that multiply the coordinate values by constant values, and optionally drop the last coordinates.
* This is an optimization of {@link ProjectiveTransform} for a common case.
*
* <div class="note"><b>Note:</b> we do not provide two-dimensional specialization because
@@ -48,7 +48,7 @@ final class ScaleTransform extends AbstractLinearTransform implements ExtendedPr
private static final long serialVersionUID = 8527439133082104085L;
/**
- * Multiplication factors, to be applied in the same order than ordinate values.
+ * Multiplication factors, to be applied in the same order than coordinate values.
* The length of this array is the number of target dimensions.
*/
private final double[] factors;
@@ -60,7 +60,7 @@ final class ScaleTransform extends AbstractLinearTransform implements ExtendedPr
private final double[] errors;
/**
- * Number of ordinate values to drop after the values that we multiplied.
+ * Number of coordinate values to drop after the values that we multiplied.
* Values to drop happen for example in Geographic 3D to 2D conversions.
*/
private final int numDroppedDimensions;
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java
index 8ea54b0..2071d61 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/transform/TranslationTransform.java
@@ -26,7 +26,7 @@ import org.apache.sis.util.ArraysExt;
/**
- * An affine transform that translate the ordinate values by constant values.
+ * An affine transform that translate the coordinate values by constant values.
*
* <div class="note"><b>Note:</b> we do not provide two-dimensional specialization because
* {@link org.apache.sis.internal.referencing.j2d.AffineTransform2D} should be used in such case.</div>
@@ -46,7 +46,7 @@ final class TranslationTransform extends AbstractLinearTransform implements Exte
private static final long serialVersionUID = 7382503993222285134L;
/**
- * Translation terms, to be applied in the same order than ordinate values.
+ * Translation terms, to be applied in the same order than coordinate values.
* The length of this array is the number of target dimensions.
*/
private final double[] offsets;
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
index e7487aa..b6a7700 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
@@ -107,13 +107,13 @@ public final strictfp class AbstractEnvelopeTest extends TestCase {
switch (type) {
case SUBENVELOPE: {
// Asserts that other dimensions in the original envelope has not been modified.
- final double[] ordinates = ((SubEnvelope) envelope).ordinates;
- assertEquals(2, ordinates[0], STRICT);
- assertEquals(3, ordinates[5], STRICT);
- assertEquals(4, ordinates[3], STRICT);
- assertEquals(6, ordinates[8], STRICT);
- assertEquals(8, ordinates[4], STRICT);
- assertEquals(9, ordinates[9], STRICT);
+ final double[] coordinates = ((SubEnvelope) envelope).coordinates;
+ assertEquals(2, coordinates[0], STRICT);
+ assertEquals(3, coordinates[5], STRICT);
+ assertEquals(4, coordinates[3], STRICT);
+ assertEquals(6, coordinates[8], STRICT);
+ assertEquals(8, coordinates[4], STRICT);
+ assertEquals(9, coordinates[9], STRICT);
break;
}
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java
index ce2a886..4f77c3e 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/ArrayEnvelopeTest.java
@@ -42,7 +42,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
public void testIsEmpty() {
ArrayEnvelope envelope = new ArrayEnvelope(new double[] {0, -356.683168});
assertTrue(envelope.isEmpty());
- envelope.ordinates[0] = -360;
+ envelope.coordinates[0] = -360;
assertFalse(envelope.isEmpty());
}
@@ -52,14 +52,14 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
@Test
public void testGetExtremums() {
ArrayEnvelope envelope = new ArrayEnvelope(2);
- envelope.ordinates[2] = -1728;
+ envelope.coordinates[2] = -1728;
assertTrue(Double.isNaN(envelope.getMinimum(0)));
assertTrue(Double.isNaN(envelope.getMaximum(0)));
assertEquals(0, envelope.getMinimum(1), STRICT);
assertEquals(0, envelope.getMaximum(1), STRICT);
// Make the range valid and test again.
- envelope.ordinates[0] = -1800;
+ envelope.coordinates[0] = -1800;
assertEquals(-1800, envelope.getMinimum(0), STRICT);
assertEquals(-1728, envelope.getMaximum(0), STRICT);
}
@@ -91,7 +91,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
assertArrayEquals(new double[] {
-5610.14928, -3642.5148, 1957.4432, -170.0175, -77.9698, Double.NEGATIVE_INFINITY,
-5610.14920, -3642.5140, 1957.4440, -170.0170, -77.9690, Double.NEGATIVE_INFINITY
- }, envelope.ordinates, STRICT);
+ }, envelope.coordinates, STRICT);
}
/**
@@ -99,7 +99,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
*/
@Test(expected = IllegalArgumentException.class)
public void testCreatesFromInvalidWKT() {
- assertNotNull(new ArrayEnvelope("BBOX[\"invalid\"]").ordinates);
+ assertNotNull(new ArrayEnvelope("BBOX[\"invalid\"]").coordinates);
}
/**
@@ -125,7 +125,7 @@ public final strictfp class ArrayEnvelopeTest extends TestCase {
assertTrue (env1.equals(env1));
assertTrue (env2.equals(env2));
- env2.ordinates[0] = 1;
+ env2.coordinates[0] = 1;
assertTrue(env1.equals(env2));
assertTrue(env2.equals(env1));
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java
index 7a30075..28ae885 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/CoordinateFormatTest.java
@@ -50,7 +50,7 @@ import static org.junit.Assert.*;
public final strictfp class CoordinateFormatTest extends TestCase {
/**
* Tests formatting a coordinate in unknown CRS.
- * The ordinate values are expected to be formatted as ordinary numbers.
+ * The coordinate values are expected to be formatted as ordinary numbers.
*/
@Test
public void testFormatUnknownCRS() {
@@ -73,7 +73,7 @@ public final strictfp class CoordinateFormatTest extends TestCase {
/**
* Tests parsing a coordinate in unknown CRS.
- * The ordinate values are formatted as ordinary numbers.
+ * The coordinate values are formatted as ordinary numbers.
*
* @throws ParseException if the parsing failed.
*/
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java
index cb00f38..a77d93b 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition1DTest.java
@@ -83,8 +83,8 @@ public final strictfp class DirectPosition1DTest extends TestCase {
public void testClone() {
final DirectPosition1D p1 = new DirectPosition1D(20);
final DirectPosition1D p2 = p1.clone();
- assertEquals("Expected the same CRS and ordinates.", p1, p2);
- assertEquals("Expected the same ordinates.", 20.0, p2.ordinate, 0.0);
+ assertEquals("Expected the same CRS and coordinates.", p1, p2);
+ assertEquals("Expected the same coordinates.", 20.0, p2.coordinate, 0.0);
validate(p2);
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java
index d387171..b1faab8 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/DirectPosition2DTest.java
@@ -83,9 +83,9 @@ public final strictfp class DirectPosition2DTest extends TestCase {
public void testClone() {
final DirectPosition2D p1 = new DirectPosition2D(10, 30);
final DirectPosition2D p2 = p1.clone();
- assertEquals("Expected the same CRS and ordinates.", p1, p2);
- assertEquals("Expected the same ordinates.", 10.0, p2.x, 0.0);
- assertEquals("Expected the same ordinates.", 30.0, p2.y, 0.0);
+ assertEquals("Expected the same CRS and coordinates.", p1, p2);
+ assertEquals("Expected the same coordinates.", 10.0, p2.x, 0.0);
+ assertEquals("Expected the same coordinates.", 30.0, p2.y, 0.0);
validate(p2);
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java
index a58cd29..e0bf6b5 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/EnvelopesTest.java
@@ -146,7 +146,7 @@ public final strictfp class EnvelopesTest extends TransformTestCase<GeneralEnvel
/**
* Tests the transformation of an envelope from a 4D CRS to a 2D CRS
- * where the ordinates in one dimension are NaN.
+ * where the coordinates in one dimension are NaN.
*
* @throws TransformException if an error occurred while transforming the envelope.
*
@@ -170,7 +170,7 @@ public final strictfp class EnvelopesTest extends TransformTestCase<GeneralEnvel
assertTrue ("isEmpty", env.isEmpty()); // Opportunist test (not really the topic of this method).
/*
* If the referencing framework has selected the CopyTransform implementation
- * as expected, then the envelope ordinates should not be NaN.
+ * as expected, then the envelope coordinates should not be NaN.
*/
final Envelope env2D = Envelopes.transform(env, targetCRS);
assertEquals(-170, env2D.getMinimum(0), 0);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java
index 91bdf4b..3f73317 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralDirectPositionTest.java
@@ -91,9 +91,9 @@ public final strictfp class GeneralDirectPositionTest extends TestCase {
public void testClone() {
final GeneralDirectPosition p1 = new GeneralDirectPosition(10, 20, 30);
final GeneralDirectPosition p2 = p1.clone();
- assertEquals ("Expected the same CRS and ordinates.", p1, p2);
- assertTrue ("Expected the same ordinates.", Arrays.equals(p1.ordinates, p2.ordinates));
- assertNotSame("the ordinates array should have been cloned.", p1.ordinates, p2.ordinates);
+ assertEquals ("Expected the same CRS and coordinates.", p1, p2);
+ assertTrue ("Expected the same coordinates.", Arrays.equals(p1.coordinates, p2.coordinates));
+ assertNotSame("The coordinates array should have been cloned.", p1.coordinates, p2.coordinates);
validate(p2);
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java
index ab42d3e..43b86db 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/GeneralEnvelopeTest.java
@@ -58,7 +58,7 @@ public strictfp class GeneralEnvelopeTest extends TestCase {
boolean skipValidation;
/**
- * Creates a new geographic envelope for the given ordinate values.
+ * Creates a new geographic envelope for the given coordinate values.
* This method is overridden by {@link SubEnvelopeTest}.
*/
GeneralEnvelope create(final double xmin, final double ymin, final double xmax, final double ymax) {
@@ -81,17 +81,17 @@ public strictfp class GeneralEnvelopeTest extends TestCase {
/**
* Asserts that the given two-dimensional envelope is equals to the given rectangle.
- * The {@code xLower} and {@code xUpper} arguments are the <var>x</var> ordinate values
+ * The {@code xLower} and {@code xUpper} arguments are the <var>x</var> coordinate values
* for the lower and upper corners respectively. The actual {@code xmin} and {@code ymin}
* values will be inferred from those corners.
*
* <p>This method assumes that only the <var>x</var> axis may be a wraparound axis.</p>
*
* @param test the actual envelope to verify.
- * @param xLower the expected first <var>x</var> ordinate value. May be greater than {@code xUpper}.
- * @param xUpper the expected last <var>x</var> ordinate value. May be less than {@code xLower}.
- * @param ymin the expected minimal <var>y</var> ordinate value. Must be less than {@code ymax}.
- * @param ymax the expected maximal <var>y</var> ordinate value. Must be greater than {@code ymax}.
+ * @param xLower the expected first <var>x</var> coordinate value. May be greater than {@code xUpper}.
+ * @param xUpper the expected last <var>x</var> coordinate value. May be less than {@code xLower}.
+ * @param ymin the expected minimal <var>y</var> coordinate value. Must be less than {@code ymax}.
+ * @param ymax the expected maximal <var>y</var> coordinate value. Must be greater than {@code ymax}.
*/
private static void assertEnvelopeEquals(final Envelope test,
final double xLower, final double ymin, final double xUpper, final double ymax)
@@ -736,7 +736,7 @@ public strictfp class GeneralEnvelopeTest extends TestCase {
assertNotSame("Expected a new instance.", e1, e2);
assertEquals ("The two instances should be equal.", e1, e2);
e1.setRange(0, -40, +61);
- assertFalse("Ordinates array should have been cloned.", e1.equals(e2));
+ assertFalse("Coordinates array should have been cloned.", e1.equals(e2));
e2.setRange(0, -40, +61);
assertEquals(e1, e2);
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java b/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java
index 18f8bc7..d32f09b 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/geometry/SubEnvelopeTest.java
@@ -38,7 +38,7 @@ import static org.apache.sis.geometry.AbstractEnvelopeTest.WGS84;
@DependsOn(GeneralEnvelopeTest.class)
public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
/**
- * Creates a new sub-envelope envelope for the given ordinate values.
+ * Creates a new sub-envelope envelope for the given coordinate values.
*/
@Override
GeneralEnvelope create(final double xmin, final double ymin, final double xmax, final double ymax) {
@@ -62,13 +62,13 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
@Override
void verifyInvariants(final GeneralEnvelope envelope) {
super.verifyInvariants(envelope);
- final double[] ordinates = envelope.ordinates;
- assertEquals(1, ordinates[0], STRICT);
- assertEquals(4, ordinates[1], STRICT);
- assertEquals(5, ordinates[4], STRICT);
- assertEquals(2, ordinates[5], STRICT);
- assertEquals(7, ordinates[6], STRICT);
- assertEquals(9, ordinates[9], STRICT);
+ final double[] coordinates = envelope.coordinates;
+ assertEquals(1, coordinates[0], STRICT);
+ assertEquals(4, coordinates[1], STRICT);
+ assertEquals(5, coordinates[4], STRICT);
+ assertEquals(2, coordinates[5], STRICT);
+ assertEquals(7, coordinates[6], STRICT);
+ assertEquals(9, coordinates[9], STRICT);
}
/**
@@ -85,7 +85,7 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
public void testSetToNaN() {
final GeneralEnvelope e = create(-40, -20, +60, +30);
e.setToNaN();
- assertArrayEquals(new double[] {1, 4, NaN, NaN, 5, 2, 7, NaN, NaN, 9}, e.ordinates, STRICT);
+ assertArrayEquals(new double[] {1, 4, NaN, NaN, 5, 2, 7, NaN, NaN, 9}, e.coordinates, STRICT);
validate(e);
}
@@ -98,11 +98,11 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
final GeneralEnvelope e1 = create(-40, -20, +60, +30);
final GeneralEnvelope e2 = create(-40, -20, +60, +30);
assertEquals(e1, e2);
- e2.ordinates[0] = -1;
- e2.ordinates[1] = -4;
- e2.ordinates[9] = -9;
+ e2.coordinates[0] = -1;
+ e2.coordinates[1] = -4;
+ e2.coordinates[9] = -9;
assertEquals(e1, e2);
- e2.ordinates[2] = -41;
+ e2.coordinates[2] = -41;
assertFalse(e1.equals(e2));
}
@@ -114,8 +114,8 @@ public final strictfp class SubEnvelopeTest extends GeneralEnvelopeTest {
public void testClone() {
final GeneralEnvelope e1 = create(-40, -20, +60, +30);
final GeneralEnvelope e2 = e1.clone();
- assertArrayEquals(new double[] {1, 4, -40, -20, 5, 2, 7, +60, +30, 9}, e1.ordinates, STRICT);
- assertArrayEquals(new double[] { -40, -20, +60, +30 }, e2.ordinates, STRICT);
+ assertArrayEquals(new double[] {1, 4, -40, -20, 5, 2, 7, +60, +30, 9}, e1.coordinates, STRICT);
+ assertArrayEquals(new double[] { -40, -20, +60, +30 }, e2.coordinates, STRICT);
validate(e2);
}
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java b/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java
index 4c9e57f..5f8e509 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/provider/GeographicOffsetsTest.java
@@ -128,7 +128,7 @@ public final strictfp class GeographicOffsetsTest extends TransformTestCase {
/*
* Now create the MathTransform. But at the difference of the above testVerticalOffset() method,
* we supply information about axis directions. The operation parameter shall have the same sign
- * than in the EPSG database (which is positive), and the source and target ordinates shall have
+ * than in the EPSG database (which is positive), and the source and target coordinates shall have
* the same sign than in the EPSG example (positive too). However we do not test unit conversion
* in this method (EPSG sample point uses feet units), only axis direction.
*/
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java
index 7f43445..0e82a40 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/cs/HardCodedAxes.java
@@ -39,7 +39,7 @@ import org.apache.sis.measure.Units;
public final strictfp class HardCodedAxes {
/**
* Axis for geodetic longitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#EAST East}
+ * Increasing coordinate values go {@linkplain AxisDirection#EAST East}
* and units are {@linkplain Units#DEGREE degrees}.
* The ISO 19111 name is <cite>"geodetic longitude"</cite> and the abbreviation is "λ" (lambda).
*
@@ -55,7 +55,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for geodetic latitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#NORTH North}
+ * Increasing coordinate values go {@linkplain AxisDirection#NORTH North}
* and units are {@linkplain Units#DEGREE degrees}.
* The ISO 19111 name is <cite>"geodetic latitude"</cite> and the abbreviation is "φ" (phi).
*
@@ -78,7 +78,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for longitudes in grad units.
* The axis name is {@code "Longitude"} (the {@code "Geodetic"} prefix is omitted for testing purpose).
- * Increasing ordinates values go {@linkplain AxisDirection#EAST East} and units are {@link Units#GRAD}.
+ * Increasing coordinate values go {@linkplain AxisDirection#EAST East} and units are {@link Units#GRAD}.
* The abbreviation is "λ" (lambda). The unit symbol is "gon".
*
* @see #GEODETIC_LONGITUDE
@@ -90,7 +90,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for latitudes in grad units.
* The axis name is {@code "Latitude"} (the {@code "Geodetic"} prefix is omitted for testing purpose).
- * Increasing ordinates values go {@linkplain AxisDirection#NORTH North} and units are {@link Units#GRAD}.
+ * Increasing coordinate values go {@linkplain AxisDirection#NORTH North} and units are {@link Units#GRAD}.
* The abbreviation is "φ" (phi). The unit symbol is "gon".
*
* @see #GEODETIC_LATITUDE
@@ -102,7 +102,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for height values above the ellipsoid in a
* {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"ellipsoidal height"</cite> and the abbreviation is lower case <cite>"h"</cite>.
*
* <p>This axis is usually part of a {@link #GEODETIC_LONGITUDE}, {@link #GEODETIC_LATITUDE},
@@ -120,7 +120,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for height values above the ellipsoid in a
* {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#CENTIMETRE centimetres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#CENTIMETRE centimetres}.
*
* @since 0.7
*/
@@ -129,7 +129,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for height values measured from gravity.
- * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"gravity-related height"</cite> and the abbreviation is upper case <cite>"H"</cite>.
*
* @see #ALTITUDE
@@ -148,7 +148,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for altitude values.
- * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
* The abbreviation is lower case <cite>"h"</cite>.
*
* <p>This axis is usually part of a {@link #GEODETIC_LONGITUDE}, {@link #GEODETIC_LATITUDE},
@@ -164,7 +164,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for depth.
- * Increasing ordinates values go {@linkplain AxisDirection#DOWN down} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#DOWN down} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"depth"</cite>.
*
* @see #ALTITUDE
@@ -178,7 +178,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for radius in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
* using {@linkplain org.apache.sis.referencing.cs.DefaultSphericalCS spherical CS}.
- * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"geocentric radius"</cite> and the abbreviation is lower-case <cite>"r"</cite>.
*
* <div class="note"><b>Note:</b>
@@ -202,7 +202,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for longitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
* using {@linkplain org.apache.sis.referencing.cs.DefaultSphericalCS spherical CS}.
- * Increasing ordinates values go {@linkplain AxisDirection#EAST East}
+ * Increasing coordinate values go {@linkplain AxisDirection#EAST East}
* and units are {@linkplain Units#DEGREE degrees}.
* The ISO 19111 name is <cite>"spherical longitude"</cite> (also called <cite>"azimuthal angle"</cite>)
* and the abbreviation is "θ" (theta).
@@ -226,7 +226,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for latitudes in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
* using {@linkplain org.apache.sis.referencing.cs.DefaultSphericalCS spherical CS}.
- * Increasing ordinates values go {@linkplain AxisDirection#NORTH North}
+ * Increasing coordinate values go {@linkplain AxisDirection#NORTH North}
* and units are {@linkplain Units#DEGREE degrees}.
* The ISO 19111 name is <cite>"spherical latitude"</cite> (also called <cite>"polar (zenith) angle"</cite>)
* and the abbreviation is "Ω".
@@ -248,7 +248,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for <var>x</var> values in a {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
- * Increasing ordinates values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
* The abbreviation is lower case <cite>"x"</cite>.
*
* <p>This axis is usually part of a {@link #X}, {@link #Y}, {@link #Z} set.</p>
@@ -264,7 +264,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for <var>y</var> values in a {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
- * Increasing ordinates values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
* The abbreviation is lower case <cite>"y"</cite>.
*
* <p>This axis is usually part of a {@link #X}, {@link #Y}, {@link #Z} set.</p>
@@ -280,7 +280,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for <var>z</var> values in a {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
- * Increasing ordinates values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#UP up} and units are {@linkplain Units#METRE metres}.
* The abbreviation is lower case <cite>"z"</cite>.
*
* <p>This axis is usually part of a {@link #X}, {@link #Y}, {@link #Z} set.</p>
@@ -291,7 +291,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for <var>x</var> values in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
* using {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
- * Increasing ordinates values goes typically toward prime meridian, but the actual axis direction
+ * Increasing coordinate values goes typically toward prime meridian, but the actual axis direction
* is {@link AxisDirection#GEOCENTRIC_X GEOCENTRIC_X}. The units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"Geocentric X"</cite> and the abbreviation is upper case <cite>"X"</cite>.
*
@@ -306,7 +306,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for <var>y</var> values in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
* using {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
- * Increasing ordinates values goes typically toward East, but the actual axis direction is
+ * Increasing coordinate values goes typically toward East, but the actual axis direction is
* {@link AxisDirection#GEOCENTRIC_Y GEOCENTRIC_Y}. The units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"Geocentric Y"</cite> and the abbreviation is upper case <cite>"Y"</cite>.
*
@@ -321,7 +321,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for <var>z</var> values in a {@linkplain org.apache.sis.referencing.crs.DefaultGeocentricCRS geocentric CRS}
* using {@linkplain org.apache.sis.referencing.cs.DefaultCartesianCS Cartesian CS}.
- * Increasing ordinates values goes typically toward North, but the actual axis direction is
+ * Increasing coordinate values goes typically toward North, but the actual axis direction is
* {@link AxisDirection#GEOCENTRIC_Z GEOCENTRIC_Z}. The units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"Geocentric Z"</cite> and the abbreviation is upper case <cite>"Z"</cite>.
*
@@ -335,7 +335,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for Easting values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#EAST East} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"easting"</cite> and the abbreviation is upper case <cite>"E"</cite>.
*
* <p>This axis is usually part of a {@link #EASTING}, {@link #NORTHING} set.</p>
@@ -349,7 +349,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for Westing values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#WEST West} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#WEST West} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"westing"</cite> and the abbreviation is upper case <cite>"W"</cite>.
*
* @see #X
@@ -361,7 +361,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for Northing values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#NORTH North} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"northing"</cite> and the abbreviation is upper case <cite>"N"</cite>.
*
* <p>This axis is usually part of a {@link #EASTING}, {@link #NORTHING} set.</p>
@@ -375,7 +375,7 @@ public final strictfp class HardCodedAxes {
/**
* Axis for Southing values in a {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS projected CRS}.
- * Increasing ordinates values go {@linkplain AxisDirection#SOUTH South} and units are {@linkplain Units#METRE metres}.
+ * Increasing coordinate values go {@linkplain AxisDirection#SOUTH South} and units are {@linkplain Units#METRE metres}.
* The ISO 19111 name is <cite>"southing"</cite> and the abbreviation is upper case <cite>"S"</cite>.
*
* @see #Y
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java
index 2da281d..995476d 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/datum/TimeDependentBWPTest.java
@@ -114,7 +114,7 @@ public final strictfp class TimeDependentBWPTest extends TestCase {
compareWithExplicitCalculation(actual);
/*
* Now compare with the expected value given in the EPSG example. The 0.013 tolerance threshold
- * is for the X ordinate and has been determined empirically in testEpsgCalculation().
+ * is for the X coordinate and has been determined empirically in testEpsgCalculation().
*/
assertMatrixEquals("toGDA94", target, actual, 0.013);
assertMatrixEquals("toITRF2008", source, toITRF2008.multiply(target), 0.013);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java
index c928371..b381f62 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationFinderTest.java
@@ -691,7 +691,7 @@ public final strictfp class CoordinateOperationFinderTest extends MathTransformT
/**
* Tests the conversion from a two-dimensional geographic CRS to a three-dimensional geographic CRS.
- * Ordinate values of the vertical dimension should be set to zero.
+ * Coordinate values of the vertical dimension should be set to zero.
*
* @throws FactoryException if the operation can not be created.
* @throws TransformException if an error occurred while converting the test points.
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java
index f3d2fd9..c011acf 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/HardCodedConversions.java
@@ -55,7 +55,7 @@ public final strictfp class HardCodedConversions {
/**
* A two-dimensional Mercator projection using the WGS84 datum.
- * This CRS uses (<var>easting</var>, <var>northing</var>) ordinates in metres.
+ * This CRS uses (<var>easting</var>, <var>northing</var>) coordinates in metres.
* The base CRS uses (<var>longitude</var>, <var>latitude</var>) axes
* and the prime meridian is Greenwich.
*
@@ -71,7 +71,7 @@ public final strictfp class HardCodedConversions {
/**
* A three-dimensional Mercator projection using the WGS84 datum.
- * This CRS uses (<var>easting</var>, <var>northing</var>, <var>height</var>) ordinates in metres.
+ * This CRS uses (<var>easting</var>, <var>northing</var>, <var>height</var>) coordinates in metres.
* The base CRS uses (<var>longitude</var>, <var>latitude</var>, <var>height</var>) axes
* and the prime meridian is Greenwich.
*
@@ -84,7 +84,7 @@ public final strictfp class HardCodedConversions {
/**
* A two- or three-dimensional Mercator projection using the given base CRS.
- * This CRS uses (<var>easting</var>, <var>northing</var>) ordinates in metres.
+ * This CRS uses (<var>easting</var>, <var>northing</var>) coordinates in metres.
*
* @param baseCRS the two- or three-dimensional base CRS.
* @return two- or three-dimensional Mercator projection.
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java
index 868ce37..02fe30c 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/builder/LinearTransformBuilderTest.java
@@ -269,9 +269,9 @@ public final strictfp class LinearTransformBuilderTest extends TestCase {
final Map<DirectPosition1D,DirectPosition1D> pos = new HashMap<>(numPts);
for (int i=0; i<numPts; i++) {
final DirectPosition1D src = new DirectPosition1D(rd.nextDouble() * 100 - 50);
- final DirectPosition1D tgt = new DirectPosition1D(src.ordinate * scale + offset);
+ final DirectPosition1D tgt = new DirectPosition1D(src.coordinate * scale + offset);
if (addErrors) {
- tgt.ordinate += rd.nextDouble() * 10 - 5;
+ tgt.coordinate += rd.nextDouble() * 10 - 5;
}
assertNull(pos.put(src, tgt));
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java
index 13db25e..0c16aff 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/matrix/MatricesTest.java
@@ -273,7 +273,7 @@ public final strictfp class MatricesTest extends TestCase {
0, 0, 0, 1
}), matrix);
/*
- * Test adding a dimension with ordinate values set to zero.
+ * Test adding a dimension with coordinate values set to zero.
*/
expanded.subEnvelope(0, 2).setEnvelope(dstEnvelope);
matrix = Matrices.createTransform(srcEnvelope, expanded);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java
index 0392c23..f29d1fa 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/projection/AlbersEqualAreaTest.java
@@ -95,8 +95,8 @@ public final strictfp class AlbersEqualAreaTest extends MapProjectionTestCase {
/*
* Verify consistency with random points.
*/
- verifyInDomain(new double[] {-20, 20}, // Minimal input ordinate values
- new double[] {+20, 50}, // Maximal input ordinate values
+ verifyInDomain(new double[] {-20, 20}, // Minimal input coordinate values
+ new double[] {+20, 50}, // Maximal input coordinate values
new int[] { 5, 5}, // Number of points to test
TestUtilities.createRandomNumberGenerator());
}
@@ -148,8 +148,8 @@ public final strictfp class AlbersEqualAreaTest extends MapProjectionTestCase {
/*
* Verify consistency with random points.
*/
- verifyInDomain(new double[] {-20, 20}, // Minimal input ordinate values
- new double[] {+20, 50}, // Maximal input ordinate values
+ verifyInDomain(new double[] {-20, 20}, // Minimal input coordinate values
+ new double[] {+20, 50}, // Maximal input coordinate values
new int[] { 5, 5}, // Number of points to test
TestUtilities.createRandomNumberGenerator());
}
@@ -249,8 +249,8 @@ public final strictfp class AlbersEqualAreaTest extends MapProjectionTestCase {
toleranceModifier = ToleranceModifier.PROJECTION;
final double delta = toRadians(100.0 / 60) / 1852; // Approximately 100 metres.
derivativeDeltas = new double[] {delta, delta};
- verifyInDomain(new double[] {-40, 10}, // Minimal input ordinate values
- new double[] {+40, 60}, // Maximal input ordinate values
+ verifyInDomain(new double[] {-40, 10}, // Minimal input coordinate values
+ new double[] {+40, 60}, // Maximal input coordinate values
new int[] { 5, 5}, // Number of points to test
TestUtilities.createRandomNumberGenerator());
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java
index 546305f..8aa9eb2 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/AbstractMathTransformTest.java
@@ -223,7 +223,7 @@ public final strictfp class AbstractMathTransformTest extends TestCase {
}
}
/*
- * Inspects each transformed coordinates. Either all ordinates are NaN, or either
+ * Inspects each transformed coordinates. Either all coordinates are NaN, or either
* none of them are. Verifies with RandomFailureTransform if the NaN state is the
* expected one.
*/
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java
index 3e6db5f..076aff8 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomain.java
@@ -68,23 +68,23 @@ public strictfp class CoordinateDomain {
throw new IllegalArgumentException();
}
final double axis = GeodeticDatumMock.SPHERE.getEllipsoid().getSemiMajorAxis();
- final double[] ordinates = GEOGRAPHIC.generateRandomInput(random, dimension, numPts);
- for (int i=0; i<ordinates.length;) {
- final double phi = toRadians(ordinates[i ]);
- final double theta = toRadians(ordinates[i+1]);
- final double radius = axis + ordinates[i+2];
+ final double[] coordinates = GEOGRAPHIC.generateRandomInput(random, dimension, numPts);
+ for (int i=0; i<coordinates.length;) {
+ final double phi = toRadians(coordinates[i ]);
+ final double theta = toRadians(coordinates[i+1]);
+ final double radius = axis + coordinates[i+2];
final double radXY = radius * cos(theta);
- ordinates[i++] = radXY * cos(phi);
- ordinates[i++] = radXY * sin(phi);
- ordinates[i++] = radius * sin(theta);
+ coordinates[i++] = radXY * cos(phi);
+ coordinates[i++] = radXY * sin(phi);
+ coordinates[i++] = radius * sin(theta);
}
- return ordinates;
+ return coordinates;
}
};
/**
* Geographic input coordinates with angles in decimal degrees.
- * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+ * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC = new CoordinateDomain(
Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -93,7 +93,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates avoiding poles and anti-meridian.
- * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+ * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_SAFE = new CoordinateDomain(
Longitude.MIN_VALUE + 1, Longitude.MAX_VALUE - 1,
@@ -102,7 +102,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates close to the poles.
- * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+ * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_POLES = new CoordinateDomain(
Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -111,23 +111,23 @@ public strictfp class CoordinateDomain {
{
@Override
public double[] generateRandomInput(final Random random, final int dimension, final int numPts) {
- final double[] ordinates = super.generateRandomInput(random, dimension, numPts);
- for (int i=1; i < ordinates.length; i += dimension) {
- final double φ = ordinates[i];
+ final double[] coordinates = super.generateRandomInput(random, dimension, numPts);
+ for (int i=1; i < coordinates.length; i += dimension) {
+ final double φ = coordinates[i];
double a = abs(φ);
if (a < ARTICLE_CIRCLE) {
a -= floor(a / (Latitude.MAX_VALUE - ARTICLE_CIRCLE)) * (Latitude.MAX_VALUE - ARTICLE_CIRCLE);
a = (Latitude.MAX_VALUE - a);
- ordinates[i] = copySign(a, φ);
+ coordinates[i] = copySign(a, φ);
}
}
- return ordinates;
+ return coordinates;
}
};
/**
* Geographic input coordinates close to the north pole.
- * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+ * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_NORTH_POLE = new CoordinateDomain(
Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -136,7 +136,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates close to the south pole.
- * Ordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
+ * Coordinates are in (<var>longitude</var>, <var>latitude</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_SOUTH_POLE = new CoordinateDomain(
Longitude.MIN_VALUE, Longitude.MAX_VALUE,
@@ -145,7 +145,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates with angles in radians.
- * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+ * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_RADIANS = new CoordinateDomain(
-PI, PI,
@@ -154,7 +154,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates with angles in radians and only half of the longitude range.
- * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+ * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_RADIANS_HALF_λ = new CoordinateDomain(
-PI/2, PI/2,
@@ -163,7 +163,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates with angles in radians in the North hemisphere only.
- * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+ * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_RADIANS_NORTH = new CoordinateDomain(
-PI, PI,
@@ -172,7 +172,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates with angles in radians in the South hemisphere only.
- * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+ * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_RADIANS_SOUTH = new CoordinateDomain(
-PI, PI,
@@ -181,7 +181,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates with angles in radians in the East hemisphere only.
- * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+ * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_RADIANS_EAST = new CoordinateDomain(
0, PI,
@@ -190,7 +190,7 @@ public strictfp class CoordinateDomain {
/**
* Geographic input coordinates with angles in radians in the West hemisphere only.
- * Ordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
+ * Coordinates are in (<var>lambda</var>, <var>phi</var>, <var>height</var>) order.
*/
public static final CoordinateDomain GEOGRAPHIC_RADIANS_WEST = new CoordinateDomain(
-PI, 0,
@@ -199,7 +199,7 @@ public strictfp class CoordinateDomain {
/**
* Projected input coordinates in a range suitable for UTM projections.
- * Ordinates are in (<var>easting</var>, <var>northing</var>, <var>height</var>) order.
+ * Coordinates are in (<var>easting</var>, <var>northing</var>, <var>height</var>) order.
*/
public static final CoordinateDomain PROJECTED = new CoordinateDomain(
-350000, 350000, // Easting
@@ -248,10 +248,10 @@ public strictfp class CoordinateDomain {
* @param random the random number generator to use.
* @param dimension the number of dimension of the points to generate.
* @param numPts the number of points to generate.
- * @return an array of length {@code numPts*dimension} filled with random input ordinate values.
+ * @return an array of length {@code numPts*dimension} filled with random input coordinate values.
*/
public double[] generateRandomInput(final Random random, final int dimension, final int numPts) {
- final double[] ordinates = new double[numPts * dimension];
+ final double[] coordinates = new double[numPts * dimension];
for (int j=0; j<dimension; j++) {
final double min, max;
switch (j) {
@@ -259,17 +259,17 @@ public strictfp class CoordinateDomain {
case 1: min = ymin; max = ymax; break;
case 2: min = zmin; max = zmax; break;
default: {
- for (int i=j; i<ordinates.length; i += dimension) {
- ordinates[i] = random.nextGaussian();
+ for (int i=j; i<coordinates.length; i += dimension) {
+ coordinates[i] = random.nextGaussian();
}
continue;
}
}
final double range = max - min;
- for (int i=j; i<ordinates.length; i += dimension) {
- ordinates[i] = min + range * random.nextDouble();
+ for (int i=j; i<coordinates.length; i += dimension) {
+ coordinates[i] = min + range * random.nextDouble();
}
}
- return ordinates;
+ return coordinates;
}
}
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java
index 33eaf7d..6b0fdde 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CoordinateDomainTest.java
@@ -60,9 +60,9 @@ public strictfp class CoordinateDomainTest extends TestCase {
one can use the following code:
public static void main(String[] args) {
- double[] ordinates = CoordinateDomain.GEOGRAPHIC.generateRandomInput(new Random(9157324015136982593L), 3, 5));
- for (int i=0; i<ordinates.length;) {
- System.out.format(java.util.Locale.US, " %6.1f, %6.1f, %8.1f,%n", ordinates[i++], ordinates[i++], ordinates[i++]);
+ double[] coordinates = CoordinateDomain.GEOGRAPHIC.generateRandomInput(new Random(9157324015136982593L), 3, 5));
+ for (int i=0; i<coordinates.length;) {
+ System.out.format(java.util.Locale.US, " %6.1f, %6.1f, %8.1f,%n", coordinates[i++], coordinates[i++], coordinates[i++]);
}
}
*/
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java
index 0e6c2eb..d7366cd 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/CopyTransformTest.java
@@ -43,7 +43,7 @@ import static org.apache.sis.test.ReferencingAssert.*;
})
public final strictfp class CopyTransformTest extends MathTransformTestCase {
/**
- * Generates random ordinates with approximately 5% of NaN values in the array.
+ * Generates random coordinates with approximately 5% of NaN values in the array.
*/
private double[] generateRandomCoordinates() {
return generateRandomCoordinates(CoordinateDomain.GEOGRAPHIC, 0.05f);
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java
index 2c4056d..ae0ba43 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/transform/PseudoTransform.java
@@ -52,7 +52,7 @@ strictfp class PseudoTransform extends AbstractMathTransform {
protected final int sourceDimension, targetDimension;
/**
- * Temporary buffer for copying the ordinate of a single source points.
+ * Temporary buffer for copying the coordinates of a single source point.
* Used in order to be compliant with {@link IterationStrategy} contract.
*/
private final double[] buffer;
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java b/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java
index b9bd6f4..6776155 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/test/ReferencingAssert.java
@@ -268,7 +268,7 @@ public strictfp class ReferencingAssert extends MetadataAssert {
}
/**
- * Asserts that two envelopes have the same minimum and maximum ordinates.
+ * Asserts that two envelopes have the same minimum and maximum coordinates.
* This method ignores the envelope type (i.e. the implementation class) and the CRS.
*
* @param expected the expected envelope.
@@ -412,14 +412,14 @@ public strictfp class ReferencingAssert extends MetadataAssert {
for (int index=0; index<numCases; index++) {
int n = index;
for (int i=0; i<dimension; i++) {
- final double ordinate;
+ final double coordinate;
switch (n % 3) {
- case 0: ordinate = e2.getMinimum(i); break;
- case 1: ordinate = e2.getMedian (i); break;
- case 2: ordinate = e2.getMaximum(i); break;
+ case 0: coordinate = e2.getMinimum(i); break;
+ case 1: coordinate = e2.getMedian (i); break;
+ case 2: coordinate = e2.getMaximum(i); break;
default: throw new AssertionError(i);
}
- pos.setOrdinate(i, ordinate);
+ pos.setOrdinate(i, coordinate);
n /= 3;
}
assertEquals(0, n); // Opportunist check of this assert method.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java b/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java
index 87281d2..9d64a43 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/math/CompoundDirectPositions.java
@@ -23,7 +23,7 @@ import org.apache.sis.util.resources.Errors;
/**
- * A sequence of {@code DirectPosition}s which is a view over arrays of ordinate values.
+ * A sequence of {@code DirectPosition}s which is a view over arrays of coordinate values.
* Each dimension is stored in a separated array. For example this class can view three
* arrays (x[], y[], and z[]) as a sequence of three-dimensional {@code DirectPosition}.
*
@@ -40,12 +40,12 @@ import org.apache.sis.util.resources.Errors;
*/
final class CompoundDirectPositions implements DirectPosition, Iterable<DirectPosition>, Iterator<DirectPosition> {
/**
- * The arrays of ordinate values, for example (x[], y[], z[]).
+ * The arrays of coordinate values, for example (x[], y[], z[]).
*/
- private final Vector[] ordinates;
+ private final Vector[] coordinates;
/**
- * Length of all ordinate values minus one.
+ * Length of all coordinate values minus one.
*/
private final int last;
@@ -55,13 +55,13 @@ final class CompoundDirectPositions implements DirectPosition, Iterable<DirectPo
private int index;
/**
- * Wraps the given array of ordinate values.
+ * Wraps the given array of coordinate values.
*/
- CompoundDirectPositions(final Vector... ordinates) {
- this.ordinates = ordinates;
- final int length = ordinates[0].size();
- for (int i=1; i<ordinates.length; i++) {
- if (ordinates[i].size() != length) {
+ CompoundDirectPositions(final Vector... coordinates) {
+ this.coordinates = coordinates;
+ final int length = coordinates[0].size();
+ for (int i=1; i<coordinates.length; i++) {
+ if (coordinates[i].size() != length) {
throw new IllegalArgumentException(Errors.format(Errors.Keys.MismatchedArrayLengths));
}
}
@@ -127,15 +127,15 @@ final class CompoundDirectPositions implements DirectPosition, Iterable<DirectPo
*/
@Override
public int getDimension() {
- return ordinates.length;
+ return coordinates.length;
}
/**
- * Return the ordinate value at the given dimension.
+ * Return the coordinate value at the given dimension.
*/
@Override
public double getOrdinate(final int dimension) {
- return ordinates[dimension].doubleValue(index);
+ return coordinates[dimension].doubleValue(index);
}
/**
diff --git a/core/sis-utility/src/main/java/org/apache/sis/math/Line.java b/core/sis-utility/src/main/java/org/apache/sis/math/Line.java
index 34f38fb..9b3b219 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/math/Line.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/math/Line.java
@@ -231,10 +231,10 @@ public class Line implements DoubleUnaryOperator, Cloneable, Serializable {
* Sets a line through the specified points.
* The line will continue toward infinity after the points.
*
- * @param x1 ordinate <var>x</var> of the first point.
- * @param y1 ordinate <var>y</var> of the first point.
- * @param x2 ordinate <var>x</var> of the second point.
- * @param y2 ordinate <var>y</var> of the second point.
+ * @param x1 coordinate <var>x</var> of the first point.
+ * @param y1 coordinate <var>y</var> of the first point.
+ * @param x2 coordinate <var>x</var> of the second point.
+ * @param y2 coordinate <var>y</var> of the second point.
*/
public void setFromPoints(final double x1, final double y1, final double x2, final double y2) {
this.slope = (y2 - y1) / (x2 - x1);
@@ -295,9 +295,9 @@ public class Line implements DoubleUnaryOperator, Cloneable, Serializable {
/**
* Given a sequence of points, fits them to a straight line
* <var>y</var> = <var>slope</var>⋅<var>x</var> + <var>y₀</var> in a least-squares senses.
- * Points shall be two dimensional with ordinate values in the (<var>x</var>,<var>y</var>) order.
+ * Points shall be two dimensional with coordinate values in the (<var>x</var>,<var>y</var>) order.
* This method assumes that the <var>x</var> values are precise and all uncertainty is in <var>y</var>.
- * {@link Double#NaN} ordinate values are ignored.
+ * {@link Double#NaN} coordinate values are ignored.
*
* @param points the two-dimensional points.
* @return estimation of the correlation coefficient. The closer this coefficient is to +1 or -1, the better the fit.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java b/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java
index 1583f81..de41015 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/math/Plane.java
@@ -248,7 +248,7 @@ public class Plane implements DoubleBinaryOperator, Cloneable, Serializable {
}
/**
- * Computes the plane's coefficients from the given ordinate values.
+ * Computes the plane's coefficients from the given coordinate values.
* This method uses a linear regression in the least-square sense, with the assumption that
* the (<var>x</var>,<var>y</var>) values are precise and all uncertainty is in <var>z</var>.
* {@link Double#NaN} values are ignored. The result is undetermined if all points are colinear.
@@ -270,7 +270,7 @@ public class Plane implements DoubleBinaryOperator, Cloneable, Serializable {
}
/**
- * Computes the plane's coefficients from the given ordinate values.
+ * Computes the plane's coefficients from the given coordinate values.
* This method uses a linear regression in the least-square sense, with the assumption that
* the (<var>x</var>,<var>y</var>) values are precise and all uncertainty is in <var>z</var>.
* {@link Double#NaN} values are ignored. The result is undetermined if all points are colinear.
@@ -355,7 +355,7 @@ public class Plane implements DoubleBinaryOperator, Cloneable, Serializable {
* Computes the plane's coefficients from the given sequence of points.
* This method uses a linear regression in the least-square sense, with the assumption that
* the (<var>x</var>,<var>y</var>) values are precise and all uncertainty is in <var>z</var>.
- * Points shall be three dimensional with ordinate values in the (<var>x</var>,<var>y</var>,<var>z</var>) order.
+ * Points shall be three dimensional with coordinate values in the (<var>x</var>,<var>y</var>,<var>z</var>) order.
* {@link Double#NaN} values are ignored. The result is undetermined if all points are colinear.
*
* @param points the three-dimensional points.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java b/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java
index 8b57fe3..90b313d 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/measure/Latitude.java
@@ -115,8 +115,8 @@ public final class Latitude extends Angle {
* {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS};
* it may also be <cite>geocentric latitudes</cite>.
*
- * <p>If the axis direction is South, then the sign of the ordinate value is inverted.
- * If the ordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
+ * <p>If the axis direction is South, then the sign of the coordinate value is inverted.
+ * If the coordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
* then a unit conversion is applied.</p>
*
* @param position the coordinate from which to extract the latitude value in degrees.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java b/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java
index 97eeca4..9a84754 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/measure/Longitude.java
@@ -102,8 +102,8 @@ public final class Longitude extends Angle {
* {@linkplain org.apache.sis.referencing.crs.DefaultGeographicCRS geographic CRS};
* it may also be <cite>geocentric longitudes</cite>.
*
- * <p>If the axis direction is West, then the sign of the ordinate value is inverted.
- * If the ordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
+ * <p>If the axis direction is West, then the sign of the coordinate value is inverted.
+ * If the coordinate value uses another angular units than {@linkplain Units#DEGREE degrees},
* then a unit conversion is applied.</p>
*
* @param position the coordinate from which to extract the longitude value in degrees.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
index ca225f8..80a841c 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
+++ b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
@@ -368,6 +368,11 @@ public final class Errors extends IndexedResourceBundle {
public static final short IllegalClass_2 = 50;
/**
+ * The [{0} … {1}] range of coordinate values is not valid for the “{2}” axis.
+ */
+ public static final short IllegalCoordinateRange_3 = 57;
+
+ /**
* Coordinate system can not be “{0}”.
*/
public static final short IllegalCoordinateSystem_1 = 51;
@@ -403,11 +408,6 @@ public final class Errors extends IndexedResourceBundle {
public static final short IllegalOptionValue_2 = 56;
/**
- * The [{0} … {1}] range of ordinate values is not valid for the “{2}” axis.
- */
- public static final short IllegalOrdinateRange_3 = 57;
-
- /**
* Property “{0}” does not accept instances of ‘{1}’.
*/
public static final short IllegalPropertyValueClass_2 = 58;
diff --git a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
index 1b4f467..b69913a 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
+++ b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
@@ -91,7 +91,7 @@ IllegalLanguageCode_1 = The \u201c{0}\u201d language is not recogniz
IllegalMapping_2 = Illegal mapping: {0} \u2192 {1}.
IllegalMemberType_2 = Member \u201c{0}\u201d can not be associated to type \u201c{1}\u201d.
IllegalOptionValue_2 = Option \u2018{0}\u2019 can not take the \u201c{1}\u201d value.
-IllegalOrdinateRange_3 = The [{0} \u2026 {1}] range of ordinate values is not valid for the \u201c{2}\u201d axis.
+IllegalCoordinateRange_3 = The [{0} \u2026 {1}] range of coordinate values is not valid for the \u201c{2}\u201d axis.
IllegalPropertyValueClass_2 = Property \u201c{0}\u201d does not accept instances of \u2018{1}\u2019.
IllegalPropertyValueClass_3 = Expected an instance of \u2018{1}\u2019 for the \u201c{0}\u201d property, but got an instance of \u2018{2}\u2019.
IllegalRange_2 = Range [{0} \u2026 {1}] is not valid.
diff --git a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
index fe58d55..8bc217f 100644
--- a/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
+++ b/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
@@ -88,7 +88,7 @@ IllegalLanguageCode_1 = Le code de langue \u00ab\u202f{0}\u202f\u00b
IllegalMapping_2 = Correspondance ill\u00e9gale: {0} \u2192 {1}.
IllegalMemberType_2 = Le membre \u00ab\u202f{0}\u202f\u00bb ne peut pas \u00eatre associ\u00e9 au type \u00ab\u202f{1}\u202f\u00bb.
IllegalOptionValue_2 = L\u2019option \u2018{0}\u2019 n\u2019accepte pas la valeur \u00ab\u202f{1}\u202f\u00bb.
-IllegalOrdinateRange_3 = La plage de valeurs de coordonn\u00e9es [{0} \u2026 {1}] n\u2019est pas valide pour l\u2019axe \u00ab\u202f{2}\u202f\u00bb.
+IllegalCoordinateRange_3 = La plage de valeurs de coordonn\u00e9es [{0} \u2026 {1}] n\u2019est pas valide pour l\u2019axe \u00ab\u202f{2}\u202f\u00bb.
IllegalPropertyValueClass_2 = La propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb n\u2019accepte pas les valeurs de type \u2018{1}\u2019.
IllegalPropertyValueClass_3 = Une instance \u2018{1}\u2019 \u00e9tait attendue pour la propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb, mais la valeur donn\u00e9e est une instance de \u2018{2}\u2019.
IllegalRange_2 = La plage [{0} \u2026 {1}] n\u2019est pas valide.
diff --git a/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java b/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java
index 5008a2d..f4823ac 100644
--- a/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java
+++ b/core/sis-utility/src/test/java/org/apache/sis/test/TestUtilities.java
@@ -363,9 +363,9 @@ public final strictfp class TestUtilities extends Static {
}
/**
- * Returns a copy of the given array with the last ordinate values dropped for each coordinates.
+ * Returns a copy of the given array with the last coordinate values dropped for each coordinates.
*
- * @param coordinates the source coordinates from which to drop the last ordinate values.
+ * @param coordinates the source coordinates from which to drop the last coordinate values.
* @param sourceDim number of dimensions of each point in the {@code coordinates} array.
* @param targetDim number of dimensions to retain.
* @return copy of the given {@code coordinates} array with only the {@code targetDim} first dimension for each point.
diff --git a/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java b/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java
index 31dc007..cd7e610 100644
--- a/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java
+++ b/storage/sis-earth-observation/src/main/java/org/apache/sis/storage/earthobservation/LandsatReader.java
@@ -142,7 +142,7 @@ final class LandsatReader extends MetadataBuilder {
static final Pattern CREDIT = Pattern.compile("\\bcourtesy\\h+of\\h+(the)?\\b\\s*", Pattern.CASE_INSENSITIVE);
/**
- * Number of spatial dimensions. This is the number of ordinate values to be stored
+ * Number of spatial dimensions. This is the number of coordinate values to be stored
* in the {@link #gridSizes} and {@link #corners} arrays for each tuple.
*/
static final int DIM = 2;
@@ -192,7 +192,7 @@ final class LandsatReader extends MetadataBuilder {
/**
* Index of projected and geographic coordinates in the {@link #corners} array.
- * Each kind of coordinates are stored as 4 corners of {@value #DIM} ordinate values.
+ * Each kind of coordinates are stored as 4 corners of {@value #DIM} coordinate values.
*/
private static final int PROJECTED = 0*DIM,
GEOGRAPHIC = 4*DIM;
@@ -390,7 +390,7 @@ final class LandsatReader extends MetadataBuilder {
/**
* Parses the given value and stores it at the given index in the {@link #corners} array.
* The given index must be one of the {@link #PROJECTED} or {@link #GEOGRAPHIC} constants
- * plus the ordinate index.
+ * plus the coordinate index.
*/
private void parseCorner(final int index, final String value) throws NumberFormatException {
corners[index] = Double.parseDouble(value);
diff --git a/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c b/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c
index 9ae2b15..329dc4c 100644
--- a/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c
+++ b/storage/sis-gdal/src/main/c/org_apache_sis_storage_gdal_PJ.c
@@ -194,10 +194,10 @@ JNIEXPORT jdoubleArray JNICALL Java_org_apache_sis_storage_gdal_PJ_getEllipsoidD
void convertAngularOrdinates(projPJ pj, double* data, jint numPts, int dimension, double factor) {
int dimToSkip;
if (pj_is_latlong(pj)) {
- // Convert only the 2 first ordinates and skip all the other dimensions.
+ // Convert only the 2 first coordinates and skip all the other dimensions.
dimToSkip = dimension - 2;
} else if (pj_is_geocent(pj)) {
- // Convert only the 3 first ordinates and skip all the other dimensions.
+ // Convert only the 3 first coordinates and skip all the other dimensions.
dimToSkip = dimension - 3;
} else {
// Not a geographic or geocentric CRS: nothing to convert.
diff --git a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java
index 06fd23d..b54c5c4 100644
--- a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java
+++ b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/GridGeometryBuilder.java
@@ -106,9 +106,9 @@ final class GridGeometryBuilder {
public String asciiParameters;
/**
- * Raster model tie points. This vector contains ordinate values structured as (I,J,K, X,Y,Z) records.
- * The (I,J,K) ordinate values specify the point at location (I,J) in raster space with pixel-value K,
- * and (X,Y,Z) ordinate values specify the point in the Coordinate Reference System. In most cases the
+ * Raster model tie points. This vector contains coordinate values structured as (I,J,K, X,Y,Z) records.
+ * The (I,J,K) coordinate values specify the point at location (I,J) in raster space with pixel-value K,
+ * and (X,Y,Z) coordinate values specify the point in the Coordinate Reference System. In most cases the
* coordinate system is only two-dimensional, in which case both K and Z should be set to zero.
*/
public Vector modelTiePoints;
diff --git a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java
index 799cea5..06c6967 100644
--- a/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java
+++ b/storage/sis-geotiff/src/main/java/org/apache/sis/storage/geotiff/Localization.java
@@ -92,13 +92,13 @@ final class Localization {
try {
final LocalizationGridBuilder grid = new LocalizationGridBuilder(x, y);
final LinearTransform sourceToGrid = grid.getSourceToGrid();
- final double[] ordinates = new double[2];
+ final double[] coordinates = new double[2];
for (int i=0; i<size; i += RECORD_LENGTH) {
- ordinates[0] = modelTiePoints.doubleValue(i);
- ordinates[1] = modelTiePoints.doubleValue(i+1);
- sourceToGrid.transform(ordinates, 0, ordinates, 0, 1);
- grid.setControlPoint(Math.toIntExact(Math.round(ordinates[0])),
- Math.toIntExact(Math.round(ordinates[1])),
+ coordinates[0] = modelTiePoints.doubleValue(i);
+ coordinates[1] = modelTiePoints.doubleValue(i+1);
+ sourceToGrid.transform(coordinates, 0, coordinates, 0, 1);
+ grid.setControlPoint(Math.toIntExact(Math.round(coordinates[0])),
+ Math.toIntExact(Math.round(coordinates[1])),
modelTiePoints.doubleValue(i + (RECORD_LENGTH/2)),
modelTiePoints.doubleValue(i + (RECORD_LENGTH/2 + 1)));
}
diff --git a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java
index 7725d43..cfd0cbd 100644
--- a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java
+++ b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/impl/GridInfo.java
@@ -306,7 +306,7 @@ next: for (final String name : axisNames) {
}
/*
* Get the grid dimensions (part of the "domain" in UCAR terminology) used for computing
- * the ordinate values along the current axis. There is exactly 1 such grid dimension in
+ * the coordinate values along the current axis. There is exactly 1 such grid dimension in
* straightforward netCDF files. However some more complex files may have 2 dimensions.
*/
int i = 0;
diff --git a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java
index 37d56e4..b8b6df1 100644
--- a/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java
+++ b/storage/sis-netcdf/src/main/java/org/apache/sis/internal/netcdf/ucar/GridWrapper.java
@@ -256,7 +256,7 @@ next: for (final String name : axisNames) {
}
/*
* Get the grid dimensions (part of the "domain" in UCAR terminology) used for computing
- * the ordinate values along the current axis. There is exactly 1 such grid dimension in
+ * the coordinate values along the current axis. There is exactly 1 such grid dimension in
* straightforward netCDF files. However some more complex files may have 2 dimensions.
*/
int i = 0;
diff --git a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java
index 1afdc34..133c6ea 100644
--- a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java
+++ b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/MetadataBuilder.java
@@ -1792,13 +1792,13 @@ parse: for (int i = 0; i < length;) {
* <li>{@code metadata/identificationInfo/extent/geographicElement}</li>
* </ul>
*
- * @param ordinates the geographic coordinates, or {@code null} for no-operation.
- * @param index index of the first value to use in the given array.
+ * @param coordinates the geographic coordinates, or {@code null} for no-operation.
+ * @param index index of the first value to use in the given array.
*/
- public final void addExtent(final double[] ordinates, int index) {
- if (ordinates != null) {
+ public final void addExtent(final double[] coordinates, int index) {
+ if (coordinates != null) {
final DefaultGeographicBoundingBox bbox = new DefaultGeographicBoundingBox(
- ordinates[index], ordinates[++index], ordinates[++index], ordinates[++index]);
+ coordinates[index], coordinates[++index], coordinates[++index], coordinates[++index]);
if (!bbox.isEmpty()) {
addIfNotPresent(extent().getGeographicElements(), bbox);
}
diff --git a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java
index 7895203..caa298a 100644
--- a/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java
+++ b/storage/sis-storage/src/main/java/org/apache/sis/internal/storage/csv/Store.java
@@ -115,7 +115,7 @@ final class Store extends URIDataStore implements FeatureSet {
static final char SEPARATOR = ',';
/**
- * The separator between ordinate values in a coordinate.
+ * The separator between coordinate values in a coordinate tuple.
*/
static final char ORDINATE_SEPARATOR = ' ';
[sis] 03/03: Remove Formulas.pow3(int),
replaced by the more generic MathFunctions.pow(long, int).
Posted by de...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
desruisseaux pushed a commit to branch geoapi-4.0
in repository https://gitbox.apache.org/repos/asf/sis.git
commit e36a238b801b006c6fd9ebb63271b91a8756f2ca
Author: Martin Desruisseaux <ma...@geomatys.com>
AuthorDate: Tue Jun 11 17:03:44 2019 +0200
Remove Formulas.pow3(int), replaced by the more generic MathFunctions.pow(long, int).
---
.../main/java/org/apache/sis/geometry/Envelopes.java | 4 ++--
.../apache/sis/internal/referencing/Formulas.java | 20 --------------------
.../sis/internal/referencing/FormulasTest.java | 12 ------------
3 files changed, 2 insertions(+), 34 deletions(-)
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
index 36177e0..13d5f86 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/geometry/Envelopes.java
@@ -44,7 +44,6 @@ import org.apache.sis.referencing.operation.transform.AbstractMathTransform;
import org.apache.sis.internal.metadata.ReferencingServices;
import org.apache.sis.internal.referencing.CoordinateOperations;
import org.apache.sis.internal.referencing.DirectPositionView;
-import org.apache.sis.internal.referencing.Formulas;
import org.apache.sis.internal.system.Loggers;
import org.apache.sis.util.logging.Logging;
import org.apache.sis.util.resources.Errors;
@@ -52,6 +51,7 @@ import org.apache.sis.util.ArgumentChecks;
import org.apache.sis.util.ComparisonMode;
import org.apache.sis.util.Utilities;
import org.apache.sis.util.Static;
+import org.apache.sis.math.MathFunctions;
import static org.apache.sis.util.StringBuilders.trimFractionalPart;
@@ -422,7 +422,7 @@ public final class Envelopes extends Static {
int pointIndex = 0;
boolean isDerivativeSupported = true;
GeneralEnvelope transformed = null;
- final Matrix[] derivatives = new Matrix[Formulas.pow3(sourceDim)];
+ final Matrix[] derivatives = new Matrix[Math.toIntExact(MathFunctions.pow(3, sourceDim))];
final double[] coordinates = new double[derivatives.length * targetDim];
final double[] sourcePt = new double[sourceDim];
for (int i=sourceDim; --i>=0;) {
diff --git a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
index 9c145a2..fe86928 100644
--- a/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
+++ b/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/Formulas.java
@@ -98,26 +98,6 @@ public final class Formulas extends Static {
}
/**
- * Returns 3ⁿ for very small (less than 10) positive values of <var>n</var>.
- * Note that this method overflow for any value equals or greater than 20.
- *
- * @param n the exponent.
- * @return 3ⁿ
- *
- * @see org.apache.sis.math.DecimalFunctions#pow10(int)
- *
- * @since 0.5
- */
- public static int pow3(int n) {
- assert n >= 0 && n <= 19 : n;
- int p = 1;
- while (--n >= 0) {
- p *= 3;
- }
- return p;
- }
-
- /**
* Returns {@code true} if {@code ymin} is the south pole and {@code ymax} is the north pole.
*
* @param ymin the minimal latitude to test.
diff --git a/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/FormulasTest.java b/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/FormulasTest.java
index 9f0302a..46b81ff 100644
--- a/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/FormulasTest.java
+++ b/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/FormulasTest.java
@@ -52,18 +52,6 @@ public final strictfp class FormulasTest extends TestCase {
}
/**
- * Tests {@link Formulas#pow3(int)}.
- *
- * @since 0.5
- */
- @Test
- public void testPow3() {
- for (int n=0; n<=8; n++) {
- assertEquals((int) StrictMath.round(StrictMath.pow(3, n)), Formulas.pow3(n));
- }
- }
-
- /**
* Tests {@link Formulas#isPoleToPole(double, double)}.
*/
@Test