diff --git a/src/main/java/org/orekit/rugged/adjustment/AdjustmentContext.java b/src/main/java/org/orekit/rugged/adjustment/AdjustmentContext.java
index 66ad0a2b7bb03f159cc6507e382caa31b528803d..aae53d50b0204172dcf53007ae4b68af3a4db4e2 100644
--- a/src/main/java/org/orekit/rugged/adjustment/AdjustmentContext.java
+++ b/src/main/java/org/orekit/rugged/adjustment/AdjustmentContext.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -35,29 +35,32 @@ import org.orekit.rugged.linesensor.LineSensor;
import org.orekit.rugged.refining.measures.Observables;
import org.orekit.utils.ParameterDriver;
-/** Create adjustment context for viewing model refining refining.
- *
- *
+/** Create adjustment context for viewing model refining.
* @author Lucie LabatAllee
* @author Jonathan Guinet
+ * @author Luc Maisonobe
+ * @author Guylaine Prat
+ * @since 2.0
*/
public class AdjustmentContext {
/** List of Rugged instances to optimize. */
private final Map<String, Rugged> viewingModel;
- /** set of measures. */
+ /** Set of measures. */
private final Observables measures;
- /** least square optimizer choice.*/
+ /** Least square optimizer choice.*/
private OptimizerId optimizerID;
/** Build a new instance.
- * @param viewingModel viewingModel
+ * The default optimizer is Gauss Newton with QR decomposition.
+ * @param viewingModel viewing model
* @param measures control and tie points
*/
public AdjustmentContext(final Collection<Rugged> viewingModel, final Observables measures) {
+
this.viewingModel = new HashMap<String, Rugged>();
for (final Rugged r : viewingModel) {
this.viewingModel.put(r.getName(), r);
@@ -66,9 +69,8 @@ public class AdjustmentContext {
this.optimizerID = OptimizerId.GAUSS_NEWTON_QR;
}
-
- /** setter for optimizer algorithm.
- * @param optimizerId the algorithm
+ /** Setter for optimizer algorithm.
+ * @param optimizerId the chosen algorithm
*/
public void setOptimizer(final OptimizerId optimizerId)
{
@@ -115,16 +117,16 @@ public class AdjustmentContext {
* @param ruggedNameList list of rugged to refine
* @param maxEvaluations maximum number of evaluations
* @param parametersConvergenceThreshold convergence threshold on normalized
- * parameters (dimensionless, related to parameters scales)
- *
+ * parameters (dimensionless, related to parameters scales)
* @return optimum of the least squares problem
* @exception RuggedException if several parameters with the same name
* exist, if no parameters have been selected for estimation, or
* if parameters cannot be estimated (too few measurements,
* ill-conditioned problem ...)
*/
- public Optimum estimateFreeParameters(final Collection<String> ruggedNameList, final int maxEvaluations, final double parametersConvergenceThreshold)
- throws RuggedException {
+ public Optimum estimateFreeParameters(final Collection<String> ruggedNameList, final int maxEvaluations,
+ final double parametersConvergenceThreshold)
+ throws RuggedException {
try {
final List<Rugged> ruggedList = new ArrayList<Rugged>();
@@ -141,7 +143,8 @@ public class AdjustmentContext {
final LeastSquareAdjuster adjuster = new LeastSquareAdjuster(this.optimizerID);
LeastSquaresProblem theProblem = null;
- /** builder */
+
+ // builder
switch (ruggedList.size()) {
case 1:
final Rugged rugged = ruggedList.get(0);
@@ -165,5 +168,4 @@ public class AdjustmentContext {
throw new RuggedException(oe, oe.getSpecifier(), oe.getParts());
}
}
-
}
diff --git a/src/main/java/org/orekit/rugged/adjustment/GroundOptimizationProblemBuilder.java b/src/main/java/org/orekit/rugged/adjustment/GroundOptimizationProblemBuilder.java
index 365d224cf5e19d5ef5018fd7571427003c8db5f9..30689765054506d3a476ea5a0cd12cda0ccb6402 100644
--- a/src/main/java/org/orekit/rugged/adjustment/GroundOptimizationProblemBuilder.java
+++ b/src/main/java/org/orekit/rugged/adjustment/GroundOptimizationProblemBuilder.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -46,8 +46,11 @@ import org.orekit.rugged.refining.measures.Observables;
import org.orekit.rugged.refining.measures.SensorToGroundMapping;
import org.orekit.utils.ParameterDriver;
-
-
+/**
+ * TODO GP description a completer
+ * @author Guylaine Prat
+ * @since 2.0
+ */
public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder {
/** Key for target. */
@@ -56,22 +59,23 @@ public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder
/** Key for weight. */
private static final String WEIGHT = "Weight";
- /** rugged instance to refine.*/
+ /** Rugged instance to refine.*/
private final Rugged rugged;
- /** sensorToGround mapping to generate target tab for optimization.*/
+ /** Sensor to ground mapping to generate target tab for optimization.*/
private List<SensorToGroundMapping> sensorToGroundMappings;
- /** minimum line for inverse location estimation.*/
+ /** Minimum line for inverse location estimation.*/
private int minLine;
- /** maximum line for inverse location estimation.*/
+ /** Maximum line for inverse location estimation.*/
private int maxLine;
- /** target and weight (the solution of the optimization problem).*/
+ /** Target and weight (the solution of the optimization problem).*/
private HashMap<String, double[] > targetAndWeight;
- /**
+
+ /** TODO GP description a completer
* @param sensors list of sensors to refine
* @param measures set of observables
* @param rugged name of rugged to refine
@@ -79,7 +83,8 @@ public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder
*/
public GroundOptimizationProblemBuilder(final List<LineSensor> sensors,
final Observables measures, final Rugged rugged)
- throws RuggedException {
+ throws RuggedException {
+
super(sensors, measures);
this.rugged = rugged;
this.initMapping();
@@ -90,18 +95,23 @@ public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder
*/
@Override
protected void initMapping() {
+
final String ruggedName = rugged.getName();
this.sensorToGroundMappings = new ArrayList<SensorToGroundMapping>();
for (final LineSensor lineSensor : sensors) {
final SensorToGroundMapping mapping = this.measures.getGroundMapping(ruggedName, lineSensor.getName());
- if (mapping != null)
+ if (mapping != null) {
this.sensorToGroundMappings.add(mapping);
+ }
}
}
+ /* (non-Javadoc)
+ * @see org.orekit.rugged.adjustment.OptimizationProblemBuilder#createTargetAndWeight()
+ */
@Override
- protected void createTargetAndWeight()
- throws RuggedException {
+ protected void createTargetAndWeight() throws RuggedException {
+
try {
int n = 0;
for (final SensorToGroundMapping reference : this.sensorToGroundMappings) {
@@ -141,9 +151,12 @@ public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder
}
}
+ /* (non-Javadoc)
+ * @see org.orekit.rugged.adjustment.OptimizationProblemBuilder#createFunction()
+ */
@Override
- protected MultivariateJacobianFunction createFunction()
- {
+ protected MultivariateJacobianFunction createFunction() {
+
// model function
final MultivariateJacobianFunction model = point -> {
try {
@@ -210,15 +223,16 @@ public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder
throw new OrekitExceptionWrapper(oe);
}
};
+
return model;
}
- /** leastsquare problem builder.
+ /** Least square problem builder.
* @param maxEvaluations maxIterations and evaluations
* @param convergenceThreshold parameter convergence threshold
* @throws RuggedException if sensor is not found
- * @return
+ * @return the least square problem
*/
@Override
public final LeastSquaresProblem build(final int maxEvaluations, final double convergenceThreshold) throws RuggedException {
@@ -235,5 +249,4 @@ public class GroundOptimizationProblemBuilder extends OptimizationProblemBuilder
.target(target).parameterValidator(validator).checker(checker)
.model(model).build();
}
-
}
diff --git a/src/main/java/org/orekit/rugged/adjustment/InterSensorsOptimizationProblemBuilder.java b/src/main/java/org/orekit/rugged/adjustment/InterSensorsOptimizationProblemBuilder.java
index 064a2d5715d84b216458e016ebab2c9cb145368a..12835c589796fc788e50fc1660fa2eb0c3c6f711 100644
--- a/src/main/java/org/orekit/rugged/adjustment/InterSensorsOptimizationProblemBuilder.java
+++ b/src/main/java/org/orekit/rugged/adjustment/InterSensorsOptimizationProblemBuilder.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -49,10 +49,12 @@ import org.orekit.rugged.utils.SpacecraftToObservedBody;
import org.orekit.time.AbsoluteDate;
import org.orekit.utils.ParameterDriver;
-
-
-public class InterSensorsOptimizationProblemBuilder
-extends OptimizationProblemBuilder {
+/** TODO GP description a completer
+ * @author ???
+ * @author Guylaine Prat
+ * @since 2.0
+ */
+public class InterSensorsOptimizationProblemBuilder extends OptimizationProblemBuilder {
/** Key for target. */
private static final String TARGET = "Target";
@@ -60,17 +62,16 @@ extends OptimizationProblemBuilder {
/** Key for weight. */
private static final String WEIGHT = "Weight";
- /** list of rugged instance to refine.*/
+ /** List of rugged instance to refine.*/
private Map<String, Rugged> ruggedMap;
- /** sensorToGround mapping to generate target tab for optimization.*/
+ /** Sensor to ground mapping to generate target tab for optimization.*/
private List<SensorToSensorMapping> sensorToSensorMappings;
-
- /** targets and weights of optimization problem. */
+ /** Targets and weights of optimization problem. */
private HashMap<String, double[] > targetAndWeight;
- /**
+ /** Constructor
* @param sensors list of sensors to refine
* @param measures set of observables
* @param ruggedList names of rugged to refine
@@ -78,13 +79,11 @@ extends OptimizationProblemBuilder {
*/
public InterSensorsOptimizationProblemBuilder(final List<LineSensor> sensors,
final Observables measures, final Collection<Rugged> ruggedList)
- throws RuggedException {
+ throws RuggedException {
+
super(sensors, measures);
-
this.ruggedMap = new LinkedHashMap<String, Rugged>();
-
- for (final Rugged rugged : ruggedList)
- {
+ for (final Rugged rugged : ruggedList) {
this.ruggedMap.put(rugged.getName(), rugged);
}
this.initMapping();
@@ -94,93 +93,96 @@ extends OptimizationProblemBuilder {
* @see org.orekit.rugged.adjustment.OptimizationProblemBuilder#initMapping()
*/
@Override
- protected void initMapping()
- {
- this.sensorToSensorMappings = new ArrayList<SensorToSensorMapping>();
- for (final String ruggedNameA : this.ruggedMap.keySet()) {
- for (final String ruggedNameB : this.ruggedMap.keySet()) {
- for (final LineSensor sensorA : this.sensors) {
- for (final LineSensor sensorB : this.sensors) {
- final String sensorNameA = sensorA.getName();
- final String sensorNameB = sensorB.getName();
- final SensorToSensorMapping mapping = this.measures.getInterMapping(ruggedNameA, sensorNameA, ruggedNameB, sensorNameB);
- if (mapping != null)
- {
-
- this.sensorToSensorMappings.add(mapping);
- }
- }
- }
-
- }
-
- }
-
+ protected void initMapping() {
+
+ this.sensorToSensorMappings = new ArrayList<SensorToSensorMapping>();
+
+ for (final String ruggedNameA : this.ruggedMap.keySet()) {
+ for (final String ruggedNameB : this.ruggedMap.keySet()) {
+
+ for (final LineSensor sensorA : this.sensors) {
+ for (final LineSensor sensorB : this.sensors) {
+
+ final String sensorNameA = sensorA.getName();
+ final String sensorNameB = sensorB.getName();
+ final SensorToSensorMapping mapping = this.measures.getInterMapping(ruggedNameA, sensorNameA, ruggedNameB, sensorNameB);
+
+ if (mapping != null) {
+ this.sensorToSensorMappings.add(mapping);
+ }
+ }
+ }
+ }
+ }
}
+ /* (non-Javadoc)
+ * @see org.orekit.rugged.adjustment.OptimizationProblemBuilder#createTargetAndWeight()
+ */
@Override
- protected void createTargetAndWeight()
- throws RuggedException {
- try {
- int n = 0;
- for (final SensorToSensorMapping reference : this.sensorToSensorMappings) {
- n += reference.getMapping().size();
- }
-
- if (n == 0) {
- throw new RuggedException(RuggedMessages.NO_REFERENCE_MAPPINGS);
- }
-
- n = 2 * n;
-
- final double[] target = new double[n];
- final double[] weight = new double[n];
-
- int k = 0;
-
- for (final SensorToSensorMapping reference : this.sensorToSensorMappings) {
-
- // Get Earth constraint weight
- final double earthConstraintWeight = reference.getEarthConstraintWeight();
- int i = 0;
- for (Iterator<Map.Entry<SensorPixel, SensorPixel>> gtIt = reference.getMapping().iterator(); gtIt.hasNext(); i++) {
- if (i == reference.getMapping().size()) break;
-
- // Get LOS distance
- final Double losDistance = reference.getLosDistance(i);
-
- weight[k] = 1.0 - earthConstraintWeight;
- target[k++] = losDistance.doubleValue();
-
- // Get Earth distance (constraint)
- final Double earthDistance = reference.getEarthDistance(i);
- weight[k] = earthConstraintWeight;
- target[k++] = earthDistance.doubleValue();
- }
- }
-
- this.targetAndWeight = new HashMap<String, double[]>();
- this.targetAndWeight.put(TARGET, target);
- this.targetAndWeight.put(WEIGHT, weight);
-
- } catch (RuggedExceptionWrapper rew) {
- throw rew.getException();
- }
+ protected void createTargetAndWeight() throws RuggedException {
+
+ try {
+ int n = 0;
+ for (final SensorToSensorMapping reference : this.sensorToSensorMappings) {
+ n += reference.getMapping().size();
+ }
+ if (n == 0) {
+ throw new RuggedException(RuggedMessages.NO_REFERENCE_MAPPINGS);
+ }
+
+ n = 2 * n;
+
+ final double[] target = new double[n];
+ final double[] weight = new double[n];
+
+ int k = 0;
+ for (final SensorToSensorMapping reference : this.sensorToSensorMappings) {
+
+ // Get Earth constraint weight
+ final double earthConstraintWeight = reference.getEarthConstraintWeight();
+
+ int i = 0;
+ for (Iterator<Map.Entry<SensorPixel, SensorPixel>> gtIt = reference.getMapping().iterator(); gtIt.hasNext(); i++) {
+
+ if (i == reference.getMapping().size()) break;
+
+ // Get LOS distance
+ final Double losDistance = reference.getLosDistance(i);
+
+ weight[k] = 1.0 - earthConstraintWeight;
+ target[k++] = losDistance.doubleValue();
+
+ // Get Earth distance (constraint)
+ final Double earthDistance = reference.getEarthDistance(i);
+ weight[k] = earthConstraintWeight;
+ target[k++] = earthDistance.doubleValue();
+ }
+ }
+
+ this.targetAndWeight = new HashMap<String, double[]>();
+ this.targetAndWeight.put(TARGET, target);
+ this.targetAndWeight.put(WEIGHT, weight);
+
+ } catch (RuggedExceptionWrapper rew) {
+ throw rew.getException();
+ }
}
+ /* (non-Javadoc)
+ * @see org.orekit.rugged.adjustment.OptimizationProblemBuilder#createFunction()
+ */
@Override
- protected MultivariateJacobianFunction createFunction()
- {
+ protected MultivariateJacobianFunction createFunction() {
+
// model function
final MultivariateJacobianFunction model = point -> {
- try {
-
+ try {
// set the current parameters values
int i = 0;
for (final ParameterDriver driver : this.drivers) {
driver.setNormalizedValue(point.getEntry(i++));
-
}
final double[] target = this.targetAndWeight.get(TARGET);
@@ -192,20 +194,18 @@ extends OptimizationProblemBuilder {
int l = 0;
for (final SensorToSensorMapping reference : this.sensorToSensorMappings) {
-
final String ruggedNameA = reference.getRuggedNameA();
final String ruggedNameB = reference.getRuggedNameB();
final Rugged ruggedA = this.ruggedMap.get(ruggedNameA);
-
if (ruggedA == null) {
throw new RuggedException(RuggedMessages.INVALID_RUGGED_NAME);
}
+
final Rugged ruggedB = this.ruggedMap.get(ruggedNameB);
if (ruggedB == null) {
throw new RuggedException(RuggedMessages.INVALID_RUGGED_NAME);
}
-
for (final Map.Entry<SensorPixel, SensorPixel> mapping : reference.getMapping()) {
final SensorPixel spA = mapping.getKey();
@@ -222,19 +222,13 @@ extends OptimizationProblemBuilder {
final SpacecraftToObservedBody scToBodyA = ruggedA.getScToBody();
- final DerivativeStructure[] ilResult = ruggedB.distanceBetweenLOSDerivatives(lineSensorA,
- dateA,
- pixelA,
- scToBodyA,
- lineSensorB,
- dateB,
- pixelB,
- generator);
+ final DerivativeStructure[] ilResult =
+ ruggedB.distanceBetweenLOSDerivatives(lineSensorA, dateA, pixelA, scToBodyA,
+ lineSensorB, dateB, pixelB, generator);
if (ilResult == null) {
- // TODO
+ // TODO GP manque code
} else {
-
// extract the value
value.setEntry(l, ilResult[0].getValue());
value.setEntry(l + 1, ilResult[1].getValue());
@@ -271,11 +265,11 @@ extends OptimizationProblemBuilder {
}
- /** leastsquare problem builder.
+ /** Least square problem builder.
* @param maxEvaluations maxIterations and evaluations
* @param convergenceThreshold parameter convergence threshold
* @throws RuggedException if sensor is not found
- * @return
+ * @return the least square problem
*/
@Override
public final LeastSquaresProblem build(final int maxEvaluations, final double convergenceThreshold) throws RuggedException {
@@ -292,5 +286,4 @@ extends OptimizationProblemBuilder {
.target(target).parameterValidator(validator).checker(checker)
.model(model).build();
}
-
}
diff --git a/src/main/java/org/orekit/rugged/adjustment/LeastSquareAdjuster.java b/src/main/java/org/orekit/rugged/adjustment/LeastSquareAdjuster.java
index e1efae7cff9cb4dfb2d2647200307f29671620a2..e8accef0e7ae70bbf7a518a367e6107065dc7e60 100644
--- a/src/main/java/org/orekit/rugged/adjustment/LeastSquareAdjuster.java
+++ b/src/main/java/org/orekit/rugged/adjustment/LeastSquareAdjuster.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -24,31 +24,35 @@ import org.hipparchus.optim.nonlinear.vector.leastsquares.LeastSquaresProblem;
import org.hipparchus.optim.nonlinear.vector.leastsquares.LevenbergMarquardtOptimizer;
import org.orekit.rugged.errors.RuggedException;
+/** TODO GP description a completer
+ * @author Guylaine Prat
+ * @since 2.0
+ */
public class LeastSquareAdjuster {
- /** least square optimzaer.*/
+ /** Least square optimizer.*/
private final LeastSquaresOptimizer adjuster;
- /** least square optimizer choice.*/
+ /** Least square optimizer choice.*/
private final OptimizerId optimizerID;
- /** constructor.
+ /** Constructor.
* @param optimizerID optimizer choice
*/
- LeastSquareAdjuster(final OptimizerId optimizerID)
- {
+ // TODO GP public protected ???
+ LeastSquareAdjuster(final OptimizerId optimizerID) {
this.optimizerID = optimizerID;
this.adjuster = this.selectOptimizer();
}
- /** default constructor assuming Gauss Newton QR algorithm.*/
- LeastSquareAdjuster()
- {
+ /** Default constructor with Gauss Newton with QR decomposition algorithm.*/
+ // TODO GP public protected ???
+ LeastSquareAdjuster() {
this.optimizerID = OptimizerId.GAUSS_NEWTON_QR;
this.adjuster = this.selectOptimizer();
}
- /** solve the least square problem.
+ /** Solve the least square problem.
* @param problem the least square problem
* @return the solution
*/
@@ -57,22 +61,25 @@ public class LeastSquareAdjuster {
}
/** Create the optimizer.
- * @return optimizer
+ * @return the least square optimizer
*/
private LeastSquaresOptimizer selectOptimizer() {
- // set up the optimizer
+
+ // Set up the optimizer
switch (this.optimizerID) {
+
case LEVENBERG_MARQUADT:
return new LevenbergMarquardtOptimizer();
+
case GAUSS_NEWTON_LU :
return new GaussNewtonOptimizer().withDecomposition(GaussNewtonOptimizer.Decomposition.LU);
+
case GAUSS_NEWTON_QR :
return new GaussNewtonOptimizer().withDecomposition(GaussNewtonOptimizer.Decomposition.QR);
+
default :
// this should never happen
throw RuggedException.createInternalError(null);
}
-
}
-
}
diff --git a/src/main/java/org/orekit/rugged/adjustment/OptimizationProblemBuilder.java b/src/main/java/org/orekit/rugged/adjustment/OptimizationProblemBuilder.java
index db1d23969d11fe96beda99c155c76d8beb42e622..c8c12ea86df19f995ed2bdaec97c24757f227896 100644
--- a/src/main/java/org/orekit/rugged/adjustment/OptimizationProblemBuilder.java
+++ b/src/main/java/org/orekit/rugged/adjustment/OptimizationProblemBuilder.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -43,41 +43,39 @@ import org.orekit.utils.ParameterDriver;
/**
* Builder for optimization problem.
* <p>
+ * TODO GP description a completer
* </p>
- *
* @author Jonathan Guinet
+ * @author Guylaine Prat
+ * @since 2.0
*/
abstract class OptimizationProblemBuilder {
- /**
- * Margin used in parameters estimation for the inverse location lines
- * range.
- */
+ /** Margin used in parameters estimation for the inverse location lines range. */
protected static final int ESTIMATION_LINE_RANGE_MARGIN = 100;
/** Derivative structure generator.*/
protected final DSGenerator generator;
- /** parameterDriversList. */
+ /** Parameter drivers list. */
protected final List<ParameterDriver> drivers;
- /** number of params to refine. */
+ /** Number of parameters to refine. */
protected final int nbParams;
-
- /** measures .*/
+ /** Measures. */
protected Observables measures;
+ /** Sensors list. */
protected final List<LineSensor> sensors;
- /** OptimizationProblemBuilder constructor.
- * @param sensors
- * @param measures
- * @throws RuggedException
+ /** Constructor.
+ * @param sensors list of sensors to refine
+ * @param measures set of observables
+ * @throws RuggedException an exception is generated if no parameters has been selected for refining
*/
- OptimizationProblemBuilder(final List<LineSensor> sensors,
- final Observables measures)
- throws RuggedException {
+ OptimizationProblemBuilder(final List<LineSensor> sensors, final Observables measures) throws RuggedException {
+
try {
this.generator = this.createGenerator(sensors);
this.drivers = this.generator.getSelected();
@@ -93,143 +91,147 @@ abstract class OptimizationProblemBuilder {
this.sensors = sensors;
}
- /** nbParams getter.
- * @return returns the number of variable parameters
+ /** Get the number of parameters to refine.
+ * @return the number of parameters to refine
*/
public final int getNbParams() {
- return this.getNbParams();
+ return this.nbParams;
}
/**
- * parameters drivers list getter.
- *
- * @return selected list of parameters driver
+ * Get the parameters drivers list.
+ * @return the selected list of parameters driver
*/
public final List<ParameterDriver> getSelectedParametersDriver() {
return this.drivers;
}
-
/**
- * generator getter.
- *
+ * Get the derivative structure generator.
* @return the derivative structure generator.
*/
public final DSGenerator getGenerator() {
return this.generator;
}
-
-
- /** leastsquare problem builder.
- * @param maxEvaluations maxIterations and evaluations
- * @param convergenceThreshold parameter convergence threshold
+ /** Least squares problem builder.
+ * @param maxEvaluations maximum number of evaluations
+ * @param convergenceThreshold convergence threshold
* @throws RuggedException if sensor is not found
- * @return the problem
+ * @return the least squares problem
*/
- public abstract LeastSquaresProblem build(int maxEvaluations, double convergenceThreshold) throws RuggedException;
+ public abstract LeastSquaresProblem build(int maxEvaluations, double convergenceThreshold)
+ throws RuggedException;
- /**
- * Create the convergence check.
+ /** Create the convergence check.
* <p>
- * check Linf distance of parameters variation between previous and current
- * iteration
+ * check LInf distance of parameters variation between previous and current iteration
* </p>
- *
* @param parametersConvergenceThreshold convergence threshold
* @return the checker
*/
- final ConvergenceChecker<LeastSquaresProblem.Evaluation>
- createChecker(final double parametersConvergenceThreshold) {
- final ConvergenceChecker<LeastSquaresProblem.Evaluation> checker = (iteration,
- previous,
- current) -> current
- .getPoint()
- .getLInfDistance(previous
- .getPoint()) <= parametersConvergenceThreshold;
- return checker;
+ final ConvergenceChecker<LeastSquaresProblem.Evaluation>
+ createChecker(final double parametersConvergenceThreshold) {
+
+ // TODO GP description a completer
+ final ConvergenceChecker<LeastSquaresProblem.Evaluation> checker =
+ (iteration, previous, current)
+ -> current.getPoint().getLInfDistance(previous.getPoint())
+ <= parametersConvergenceThreshold;
+
+ return checker;
}
- /**
- * create start point for optimization algorithm.
- *
- * @return start parameters values
+ /** Create start points for optimization algorithm.
+ * @return start parameters values (normalized)
*/
final double[] createStartTab() {
- int iStart = 0;
- // get start point (as a normalized value)
+
+ // Get start points (as a normalized value)
final double[] start = new double[this.nbParams];
+ int iStart = 0;
for (final ParameterDriver driver : this.drivers) {
start[iStart++] = driver.getNormalizedValue();
}
return start;
-
}
+ // TODO GP description a completer
protected abstract void createTargetAndWeight() throws RuggedException;
-
+ // TODO GP description a completer
protected abstract MultivariateJacobianFunction createFunction();
- /** parse the observables to select mapping .*/
+ /** Parse the observables to select mapping .*/
protected abstract void initMapping();
-
- /**
- * create parameter validator.
- *
+
+ /** Create parameter validator.
* @return parameter validator
*/
final ParameterValidator createParameterValidator() {
- // prevent parameters to exceed their prescribed bounds
+
+ // Prevent parameters to exceed their prescribed bounds
+ // TODO GP description a completer
final ParameterValidator validator = params -> {
try {
int i = 0;
for (final ParameterDriver driver : this.drivers) {
+
// let the parameter handle min/max clipping
driver.setNormalizedValue(params.getEntry(i));
params.setEntry(i++, driver.getNormalizedValue());
}
return params;
+
} catch (OrekitException oe) {
throw new OrekitExceptionWrapper(oe);
}
};
+
return validator;
}
- /**
- * Create the generator for {@link DerivativeStructure} instances.
- *
- * @param selectedSensors sensors referencing the parameters drivers
+ /** Create the generator for {@link DerivativeStructure} instances.
+ * @param selectedSensors list of sensors referencing the parameters drivers
* @return a new generator
*/
private DSGenerator createGenerator(final List<LineSensor> selectedSensors) {
- final Set<String> names = new HashSet<>();
+ // Initialize set of drivers name
+ final Set<String> names = new HashSet<>();
+
+ // Get the drivers name
for (final LineSensor sensor : selectedSensors) {
+
+ // Get the drivers name for the sensor
sensor.getParametersDrivers().forEach(driver -> {
+
+ // Add the name of the driver to the set of drivers name
if (names.contains(driver.getName()) == false) {
names.add(driver.getName());
}
});
}
- // set up generator list and map
+ // Set up generator list and map
final List<ParameterDriver> selected = new ArrayList<>();
final Map<String, Integer> map = new HashMap<>();
+
+ // Get the list of selected drivers
for (final LineSensor sensor : selectedSensors) {
+
sensor.getParametersDrivers().filter(driver -> driver.isSelected()).forEach(driver -> {
if (map.get(driver.getName()) == null) {
map.put(driver.getName(), map.size());
selected.add(driver);
}
-
});
}
final DSFactory factory = new DSFactory(map.size(), 1);
+ // TODO GP description a completer
return new DSGenerator() {
/** {@inheritDoc} */
@@ -241,14 +243,13 @@ abstract class OptimizationProblemBuilder {
/** {@inheritDoc} */
@Override
public DerivativeStructure constant(final double value) {
-
return factory.constant(value);
-
}
/** {@inheritDoc} */
@Override
public DerivativeStructure variable(final ParameterDriver driver) {
+
final Integer index = map.get(driver.getName());
if (index == null) {
return constant(driver.getValue());
@@ -256,8 +257,6 @@ abstract class OptimizationProblemBuilder {
return factory.variable(index.intValue(), driver.getValue());
}
}
-
};
}
-
}
diff --git a/src/main/java/org/orekit/rugged/adjustment/OptimizerId.java b/src/main/java/org/orekit/rugged/adjustment/OptimizerId.java
index 7372b17702696791b3a7eb60694e9b7ba7aa938f..3f0bae9b11684fabda1b2314a6e33fe8ee7587ec 100644
--- a/src/main/java/org/orekit/rugged/adjustment/OptimizerId.java
+++ b/src/main/java/org/orekit/rugged/adjustment/OptimizerId.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -17,18 +17,19 @@
package org.orekit.rugged.adjustment;
-/** Enumerate for Optimizer used in Least Square optimization.
+/** Enumerate for Optimizer used in Least square optimization.
* @author Jonathan Guinet
+ * @since 2.0
*/
public enum OptimizerId {
- /** Levenberg Marquadt.
- */
+ /** Levenberg Marquadt. */
LEVENBERG_MARQUADT,
- /** Gauss Newton with LU decomposition.
- */
+
+ /** Gauss Newton with LU decomposition. */
GAUSS_NEWTON_LU,
- /** Gauss Newton with QR decomposition.
- */
+
+ /** Gauss Newton with QR decomposition. */
GAUSS_NEWTON_QR
+
}
diff --git a/src/main/java/org/orekit/rugged/api/ProjectionTypeId.java b/src/main/java/org/orekit/rugged/api/ProjectionTypeId.java
index bb25c877ecefef08126eda4b71531398cdf909db..efd8044a96840ae4e7ce121a59fa18e1b2ba0939 100644
--- a/src/main/java/org/orekit/rugged/api/ProjectionTypeId.java
+++ b/src/main/java/org/orekit/rugged/api/ProjectionTypeId.java
@@ -19,24 +19,25 @@ package org.orekit.rugged.api;
/** Enumerate for cartographic projection type.
* @author Lucie Labat-Allee
+ * @since 2.0
*/
public enum ProjectionTypeId {
- /** Constant for WGS 84 projection type. */
- WGS84,
+ /** Constant for WGS 84 projection type. */
+ WGS84,
- /** Constant for UTM zone 1N projection type. */
- UTM1N,
+ /** Constant for UTM zone 1N projection type. */
+ UTM1N,
- /** Constant for UTM zone 60N projection type. */
- UTM60N,
+ /** Constant for UTM zone 60N projection type. */
+ UTM60N,
- /** Constant for UTM zone 1S projection type. */
- UTM1S,
+ /** Constant for UTM zone 1S projection type. */
+ UTM1S,
- /** Constant for UTM zone 60S projection type. */
- UTM60S,
+ /** Constant for UTM zone 60S projection type. */
+ UTM60S,
- /** Constant for Lambert-93 projection type. */
- LAMBERT93
+ /** Constant for Lambert-93 projection type. */
+ LAMBERT93
}
diff --git a/src/main/java/org/orekit/rugged/api/Rugged.java b/src/main/java/org/orekit/rugged/api/Rugged.java
index 6ef7b621a84b4b2aa4596c372fc8ade7098550e9..e7d2b4652d3f9705f695a091e164aed3ac4e1603 100644
--- a/src/main/java/org/orekit/rugged/api/Rugged.java
+++ b/src/main/java/org/orekit/rugged/api/Rugged.java
@@ -43,9 +43,7 @@ import org.orekit.time.AbsoluteDate;
import org.orekit.utils.Constants;
import org.orekit.utils.PVCoordinates;
-/**
- * Main class of Rugged library API.
- *
+/** Main class of Rugged library API.
* @see RuggedBuilder
* @author Luc Maisonobe
* @author Lucie LabatAllee
@@ -54,11 +52,10 @@ import org.orekit.utils.PVCoordinates;
*/
public class Rugged {
- /**
- * Accuracy to use in the first stage of inverse location.
+ /** 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.
+ * 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_LOCATION_ACCURACY = 0.01;
@@ -95,18 +92,14 @@ public class Rugged {
/** Build a configured instance.
* <p>
- * By default, the instance performs both light time correction (which
- * refers to ground point motion with respect to inertial frame) and
- * aberration of light correction (which refers to spacecraft proper
- * velocity). Explicit calls to {@link #setLightTimeCorrection(boolean)
- * setLightTimeCorrection} and
- * {@link #setAberrationOfLightCorrection(boolean)
- * setAberrationOfLightCorrection} can be made after construction if these
- * phenomena should not be corrected.
+ * By default, the instance performs both light time correction (which refers
+ * to ground point motion with respect to inertial frame) and aberration of
+ * light correction (which refers to spacecraft proper velocity). Explicit calls
+ * to {@link #setLightTimeCorrection(boolean) setLightTimeCorrection}
+ * and {@link #setAberrationOfLightCorrection(boolean) setAberrationOfLightCorrection}
+ * can be made after construction if these phenomena should not be corrected.
* </p>
- *
- * @param algorithm algorithm to use for Digital Elevation Model
- * intersection
+ * @param algorithm algorithm to use for Digital Elevation Model intersection
* @param ellipsoid f reference ellipsoid
* @param lightTimeCorrection if true, the light travel time between ground
* @param aberrationOfLightCorrection if true, the aberration of light
@@ -115,7 +108,7 @@ public class Rugged {
* @param atmosphericRefraction the atmospheric refraction model to be used for more accurate location
* @param scToBody transforms interpolator
* @param sensors sensors
- * @param name RuggedName
+ * @param name Rugged name
*/
Rugged(final IntersectionAlgorithm algorithm, final ExtendedEllipsoid ellipsoid, final boolean lightTimeCorrection,
final boolean aberrationOfLightCorrection, final AtmosphericRefraction atmosphericRefraction,
@@ -131,7 +124,8 @@ public class Rugged {
// intersection algorithm
this.algorithm = algorithm;
- // rugged name
+ // Rugged name
+ // @since 2.0
this.name = name;
this.sensors = new HashMap<String, LineSensor>();
@@ -140,46 +134,37 @@ public class Rugged {
}
this.finders = new HashMap<String, SensorMeanPlaneCrossing>();
- this.lightTimeCorrection = lightTimeCorrection;
+ this.lightTimeCorrection = lightTimeCorrection;
this.aberrationOfLightCorrection = aberrationOfLightCorrection;
this.atmosphericRefraction = atmosphericRefraction;
}
- /**
- * Get the ruggd name.
- *
- * @return rugged name
+ /** Get the Rugged name.
+ * @return Rugged name
+ * @since 2.0
*/
public String getName() {
return name;
}
-
-
- /**
- * Get the DEM intersection algorithm.
- *
+ /** Get the DEM intersection algorithm.
* @return DEM intersection algorithm
*/
public IntersectionAlgorithm getAlgorithm() {
return algorithm;
}
- /**
- * Get flag for light time correction.
- *
+ /** Get flag for light time correction.
* @return true if the light time between ground and spacecraft is
- * compensated for more accurate location
+ * compensated for more accurate location
*/
public boolean isLightTimeCorrected() {
return lightTimeCorrection;
}
- /**
- * Get flag for aberration of light correction.
- *
- * @return true if the aberration of light time is corrected for more
- * accurate location
+ /** Get flag for aberration of light correction.
+ * @return true if the aberration of light time is corrected
+ * for more accurate location
*/
public boolean isAberrationOfLightCorrected() {
return aberrationOfLightCorrection;
@@ -187,6 +172,7 @@ public class Rugged {
/** Get the atmospheric refraction model.
* @return atmospheric refraction model
+ * @since 2.0
*/
public AtmosphericRefraction getRefractionCorrection() {
return atmosphericRefraction;
@@ -199,35 +185,29 @@ public class Rugged {
return sensors.values();
}
- /**
- * Get the start of search time span.
- *
+ /** Get the start of search time span.
* @return start of search time span
*/
public AbsoluteDate getMinDate() {
return scToBody.getMinDate();
}
- /**
- * Get the end of search time span.
- *
+ /** Get the end of search time span.
* @return end of search time span
*/
public AbsoluteDate getMaxDate() {
return scToBody.getMaxDate();
}
- /**
- * Check if a date is in the supported range.
+ /** Check if a date is in the supported range.
* <p>
- * The support range is given by the {@code minDate} and {@code maxDate}
- * construction parameters, with an {@code
- * overshootTolerance} margin accepted (i.e. a date slightly before
- * {@code minDate} or slightly after {@code maxDate} will be considered in
- * range if the overshoot does not exceed the tolerance set at
- * construction).
+ * The support range is given by the {@code minDate} and
+ * {@code maxDate} construction parameters, with an {@code
+ * overshootTolerance} margin accepted (i.e. a date slightly
+ * before {@code minDate} or slightly after {@code maxDate}
+ * will be considered in range if the overshoot does not exceed
+ * the tolerance set at construction).
* </p>
- *
* @param date date to check
* @return true if date is in the supported range
*/
@@ -235,72 +215,55 @@ public class Rugged {
return scToBody.isInRange(date);
}
- /**
- * Get the observed body ellipsoid.
- *
+ /** Get the observed body ellipsoid.
* @return observed body ellipsoid
*/
public ExtendedEllipsoid getEllipsoid() {
return ellipsoid;
}
- /**
- * Direct location 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
+ * @exception RuggedException if line cannot be localized, or sensor is unknown
*/
- public GeodeticPoint[] directLocation(final String sensorName,
- final double lineNumber)
- throws RuggedException {
+ public GeodeticPoint[] directLocation(final String sensorName, final double lineNumber)
+ throws RuggedException {
- // compute the approximate transform between spacecraft and observed
- // body
- final LineSensor sensor = getLineSensor(sensorName);
- final AbsoluteDate date = sensor.getDate(lineNumber);
- final Transform scToInert = scToBody.getScToInertial(date);
- final Transform inertToBody = scToBody.getInertialToBody(date);
- final Transform approximate = new Transform(date, scToInert,
- inertToBody);
+ // compute the approximate transform between spacecraft and observed body
+ final LineSensor sensor = getLineSensor(sensorName);
+ final AbsoluteDate date = sensor.getDate(lineNumber);
+ final Transform scToInert = scToBody.getScToInertial(date);
+ final Transform inertToBody = scToBody.getInertialToBody(date);
+ final Transform approximate = new Transform(date, scToInert, inertToBody);
- final Vector3D spacecraftVelocity = scToInert
- .transformPVCoordinates(PVCoordinates.ZERO).getVelocity();
+ final Vector3D spacecraftVelocity =
+ scToInert.transformPVCoordinates(PVCoordinates.ZERO).getVelocity();
// compute location of each pixel
- final Vector3D pInert = scToInert
- .transformPosition(sensor.getPosition());
+ final Vector3D pInert = scToInert.transformPosition(sensor.getPosition());
final GeodeticPoint[] gp = new GeodeticPoint[sensor.getNbPixels()];
for (int i = 0; i < sensor.getNbPixels(); ++i) {
DumpManager.dumpDirectLocation(date, sensor.getPosition(), sensor.getLOS(date, i), lightTimeCorrection,
aberrationOfLightCorrection, atmosphericRefraction != null);
- final Vector3D obsLInert = scToInert
- .transformVector(sensor.getLOS(date, i));
+ final Vector3D obsLInert = scToInert.transformVector(sensor.getLOS(date, i));
final Vector3D lInert;
if (aberrationOfLightCorrection) {
// apply aberration of light correction
- // as the spacecraft velocity is small with respect to speed of
- // light,
- // we use classical velocity addition and not relativistic
- // velocity addition
- // we look for a positive k such that: c * lInert + vsat = k *
- // obsLInert
+ // as the spacecraft velocity is small with respect to speed of light,
+ // we use classical velocity addition and not relativistic velocity addition
+ // we look for a positive k such that: c * lInert + vsat = k * obsLInert
// with lInert normalized
final double a = obsLInert.getNormSq();
- final double b = -Vector3D.dotProduct(obsLInert,
- spacecraftVelocity);
- final double c = spacecraftVelocity
- .getNormSq() - Constants.SPEED_OF_LIGHT *
- Constants.SPEED_OF_LIGHT;
+ final double b = -Vector3D.dotProduct(obsLInert, spacecraftVelocity);
+ final double c = spacecraftVelocity.getNormSq() - Constants.SPEED_OF_LIGHT * Constants.SPEED_OF_LIGHT;
final double s = FastMath.sqrt(b * b - a * c);
final double k = (b > 0) ? -c / (s + b) : (s - b) / a;
- lInert = new Vector3D(k / Constants.SPEED_OF_LIGHT, obsLInert,
- -1.0 / Constants.SPEED_OF_LIGHT,
- spacecraftVelocity);
+ lInert = new Vector3D( k / Constants.SPEED_OF_LIGHT, obsLInert,
+ -1.0 / Constants.SPEED_OF_LIGHT, spacecraftVelocity);
} else {
// don't apply aberration of light correction
lInert = obsLInert;
@@ -308,35 +271,29 @@ public class Rugged {
if (lightTimeCorrection) {
// compute DEM intersection with light time correction
- final Vector3D sP = approximate
- .transformPosition(sensor.getPosition());
- final Vector3D sL = approximate
- .transformVector(sensor.getLOS(date, i));
- final Vector3D eP1 = ellipsoid
- .transform(ellipsoid.pointOnGround(sP, sL, 0.0));
- final double deltaT1 = eP1.distance(sP) /
- Constants.SPEED_OF_LIGHT;
+ final Vector3D sP = approximate.transformPosition(sensor.getPosition());
+ final Vector3D sL = approximate.transformVector(sensor.getLOS(date, i));
+ final Vector3D eP1 = ellipsoid.transform(ellipsoid.pointOnGround(sP, sL, 0.0));
+ final double deltaT1 = eP1.distance(sP) / Constants.SPEED_OF_LIGHT;
final Transform shifted1 = inertToBody.shiftedBy(-deltaT1);
- final NormalizedGeodeticPoint gp1 = algorithm
- .intersection(ellipsoid, shifted1.transformPosition(pInert),
- shifted1.transformVector(lInert));
+ final NormalizedGeodeticPoint gp1 = algorithm.intersection(ellipsoid,
+ shifted1.transformPosition(pInert),
+ shifted1.transformVector(lInert));
- final Vector3D eP2 = ellipsoid.transform(gp1);
- final double deltaT2 = eP2.distance(sP) /
- Constants.SPEED_OF_LIGHT;
+ final Vector3D eP2 = ellipsoid.transform(gp1);
+ final double deltaT2 = eP2.distance(sP) / Constants.SPEED_OF_LIGHT;
final Transform shifted2 = inertToBody.shiftedBy(-deltaT2);
- gp[i] = algorithm
- .refineIntersection(ellipsoid,
- shifted2.transformPosition(pInert),
- shifted2.transformVector(lInert), gp1);
+ gp[i] = algorithm.refineIntersection(ellipsoid,
+ shifted2.transformPosition(pInert),
+ shifted2.transformVector(lInert),
+ gp1);
} else {
// compute DEM intersection without light time correction
final Vector3D pBody = inertToBody.transformPosition(pInert);
final Vector3D lBody = inertToBody.transformVector(lInert);
- gp[i] = algorithm
- .refineIntersection(ellipsoid, pBody, lBody, algorithm
- .intersection(ellipsoid, pBody, lBody));
+ gp[i] = algorithm.refineIntersection(ellipsoid, pBody, lBody,
+ algorithm.intersection(ellipsoid, pBody, lBody));
}
if (atmosphericRefraction != null) {
@@ -354,60 +311,45 @@ public class Rugged {
}
- /**
- * Direct location of a single line-of-sight.
- *
+ /** 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 intersection point between specified los and
- * ground
- * @exception RuggedException if line cannot be localized, or sensor is
- * unknown
+ * @return ground position of intersection point between specified los and ground
+ * @exception RuggedException if line cannot be localized, or sensor is unknown
*/
- public GeodeticPoint directLocation(final AbsoluteDate date,
- final Vector3D position,
- final Vector3D los)
- throws RuggedException {
+ public GeodeticPoint directLocation(final AbsoluteDate date, final Vector3D position, final Vector3D los)
+ throws RuggedException {
DumpManager.dumpDirectLocation(date, position, los, lightTimeCorrection, aberrationOfLightCorrection,
atmosphericRefraction != null);
- // compute the approximate transform between spacecraft and observed
- // body
- final Transform scToInert = scToBody.getScToInertial(date);
- final Transform inertToBody = scToBody.getInertialToBody(date);
- final Transform approximate = new Transform(date, scToInert,
- inertToBody);
+ // compute the approximate transform between spacecraft and observed body
+ final Transform scToInert = scToBody.getScToInertial(date);
+ final Transform inertToBody = scToBody.getInertialToBody(date);
+ final Transform approximate = new Transform(date, scToInert, inertToBody);
- final Vector3D spacecraftVelocity = scToInert
- .transformPVCoordinates(PVCoordinates.ZERO).getVelocity();
+ final Vector3D spacecraftVelocity =
+ scToInert.transformPVCoordinates(PVCoordinates.ZERO).getVelocity();
// compute location of specified pixel
- final Vector3D pInert = scToInert.transformPosition(position);
+ final Vector3D pInert = scToInert.transformPosition(position);
final Vector3D obsLInert = scToInert.transformVector(los);
final Vector3D lInert;
if (aberrationOfLightCorrection) {
// apply aberration of light correction
- // as the spacecraft velocity is small with respect to speed of
- // light,
- // we use classical velocity addition and not relativistic velocity
- // addition
- // we look for a positive k such that: c * lInert + vsat = k *
- // obsLInert
+ // as the spacecraft velocity is small with respect to speed of light,
+ // we use classical velocity addition and not relativistic velocity addition
+ // we look for a positive k such that: c * lInert + vsat = k * obsLInert
// with lInert normalized
final double a = obsLInert.getNormSq();
- final double b = -Vector3D.dotProduct(obsLInert,
- spacecraftVelocity);
- final double c = spacecraftVelocity
- .getNormSq() - Constants.SPEED_OF_LIGHT *
- Constants.SPEED_OF_LIGHT;
+ final double b = -Vector3D.dotProduct(obsLInert, spacecraftVelocity);
+ final double c = spacecraftVelocity.getNormSq() - Constants.SPEED_OF_LIGHT * Constants.SPEED_OF_LIGHT;
final double s = FastMath.sqrt(b * b - a * c);
final double k = (b > 0) ? -c / (s + b) : (s - b) / a;
- lInert = new Vector3D(k / Constants.SPEED_OF_LIGHT, obsLInert,
- -1.0 / Constants.SPEED_OF_LIGHT,
- spacecraftVelocity);
+ lInert = new Vector3D( k / Constants.SPEED_OF_LIGHT, obsLInert,
+ -1.0 / Constants.SPEED_OF_LIGHT, spacecraftVelocity);
} else {
// don't apply aberration of light correction
lInert = obsLInert;
@@ -416,30 +358,29 @@ public class Rugged {
final NormalizedGeodeticPoint gp;
if (lightTimeCorrection) {
// compute DEM intersection with light time correction
- final Vector3D sP = approximate.transformPosition(position);
- final Vector3D sL = approximate.transformVector(los);
- final Vector3D eP1 = ellipsoid
- .transform(ellipsoid.pointOnGround(sP, sL, 0.0));
- final double deltaT1 = eP1.distance(sP) / Constants.SPEED_OF_LIGHT;
+ final Vector3D sP = approximate.transformPosition(position);
+ final Vector3D sL = approximate.transformVector(los);
+ final Vector3D eP1 = ellipsoid.transform(ellipsoid.pointOnGround(sP, sL, 0.0));
+ final double deltaT1 = eP1.distance(sP) / Constants.SPEED_OF_LIGHT;
final Transform shifted1 = inertToBody.shiftedBy(-deltaT1);
- final NormalizedGeodeticPoint gp1 = algorithm
- .intersection(ellipsoid, shifted1.transformPosition(pInert),
- shifted1.transformVector(lInert));
+ final NormalizedGeodeticPoint gp1 = algorithm.intersection(ellipsoid,
+ shifted1.transformPosition(pInert),
+ shifted1.transformVector(lInert));
- final Vector3D eP2 = ellipsoid.transform(gp1);
- final double deltaT2 = eP2.distance(sP) / Constants.SPEED_OF_LIGHT;
+ final Vector3D eP2 = ellipsoid.transform(gp1);
+ final double deltaT2 = eP2.distance(sP) / Constants.SPEED_OF_LIGHT;
final Transform shifted2 = inertToBody.shiftedBy(-deltaT2);
gp = algorithm.refineIntersection(ellipsoid,
- shifted2.transformPosition(pInert),
- shifted2.transformVector(lInert),
- gp1);
+ shifted2.transformPosition(pInert),
+ shifted2.transformVector(lInert),
+ gp1);
} else {
// compute DEM intersection without light time correction
final Vector3D pBody = inertToBody.transformPosition(pInert);
final Vector3D lBody = inertToBody.transformVector(lInert);
gp = algorithm.refineIntersection(ellipsoid, pBody, lBody,
- algorithm.intersection(ellipsoid, pBody, lBody));
+ algorithm.intersection(ellipsoid, pBody, lBody));
}
final NormalizedGeodeticPoint result;
@@ -458,31 +399,27 @@ public class Rugged {
}
- /**
- * Find the date at which sensor sees a ground point.
+ /** Find the date at which sensor sees a ground point.
* <p>
- * This method is a partial
- * {@link #inverseLocation(String, GeodeticPoint, int, int) inverse
- * location} 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
* computed from the Digital Elevation Model.
* </p>
* <p>
- * Note that for each sensor name, the {@code minLine} and {@code maxLine}
- * settings are cached, because they induce costly frames computation. So
- * these settings should not be tuned very finely and changed at each call,
- * but should rather be a few thousand lines wide and refreshed only when
- * needed. If for example an inverse location is roughly estimated to occur
- * near line 53764 (for example using
- * {@link org.orekit.rugged.utils.RoughVisibilityEstimator}),
- * {@code minLine} and {@code maxLine} could be set for example to 50000 and
- * 60000, which would be OK also if next line inverse location is expected
- * to occur near line 53780, and next one ... The setting could be changed
- * for example to 55000 and 65000 when an inverse location is expected to
- * occur after 55750. Of course, these values are only an example and should
- * be adjusted depending on mission needs.
+ * Note that for each sensor name, the {@code minLine} and {@code maxLine} settings
+ * are cached, because they induce costly frames computation. So these settings
+ * should not be tuned very finely and changed at each call, but should rather be
+ * a few thousand lines wide and refreshed only when needed. If for example an
+ * inverse location is roughly estimated to occur near line 53764 (for example
+ * using {@link org.orekit.rugged.utils.RoughVisibilityEstimator}), {@code minLine}
+ * and {@code maxLine} could be set for example to 50000 and 60000, which would
+ * be OK also if next line inverse location is expected to occur near line 53780,
+ * and next one ... The setting could be changed for example to 55000 and 65000 when
+ * an inverse location is expected to occur after 55750. Of course, these values
+ * are only an example and should be adjusted depending on mission needs.
* </p>
* @param sensorName name of the line sensor
* @param latitude ground point latitude (rad)
@@ -490,71 +427,56 @@ public class Rugged {
* @param minLine minimum line number
* @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
+ * @exception RuggedException if line cannot be localized, or sensor is unknown
* @see #inverseLocation(String, double, double, int, int)
* @see org.orekit.rugged.utils.RoughVisibilityEstimator
*/
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));
+ 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 dateLocation(sensorName, groundPoint, minLine, maxLine);
}
- /**
- * Find the date at which sensor sees a ground point.
+ /** Find the date at which sensor sees a ground point.
* <p>
- * This method is a partial
- * {@link #inverseLocation(String, GeodeticPoint, int, int) inverse
- * location} focusing only on date.
+ * This method is a partial {@link #inverseLocation(String,
+ * GeodeticPoint, int, int) inverse location} focusing only on date.
* </p>
* <p>
- * Note that for each sensor name, the {@code minLine} and {@code maxLine}
- * settings are cached, because they induce costly frames computation. So
- * these settings should not be tuned very finely and changed at each call,
- * but should rather be a few thousand lines wide and refreshed only when
- * needed. If for example an inverse location is roughly estimated to occur
- * near line 53764 (for example using
- * {@link org.orekit.rugged.utils.RoughVisibilityEstimator}),
- * {@code minLine} and {@code maxLine} could be set for example to 50000 and
- * 60000, which would be OK also if next line inverse location is expected
- * to occur near line 53780, and next one ... The setting could be changed
- * for example to 55000 and 65000 when an inverse location is expected to
- * occur after 55750. Of course, these values are only an example and should
- * be adjusted depending on mission needs.
+ * Note that for each sensor name, the {@code minLine} and {@code maxLine} settings
+ * are cached, because they induce costly frames computation. So these settings
+ * should not be tuned very finely and changed at each call, but should rather be
+ * a few thousand lines wide and refreshed only when needed. If for example an
+ * inverse location is roughly estimated to occur near line 53764 (for example
+ * using {@link org.orekit.rugged.utils.RoughVisibilityEstimator}), {@code minLine}
+ * and {@code maxLine} could be set for example to 50000 and 60000, which would
+ * be OK also if next line inverse location is expected to occur near line 53780,
+ * and next one ... The setting could be changed for example to 55000 and 65000 when
+ * an inverse location is expected to occur after 55750. Of course, these values
+ * are only an example and should be adjusted depending on mission needs.
* </p>
- *
* @param sensorName name of the line sensor
* @param point point to localize
* @param minLine minimum line number
* @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
+ * @exception RuggedException if line cannot be localized, or sensor is unknown
* @see #inverseLocation(String, GeodeticPoint, int, int)
* @see org.orekit.rugged.utils.RoughVisibilityEstimator
*/
- public AbsoluteDate dateLocation(final String sensorName,
- final GeodeticPoint point,
+ public AbsoluteDate dateLocation(final String sensorName, final GeodeticPoint point,
final int minLine, final int maxLine)
- throws RuggedException {
+ throws RuggedException {
final LineSensor sensor = getLineSensor(sensorName);
- final SensorMeanPlaneCrossing planeCrossing = getPlaneCrossing(sensorName,
- minLine,
- maxLine);
-
- // find approximately the sensor line at which ground point crosses
- // sensor mean plane
- final Vector3D target = ellipsoid.transform(point);
- final SensorMeanPlaneCrossing.CrossingResult crossingResult = planeCrossing
- .find(target);
+ final SensorMeanPlaneCrossing planeCrossing = getPlaneCrossing(sensorName, minLine, maxLine);
+
+ // find approximately the sensor line at which ground point crosses sensor mean plane
+ final Vector3D target = ellipsoid.transform(point);
+ final SensorMeanPlaneCrossing.CrossingResult crossingResult = planeCrossing.find(target);
if (crossingResult == null) {
// target is out of search interval
return null;
@@ -564,26 +486,23 @@ public class Rugged {
}
- /**
- * Inverse location 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.
* </p>
* <p>
- * Note that for each sensor name, the {@code minLine} and {@code maxLine}
- * settings are cached, because they induce costly frames computation. So
- * these settings should not be tuned very finely and changed at each call,
- * but should rather be a few thousand lines wide and refreshed only when
- * needed. If for example an inverse location is roughly estimated to occur
- * near line 53764 (for example using
- * {@link org.orekit.rugged.utils.RoughVisibilityEstimator}),
- * {@code minLine} and {@code maxLine} could be set for example to 50000 and
- * 60000, which would be OK also if next line inverse location is expected
- * to occur near line 53780, and next one ... The setting could be changed
- * for example to 55000 and 65000 when an inverse location is expected to
- * occur after 55750. Of course, these values are only an example and should
- * be adjusted depending on mission needs.
+ * Note that for each sensor name, the {@code minLine} and {@code maxLine} settings
+ * are cached, because they induce costly frames computation. So these settings
+ * should not be tuned very finely and changed at each call, but should rather be
+ * a few thousand lines wide and refreshed only when needed. If for example an
+ * inverse location is roughly estimated to occur near line 53764 (for example
+ * using {@link org.orekit.rugged.utils.RoughVisibilityEstimator}), {@code minLine}
+ * and {@code maxLine} could be set for example to 50000 and 60000, which would
+ * be OK also if next line inverse location is expected to occur near line 53780,
+ * and next one ... The setting could be changed for example to 55000 and 65000 when
+ * an inverse location is expected to occur after 55750. Of course, these values
+ * are only an example and should be adjusted depending on mission needs.
* </p>
* @param sensorName name of the line sensor
* @param latitude ground point latitude (rad)
@@ -591,134 +510,101 @@ public class Rugged {
* @param minLine minimum line number
* @param maxLine maximum line number
* @return sensor pixel seeing ground point, or null if ground point cannot
- * be seen between the prescribed line numbers
- * @exception RuggedException if line cannot be localized, or sensor is
- * unknown
+ * be seen between the prescribed line numbers
+ * @exception RuggedException if line cannot be localized, or sensor is unknown
* @see org.orekit.rugged.utils.RoughVisibilityEstimator
*/
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));
+ 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 inverseLocation(sensorName, groundPoint, minLine, maxLine);
}
- /**
- * Inverse location of a point.
+ /** Inverse location of a point.
* <p>
- * Note that for each sensor name, the {@code minLine} and {@code maxLine}
- * settings are cached, because they induce costly frames computation. So
- * these settings should not be tuned very finely and changed at each call,
- * but should rather be a few thousand lines wide and refreshed only when
- * needed. If for example an inverse location is roughly estimated to occur
- * near line 53764 (for example using
- * {@link org.orekit.rugged.utils.RoughVisibilityEstimator}),
- * {@code minLine} and {@code maxLine} could be set for example to 50000 and
- * 60000, which would be OK also if next line inverse location is expected
- * to occur near line 53780, and next one ... The setting could be changed
- * for example to 55000 and 65000 when an inverse location is expected to
- * occur after 55750. Of course, these values are only an example and should
- * be adjusted depending on mission needs.
+ * Note that for each sensor name, the {@code minLine} and {@code maxLine} settings
+ * are cached, because they induce costly frames computation. So these settings
+ * should not be tuned very finely and changed at each call, but should rather be
+ * a few thousand lines wide and refreshed only when needed. If for example an
+ * inverse location is roughly estimated to occur near line 53764 (for example
+ * using {@link org.orekit.rugged.utils.RoughVisibilityEstimator}), {@code minLine}
+ * and {@code maxLine} could be set for example to 50000 and 60000, which would
+ * be OK also if next line inverse location is expected to occur near line 53780,
+ * and next one ... The setting could be changed for example to 55000 and 65000 when
+ * an inverse location is expected to occur after 55750. Of course, these values
+ * are only an example and should be adjusted depending on mission needs.
* </p>
- *
* @param sensorName name of the line sensor
* @param point point to localize
* @param minLine minimum line number
* @param maxLine maximum line number
- * @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
+ * @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 #dateLocation(String, GeodeticPoint, int, int)
* @see org.orekit.rugged.utils.RoughVisibilityEstimator
*/
- public SensorPixel inverseLocation(final String sensorName,
- final GeodeticPoint point,
+ public SensorPixel inverseLocation(final String sensorName, final GeodeticPoint point,
final int minLine, final int maxLine)
- throws RuggedException {
+ throws RuggedException {
final LineSensor sensor = getLineSensor(sensorName);
DumpManager.dumpInverseLocation(sensor, point, minLine, maxLine,
- lightTimeCorrection,
- aberrationOfLightCorrection);
+ lightTimeCorrection, aberrationOfLightCorrection);
- final SensorMeanPlaneCrossing planeCrossing = getPlaneCrossing(sensorName,
- minLine,
- maxLine);
+ final SensorMeanPlaneCrossing planeCrossing = getPlaneCrossing(sensorName, minLine, maxLine);
DumpManager.dumpSensorMeanPlane(planeCrossing);
- // find approximately the sensor line at which ground point crosses
- // sensor mean plane
- final Vector3D target = ellipsoid.transform(point);
- final SensorMeanPlaneCrossing.CrossingResult crossingResult = planeCrossing
- .find(target);
+ // find approximately the sensor line at which ground point crosses sensor mean plane
+ final Vector3D target = ellipsoid.transform(point);
+ final SensorMeanPlaneCrossing.CrossingResult crossingResult = planeCrossing.find(target);
if (crossingResult == null) {
// target is out of search interval
return null;
}
// find approximately the pixel along this sensor line
- final SensorPixelCrossing pixelCrossing = new SensorPixelCrossing(sensor,
- planeCrossing
- .getMeanPlaneNormal(),
- crossingResult
- .getTargetDirection(),
- MAX_EVAL,
- COARSE_INVERSE_LOCATION_ACCURACY);
- final double coarsePixel = pixelCrossing
- .locatePixel(crossingResult.getDate());
+ final SensorPixelCrossing pixelCrossing =
+ new SensorPixelCrossing(sensor, planeCrossing.getMeanPlaneNormal(),
+ crossingResult.getTargetDirection(),
+ MAX_EVAL, COARSE_INVERSE_LOCATION_ACCURACY);
+ final double coarsePixel = pixelCrossing.locatePixel(crossingResult.getDate());
if (Double.isNaN(coarsePixel)) {
// target is out of search interval
return null;
}
- // fix line by considering the closest pixel exact position and
- // line-of-sight
- // (this pixel might point towards a direction slightly above or below
- // the mean sensor plane)
- final int lowIndex = FastMath.max(0, FastMath
- .min(sensor.getNbPixels() - 2, (int) FastMath.floor(coarsePixel)));
- final Vector3D lowLOS = sensor.getLOS(crossingResult.getDate(),
- lowIndex);
- final Vector3D highLOS = sensor.getLOS(crossingResult.getDate(),
- lowIndex + 1);
- final Vector3D localZ = Vector3D.crossProduct(lowLOS, highLOS)
- .normalize();
- final double beta = FastMath.acos(Vector3D
- .dotProduct(crossingResult.getTargetDirection(), localZ));
- final double s = Vector3D
- .dotProduct(crossingResult.getTargetDirectionDerivative(), localZ);
- final double betaDer = -s / FastMath.sqrt(1 - s * s);
- final double deltaL = (0.5 * FastMath.PI - beta) / betaDer;
- final double fixedLine = crossingResult.getLine() + deltaL;
- final Vector3D fixedDirection = new Vector3D(1,
- crossingResult
- .getTargetDirection(),
- deltaL,
- crossingResult
- .getTargetDirectionDerivative())
- .normalize();
+ // fix line by considering the closest pixel exact position and line-of-sight
+ // (this pixel might point towards a direction slightly above or below the mean sensor plane)
+ final int lowIndex = FastMath.max(0, FastMath.min(sensor.getNbPixels() - 2, (int) FastMath.floor(coarsePixel)));
+ final Vector3D lowLOS = sensor.getLOS(crossingResult.getDate(), lowIndex);
+ final Vector3D highLOS = sensor.getLOS(crossingResult.getDate(), lowIndex + 1);
+ final Vector3D localZ = Vector3D.crossProduct(lowLOS, highLOS).normalize();
+ final double beta = FastMath.acos(Vector3D.dotProduct(crossingResult.getTargetDirection(),
+ localZ));
+ final double s = Vector3D.dotProduct(crossingResult.getTargetDirectionDerivative(),
+ localZ);
+ final double betaDer = -s / FastMath.sqrt(1 - s * s);
+ final double deltaL = (0.5 * FastMath.PI - beta) / betaDer;
+ final double fixedLine = crossingResult.getLine() + deltaL;
+ final Vector3D fixedDirection = new Vector3D(1, crossingResult.getTargetDirection(),
+ deltaL, crossingResult.getTargetDirectionDerivative()).normalize();
// fix neighbouring pixels
- final AbsoluteDate fixedDate = sensor.getDate(fixedLine);
- final Vector3D fixedX = sensor.getLOS(fixedDate, lowIndex);
- final Vector3D fixedZ = Vector3D
- .crossProduct(fixedX, sensor.getLOS(fixedDate, lowIndex + 1));
- final Vector3D fixedY = Vector3D.crossProduct(fixedZ, fixedX);
+ final AbsoluteDate fixedDate = sensor.getDate(fixedLine);
+ final Vector3D fixedX = sensor.getLOS(fixedDate, lowIndex);
+ final Vector3D fixedZ = Vector3D.crossProduct(fixedX, sensor.getLOS(fixedDate, lowIndex + 1));
+ final Vector3D fixedY = Vector3D.crossProduct(fixedZ, fixedX);
// fix pixel
- final double pixelWidth = FastMath
- .atan2(Vector3D.dotProduct(highLOS, fixedY),
- Vector3D.dotProduct(highLOS, fixedX));
- final double alpha = FastMath
- .atan2(Vector3D.dotProduct(fixedDirection, fixedY),
- Vector3D.dotProduct(fixedDirection, fixedX));
+ final double pixelWidth = FastMath.atan2(Vector3D.dotProduct(highLOS, fixedY),
+ Vector3D.dotProduct(highLOS, fixedX));
+ final double alpha = FastMath.atan2(Vector3D.dotProduct(fixedDirection, fixedY),
+ Vector3D.dotProduct(fixedDirection, fixedX));
final double fixedPixel = lowIndex + alpha / pixelWidth;
final SensorPixel result = new SensorPixel(fixedLine, fixedPixel);
@@ -727,81 +613,54 @@ public class Rugged {
}
- /**
- * Compute distance between two line sensors.
- *
+ /** Compute distances between two line sensors.
* @param sensorA line sensor A
* @param dateA current date for sensor A
* @param pixelA pixel index for sensor A
- * @param scToBodyA spacecraftToBody transform for sensor A
+ * @param scToBodyA spacecraft to body transform for sensor A
* @param sensorB line sensor B
* @param dateB current date for sensor B
* @param pixelB pixel index for sensor B
- * @return distance computing
- * @exception RuggedException if sensor is unknown
+ * @return distances computed between LOS and to the ground
+ * @exception RuggedException
+ * @since 2.0
*/
- public double[]
- distanceBetweenLOS(final LineSensor sensorA, final AbsoluteDate dateA,
- final double pixelA,
+ public double[] distanceBetweenLOS(final LineSensor sensorA, final AbsoluteDate dateA, final double pixelA,
final SpacecraftToObservedBody scToBodyA,
- final LineSensor sensorB, final AbsoluteDate dateB,
- final double pixelB)
- throws RuggedException {
-
- // Compute the approximate transforms between spacecraft and observed
- // body
- final Transform scToInertA = scToBodyA.getScToInertial(dateA); // from
- // rugged
- // instance
- // A
- final Transform scToInertB = scToBody.getScToInertial(dateB); // from
- // (current)
- // rugged
- // instance
- // B
+ final LineSensor sensorB, final AbsoluteDate dateB, final double pixelB)
+ throws RuggedException {
+ // Compute the approximate transform between spacecraft and observed body
+ // from Rugged instance A
+ final Transform scToInertA = scToBodyA.getScToInertial(dateA);
final Transform inertToBodyA = scToBodyA.getInertialToBody(dateA);
+ final Transform transformScToBodyA = new Transform(dateA, scToInertA, inertToBodyA);
+
+ // from (current) Rugged instance B
+ final Transform scToInertB = scToBody.getScToInertial(dateB);
final Transform inertToBodyB = scToBody.getInertialToBody(dateB);
+ final Transform transformScToBodyB = new Transform(dateB, scToInertB, inertToBodyB);
- final Transform trasnformScToBodyA = new Transform(dateA, scToInertA,
- inertToBodyA);
- final Transform trasnformScToBodyB = new Transform(dateB, scToInertB,
- inertToBodyB);
-
- // Get sensors's position and LOS into local frame
- // LOS
- final Vector3D vALocal = sensorA.getLOS(dateA, pixelA); // V_a : line of
- // sight's
- // vectorA
- final Vector3D vBLocal = sensorB.getLOS(dateB, pixelB); // V_b : line of
- // sight's
- // vectorb
-
- // positions
- final Vector3D sALocal = sensorA.getPosition(); // S_a : sensorA 's
- // position
- final Vector3D sBLocal = sensorB.getPosition(); // S_b
-
- // Get sensors's position and LOS into inertial frame
- final Vector3D sA = trasnformScToBodyA.transformPosition(sALocal);
- final Vector3D vA = trasnformScToBodyA.transformVector(vALocal);
- final Vector3D sB = trasnformScToBodyB.transformPosition(sBLocal);
- final Vector3D vB = trasnformScToBodyB.transformVector(vBLocal);
-
- final Vector3D vBase = sB.subtract(sA); // S_b - S_a
- final double svA = Vector3D.dotProduct(vBase, vA); // SV_a = (S_b -
- // S_a).V_a
- final double svB = Vector3D.dotProduct(vBase, vB); // SV_b = (S_b -
- // S_a).V_b
+ // Get sensors LOS into local frame
+ final Vector3D vALocal = sensorA.getLOS(dateA, pixelA);
+ final Vector3D vBLocal = sensorB.getLOS(dateB, pixelB);
- final double vAvB = Vector3D.dotProduct(vA, vB); // V_a.V_b
+ // Position of sensors into local frame
+ final Vector3D sALocal = sensorA.getPosition(); // S_a : sensorA 's position
+ final Vector3D sBLocal = sensorB.getPosition(); // S_b : sensorB 's position
+
+ // Get sensors position and LOS into body frame
+ final Vector3D sA = transformScToBodyA.transformPosition(sALocal); // S_a : sensorA's position
+ final Vector3D vA = transformScToBodyA.transformVector(vALocal); // V_a : line of sight's vectorA
+ final Vector3D sB = transformScToBodyB.transformPosition(sBLocal); // S_b : sensorB's position
+ final Vector3D vB = transformScToBodyB.transformVector(vBLocal); // V_b : line of sight's vectorB
- // Test using |SaSb,Va,Vb |/||Va^Vb||
- //final Vector3D w = Vector3D.crossProduct(vA, vB);
- //final Vector3D vect = Vector3D.crossProduct(vBase,vA);
- //final double k = Vector3D.dotProduct(vect, vB);
- //final double dist = Math.abs(k) /w.getNorm();
- //System.out.format("dist %f %n",dist);
+ // Compute distance
+ final Vector3D vBase = sB.subtract(sA); // S_b - S_a
+ final double svA = Vector3D.dotProduct(vBase, vA); // SV_a = (S_b - S_a).V_a
+ final double svB = Vector3D.dotProduct(vBase, vB); // SV_b = (S_b - S_a).V_b
+
+ final double vAvB = Vector3D.dotProduct(vA, vB); // V_a.V_b
// Compute lambda_b = (SV_a * V_a.V_b - SV_b) / (1 - (V_a.V_b)²)
final double lambdaB = (svA * vAvB - svB) / (1 - vAvB * vAvB);
@@ -809,25 +668,24 @@ public class Rugged {
// Compute lambda_a = SV_a + lambdaB * V_a.V_b
final double lambdaA = svA + lambdaB * vAvB;
- final Vector3D mA = sA.add(vA.scalarMultiply(lambdaA)); // M_a = S_a +
- // lambda_a *
- // V_a
- final Vector3D mB = sB.add(vB.scalarMultiply(lambdaB)); // M_b = S_b +
- // lambda_b *
- // V_b
-
- final Vector3D vDistance = mB.subtract(mA); // M_b - M_a
+ // Compute vector M_a = S_a + lambda_a * V_a
+ final Vector3D mA = sA.add(vA.scalarMultiply(lambdaA));
+ // Compute vector M_b = S_b + lambda_b * V_b
+ final Vector3D mB = sB.add(vB.scalarMultiply(lambdaB));
+ // Compute vector M_a -> M_B for which distance between LOS is minimum
+ final Vector3D vDistanceMin = mB.subtract(mA); // M_b - M_a
+
+ // Compute vector from mid point of vector M_a -> M_B to the ground (corresponds to minimum elevation)
final Vector3D midPoint = (mB.add(mA)).scalarMultiply(0.5);
- // Get the euclidean norm
- final double[] d = {vDistance.getNorm(), midPoint.getNorm()};
- return d;
+ // Get the euclidean norms to compute the minimum distances: between LOS and to the ground
+ final double[] distances = {vDistanceMin.getNorm(), midPoint.getNorm()};
+
+ return distances;
}
- /**
- * Compute distance between two line sensors with derivatives.
- *
+ /** Compute distances between two line sensors with derivatives.
* @param sensorA line sensor A
* @param dateA current date for sensor A
* @param pixelA pixel index for sensor A
@@ -835,128 +693,87 @@ public class Rugged {
* @param sensorB line sensor B
* @param dateB current date for sensor B
* @param pixelB pixel index for sensor B
- * @param generator generator to use for building
- * {@link DerivativeStructure} instances
- * @return distance computing with derivatives
- * @exception RuggedException if sensor is unknown
- * @see #distanceBetweenLOS(String, AbsoluteDate, int, String, AbsoluteDate,
- * int)
+ * @param generator generator to use for building {@link DerivativeStructure} instances
+ * @return distances computed, with derivatives, between LOS and to the ground
+ * @exception RuggedException
+ * @see #distanceBetweenLOS(LineSensor, AbsoluteDate, double, SpacecraftToObservedBody, LineSensor, AbsoluteDate, double)
*/
- public DerivativeStructure[]
- distanceBetweenLOSDerivatives(final LineSensor sensorA,
- final AbsoluteDate dateA,
- final double pixelA,
- final SpacecraftToObservedBody scToBodyA,
- final LineSensor sensorB,
- final AbsoluteDate dateB,
- final double pixelB,
- final DSGenerator generator)
- throws RuggedException {
-
- // final LineSensor sensorA = getLineSensor(sensorNameA);
- // final LineSensor sensorB = getLineSensor(sensorNameB);
-
- // Compute the approximate transforms between spacecraft and observed
- // body
- final Transform scToInertA = scToBodyA.getScToInertial(dateA); // from
- // rugged
- // instance
- // A
- final Transform scToInertB = scToBody.getScToInertial(dateB); // from
- // (current)
- // rugged
- // instance
- // B
-
+ public DerivativeStructure[] distanceBetweenLOSDerivatives(
+ final LineSensor sensorA, final AbsoluteDate dateA, final double pixelA,
+ final SpacecraftToObservedBody scToBodyA,
+ final LineSensor sensorB, final AbsoluteDate dateB, final double pixelB,
+ final DSGenerator generator)
+ throws RuggedException {
+
+ // Compute the approximate transforms between spacecraft and observed body
+ // from Rugged instance A
+ final Transform scToInertA = scToBodyA.getScToInertial(dateA);
final Transform inertToBodyA = scToBodyA.getInertialToBody(dateA);
- final Transform trasnformScToBodyA = new Transform(dateA, scToInertA,
- inertToBodyA);
-
+ final Transform transformScToBodyA = new Transform(dateA, scToInertA, inertToBodyA);
+
+ // from (current) Rugged instance B
+ final Transform scToInertB = scToBody.getScToInertial(dateB);
final Transform inertToBodyB = scToBody.getInertialToBody(dateB);
- final Transform trasnformScToBodyB = new Transform(dateB, scToInertB,
- inertToBodyB);
-
- // Get sensors's LOS into local frame
- final FieldVector3D<DerivativeStructure> vALocal = sensorA
- .getLOSDerivatives(dateA, pixelA, generator);
- final FieldVector3D<DerivativeStructure> vBLocal = sensorB
- .getLOSDerivatives(dateB, pixelB, generator);
-
- // Get sensors's LOS into body frame frame
- final FieldVector3D<DerivativeStructure> vA = trasnformScToBodyA
- .transformVector(vALocal); // V_a : line of sight's vectorA
- final FieldVector3D<DerivativeStructure> vB = trasnformScToBodyB
- .transformVector(vBLocal); // V_b
-
- final Vector3D sAtmp = sensorA.getPosition(); // S_a : sensorA 's
- // position
- final Vector3D sBtmp = sensorB.getPosition(); // S_b : sensorB 's
- // position
- final DerivativeStructure scaleFactor = FieldVector3D
- .dotProduct(vA.normalize(), vA.normalize()); // V_a.V_a=1
- // Build a vector from position vector and a scale factor (equals to 1).
+ final Transform transformScToBodyB = new Transform(dateB, scToInertB, inertToBodyB);
+
+ // Get sensors LOS into local frame
+ final FieldVector3D<DerivativeStructure> vALocal = sensorA.getLOSDerivatives(dateA, pixelA, generator);
+ final FieldVector3D<DerivativeStructure> vBLocal = sensorB.getLOSDerivatives(dateB, pixelB, generator);
+
+ // Get sensors LOS into body frame
+ final FieldVector3D<DerivativeStructure> vA = transformScToBodyA.transformVector(vALocal); // V_a : line of sight's vectorA
+ final FieldVector3D<DerivativeStructure> vB = transformScToBodyB.transformVector(vBLocal); // V_b : line of sight's vectorB
+
+ // Position of sensors into local frame
+ final Vector3D sAtmp = sensorA.getPosition();
+ final Vector3D sBtmp = sensorB.getPosition();
+
+ final DerivativeStructure scaleFactor = FieldVector3D.dotProduct(vA.normalize(), vA.normalize()); // V_a.V_a=1
+
+ // Build a vector from the position and a scale factor (equals to 1).
// The vector built will be scaleFactor * sAtmp for example.
- final FieldVector3D<DerivativeStructure> sALocal = new FieldVector3D<DerivativeStructure>(scaleFactor,
- sAtmp);
- final FieldVector3D<DerivativeStructure> sBLocal = new FieldVector3D<DerivativeStructure>(scaleFactor,
- sBtmp);
-
- // Get sensors's position into inertial frame
- final FieldVector3D<DerivativeStructure> sA = trasnformScToBodyA
- .transformPosition(sALocal);
- final FieldVector3D<DerivativeStructure> sB = trasnformScToBodyB
- .transformPosition(sBLocal);
-
-
- final FieldVector3D<DerivativeStructure> vBase = sB.subtract(sA); // S_b
- // -
- // S_a
- final DerivativeStructure svA = FieldVector3D.dotProduct(vBase, vA); // SV_a
- // =
- // (S_b
- // -
- // S_a).V_a
- final DerivativeStructure svB = FieldVector3D.dotProduct(vBase, vB); // SV_b
- // =
- // (S_b
- // -
- // S_a).V_b
+ final FieldVector3D<DerivativeStructure> sALocal = new FieldVector3D<DerivativeStructure>(scaleFactor, sAtmp);
+ final FieldVector3D<DerivativeStructure> sBLocal = new FieldVector3D<DerivativeStructure>(scaleFactor, sBtmp);
+
+ // Get sensors position into body frame
+ final FieldVector3D<DerivativeStructure> sA = transformScToBodyA.transformPosition(sALocal); // S_a : sensorA 's position
+ final FieldVector3D<DerivativeStructure> sB = transformScToBodyB.transformPosition(sBLocal); // S_b : sensorB 's position
+
+ // Compute distance
+ final FieldVector3D<DerivativeStructure> vBase = sB.subtract(sA); // S_b - S_a
+ final DerivativeStructure svA = FieldVector3D.dotProduct(vBase, vA); // SV_a = (S_b - S_a).V_a
+ final DerivativeStructure svB = FieldVector3D.dotProduct(vBase, vB); // SV_b = (S_b - S_a).V_b
final DerivativeStructure vAvB = FieldVector3D.dotProduct(vA, vB); // V_a.V_b
// Compute lambda_b = (SV_a * V_a.V_b - SV_b) / (1 - (V_a.V_b)²)
- final DerivativeStructure lambdaB = (svA.multiply(vAvB).subtract(svB))
- .divide(vAvB.multiply(vAvB).subtract(1).negate());
+ final DerivativeStructure lambdaB = (svA.multiply(vAvB).subtract(svB)).divide(vAvB.multiply(vAvB).subtract(1).negate());
// Compute lambda_a = SV_a + lambdaB * V_a.V_b
final DerivativeStructure lambdaA = vAvB.multiply(lambdaB).add(svA);
- final FieldVector3D<DerivativeStructure> mA = sA
- .add(vA.scalarMultiply(lambdaA)); // M_a = S_a + lambda_a * V_a
- final FieldVector3D<DerivativeStructure> mB = sB
- .add(vB.scalarMultiply(lambdaB)); // M_b = S_b + lambda_b * V_b
-
- final FieldVector3D<DerivativeStructure> vDistance = mB.subtract(mA); // M_b
- // -
- // M_a
-
- // Get the euclidean norm
+ // Compute vector M_a:
+ final FieldVector3D<DerivativeStructure> mA = sA.add(vA.scalarMultiply(lambdaA)); // M_a = S_a + lambda_a * V_a
+ // Compute vector M_b
+ final FieldVector3D<DerivativeStructure> mB = sB.add(vB.scalarMultiply(lambdaB)); // M_b = S_b + lambda_b * V_b
+ // Compute vector M_a -> M_B for which distance between LOS is minimum
+ final FieldVector3D<DerivativeStructure> vDistanceMin = mB.subtract(mA); // M_b - M_a
+
+ // Compute vector from mid point of vector M_a -> M_B to the ground (corresponds to minimum elevation)
final FieldVector3D<DerivativeStructure> midPoint = (mB.add(mA)).scalarMultiply(0.5);
-
- // Get the euclidean norm
+ // Get the euclidean norms to compute the minimum distances:
+ // between LOS
+ final DerivativeStructure dMin = vDistanceMin.getNorm();
+ // to the ground
final DerivativeStructure dEarth = midPoint.getNorm();
- final DerivativeStructure d = vDistance.getNorm();
-
- return new DerivativeStructure[] {d, dEarth};
+ return new DerivativeStructure[] {dMin, dEarth};
}
- /**
- * Get the mean plane crossing finder for a sensor.
- *
+ /** Get the mean plane crossing finder for a sensor.
* @param sensorName name of the line sensor
* @param minLine minimum line number
* @param maxLine maximum line number
@@ -964,22 +781,19 @@ public class Rugged {
* @exception RuggedException if sensor is unknown
*/
private SensorMeanPlaneCrossing getPlaneCrossing(final String sensorName,
- final int minLine,
- final int maxLine)
- throws RuggedException {
+ final int minLine, final int maxLine)
+ throws RuggedException {
final LineSensor sensor = getLineSensor(sensorName);
SensorMeanPlaneCrossing planeCrossing = finders.get(sensorName);
- if (planeCrossing == null || planeCrossing.getMinLine() != minLine ||
- planeCrossing.getMaxLine() != maxLine) {
+ if (planeCrossing == null ||
+ planeCrossing.getMinLine() != minLine ||
+ planeCrossing.getMaxLine() != maxLine) {
// create a new finder for the specified sensor and range
- planeCrossing = new SensorMeanPlaneCrossing(sensor, scToBody,
- minLine, maxLine,
- lightTimeCorrection,
- aberrationOfLightCorrection,
- MAX_EVAL,
- COARSE_INVERSE_LOCATION_ACCURACY);
+ planeCrossing = new SensorMeanPlaneCrossing(sensor, scToBody, minLine, maxLine,
+ lightTimeCorrection, aberrationOfLightCorrection,
+ MAX_EVAL, COARSE_INVERSE_LOCATION_ACCURACY);
// store the finder, in order to reuse it
// (and save some computation done in its constructor)
@@ -991,187 +805,141 @@ public class Rugged {
}
- /**
- * Set the mean plane crossing finder for a sensor.
- *
+ /** Set the mean plane crossing finder for a sensor.
* @param planeCrossing plane crossing finder
* @exception RuggedException if sensor is unknown
*/
private void setPlaneCrossing(final SensorMeanPlaneCrossing planeCrossing)
- throws RuggedException {
+ throws RuggedException {
finders.put(planeCrossing.getSensor().getName(), planeCrossing);
}
- /**
- * Inverse location of a point with derivatives.
- *
+ /** Inverse location of a point with derivatives.
* @param sensorName name of the line sensor
* @param point point to localize
* @param minLine minimum line number
* @param maxLine maximum line number
- * @param generator generator to use for building
- * {@link DerivativeStructure} instances
- * @return sensor pixel seeing point with derivatives, or null if point
- * cannot be seen between the prescribed line numbers
- * @exception RuggedException if line cannot be localized, or sensor is
- * unknown
+ * @param generator generator to use for building {@link DerivativeStructure} instances
+ * @return sensor pixel seeing point with derivatives, or null if point cannot be seen between the
+ * prescribed line numbers
+ * @exception RuggedException if line cannot be localized, or sensor is unknown
* @see #inverseLocation(String, GeodeticPoint, int, int)
+ * @since 2.0
*/
- public DerivativeStructure[]
- inverseLocationDerivatives(final String sensorName,
- final GeodeticPoint point, final int minLine,
- final int maxLine,
- final DSGenerator generator)
- throws RuggedException {
+ public DerivativeStructure[] inverseLocationDerivatives(final String sensorName,
+ final GeodeticPoint point,
+ final int minLine,
+ final int maxLine,
+ final DSGenerator generator)
+ throws RuggedException {
final LineSensor sensor = getLineSensor(sensorName);
- final SensorMeanPlaneCrossing planeCrossing = getPlaneCrossing(sensorName,
- minLine,
- maxLine);
+ final SensorMeanPlaneCrossing planeCrossing = getPlaneCrossing(sensorName, minLine, maxLine);
- // find approximately the sensor line at which ground point crosses
- // sensor mean plane
- final Vector3D target = ellipsoid.transform(point);
- final SensorMeanPlaneCrossing.CrossingResult crossingResult = planeCrossing
- .find(target);
+ // find approximately the sensor line at which ground point crosses sensor mean plane
+ final Vector3D target = ellipsoid.transform(point);
+ final SensorMeanPlaneCrossing.CrossingResult crossingResult = planeCrossing.find(target);
if (crossingResult == null) {
// target is out of search interval
return null;
}
// find approximately the pixel along this sensor line
- final SensorPixelCrossing pixelCrossing = new SensorPixelCrossing(sensor,
- planeCrossing
- .getMeanPlaneNormal(),
- crossingResult
- .getTargetDirection(),
- MAX_EVAL,
- COARSE_INVERSE_LOCATION_ACCURACY);
- final double coarsePixel = pixelCrossing
- .locatePixel(crossingResult.getDate());
+ final SensorPixelCrossing pixelCrossing =
+ new SensorPixelCrossing(sensor, planeCrossing.getMeanPlaneNormal(),
+ crossingResult.getTargetDirection(),
+ MAX_EVAL, COARSE_INVERSE_LOCATION_ACCURACY);
+ final double coarsePixel = pixelCrossing.locatePixel(crossingResult.getDate());
if (Double.isNaN(coarsePixel)) {
// target is out of search interval
return null;
}
- // fix line by considering the closest pixel exact position and
- // line-of-sight
- // (this pixel might point towards a direction slightly above or below
- // the mean sensor plane)
- final int lowIndex = FastMath.max(0, FastMath
- .min(sensor.getNbPixels() - 2, (int) FastMath.floor(coarsePixel)));
- final FieldVector3D<DerivativeStructure> lowLOS = sensor
- .getLOSDerivatives(crossingResult.getDate(), lowIndex, generator);
- final FieldVector3D<DerivativeStructure> highLOS = sensor
- .getLOSDerivatives(crossingResult.getDate(), lowIndex + 1,
- generator);
- final FieldVector3D<DerivativeStructure> localZ = FieldVector3D
- .crossProduct(lowLOS, highLOS).normalize();
- final DerivativeStructure beta = FieldVector3D
- .dotProduct(crossingResult.getTargetDirection(), localZ).acos();
- final DerivativeStructure s = FieldVector3D
- .dotProduct(crossingResult.getTargetDirectionDerivative(), localZ);
- final DerivativeStructure minusBetaDer = s
- .divide(s.multiply(s).subtract(1).negate().sqrt());
- final DerivativeStructure deltaL = beta.subtract(0.5 * FastMath.PI)
- .divide(minusBetaDer);
- final DerivativeStructure fixedLine = deltaL
- .add(crossingResult.getLine());
- final FieldVector3D<DerivativeStructure> fixedDirection = new FieldVector3D<DerivativeStructure>(deltaL
- .getField().getOne(), crossingResult
- .getTargetDirection(), deltaL, crossingResult
- .getTargetDirectionDerivative()).normalize();
+ // fix line by considering the closest pixel exact position and line-of-sight
+ // (this pixel might point towards a direction slightly above or below the mean sensor plane)
+ final int lowIndex = FastMath.max(0, FastMath.min(sensor.getNbPixels() - 2, (int) FastMath.floor(coarsePixel)));
+ final FieldVector3D<DerivativeStructure> lowLOS =
+ sensor.getLOSDerivatives(crossingResult.getDate(), lowIndex, generator);
+ final FieldVector3D<DerivativeStructure> highLOS = sensor.getLOSDerivatives(crossingResult.getDate(), lowIndex + 1, generator);
+ final FieldVector3D<DerivativeStructure> localZ = FieldVector3D.crossProduct(lowLOS, highLOS).normalize();
+ final DerivativeStructure beta = FieldVector3D.dotProduct(crossingResult.getTargetDirection(), localZ).acos();
+ final DerivativeStructure s = FieldVector3D.dotProduct(crossingResult.getTargetDirectionDerivative(), localZ);
+ final DerivativeStructure minusBetaDer = s.divide(s.multiply(s).subtract(1).negate().sqrt());
+ final DerivativeStructure deltaL = beta.subtract(0.5 * FastMath.PI) .divide(minusBetaDer);
+ final DerivativeStructure fixedLine = deltaL.add(crossingResult.getLine());
+ final FieldVector3D<DerivativeStructure> fixedDirection =
+ new FieldVector3D<DerivativeStructure>(deltaL.getField().getOne(), crossingResult.getTargetDirection(),
+ deltaL, crossingResult.getTargetDirectionDerivative()).normalize();
// fix neighbouring pixels
- final AbsoluteDate fixedDate = sensor.getDate(fixedLine.getValue());
- final FieldVector3D<DerivativeStructure> fixedX = sensor
- .getLOSDerivatives(fixedDate, lowIndex, generator);
- final FieldVector3D<DerivativeStructure> fixedZ = FieldVector3D
- .crossProduct(fixedX, sensor
- .getLOSDerivatives(fixedDate, lowIndex + 1, generator));
- final FieldVector3D<DerivativeStructure> fixedY = FieldVector3D
- .crossProduct(fixedZ, fixedX);
+ final AbsoluteDate fixedDate = sensor.getDate(fixedLine.getValue());
+ final FieldVector3D<DerivativeStructure> fixedX = sensor.getLOSDerivatives(fixedDate, lowIndex, generator);
+ final FieldVector3D<DerivativeStructure> fixedZ = FieldVector3D.crossProduct(fixedX, sensor.getLOSDerivatives(fixedDate, lowIndex + 1, generator));
+ final FieldVector3D<DerivativeStructure> fixedY = FieldVector3D.crossProduct(fixedZ, fixedX);
// fix pixel
- final DerivativeStructure hY = FieldVector3D.dotProduct(highLOS,
- fixedY);
- final DerivativeStructure hX = FieldVector3D.dotProduct(highLOS,
- fixedX);
+ final DerivativeStructure hY = FieldVector3D.dotProduct(highLOS, fixedY);
+ final DerivativeStructure hX = FieldVector3D.dotProduct(highLOS, fixedX);
final DerivativeStructure pixelWidth = hY.atan2(hX);
- final DerivativeStructure fY = FieldVector3D.dotProduct(fixedDirection,
- fixedY);
- final DerivativeStructure fX = FieldVector3D.dotProduct(fixedDirection,
- fixedX);
- final DerivativeStructure alpha = fY.atan2(fX);
- final DerivativeStructure fixedPixel = alpha.divide(pixelWidth)
- .add(lowIndex);
+ final DerivativeStructure fY = FieldVector3D.dotProduct(fixedDirection, fixedY);
+ final DerivativeStructure fX = FieldVector3D.dotProduct(fixedDirection, fixedX);
+ final DerivativeStructure alpha = fY.atan2(fX);
+ final DerivativeStructure fixedPixel = alpha.divide(pixelWidth).add(lowIndex);
return new DerivativeStructure[] {
- fixedLine, fixedPixel
+ fixedLine, fixedPixel
};
}
- /**
- * Get transform from spacecraft to inertial frame.
- *
+ /** Get transform from spacecraft to inertial frame.
* @param date date of the transform
* @return transform from spacecraft to inertial frame
- * @exception RuggedException if spacecraft position or attitude cannot be
- * computed at date
+ * @exception RuggedException if spacecraft position or attitude cannot be computed at date
*/
public Transform getScToInertial(final AbsoluteDate date)
- throws RuggedException {
+ throws RuggedException {
return scToBody.getScToInertial(date);
}
- /**
- * Get transform from inertial frame to observed body frame.
- *
+ /** Get transform from inertial frame to observed body frame.
* @param date date of the transform
* @return transform from inertial frame to observed body frame
* @exception RuggedException if frames cannot be computed at date
*/
public Transform getInertialToBody(final AbsoluteDate date)
- throws RuggedException {
+ throws RuggedException {
return scToBody.getInertialToBody(date);
}
- /**
- * Get transform from observed body frame to inertial frame.
- *
+ /** Get transform from observed body frame to inertial frame.
* @param date date of the transform
* @return transform from observed body frame to inertial frame
* @exception RuggedException if frames cannot be computed at date
*/
public Transform getBodyToInertial(final AbsoluteDate date)
- throws RuggedException {
+ throws RuggedException {
return scToBody.getBodyToInertial(date);
}
- /**
- * Get a sensor.
- *
+ /** Get a sensor.
* @param sensorName sensor name
* @return selected sensor
* @exception RuggedException if sensor is not known
*/
- public LineSensor getLineSensor(final String sensorName)
- throws RuggedException {
+ public LineSensor getLineSensor(final String sensorName) throws RuggedException {
final LineSensor sensor = sensors.get(sensorName);
if (sensor == null) {
- throw new RuggedException(RuggedMessages.UNKNOWN_SENSOR,
- sensorName);
+ throw new RuggedException(RuggedMessages.UNKNOWN_SENSOR, sensorName);
}
return sensor;
}
- /**
- * Get converter between spacecraft and body.
- *
+ /** Get converter between spacecraft and body.
* @return the scToBody
+ * @since 2.0
*/
public SpacecraftToObservedBody getScToBody() {
return scToBody;
diff --git a/src/main/java/org/orekit/rugged/api/RuggedBuilder.java b/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
index d6b7582fce6ed49a96f3d2cb18add5f1ff89b982..66f2fad22c7bc7c8d2d22db395f00758b90d1507 100644
--- a/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
+++ b/src/main/java/org/orekit/rugged/api/RuggedBuilder.java
@@ -162,7 +162,7 @@ public class RuggedBuilder {
/** Sensors. */
private final List<LineSensor> sensors;
- /** Rugged Name. */
+ /** Rugged name. */
private String name;
/** Create a non-configured builder.
@@ -191,7 +191,7 @@ public class RuggedBuilder {
* @see #getEllipsoid()
*/
public RuggedBuilder setEllipsoid(final EllipsoidId ellipsoidID, final BodyRotatingFrameId bodyRotatingFrameID)
- throws RuggedException {
+ throws RuggedException {
return setEllipsoid(selectEllipsoid(ellipsoidID, selectBodyRotatingFrame(bodyRotatingFrameID)));
}
@@ -205,7 +205,7 @@ public class RuggedBuilder {
*/
// CHECKSTYLE: stop HiddenField check
public RuggedBuilder setEllipsoid(final OneAxisEllipsoid ellipsoid)
- throws RuggedException {
+ throws RuggedException {
// CHECKSTYLE: resume HiddenField check
this.ellipsoid = new ExtendedEllipsoid(ellipsoid.getEquatorialRadius(),
ellipsoid.getFlattening(),
@@ -223,22 +223,22 @@ public class RuggedBuilder {
return ellipsoid;
}
- /** Get the rugged name.
- * @return the name
+ /** Get the Rugged name.
+ * @return the Rugged name
+ * @since 2.0
*/
public String getName() {
return name;
}
-
- /** Set the rugged name.
+ /** Set the Rugged name.
* @param name the Rugged name
+ * @since 2.0
*/
public void setName(final String name) {
this.name = name;
}
-
/** Set the algorithm to use for Digital Elevation Model intersection.
* <p>
* Note that some algorithms require specific other methods to be called too:
@@ -442,7 +442,7 @@ public class RuggedBuilder {
final CartesianDerivativesFilter pvFilter,
final List<TimeStampedAngularCoordinates> quaternions, final int aInterpolationNumber,
final AngularDerivativesFilter aFilter)
- throws RuggedException {
+ throws RuggedException {
return setTrajectory(selectInertialFrame(inertialFrame),
positionsVelocities, pvInterpolationNumber, pvFilter,
quaternions, aInterpolationNumber, aFilter);
@@ -599,7 +599,7 @@ public class RuggedBuilder {
* @see #storeInterpolator(OutputStream)
*/
public RuggedBuilder setTrajectoryAndTimeSpan(final InputStream storageStream)
- throws RuggedException {
+ throws RuggedException {
try {
this.inertial = null;
this.pvSample = null;
@@ -663,7 +663,7 @@ public class RuggedBuilder {
*/
private void checkFramesConsistency() throws RuggedException {
if (ellipsoid != null && scToBody != null &&
- !ellipsoid.getBodyFrame().getName().equals(scToBody.getBodyFrame().getName())) {
+ !ellipsoid.getBodyFrame().getName().equals(scToBody.getBodyFrame().getName())) {
throw new RuggedException(RuggedMessages.FRAMES_MISMATCH_WITH_INTERPOLATOR_DUMP,
ellipsoid.getBodyFrame().getName(), scToBody.getBodyFrame().getName());
}
@@ -723,7 +723,7 @@ public class RuggedBuilder {
final List<TimeStampedAngularCoordinates> quaternions,
final int aInterpolationNumber,
final AngularDerivativesFilter aFilter)
- throws RuggedException {
+ throws RuggedException {
return new SpacecraftToObservedBody(inertialFrame, bodyFrame,
minDate, maxDate, tStep, overshootTolerance,
positionsVelocities, pvInterpolationNumber,
@@ -753,20 +753,20 @@ public class RuggedBuilder {
final CartesianDerivativesFilter pvFilter,
final AngularDerivativesFilter aFilter,
final Propagator propagator)
- throws RuggedException {
+ throws RuggedException {
try {
// extract position/attitude samples from propagator
final List<TimeStampedPVCoordinates> positionsVelocities =
- new ArrayList<TimeStampedPVCoordinates>();
+ new ArrayList<TimeStampedPVCoordinates>();
final List<TimeStampedAngularCoordinates> quaternions =
- new ArrayList<TimeStampedAngularCoordinates>();
+ new ArrayList<TimeStampedAngularCoordinates>();
propagator.setMasterMode(interpolationStep, new OrekitFixedStepHandler() {
/** {@inheritDoc} */
@Override
public void handleStep(final SpacecraftState currentState, final boolean isLast)
- throws OrekitException {
+ throws OrekitException {
final AbsoluteDate date = currentState.getDate();
final PVCoordinates pv = currentState.getPVCoordinates(inertialFrame);
final Rotation q = currentState.getAttitude().getRotation();
@@ -909,24 +909,24 @@ public class RuggedBuilder {
* @exception RuggedException if data needed for some frame cannot be loaded
*/
private static Frame selectInertialFrame(final InertialFrameId inertialFrameId)
- throws RuggedException {
+ throws RuggedException {
try {
// set up the inertial frame
switch (inertialFrameId) {
- case GCRF :
- return FramesFactory.getGCRF();
- case EME2000 :
- return FramesFactory.getEME2000();
- case MOD :
- return FramesFactory.getMOD(IERSConventions.IERS_1996);
- case TOD :
- return FramesFactory.getTOD(IERSConventions.IERS_1996, true);
- case VEIS1950 :
- return FramesFactory.getVeis1950();
- default :
- // this should never happen
- throw RuggedException.createInternalError(null);
+ case GCRF :
+ return FramesFactory.getGCRF();
+ case EME2000 :
+ return FramesFactory.getEME2000();
+ case MOD :
+ return FramesFactory.getMOD(IERSConventions.IERS_1996);
+ case TOD :
+ return FramesFactory.getTOD(IERSConventions.IERS_1996, true);
+ case VEIS1950 :
+ return FramesFactory.getVeis1950();
+ default :
+ // this should never happen
+ throw RuggedException.createInternalError(null);
}
} catch (OrekitException oe) {
throw new RuggedException(oe, oe.getSpecifier(), oe.getParts().clone());
@@ -940,20 +940,20 @@ public class RuggedBuilder {
* @exception RuggedException if data needed for some frame cannot be loaded
*/
private static Frame selectBodyRotatingFrame(final BodyRotatingFrameId bodyRotatingFrame)
- throws RuggedException {
+ throws RuggedException {
try {
// set up the rotating frame
switch (bodyRotatingFrame) {
- case ITRF :
- return FramesFactory.getITRF(IERSConventions.IERS_2010, true);
- case ITRF_EQUINOX :
- return FramesFactory.getITRFEquinox(IERSConventions.IERS_1996, true);
- case GTOD :
- return FramesFactory.getGTOD(IERSConventions.IERS_1996, true);
- default :
- // this should never happen
- throw RuggedException.createInternalError(null);
+ case ITRF :
+ return FramesFactory.getITRF(IERSConventions.IERS_2010, true);
+ case ITRF_EQUINOX :
+ return FramesFactory.getITRFEquinox(IERSConventions.IERS_1996, true);
+ case GTOD :
+ return FramesFactory.getGTOD(IERSConventions.IERS_1996, true);
+ default :
+ // this should never happen
+ throw RuggedException.createInternalError(null);
}
} catch (OrekitException oe) {
throw new RuggedException(oe, oe.getSpecifier(), oe.getParts().clone());
@@ -970,19 +970,19 @@ public class RuggedBuilder {
// set up the ellipsoid
switch (ellipsoidID) {
- case GRS80 :
- return new OneAxisEllipsoid(6378137.0, 1.0 / 298.257222101, bodyFrame);
- case WGS84 :
- return new OneAxisEllipsoid(Constants.WGS84_EARTH_EQUATORIAL_RADIUS,
- Constants.WGS84_EARTH_FLATTENING,
- bodyFrame);
- case IERS96 :
- return new OneAxisEllipsoid(6378136.49, 1.0 / 298.25645, bodyFrame);
- case IERS2003 :
- return new OneAxisEllipsoid(6378136.6, 1.0 / 298.25642, bodyFrame);
- default :
- // this should never happen
- throw RuggedException.createInternalError(null);
+ case GRS80 :
+ return new OneAxisEllipsoid(6378137.0, 1.0 / 298.257222101, bodyFrame);
+ case WGS84 :
+ return new OneAxisEllipsoid(Constants.WGS84_EARTH_EQUATORIAL_RADIUS,
+ Constants.WGS84_EARTH_FLATTENING,
+ bodyFrame);
+ case IERS96 :
+ return new OneAxisEllipsoid(6378136.49, 1.0 / 298.25645, bodyFrame);
+ case IERS2003 :
+ return new OneAxisEllipsoid(6378136.6, 1.0 / 298.25642, bodyFrame);
+ default :
+ // this should never happen
+ throw RuggedException.createInternalError(null);
}
}
@@ -1000,19 +1000,19 @@ public class RuggedBuilder {
// set up the algorithm
switch (algorithmID) {
- case DUVENHAGE :
- return new DuvenhageAlgorithm(updater, maxCachedTiles, false);
- case DUVENHAGE_FLAT_BODY :
- return new DuvenhageAlgorithm(updater, maxCachedTiles, true);
- case BASIC_SLOW_EXHAUSTIVE_SCAN_FOR_TESTS_ONLY :
- return new BasicScanAlgorithm(updater, maxCachedTiles);
- case CONSTANT_ELEVATION_OVER_ELLIPSOID :
- return new ConstantElevationAlgorithm(constantElevation);
- case IGNORE_DEM_USE_ELLIPSOID :
- return new IgnoreDEMAlgorithm();
- default :
- // this should never happen
- throw RuggedException.createInternalError(null);
+ case DUVENHAGE :
+ return new DuvenhageAlgorithm(updater, maxCachedTiles, false);
+ case DUVENHAGE_FLAT_BODY :
+ return new DuvenhageAlgorithm(updater, maxCachedTiles, true);
+ case BASIC_SLOW_EXHAUSTIVE_SCAN_FOR_TESTS_ONLY :
+ return new BasicScanAlgorithm(updater, maxCachedTiles);
+ case CONSTANT_ELEVATION_OVER_ELLIPSOID :
+ return new ConstantElevationAlgorithm(constantElevation);
+ case IGNORE_DEM_USE_ELLIPSOID :
+ return new IgnoreDEMAlgorithm();
+ default :
+ // this should never happen
+ throw RuggedException.createInternalError(null);
}
}
diff --git a/src/main/java/org/orekit/rugged/errors/RuggedMessages.java b/src/main/java/org/orekit/rugged/errors/RuggedMessages.java
index 46e8b6a4994f406e973deb69341392a5b720c3ba..4a6854d741483a1ca57b756d6011ec9a59203681 100644
--- a/src/main/java/org/orekit/rugged/errors/RuggedMessages.java
+++ b/src/main/java/org/orekit/rugged/errors/RuggedMessages.java
@@ -80,8 +80,8 @@ public enum RuggedMessages implements Localizable {
NO_PARAMETERS_SELECTED("no parameters have been selected for estimation"),
NO_REFERENCE_MAPPINGS("no reference mappings for parameters estimation"),
DUPLICATED_PARAMETER_NAME("a different parameter with name {0} already exists"),
- INVALID_RUGGED_NAME("invalid rugged name."),
- UNSUPPORTED_REFINING_CONTEXT("refining using {0} rugged instance is not handled."),
+ INVALID_RUGGED_NAME("invalid rugged name"),
+ UNSUPPORTED_REFINING_CONTEXT("refining using {0} rugged instance is not handled"),
NO_LAYER_DATA("no atmospheric layer data at altitude {0} (lowest altitude: {1})");
// CHECKSTYLE: resume JavadocVariable check
@@ -111,12 +111,12 @@ public enum RuggedMessages implements Localizable {
public String getLocalizedString(final Locale locale) {
try {
final ResourceBundle bundle =
- ResourceBundle.getBundle(RESOURCE_BASE_NAME, locale, new UTF8Control());
+ ResourceBundle.getBundle(RESOURCE_BASE_NAME, locale, new UTF8Control());
if (bundle.getLocale().getLanguage().equals(locale.getLanguage())) {
final String translated = bundle.getString(name());
if ((translated != null) &&
- (translated.length() > 0) &&
- (!translated.toLowerCase().contains("missing translation"))) {
+ (translated.length() > 0) &&
+ (!translated.toLowerCase().contains("missing translation"))) {
// the value of the resource is the translated format
return translated;
}
@@ -145,7 +145,7 @@ public enum RuggedMessages implements Localizable {
@Override
public ResourceBundle newBundle(final String baseName, final Locale locale, final String format,
final ClassLoader loader, final boolean reload)
- throws IllegalAccessException, InstantiationException, IOException {
+ throws IllegalAccessException, InstantiationException, IOException {
// The below is a copy of the default implementation.
final String bundleName = toBundleName(baseName, locale);
final String resourceName = toResourceName(bundleName, "utf8");
diff --git a/src/main/java/org/orekit/rugged/linesensor/LineDatation.java b/src/main/java/org/orekit/rugged/linesensor/LineDatation.java
index ce0e754e145b1e8c4bfa26ffac36c4062abb2c51..4147815c0cbaa5d2880db33b9f7d6ad7c005f859 100644
--- a/src/main/java/org/orekit/rugged/linesensor/LineDatation.java
+++ b/src/main/java/org/orekit/rugged/linesensor/LineDatation.java
@@ -21,7 +21,6 @@ import org.orekit.time.AbsoluteDate;
/** Interface representing line datation model.
* @see LinearLineDatation
* @author Luc Maisonobe
- * @author Guylaine Prat
*/
public interface LineDatation {
diff --git a/src/main/java/org/orekit/rugged/linesensor/LineSensor.java b/src/main/java/org/orekit/rugged/linesensor/LineSensor.java
index 5e1f1071a260c34046c1d5b2044ffaaf9532baf3..cdb946d8ffb6de438b3f2c51e559b5a50f647c19 100644
--- a/src/main/java/org/orekit/rugged/linesensor/LineSensor.java
+++ b/src/main/java/org/orekit/rugged/linesensor/LineSensor.java
@@ -104,6 +104,7 @@ public class LineSensor {
* @param i pixel index (must be between 0 and {@link #getNbPixels()} - 1
* @return pixel normalized line-of-sight
* @exception RuggedException if date cannot be handled
+ * @since 2.0
*/
public Vector3D getLOS(final AbsoluteDate date, final double i)
throws RuggedException {
@@ -121,6 +122,7 @@ public class LineSensor {
* @param i pixel index (must be between 0 and {@link #getNbPixels()} - 1
* @param generator generator to use for building {@link DerivativeStructure} instances
* @return pixel normalized line-of-sight
+ * @since 2.0
*/
public FieldVector3D<DerivativeStructure> getLOSDerivatives(final AbsoluteDate date, final int i,
final DSGenerator generator) {
@@ -133,6 +135,7 @@ public class LineSensor {
* @param i pixel index (must be between 0 and {@link #getNbPixels()} - 1
* @param generator generator to use for building {@link DerivativeStructure} instances
* @return pixel normalized line-of-sight
+ * @since 2.0
*/
public FieldVector3D<DerivativeStructure> getLOSDerivatives(final AbsoluteDate date, final double i,
final DSGenerator generator) {
diff --git a/src/main/java/org/orekit/rugged/linesensor/LinearLineDatation.java b/src/main/java/org/orekit/rugged/linesensor/LinearLineDatation.java
index f23f35cf61bedede23228bf7da9ab3292e7327ac..0f890c2d1f58203ee75be1192f7e2948d83b2860 100644
--- a/src/main/java/org/orekit/rugged/linesensor/LinearLineDatation.java
+++ b/src/main/java/org/orekit/rugged/linesensor/LinearLineDatation.java
@@ -24,8 +24,6 @@ import org.orekit.time.AbsoluteDate;
* Instances of this class are guaranteed to be immutable.
* </p>
* @author Luc Maisonobe
- * @author Guylaine Prat
-
*/
public class LinearLineDatation implements LineDatation {
diff --git a/src/main/java/org/orekit/rugged/linesensor/SensorMeanPlaneCrossing.java b/src/main/java/org/orekit/rugged/linesensor/SensorMeanPlaneCrossing.java
index 2f1f965611084814c945d9c970661711b3e65cb9..28aa64063f7243ca8958e2109d4fdfbf9c9715c4 100644
--- a/src/main/java/org/orekit/rugged/linesensor/SensorMeanPlaneCrossing.java
+++ b/src/main/java/org/orekit/rugged/linesensor/SensorMeanPlaneCrossing.java
@@ -343,6 +343,7 @@ public class SensorMeanPlaneCrossing {
/** Get the derivative of the normalized target direction in spacecraft frame at crossing.
* @return derivative of the normalized target direction in spacecraft frame at crossing
* with respect to line number
+ * @since 2.0
*/
public Vector3D getTargetDirectionDerivative() {
return targetDirectionDerivative;
diff --git a/src/main/java/org/orekit/rugged/los/FixedZHomothety.java b/src/main/java/org/orekit/rugged/los/FixedZHomothety.java
index 1eb226b85c3b5b059e550218995285a0fcafd543..8b05b494811b879d7c200349d6d5524c6aab8c0a 100644
--- a/src/main/java/org/orekit/rugged/los/FixedZHomothety.java
+++ b/src/main/java/org/orekit/rugged/los/FixedZHomothety.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -31,7 +31,9 @@ import org.orekit.utils.ParameterObserver;
/** {@link TimeIndependentLOSTransform LOS transform} based on a homothety along the Z axis.
* inspired from FixedZHomothety / s2geolib
* @author Lucie Labatallee
+ * @author Guylaine Prat
* @see LOSBuilder
+ * @since 2.0
*/
public class FixedZHomothety implements TimeIndependentLOSTransform {
@@ -69,7 +71,6 @@ public class FixedZHomothety implements TimeIndependentLOSTransform {
public void valueChanged(final double previousValue, final ParameterDriver driver) {
// reset factor to zero, they will be evaluated lazily if needed
factor = 0.0;
-// System.out.format("Value changed: %f %n", factorDriver.getValue());
factorDS = null;
}
});
diff --git a/src/main/java/org/orekit/rugged/los/PolynomialRotation.java b/src/main/java/org/orekit/rugged/los/PolynomialRotation.java
index bec75818f6defd97a6a95a28e947f834551c4494..4f6c6b93e8aacf326901fe182693e9fe1d4baaa5 100644
--- a/src/main/java/org/orekit/rugged/los/PolynomialRotation.java
+++ b/src/main/java/org/orekit/rugged/los/PolynomialRotation.java
@@ -125,7 +125,9 @@ public class PolynomialRotation implements LOSTransform {
this(name, axis, referenceDate, angle.getCoefficients());
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 2.0
+ */
@Override
public Stream<ParameterDriver> getParametersDrivers() {
return Stream.of(coefficientsDrivers);
diff --git a/src/main/java/org/orekit/rugged/los/TimeDependentLOS.java b/src/main/java/org/orekit/rugged/los/TimeDependentLOS.java
index 44b8f2908f0fade1179eec44f19af44ae6e43654..e069995e0ae672c45628ef1b2e7bb9792a8580b4 100644
--- a/src/main/java/org/orekit/rugged/los/TimeDependentLOS.java
+++ b/src/main/java/org/orekit/rugged/los/TimeDependentLOS.java
@@ -60,6 +60,7 @@ public interface TimeDependentLOS {
* @param date date
* @param generator generator to use for building {@link DerivativeStructure} instances
* @return line of sight, and its first partial derivatives with respect to the parameters
+ * @since 2.0
*/
FieldVector3D<DerivativeStructure> getLOSDerivatives(int index, AbsoluteDate date,
DSGenerator generator);
diff --git a/src/main/java/org/orekit/rugged/refining/generators/GroundMeasureGenerator.java b/src/main/java/org/orekit/rugged/refining/generators/GroundMeasureGenerator.java
index 948712eba8fbe51c2a0bc8bd85ecd26f13b14932..6d9bc4c6852e6dc218b649d9a4830a49f5b1f888 100644
--- a/src/main/java/org/orekit/rugged/refining/generators/GroundMeasureGenerator.java
+++ b/src/main/java/org/orekit/rugged/refining/generators/GroundMeasureGenerator.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -29,60 +29,64 @@ import org.orekit.rugged.linesensor.SensorPixel;
import org.orekit.rugged.refining.measures.Noise;
import org.orekit.rugged.refining.measures.Observables;
import org.orekit.rugged.refining.measures.SensorToGroundMapping;
-import org.orekit.rugged.refining.metrics.DistanceTools;
import org.orekit.time.AbsoluteDate;
-
-
/** Ground measures generator (sensor to ground mapping).
* @author Jonathan Guinet
- * @autor Lucie Labat-Allee
+ * @author Lucie Labat-Allee
+ * @author Guylaine Prat
+ * @since 2.0
*/
public class GroundMeasureGenerator implements Measurable {
-
- /** mapping. */
+ /** Sensor to ground mapping. */
private SensorToGroundMapping groundMapping;
- /** observables which contains ground mapping. */
+ /** Observables which contains ground mapping. */
private Observables observables;
+ /** Rugged instance */
private Rugged rugged;
+ /** Line sensor */
private LineSensor sensor;
- private int measureCount;
-
+ /** Number of lines of the sensor */
private int dimension;
+
+ /** Number of measures */
+ private int measureCount;
/** Simple constructor.
- * <p>
- *
- * </p>
+ * @param rugged Rugged instance
+ * @param sensorName sensor name
+ * @param dimension number of line of the sensor
+ * @throws RuggedException
*/
- public GroundMeasureGenerator(final Rugged rugged, final String sensorName, final int dimension) throws RuggedException
- {
-
- // generate reference mapping
- groundMapping = new SensorToGroundMapping(rugged.getName(), sensorName);
+ public GroundMeasureGenerator(final Rugged rugged, final String sensorName, final int dimension)
+ throws RuggedException {
+
+ // Generate reference mapping
+ this.groundMapping = new SensorToGroundMapping(rugged.getName(), sensorName);
- //create observables for one model
+ // Create observables for one model
this.observables = new Observables(1);
this.rugged = rugged;
- sensor = rugged.getLineSensor(groundMapping.getSensorName());
- measureCount = 0;
+ this.sensor = rugged.getLineSensor(groundMapping.getSensorName());
this.dimension = dimension;
-
+ this.measureCount = 0;
}
+ /** Get the sensor to ground mapping
+ * @return the sensor to ground mapping
+ */
public SensorToGroundMapping getGroundMapping() {
return groundMapping;
}
-
- /** getter for observables.
- * @return the observables
+ /** Get the observables which contains the ground mapping
+ * @return the observables which contains the ground mapping
*/
public Observables getObservables() {
return observables;
@@ -94,50 +98,52 @@ public class GroundMeasureGenerator implements Measurable {
}
@Override
- public void createMeasure(final int lineSampling, final int pixelSampling)
- throws RuggedException {
+ public void createMeasure(final int lineSampling, final int pixelSampling) throws RuggedException {
+
for (double line = 0; line < dimension; line += lineSampling) {
final AbsoluteDate date = sensor.getDate(line);
+
for (int pixel = 0; pixel < sensor.getNbPixels(); pixel += pixelSampling) {
final GeodeticPoint gp2 = rugged.directLocation(date, sensor.getPosition(),
sensor.getLOS(date, pixel));
groundMapping.addMapping(new SensorPixel(line, pixel), gp2);
+
+ // increment the number of measures
measureCount++;
}
}
+
observables.addGroundMapping(groundMapping);
}
@Override
public void createNoisyMeasure(final int lineSampling, final int pixelSampling, final Noise noise)
throws RuggedException {
- /* Estimate latitude and longitude errors estimation */
+
+ // Estimate latitude and longitude errors (rad)
final Vector3D latLongError = estimateLatLongError();
- /* Get noise features */
- final double[] mean = noise.getMean(); /* [latitude, longitude, altitude] mean */
- final double[] std = noise.getStandardDeviation(); /* [latitude, longitude, altitude] standard deviation */
+ // Get noise features
+ final double[] mean = noise.getMean(); // [latitude, longitude, altitude] mean
+ final double[] std = noise.getStandardDeviation(); // [latitude, longitude, altitude] standard deviation
- final double latErrorMean = mean[0] * latLongError.getX(); // in line: -0.000002 deg
- final double lonErrorMean = mean[1] * latLongError.getY(); // in line: 0.000012 deg
- final double latErrorStd = std[0] * latLongError.getX(); // in line: -0.000002 deg
- final double lonErrorStd = std[1] * latLongError.getY(); // in line: 0.000012 deg
+ final double latErrorMean = mean[0] * latLongError.getX();
+ final double lonErrorMean = mean[1] * latLongError.getY();
+ final double latErrorStd = std[0] * latLongError.getX();
+ final double lonErrorStd = std[1] * latLongError.getY();
// Gaussian random generator
// Build a null mean random uncorrelated vector generator with standard deviation corresponding to the estimated error on ground
final double meanGenerator[] = {latErrorMean, lonErrorMean, mean[2]};
final double stdGenerator[] = {latErrorStd, lonErrorStd, std[2]};
- System.out.format("Corresponding error estimation on ground {Latitude, Longitude, Altitude}:%n");
- System.out.format("\tMean: {%1.10f rad, %1.10f rad, %1.10f m} %n", meanGenerator[0], meanGenerator[1], meanGenerator[2]);
- System.out.format("\tStd : {%1.10f rad, %1.10f rad, %1.10f m} %n", stdGenerator[0], stdGenerator[1], stdGenerator[2]);
+ // TODO GP commentaire sur la seed du generator ???
final GaussianRandomGenerator rng = new GaussianRandomGenerator(new Well19937a(0xefac03d9be4d24b9l));
final UncorrelatedRandomVectorGenerator rvg = new UncorrelatedRandomVectorGenerator(meanGenerator, stdGenerator, rng);
- System.out.format("Add a gaussian noise to measures without biais (null mean) and standard deviation%n corresponding to the estimated error on ground.%n");
for (double line = 0; line < dimension; line += lineSampling) {
final AbsoluteDate date = sensor.getDate(line);
@@ -154,38 +160,39 @@ public class GroundMeasureGenerator implements Measurable {
gp2.getLongitude() + vecRandom.getY(),
gp2.getAltitude() + vecRandom.getZ());
- //if(line == 0) {
- // System.out.format("Init gp: (%f,%d): %s %n",line,pixel,gp2.toString());
- // System.out.format("Random: (%f,%d): %s %n",line,pixel,vecRandom.toString());
- // System.out.format("Final gp: (%f,%d): %s %n",line,pixel,gpNoisy.toString());
- //}
-
groundMapping.addMapping(new SensorPixel(line, pixel), gpNoisy);
+
+ // increment the number of measures
measureCount++;
}
}
+
this.observables.addGroundMapping(groundMapping);
}
+ /** Compute latitude and longitude errors
+ * @return the latitude and longitude errors (rad)
+ * @throws RuggedException
+ */
private Vector3D estimateLatLongError() throws RuggedException {
- System.out.format("Uncertainty in pixel (in line) for a real geometric refining: 1 pixel (assumption)%n");
+ // TODO GP add explanation
+
final int pix = sensor.getNbPixels() / 2;
final int line = (int) FastMath.floor(pix); // assumption : same number of line and pixels;
- System.out.format("Pixel size estimated at position pix: %d line: %d %n", pix, line);
+
final AbsoluteDate date = sensor.getDate(line);
final GeodeticPoint gp_pix0 = rugged.directLocation(date, sensor.getPosition(), sensor.getLOS(date, pix));
+
final AbsoluteDate date1 = sensor.getDate(line + 1);
final GeodeticPoint gp_pix1 = rugged.directLocation(date1, sensor.getPosition(), sensor.getLOS(date1, pix + 1));
+
final double latErr = FastMath.abs(gp_pix0.getLatitude() - gp_pix1.getLatitude());
final double lonErr = FastMath.abs(gp_pix0.getLongitude() - gp_pix1.getLongitude());
- //double dist = FastMath.sqrt(lonErr*lonErr + latErr*latErr)/FastMath.sqrt(2);
- final double distanceX = DistanceTools.computeDistanceInMeter(gp_pix0.getLongitude(), gp_pix0.getLatitude(), gp_pix1.getLongitude(), gp_pix0.getLatitude());
- final double distanceY = DistanceTools.computeDistanceInMeter(gp_pix0.getLongitude(), gp_pix0.getLatitude(), gp_pix0.getLongitude(), gp_pix1.getLatitude());
-
- System.out.format("Estimated distance: X %3.3f Y %3.3f %n", distanceX, distanceY);
+
+// final double distanceX = DistanceTools.computeDistanceInMeter(gp_pix0.getLongitude(), gp_pix0.getLatitude(), gp_pix1.getLongitude(), gp_pix0.getLatitude());
+// final double distanceY = DistanceTools.computeDistanceInMeter(gp_pix0.getLongitude(), gp_pix0.getLatitude(), gp_pix0.getLongitude(), gp_pix1.getLatitude());
- //System.out.format(" lat : %1.10f %1.10f %n", latErr, lonErr);
return new Vector3D(latErr, lonErr, 0.0);
}
}
diff --git a/src/main/java/org/orekit/rugged/refining/generators/InterMeasureGenerator.java b/src/main/java/org/orekit/rugged/refining/generators/InterMeasureGenerator.java
index 1f1c74b6adf4c6b2a0131731ecb680a0c8eba20b..3fa808ad7350ca6efeaf20023b67b8a9640aad91 100644
--- a/src/main/java/org/orekit/rugged/refining/generators/InterMeasureGenerator.java
+++ b/src/main/java/org/orekit/rugged/refining/generators/InterMeasureGenerator.java
@@ -37,42 +37,56 @@ import org.orekit.time.AbsoluteDate;
* Inter-measures generator (sensor to sensor mapping).
* @author Jonathan Guinet
* @author Lucie Labatallee
+ * @author Guylaine Prat
+ * @since 2.0
*/
public class InterMeasureGenerator implements Measurable {
- /** mapping. */
+ /** Mapping from sensor A to sensor B. */
private SensorToSensorMapping interMapping;
- /** observables which contains sensor to sensor mapping.*/
+ /** Observables which contains sensor to sensor mapping.*/
private Observables observables;
+ /** Rugged instance corresponding to the viewing model A */
private Rugged ruggedA;
+ /** Rugged instance corresponding to the viewing model B */
private Rugged ruggedB;
+ /** Sensor A */
private LineSensor sensorA;
+ /** Sensor B */
private LineSensor sensorB;
+ /** Number of measures */
private int measureCount;
- private String sensorNameA;
+ // TODO GP pas utilise ...
+ // private String sensorNameA;
+ /** Sensor name B */
private String sensorNameB;
+ /** Number of line for acquisition A */
private int dimensionA;
+ /** Number of line for acquisition B */
private int dimensionB;
-
+
+ /** Limit value for outlier points */
private double outlier;
/** Default constructor: measures generation without outlier points control
* and without Earth distance constraint.
- * @param viewingModelA
- * @param ruggedA
- * @param viewingModelB
- * @param ruggedB
+ * @param ruggedA Rugged instance corresponding to the viewing model A
+ * @param sensorNameA sensor name A
+ * @param dimensionA number of line for acquisition A
+ * @param ruggedB Rugged instance corresponding to the viewing model B
+ * @param sensorNameB sensor name B
+ * @param dimensionB number of line for acquisition B
* @throws RuggedException
*/
public InterMeasureGenerator(final Rugged ruggedA, final String sensorNameA, final int dimensionA,
@@ -82,10 +96,10 @@ public class InterMeasureGenerator implements Measurable {
// Initialize parameters
initParams(ruggedA, sensorNameA, dimensionA, ruggedB, sensorNameB, dimensionB);
- // generate reference mapping, without Earth distance constraint
+ // Generate reference mapping, without Earth distance constraint
interMapping = new SensorToSensorMapping(sensorNameA, sensorNameB);
- //create observables for two models
+ // Create observables for two models
observables = new Observables(2);
}
@@ -93,8 +107,12 @@ public class InterMeasureGenerator implements Measurable {
/** Constructor for measures generation taking into account outlier points control,
* without Earth distance constraint.
* @param ruggedA Rugged instance corresponding to the viewing model A
+ * @param sensorNameA sensor name A
+ * @param dimensionA dimension for acquisition A
* @param ruggedB Rugged instance corresponding to the viewing model B
- * @param outlier limit value of outlier points
+ * @param sensorNameB sensor name B
+ * @param dimensionB dimension for acquisition B
+ * @param outlier limit value for outlier points
* @throws RuggedException
*/
public InterMeasureGenerator(final Rugged ruggedA, final String sensorNameA, final int dimensionA,
@@ -104,19 +122,20 @@ public class InterMeasureGenerator implements Measurable {
this(ruggedA, sensorNameA, dimensionA, ruggedB, sensorNameB, dimensionB);
this.outlier = outlier;
-
}
-
/** Constructor for measures generation taking into account outlier points control,
* and Earth distance constraint.
* @param ruggedA Rugged instance corresponding to the viewing model A
+ * @param sensorNameA sensor name A
+ * @param dimensionA dimension for acquisition A
* @param ruggedB Rugged instance corresponding to the viewing model B
- * @param outlier limit value of outlier points
+ * @param sensorNameB sensor name B
+ * @param dimensionB dimension for acquisition B
+ * @param outlier limit value for outlier points
* @param earthConstraintWeight weight given to the Earth distance constraint
* with respect to the LOS distance (between 0 and 1).
* @throws RuggedException
- * @see Rugged#estimateFreeParams2Models
*/
public InterMeasureGenerator(final Rugged ruggedA, final String sensorNameA, final int dimensionA,
final Rugged ruggedB, final String sensorNameB, final int dimensionB,
@@ -126,25 +145,28 @@ public class InterMeasureGenerator implements Measurable {
// Initialize parameters
initParams(ruggedA, sensorNameA, dimensionA, ruggedB, sensorNameB, dimensionB);
- // generate reference mapping, with Earth distance constraints
+ // Generate reference mapping, with Earth distance constraints.
// Weighting will be applied as follow :
- // (1-earthConstraintWeight) for losDistance weighting
- // earthConstraintWeight for earthDistance weighting
+ // (1-earthConstraintWeight) for losDistance weighting
+ // earthConstraintWeight for earthDistance weighting
interMapping = new SensorToSensorMapping(sensorNameA, ruggedA.getName(), sensorNameB, ruggedB.getName(), earthConstraintWeight);
- // outlier points control
+ // Outlier points control
this.outlier = outlier;
+ // Observables which contains sensor to sensor mapping
this.observables = new Observables(2);
-
}
+ /** Get the mapping from sensor A to sensor B
+ * @return the mapping from sensor A to sensor B
+ */
public SensorToSensorMapping getInterMapping() {
return interMapping;
}
- /** getter for observables.
- * @return the observables
+ /** Get the observables which contains sensor to sensor mapping
+ * @return the observables which contains sensor to sensor mapping
*/
public Observables getObservables() {
return observables;
@@ -172,9 +194,11 @@ public class InterMeasureGenerator implements Measurable {
sensorA.getLOS(dateA, pixelA));
final SensorPixel sensorPixelB = ruggedB.inverseLocation(sensorNameB, gpA, minLine, maxLine);
- // we need to test if the sensor pixel is found in the
- // prescribed lines otherwise the sensor pixel is null
+
+ // We need to test if the sensor pixel is found in the prescribed lines
+ // otherwise the sensor pixel is null
if (sensorPixelB != null) {
+
final AbsoluteDate dateB = sensorB.getDate(sensorPixelB.getLineNumber());
final double pixelB = sensorPixelB.getPixelNumber();
final SpacecraftToObservedBody scToBodyA = ruggedA.getScToBody();
@@ -185,73 +209,61 @@ public class InterMeasureGenerator implements Measurable {
final double GEOdistance = DistanceTools.computeDistanceInMeter(gpA.getLongitude(), gpA.getLatitude(),
gpB.getLongitude(), gpB.getLatitude());
- if (GEOdistance < this.outlier)
- {
- /*System.out.format("A line %2.3f pixel %2.3f %n", line, pixelA);*/
-
+ if (GEOdistance < this.outlier) {
+
final SensorPixel RealPixelA = new SensorPixel(line, pixelA);
-
- final SensorPixel RealPixelB = new SensorPixel(sensorPixelB.getLineNumber(),
- sensorPixelB.getPixelNumber());
+ final SensorPixel RealPixelB = new SensorPixel(sensorPixelB.getLineNumber(), sensorPixelB.getPixelNumber());
final AbsoluteDate RealDateA = sensorA.getDate(RealPixelA.getLineNumber());
final AbsoluteDate RealDateB = sensorB.getDate(RealPixelB.getLineNumber());
final double[] distanceLOSB = ruggedB.distanceBetweenLOS(sensorA, RealDateA, RealPixelA.getPixelNumber(), scToBodyA,
sensorB, RealDateB, RealPixelB.getPixelNumber());
-
final double losDistance = 0.0;
final double earthDistance = distanceLOSB[1];
interMapping.addMapping(RealPixelA, RealPixelB, losDistance, earthDistance);
- measureCount++;
- }
- else
- {
- /*System.out.format("A line %2.3f pixel %2.3f %n rejected ", line, pixelA);*/
+
+ // increment the number of measures
+ this.measureCount++;
}
}
}
}
+
this.observables.addInterMapping(interMapping);
}
- /** tie point creation from directLocation with RuggedA and inverse location.
- * with RuggedB
+ /** Tie point creation from direct 1ocation with Rugged A and inverse location with Rugged B
* @param lineSampling sampling along lines
* @param pixelSampling sampling along columns
- * @param noise error tabulation
+ * @param noise errors to apply to measure for pixel A and pixel B
* @throws RuggedException
*/
- @Override
public void createNoisyMeasure(final int lineSampling, final int pixelSampling, final Noise noise)
throws RuggedException {
- /* Get noise features (errors) */
- final double[] mean = noise.getMean(); /* [pixelA, pixelB] mean */
- final double[] std = noise.getStandardDeviation(); /* [pixelA, pixelB] standard deviation */
+ // Get noise features (errors)
+ // [pixelA, pixelB] mean
+ final double[] mean = noise.getMean();
+ // [pixelA, pixelB] standard deviation
+ final double[] std = noise.getStandardDeviation();
- // Search the sensor pixel seeing point
+ // Search the sensor pixel seeing point
final int minLine = 0;
final int maxLine = dimensionB - 1;
- final double meanA[] = {
- mean[0], mean[0]
- };
- final double stdA[] = {
- std[0], std[0]
- };
- final double meanB[] = {
- mean[1], mean[1]
- };
- final double stdB[] = {
- std[1], std[1]
- };
+ final double meanA[] = { mean[0], mean[0] };
+ final double stdA[] = { std[0], std[0] };
+ final double meanB[] = { mean[1], mean[1] };
+ final double stdB[] = { std[1], std[1] };
+ // TODO GP explanation about seed ???
final GaussianRandomGenerator rngA = new GaussianRandomGenerator(new Well19937a(0xefac03d9be4d24b9l));
final UncorrelatedRandomVectorGenerator rvgA = new UncorrelatedRandomVectorGenerator(meanA, stdA, rngA);
+ // TODO GP explanation about seed ???
final GaussianRandomGenerator rngB = new GaussianRandomGenerator(new Well19937a(0xdf1c03d9be0b34b9l));
final UncorrelatedRandomVectorGenerator rvgB = new UncorrelatedRandomVectorGenerator(meanB, stdB, rngB);
@@ -262,59 +274,31 @@ public class InterMeasureGenerator implements Measurable {
final GeodeticPoint gpA = ruggedA.directLocation(dateA, sensorA.getPosition(),
sensorA.getLOS(dateA, pixelA));
-
final SensorPixel sensorPixelB = ruggedB.inverseLocation(sensorNameB, gpA, minLine, maxLine);
- // we need to test if the sensor pixel is found in the
- // prescribed lines otherwise the sensor pixel is null
+
+ // We need to test if the sensor pixel is found in the prescribed lines
+ // otherwise the sensor pixel is null
if (sensorPixelB != null) {
- //System.out.format(" %n");
+
final AbsoluteDate dateB = sensorB.getDate(sensorPixelB.getLineNumber());
final double pixelB = sensorPixelB.getPixelNumber();
+
+ // Get spacecraft to body transform of Rugged instance A
final SpacecraftToObservedBody scToBodyA = ruggedA.getScToBody();
- //System.out.format("%n distance %1.8e dist %f %n",distanceLOSB[0],distanceLOSB[1]);
- // Get spacecraft to body transform of rugged instance A
-
- /*final SpacecraftToObservedBody scToBodyA = ruggedA
- .getScToBody();
- final SpacecraftToObservedBody scToBodyB = ruggedB
- .getScToBody();
-
- double distanceLOSB = ruggedB
- .distanceBetweenLOS(sensorA, dateA, pixelA, scToBodyA,
- sensorB, dateB, pixelB);
- double distanceLOSA = ruggedA
- .distanceBetweenLOS(sensorB, dateB, pixelB, scToBodyB,
- sensorA, dateA, pixelA);*/
-
- //System.out.format("distance LOS %1.8e %1.8e %n",distanceLOSB,distanceLOSA);
-
-
final GeodeticPoint gpB = ruggedB.directLocation(dateB, sensorB.getPosition(),
sensorB.getLOS(dateB, pixelB));
-
final double GEOdistance = DistanceTools.computeDistanceInMeter(gpA.getLongitude(), gpA.getLatitude(),
gpB.getLongitude(), gpB.getLatitude());
-
+ // TODO GP explanation about computation here
if (GEOdistance < outlier) {
- /*System.out.format("A line %2.3f pixel %2.3f %n", line,
- pixelA);*/
final double[] vecRandomA = rvgA.nextVector();
final double[] vecRandomB = rvgB.nextVector();
- final SensorPixel RealPixelA = new SensorPixel(line + vecRandomA[0],
- pixelA + vecRandomA[1]);
+ final SensorPixel RealPixelA = new SensorPixel(line + vecRandomA[0], pixelA + vecRandomA[1]);
final SensorPixel RealPixelB = new SensorPixel(sensorPixelB.getLineNumber() + vecRandomB[0],
sensorPixelB.getPixelNumber() + vecRandomB[1]);
- /*System.out.format("pix A %f %f Real %f %f %n", line,
- pixelA, RealPixelA.getLineNumber(),
- RealPixelA.getPixelNumber());
- System.out.format("pix B %f %f Real %f %f %n",
- sensorPixelB.getLineNumber(),
- sensorPixelB.getPixelNumber(),
- RealPixelB.getLineNumber(),
- RealPixelB.getPixelNumber());*/
final AbsoluteDate RealDateA = sensorA.getDate(RealPixelA.getLineNumber());
final AbsoluteDate RealDateB = sensorB.getDate(RealPixelB.getLineNumber());
final double[] distanceLOSB = ruggedB.distanceBetweenLOS(sensorA, RealDateA, RealPixelA.getPixelNumber(), scToBodyA,
@@ -323,52 +307,46 @@ public class InterMeasureGenerator implements Measurable {
final Double earthDistance = distanceLOSB[1];
interMapping.addMapping(RealPixelA, RealPixelB, losDistance, earthDistance);
- measureCount++;
- }
- else
- {
- /*System.out.format("A line %2.3f pixel %2.3f %n rejected ", line,
- pixelA);*/
+
+ // increment the number of measures
+ this.measureCount++;
}
}
-
}
}
+
this.observables.addInterMapping(interMapping);
}
/** Default constructor: measures generation without outlier points control
* and Earth distances constraint.
- * @param viewingModelA
- * @param rA
- * @param viewingModelB
- * @param rB
+ * @param rA Rugged instance A
+ * @param sNameA sensor name A
+ * @param dimA dimension for acquisition A
+ * @param rB Rugged instance B
+ * @param sNameB sensor name B
+ * @param dimB dimension for acquisition B
* @throws RuggedException
*/
private void initParams(final Rugged rA, final String sNameA, final int dimA,
final Rugged rB, final String sNameB, final int dimB)
throws RuggedException {
- // generate reference mapping
- this.sensorNameA = sNameA;
this.sensorNameB = sNameB;
- // check that sensors's name is different
+ // Check that sensors's name is different
if (sNameA.contains(sNameB)) {
- throw new RuggedExceptionWrapper(new RuggedException(RuggedMessages.DUPLICATED_PARAMETER_NAME,
- sNameA));
+ throw new RuggedExceptionWrapper(new RuggedException(RuggedMessages.DUPLICATED_PARAMETER_NAME, sNameA));
}
this.ruggedA = rA;
this.ruggedB = rB;
- sensorA = rA.getLineSensor(sNameA);
- sensorB = rB.getLineSensor(sNameB);
+ this.sensorA = rA.getLineSensor(sNameA);
+ this.sensorB = rB.getLineSensor(sNameB);
this.dimensionA = dimA;
this.dimensionB = dimB;
- measureCount = 0;
-
+ this.measureCount = 0;
}
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/generators/Measurable.java b/src/main/java/org/orekit/rugged/refining/generators/Measurable.java
index 23722529198a28d12a71ec0b137ba244b3925e8e..985663aa0053a8e801391f31d803dd3a39f83907 100644
--- a/src/main/java/org/orekit/rugged/refining/generators/Measurable.java
+++ b/src/main/java/org/orekit/rugged/refining/generators/Measurable.java
@@ -21,14 +21,30 @@ import org.orekit.rugged.refining.measures.Noise;
/** For measures generator.
* @author Lucie Labat-Allee
+ * @author Guylaine Prat
+ * @since 2.0
*/
-
public interface Measurable {
-
+
+ /** Get the number of measures
+ * @return the number of measures
+ * @throws RuggedException
+ */
int getMeasureCount() throws RuggedException;
+ /** Create measures (without noise)
+ * @param lineSampling line sampling
+ * @param pixelSampling pixel sampling
+ * @throws RuggedException
+ */
void createMeasure(int lineSampling, int pixelSampling) throws RuggedException;
+ /** Create noisy measures
+ * @param lineSampling line sampling
+ * @param pixelSampling pixel sampling
+ * @param noise the noise to add to the measures
+ * @throws RuggedException
+ */
void createNoisyMeasure(int lineSampling, int pixelSampling, Noise noise) throws RuggedException;
}
diff --git a/src/main/java/org/orekit/rugged/refining/measures/Noise.java b/src/main/java/org/orekit/rugged/refining/measures/Noise.java
index 81f86f1a138faaca1806fc16d03d7720b9499075..748ddb9dfa04084f40692af528c095cbd6304d09 100644
--- a/src/main/java/org/orekit/rugged/refining/measures/Noise.java
+++ b/src/main/java/org/orekit/rugged/refining/measures/Noise.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -19,6 +19,7 @@ package org.orekit.rugged.refining.measures;
/** Class for adding a noise to measures.
* @author Lucie Labat-Allee
+ * @author Guylaine Prat
* @since 2.0
*/
public class Noise {
@@ -35,12 +36,9 @@ public class Noise {
/** Standard deviation. */
private double[] standardDeviation;
-
-
/** Distribution. */
private int distribution = GAUSSIAN;
-
/** Build a new instance.
* @param distribution noise type
* @param dimension noise dimension
@@ -52,56 +50,46 @@ public class Noise {
this.distribution = distribution;
}
-
-
- /**
+ /** Get the mean
* @return the mean
*/
public double[] getMean() {
return mean;
}
-
-
- /**
+ /** Set the mean
* @param mean the mean to set
*/
public void setMean(final double[] mean) {
this.mean = mean;
}
-
-
- /**
- * @return the standardDeviation
+ /** Get the standard deviation
+ * @return the standard deviation
*/
public double[] getStandardDeviation() {
return standardDeviation;
}
-
-
- /**
- * @param standardDeviation the standardDeviation to set
+ /** Set the standard deviation
+ * @param standardDeviation the standard deviation to set
*/
public void setStandardDeviation(final double[] standardDeviation) {
this.standardDeviation = standardDeviation;
}
- /**
+ /** Get the distribution
* @return the distribution
*/
public int getDistribution() {
return distribution;
}
- /**
+ /** Get the dimension
* @return the dimension
*/
public static int getDimension() {
return dimension;
}
-
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/measures/Observables.java b/src/main/java/org/orekit/rugged/refining/measures/Observables.java
index 3fd52682f641b4eb2d37b7d6dc2784807c0450ef..75099999f657a42c3f85010e1766b6f2bd8865be 100644
--- a/src/main/java/org/orekit/rugged/refining/measures/Observables.java
+++ b/src/main/java/org/orekit/rugged/refining/measures/Observables.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -21,9 +21,10 @@ import java.util.LinkedHashMap;
import java.util.Map;
/** Class for measures generation.
- * @author Lucie Labat-Allee
* @see SensorToSensorMapping
* @see SensorToGroundMapping
+ * @author Lucie Labat-Allee
+ * @author Guylaine Prat
* @since 2.0
*/
public class Observables {
@@ -45,7 +46,7 @@ public class Observables {
/** Build a new instance.
- * @param nbModels number of viewing models
+ * @param nbModels number of viewing models to map
*/
public Observables(final int nbModels) {
this.groundMappings = new LinkedHashMap<String, SensorToGroundMapping>();
@@ -60,14 +61,14 @@ public class Observables {
interMappings.put(this.createKey(interMapping), interMapping);
}
- /** Add a ground mapping between.
+ /** Add a ground mapping between ????
+ * TODO GP commentaire a completer
* @param groundMapping sensor to ground mapping
*/
public void addGroundMapping(final SensorToGroundMapping groundMapping) {
groundMappings.put(this.createKey(groundMapping), groundMapping);
}
-
/** Get all the ground mapping entries.
* @return an unmodifiable view of all mapping entries
*/
@@ -75,72 +76,71 @@ public class Observables {
return groundMappings.values();
}
-
/**
* Get a ground Mapping for a sensor.
- *
- * @param ruggedName rugged name
+ * @param ruggedName Rugged name
* @param sensorName sensor name
- * @return selected ground mapping or null of sensorName is not found
+ * @return selected ground mapping or null if sensor is not found
*/
public SensorToGroundMapping getGroundMapping(final String ruggedName, final String sensorName) {
final SensorToGroundMapping mapping = this.groundMappings.get(ruggedName + RUGGED_SENSOR_SEPARATOR + sensorName);
return mapping;
}
- /**
- * @return the interMappings
+ /** Get the sensor to sensor values
+ * TODO GP commentaire a completer
+ * @return the inter-mappings
*/
public Collection<SensorToSensorMapping> getInterMappings() {
return interMappings.values();
}
+ /** Get the number of viewing models to map
+ * @return the number of viewing models to map
+ */
+ public int getNbModels() {
+ return nbModels;
+ }
+
/**
- * Get a sensor Mapping for a sensor.
- *
- * @param ruggedNameA rugged name A
+ * Get a sensor mapping for a sensor.
+ * TODO GP commentaire a completer
+ * @param ruggedNameA Rugged name A
* @param sensorNameA sensor name A
- * @param ruggedNameB rugged name B
+ * @param ruggedNameB Rugged name B
* @param sensorNameB sensor name B
- * @return selected ground mapping or null of sensorName is not found
+ * @return selected ground mapping or null if a sensor is not found
*/
- public SensorToSensorMapping getInterMapping(final String ruggedNameA, final String sensorNameA, final String ruggedNameB, final String sensorNameB) {
+ public SensorToSensorMapping getInterMapping(final String ruggedNameA, final String sensorNameA,
+ final String ruggedNameB, final String sensorNameB) {
+ //TODO GP revoir la creation de string par "+"
final String keyA = ruggedNameA + RUGGED_SENSOR_SEPARATOR + sensorNameA;
final String keyB = ruggedNameB + RUGGED_SENSOR_SEPARATOR + sensorNameB;
final SensorToSensorMapping mapping = interMappings.get(keyA + SENSORS_SEPARATOR + keyB);
return mapping;
}
-
- /**
- * @return the nbModels
- */
- public int getNbModels() {
- return nbModels;
- }
-
-
- /** create key for GroudMapping map.
- * @param groundMapping the groundMapping
+ /** Create key for SensorToGroundMapping map.
+ * @param groundMapping the ground mapping
* @return the key
*/
private String createKey(final SensorToGroundMapping groundMapping)
{
+ //TODO GP revoir la creation de string par "+"
final String key = groundMapping.getRuggedName() + RUGGED_SENSOR_SEPARATOR + groundMapping.getSensorName();
return key;
}
- /** create key for SensorToSensorMapping map.
- * @param sensorMapping the interMapping
+ /** Create key for SensorToSensorMapping map.
+ * @param sensorMapping the inter mapping
* @return the key
*/
private String createKey(final SensorToSensorMapping sensorMapping)
{
+ //TODO GP revoir la creation de string par "+"
final String keyA = sensorMapping.getRuggedNameA() + RUGGED_SENSOR_SEPARATOR + sensorMapping.getSensorNameA();
final String keyB = sensorMapping.getRuggedNameB() + RUGGED_SENSOR_SEPARATOR + sensorMapping.getSensorNameB();
return keyA + SENSORS_SEPARATOR + keyB;
}
-
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/measures/SensorMapping.java b/src/main/java/org/orekit/rugged/refining/measures/SensorMapping.java
index b6d1d00789066396c6996f93f2dfdc0ae26c31f8..1ec4f131c40ceaf259c7b7bb7b41d71de2519bd2 100644
--- a/src/main/java/org/orekit/rugged/refining/measures/SensorMapping.java
+++ b/src/main/java/org/orekit/rugged/refining/measures/SensorMapping.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -25,31 +25,34 @@ import org.orekit.rugged.linesensor.SensorPixel;
/** Container for mapping sensor pixels with sensor pixels or ground points.
* @author Lucie Labat-Allee
+ * @author Guylaine Prat
* @since 2.0
*/
public class SensorMapping<T> {
+ /** Default name for Rugged. */
+ private static final String RUGGED = "Rugged";
+
/** Name of the sensor to which mapping applies. */
private final String sensorName;
- /** Name of the rugged to which mapping applies. */
+ /** Name of the Rugged to which mapping applies. */
private final String ruggedName;
-
/** Mapping from sensor to other (sensor or ground). */
private final Map<SensorPixel, T> mapping;
- /** Build a new instance.
+ /** Build a new instance (with default Rugged name).
* @param sensorName name of the sensor to which mapping applies
*/
public SensorMapping(final String sensorName) {
- this(sensorName, "Rugged");
+ this(sensorName, RUGGED);
}
- /** Build a new instance.
+ /** Build a new instance with a specific Rugged name.
* @param sensorName name of the sensor to which mapping applies
- * @param ruggedName name of the rugged to which mapping applies
+ * @param ruggedName name of the Rugged to which mapping applies
*/
public SensorMapping(final String sensorName, final String ruggedName) {
this.sensorName = sensorName;
@@ -57,7 +60,6 @@ public class SensorMapping<T> {
this.mapping = new LinkedHashMap<SensorPixel, T>();
}
-
/** Get the name of the sensor to which mapping applies.
* @return name of the sensor to which mapping applies
*/
@@ -65,17 +67,16 @@ public class SensorMapping<T> {
return sensorName;
}
- /** Get the name of the rugged to which mapping applies.
- * @return name of the rugged to which mapping applies
+ /** Get the name of the Rugged to which mapping applies.
+ * @return name of the Rugged to which mapping applies
*/
public String getRuggedName() {
return ruggedName;
}
-
/** Add a mapping between a sensor pixel and another point (sensor pixel or ground point).
* @param pixel sensor pixel
- * @param point sensor pixel / ground point corresponding to the sensor pixel
+ * @param point sensor pixel or ground point corresponding to the sensor pixel
*/
public void addMapping(final SensorPixel pixel, final T point) {
mapping.put(pixel, point);
diff --git a/src/main/java/org/orekit/rugged/refining/measures/SensorToGroundMapping.java b/src/main/java/org/orekit/rugged/refining/measures/SensorToGroundMapping.java
index aa9f0e76e90f03653a5c60c8a5ff1dfac421bc1f..321c9003828652cce0678c41b3c5db951e73f37e 100644
--- a/src/main/java/org/orekit/rugged/refining/measures/SensorToGroundMapping.java
+++ b/src/main/java/org/orekit/rugged/refining/measures/SensorToGroundMapping.java
@@ -24,34 +24,38 @@ import org.orekit.bodies.GeodeticPoint;
import org.orekit.rugged.linesensor.SensorPixel;
/** Container for mapping between sensor pixels and ground points.
+ * @see SensorMapping
* @author Luc Maisonobe
* @author Lucie Labat-Allee
- * @see SensorMapping
+ * @author Guylaine Prat
* @since 2.0
*/
public class SensorToGroundMapping {
+ /** Default name for Rugged. */
+ private static final String RUGGED = "Rugged";
+
/** Name of the sensor to which mapping applies. */
private final String sensorName;
/** Mapping from sensor to ground. */
private final SensorMapping<GeodeticPoint> groundMapping;
- /** Build a new instance.
- * @param ruggedName name of the rugged to which mapping applies
+
+ /** Build a new instance (with default Rugged name).
* @param sensorName name of the sensor to which mapping applies
*/
- public SensorToGroundMapping(final String ruggedName, final String sensorName) {
- this.sensorName = sensorName;
- this.groundMapping = new SensorMapping<GeodeticPoint>(sensorName, ruggedName);
+ public SensorToGroundMapping(final String sensorName) {
+ this(sensorName, RUGGED);
}
-
- /** Build a new instance.
+ /** Build a new instance with a specific Rugged name.
+ * @param ruggedName name of the Rugged to which mapping applies
* @param sensorName name of the sensor to which mapping applies
*/
- public SensorToGroundMapping(final String sensorName) {
- this(sensorName, "Rugged");
+ public SensorToGroundMapping(final String ruggedName, final String sensorName) {
+ this.sensorName = sensorName;
+ this.groundMapping = new SensorMapping<GeodeticPoint>(sensorName, ruggedName);
}
/** Get the name of the sensor to which mapping applies.
@@ -61,8 +65,8 @@ public class SensorToGroundMapping {
return sensorName;
}
- /** Get the name of the rugged to which mapping applies.
- * @return name of the rugged to which mapping applies
+ /** Get the name of the Rugged to which mapping applies.
+ * @return name of the Rugged to which mapping applies
*/
public String getRuggedName() {
return this.groundMapping.getRuggedName();
@@ -82,5 +86,4 @@ public class SensorToGroundMapping {
public Set<Map.Entry<SensorPixel, GeodeticPoint>> getMapping() {
return Collections.unmodifiableSet(groundMapping.getMapping());
}
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/measures/SensorToSensorMapping.java b/src/main/java/org/orekit/rugged/refining/measures/SensorToSensorMapping.java
index dc9fe815c5027d86c42c9dc7703186fc71c8be6e..e1790e926d467c325bde54a0c6020656a8d1c7ba 100644
--- a/src/main/java/org/orekit/rugged/refining/measures/SensorToSensorMapping.java
+++ b/src/main/java/org/orekit/rugged/refining/measures/SensorToSensorMapping.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -21,80 +21,106 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.orekit.rugged.linesensor.LineSensor;
import org.orekit.rugged.linesensor.SensorPixel;
+import org.orekit.rugged.utils.SpacecraftToObservedBody;
+import org.orekit.time.AbsoluteDate;
/** Container for mapping sensors pixels of two viewing models.
- * Store the distance between both lines of sight computed with @link {@link Rugged#distanceBetweenLOS(
- * String, org.orekit.time.AbsoluteDate, int, String, org.orekit.time.AbsoluteDate, int)}
- * Constraints in relation to Earth distance can be added.
- * @author Lucie LabatAllee
+ * Store the distance between both lines of sight computed with
+ * {@link Rugged#distanceBetweenLOS(LineSensor, AbsoluteDate, double, SpacecraftToObservedBody, LineSensor, AbsoluteDate, double)}
+ * <p> Constraints in relation to Earth distance can be added.
* @see SensorMapping
+ * @author Lucie LabatAllee
+ * @author Guylaine Prat
* @since 2.0
*/
public class SensorToSensorMapping {
- /** Name for Rugged. */
+ /** Default name for Rugged. */
private static final String RUGGED = "Rugged";
/** Name of the sensor B to which mapping applies. */
private final String sensorNameB;
- /** Name of the rugged B to which mapping applies. */
+ /** Name of the Rugged B to which mapping applies. */
private final String ruggedNameB;
/** Mapping from sensor A to sensor B. */
private final SensorMapping<SensorPixel> interMapping;
- /** Distance between two LOS. */
+ /** Distances between two LOS. */
private final List<Double> losDistances;
- /** Earth distance associated with pixel A. */
+ /** Earth distances associated with pixel A. */
private final List<Double> earthDistances;
/** Earth constraint weight. */
private double earthConstraintWeight;
- /** Build a new instance without Earth constraints.
+
+ /** Build a new instance without Earth constraint (with default Rugged names).
* @param sensorNameA name of the sensor A to which mapping applies
* @param sensorNameB name of the sensor B to which mapping applies
*/
public SensorToSensorMapping(final String sensorNameA, final String sensorNameB) {
+
this(sensorNameA, RUGGED, sensorNameB, RUGGED, 0.0);
}
- /** Build a new instance without Earth constraints.
+ /** Build a new instance with Earth constraint.
* @param sensorNameA name of the sensor A to which mapping applies
+ * @param ruggedNameA name of the Rugged A to which mapping applies
* @param sensorNameB name of the sensor B to which mapping applies
- */
- public SensorToSensorMapping(final String sensorNameA, final String ruggedNameA, final String sensorNameB, final String ruggedNameB, final double constraintWeight) {
- this.interMapping = new SensorMapping<SensorPixel>(sensorNameA, ruggedNameA);
+ * @param ruggedNameB name of the Rugged B to which mapping applies
+ * @param earthConstraintWeight weight given to the Earth distance constraint
+ * with respect to the LOS distance (between 0 and 1).
+ * <br>Weighting will be applied as follow :
+ * <ul>
+ * <li>(1 - earthConstraintWeight) for LOS distance weighting</li>
+ * <li>earthConstraintWeight for Earth distance weighting</li>
+ * </ul>
+ */
+ public SensorToSensorMapping(final String sensorNameA, final String ruggedNameA,
+ final String sensorNameB, final String ruggedNameB,
+ final double earthConstraintWeight) {
+
+ this.interMapping = new SensorMapping<SensorPixel>(sensorNameA, ruggedNameA);
this.sensorNameB = sensorNameB;
this.ruggedNameB = ruggedNameB;
this.losDistances = new ArrayList<Double>();
this.earthDistances = new ArrayList<Double>();
- this.earthConstraintWeight = constraintWeight;
-
+ this.earthConstraintWeight = earthConstraintWeight;
}
/** Build a new instance without Earth constraints.
* @param sensorNameA name of the sensor A to which mapping applies
+ * @param ruggedNameA name of the Rugged A to which mapping applies
* @param sensorNameB name of the sensor B to which mapping applies
+ * @param ruggedNameB name of the Rugged B to which mapping applies
*/
- public SensorToSensorMapping(final String sensorNameA, final String ruggedNameA, final String sensorNameB, final String ruggedNameB) {
+ public SensorToSensorMapping(final String sensorNameA, final String ruggedNameA,
+ final String sensorNameB, final String ruggedNameB) {
+
this(sensorNameA, ruggedNameA, sensorNameB, ruggedNameB, 0.0);
}
- /** Build a new instance with Earth constraints: we want to minimize the distance between pixelA and Earth.
+ /** Build a new instance with Earth constraints (with default Rugged names):
+ * we want to minimize the distance between pixel A and Earth.
* @param sensorNameA name of the sensor A to which mapping applies
* @param sensorNameB name of the sensor B to which mapping applies
- * @param constraintWeight weight given to the Earth distance constraint
- * with respect to the LOS distance (between 0 and 1). Weighting will be applied as follow :
- * (1-earthConstraintWeight) for losDistance weighting
- * earthConstraintWeight for earthDistance weighting
+ * @param earthConstraintWeight weight given to the Earth distance constraint
+ * with respect to the LOS distance (between 0 and 1).
+ * <br>Weighting will be applied as follow :
+ * <ul>
+ * <li>(1 - earthConstraintWeight) for LOS distance weighting</li>
+ * <li>earthConstraintWeight for Earth distance weighting</li>
+ * </ul>
*/
public SensorToSensorMapping(final String sensorNameA, final String sensorNameB,
- final double constraintWeight) {
- this(sensorNameA, RUGGED, sensorNameB, RUGGED, constraintWeight);
+ final double earthConstraintWeight) {
+
+ this(sensorNameA, RUGGED, sensorNameB, RUGGED, earthConstraintWeight);
}
/** Get the name of the sensor B to which mapping applies.
@@ -111,15 +137,15 @@ public class SensorToSensorMapping {
return interMapping.getSensorName();
}
- /** Get the name of the rugged B to which mapping applies.
- * @return name of the rugged B to which mapping applies
+ /** Get the name of the Rugged B to which mapping applies.
+ * @return name of the Rugged B to which mapping applies
*/
public String getRuggedNameB() {
return ruggedNameB;
}
- /** Get the name of the rugged A to which mapping applies.
- * @return name of the rugged A to which mapping applies
+ /** Get the name of the Rugged A to which mapping applies.
+ * @return name of the Rugged A to which mapping applies
*/
public String getRuggedNameA() {
return interMapping.getRuggedName();
@@ -133,37 +159,37 @@ public class SensorToSensorMapping {
}
/** Get distances between lines of sight (from both view).
- * @return the losDistances
+ * @return the LOS distances
*/
public List<Double> getLosDistances() {
return losDistances;
}
/** Get distances between Earth and pixel A (mapping with constraints).
- * @return the earthDistances
+ * @return the Earth distances
*/
public List<Double> getEarthDistances() {
return earthDistances;
}
/** Get the weight given to the Earth distance constraint with respect to the LOS distance.
- * @return the earthConstraintWeight
+ * @return the Earth constraint weight
*/
public double getEarthConstraintWeight() {
return earthConstraintWeight;
}
- /** Get distance between Earth and pixel A, corresponding to the inter mapping index.
- * @param idx inter mapping index
- * @return the earthDistances
+ /** Get distance between Earth and pixel A, corresponding to the inter-mapping index.
+ * @param idx inter-mapping index
+ * @return the Earth distances at index idx
*/
public Double getEarthDistance(final int idx) {
return getEarthDistances().get(idx);
}
- /** Get distance between LOS, corresponding to the inter mapping index.
- * @param idx inter mapping index
- * @return the losDistance
+ /** Get distance between LOS, corresponding to the inter-mapping index.
+ * @param idx inter-mapping index
+ * @return the LOS distance at index idx
*/
public Double getLosDistance(final int idx) {
return getLosDistances().get(idx);
@@ -175,19 +201,21 @@ public class SensorToSensorMapping {
* @param losDistance distance between both line of sight
*/
public void addMapping(final SensorPixel pixelA, final SensorPixel pixelB, final Double losDistance) {
+
interMapping.addMapping(pixelA, pixelB);
losDistances.add(losDistance);
}
/** Add a mapping between two sensor pixels (A and B) and corresponding distance between the LOS.
- * and the earth distance constraint associated with pixel A
+ * and the Earth distance constraint associated with pixel A
* @param pixelA sensor pixel A
- * @param pixelB sensor pixel B corresponding to the sensor pixel A
+ * @param pixelB sensor pixel B corresponding to the sensor pixel A (by direct then inverse location)
* @param losDistance distance between both line of sight
* @param earthDistance distance between Earth and pixel A
*/
public void addMapping(final SensorPixel pixelA, final SensorPixel pixelB,
final Double losDistance, final Double earthDistance) {
+
interMapping.addMapping(pixelA, pixelB);
losDistances.add(losDistance);
earthDistances.add(earthDistance);
@@ -199,5 +227,4 @@ public class SensorToSensorMapping {
public void setEarthConstraintWeight(final double earthConstraintWeight) {
this.earthConstraintWeight = earthConstraintWeight;
}
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/metrics/DistanceTools.java b/src/main/java/org/orekit/rugged/refining/metrics/DistanceTools.java
index 3484ff762681e22381ceb2d19b5882d8381c755e..3e4184a25f4c7e8577316e2b211e02484d6cfde4 100644
--- a/src/main/java/org/orekit/rugged/refining/metrics/DistanceTools.java
+++ b/src/main/java/org/orekit/rugged/refining/metrics/DistanceTools.java
@@ -20,14 +20,16 @@ import org.hipparchus.geometry.euclidean.threed.Vector3D;
import org.hipparchus.util.FastMath;
/**
- * class for computing geodetic distance.
+ * Class for computing geodetic distance.
+ * TODO GP voir avec Luc si pas d'outil dans orekit ???
* @author Jonathan Guinet
+ * @author Guylaine Prat
+ * @since 2.0
*/
public class DistanceTools {
- /**
- * Earth radius in cms.
- */
+ /** Earth radius in cms. */
+ // TODO GP constant for earth ???
public static final double EARTH_RADIUS = 637100000d;
/** Private constructor for utility class.
@@ -36,58 +38,54 @@ public class DistanceTools {
}
/** Choice the method for computing geodetic distance between two points.
- * @param xRad1 Longitude of first geodetic point
- * @param xRad2 Latitude of first geodetic point
- * @param yRad1 Longitude of second geodetic point
- * @param yRad2 Latitude of second geodetic point
+ * @param long1 Longitude of first geodetic point (rad)
+ * @param lat1 Latitude of first geodetic point (rad)
+ * @param long2 Longitude of second geodetic point (rad)
+ * @param lat2 Latitude of second geodetic point (rad)
* @param computeAngular if true, distance will be angular
- * @return distance in meters
+ * @return distance in meters or radians if flag computeAngular is true
*/
- public static double computeDistance(final double xRad1, final double yRad1,
- final double xRad2, final double yRad2,
+ public static double computeDistance(final double long1, final double lat1,
+ final double long2, final double lat2,
final boolean computeAngular) {
if (computeAngular == true) {
- return computeDistanceAngular(xRad1, yRad1, xRad2, yRad2);
+ return computeDistanceAngular(long1, lat1, long2, lat2);
} else {
- return computeDistanceInMeter(xRad1, yRad1, xRad2, yRad2);
+ return computeDistanceInMeter(long1, lat1, long2, lat2);
}
-
}
- /** Compute a geodetic distance in meters between point (xRad1, yRad1) and point (xRad2, yRad2).
- * @param xRad1 Longitude of first geodetic point
- * @param xRad2 Latitude of first geodetic point
- * @param yRad1 Longitude of second geodetic point
- * @param yRad2 Latitude of second geodetic point
+ /** Compute a geodetic distance in meters between point (long1, lat1) and point (long2, lat2).
+ * @param long1 Longitude of first geodetic point (rad)
+ * @param lat1 Latitude of first geodetic point (rad)
+ * @param long2 Longitude of second geodetic point (rad)
+ * @param lat2 Latitude of second geodetic point (rad)
* @return distance in meters
*/
- public static double computeDistanceInMeter(final double xRad1, final double yRad1,
- final double xRad2, final double yRad2) {
+ public static double computeDistanceInMeter(final double long1, final double lat1,
+ final double long2, final double lat2) {
+
// get vectors on unit sphere from angular coordinates
- final Vector3D p1 = new Vector3D(yRad1, xRad1); //
- final Vector3D p2 = new Vector3D(yRad2, xRad2);
+ final Vector3D p1 = new Vector3D(lat1, long1); //
+ final Vector3D p2 = new Vector3D(lat2, long2);
final double distance = EARTH_RADIUS / 100 * Vector3D.angle(p1, p2);
return distance;
-
}
/** Compute an angular distance between two geodetic points.
- * @param xRad1 Longitude of first geodetic point
- * @param xRad2 Latitude of first geodetic point
- * @param yRad1 Longitude of second geodetic point
- * @param yRad2 Latitude of second geodetic point
- * @return distance in meters
+ * @param long1 Longitude of first geodetic point (rad)
+ * @param lat1 Latitude of first geodetic point (rad)
+ * @param long2 Longitude of second geodetic point (rad)
+ * @param lat2 Latitude of second geodetic point (rad)
+ * @return angular distance in radians
*/
- public static double computeDistanceAngular(final double xRad1, final double yRad1,
- final double xRad2, final double yRad2) {
-
- final double lonDiff = xRad1 - xRad2;
- final double latDiff = yRad1 - yRad2;
+ public static double computeDistanceAngular(final double long1, final double lat1,
+ final double long2, final double lat2) {
+ final double lonDiff = long1 - long2;
+ final double latDiff = lat1 - lat2;
return FastMath.hypot(lonDiff, latDiff);
-
}
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/metrics/LocalisationMetrics.java b/src/main/java/org/orekit/rugged/refining/metrics/LocalisationMetrics.java
index 7cb565debfd7a912caae8cf031f45bf0e5fb2de5..b6662f62ca01991195daee0e2d728fc83b171d04 100644
--- a/src/main/java/org/orekit/rugged/refining/metrics/LocalisationMetrics.java
+++ b/src/main/java/org/orekit/rugged/refining/metrics/LocalisationMetrics.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -33,12 +33,15 @@ import org.orekit.rugged.utils.SpacecraftToObservedBody;
import org.orekit.time.AbsoluteDate;
/**
- * class for testing geometric performances in absolute location.
- * Metrics are computed for two scenarios: ground points and liaison points
- * @author Jonathan Guinet
- * @author Lucie Labat-Allee
+ * TODO GP migrer sous tutorials
+ * Class for testing geometric performances in absolute location.
+ * Metrics are computed for two scenarios: ground points and liaison points.
* @see SensorToSensorMapping
* @see SensorToGroundMapping
+ * @author Jonathan Guinet
+ * @author Lucie Labat-Allee
+ * @author Guylaine Prat
+ * @since 2.0
*/
public class LocalisationMetrics {
@@ -60,37 +63,34 @@ public class LocalisationMetrics {
/** Earth distance mean.*/
private double earthDistanceMean;
-
+
/** Compute metrics corresponding to the ground points study.
- * <p>
* @param measMapping Mapping of observations/measures = the ground truth
* @param rugged Rugged instance
- * @param computeAngular Flag to known if distance is computed in meters (false) or with angular (true)
- * </p>
+ * @param computeAngular flag to know if distance is computed in meters (false) or with angular (true)
+ * @exception RuggedException if direct location fails
*/
public LocalisationMetrics(final SensorToGroundMapping measMapping, final Rugged rugged, final boolean computeAngular)
- throws RuggedException {
+ throws RuggedException {
+
// Initialization
this.resMax = 0.0;
this.resMean = 0.0;
// Compute metrics - Case of Sensor to Ground mapping (fulcrum points study)
computeMetrics(measMapping, rugged, computeAngular);
-
}
-
/** Compute metrics corresponding to the liaison points study.
- * <p>
* @param measMapping Mapping of observations/measures = the ground truth
* @param ruggedA Rugged instance corresponding to viewing model A
* @param ruggedB Rugged instance corresponding to viewing model B
- * @param computeAngular Flag to known if distance is computed in meters (false) or with angular (true)
- * </p>
+ * @param computeAngular flag to know if distance is computed in meters (false) or with angular (true)
+ * @exception RuggedException if direct location fails
*/
public LocalisationMetrics(final SensorToSensorMapping measMapping, final Rugged ruggedA, final Rugged ruggedB,
final boolean computeAngular)
- throws RuggedException {
+ throws RuggedException {
// Initialization
this.resMax = 0.0;
@@ -104,37 +104,35 @@ public class LocalisationMetrics {
computeLiaisonMetrics(measMapping, ruggedA, ruggedB, computeAngular);
}
-
/**
* Compute metrics: case of ground control points.
- * <p>
* @param measMapping Mapping of observations/measures = the ground truth
* @param rugged Rugged instance
- * @param computeAngular Flag to known if distance is computed in meters (false) or with angular (true)
- * @exception RuggedException if directLocation fails
- * </p>
+ * @param computeAngular flag to know if distance is computed in meters (false) or with angular (true)
+ * @exception RuggedException if direct location fails
*/
public void computeMetrics(final SensorToGroundMapping measMapping, final Rugged rugged, final boolean computeAngular)
- throws RuggedException {
+ throws RuggedException {
- /* Mapping of observations/measures = the ground truth */
+ // Mapping of observations/measures = the ground truth
final Set<Map.Entry<SensorPixel, GeodeticPoint>> measuresMapping;
final LineSensor lineSensor;
- double count = 0; /* counter for compute mean distance */
- int nbMeas = 0; /* number of measures */
- double distance = 0;
-
- /* Initialization */
+
+ // counter for compute mean distance
+ double count = 0;
+
+ // Initialization
measuresMapping = measMapping.getMapping();
lineSensor = rugged.getLineSensor(measMapping.getSensorName());
- nbMeas = measuresMapping.size();
+
+ // number of measures
+ int nbMeas = measuresMapping.size();
+
final Iterator<Map.Entry<SensorPixel, GeodeticPoint>> gtIt = measuresMapping.iterator();
- /* Browse map of measures */
+ // Browse map of measures
while (gtIt.hasNext()) {
- distance = 0;
-
final Map.Entry<SensorPixel, GeodeticPoint> gtMeas = gtIt.next();
final SensorPixel gtSP = gtMeas.getKey();
@@ -146,55 +144,47 @@ public class LocalisationMetrics {
lineSensor.getLOS(date,
(int) gtSP.getPixelNumber()));
// Compute distance
- distance = DistanceTools.computeDistance(esGP.getLongitude(), esGP.getLatitude(),
+ double distance = DistanceTools.computeDistance(esGP.getLongitude(), esGP.getLatitude(),
gtGP.getLongitude(), gtGP.getLatitude(),
computeAngular);
count += distance;
-
if (distance > resMax) {
resMax = distance;
}
}
// Mean of residues
resMean = count / nbMeas;
-
}
-
/**
* Compute metrics: case of liaison points.
- * <p>
* @param measMapping Mapping of observations/measures = the ground truth
* @param ruggedA Rugged instance corresponding to viewing model A
* @param ruggedB Rugged instance corresponding to viewing model B
- * @param computeAngular Flag to known if distance is computed in meters (false) or with angular (true)
- * @exception RuggedException if directLocation fails
- * </p>
+ * @param computeAngular Flag to know if distance is computed in meters (false) or with angular (true)
+ * @exception RuggedException if direct location fails
*/
public void computeLiaisonMetrics(final SensorToSensorMapping measMapping, final Rugged ruggedA, final Rugged ruggedB,
final boolean computeAngular)
- throws RuggedException {
+ throws RuggedException {
- /* Mapping of observations/measures = the ground truth */
+ // Mapping of observations/measures = the ground truth
final Set<Map.Entry<SensorPixel, SensorPixel>> measuresMapping;
- final LineSensor lineSensorA; /* line sensor corresponding to rugged A */
- final LineSensor lineSensorB; /* line sensor corresponding to rugged B */
- double count = 0; /* counter for computing remaining mean distance */
- double losDistanceCount = 0; /* counter for computing LOS distance mean */
- double earthDistanceCount = 0; /* counter for computing Earth distance mean */
- int nbMeas = 0; /* number of measures */
- double distance = 0; /* remaining distance */
- int i = 0; /* increment of measures */
-
+ final LineSensor lineSensorA; // line sensor corresponding to rugged A
+ final LineSensor lineSensorB; // line sensor corresponding to rugged B
+ double count = 0; // counter for computing remaining mean distance
+ double losDistanceCount = 0; // counter for computing LOS distance mean
+ double earthDistanceCount = 0; // counter for computing Earth distance mean
+ int i = 0; // increment of measures
- /* Initialization */
+ // Initialization
measuresMapping = measMapping.getMapping();
lineSensorA = ruggedA.getLineSensor(measMapping.getSensorNameA());
lineSensorB = ruggedB.getLineSensor(measMapping.getSensorNameB());
- nbMeas = measuresMapping.size();
-
- /* Browse map of measures */
+ int nbMeas = measuresMapping.size(); // number of measures
+
+ // Browse map of measures
for (Iterator<Map.Entry<SensorPixel, SensorPixel>> gtIt = measuresMapping.iterator();
gtIt.hasNext();
i++) {
@@ -203,8 +193,6 @@ public class LocalisationMetrics {
break;
}
- distance = 0;
-
final Map.Entry<SensorPixel, SensorPixel> gtMapping = gtIt.next();
final SensorPixel spA = gtMapping.getKey();
@@ -219,7 +207,6 @@ public class LocalisationMetrics {
final Vector3D losA = lineSensorA.getLOS(dateA, pixelA);
final Vector3D losB = lineSensorB.getLOS(dateB, pixelB);
-
final GeodeticPoint gpA = ruggedA.directLocation(dateA, lineSensorA.getPosition(), losA);
final GeodeticPoint gpB = ruggedB.directLocation(dateB, lineSensorB.getPosition(), losB);
@@ -247,7 +234,7 @@ public class LocalisationMetrics {
earthDistanceCount += earthDistance;
// Compute remaining distance
- distance = DistanceTools.computeDistance(gpB.getLongitude(), gpB.getLatitude(),
+ double distance = DistanceTools.computeDistance(gpB.getLongitude(), gpB.getLatitude(),
gpA.getLongitude(), gpA.getLatitude(),
computeAngular);
count += distance;
@@ -261,15 +248,13 @@ public class LocalisationMetrics {
earthDistanceMean = earthDistanceCount / nbMeas;
}
-
- /** Get the Max residue.
+ /** Get the max residue.
* @return maximum of residues
*/
public double getMaxResidual() {
return resMax;
}
-
/** Get the mean of residues.
* @return mean of residues
*/
@@ -277,37 +262,31 @@ public class LocalisationMetrics {
return resMean;
}
-
- /** Get the LOS maximum residue.
- * @return max residue
+ /** Get the LOS maximum distance.
+ * @return LOS maximum distance
*/
public double getLosMaxDistance() {
return losDistanceMax;
}
-
- /** Get the LOS mean residue.
- * @return mean residue
+ /** Get the LOS mean distance.
+ * @return LOS mean distance
*/
public double getLosMeanDistance() {
return losDistanceMean;
}
-
/** Get the Earth distance maximum residue.
- * @return max residue
+ * @return Earth distance max residue
*/
public double getEarthMaxDistance() {
return earthDistanceMax;
}
-
- /** Get the earth distance mean residue.
- * @return mean residue
+ /** Get the Earth distance mean residue.
+ * @return Earth distance mean residue
*/
public double getEarthMeanDistance() {
return earthDistanceMean;
}
-
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/models/OrbitModel.java b/src/main/java/org/orekit/rugged/refining/models/OrbitModel.java
index 5ade7c8d767ec68f10fdb5160ac7cb5f7d000baa..c77028df17990674813da340f04b67047d9ea322 100644
--- a/src/main/java/org/orekit/rugged/refining/models/OrbitModel.java
+++ b/src/main/java/org/orekit/rugged/refining/models/OrbitModel.java
@@ -60,14 +60,14 @@ import org.orekit.utils.TimeStampedPVCoordinates;
import org.orekit.utils.AngularDerivativesFilter;
/**
- * Orbit Model class to generate PV and Q.
- *
- * @author jguinet
- */
+ * TODO GP add comments for tuto
+ * Orbit Model class to generate positions-velocities and attitude quaternions.
+ * @author Jonathan Guinet
+ * @author Guylaine Prat
+ * @since 2.0 */
public class OrbitModel {
-
/** Flag to change Attitude Law (by default Nadir Pointing Yaw Compensation). */
private boolean userDefinedLOFTransform;
@@ -89,12 +89,15 @@ public class OrbitModel {
userDefinedLOFTransform = false;
}
+ /** TODO GP add comments
+ */
public static void addSatellitePV(final TimeScale gps, final Frame eme2000, final Frame itrf,
final List<TimeStampedPVCoordinates> satellitePVList,
final String absDate,
final double px, final double py, final double pz,
final double vx, final double vy, final double vz)
throws OrekitException {
+
final AbsoluteDate ephemerisDate = new AbsoluteDate(absDate, gps);
final Vector3D position = new Vector3D(px, py, pz);
final Vector3D velocity = new Vector3D(vx, vy, vz);
@@ -106,10 +109,13 @@ public class OrbitModel {
Vector3D.ZERO));
}
+ /** TODO GP add comments
+ */
public void addSatelliteQ(final TimeScale gps,
final List<TimeStampedAngularCoordinates> satelliteQList,
final String absDate,
final double q0, final double q1, final double q2, final double q3) {
+
final AbsoluteDate attitudeDate = new AbsoluteDate(absDate, gps);
final Rotation rotation = new Rotation(q0, q1, q2, q3, true);
final TimeStampedAngularCoordinates pair = new TimeStampedAngularCoordinates(attitudeDate,
@@ -119,21 +125,26 @@ public class OrbitModel {
satelliteQList.add(pair);
}
- public BodyShape createEarth()
- throws OrekitException {
+ /** TODO GP add comments
+ */
+ public BodyShape createEarth() throws OrekitException {
+
return new OneAxisEllipsoid(Constants.WGS84_EARTH_EQUATORIAL_RADIUS,
Constants.WGS84_EARTH_FLATTENING,
- FramesFactory.getITRF(
- IERSConventions.IERS_2010, true));
+ FramesFactory.getITRF(IERSConventions.IERS_2010, true));
}
- public NormalizedSphericalHarmonicsProvider createGravityField()
- throws OrekitException {
+ /** TODO GP add comments
+ */
+ public NormalizedSphericalHarmonicsProvider createGravityField() throws OrekitException {
+
return GravityFieldFactory.getNormalizedProvider(12, 12);
}
- public Orbit createOrbit(final double mu, final AbsoluteDate date)
- throws OrekitException {
+ /** TODO GP add comments
+ */
+ public Orbit createOrbit(final double mu, final AbsoluteDate date) throws OrekitException {
+
// the following orbital parameters have been computed using
// Orekit tutorial about phasing, using the following configuration:
//
@@ -147,19 +158,20 @@ public class OrbitModel {
// gravity.field.order = 12
final Frame eme2000 = FramesFactory.getEME2000();
- // return new CircularOrbit(7173352.811913891,
- return new CircularOrbit(694000.0 +
- Constants.WGS84_EARTH_EQUATORIAL_RADIUS, // ajouter
- // Rayon
- -4.029194321683225E-4, 0.0013530362644647786,
- FastMath.toRadians(98.2), // pleiades
- // inclinaison 98.2
- // FastMath.toRadians(-86.47),
+ return new CircularOrbit(694000.0 + Constants.WGS84_EARTH_EQUATORIAL_RADIUS,
+ -4.029194321683225E-4,
+ 0.0013530362644647786,
+ FastMath.toRadians(98.2), // Pleiades inclination 98.2 deg
FastMath.toRadians(-86.47 + 180),
FastMath.toRadians(135.9 + 0.3),
- PositionAngle.TRUE, eme2000, date, mu);
+ PositionAngle.TRUE,
+ eme2000,
+ date,
+ mu);
}
+ /** TODO GP add comments
+ */
public void setLOFTransform(final double[] rollPoly, final double[] pitchPoly,
final double[] yawPoly, final AbsoluteDate date) {
@@ -170,7 +182,10 @@ public class OrbitModel {
this.refDate = date;
}
+ /** TODO GP add comments
+ */
private double getPoly(final double[] poly, final double shift) {
+
double val = 0.0;
for (int coef = 0; coef < poly.length; coef++) {
val = val + poly[coef] * FastMath.pow(shift, coef);
@@ -178,14 +193,15 @@ public class OrbitModel {
return val;
}
- private Rotation getOffset(final BodyShape earth, final Orbit orbit, final double shift)
+ /** TODO GP add comments
+ */
+ private Rotation getOffset(final BodyShape earth, final Orbit orbit, final double shift)
throws OrekitException {
+
final LOFType type = LOFType.VVLH;
final double roll = getPoly(lofTransformRollPoly, shift);
final double pitch = getPoly(lofTransformPitchPoly, shift);
final double yaw = getPoly(lofTransformYawPoly, shift);
- /**System.out.format("at shift %f roll %f pitch %f yaw %f \n ", shift,
- roll, pitch, yaw);*/
final LofOffset law = new LofOffset(orbit.getFrame(), type, RotationOrder.XYZ,
roll, pitch, yaw);
@@ -197,9 +213,12 @@ public class OrbitModel {
getAttitude(orbit, orbit.getDate().getDate().shiftedBy(shift), orbit.getFrame()).
getRotation();
final Rotation offsetProper = offsetAtt.compose(nadirAtt.revert(), RotationConvention.VECTOR_OPERATOR);
+
return offsetProper;
}
+ /** TODO GP add comments
+ */
public AttitudeProvider createAttitudeProvider(final BodyShape earth, final Orbit orbit)
throws OrekitException {
@@ -224,81 +243,83 @@ public class OrbitModel {
}
}
- public Propagator createPropagator(final BodyShape earth,
+ /** TODO GP add comments
+ */
+ public Propagator createPropagator(final BodyShape earth,
final NormalizedSphericalHarmonicsProvider gravityField,
final Orbit orbit)
throws OrekitException {
final AttitudeProvider attitudeProvider = createAttitudeProvider(earth, orbit);
- final SpacecraftState state = new SpacecraftState(orbit, attitudeProvider
- .getAttitude(orbit, orbit.getDate(), orbit.getFrame()), 1180.0);
+ final SpacecraftState state =
+ new SpacecraftState(orbit,
+ attitudeProvider.getAttitude(orbit, orbit.getDate(), orbit.getFrame()), 1180.0);
// numerical model for improving orbit
final OrbitType type = OrbitType.CIRCULAR;
- final double[][] tolerances = NumericalPropagator.tolerances(0.1, orbit,
- type);
- final DormandPrince853Integrator integrator = new DormandPrince853Integrator(1.0e-4 *
- orbit
- .getKeplerianPeriod(),
- 1.0e-1 * orbit
- .getKeplerianPeriod(),
- tolerances[0],
- tolerances[1]);
+ final double[][] tolerances = NumericalPropagator.tolerances(0.1, orbit, type);
+ final DormandPrince853Integrator integrator =
+ new DormandPrince853Integrator(1.0e-4 * orbit.getKeplerianPeriod(),
+ 1.0e-1 * orbit.getKeplerianPeriod(),
+ tolerances[0],
+ tolerances[1]);
integrator.setInitialStepSize(1.0e-2 * orbit.getKeplerianPeriod());
+
final NumericalPropagator numericalPropagator = new NumericalPropagator(integrator);
- numericalPropagator
- .addForceModel(new HolmesFeatherstoneAttractionModel(earth
- .getBodyFrame(), gravityField));
- numericalPropagator
- .addForceModel(new ThirdBodyAttraction(CelestialBodyFactory
- .getSun()));
- numericalPropagator
- .addForceModel(new ThirdBodyAttraction(CelestialBodyFactory
- .getMoon()));
+ numericalPropagator.addForceModel(new HolmesFeatherstoneAttractionModel(earth.getBodyFrame(), gravityField));
+ numericalPropagator .addForceModel(new ThirdBodyAttraction(CelestialBodyFactory.getSun()));
+ numericalPropagator .addForceModel(new ThirdBodyAttraction(CelestialBodyFactory.getMoon()));
numericalPropagator.setOrbitType(type);
numericalPropagator.setInitialState(state);
numericalPropagator.setAttitudeProvider(attitudeProvider);
+
return numericalPropagator;
-
}
- public List<TimeStampedPVCoordinates>
- orbitToPV(final Orbit orbit, final BodyShape earth, final AbsoluteDate minDate,
- final AbsoluteDate maxDate, final double step)
- throws OrekitException {
+ /** TODO GP add comments
+ */
+ public List<TimeStampedPVCoordinates> orbitToPV(final Orbit orbit, final BodyShape earth,
+ final AbsoluteDate minDate, final AbsoluteDate maxDate,
+ final double step)
+ throws OrekitException {
+
final Propagator propagator = new KeplerianPropagator(orbit);
propagator.setAttitudeProvider(createAttitudeProvider(earth, orbit));
propagator.propagate(minDate);
final List<TimeStampedPVCoordinates> list = new ArrayList<TimeStampedPVCoordinates>();
- propagator.setMasterMode(step,
- (currentState, isLast) ->
- list.add(new TimeStampedPVCoordinates(currentState.getDate(),
- currentState.getPVCoordinates().getPosition(),
- currentState.getPVCoordinates().getVelocity(),
- Vector3D.ZERO)));
+ propagator.setMasterMode(step,
+ (currentState, isLast) ->
+ list.add(new TimeStampedPVCoordinates(currentState.getDate(),
+ currentState.getPVCoordinates().getPosition(),
+ currentState.getPVCoordinates().getVelocity(),
+ Vector3D.ZERO)));
propagator.propagate(maxDate);
+
return list;
}
- public List<TimeStampedAngularCoordinates>
- orbitToQ(final Orbit orbit, final BodyShape earth, final AbsoluteDate minDate,
- final AbsoluteDate maxDate, final double step)
- throws OrekitException {
+ /** TODO GP add comments
+ */
+ public List<TimeStampedAngularCoordinates> orbitToQ(final Orbit orbit, final BodyShape earth,
+ final AbsoluteDate minDate, final AbsoluteDate maxDate,
+ final double step)
+ throws OrekitException {
+
final Propagator propagator = new KeplerianPropagator(orbit);
propagator.setAttitudeProvider(createAttitudeProvider(earth, orbit));
propagator.propagate(minDate);
final List<TimeStampedAngularCoordinates> list = new ArrayList<>();
propagator.setMasterMode(step,
- (currentState, isLast) ->
- list.add(new TimeStampedAngularCoordinates(currentState.getDate(),
- currentState.getAttitude().getRotation(),
- Vector3D.ZERO,
- Vector3D.ZERO)));
+ (currentState, isLast) ->
+ list.add(new TimeStampedAngularCoordinates(currentState.getDate(),
+ currentState.getAttitude().getRotation(),
+ Vector3D.ZERO,
+ Vector3D.ZERO)));
propagator.propagate(maxDate);
+
return list;
}
-
}
diff --git a/src/main/java/org/orekit/rugged/refining/models/PleiadesViewingModel.java b/src/main/java/org/orekit/rugged/refining/models/PleiadesViewingModel.java
index 3e325b208a7a5821d7d81da9d0e3ed264cba2556..2051061b7e2e986da66d4ac479fbfceaa2a241b8 100644
--- a/src/main/java/org/orekit/rugged/refining/models/PleiadesViewingModel.java
+++ b/src/main/java/org/orekit/rugged/refining/models/PleiadesViewingModel.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -16,8 +16,6 @@
*/
package org.orekit.rugged.refining.models;
-
-
import org.hipparchus.geometry.euclidean.threed.Rotation;
import org.hipparchus.geometry.euclidean.threed.RotationConvention;
import org.hipparchus.geometry.euclidean.threed.Vector3D;
@@ -41,24 +39,24 @@ import org.orekit.rugged.linesensor.LineSensor;
import org.orekit.rugged.errors.RuggedException;
import org.orekit.errors.OrekitException;
-
/**
- * PleiadesViewingModel class definition.
- * @author Jonathan Guinet, Lucie LabatAllee
- *
+ * TODO GP add comments for tuto
+ * Pleiades viewing model class definition.
+ * @author Jonathan Guinet
+ * @author Lucie Labat-Allee
+ * @since 2.0
*/
-
public class PleiadesViewingModel {
-
/** intrinsic Pleiades parameters. */
- public double fov = 1.65; // 20km - alt 694km
- public int dimension = 40000;
+ public double fov = 1.65; // 20km - alt 694km
+ // Number of line of the sensor
+ public int dimension = 40000;
- public double angle;
- public LineSensor lineSensor;
- public String date;
+ public double angle;
+ public LineSensor lineSensor;
+ public String date;
private String sensorName;
@@ -71,8 +69,8 @@ public class PleiadesViewingModel {
* sensorName="line", incidenceAngle = 0.0, date = "2016-01-01T12:00:00.0"
* </p>
*/
- public PleiadesViewingModel(final String sensorName)
- throws RuggedException, OrekitException {
+ public PleiadesViewingModel(final String sensorName) throws RuggedException, OrekitException {
+
this(sensorName, 0.0, "2016-01-01T12:00:00.0");
}
@@ -85,13 +83,15 @@ public class PleiadesViewingModel {
*/
public PleiadesViewingModel(final String sensorName, final double incidenceAngle, final String referenceDate)
throws RuggedException, OrekitException {
+
this.sensorName = sensorName;
this.date = referenceDate;
this.angle = incidenceAngle;
this.createLineSensor();
}
-
+ /** TODO GP add comments
+ */
public LOSBuilder rawLOS(final Vector3D center, final Vector3D normal, final double halfAperture, final int n) {
final List<Vector3D> list = new ArrayList<Vector3D>(n);
@@ -103,7 +103,10 @@ public class PleiadesViewingModel {
return new LOSBuilder(list);
}
- public TimeDependentLOS buildLOS() {
+ /** TODO GP add comments
+ */
+ public TimeDependentLOS buildLOS() {
+
final LOSBuilder losBuilder = rawLOS(new Rotation(Vector3D.PLUS_I,
FastMath.toRadians(this.angle),
RotationConvention.VECTOR_OPERATOR).applyTo(Vector3D.PLUS_K),
@@ -112,64 +115,71 @@ public class PleiadesViewingModel {
losBuilder.addTransform(new FixedRotation(sensorName + "_roll", Vector3D.MINUS_I, 0.00));
losBuilder.addTransform(new FixedRotation(sensorName + "_pitch", Vector3D.MINUS_J, 0.00));
- //factor is a common parameters shared between all Pleiades models
+ // factor is a common parameters shared between all Pleiades models
losBuilder.addTransform(new FixedZHomothety("factor", 1.0));
- return losBuilder.build();
+
+ return losBuilder.build();
}
- public AbsoluteDate getDatationReference() throws OrekitException {
- // We use Orekit for handling time and dates, and Rugged for defining the datation model:
- final TimeScale utc = TimeScalesFactory.getUTC();
- return new AbsoluteDate(date, utc);
+ /** TODO GP add comments
+ */
+ public AbsoluteDate getDatationReference() throws OrekitException {
+
+ // We use Orekit for handling time and dates, and Rugged for defining the datation model:
+ final TimeScale utc = TimeScalesFactory.getUTC();
+
+ return new AbsoluteDate(date, utc);
}
- public AbsoluteDate getMinDate() throws RuggedException {
+ /** TODO GP add comments
+ */
+ public AbsoluteDate getMinDate() throws RuggedException {
return lineSensor.getDate(0);
}
- public AbsoluteDate getMaxDate() throws RuggedException {
+ /** TODO GP add comments
+ */
+ public AbsoluteDate getMaxDate() throws RuggedException {
return lineSensor.getDate(dimension);
}
- public LineSensor getLineSensor() {
+ /** TODO GP add comments
+ */
+ public LineSensor getLineSensor() {
return lineSensor;
}
- public String getSensorName() {
+ /** TODO GP add comments
+ */
+ public String getSensorName() {
return sensorName;
}
- /**
- * @return the dimension
- */
- public int getDimension() {
+ /** TODO GP add comments
+ */
+ public int getDimension() {
return dimension;
}
- private void createLineSensor()
- throws RuggedException, OrekitException {
-
-
+ /** TODO GP add comments
+ */
+ private void createLineSensor() throws RuggedException, OrekitException {
// Offset of the MSI from center of mass of satellite
- //System.out.println("MSI offset from center of mass of satellite");
// one line sensor
// los: swath in the (YZ) plane, looking at 50° roll, 2.6" per pixel
- //Vector3D msiOffset = new Vector3D(1.5, 0, -0.2);
final Vector3D msiOffset = new Vector3D(0, 0, 0);
- // to do build complex los
+ // TODO build complex los
final TimeDependentLOS lineOfSight = buildLOS();
final double rate = 1 / linePeriod;
// linear datation model: at reference time we get the middle line, and the rate is one line every 1.5ms
final LineDatation lineDatation = new LinearLineDatation(getDatationReference(), dimension / 2, rate);
- //LineDatation lineDatation = new LinearLineDatation(absDate, 1d, 20);
+
lineSensor = new LineSensor(sensorName, lineDatation, msiOffset, lineOfSight);
-
}
-
}
diff --git a/src/main/java/org/orekit/rugged/utils/DSGenerator.java b/src/main/java/org/orekit/rugged/utils/DSGenerator.java
index d757e2ea6fcb5a873f88a1eb549f41b2e5cf94ac..05e60f63d117addec2889f1665fbf3ce5eabbcc6 100644
--- a/src/main/java/org/orekit/rugged/utils/DSGenerator.java
+++ b/src/main/java/org/orekit/rugged/utils/DSGenerator.java
@@ -1,4 +1,4 @@
-/* Copyright 2013-2016 CS Systèmes d'Information
+/* Copyright 2013-2017 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.