From 3c31ab7f506eed1e7a49f63e4c256277db0d05f4 Mon Sep 17 00:00:00 2001
From: Luc Maisonobe <luc@orekit.org>
Date: Thu, 20 Nov 2014 17:14:23 +0100
Subject: [PATCH] Switched word localization -> location.
---
aster/pom.xml | 9 ++
.../java/org/orekit/rugged/api/Rugged.java | 78 ++++++------
.../rugged/api/SensorMeanPlaneCrossing.java | 4 +-
.../rugged/api/SensorPixelCrossing.java | 2 +-
.../org/orekit/rugged/api/RuggedTest.java | 120 +++++++++---------
.../intersection/AbstractAlgorithmTest.java | 4 +-
...uml => direct-location-class-diagram.puml} | 2 +-
... => direct-location-sequence-diagram.puml} | 2 +-
...=> inverse-location-sequence-diagram.puml} | 4 +-
pom.xml | 32 ++---
.../design/digital-elevation-model.md | 2 +-
src/site/markdown/design/overview.md | 4 +-
.../markdown/design/preliminary-design.md | 18 +--
src/site/markdown/index.md | 6 +-
...ect-localization.md => direct-location.md} | 8 +-
src/site/site.xml | 2 +-
src/site/xdoc/changes.xml | 30 ++---
17 files changed, 168 insertions(+), 159 deletions(-)
rename design/{direct-localization-class-diagram.puml => direct-location-class-diagram.puml} (98%)
rename design/{direct-localization-sequence-diagram.puml => direct-location-sequence-diagram.puml} (98%)
rename design/{inverse-localization-sequence-diagram.puml => inverse-location-sequence-diagram.puml} (98%)
rename src/site/markdown/tutorials/{direct-localization.md => direct-location.md} (98%)
diff --git a/aster/pom.xml b/aster/pom.xml
index c7b50993..6ea13f95 100644
--- a/aster/pom.xml
+++ b/aster/pom.xml
@@ -38,6 +38,15 @@
<url>http://www.c-s.fr/</url>
</organization>
+ <repositories>
+ <repository>
+ <!-- This is needed *only* because Apache Commons Imaging has not been released yet -->
+ <!-- it will be removed as soon as 1.0 is officially available in maven central -->
+ <id>org.apache</id>
+ <url>https://repository.apache.org/content/repositories/snapshots/</url>
+ </repository>
+ </repositories>
+
<dependencies>
<dependency>
<groupId>org.orekit</groupId>
diff --git a/core/src/main/java/org/orekit/rugged/api/Rugged.java b/core/src/main/java/org/orekit/rugged/api/Rugged.java
index e7bdde20..ca32b3ba 100644
--- a/core/src/main/java/org/orekit/rugged/api/Rugged.java
+++ b/core/src/main/java/org/orekit/rugged/api/Rugged.java
@@ -65,13 +65,13 @@ import org.orekit.utils.TimeStampedPVCoordinates;
*/
public class Rugged {
- /** Accuracy to use in the first stage of inverse localization.
+ /** Accuracy to use in the first stage of inverse location.
* <p>
* This accuracy is only used to locate the point within one
* pixel, hence there is no point in choosing a too small value here.
* </p>
*/
- private static final double COARSE_INVERSE_LOCALIZATION_ACCURACY = 0.01;
+ private static final double COARSE_INVERSE_LOCATION_ACCURACY = 0.01;
/** Maximum number of evaluations. */
private static final int MAX_EVAL = 50;
@@ -519,12 +519,12 @@ public class Rugged {
/** Set flag for light time correction.
* <p>
* This methods set the flag for compensating or not light time between
- * ground and spacecraft. Compensating this delay improves localization
+ * ground and spacecraft. Compensating this delay improves location
* accuracy and is enabled by default. Not compensating it is mainly useful
* for validation purposes against system that do not compensate it.
* </p>
* @param lightTimeCorrection if true, the light travel time between ground
- * and spacecraft is compensated for more accurate localization
+ * and spacecraft is compensated for more accurate location
* @see #isLightTimeCorrected()
* @see #setAberrationOfLightCorrection(boolean)
*/
@@ -534,7 +534,7 @@ public class Rugged {
/** Get flag for light time correction.
* @return true if the light time between ground and spacecraft is
- * compensated for more accurate localization
+ * compensated for more accurate location
* @see #setLightTimeCorrection(boolean)
*/
public boolean isLightTimeCorrected() {
@@ -546,14 +546,14 @@ public class Rugged {
* This methods set the flag for compensating or not aberration of light,
* which is velocity composition between light and spacecraft when the
* light from ground points reaches the sensor.
- * Compensating this velocity composition improves localization
+ * Compensating this velocity composition improves location
* accuracy and is enabled by default. Not compensating it is useful
* in two cases: for validation purposes against system that do not
* compensate it or when the pixels line of sight already include the
* correction.
* </p>
* @param aberrationOfLightCorrection if true, the aberration of light
- * is corrected for more accurate localization
+ * is corrected for more accurate location
* @see #isAberrationOfLightCorrected()
* @see #setLightTimeCorrection(boolean)
*/
@@ -563,7 +563,7 @@ public class Rugged {
/** Get flag for aberration of light correction.
* @return true if the aberration of light time is corrected
- * for more accurate localization
+ * for more accurate location
* @see #setAberrationOfLightCorrection(boolean)
*/
public boolean isAberrationOfLightCorrected() {
@@ -718,13 +718,13 @@ public class Rugged {
}
- /** Direct localization of a sensor line.
+ /** Direct location of a sensor line.
* @param sensorName name of the line sensor
* @param lineNumber number of the line to localize on ground
* @return ground position of all pixels of the specified sensor line
* @exception RuggedException if line cannot be localized, or sensor is unknown
*/
- public GeodeticPoint[] directLocalization(final String sensorName, final double lineNumber)
+ public GeodeticPoint[] directLocation(final String sensorName, final double lineNumber)
throws RuggedException {
// compute the approximate transform between spacecraft and observed body
@@ -737,7 +737,7 @@ public class Rugged {
final Vector3D spacecraftVelocity =
scToInert.transformPVCoordinates(PVCoordinates.ZERO).getVelocity();
- // compute localization of each pixel
+ // compute location of each pixel
final Vector3D pInert = scToInert.transformPosition(sensor.getPosition());
final GeodeticPoint[] gp = new GeodeticPoint[sensor.getNbPixels()];
for (int i = 0; i < sensor.getNbPixels(); ++i) {
@@ -795,14 +795,14 @@ public class Rugged {
}
- /** Direct localization of a single line-of-sight.
- * @param date date of the localization
+ /** Direct location of a single line-of-sight.
+ * @param date date of the location
* @param position pixel position in spacecraft frame
* @param los normalized line-of-sight in spacecraft frame
* @return ground position of all pixels of the specified sensor line
* @exception RuggedException if line cannot be localized, or sensor is unknown
*/
- public GeodeticPoint directLocalization(final AbsoluteDate date, final Vector3D position, final Vector3D los)
+ public GeodeticPoint directLocation(final AbsoluteDate date, final Vector3D position, final Vector3D los)
throws RuggedException {
// compute the approximate transform between spacecraft and observed body
@@ -813,7 +813,7 @@ public class Rugged {
final Vector3D spacecraftVelocity =
scToInert.transformPVCoordinates(PVCoordinates.ZERO).getVelocity();
- // compute localization of specified pixel
+ // compute location of specified pixel
final Vector3D pInert = scToInert.transformPosition(position);
final Vector3D obsLInert = scToInert.transformVector(los);
@@ -867,8 +867,8 @@ public class Rugged {
/** Find the date at which sensor sees a ground point.
* <p>
- * This method is a partial {@link #inverseLocalization(String,
- * GeodeticPoint, int, int) inverse localization} focusing only on date.
+ * This method is a partial {@link #inverseLocation(String,
+ * GeodeticPoint, int, int) inverse location} focusing only on date.
* </p>
* <p>
* The point is given only by its latitude and longitude, the elevation is
@@ -881,21 +881,21 @@ public class Rugged {
* @param maxLine maximum line number
* @return date at which ground point is seen by line sensor
* @exception RuggedException if line cannot be localized, or sensor is unknown
- * @see #inverseLocalization(String, double, double, int, int)
+ * @see #inverseLocation(String, double, double, int, int)
*/
- public AbsoluteDate dateLocalization(final String sensorName,
- final double latitude, final double longitude,
- final int minLine, final int maxLine)
+ public AbsoluteDate dateLocation(final String sensorName,
+ final double latitude, final double longitude,
+ final int minLine, final int maxLine)
throws RuggedException {
final GeodeticPoint groundPoint =
new GeodeticPoint(latitude, longitude, algorithm.getElevation(latitude, longitude));
- return dateLocalization(sensorName, groundPoint, minLine, maxLine);
+ return dateLocation(sensorName, groundPoint, minLine, maxLine);
}
/** Find the date at which sensor sees a ground point.
* <p>
- * This method is a partial {@link #inverseLocalization(String,
- * GeodeticPoint, int, int) inverse localization} focusing only on date.
+ * This method is a partial {@link #inverseLocation(String,
+ * GeodeticPoint, int, int) inverse location} focusing only on date.
* </p>
* @param sensorName name of the line sensor
* @param point point to localize
@@ -903,10 +903,10 @@ public class Rugged {
* @param maxLine maximum line number
* @return date at which ground point is seen by line sensor
* @exception RuggedException if line cannot be localized, or sensor is unknown
- * @see #inverseLocalization(String, GeodeticPoint, int, int)
+ * @see #inverseLocation(String, GeodeticPoint, int, int)
*/
- public AbsoluteDate dateLocalization(final String sensorName, final GeodeticPoint point,
- final int minLine, final int maxLine)
+ public AbsoluteDate dateLocation(final String sensorName, final GeodeticPoint point,
+ final int minLine, final int maxLine)
throws RuggedException {
final LineSensor sensor = getLineSensor(sensorName);
@@ -918,7 +918,7 @@ public class Rugged {
// create a new finder for the specified sensor and range
planeCrossing = new SensorMeanPlaneCrossing(sensor, scToBody, minLine, maxLine,
lightTimeCorrection, aberrationOfLightCorrection,
- MAX_EVAL, COARSE_INVERSE_LOCALIZATION_ACCURACY);
+ MAX_EVAL, COARSE_INVERSE_LOCATION_ACCURACY);
// store the finder, in order to reuse it
// (and save some computation done in its constructor)
@@ -938,7 +938,7 @@ public class Rugged {
}
- /** Inverse localization of a ground point.
+ /** Inverse location of a ground point.
* <p>
* The point is given only by its latitude and longitude, the elevation is
* computed from the Digital Elevation Model.
@@ -952,16 +952,16 @@ public class Rugged {
* be seen between the prescribed line numbers
* @exception RuggedException if line cannot be localized, or sensor is unknown
*/
- public SensorPixel inverseLocalization(final String sensorName,
- final double latitude, final double longitude,
- final int minLine, final int maxLine)
+ public SensorPixel inverseLocation(final String sensorName,
+ final double latitude, final double longitude,
+ final int minLine, final int maxLine)
throws RuggedException {
final GeodeticPoint groundPoint =
new GeodeticPoint(latitude, longitude, algorithm.getElevation(latitude, longitude));
- return inverseLocalization(sensorName, groundPoint, minLine, maxLine);
+ return inverseLocation(sensorName, groundPoint, minLine, maxLine);
}
- /** Inverse localization of a point.
+ /** Inverse location of a point.
* @param sensorName name of the line sensor
* @param point point to localize
* @param minLine minimum line number
@@ -969,10 +969,10 @@ public class Rugged {
* @return sensor pixel seeing point, or null if point cannot be seen between the
* prescribed line numbers
* @exception RuggedException if line cannot be localized, or sensor is unknown
- * @see #dateLocalization(String, GeodeticPoint, int, int)
+ * @see #dateLocation(String, GeodeticPoint, int, int)
*/
- public SensorPixel inverseLocalization(final String sensorName, final GeodeticPoint point,
- final int minLine, final int maxLine)
+ public SensorPixel inverseLocation(final String sensorName, final GeodeticPoint point,
+ final int minLine, final int maxLine)
throws RuggedException {
final LineSensor sensor = getLineSensor(sensorName);
@@ -984,7 +984,7 @@ public class Rugged {
// create a new finder for the specified sensor and range
planeCrossing = new SensorMeanPlaneCrossing(sensor, scToBody, minLine, maxLine,
lightTimeCorrection, aberrationOfLightCorrection,
- MAX_EVAL, COARSE_INVERSE_LOCALIZATION_ACCURACY);
+ MAX_EVAL, COARSE_INVERSE_LOCATION_ACCURACY);
// store the finder, in order to reuse it
// (and save some computation done in its constructor)
@@ -1004,7 +1004,7 @@ public class Rugged {
final SensorPixelCrossing pixelCrossing =
new SensorPixelCrossing(sensor, planeCrossing.getMeanPlaneNormal(),
crossingResult.getTargetDirection().toVector3D(),
- MAX_EVAL, COARSE_INVERSE_LOCALIZATION_ACCURACY);
+ MAX_EVAL, COARSE_INVERSE_LOCATION_ACCURACY);
final double coarsePixel = pixelCrossing.locatePixel(crossingResult.getDate());
if (Double.isNaN(coarsePixel)) {
// target is out of search interval
diff --git a/core/src/main/java/org/orekit/rugged/api/SensorMeanPlaneCrossing.java b/core/src/main/java/org/orekit/rugged/api/SensorMeanPlaneCrossing.java
index a2343496..389bc2ab 100644
--- a/core/src/main/java/org/orekit/rugged/api/SensorMeanPlaneCrossing.java
+++ b/core/src/main/java/org/orekit/rugged/api/SensorMeanPlaneCrossing.java
@@ -31,7 +31,7 @@ import org.orekit.utils.PVCoordinates;
/** Class dedicated to find when ground point crosses mean sensor plane.
* <p>
- * This class is used in the first stage of inverse localization.
+ * This class is used in the first stage of inverse location.
* </p>
* @author Luc Maisonobe
*/
@@ -242,7 +242,7 @@ class SensorMeanPlaneCrossing {
// we don't use an Apache Commons Math solver here because we are more
// interested in reducing the number of evaluations than being accurate,
- // as we know the solution is improved in the second stage of inverse localization.
+ // as we know the solution is improved in the second stage of inverse location.
// We expect two or three evaluations only. Each new evaluation shows up quickly in
// the performances as it involves frames conversions
double crossingLine = midLine;
diff --git a/core/src/main/java/org/orekit/rugged/api/SensorPixelCrossing.java b/core/src/main/java/org/orekit/rugged/api/SensorPixelCrossing.java
index 157cbb1c..8325b951 100644
--- a/core/src/main/java/org/orekit/rugged/api/SensorPixelCrossing.java
+++ b/core/src/main/java/org/orekit/rugged/api/SensorPixelCrossing.java
@@ -28,7 +28,7 @@ import org.orekit.time.AbsoluteDate;
/** Class devoted to locate where ground point crosses a sensor line.
* <p>
- * This class is used in the first stage of inverse localization.
+ * This class is used in the first stage of inverse location.
* </p>
* @author Luc Maisonobe
*/
diff --git a/core/src/test/java/org/orekit/rugged/api/RuggedTest.java b/core/src/test/java/org/orekit/rugged/api/RuggedTest.java
index b6a46d3a..db6a506e 100644
--- a/core/src/test/java/org/orekit/rugged/api/RuggedTest.java
+++ b/core/src/test/java/org/orekit/rugged/api/RuggedTest.java
@@ -338,7 +338,7 @@ public class RuggedTest {
long t1 = System.currentTimeMillis();
int pixels = 0;
for (double line = firstLine; line < lastLine; line++) {
- GeodeticPoint[] gp = rugged.directLocalization("line", line);
+ GeodeticPoint[] gp = rugged.directLocation("line", line);
for (int i = 0; i < gp.length; ++i) {
final int latCode = (int) FastMath.rint(FastMath.scalb(gp[i].getLatitude(), 29));
final int lonCode = (int) FastMath.rint(FastMath.scalb(gp[i].getLongitude(), 29));
@@ -358,7 +358,7 @@ public class RuggedTest {
System.out.format(Locale.US,
"%n%n%5dx%5d:%n" +
" Orekit initialization and DEM creation : %5.1fs%n" +
- " direct localization and %3dM grid writing: %5.1fs (%.1f px/s)%n",
+ " direct location and %3dM grid writing: %5.1fs (%.1f px/s)%n",
lastLine - firstLine, los.size(),
1.0e-3 *(t1 - t0), sizeM, 1.0e-3 *(t2 - t1), pixels / (1.0e-3 * (t2 - t1)));
} catch (IOException ioe) {
@@ -419,11 +419,11 @@ public class RuggedTest {
rugged.setLightTimeCorrection(true);
rugged.setAberrationOfLightCorrection(false);
- GeodeticPoint[] gpWithLightTimeCorrection = rugged.directLocalization("line", 200);
+ GeodeticPoint[] gpWithLightTimeCorrection = rugged.directLocation("line", 200);
rugged.setLightTimeCorrection(false);
rugged.setAberrationOfLightCorrection(false);
- GeodeticPoint[] gpWithoutLightTimeCorrection = rugged.directLocalization("line", 200);
+ GeodeticPoint[] gpWithoutLightTimeCorrection = rugged.directLocation("line", 200);
for (int i = 0; i < gpWithLightTimeCorrection.length; ++i) {
Vector3D pWith = earth.transform(gpWithLightTimeCorrection[i]);
@@ -474,11 +474,11 @@ public class RuggedTest {
rugged.setLightTimeCorrection(false);
rugged.setAberrationOfLightCorrection(true);
- GeodeticPoint[] gpWithAberrationOfLightCorrection = rugged.directLocalization("line", 200);
+ GeodeticPoint[] gpWithAberrationOfLightCorrection = rugged.directLocation("line", 200);
rugged.setLightTimeCorrection(false);
rugged.setAberrationOfLightCorrection(false);
- GeodeticPoint[] gpWithoutAberrationOfLightCorrection = rugged.directLocalization("line", 200);
+ GeodeticPoint[] gpWithoutAberrationOfLightCorrection = rugged.directLocation("line", 200);
for (int i = 0; i < gpWithAberrationOfLightCorrection.length; ++i) {
Vector3D pWith = earth.transform(gpWithAberrationOfLightCorrection[i]);
@@ -529,7 +529,7 @@ public class RuggedTest {
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ruggedFull.addLineSensor(lineSensor);
- GeodeticPoint[] gpWithFlatBodyCorrection = ruggedFull.directLocalization("line", 100);
+ GeodeticPoint[] gpWithFlatBodyCorrection = ruggedFull.directLocation("line", 100);
Rugged ruggedFlat = new Rugged(updater, 8, AlgorithmId.DUVENHAGE_FLAT_BODY,
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
@@ -539,7 +539,7 @@ public class RuggedTest {
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ruggedFlat.addLineSensor(lineSensor);
- GeodeticPoint[] gpWithoutFlatBodyCorrection = ruggedFlat.directLocalization("line", 100);
+ GeodeticPoint[] gpWithoutFlatBodyCorrection = ruggedFlat.directLocation("line", 100);
SummaryStatistics stats = new SummaryStatistics();
for (int i = 0; i < gpWithFlatBodyCorrection.length; ++i) {
@@ -554,7 +554,7 @@ public class RuggedTest {
}
@Test
- public void testLocalizationsinglePoint()
+ public void testLocationsinglePoint()
throws RuggedException, OrekitException, URISyntaxException {
int dimension = 200;
@@ -593,11 +593,11 @@ public class RuggedTest {
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
rugged.addLineSensor(lineSensor);
- GeodeticPoint[] gpLine = rugged.directLocalization("line", 100);
+ GeodeticPoint[] gpLine = rugged.directLocation("line", 100);
for (int i = 0; i < gpLine.length; ++i) {
GeodeticPoint gpPixel =
- rugged.directLocalization(lineSensor.getDate(100), lineSensor.getPosition(),
+ rugged.directLocation(lineSensor.getDate(100), lineSensor.getPosition(),
lineSensor.getLos(lineSensor.getDate(100), i));
Assert.assertEquals(gpLine[i].getLatitude(), gpPixel.getLatitude(), 1.0e-10);
Assert.assertEquals(gpLine[i].getLongitude(), gpPixel.getLongitude(), 1.0e-10);
@@ -607,7 +607,7 @@ public class RuggedTest {
}
@Test
- public void testLocalizationsinglePointNoCorrections()
+ public void testLocationsinglePointNoCorrections()
throws RuggedException, OrekitException, URISyntaxException {
int dimension = 200;
@@ -648,11 +648,11 @@ public class RuggedTest {
rugged.setAberrationOfLightCorrection(false);
rugged.setLightTimeCorrection(false);
rugged.addLineSensor(lineSensor);
- GeodeticPoint[] gpLine = rugged.directLocalization("line", 100);
+ GeodeticPoint[] gpLine = rugged.directLocation("line", 100);
for (int i = 0; i < gpLine.length; ++i) {
GeodeticPoint gpPixel =
- rugged.directLocalization(lineSensor.getDate(100), lineSensor.getPosition(),
+ rugged.directLocation(lineSensor.getDate(100), lineSensor.getPosition(),
lineSensor.getLos(lineSensor.getDate(100), i));
Assert.assertEquals(gpLine[i].getLatitude(), gpPixel.getLatitude(), 1.0e-10);
Assert.assertEquals(gpLine[i].getLongitude(), gpPixel.getLongitude(), 1.0e-10);
@@ -701,7 +701,7 @@ public class RuggedTest {
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ruggedDuvenhage.addLineSensor(lineSensor);
- GeodeticPoint[] gpDuvenhage = ruggedDuvenhage.directLocalization("line", 100);
+ GeodeticPoint[] gpDuvenhage = ruggedDuvenhage.directLocation("line", 100);
Rugged ruggedBasicScan = new Rugged(updater, 8, AlgorithmId.BASIC_SLOW_EXHAUSTIVE_SCAN_FOR_TESTS_ONLY,
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
@@ -711,7 +711,7 @@ public class RuggedTest {
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ruggedBasicScan.addLineSensor(lineSensor);
- GeodeticPoint[] gpBasicScan = ruggedBasicScan.directLocalization("line", 100);
+ GeodeticPoint[] gpBasicScan = ruggedBasicScan.directLocation("line", 100);
for (int i = 0; i < gpDuvenhage.length; ++i) {
@@ -762,7 +762,7 @@ public class RuggedTest {
orbitToQ(orbit, earth, minDate.shiftedBy(-1.0), maxDate.shiftedBy(+1.0), 0.25), 2,
AngularDerivativesFilter.USE_R, 0.001);
ruggedOriginal.addLineSensor(lineSensor);
- GeodeticPoint[] gpOriginal = ruggedOriginal.directLocalization("line", 100);
+ GeodeticPoint[] gpOriginal = ruggedOriginal.directLocation("line", 100);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ruggedOriginal.dumpInterpolator(bos);
@@ -773,7 +773,7 @@ public class RuggedTest {
EllipsoidId.WGS84, InertialFrameId.EME2000, BodyRotatingFrameId.ITRF,
new ByteArrayInputStream(bos.toByteArray()));
ruggedRecovered.addLineSensor(lineSensor);
- GeodeticPoint[] gpRecovered = ruggedRecovered.directLocalization("line", 100);
+ GeodeticPoint[] gpRecovered = ruggedRecovered.directLocation("line", 100);
for (int i = 0; i < gpOriginal.length; ++i) {
Vector3D pOriginal = earth.transform(gpOriginal[i]);
@@ -976,7 +976,7 @@ public class RuggedTest {
// it is only used to check timings, and also creates a large (38M) temporary file
@Ignore
@Test
- public void testInverseLocalizationTiming()
+ public void testInverseLocationTiming()
throws RuggedException, OrekitException, URISyntaxException {
long t0 = System.currentTimeMillis();
@@ -1047,7 +1047,7 @@ public class RuggedTest {
}
for (int j = 0; j < dimension; ++j) {
double longitude = lon0 + (j * delta) / dimension;
- SensorPixel sp = rugged.inverseLocalization(lineSensor.getName(), latitude, longitude, 0, dimension);
+ SensorPixel sp = rugged.inverseLocation(lineSensor.getName(), latitude, longitude, 0, dimension);
if (sp == null) {
++badPixels;
buffer.putInt(-1);
@@ -1069,7 +1069,7 @@ public class RuggedTest {
System.out.format(Locale.US,
"%n%n%5dx%5d, %d sensors:%n" +
" Orekit initialization and DEM creation : %5.1fs%n" +
- " inverse localization and %3dM grid writing: %5.1fs (%.1f px/s, %.1f%% covered)%n",
+ " inverse location and %3dM grid writing: %5.1fs (%.1f px/s, %.1f%% covered)%n",
dimension, dimension, nbSensors,
1.0e-3 * (t1 - t0), sizeM, 1.0e-3 * (t2 - t1),
(badPixels + goodPixels) / (1.0e-3 * (t2 - t1)),
@@ -1080,21 +1080,21 @@ public class RuggedTest {
}
@Test
- public void testInverseLocalization()
+ public void testInverseLocation()
throws RuggedException, OrekitException, URISyntaxException {
- checkInverseLocalization(2000, false, false, 7.0e-6, 6.0e-6);
- checkInverseLocalization(2000, false, true, 1.0e-5, 8.0e-4);
- checkInverseLocalization(2000, true, false, 6.0e-6, 5.0e-3);
- checkInverseLocalization(2000, true, true, 8.0e-6, 9.0e-4);
+ checkInverseLocation(2000, false, false, 7.0e-6, 6.0e-6);
+ checkInverseLocation(2000, false, true, 1.0e-5, 8.0e-4);
+ checkInverseLocation(2000, true, false, 6.0e-6, 5.0e-3);
+ checkInverseLocation(2000, true, true, 8.0e-6, 9.0e-4);
}
@Test
- public void testDateLocalization()
+ public void testDateLocation()
throws RuggedException, OrekitException, URISyntaxException {
- checkDateLocalization(2000, false, false, 2.0e-8);
- checkDateLocalization(2000, false, true, 2.0e-8);
- checkDateLocalization(2000, true, false, 8.0e-9);
- checkDateLocalization(2000, true, true, 2.0e-8);
+ checkDateLocation(2000, false, false, 2.0e-8);
+ checkDateLocation(2000, false, true, 2.0e-8);
+ checkDateLocation(2000, true, false, 8.0e-9);
+ checkDateLocation(2000, true, true, 2.0e-8);
}
@Test
@@ -1176,19 +1176,19 @@ public class RuggedTest {
rugged.addLineSensor(lineSensor);
GeodeticPoint point1 = new GeodeticPoint(0.7053784581520293, -1.7354535645320581, 691.856741468848);
- SensorPixel sensorPixel1 = rugged.inverseLocalization(lineSensor.getName(), point1, 1, 131328);
+ SensorPixel sensorPixel1 = rugged.inverseLocation(lineSensor.getName(), point1, 1, 131328);
Assert.assertEquals( 2.01472, sensorPixel1.getLineNumber(), 1.0e-5);
Assert.assertEquals( 2.09271, sensorPixel1.getPixelNumber(), 1.0e-5);
GeodeticPoint point2 = new GeodeticPoint(0.704463899881073, -1.7303503789334154, 648.9200602492216);
- SensorPixel sensorPixel2 = rugged.inverseLocalization(lineSensor.getName(), point2, 1, 131328);
+ SensorPixel sensorPixel2 = rugged.inverseLocation(lineSensor.getName(), point2, 1, 131328);
Assert.assertEquals( 2.02184, sensorPixel2.getLineNumber(), 1.0e-5);
Assert.assertEquals( 27.53008, sensorPixel2.getPixelNumber(), 1.0e-5);
GeodeticPoint point3 = new GeodeticPoint(0.7009593480939814, -1.7314283804521957, 588.3075485689468);
- SensorPixel sensorPixel3 = rugged.inverseLocalization(lineSensor.getName(), point3, 1, 131328);
+ SensorPixel sensorPixel3 = rugged.inverseLocation(lineSensor.getName(), point3, 1, 131328);
Assert.assertEquals(2305.26174, sensorPixel3.getLineNumber(), 1.0e-5);
Assert.assertEquals( 27.18381, sensorPixel3.getPixelNumber(), 1.0e-5);
GeodeticPoint point4 = new GeodeticPoint(0.7018731669637096, -1.73651769725183, 611.2759403696498);
- SensorPixel sensorPixel4 = rugged.inverseLocalization(lineSensor.getName(), point4, 1, 131328);
+ SensorPixel sensorPixel4 = rugged.inverseLocation(lineSensor.getName(), point4, 1, 131328);
Assert.assertEquals(2305.25506, sensorPixel4.getLineNumber(), 1.0e-5);
Assert.assertEquals( 1.54447, sensorPixel4.getPixelNumber(), 1.0e-5);
@@ -1302,17 +1302,17 @@ public class RuggedTest {
LineSensor lineSensor = new LineSensor("QUICK_LOOK", lineDatation, offset, lineOfSight);
rugged.addLineSensor(lineSensor);
- GeodeticPoint[] temp = rugged.directLocalization("QUICK_LOOK", -250);
+ GeodeticPoint[] temp = rugged.directLocation("QUICK_LOOK", -250);
GeodeticPoint first = temp[0];
double minLon = first.getLongitude();
double minLat = first.getLatitude();
- temp = rugged.directLocalization("QUICK_LOOK", 350);
+ temp = rugged.directLocation("QUICK_LOOK", 350);
GeodeticPoint last = temp[temp.length - 1];
double maxLon = last.getLongitude();
double maxLat = last.getLatitude();
GeodeticPoint gp = new GeodeticPoint((minLat + maxLat) / 2d, (minLon + maxLon) / 2d, 0d);
- SensorPixel sensorPixel = rugged.inverseLocalization("QUICK_LOOK", gp, -250, 350);
+ SensorPixel sensorPixel = rugged.inverseLocation("QUICK_LOOK", gp, -250, 350);
Assert.assertNotNull(sensorPixel);
@@ -1361,9 +1361,9 @@ public class RuggedTest {
rugged.addLineSensor(lineSensor);
int lineNumber = 97;
- GeodeticPoint[] gp = rugged.directLocalization("curved", lineNumber);
+ GeodeticPoint[] gp = rugged.directLocation("curved", lineNumber);
for (int i = 0; i < gp.length; ++i) {
- SensorPixel pixel = rugged.inverseLocalization("curved", gp[i], firstLine, lastLine);
+ SensorPixel pixel = rugged.inverseLocation("curved", gp[i], firstLine, lastLine);
Assert.assertEquals(lineNumber, pixel.getLineNumber(), 1.5e-7);
Assert.assertEquals(i, pixel.getPixelNumber(), 3.1e-7);
}
@@ -1393,7 +1393,7 @@ public class RuggedTest {
satelliteQList.add(pair);
}
- private void checkInverseLocalization(int dimension, boolean lightTimeCorrection, boolean aberrationOfLightCorrection,
+ private void checkInverseLocation(int dimension, boolean lightTimeCorrection, boolean aberrationOfLightCorrection,
double maxLineError, double maxPixelError)
throws RuggedException, OrekitException, URISyntaxException {
@@ -1436,12 +1436,12 @@ public class RuggedTest {
rugged.addLineSensor(lineSensor);
double referenceLine = 0.87654 * dimension;
- GeodeticPoint[] gp = rugged.directLocalization("line", referenceLine);
+ GeodeticPoint[] gp = rugged.directLocation("line", referenceLine);
for (double p = 0; p < gp.length - 1; p += 1.0) {
int i = (int) FastMath.floor(p);
double d = p - i;
- SensorPixel sp = rugged.inverseLocalization("line",
+ SensorPixel sp = rugged.inverseLocation("line",
(1 - d) * gp[i].getLatitude() + d * gp[i + 1].getLatitude(),
(1 - d) * gp[i].getLongitude() + d * gp[i + 1].getLongitude(),
0, dimension);
@@ -1450,36 +1450,36 @@ public class RuggedTest {
}
// point out of line (20 pixels before first pixel)
- Assert.assertNull(rugged.inverseLocalization("line",
+ Assert.assertNull(rugged.inverseLocation("line",
21 * gp[0].getLatitude() - 20 * gp[1].getLatitude(),
21 * gp[0].getLongitude() - 20 * gp[1].getLongitude(),
0, dimension));
// point out of line (20 pixels after last pixel)
- Assert.assertNull(rugged.inverseLocalization("line",
+ Assert.assertNull(rugged.inverseLocation("line",
-20 * gp[gp.length - 2].getLatitude() + 21 * gp[gp.length - 1].getLatitude(),
-20 * gp[gp.length - 2].getLongitude() + 21 * gp[gp.length - 1].getLongitude(),
0, dimension));
// point out of line (20 lines before first line)
- GeodeticPoint[] gp0 = rugged.directLocalization("line", 0);
- GeodeticPoint[] gp1 = rugged.directLocalization("line", 1);
- Assert.assertNull(rugged.inverseLocalization("line",
+ GeodeticPoint[] gp0 = rugged.directLocation("line", 0);
+ GeodeticPoint[] gp1 = rugged.directLocation("line", 1);
+ Assert.assertNull(rugged.inverseLocation("line",
21 * gp0[dimension / 2].getLatitude() - 20 * gp1[dimension / 2].getLatitude(),
21 * gp0[dimension / 2].getLongitude() - 20 * gp1[dimension / 2].getLongitude(),
0, dimension));
// point out of line (20 lines after last line)
- GeodeticPoint[] gp2 = rugged.directLocalization("line", dimension - 2);
- GeodeticPoint[] gp3 = rugged.directLocalization("line", dimension - 1);
- Assert.assertNull(rugged.inverseLocalization("line",
+ GeodeticPoint[] gp2 = rugged.directLocation("line", dimension - 2);
+ GeodeticPoint[] gp3 = rugged.directLocation("line", dimension - 1);
+ Assert.assertNull(rugged.inverseLocation("line",
-20 * gp2[dimension / 2].getLatitude() + 21 * gp3[dimension / 2].getLatitude(),
-20 * gp2[dimension / 2].getLongitude() + 21 * gp3[dimension / 2].getLongitude(),
0, dimension));
}
- private void checkDateLocalization(int dimension, boolean lightTimeCorrection, boolean aberrationOfLightCorrection,
+ private void checkDateLocation(int dimension, boolean lightTimeCorrection, boolean aberrationOfLightCorrection,
double maxDateError)
throws RuggedException, OrekitException, URISyntaxException {
@@ -1522,12 +1522,12 @@ public class RuggedTest {
rugged.addLineSensor(lineSensor);
double referenceLine = 0.87654 * dimension;
- GeodeticPoint[] gp = rugged.directLocalization("line", referenceLine);
+ GeodeticPoint[] gp = rugged.directLocation("line", referenceLine);
for (double p = 0; p < gp.length - 1; p += 1.0) {
int i = (int) FastMath.floor(p);
double d = p - i;
- AbsoluteDate date = rugged.dateLocalization("line",
+ AbsoluteDate date = rugged.dateLocation("line",
(1 - d) * gp[i].getLatitude() + d * gp[i + 1].getLatitude(),
(1 - d) * gp[i].getLongitude() + d * gp[i + 1].getLongitude(),
0, dimension);
@@ -1535,17 +1535,17 @@ public class RuggedTest {
}
// point out of line (20 lines before first line)
- GeodeticPoint[] gp0 = rugged.directLocalization("line", 0);
- GeodeticPoint[] gp1 = rugged.directLocalization("line", 1);
- Assert.assertNull(rugged.dateLocalization("line",
+ GeodeticPoint[] gp0 = rugged.directLocation("line", 0);
+ GeodeticPoint[] gp1 = rugged.directLocation("line", 1);
+ Assert.assertNull(rugged.dateLocation("line",
21 * gp0[dimension / 2].getLatitude() - 20 * gp1[dimension / 2].getLatitude(),
21 * gp0[dimension / 2].getLongitude() - 20 * gp1[dimension / 2].getLongitude(),
0, dimension));
// point out of line (20 lines after last line)
- GeodeticPoint[] gp2 = rugged.directLocalization("line", dimension - 2);
- GeodeticPoint[] gp3 = rugged.directLocalization("line", dimension - 1);
- Assert.assertNull(rugged.dateLocalization("line",
+ GeodeticPoint[] gp2 = rugged.directLocation("line", dimension - 2);
+ GeodeticPoint[] gp3 = rugged.directLocation("line", dimension - 1);
+ Assert.assertNull(rugged.dateLocation("line",
-20 * gp2[dimension / 2].getLatitude() + 21 * gp3[dimension / 2].getLatitude(),
-20 * gp2[dimension / 2].getLongitude() + 21 * gp3[dimension / 2].getLongitude(),
0, dimension));
diff --git a/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java b/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java
index b19a9d20..d906f179 100644
--- a/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java
+++ b/core/src/test/java/org/orekit/rugged/intersection/AbstractAlgorithmTest.java
@@ -83,7 +83,7 @@ public abstract class AbstractAlgorithmTest {
Assert.assertEquals(-87754.914, pointInSpacecraftFrame.getY(), 1.0e-3);
Assert.assertEquals(790330.254, pointInSpacecraftFrame.getZ(), 1.0e-3);
- // test direct localization
+ // test direct location
Vector3D position = state.getPVCoordinates(earth.getBodyFrame()).getPosition();
Vector3D los = groundP.subtract(position);
GeodeticPoint result = algorithm.refineIntersection(earth, position, los,
@@ -109,7 +109,7 @@ public abstract class AbstractAlgorithmTest {
final IntersectionAlgorithm algorithm = createAlgorithm(updater, 8);
- // test direct localization
+ // test direct location
Vector3D position = state.getPVCoordinates(earth.getBodyFrame()).getPosition();
Vector3D los = groundP.subtract(position);
GeodeticPoint result = algorithm.refineIntersection(earth, position, los,
diff --git a/design/direct-localization-class-diagram.puml b/design/direct-location-class-diagram.puml
similarity index 98%
rename from design/direct-localization-class-diagram.puml
rename to design/direct-location-class-diagram.puml
index f49203d8..945487f2 100644
--- a/design/direct-localization-class-diagram.puml
+++ b/design/direct-location-class-diagram.puml
@@ -56,7 +56,7 @@
package api #DDEBD8 {
class Rugged {
- +directLocalization(sensorName, line)
+ +directLocation(sensorName, line)
}
class LineSensor
IntersectionAlgorithm "1" <--o Rugged : delegate DEM intersection
diff --git a/design/direct-localization-sequence-diagram.puml b/design/direct-location-sequence-diagram.puml
similarity index 98%
rename from design/direct-localization-sequence-diagram.puml
rename to design/direct-location-sequence-diagram.puml
index fd9b6f95..5c71b443 100644
--- a/design/direct-localization-sequence-diagram.puml
+++ b/design/direct-location-sequence-diagram.puml
@@ -41,7 +41,7 @@
participant "Tile" as T
activate A
- A -> R : directLocalization(name, number)
+ A -> R : directLocation(name, number)
activate R
R -> LS : apply time stamping model
R -> S : get transforms at line date
diff --git a/design/inverse-localization-sequence-diagram.puml b/design/inverse-location-sequence-diagram.puml
similarity index 98%
rename from design/inverse-localization-sequence-diagram.puml
rename to design/inverse-location-sequence-diagram.puml
index bb279864..82304f69 100644
--- a/design/inverse-localization-sequence-diagram.puml
+++ b/design/inverse-location-sequence-diagram.puml
@@ -42,7 +42,7 @@
participant "Math" as M
activate A
- A -> R : inverseLocalization
+ A -> R : inverseLocation
activate R
R -> P : getMeanPlaneFinder
activate P
@@ -51,7 +51,7 @@
transforms are computed
only once and reused
across successive inverse
- localization calls
+ location calls
end note
activate S
S -> T : create
diff --git a/pom.xml b/pom.xml
index 3b84396d..f2195ea9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -19,24 +19,24 @@
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<maven.compiler.source>1.6</maven.compiler.source>
<maven.compiler.target>1.6</maven.compiler.target>
- <rugged.maven-compiler-plugin.version>3.1</rugged.maven-compiler-plugin.version>
- <rugged.maven-jar-plugin.version>2.4</rugged.maven-jar-plugin.version>
- <rugged.maven-assembly-plugin.version>2.4</rugged.maven-assembly-plugin.version>
- <rugged.maven-bundle-plugin.version>2.4.0</rugged.maven-bundle-plugin.version>
- <rugged.maven-resources-plugin.version>2.6</rugged.maven-resources-plugin.version>
- <rugged.maven-clean-plugin.version>2.5</rugged.maven-clean-plugin.version>
- <rugged.jacoco-maven-plugin.version>0.7.1.201405082137</rugged.jacoco-maven-plugin.version>
+ <rugged.maven-compiler-plugin.version>3.2</rugged.maven-compiler-plugin.version>
+ <rugged.maven-jar-plugin.version>2.5</rugged.maven-jar-plugin.version>
+ <rugged.maven-assembly-plugin.version>2.5.1</rugged.maven-assembly-plugin.version>
+ <rugged.maven-bundle-plugin.version>2.5.3</rugged.maven-bundle-plugin.version>
+ <rugged.maven-resources-plugin.version>2.7</rugged.maven-resources-plugin.version>
+ <rugged.maven-clean-plugin.version>2.6.1</rugged.maven-clean-plugin.version>
+ <rugged.jacoco-maven-plugin.version>0.7.2.201409121644</rugged.jacoco-maven-plugin.version>
<rugged.maven-plantuml-plugin.version>7940</rugged.maven-plantuml-plugin.version>
<rugged.plantuml.version>7999</rugged.plantuml.version>
- <rugged.maven-site-plugin.version>3.3</rugged.maven-site-plugin.version>
- <rugged.findbugs-maven-plugin.version>2.5.3</rugged.findbugs-maven-plugin.version>
- <rugged.maven-surefire-plugin.version>2.17</rugged.maven-surefire-plugin.version>
- <rugged.maven-surefire-report-plugin.version>2.17</rugged.maven-surefire-report-plugin.version>
- <rugged.maven-checkstyle-plugin.version>2.12.1</rugged.maven-checkstyle-plugin.version>
- <rugged.maven-changes-plugin.version>2.10</rugged.maven-changes-plugin.version>
- <rugged.maven-jxr-plugin.version>2.4</rugged.maven-jxr-plugin.version>
- <rugged.maven-javadoc-plugin.version>2.9.1</rugged.maven-javadoc-plugin.version>
- <rugged.maven-source-plugin.version>2.2.1</rugged.maven-source-plugin.version>
+ <rugged.maven-site-plugin.version>3.4</rugged.maven-site-plugin.version>
+ <rugged.findbugs-maven-plugin.version>3.0.0</rugged.findbugs-maven-plugin.version>
+ <rugged.maven-surefire-plugin.version>2.18</rugged.maven-surefire-plugin.version>
+ <rugged.maven-surefire-report-plugin.version>2.18</rugged.maven-surefire-report-plugin.version>
+ <rugged.maven-checkstyle-plugin.version>2.13</rugged.maven-checkstyle-plugin.version>
+ <rugged.maven-changes-plugin.version>2.11</rugged.maven-changes-plugin.version>
+ <rugged.maven-jxr-plugin.version>2.5</rugged.maven-jxr-plugin.version>
+ <rugged.maven-javadoc-plugin.version>2.10.1</rugged.maven-javadoc-plugin.version>
+ <rugged.maven-source-plugin.version>2.4</rugged.maven-source-plugin.version>
<rugged.maven-project-info-reports-plugin.version>2.7</rugged.maven-project-info-reports-plugin.version>
</properties>
diff --git a/src/site/markdown/design/digital-elevation-model.md b/src/site/markdown/design/digital-elevation-model.md
index 47f8336e..153cef8b 100644
--- a/src/site/markdown/design/digital-elevation-model.md
+++ b/src/site/markdown/design/digital-elevation-model.md
@@ -47,7 +47,7 @@ DEM loading
As the min/max KD-tree structure is specific to the Duvenhage algorithm, and as the algorithm is hidden behind
a generic interface, the tree remains an implementation detail the user should not see. The min/max KD-tree structure is
-therefore built directly at Rugged level, only when the Duvenhage algorithm has been selected to perform localization computation.
+therefore built directly at Rugged level, only when the Duvenhage algorithm has been selected to perform location computation.
On the other hand, Rugged is not expected to parsed DEM files, so the algorithm relies on the raw data being passed by the upper
layer. In order to pass these data, a specific callback function is implemented in the mission specific interface layer and
diff --git a/src/site/markdown/design/overview.md b/src/site/markdown/design/overview.md
index c2d53850..0ffb4943 100644
--- a/src/site/markdown/design/overview.md
+++ b/src/site/markdown/design/overview.md
@@ -55,8 +55,8 @@ The following table sorts out the various topics between the various layers.
| Topic | Layer | Comment
|----------------------------------|-------------------------|-----------------------------------------------------------------------------
-| Sensor to ground mapping | Rugged | Direct localization is the base feature provided
-| Ground to sensor mapping | Rugged | Inverse localization is another base feature provided
+| Sensor to ground mapping | Rugged | Direct location is the base feature provided
+| Ground to sensor mapping | Rugged | Inverse location is another base feature provided
| Individual pixels | Rugged |The API supports any number of pixels, defined by their individual line of sight provided by caller
| Optical path | Interface |The folded optical path inside the spacecraft is taken into account by computing an overall transform combining all inside reflections, so each pixel position and line of sight can be computed later on by a single translation and rotation with respect to spacecraft center of mass
| Line time-stamping | Interface/Rugged |The caller must provide a simple time-stamping model (typically linear) that will be applied
diff --git a/src/site/markdown/design/preliminary-design.md b/src/site/markdown/design/preliminary-design.md
index c09c3d64..519c0918 100644
--- a/src/site/markdown/design/preliminary-design.md
+++ b/src/site/markdown/design/preliminary-design.md
@@ -19,7 +19,7 @@ The top level design describes the various libraries and their interactions. The
corresponding to the Apache Commons Math library is not shown here for clarity.
The following sequence and class diagrams show the three most important functions: initialization
-of the libraries, direct localization and inverse localization.
+of the libraries, direct location and inverse location.
### Initialization
@@ -41,9 +41,9 @@ two different sensors are expected to be accurately combined.
-### Direct localization
+### Direct location
-Direct localization is called a large number of times by the application, once for each sensor line.
+Direct location is called a large number of times by the application, once for each sensor line.
The application only provides image processing related data to the configured Rugged instance, i.e. the
line number, and it expects the geodetic coordinates of the ground points corresponding to each pixels
in the sensor line. The Rugged instance will delegate conversions between frames to an internal
@@ -51,7 +51,7 @@ SpacecraftToObservedBody converter, the conversions between Cartesian coordinate
to an internal ExtendedEllipsoid object, and the computation of the intersection with the Digital Elevation
Model to the algorithm that was selected by user at configuration time.
-
+
The pixels independent computation (orbit and attitude interpolation, Earth frame to inertial frame transforms,
transforms composition) are performed only once per date inside the caching combined transform provider set up
@@ -63,7 +63,7 @@ and followed by the Digital Elevation Model intersection. The callback to the mi
retrieve DEM raw data is called from the inner loop but is expected to be triggered only infrequently thanks to a
caching feature done at Rugged library level.
-
+
The following figure describes the algorithm used for tile selection and how the underlying intersection algorithm
(Duvenhage in this example) is called for one tile:
@@ -75,16 +75,16 @@ describes how it is implemented in the Rugged library.
-### Inverse localization
+### Inverse location
-Inverse localization is called a large number of times by the application, typically on a regular grid in some
+Inverse location is called a large number of times by the application, typically on a regular grid in some
geographic reference like UTM. The application only provides image processing related data, i.e. the geodetic
coordinates of the ground points and expects the coordinates of the corresponding pixel (both line number of
pixel number). The pixels independent computation (orbit and attitude interpolation, Earth frame to inertial
frame transforms, transforms composition) are performed only once per line and cached across successive calls to
-inverse localization, thus greatly improving performances.
+inverse location, thus greatly improving performances.
-
+
The computation is performed in several steps. The line to which the points belong is first searched using a dedicated
solver taking advantage of the first time derivatives automatically included in Orekit transforms. It can therefore set
diff --git a/src/site/markdown/index.md b/src/site/markdown/index.md
index 9c9d55ec..e4b0bfba 100644
--- a/src/site/markdown/index.md
+++ b/src/site/markdown/index.md
@@ -19,7 +19,7 @@ Overview
contribution to line of sight computation. It is a free software
intermediate-level library written in Java.
- It mainly provides direct and inverse localization, i.e. it allows
+ It mainly provides direct and inverse location, i.e. it allows
to compute accurately which ground point is looked at from a specific
pixel in a spacecraft instrument, and conversely which pixel will
see a specified ground point. This mapping between ground and sensor
@@ -28,13 +28,13 @@ Overview
on-board sensor pixels individual line-of-sights, spacecraft motion and
attitude and several physical effects.
- Direct and inverse localization can be used to perform full ortho-rectification
+ Direct and inverse location can be used to perform full ortho-rectification
of images and correlation between sensors observing the same area.
Features
--------
- * Direct/inverse localization
+ * Direct/inverse location
* can support several types of Digital Elevation Models, including user-provided models
diff --git a/src/site/markdown/tutorials/direct-localization.md b/src/site/markdown/tutorials/direct-location.md
similarity index 98%
rename from src/site/markdown/tutorials/direct-localization.md
rename to src/site/markdown/tutorials/direct-location.md
index f2da7b7e..cb6cce46 100644
--- a/src/site/markdown/tutorials/direct-localization.md
+++ b/src/site/markdown/tutorials/direct-location.md
@@ -12,7 +12,7 @@
limitations under the License.
-->
-# Rugged initialization and direct localization
+# Rugged initialization and direct location
This tutorial explains how to initialize Rugged and use it to geolocate a satellite image.
Let's imagine the sensor is a single line imager with 2000 pixels and 20° field of view,
@@ -206,7 +206,7 @@ The next 3 arguments defines the ellipsoid and the reference frames: `EllipsoidI
On the third line, we find the time interval of the acquisition: acquisitionStartDate, acquisitionStopDate,
timeTolerance (margin allowed for extrapolation, in seconds). This is an important information as Rugged
will pre-compute a lot of stuff at initialization in order to optimize further calls to the direct and
-inverse localization functions.
+inverse location functions.
On the fourth line, the arguments are the list of time-stamped positions and velocities as well as options
for interpolation: number of points to use and type of filter for derivatives. We find the same arguments
@@ -219,7 +219,7 @@ The sensor models are added after initialization. We can add as many as we want.
-## Direct localization
+## Direct location
Finally everything is set to do some real work. Let's try to locate a point on Earth
@@ -228,7 +228,7 @@ Upper left point (first line, first pixel):
Vector3D position = lineSensor.getPosition(); // This returns a zero vector since we set the relative position of the sensor w.r.T the satellite to 0.
AbsoluteDate firstLineDate = lineSensor.getDate(1);
Vector3D los = lineSensor.getLos(firstLineDate, 0);
- GeodeticPoint upLeftPoint = rugged.directLocalization(firstLineDate, position, los);
+ GeodeticPoint upLeftPoint = rugged.directLocation(firstLineDate, position, los);
The results are ....
diff --git a/src/site/site.xml b/src/site/site.xml
index ea923be1..77decb66 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -43,7 +43,7 @@
<item name="Preliminary design" href="/design/preliminary-design.html" />
</menu>
<menu name="Tutorials">
- <item name="Direct localization" href="/tutorials/direct-localization.html" />
+ <item name="Direct location" href="/tutorials/direct-location.html" />
</menu>
<menu name="Development">
<item name="Contributing" href="/contributing.html" />
diff --git a/src/site/xdoc/changes.xml b/src/site/xdoc/changes.xml
index 9cafc4e6..bed361b5 100644
--- a/src/site/xdoc/changes.xml
+++ b/src/site/xdoc/changes.xml
@@ -59,7 +59,7 @@
Moved TileUpdate to raster package.
</action>
<action dev="luc" type="update">
- Finalized direct localization diagrams.
+ Finalized direct location diagrams.
</action>
<action dev="luc" type="update">
renamed core package into intersection.
@@ -86,21 +86,21 @@
Improved performance.
</action>
<action dev="luc" type="update">
- Disabled timing test for inverse localization.
+ Disabled timing test for inverse location.
</action>
<action dev="luc" type="update">
- Improved inverse localization speed again!
+ Improved inverse location speed again!
</action>
<action dev="luc" type="update">
- Added inverse localization from latitude and longitude only.
+ Added inverse location from latitude and longitude only.
When only latitude and longitude are specified, the elevation is
automatically computed from the Digital Elevation Model.
</action>
<action dev="luc" type="update">
- Simplified direct localization.
+ Simplified direct location.
</action>
<action dev="luc" type="update">
- Improved inverse localization performances.
+ Improved inverse location performances.
</action>
<action dev="luc" type="update">
Added rate to the LineDatation interface.
@@ -114,7 +114,7 @@
once.
</action>
<action dev="luc" type="fix">
- First working version of inverse localization.
+ First working version of inverse location.
</action>
<action dev="luc" type="update">
Streamlined line sensor model.
@@ -161,15 +161,15 @@
Remove check for context, which is ensured since construction.
</action>
<action dev="luc" type="update">
- Improved speed of inverse localization test.
+ Improved speed of inverse location test.
</action>
<action dev="luc" type="fix">
- First working version of inverse localization.
+ First working version of inverse location.
It works in simple cases (no light time correction and no aberration of
light correction), and is still really slow.
</action>
<action dev="luc" type="add">
- Started implementation of inverse localization (not working yet).
+ Started implementation of inverse location (not working yet).
</action>
<action dev="luc" type="update">
Removed a check that is not needed anymore.
@@ -187,7 +187,7 @@
</action>
<action dev="luc" type="update">
Added automatic mean plane computation for line sensors.
- This will allow implementing inverse localization.
+ This will allow implementing inverse location.
</action>
<action dev="luc" type="update">
Allow direct use of Orekit inertial frames and ellipsoids.
@@ -253,7 +253,7 @@
Added writing of grid file to full test.
</action>
<action dev="luc" type="update">
- Don't use a numerical propagator within direct localization.
+ Don't use a numerical propagator within direct location.
As the time between each line is really small (milliseconds), it is
better to propagate first and use an ephemeris later.
</action>
@@ -278,7 +278,7 @@
below min elevation so the intersection should be really on the line.
</action>
<action dev="luc" type="update">
- Greatly improved accuracy of direct localization.
+ Greatly improved accuracy of direct location.
There were some small errors (at centimeter level) as result points may
be slightly out of line of sight. These errors seemed to be due to the
final linear line-of-sight model that is used at pixel level.
@@ -418,7 +418,7 @@
Line numbers are double.
</action>
<action dev="luc" type="add">
- Started implementation of direct localization ...
+ Started implementation of direct location ...
</action>
<action dev="luc" type="update">
Added a protection against unknown sensors.
@@ -478,7 +478,7 @@
Extract an AbstractTile from SimpleTile
</action>
<action dev="luc" type="update">
- Added a simple container for inverse localization result.
+ Added a simple container for inverse location result.
</action>
<action dev="luc" type="update">
Expanded API.
--
GitLab