DumpReplayer.java

  1. /* Copyright 2013-2022 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.rugged.errors;

  19. import java.io.BufferedReader;
  20. import java.io.ByteArrayInputStream;
  21. import java.io.ByteArrayOutputStream;
  22. import java.io.File;
  23. import java.io.FileInputStream;
  24. import java.io.IOException;
  25. import java.io.InputStreamReader;
  26. import java.io.ObjectOutputStream;
  27. import java.lang.reflect.InvocationTargetException;
  28. import java.lang.reflect.Method;
  29. import java.util.ArrayList;
  30. import java.util.Arrays;
  31. import java.util.HashMap;
  32. import java.util.List;
  33. import java.util.Map;
  34. import java.util.NavigableMap;
  35. import java.util.TreeMap;
  36. import java.util.regex.Pattern;
  37. import java.util.stream.Stream;

  39. import org.hipparchus.analysis.differentiation.Derivative;
  40. import org.hipparchus.exception.LocalizedCoreFormats;
  41. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  42. import org.hipparchus.geometry.euclidean.threed.Rotation;
  43. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  44. import org.hipparchus.util.FastMath;
  45. import org.hipparchus.util.OpenIntToDoubleHashMap;
  46. import org.hipparchus.util.Pair;
  47. import org.orekit.bodies.GeodeticPoint;
  48. import org.orekit.bodies.OneAxisEllipsoid;
  49. import org.orekit.frames.Frame;
  50. import org.orekit.frames.FramesFactory;
  51. import org.orekit.frames.Predefined;
  52. import org.orekit.frames.Transform;
  53. import org.orekit.rugged.api.AlgorithmId;
  54. import org.orekit.rugged.api.Rugged;
  55. import org.orekit.rugged.api.RuggedBuilder;
  56. import org.orekit.rugged.linesensor.LineDatation;
  57. import org.orekit.rugged.linesensor.LineSensor;
  58. import org.orekit.rugged.linesensor.SensorMeanPlaneCrossing;
  59. import org.orekit.rugged.linesensor.SensorMeanPlaneCrossing.CrossingResult;
  60. import org.orekit.rugged.linesensor.SensorPixel;
  61. import org.orekit.rugged.los.TimeDependentLOS;
  62. import org.orekit.rugged.raster.TileUpdater;
  63. import org.orekit.rugged.raster.UpdatableTile;
  64. import org.orekit.rugged.refraction.AtmosphericRefraction;
  65. import org.orekit.rugged.refraction.MultiLayerModel;
  66. import org.orekit.rugged.utils.DerivativeGenerator;
  67. import org.orekit.rugged.utils.ExtendedEllipsoid;
  68. import org.orekit.rugged.utils.SpacecraftToObservedBody;
  69. import org.orekit.time.AbsoluteDate;
  70. import org.orekit.time.TimeScalesFactory;
  71. import org.orekit.utils.ParameterDriver;

  73. /** Replayer for Rugged debug dumps.
  74.  * @author Luc Maisonobe
  75.  * @author Guylaine Prat
  76.  * @see DumpManager
  77.  * @see Dump
  78.  */
  79. public class DumpReplayer {

  81.     /** Comment start marker. */
  82.     private static final String COMMENT_START = "#";

  84.     /** Keyword for latitude fields. */
  85.     private static final String LATITUDE = "latitude";

  87.     /** Keyword for longitude fields. */
  88.     private static final String LONGITUDE = "longitude";

  90.     /** Keyword for elevation fields. */
  91.     private static final String ELEVATION = "elevation";

  93.     /** Keyword for ellipsoid equatorial radius fields. */
  94.     private static final String AE = "ae";

  96.     /** Keyword for ellipsoid flattening fields. */
  97.     private static final String F = "f";

  99.     /** Keyword for frame fields. */
  100.     private static final String FRAME = "frame";

  102.     /** Keyword for date fields. */
  103.     private static final String DATE = "date";

  105.     /** Keyword for sensor position fields. */
  106.     private static final String POSITION = "position";

  108.     /** Keyword for sensor line-of-sight fields. */
  109.     private static final String LOS = "los";

  111.     /** Keyword for light-time correction fields. */
  112.     private static final String LIGHT_TIME = "lightTime";

  114.     /** Keyword for aberration of light correction fields. */
  115.     private static final String ABERRATION = "aberration";

  117.     /** Keyword for atmospheric refraction correction fields. */
  118.     private static final String REFRACTION = "refraction";

  120.     /** Keyword for min date fields. */
  121.     private static final String MIN_DATE = "minDate";

  123.     /** Keyword for max date fields. */
  124.     private static final String MAX_DATE = "maxDate";

  126.     /** Keyword for time step fields. */
  127.     private static final String T_STEP = "tStep";

  129.     /** Keyword for overshoot tolerance fields. */
  130.     private static final String TOLERANCE = "tolerance";

  132.     /** Keyword for inertial frames fields. */
  133.     private static final String INERTIAL_FRAME = "inertialFrame";

  135.     /** Keyword for observation transform index fields. */
  136.     private static final String INDEX = "index";

  138.     /** Keyword for body meta-fields. */
  139.     private static final String BODY = "body";

  141.     /** Keyword for rotation fields. */
  142.     private static final String R = "r";

  144.     /** Keyword for rotation rate fields. */
  145.     private static final String OMEGA = "Ω";

  147.     /** Keyword for rotation acceleration fields. */
  148.     private static final String OMEGA_DOT = "ΩDot";

  150.     /** Keyword for spacecraft meta-fields. */
  151.     private static final String SPACECRAFT = "spacecraft";

  153.     /** Keyword for position fields. */
  154.     private static final String P = "p";

  156.     /** Keyword for velocity fields. */
  157.     private static final String V = "v";

  159.     /** Keyword for acceleration fields. */
  160.     private static final String A = "a";

  162.     /** Keyword for minimum latitude fields. */
  163.     private static final String LAT_MIN = "latMin";

  165.     /** Keyword for latitude step fields. */
  166.     private static final String LAT_STEP = "latStep";

  168.     /** Keyword for latitude rows fields. */
  169.     private static final String LAT_ROWS = "latRows";

  171.     /** Keyword for minimum longitude fields. */
  172.     private static final String LON_MIN = "lonMin";

  174.     /** Keyword for longitude step fields. */
  175.     private static final String LON_STEP = "lonStep";

  177.     /** Keyword for longitude columns fields. */
  178.     private static final String LON_COLS = "lonCols";

  180.     /** Keyword for latitude index fields. */
  181.     private static final String LAT_INDEX = "latIndex";

  183.     /** Keyword for longitude index fields. */
  184.     private static final String LON_INDEX = "lonIndex";

  186.     /** Keyword for sensor name. */
  187.     private static final String SENSOR_NAME = "sensorName";

  189.     /** Keyword for min line. */
  190.     private static final String MIN_LINE = "minLine";

  192.     /** Keyword for max line. */
  193.     private static final String MAX_LINE = "maxLine";

  195.     /** Keyword for line number. */
  196.     private static final String LINE_NUMBER = "lineNumber";

  198.     /** Keyword for number of pixels. */
  199.     private static final String NB_PIXELS = "nbPixels";

  201.     /** Keyword for pixel number. */
  202.     private static final String PIXEL_NUMBER = "pixelNumber";

  204.     /** Keyword for max number of evaluations. */
  205.     private static final String MAX_EVAL = "maxEval";

  207.     /** Keyword for accuracy. */
  208.     private static final String ACCURACY = "accuracy";

  210.     /** Keyword for normal. */
  211.     private static final String NORMAL = "normal";

  213.     /** Keyword for rate. */
  214.     private static final String RATE = "rate";

  216.     /** Keyword for cached results. */
  217.     private static final String CACHED_RESULTS = "cachedResults";

  219.     /** Keyword for target. */
  220.     private static final String TARGET = "target";

  222.     /** Keyword for target direction. */
  223.     private static final String TARGET_DIRECTION = "targetDirection";

  225.     /** Keyword for null result. */
  226.     private static final String NULL_RESULT = "NULL";

  228.     /** Pattern for delimiting regular expressions. */
  229.     private static final Pattern SEPARATOR = Pattern.compile("\\s+");

  231.     /** Empty pattern. */
  232.     private static final Pattern PATTERN = Pattern.compile(" ");

  234.     /** Constant elevation for constant elevation algorithm. */
  235.     private double constantElevation;

  237.     /** Algorithm identifier. */
  238.     private AlgorithmId algorithmId;

  240.     /** Ellipsoid. */
  241.     private OneAxisEllipsoid ellipsoid;

  243.     /** Tiles list. */
  244.     private final List<ParsedTile> tiles;

  246.     /** Sensors list. */
  247.     private final List<ParsedSensor> sensors;

  249.     /** Interpolator min date. */
  250.     private AbsoluteDate minDate;

  252.     /** Interpolator max date. */
  253.     private AbsoluteDate maxDate;

  255.     /** Interpolator step. */
  256.     private double tStep;

  258.     /** Interpolator overshoot tolerance. */
  259.     private double tolerance;

  261.     /** Inertial frame. */
  262.     private Frame inertialFrame;

  264.     /** Transforms sample from observed body frame to inertial frame. */
  265.     private NavigableMap<Integer, Transform> bodyToInertial;

  267.     /** Transforms sample from spacecraft frame to inertial frame. */
  268.     private NavigableMap<Integer, Transform> scToInertial;

  270.     /** Flag for light time correction. */
  271.     private boolean lightTimeCorrection;

  273.     /** Flag for aberration of light correction. */
  274.     private boolean aberrationOfLightCorrection;

  276.     /** Flag for atmospheric refraction. */
  277.     private boolean atmosphericRefraction;

  279.     /** Dumped calls. */
  280.     private final List<DumpedCall> calls;


  283.     /** Simple constructor.
  284.      */
  285.     public DumpReplayer() {
  286.         tiles   = new ArrayList<>();
  287.         sensors = new ArrayList<>();
  288.         calls   = new ArrayList<>();
  289.     }

  291.     /** Parse a dump file.
  292.      * @param file dump file to parse
  293.      */
  294.     public void parse(final File file) {
  295.         try {
  296.             final BufferedReader reader =
  297.                     new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
  298.             int l = 0;
  299.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  300.                 LineParser.parse(++l, file, line, this);
  301.             }
  302.             reader.close();
  303.         } catch (IOException ioe) {
  304.             throw new RuggedException(ioe, LocalizedCoreFormats.SIMPLE_MESSAGE, ioe.getLocalizedMessage());
  305.         }
  306.     }

  308.     /** Create a Rugged instance from parsed data.
  309.      * @return rugged instance
  310.      */
  311.     public Rugged createRugged() {
  312.         try {
  313.             final RuggedBuilder builder = new RuggedBuilder();

  315.             if (algorithmId == null) {
  316.                 algorithmId = AlgorithmId.IGNORE_DEM_USE_ELLIPSOID;
  317.             }
  318.             builder.setAlgorithm(algorithmId);
  319.             if (algorithmId == AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID) {
  320.                 builder.setConstantElevation(constantElevation);
  321.             } else if (algorithmId != AlgorithmId.IGNORE_DEM_USE_ELLIPSOID) {
  322.                 builder.setDigitalElevationModel(new TileUpdater() {

  324.                     /** {@inheritDoc} */
  325.                     @Override
  326.                     public void updateTile(final double latitude, final double longitude, final UpdatableTile tile) {
  327.                         for (final ParsedTile parsedTile : tiles) {
  328.                             if (parsedTile.isInterpolable(latitude, longitude)) {
  329.                                 parsedTile.updateTile(tile);
  330.                                 return;
  331.                             }
  332.                         }
  333.                         throw new RuggedException(RuggedMessages.NO_DEM_DATA,
  334.                                                   FastMath.toDegrees(latitude), FastMath.toDegrees(longitude));
  335.                     }
  336.                 }, 8);
  337.             }

  339.             builder.setEllipsoid(ellipsoid);

  341.             builder.setLightTimeCorrection(lightTimeCorrection);
  342.             builder.setAberrationOfLightCorrection(aberrationOfLightCorrection);
  343.             if (atmosphericRefraction) { // Use the default model with the default configuration values
  344.                 final ExtendedEllipsoid extendedEllipsoid = builder.getEllipsoid();
  345.                 final AtmosphericRefraction atmosphericModel = new MultiLayerModel(extendedEllipsoid);
  346.                 // Build Rugged with atmospheric refraction model
  347.                 builder.setRefractionCorrection(atmosphericModel);
  348.             }


  351.             // build missing transforms by extrapolating the parsed ones
  352.             final int n = (int) FastMath.ceil(maxDate.durationFrom(minDate) / tStep);
  353.             final List<Transform> b2iList = new ArrayList<>(n);
  354.             final List<Transform> s2iList = new ArrayList<>(n);
  355.             for (int i = 0; i < n; ++i) {
  356.                 if (bodyToInertial.containsKey(i)) {
  357.                     // the i-th transform was dumped
  358.                     b2iList.add(bodyToInertial.get(i));
  359.                     s2iList.add(scToInertial.get(i));
  360.                 } else {
  361.                     // the i-th transformed was not dumped, we have to extrapolate it
  362.                     final Map.Entry<Integer, Transform> lower  = bodyToInertial.lowerEntry(i);
  363.                     final Map.Entry<Integer, Transform> higher = bodyToInertial.higherEntry(i);
  364.                     final int closest;
  365.                     if (lower == null) {
  366.                         closest = higher.getKey();
  367.                     } else if (higher == null) {
  368.                         closest = lower.getKey();
  369.                     } else {
  370.                         closest = (i - lower.getKey() <= higher.getKey() - i) ? lower.getKey() : higher.getKey();
  371.                     }
  372.                     b2iList.add(bodyToInertial.get(closest).shiftedBy((i - closest) * tStep));
  373.                     s2iList.add(scToInertial.get(closest).shiftedBy((i - closest) * tStep));
  374.                 }
  375.             }

  377.             // we use Rugged transforms reloading mechanism to ensure the spacecraft
  378.             // to body transforms will be the same as the ones dumped
  379.             final SpacecraftToObservedBody scToBody =
  380.                     new SpacecraftToObservedBody(inertialFrame, ellipsoid.getBodyFrame(),
  381.                                                  minDate, maxDate, tStep, tolerance,
  382.                                                  b2iList, s2iList);
  383.             final ByteArrayOutputStream bos = new ByteArrayOutputStream();
  384.             new ObjectOutputStream(bos).writeObject(scToBody);
  385.             final ByteArrayInputStream  bis = new ByteArrayInputStream(bos.toByteArray());
  386.             builder.setTrajectoryAndTimeSpan(bis);

  388.             final List<SensorMeanPlaneCrossing> planeCrossings = new ArrayList<>();
  389.             for (final ParsedSensor parsedSensor : sensors) {
  390.                 final LineSensor sensor = new LineSensor(parsedSensor.name,
  391.                                                          parsedSensor,
  392.                                                          parsedSensor.position,
  393.                                                          parsedSensor);
  394.                 if (parsedSensor.meanPlane != null) {
  395.                     planeCrossings.add(new SensorMeanPlaneCrossing(sensor, scToBody,
  396.                                                                    parsedSensor.meanPlane.minLine,
  397.                                                                    parsedSensor.meanPlane.maxLine,
  398.                                                                    lightTimeCorrection, aberrationOfLightCorrection,
  399.                                                                    parsedSensor.meanPlane.maxEval,
  400.                                                                    parsedSensor.meanPlane.accuracy,
  401.                                                                    parsedSensor.meanPlane.normal,
  402.                                                                    Arrays.stream(parsedSensor.meanPlane.cachedResults)));
  403.                 }
  404.                 builder.addLineSensor(sensor);
  405.             }

  407.             final Rugged rugged = builder.build();

  409.             final Method setPlaneCrossing = Rugged.class.getDeclaredMethod("setPlaneCrossing",
  410.                                                                            SensorMeanPlaneCrossing.class);
  411.             setPlaneCrossing.setAccessible(true);
  412.             for (final SensorMeanPlaneCrossing planeCrossing : planeCrossings) {
  413.                 setPlaneCrossing.invoke(rugged, planeCrossing);
  414.             }

  416.             return rugged;

  418.         } catch (IOException | NoSuchMethodException  | IllegalAccessException  | InvocationTargetException e) {
  419.             // this should never happen
  420.             throw new RuggedInternalError(e);
  421.         }
  422.     }

  424.     /** Get a sensor by name.
  425.      * @param name sensor name
  426.      * @return parsed sensor
  427.      */
  428.     private ParsedSensor getSensor(final String name) {
  429.         for (final ParsedSensor sensor : sensors) {
  430.             if (sensor.name.equals(name)) {
  431.                 return sensor;
  432.             }
  433.         }
  434.         final ParsedSensor sensor = new ParsedSensor(name);
  435.         sensors.add(sensor);
  436.         return sensor;
  437.     }

  439.     /** Execute all dumped calls.
  440.      * <p>
  441.      * The dumped calls correspond to computation methods like direct or inverse
  442.      * location.
  443.      * </p>
  444.      * @param rugged Rugged instance on which calls will be performed
  445.      * @return results of all dumped calls
  446.      */
  447.     public Result[] execute(final Rugged rugged) {
  448.         final Result[] results = new Result[calls.size()];
  449.         for (int i = 0; i < calls.size(); ++i) {
  450.             results[i] = new Result(calls.get(i).expected,
  451.                                     calls.get(i).execute(rugged));
  452.         }
  453.         return results;
  454.     }

  456.     /** Container for replay results. */
  457.     public static class Result {

  459.         /** Expected result. */
  460.         private final Object expected;

  462.         /** Replayed result. */
  463.         private final Object replayed;

  465.         /** Simple constructor.
  466.          * @param expected expected result
  467.          * @param replayed replayed result
  468.          */
  469.         private Result(final Object expected, final Object replayed) {
  470.             this.expected = expected;
  471.             this.replayed = replayed;
  472.         }

  474.         /** Get the expected result.
  475.          * @return expected result
  476.          */
  477.         public Object getExpected() {
  478.             return expected;
  479.         }

  481.         /** Get the replayed result.
  482.          * @return replayed result
  483.          */
  484.         public Object getReplayed() {
  485.             return replayed;
  486.         }

  488.     }

  490.     /** Line parsers. */
  491.     private enum LineParser {

  493.         /** Parser for algorithm dump lines. */
  494.         ALGORITHM() {

  496.             /** {@inheritDoc} */
  497.             @Override
  498.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  499.                 try {
  500.                     if (fields.length < 1) {
  501.                         throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  502.                     }
  503.                     global.algorithmId = AlgorithmId.valueOf(fields[0]);
  504.                     if (global.algorithmId == AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID) {
  505.                         if (fields.length < 3 || !fields[1].equals(ELEVATION)) {
  506.                             throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  507.                         }
  508.                         global.constantElevation = Double.parseDouble(fields[2]);
  509.                     }
  510.                 } catch (IllegalArgumentException iae) {
  511.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  512.                 }
  513.             }

  515.         },

  517.         /** Parser for ellipsoid dump lines. */
  518.         ELLIPSOID() {

  520.             /** {@inheritDoc} */
  521.             @Override
  522.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  523.                 if (fields.length < 6 || !fields[0].equals(AE) || !fields[2].equals(F) || !fields[4].equals(FRAME)) {
  524.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  525.                 }
  526.                 final double ae   = Double.parseDouble(fields[1]);
  527.                 final double f    = Double.parseDouble(fields[3]);
  528.                 final Frame  bodyFrame;
  529.                 try {
  530.                     bodyFrame = FramesFactory.getFrame(Predefined.valueOf(fields[5]));
  531.                 } catch (IllegalArgumentException iae) {
  532.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  533.                 }
  534.                 global.ellipsoid = new OneAxisEllipsoid(ae, f, bodyFrame);
  535.             }

  537.         },

  539.         /** Parser for direct location calls dump lines. */
  540.         DIRECT_LOCATION() {

  542.             /** {@inheritDoc} */
  543.             @Override
  544.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  545.                 if (fields.length < 16 ||
  546.                         !fields[0].equals(DATE) ||
  547.                         !fields[2].equals(POSITION) || !fields[6].equals(LOS) ||
  548.                         !fields[10].equals(LIGHT_TIME) || !fields[12].equals(ABERRATION) ||
  549.                         !fields[14].equals(REFRACTION)) {
  550.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  551.                 }
  552.                 final AbsoluteDate date = new AbsoluteDate(fields[1], TimeScalesFactory.getUTC());
  553.                 final Vector3D position = new Vector3D(Double.parseDouble(fields[3]),
  554.                         Double.parseDouble(fields[4]),
  555.                         Double.parseDouble(fields[5]));
  556.                 final Vector3D los      = new Vector3D(Double.parseDouble(fields[7]),
  557.                         Double.parseDouble(fields[8]),
  558.                         Double.parseDouble(fields[9]));
  559.                 if (global.calls.isEmpty()) {
  560.                     global.lightTimeCorrection         = Boolean.parseBoolean(fields[11]);
  561.                     global.aberrationOfLightCorrection = Boolean.parseBoolean(fields[13]);
  562.                     global.atmosphericRefraction       = Boolean.parseBoolean(fields[15]);
  563.                 } else {
  564.                     if (global.lightTimeCorrection != Boolean.parseBoolean(fields[11])) {
  565.                         throw new RuggedException(RuggedMessages.LIGHT_TIME_CORRECTION_REDEFINED,
  566.                                 l, file.getAbsolutePath(), line);
  567.                     }
  568.                     if (global.aberrationOfLightCorrection != Boolean.parseBoolean(fields[13])) {
  569.                         throw new RuggedException(RuggedMessages.ABERRATION_OF_LIGHT_CORRECTION_REDEFINED,
  570.                                 l, file.getAbsolutePath(), line);
  571.                     }
  572.                     if (global.atmosphericRefraction != Boolean.parseBoolean(fields[15])) {
  573.                         throw new RuggedException(RuggedMessages.ATMOSPHERIC_REFRACTION_REDEFINED,
  574.                                 l, file.getAbsolutePath(), line);
  575.                     }
  576.                 }
  577.                 global.calls.add(new DumpedCall() {

  579.                     /** {@inheritDoc} */
  580.                     @Override
  581.                     public Object execute(final Rugged rugged) {
  582.                         return rugged.directLocation(date, position, los);
  583.                     }

  585.                 });
  586.             }
  587.         },

  589.         /** Parser for direct location result dump lines. */
  590.         DIRECT_LOCATION_RESULT() {

  592.             /** {@inheritDoc} */
  593.             @Override
  594.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  595.                 if (fields.length == 1) {
  596.                     if (fields[0].equals(NULL_RESULT)) {
  597.                         final GeodeticPoint gp = null;
  598.                         final DumpedCall last = global.calls.get(global.calls.size() - 1);
  599.                         last.expected = gp;
  600.                     } else {
  601.                         throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  602.                     }
  603.                 } else if (fields.length < 6 || !fields[0].equals(LATITUDE) ||
  604.                            !fields[2].equals(LONGITUDE) || !fields[4].equals(ELEVATION)) {
  605.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  606.                 } else {
  607.                     final GeodeticPoint gp = new GeodeticPoint(Double.parseDouble(fields[1]),
  608.                                                                Double.parseDouble(fields[3]),
  609.                                                                Double.parseDouble(fields[5]));
  610.                     final DumpedCall last = global.calls.get(global.calls.size() - 1);
  611.                     last.expected = gp;
  612.                 }
  613.             }

  615.         },

  617.         /** Parser for search span dump lines. */
  618.         SPAN() {

  620.             /** {@inheritDoc} */
  621.             @Override
  622.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  623.                 if (fields.length < 10 ||
  624.                         !fields[0].equals(MIN_DATE)  || !fields[2].equals(MAX_DATE) || !fields[4].equals(T_STEP)   ||
  625.                         !fields[6].equals(TOLERANCE) || !fields[8].equals(INERTIAL_FRAME)) {
  626.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  627.                 }
  628.                 global.minDate        = new AbsoluteDate(fields[1], TimeScalesFactory.getUTC());
  629.                 global.maxDate        = new AbsoluteDate(fields[3], TimeScalesFactory.getUTC());
  630.                 global.tStep          = Double.parseDouble(fields[5]);
  631.                 global.tolerance      = Double.parseDouble(fields[7]);
  632.                 global.bodyToInertial = new TreeMap<Integer, Transform>();
  633.                 global.scToInertial   = new TreeMap<Integer, Transform>();
  634.                 try {
  635.                     global.inertialFrame = FramesFactory.getFrame(Predefined.valueOf(fields[9]));
  636.                 } catch (IllegalArgumentException iae) {
  637.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  638.                 }
  639.             }
  640.         },

  642.         /** Parser for observation transforms dump lines. */
  643.         TRANSFORM() {

  645.             /** {@inheritDoc} */
  646.             @Override
  647.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  648.                 if (fields.length < 42 ||
  649.                     !fields[0].equals(INDEX) ||
  650.                     !fields[2].equals(BODY)  ||
  651.                     !fields[3].equals(R)     || !fields[8].equals(OMEGA)    || !fields[12].equals(OMEGA_DOT) ||
  652.                     !fields[16].equals(SPACECRAFT) ||
  653.                     !fields[17].equals(P)    || !fields[21].equals(V)   || !fields[25].equals(A) ||
  654.                     !fields[29].equals(R)    || !fields[34].equals(OMEGA)   || !fields[38].equals(OMEGA_DOT)) {
  655.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  656.                 }
  657.                 final int i   = Integer.parseInt(fields[1]);
  658.                 final AbsoluteDate date = global.minDate.shiftedBy(i * global.tStep);
  659.                 global.bodyToInertial.put(i,
  660.                                           new Transform(date,
  661.                                                         new Rotation(Double.parseDouble(fields[4]),
  662.                                                                      Double.parseDouble(fields[5]),
  663.                                                                      Double.parseDouble(fields[6]),
  664.                                                                      Double.parseDouble(fields[7]),
  665.                                                                      false),
  666.                                                         new Vector3D(Double.parseDouble(fields[9]),
  667.                                                                      Double.parseDouble(fields[10]),
  668.                                                                      Double.parseDouble(fields[11])),
  669.                                                         new Vector3D(Double.parseDouble(fields[13]),
  670.                                                                      Double.parseDouble(fields[14]),
  671.                                                                      Double.parseDouble(fields[15]))));
  672.                 global.scToInertial.put(i,
  673.                                         new Transform(date,
  674.                                                       new Transform(date,
  675.                                                                     new Vector3D(Double.parseDouble(fields[18]),
  676.                                                                                  Double.parseDouble(fields[19]),
  677.                                                                                  Double.parseDouble(fields[20])),
  678.                                                                     new Vector3D(Double.parseDouble(fields[22]),
  679.                                                                                  Double.parseDouble(fields[23]),
  680.                                                                                  Double.parseDouble(fields[24])),
  681.                                                                     new Vector3D(Double.parseDouble(fields[26]),
  682.                                                                                  Double.parseDouble(fields[27]),
  683.                                                                                  Double.parseDouble(fields[28]))),
  684.                                                       new Transform(date,
  685.                                                                     new Rotation(Double.parseDouble(fields[30]),
  686.                                                                                  Double.parseDouble(fields[31]),
  687.                                                                                  Double.parseDouble(fields[32]),
  688.                                                                                  Double.parseDouble(fields[33]),
  689.                                                                                  false),
  690.                                                                     new Vector3D(Double.parseDouble(fields[35]),
  691.                                                                                  Double.parseDouble(fields[36]),
  692.                                                                                  Double.parseDouble(fields[37])),
  693.                                                                     new Vector3D(Double.parseDouble(fields[39]),
  694.                                                                                  Double.parseDouble(fields[40]),
  695.                                                                                  Double.parseDouble(fields[41])))));
  696.             }

  698.         },

  700.         /** Parser for DEM tile global geometry dump lines. */
  701.         DEM_TILE() {

  703.             /** {@inheritDoc} */
  704.             @Override
  705.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  706.                 if (fields.length < 13 ||
  707.                         !fields[1].equals(LAT_MIN) || !fields[3].equals(LAT_STEP) || !fields[5].equals(LAT_ROWS) ||
  708.                         !fields[7].equals(LON_MIN) || !fields[9].equals(LON_STEP) || !fields[11].equals(LON_COLS)) {
  709.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  710.                 }
  711.                 final String name             = fields[0];
  712.                 final double minLatitude      = Double.parseDouble(fields[2]);
  713.                 final double latitudeStep     = Double.parseDouble(fields[4]);
  714.                 final int    latitudeRows     = Integer.parseInt(fields[6]);
  715.                 final double minLongitude     = Double.parseDouble(fields[8]);
  716.                 final double longitudeStep    = Double.parseDouble(fields[10]);
  717.                 final int    longitudeColumns = Integer.parseInt(fields[12]);
  718.                 for (final ParsedTile tile : global.tiles) {
  719.                     if (tile.name.equals(name)) {
  720.                         throw new RuggedException(RuggedMessages.TILE_ALREADY_DEFINED,
  721.                                                   name, l, file.getAbsolutePath(), line);
  722.                     }
  723.                 }
  724.                 global.tiles.add(new ParsedTile(name,
  725.                                                 minLatitude, latitudeStep, latitudeRows,
  726.                                                 minLongitude, longitudeStep, longitudeColumns));
  727.             }

  729.         },

  731.         /** Parser for DEM cells dump lines. */
  732.         DEM_CELL() {

  734.             /** {@inheritDoc} */
  735.             @Override
  736.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  737.                 if (fields.length < 7 ||
  738.                     !fields[1].equals(LAT_INDEX) || !fields[3].equals(LON_INDEX) || !fields[5].equals(ELEVATION)) {
  739.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  740.                 }
  741.                 final String name      = fields[0];
  742.                 final int    latIndex  = Integer.parseInt(fields[2]);
  743.                 final int    lonIndex  = Integer.parseInt(fields[4]);
  744.                 final double elevation = Double.parseDouble(fields[6]);
  745.                 for (final ParsedTile tile : global.tiles) {
  746.                     if (tile.name.equals(name)) {
  747.                         final int index = latIndex * tile.longitudeColumns + lonIndex;
  748.                         tile.elevations.put(index, elevation);
  749.                         return;
  750.                     }
  751.                 }
  752.                 throw new RuggedException(RuggedMessages.UNKNOWN_TILE,
  753.                                           name, l, file.getAbsolutePath(), line);
  754.             }

  756.         },

  758.         /** Parser for inverse location calls dump lines. */
  759.         INVERSE_LOCATION() {

  761.             /** {@inheritDoc} */
  762.             @Override
  763.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  764.                 if (fields.length < 18 ||
  765.                         !fields[0].equals(SENSOR_NAME) ||
  766.                         !fields[2].equals(LATITUDE) || !fields[4].equals(LONGITUDE) || !fields[6].equals(ELEVATION) ||
  767.                         !fields[8].equals(MIN_LINE) || !fields[10].equals(MAX_LINE) ||
  768.                         !fields[12].equals(LIGHT_TIME) || !fields[14].equals(ABERRATION) ||
  769.                         !fields[16].equals(REFRACTION)) {
  770.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  771.                 }
  772.                 final String sensorName = fields[1];
  773.                 final GeodeticPoint point = new GeodeticPoint(Double.parseDouble(fields[3]),
  774.                                                               Double.parseDouble(fields[5]),
  775.                                                               Double.parseDouble(fields[7]));
  776.                 final int minLine = Integer.parseInt(fields[9]);
  777.                 final int maxLine = Integer.parseInt(fields[11]);
  778.                 if (global.calls.isEmpty()) {
  779.                     global.lightTimeCorrection         = Boolean.parseBoolean(fields[13]);
  780.                     global.aberrationOfLightCorrection = Boolean.parseBoolean(fields[15]);
  781.                     global.atmosphericRefraction       = Boolean.parseBoolean(fields[17]);
  782.                 } else {
  783.                     if (global.lightTimeCorrection != Boolean.parseBoolean(fields[13])) {
  784.                         throw new RuggedException(RuggedMessages.LIGHT_TIME_CORRECTION_REDEFINED,
  785.                                                   l, file.getAbsolutePath(), line);
  786.                     }
  787.                     if (global.aberrationOfLightCorrection != Boolean.parseBoolean(fields[15])) {
  788.                         throw new RuggedException(RuggedMessages.ABERRATION_OF_LIGHT_CORRECTION_REDEFINED,
  789.                                                   l, file.getAbsolutePath(), line);
  790.                     }
  791.                     if (global.atmosphericRefraction != Boolean.parseBoolean(fields[17])) {
  792.                         throw new RuggedException(RuggedMessages.ATMOSPHERIC_REFRACTION_REDEFINED,
  793.                                                   l, file.getAbsolutePath(), line);
  794.                     }
  795.                 }
  796.                 global.calls.add(new DumpedCall() {

  798.                     /** {@inheritDoc} */
  799.                     @Override
  800.                     public Object execute(final Rugged rugged) {
  801.                         return rugged.inverseLocation(sensorName, point, minLine, maxLine);
  802.                     }

  804.                 });
  805.             }

  807.         },

  809.         /** Parser for inverse location result dump lines. */
  810.         INVERSE_LOCATION_RESULT() {

  812.             /** {@inheritDoc} */
  813.             @Override
  814.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  815.                 if (fields.length == 1) {
  816.                     if (fields[0].equals(NULL_RESULT)) {
  817.                         final SensorPixel sp = null;
  818.                         final DumpedCall last = global.calls.get(global.calls.size() - 1);
  819.                         last.expected = sp;
  820.                     } else {
  821.                         throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  822.                     }
  823.                 } else if (fields.length < 4 || !fields[0].equals(LINE_NUMBER) || !fields[2].equals(PIXEL_NUMBER)) {
  824.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  825.                 } else {
  826.                     final SensorPixel sp = new SensorPixel(Double.parseDouble(fields[1]),
  827.                                                            Double.parseDouble(fields[3]));
  828.                     final DumpedCall last = global.calls.get(global.calls.size() - 1);
  829.                     last.expected = sp;
  830.                 }
  831.             }

  833.         },

  835.         /** Parser for sensor dump lines. */
  836.         SENSOR() {

  838.             /** {@inheritDoc} */
  839.             @Override
  840.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  841.                 if (fields.length < 8 || !fields[0].equals(SENSOR_NAME) ||
  842.                     !fields[2].equals(NB_PIXELS) || !fields[4].equals(POSITION)) {
  843.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  844.                 }
  845.                 final ParsedSensor sensor = global.getSensor(fields[1]);
  846.                 sensor.setNbPixels(Integer.parseInt(fields[3]));
  847.                 sensor.setPosition(new Vector3D(Double.parseDouble(fields[5]),
  848.                                                 Double.parseDouble(fields[6]),
  849.                                                 Double.parseDouble(fields[7])));
  850.             }

  852.         },

  854.         /** Parser for sensor mean plane dump lines. */
  855.         SENSOR_MEAN_PLANE() {

  857.             /** {@inheritDoc} */
  858.             @Override
  859.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  860.                 if (fields.length < 16 || !fields[0].equals(SENSOR_NAME) ||
  861.                         !fields[2].equals(MIN_LINE) || !fields[4].equals(MAX_LINE) ||
  862.                         !fields[6].equals(MAX_EVAL) || !fields[8].equals(ACCURACY) ||
  863.                         !fields[10].equals(NORMAL)  || !fields[14].equals(CACHED_RESULTS)) {
  864.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  865.                 }
  866.                 final String   sensorName = fields[1];
  867.                 final int      minLine    = Integer.parseInt(fields[3]);
  868.                 final int      maxLine    = Integer.parseInt(fields[5]);
  869.                 final int      maxEval    = Integer.parseInt(fields[7]);
  870.                 final double   accuracy   = Double.parseDouble(fields[9]);
  871.                 final Vector3D normal     = new Vector3D(Double.parseDouble(fields[11]),
  872.                         Double.parseDouble(fields[12]),
  873.                         Double.parseDouble(fields[13]));
  874.                 final int      n          = Integer.parseInt(fields[15]);
  875.                 final CrossingResult[] cachedResults = new CrossingResult[n];
  876.                 int base = 16;
  877.                 for (int i = 0; i < n; ++i) {
  878.                     if (fields.length < base + 15 || !fields[base].equals(LINE_NUMBER) ||
  879.                             !fields[base + 2].equals(DATE) || !fields[base + 4].equals(TARGET) ||
  880.                             !fields[base + 8].equals(TARGET_DIRECTION)) {
  881.                         throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  882.                     }
  883.                     final double       ln                    = Double.parseDouble(fields[base + 1]);
  884.                     final AbsoluteDate date                  = new AbsoluteDate(fields[base + 3], TimeScalesFactory.getUTC());
  885.                     final Vector3D     target                = new Vector3D(Double.parseDouble(fields[base +  5]),
  886.                             Double.parseDouble(fields[base +  6]),
  887.                             Double.parseDouble(fields[base +  7]));
  888.                     final Vector3D targetDirection           = new Vector3D(Double.parseDouble(fields[base +  9]),
  889.                             Double.parseDouble(fields[base + 10]),
  890.                             Double.parseDouble(fields[base + 11]));
  891.                     final Vector3D targetDirectionDerivative = new Vector3D(Double.parseDouble(fields[base + 12]),
  892.                             Double.parseDouble(fields[base + 13]),
  893.                             Double.parseDouble(fields[base + 14]));
  894.                     cachedResults[i] = new CrossingResult(date, ln, target, targetDirection, targetDirectionDerivative);
  895.                     base += 15;
  896.                 }
  897.                 global.getSensor(sensorName).setMeanPlane(new ParsedMeanPlane(minLine, maxLine, maxEval, accuracy, normal, cachedResults));
  898.             }
  899.         },

  901.         /** Parser for sensor LOS dump lines. */
  902.         SENSOR_LOS() {

  904.             /** {@inheritDoc} */
  905.             @Override
  906.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  907.                 if (fields.length < 10 || !fields[0].equals(SENSOR_NAME) ||
  908.                         !fields[2].equals(DATE) || !fields[4].equals(PIXEL_NUMBER) ||
  909.                         !fields[6].equals(LOS)) {
  910.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  911.                 }
  912.                 final String       sensorName  = fields[1];
  913.                 final AbsoluteDate date        = new AbsoluteDate(fields[3], TimeScalesFactory.getUTC());
  914.                 final int          pixelNumber = Integer.parseInt(fields[5]);
  915.                 final Vector3D     los         = new Vector3D(Double.parseDouble(fields[7]),
  916.                         Double.parseDouble(fields[8]),
  917.                         Double.parseDouble(fields[9]));
  918.                 global.getSensor(sensorName).setLOS(date, pixelNumber, los);
  919.             }
  920.         },

  922.         /** Parser for sensor datation dump lines. */
  923.         SENSOR_DATATION() {

  925.             /** {@inheritDoc} */
  926.             @Override
  927.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  928.                 if (fields.length < 6 || !fields[0].equals(SENSOR_NAME) ||
  929.                         !fields[2].equals(LINE_NUMBER) || !fields[4].equals(DATE)) {
  930.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  931.                 }
  932.                 final String       sensorName  = fields[1];
  933.                 final double       lineNumber  = Double.parseDouble(fields[3]);
  934.                 final AbsoluteDate date        = new AbsoluteDate(fields[5], TimeScalesFactory.getUTC());
  935.                 global.getSensor(sensorName).setDatation(lineNumber, date);
  936.             }
  937.         },

  939.         /** Parser for sensor rate dump lines. */
  940.         SENSOR_RATE() {

  942.             /** {@inheritDoc} */
  943.             @Override
  944.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global) {
  945.                 if (fields.length < 6 || !fields[0].equals(SENSOR_NAME) ||
  946.                     !fields[2].equals(LINE_NUMBER) || !fields[4].equals(RATE)) {
  947.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  948.                 }
  949.                 final String       sensorName  = fields[1];
  950.                 final double       lineNumber  = Double.parseDouble(fields[3]);
  951.                 final double       rate  = Double.parseDouble(fields[5]);
  952.                 global.getSensor(sensorName).setRate(lineNumber, rate);

  954.             }

  956.         };

  958.         /** Parse a line.
  959.          * @param l line number
  960.          * @param file dump file
  961.          * @param line line to parse
  962.          * @param global global parser to store parsed data
  963.          */
  964.         public static void parse(final int l, final File file, final String line, final DumpReplayer global) {

  966.             final String trimmed = line.trim();
  967.             if (trimmed.length() == 0 || trimmed.startsWith(COMMENT_START)) {
  968.                 return;
  969.             }

  971.             final int colon = line.indexOf(':');
  972.             if (colon > 0) {
  973.                 final String parsedKey = PATTERN.matcher(line.substring(0, colon).trim()).replaceAll("_").toUpperCase();
  974.                 try {
  975.                     final LineParser parser = LineParser.valueOf(parsedKey);
  976.                     final String[] fields;
  977.                     if (colon + 1 >= line.length()) {
  978.                         fields = new String[0];
  979.                     } else {
  980.                         fields = SEPARATOR.split(line.substring(colon + 1).trim());
  981.                     }
  982.                     parser.parse(l, file, line, fields, global);
  983.                 } catch (IllegalArgumentException iae) {
  984.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  985.                 }

  987.             } else {
  988.                 throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  989.             }

  991.         }

  993.         /** Parse a line.
  994.          * @param l line number
  995.          * @param file dump file
  996.          * @param line complete line
  997.          * @param fields data fields from the line
  998.          * @param global global parser to store parsed data
  999.          */
  1000.         public abstract void parse(int l, File file, String line, String[] fields, DumpReplayer global);

  1002.     }

  1004.     /** Local class for handling already parsed tile data. */
  1005.     private static class ParsedTile {

  1007.         /** Name of the tile. */
  1008.         private final String name;

  1010.         /** Minimum latitude. */
  1011.         private final double minLatitude;

  1013.         /** Step in latitude (size of one raster element). */
  1014.         private final double latitudeStep;

  1016.         /** Number of latitude rows. */
  1017.         private int latitudeRows;

  1019.         /** Minimum longitude. */
  1020.         private final double minLongitude;

  1022.         /** Step in longitude (size of one raster element). */
  1023.         private final double longitudeStep;

  1025.         /** Number of longitude columns. */
  1026.         private int longitudeColumns;

  1028.         /** Raster elevation data. */
  1029.         private final OpenIntToDoubleHashMap elevations;

  1031.         /** Simple constructor.
  1032.          * @param name of the tile
  1033.          * @param minLatitude minimum latitude
  1034.          * @param latitudeStep step in latitude (size of one raster element)
  1035.          * @param latitudeRows number of latitude rows
  1036.          * @param minLongitude minimum longitude
  1037.          * @param longitudeStep step in longitude (size of one raster element)
  1038.          * @param longitudeColumns number of longitude columns
  1039.          */
  1040.         ParsedTile(final String name,
  1041.                    final double minLatitude, final double latitudeStep, final int latitudeRows,
  1042.                    final double minLongitude, final double longitudeStep, final int longitudeColumns) {
  1043.             this.name             = name;
  1044.             this.minLatitude      = minLatitude;
  1045.             this.latitudeStep     = latitudeStep;
  1046.             this.minLongitude     = minLongitude;
  1047.             this.longitudeStep    = longitudeStep;
  1048.             this.latitudeRows     = latitudeRows;
  1049.             this.longitudeColumns = longitudeColumns;
  1050.             this.elevations       = new OpenIntToDoubleHashMap();
  1051.         }

  1053.         /** Check if a point is in the interpolable region of the tile.
  1054.          * @param latitude point latitude
  1055.          * @param longitude point longitude
  1056.          * @return true if the point is in the interpolable region of the tile
  1057.          */
  1058.         public boolean isInterpolable(final double latitude, final double longitude) {
  1059.             final int latitudeIndex  = (int) FastMath.floor((latitude  - minLatitude)  / latitudeStep);
  1060.             final int longitudeIndex = (int) FastMath.floor((longitude - minLongitude) / longitudeStep);
  1061.             return latitudeIndex  >= 0 && latitudeIndex  <= latitudeRows     - 2 &&
  1062.                    longitudeIndex >= 0 && longitudeIndex <= longitudeColumns - 2;
  1063.         }

  1065.         /** Update the tile according to the Digital Elevation Model.
  1066.          * @param tile to update
  1067.          */
  1068.         public void updateTile(final UpdatableTile tile) {

  1070.             tile.setGeometry(minLatitude, minLongitude,
  1071.                              latitudeStep, longitudeStep,
  1072.                              latitudeRows, longitudeColumns);

  1074.             final OpenIntToDoubleHashMap.Iterator iterator = elevations.iterator();
  1075.             while (iterator.hasNext()) {
  1076.                 iterator.advance();
  1077.                 final int    index          = iterator.key();
  1078.                 final int    latitudeIndex  = index / longitudeColumns;
  1079.                 final int    longitudeIndex = index % longitudeColumns;
  1080.                 final double elevation      = iterator.value();
  1081.                 tile.setElevation(latitudeIndex, longitudeIndex, elevation);
  1082.             }

  1084.         }

  1086.     }

  1088.     /** Local class for handling already parsed sensor data. */
  1089.     private static class ParsedSensor implements LineDatation, TimeDependentLOS {

  1091.         /** Name of the sensor. */
  1092.         private final String name;

  1094.         /** Number of pixels. */
  1095.         private int nbPixels;

  1097.         /** Position. */
  1098.         private Vector3D position;

  1100.         /** Mean plane crossing finder. */
  1101.         private ParsedMeanPlane meanPlane;

  1103.         /** LOS map. */
  1104.         private final Map<Integer, List<Pair<AbsoluteDate, Vector3D>>> losMap;

  1106.         /** Datation. */
  1107.         private final List<Pair<Double, AbsoluteDate>> datation;

  1109.         /** Rate. */
  1110.         private final List<Pair<Double, Double>> rates;

  1112.         /** simple constructor.
  1113.          * @param name name of the sensor
  1114.          */
  1115.         ParsedSensor(final String name) {
  1116.             this.name     = name;
  1117.             this.losMap   = new HashMap<Integer, List<Pair<AbsoluteDate, Vector3D>>>();
  1118.             this.datation = new ArrayList<Pair<Double, AbsoluteDate>>();
  1119.             this.rates    = new ArrayList<Pair<Double, Double>>();
  1120.         }

  1122.         /** Set the mean place finder.
  1123.          * @param meanPlane mean plane finder
  1124.          */
  1125.         public void setMeanPlane(final ParsedMeanPlane meanPlane) {
  1126.             this.meanPlane = meanPlane;
  1127.         }

  1129.         /** Set the position.
  1130.          * @param position position
  1131.          */
  1132.         public void setPosition(final Vector3D position) {
  1133.             this.position = position;
  1134.         }

  1136.         /** Set the number of pixels.
  1137.          * @param nbPixels number of pixels
  1138.          */
  1139.         public void setNbPixels(final int nbPixels) {
  1140.             this.nbPixels = nbPixels;
  1141.         }

  1143.         /** {@inheritDoc} */
  1144.         @Override
  1145.         public int getNbPixels() {
  1146.             return nbPixels;
  1147.         }

  1149.         /** Set a los direction.
  1150.          * @param date date
  1151.          * @param pixelNumber number of the pixel
  1152.          * @param los los direction
  1153.          */
  1154.         public void setLOS(final AbsoluteDate date, final int pixelNumber, final Vector3D los) {
  1155.             List<Pair<AbsoluteDate, Vector3D>> list = losMap.get(pixelNumber);
  1156.             if (list == null) {
  1157.                 list = new ArrayList<Pair<AbsoluteDate, Vector3D>>();
  1158.                 losMap.put(pixelNumber, list);
  1159.             }
  1160.             // find insertion index to have LOS sorted chronologically
  1161.             int index = 0;
  1162.             while (index < list.size()) {
  1163.                 if (list.get(index).getFirst().compareTo(date) > 0) {
  1164.                     break;
  1165.                 }
  1166.                 ++index;
  1167.             }
  1168.             list.add(index, new Pair<AbsoluteDate, Vector3D>(date, los));
  1169.         }

  1171.         /** {@inheritDoc} */
  1172.         @Override
  1173.         public Vector3D getLOS(final int index, final AbsoluteDate date) {
  1174.             final List<Pair<AbsoluteDate, Vector3D>> list = losMap.get(index);
  1175.             if (list == null) {
  1176.                 throw new RuggedInternalError(null);
  1177.             }

  1179.             if (list.size() < 2) {
  1180.                 return list.get(0).getSecond();
  1181.             }

  1183.             // find entries bracketing the the date
  1184.             int sup = 0;
  1185.             while (sup < list.size() - 1) {
  1186.                 if (list.get(sup).getFirst().compareTo(date) >= 0) {
  1187.                     break;
  1188.                 }
  1189.                 ++sup;
  1190.             }
  1191.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1193.             final AbsoluteDate dInf  = list.get(inf).getFirst();
  1194.             final Vector3D     lInf  = list.get(inf).getSecond();
  1195.             final AbsoluteDate dSup  = list.get(sup).getFirst();
  1196.             final Vector3D     lSup  = list.get(sup).getSecond();
  1197.             final double       alpha = date.durationFrom(dInf) / dSup.durationFrom(dInf);
  1198.             return new Vector3D(alpha, lSup, 1 - alpha, lInf);

  1200.         }

  1202.         /** {@inheritDoc} */
  1203.         @Override
  1204.         public <T extends Derivative<T>> FieldVector3D<T> getLOSDerivatives(final int index, final AbsoluteDate date,
  1205.                                                                             final DerivativeGenerator<T> generator) {
  1206.             final Vector3D los = getLOS(index, date);
  1207.             return new FieldVector3D<>(generator.constant(los.getX()),
  1208.                                        generator.constant(los.getY()),
  1209.                                        generator.constant(los.getZ()));
  1210.         }

  1212.         /** Set a datation pair.
  1213.          * @param lineNumber line number
  1214.          * @param date date
  1215.          */
  1216.         public void setDatation(final double lineNumber, final AbsoluteDate date) {
  1217.             // find insertion index to have datations sorted chronologically
  1218.             int index = 0;
  1219.             while (index < datation.size()) {
  1220.                 if (datation.get(index).getSecond().compareTo(date) > 0) {
  1221.                     break;
  1222.                 }
  1223.                 ++index;
  1224.             }
  1225.             datation.add(index, new Pair<Double, AbsoluteDate>(lineNumber, date));
  1226.         }

  1228.         /** {@inheritDoc} */
  1229.         @Override
  1230.         public AbsoluteDate getDate(final double lineNumber) {

  1232.             if (datation.size() < 2) {
  1233.                 return datation.get(0).getSecond();
  1234.             }

  1236.             // find entries bracketing the line number
  1237.             int sup = 0;
  1238.             while (sup < datation.size() - 1) {
  1239.                 if (datation.get(sup).getFirst() >= lineNumber) {
  1240.                     break;
  1241.                 }
  1242.                 ++sup;
  1243.             }
  1244.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1246.             final double       lInf  = datation.get(inf).getFirst();
  1247.             final AbsoluteDate dInf  = datation.get(inf).getSecond();
  1248.             final double       lSup  = datation.get(sup).getFirst();
  1249.             final AbsoluteDate dSup  = datation.get(sup).getSecond();
  1250.             final double       alpha = (lineNumber - lInf) / (lSup - lInf);
  1251.             return dInf.shiftedBy(alpha * dSup.durationFrom(dInf));

  1253.         }

  1255.         /** {@inheritDoc} */
  1256.         @Override
  1257.         public double getLine(final AbsoluteDate date) {

  1259.             if (datation.size() < 2) {
  1260.                 return datation.get(0).getFirst();
  1261.             }

  1263.             // find entries bracketing the date
  1264.             int sup = 0;
  1265.             while (sup < datation.size() - 1) {
  1266.                 if (datation.get(sup).getSecond().compareTo(date) >= 0) {
  1267.                     break;
  1268.                 }
  1269.                 ++sup;
  1270.             }
  1271.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1273.             final double       lInf  = datation.get(inf).getFirst();
  1274.             final AbsoluteDate dInf  = datation.get(inf).getSecond();
  1275.             final double       lSup  = datation.get(sup).getFirst();
  1276.             final AbsoluteDate dSup  = datation.get(sup).getSecond();
  1277.             final double       alpha = date.durationFrom(dInf) / dSup.durationFrom(dInf);
  1278.             return alpha * lSup + (1 - alpha) * lInf;

  1280.         }

  1282.         /** Set a rate.
  1283.          * @param lineNumber line number
  1284.          * @param rate lines rate
  1285.          */
  1286.         public void setRate(final double lineNumber, final double rate) {
  1287.             // find insertion index to have rates sorted by line numbers
  1288.             int index = 0;
  1289.             while (index < rates.size()) {
  1290.                 if (rates.get(index).getFirst() > lineNumber) {
  1291.                     break;
  1292.                 }
  1293.                 ++index;
  1294.             }
  1295.             rates.add(index, new Pair<Double, Double>(lineNumber, rate));
  1296.         }

  1298.         /** {@inheritDoc} */
  1299.         @Override
  1300.         public double getRate(final double lineNumber) {

  1302.             if (rates.size() < 2) {
  1303.                 return rates.get(0).getSecond();
  1304.             }

  1306.             // find entries bracketing the line number
  1307.             int sup = 0;
  1308.             while (sup < rates.size() - 1) {
  1309.                 if (rates.get(sup).getFirst() >= lineNumber) {
  1310.                     break;
  1311.                 }
  1312.                 ++sup;
  1313.             }
  1314.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1316.             final double lInf  = rates.get(inf).getFirst();
  1317.             final double rInf  = rates.get(inf).getSecond();
  1318.             final double lSup  = rates.get(sup).getFirst();
  1319.             final double rSup  = rates.get(sup).getSecond();
  1320.             final double alpha = (lineNumber - lInf) / (lSup - lInf);
  1321.             return alpha * rSup + (1 - alpha) * rInf;

  1323.         }

  1325.         /** {@inheritDoc} */
  1326.         @Override
  1327.         public Stream<ParameterDriver> getParametersDrivers() {
  1328.             return Stream.<ParameterDriver>empty();
  1329.         }

  1331.     }

  1333.     /** Local class for handling already parsed mean plane data. */
  1334.     private static class ParsedMeanPlane {

  1336.         /** Min line. */
  1337.         private final int minLine;

  1339.         /** Max line. */
  1340.         private final int maxLine;

  1342.         /** Maximum number of evaluations. */
  1343.         private final int maxEval;

  1345.         /** Accuracy to use for finding crossing line number. */
  1346.         private final double accuracy;

  1348.         /** Mean plane normal. */
  1349.         private final Vector3D normal;

  1351.         /** Cached results. */
  1352.         private final CrossingResult[] cachedResults;

  1354.         /** simple constructor.
  1355.          * @param minLine min line
  1356.          * @param maxLine max line
  1357.          * @param maxEval maximum number of evaluations
  1358.          * @param accuracy accuracy to use for finding crossing line number
  1359.          * @param normal mean plane normal
  1360.          * @param cachedResults cached results
  1361.          */
  1362.         ParsedMeanPlane(final int minLine, final int maxLine,
  1363.                         final int maxEval, final double accuracy, final Vector3D normal,
  1364.                         final CrossingResult[] cachedResults) {
  1365.             this.minLine       = minLine;
  1366.             this.maxLine       = maxLine;
  1367.             this.maxEval       = maxEval;
  1368.             this.accuracy      = accuracy;
  1369.             this.normal        = normal;
  1370.             this.cachedResults = cachedResults.clone();
  1371.         }

  1373.     }

  1375.     /** Local interface for dumped calls. */
  1376.     private abstract static class DumpedCall {

  1378.         /** Expected result. */
  1379.         private Object expected;

  1381.         /** Execute a call.
  1382.          * @param rugged Rugged instance on which called should be performed
  1383.          * @return result of the call
  1384.          */
  1385.         public abstract Object execute(Rugged rugged);

  1387.     }

  1389. }
Created with JaCoCo 0.8.7.202105040129