diff --git a/aster/pom.xml b/aster/pom.xml
index c7b509936b9488f2af11136264cc22743120ce10..6ea13f95f430d22ec488ea78179b7b0ef083ad16 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 e7bdde20bdcadd6b5b5557348c23fdc88fb169fa..ca32b3ba7f361ae62baab009cc5639311cb061f5 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 a23434968881cea9d535c2e3d7215dc2f074be5a..389bc2abd2fde1c95e1f5b07d379e124292cbd37 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 157cbb1c1f67a786cd4443976c9198c5305a964f..8325b951a587df72d804e5f9f8933ffbbca7e38d 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 b6a46d3a1287b66d6e29bbb81b4a5383312d7a92..db6a506e5977397986a31fcfcef481c4b4e4c358 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 b19a9d207207445e52f32208c9e31ab1430e943b..d906f179ea5c01d4d82dfca37c6b15fd7236e56b 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 f49203d89438e3bc3e8dc3d79a94dd110c3f241d..945487f25a8868a3ad4c28d056b9728be2b13be6 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 fd9b6f9597b37654079c044895aa1680a28545b5..5c71b443aeaa4211d3fd11e5eabe4c790fba622b 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 bb279864b06484772ac41eceac20685afefaa6ee..82304f692885344ea0c7a924cf9c13fcdfc80b02 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 3b84396df3e9daada1a81890f30c52f4c588f209..f2195ea98e43610fb2cea4541fca215e10477def 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 47f8336e63b6a637c6d3f000d6a12f955a39a0f3..153cef8b4b9ac74c626f56a5c3cbe8bee8bf0b74 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 c2d53850d7890260bf43ea151839976145e1d6f7..0ffb4943fb6bfb2ee8cc45c0995a077b196e70ca 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 c09c3d64358b6efea4b69d487fa7593d95421a5b..519c091837293514d5d9be0a22c993753853a249 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 9c9d55ecbe49c4f1b22036febcef11f43dbe8bf7..e4b0bfbaa133fe3bbe8b237d9e5b8e91675b40e5 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 f2da7b7ef008519515d4b32c49f8d1cb29962b4a..cb6cce4630f926e02863d282c038c26dfd2bbd1a 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 ea923be1796244dee01dddf1602b6e55b9c3878b..77decb66491f96862f5e9d0bca1d0f310aeaba37 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 9cafc4e6961f80eaa30af1ef0a158bf5fc7ccc0d..bed361b5add60218102c0de703eb66783aa1ee55 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.