diff --git a/src/main/java/org/orekit/rugged/api/Rugged.java b/src/main/java/org/orekit/rugged/api/Rugged.java
index 10c3af12d36f91fa8ffab48eaf5a93c198e7a8e0..7b9880348201614da7ba2ef8097eef74155f0687 100644
--- a/src/main/java/org/orekit/rugged/api/Rugged.java
+++ b/src/main/java/org/orekit/rugged/api/Rugged.java
@@ -340,6 +340,7 @@ public class Rugged {
* we consider each pixel to be at sensor position
* @param pixelLOS pixel definition with normalized line-of-sight in spacecraft frame
* @return ground position of intersection point between specified los and ground
+ * @since 2.1
*/
public GeodeticPoint directLocation(final AbsoluteDate date, final Vector3D sensorPosition, final PixelLOS pixelLOS) {
@@ -642,7 +643,7 @@ public class Rugged {
* @param sensor the line sensor
* @param planeCrossing the sensor mean plane crossing
* @return the sensor pixel crossing or null if cannot be found
- * @since 3.0
+ * @since 2.1
*/
private SensorPixel findSensorPixelWithoutAtmosphere(final GeodeticPoint point,
final LineSensor sensor, final SensorMeanPlaneCrossing planeCrossing) {
@@ -706,7 +707,7 @@ public class Rugged {
* @param minLine minimum line number where the search will be performed
* @param maxLine maximum line number where the search will be performed
* @return the sensor pixel crossing or null if cannot be found
- * @since 3.0
+ * @since 2.1
*/
private SensorPixel findSensorPixelWithAtmosphere(final GeodeticPoint point,
final LineSensor sensor, final int minLine, final int maxLine) {
@@ -725,7 +726,7 @@ public class Rugged {
// Definition of a regular grid (at sensor level)
atmosphericRefraction.configureCorrectionGrid(sensor, minLine, maxLine);
- // Get the grid knots
+ // Get the grid nodes
final int nbPixelGrid = atmosphericRefraction.getComputationParameters().getNbPixelGrid();
final int nbLineGrid = atmosphericRefraction.getComputationParameters().getNbLineGrid();
final double[] pixelGrid = atmosphericRefraction.getComputationParameters().getUgrid();
@@ -735,9 +736,9 @@ public class Rugged {
// (full computation)
atmosphericRefraction.reactivateComputation();
final GeodeticPoint[][] geodeticGridWithAtmosphere = computeDirectLocOnGridWithAtmosphere(pixelGrid, lineGrid, sensor);
- // pixelGrid and lineGrid are the knots where the direct loc is computed WITH atmosphere
+ // pixelGrid and lineGrid are the nodes where the direct loc is computed WITH atmosphere
- // Computation of the inverse location WITHOUT atmospheric refraction for the grid knots
+ // Computation of the inverse location WITHOUT atmospheric refraction for the grid nodes
atmosphericRefraction.deactivateComputation();
final SensorPixel[][] sensorPixelGridInverseWithout = computeInverseLocOnGridWithoutAtmosphere(geodeticGridWithAtmosphere,
nbPixelGrid, nbLineGrid, sensor, minLine, maxLine);
@@ -794,14 +795,15 @@ public class Rugged {
}
/** Compute the inverse location WITHOUT atmospheric refraction for the geodetic points
- * associated to the sensor grid knots.
- * @param groundGridWithAtmosphere ground grid found for sensor grid knots with atmosphere
+ * associated to the sensor grid nodes.
+ * @param groundGridWithAtmosphere ground grid found for sensor grid nodes with atmosphere
* @param nbPixelGrid size of the pixel grid
* @param nbLineGrid size of the line grid
* @param sensor the line sensor
* @param minLine minimum line number where the search will be performed
* @param maxLine maximum line number where the search will be performed
* @return the sensor pixel grid computed without atmosphere
+ * @since 2.1
*/
private SensorPixel[][] computeInverseLocOnGridWithoutAtmosphere(final GeodeticPoint[][] groundGridWithAtmosphere,
final int nbPixelGrid, final int nbLineGrid,
@@ -812,6 +814,7 @@ public class Rugged {
for (int uIndex = 0; uIndex < nbPixelGrid; uIndex++) {
for (int vIndex = 0; vIndex < nbLineGrid; vIndex++) {
+
// Check if the geodetic point exists
if (groundGridWithAtmosphere[uIndex][vIndex] != null) {
final GeodeticPoint groundPoint = groundGridWithAtmosphere[uIndex][vIndex];
@@ -819,15 +822,16 @@ public class Rugged {
final double currentLon = groundPoint.getLongitude();
try {
+ // Compute the inverse location for the current node
sensorPixelGrid[uIndex][vIndex] = inverseLocation(sensorName, currentLat, currentLon, minLine, maxLine);
- // Check if the pixel is inside the sensor
- if (sensorPixelGrid[uIndex][vIndex] != null &&
- (sensorPixelGrid[uIndex][vIndex].getPixelNumber() < (-INVLOC_MARGIN) ||
- sensorPixelGrid[uIndex][vIndex].getPixelNumber() > (INVLOC_MARGIN + sensor.getNbPixels() - 1)) ) {
- // Impossible to find the point in the given min line and max line
- throw new RuggedException(RuggedMessages.INVALID_RANGE_FOR_LINES, minLine, maxLine, "");
- } else if (sensorPixelGrid[uIndex][vIndex] == null) {
+ // Check if the pixel is inside the sensor (with a margin) OR if the inverse location was impossible (null result)
+ if ((sensorPixelGrid[uIndex][vIndex] != null &&
+ (sensorPixelGrid[uIndex][vIndex].getPixelNumber() < (-INVLOC_MARGIN) ||
+ sensorPixelGrid[uIndex][vIndex].getPixelNumber() > (INVLOC_MARGIN + sensor.getNbPixels() - 1)))
+ || (sensorPixelGrid[uIndex][vIndex] == null) ) {
+
+ // Impossible to find the point in the given min line
throw new RuggedException(RuggedMessages.INVALID_RANGE_FOR_LINES, minLine, maxLine, "");
}
} catch (RuggedException re) { // This should never happen
@@ -835,10 +839,14 @@ public class Rugged {
}
} else { // groundGrid[uIndex][vIndex] == null: impossible to compute inverse loc because ground point not defined
+
sensorPixelGrid[uIndex][vIndex] = null;
+
} // groundGrid[uIndex][vIndex] != null
} // end loop vIndex
} // end loop uIndex
+
+ // The sensor grid computed WITHOUT atmospheric refraction correction
return sensorPixelGrid;
}
@@ -848,6 +856,7 @@ public class Rugged {
* @param lineGrid the line grid
* @param sensor the line sensor
* @return the ground grid computed with atmosphere
+ * @since 2.1
*/
private GeodeticPoint[][] computeDirectLocOnGridWithAtmosphere(final double[] pixelGrid, final double[] lineGrid,
final LineSensor sensor) {
@@ -864,12 +873,16 @@ public class Rugged {
final AbsoluteDate date = sensor.getDate(lineNumber);
final Vector3D los = sensor.getLOS(date, pixelNumber);
try {
+ // Compute the direct location for the current node
groundGridWithAtmosphere[uIndex][vIndex] = directLocation(date, sensorPosition, los);
+
} catch (RuggedException re) { // This should never happen
throw RuggedException.createInternalError(re);
}
} // end loop vIndex
} // end loop uIndex
+
+ // The ground grid computed WITH atmospheric refraction correction
return groundGridWithAtmosphere;
}
diff --git a/src/main/java/org/orekit/rugged/api/RuggedBuilder.java b/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
index 7b8eac7d3eab4aa1a0c4f68d3ef669743bdd4a06..9f969594b7e1bab0989d82b826b5cb8ddfba84fd 100644
--- a/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
+++ b/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
@@ -720,12 +720,12 @@ public class RuggedBuilder {
* @return transforms interpolator
*/
private static SpacecraftToObservedBody createInterpolator(final Frame inertialFrame, final Frame bodyFrame,
- final AbsoluteDate minDate, final AbsoluteDate maxDate,
- final double tStep, final double overshootTolerance,
- final double interpolationStep, final int interpolationNumber,
- final CartesianDerivativesFilter pvFilter,
- final AngularDerivativesFilter aFilter,
- final Propagator propagator) {
+ final AbsoluteDate minDate, final AbsoluteDate maxDate,
+ final double tStep, final double overshootTolerance,
+ final double interpolationStep, final int interpolationNumber,
+ final CartesianDerivativesFilter pvFilter,
+ final AngularDerivativesFilter aFilter,
+ final Propagator propagator) {
// extract position/attitude samples from propagator
final List<TimeStampedPVCoordinates> positionsVelocities =
diff --git a/src/main/java/org/orekit/rugged/los/PixelLOS.java b/src/main/java/org/orekit/rugged/los/PixelLOS.java
index 0bed82a88f7bc92f5ffd41f505a7e670cae6be1d..8f44c1a8eb255721d74cbd26e26083ae958283fd 100644
--- a/src/main/java/org/orekit/rugged/los/PixelLOS.java
+++ b/src/main/java/org/orekit/rugged/los/PixelLOS.java
@@ -23,7 +23,7 @@ import org.orekit.rugged.linesensor.SensorPixel;
/** Container for pixel line-of-sight.
* @author Guylaine Prat
- * @since 3.0
+ * @since 2.1
*/
public class PixelLOS implements Serializable {
diff --git a/src/main/java/org/orekit/rugged/refraction/AtmosphericComputationParameters.java b/src/main/java/org/orekit/rugged/refraction/AtmosphericComputationParameters.java
index 257eec8b238b7b8981819d1dca1cb41ec5b22205..bedff6f88aee2da268027e4d324ad45f5d52689a 100644
--- a/src/main/java/org/orekit/rugged/refraction/AtmosphericComputationParameters.java
+++ b/src/main/java/org/orekit/rugged/refraction/AtmosphericComputationParameters.java
@@ -25,7 +25,7 @@ import org.orekit.rugged.utils.GridCreation;
* Atmospheric refraction computation parameters.
* Defines for inverse location a set of parameters in order to be able to perform the computation.
* @author Guylaine Prat
- * @since 3.0
+ * @since 2.1
*/
public class AtmosphericComputationParameters {
diff --git a/src/main/java/org/orekit/rugged/refraction/AtmosphericRefraction.java b/src/main/java/org/orekit/rugged/refraction/AtmosphericRefraction.java
index af4ea0bf07ef81136e4fc847f34d1bef50a18f6d..93811faee3c7c49c090b54274b3124c2a1f0b80e 100644
--- a/src/main/java/org/orekit/rugged/refraction/AtmosphericRefraction.java
+++ b/src/main/java/org/orekit/rugged/refraction/AtmosphericRefraction.java
@@ -35,28 +35,28 @@ public abstract class AtmosphericRefraction {
/** Flag to tell if we must compute the correction.
* By default: computation is set up.
- * @since 3.0
+ * @since 2.1
*/
private boolean mustBeComputed = true;
/** Flag to tell if we must compute the correction (for direct location) with an optimization grid.
* By default: optimization is not set up.
- * @since 3.0
+ * @since 2.1
*/
private boolean isOptimized = false;
/** The current atmospheric parameters.
- * @since 3.0
+ * @since 2.1
*/
private AtmosphericComputationParameters atmosphericParams;
/** Bilinear interpolating function for pixel (used by inverse location).
- * @since 3.0
+ * @since 2.1
*/
private BilinearInterpolatingFunction bifPixel = null;
/** Bilinear interpolating function of line (used by inverse location).
- * @since 3.0
+ * @since 2.1
*/
private BilinearInterpolatingFunction bifLine = null;
@@ -91,21 +91,21 @@ public abstract class AtmosphericRefraction {
* @return corrected point with the effect of atmospheric refraction
* {@link org.orekit.rugged.utils.ExtendedEllipsoid#pointAtAltitude(Vector3D, Vector3D, double)} or see
* {@link org.orekit.rugged.intersection.IntersectionAlgorithm#refineIntersection(org.orekit.rugged.utils.ExtendedEllipsoid, Vector3D, Vector3D, NormalizedGeodeticPoint)}
- * @since 3.0
+ * @since 2.1
*/
public abstract NormalizedGeodeticPoint applyCorrection(LineSensor lineSensor, SensorPixel sensorPixel,
Vector3D satPos, Vector3D satLos, NormalizedGeodeticPoint rawIntersection,
IntersectionAlgorithm algorithm);
/** Deactivate computation (needed for the inverse location computation).
- * @since 3.0
+ * @since 2.1
*/
public void deactivateComputation() {
this.mustBeComputed = false;
}
/** Reactivate computation (needed for the inverse location computation).
- * @since 3.0
+ * @since 2.1
*/
public void reactivateComputation() {
this.mustBeComputed = true;
@@ -113,7 +113,7 @@ public abstract class AtmosphericRefraction {
/** Tell if the computation must be performed.
* @return true if computation must be performed; false otherwise
- * @since 3.0
+ * @since 2.1
*/
public boolean mustBeComputed() {
return mustBeComputed;
@@ -121,7 +121,7 @@ public abstract class AtmosphericRefraction {
/** Tell if the computation (for direct location) must be optimized.
* @return true if computation must be optimized; false otherwise
- * @since 3.0
+ * @since 2.1
*/
public boolean isOptimized() {
return isOptimized;
@@ -132,6 +132,7 @@ public abstract class AtmosphericRefraction {
* @param sensor line sensor
* @param minLine min line defined for the inverse location
* @param maxLine max line defined for the inverse location
+ * @since 2.1
*/
public void configureCorrectionGrid(final LineSensor sensor, final int minLine, final int maxLine) {
@@ -143,6 +144,7 @@ public abstract class AtmosphericRefraction {
* @param minLine the asked min line
* @param maxLine the asked max line
* @return true if same context; false otherwise
+ * @since 2.1
*/
public Boolean isSameContext(final String sensorName, final int minLine, final int maxLine) {
@@ -153,6 +155,7 @@ public abstract class AtmosphericRefraction {
/** Get the computation parameters.
* @return the AtmosphericComputationParameters
+ * @since 2.1
*/
public AtmosphericComputationParameters getComputationParameters() {
return atmosphericParams;
@@ -162,6 +165,7 @@ public abstract class AtmosphericRefraction {
* Overwrite the default values, for time optimization for instance.
* @param pixelStep pixel step for the inverse location computation
* @param lineStep line step for the inverse location computation
+ * @since 2.1
*/
public void setGridSteps(final int pixelStep, final int lineStep) {
atmosphericParams.setGridSteps(pixelStep, lineStep);
@@ -169,25 +173,25 @@ public abstract class AtmosphericRefraction {
/** Compute the correction functions for pixel and lines.
* The corrections are computed for pixels and lines, on a regular grid at sensor level.
- * The corrections are based on the difference on grid knots (where direct loc is known with atmosphere refraction)
+ * The corrections are based on the difference on grid nodes (where direct loc is known with atmosphere refraction)
* and the sensor pixel found by inverse loc without atmosphere refraction.
* The bilinear interpolating functions are then computed for pixel and for line.
* Need to be computed only once for a given sensor with the same minLine and maxLine.
* @param sensorPixelGridInverseWithout inverse location grid WITHOUT atmospheric refraction
+ * @since 2.1
*/
public void computeGridCorrectionFunctions(final SensorPixel[][] sensorPixelGridInverseWithout) {
- // Compute for a sensor grid, the associated ground grid, WITH atmospheric effect
- // (for interpolations we need a regular grid)
- // ==================================================================================
final int nbPixelGrid = atmosphericParams.getNbPixelGrid();
final int nbLineGrid = atmosphericParams.getNbLineGrid();
final double[] pixelGrid = atmosphericParams.getUgrid();
final double[] lineGrid = atmosphericParams.getVgrid();
+
+ // Initialize the needed diff functions
final double[][] gridDiffPixel = new double[nbPixelGrid][nbLineGrid];
final double[][] gridDiffLine = new double[nbPixelGrid][nbLineGrid];
- // Compute the difference between grids knots WITH - without atmosphere
+ // Compute the difference between grids nodes WITH - without atmosphere
for (int lineIndex = 0; lineIndex < nbLineGrid; lineIndex++) {
for (int pixelIndex = 0; pixelIndex < nbPixelGrid; pixelIndex++) {
@@ -209,10 +213,16 @@ public abstract class AtmosphericRefraction {
this.bifLine = new BilinearInterpolatingFunction(pixelGrid, lineGrid, gridDiffLine);
}
+ /**
+ * @return the bilinear interpolating function for pixel correction
+ */
public BilinearInterpolatingFunction getBifPixel() {
return bifPixel;
}
+ /**
+ * @return the bilinear interpolating function for line correction
+ */
public BilinearInterpolatingFunction getBifLine() {
return bifLine;
}
diff --git a/src/main/java/org/orekit/rugged/refraction/MultiLayerModel.java b/src/main/java/org/orekit/rugged/refraction/MultiLayerModel.java
index 7b8b7f1463ab132a273842b2dece9be13bf49584..0d8bedad83bf86ad74ec8e611fcae0c0d227b3e9 100644
--- a/src/main/java/org/orekit/rugged/refraction/MultiLayerModel.java
+++ b/src/main/java/org/orekit/rugged/refraction/MultiLayerModel.java
@@ -107,7 +107,7 @@ public class MultiLayerModel extends AtmosphericRefraction {
* @param satLos satellite line of sight, in body frame
* @param rawIntersection intersection point without refraction correction
* @return the intersection position and LOS with the lowest atmospheric layer
- * @since 3.0
+ * @since 2.1
*/
private IntersectionLOS computeToLowestAtmosphereLayer(
final Vector3D satPos, final Vector3D satLos,
@@ -264,7 +264,7 @@ public class MultiLayerModel extends AtmosphericRefraction {
/** Container for the (position, LOS) of the intersection with the lowest atmospheric layer.
* @author Guylaine Prat
- * @since 3.0
+ * @since 2.1
*/
class IntersectionLOS {
diff --git a/src/main/java/org/orekit/rugged/utils/GridCreation.java b/src/main/java/org/orekit/rugged/utils/GridCreation.java
index d3c687bb9fad7aad27d0fe94663d11c81155d5ad..50f63b1f0c3e248b4e2b7f3654e197d6832da19e 100644
--- a/src/main/java/org/orekit/rugged/utils/GridCreation.java
+++ b/src/main/java/org/orekit/rugged/utils/GridCreation.java
@@ -18,7 +18,7 @@ package org.orekit.rugged.utils;
/** Utility class for grids creation.
* @author Guylaine Prat
- * @since 3.0
+ * @since 2.1
*/
public final class GridCreation {