DumpReplayer.java

  1. /* Copyright 2013-2025 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.                 // In the case of user used a non overlapping DEM: no need here to take it into account
  323.                 // as Rugged during the run created if necessary zipper tiles.
  324.                 // At this stage, the read DEM in the dump behave like an overlapping DEM.
  325.                 builder.setDigitalElevationModel(new TileUpdater() {

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

  342.             builder.setEllipsoid(ellipsoid);

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


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

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

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

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

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

  419.             return rugged;

  421.         } catch (IOException | NoSuchMethodException  | IllegalAccessException  | InvocationTargetException e) {
  422.             // this should never happen
  423.             throw new RuggedInternalError(e);
  424.         }
  425.     }

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

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

  459.     /** Container for replay results. */
  460.     public static class Result {

  462.         /** Expected result. */
  463.         private final Object expected;

  465.         /** Replayed result. */
  466.         private final Object replayed;

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

  477.         /** Get the expected result.
  478.          * @return expected result
  479.          */
  480.         public Object getExpected() {
  481.             return expected;
  482.         }

  484.         /** Get the replayed result.
  485.          * @return replayed result
  486.          */
  487.         public Object getReplayed() {
  488.             return replayed;
  489.         }

  491.     }

  493.     /** Line parsers. */
  494.     private enum LineParser {

  496.         /** Parser for algorithm dump lines. */
  497.         ALGORITHM() {

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

  518.         },

  520.         /** Parser for ellipsoid dump lines. */
  521.         ELLIPSOID() {

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

  540.         },

  542.         /** Parser for direct location calls dump lines. */
  543.         DIRECT_LOCATION() {

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

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

  588.                 });
  589.             }
  590.         },

  592.         /** Parser for direct location result dump lines. */
  593.         DIRECT_LOCATION_RESULT() {

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

  618.         },

  620.         /** Parser for search span dump lines. */
  621.         SPAN() {

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

  645.         /** Parser for observation transforms dump lines. */
  646.         TRANSFORM() {

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

  701.         },

  703.         /** Parser for DEM tile global geometry dump lines. */
  704.         DEM_TILE() {

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

  732.         },

  734.         /** Parser for DEM cells dump lines. */
  735.         DEM_CELL() {

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

  759.         },

  761.         /** Parser for inverse location calls dump lines. */
  762.         INVERSE_LOCATION() {

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

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

  807.                 });
  808.             }

  810.         },

  812.         /** Parser for inverse location result dump lines. */
  813.         INVERSE_LOCATION_RESULT() {

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

  836.         },

  838.         /** Parser for sensor dump lines. */
  839.         SENSOR() {

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

  855.         },

  857.         /** Parser for sensor mean plane dump lines. */
  858.         SENSOR_MEAN_PLANE() {

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

  904.         /** Parser for sensor LOS dump lines. */
  905.         SENSOR_LOS() {

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

  925.         /** Parser for sensor datation dump lines. */
  926.         SENSOR_DATATION() {

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

  942.         /** Parser for sensor rate dump lines. */
  943.         SENSOR_RATE() {

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

  957.             }

  959.         };

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

  969.             final String trimmed = line.trim();
  970.             if (trimmed.length() == 0 || trimmed.startsWith(COMMENT_START)) {
  971.                 return;
  972.             }

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

  990.             } else {
  991.                 throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  992.             }

  994.         }

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

  1005.     }

  1007.     /** Local class for handling already parsed tile data. */
  1008.     private static class ParsedTile {

  1010.         /** Name of the tile. */
  1011.         private final String name;

  1013.         /** Minimum latitude. */
  1014.         private final double minLatitude;

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

  1019.         /** Number of latitude rows. */
  1020.         private int latitudeRows;

  1022.         /** Minimum longitude. */
  1023.         private final double minLongitude;

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

  1028.         /** Number of longitude columns. */
  1029.         private int longitudeColumns;

  1031.         /** Raster elevation data. */
  1032.         private final OpenIntToDoubleHashMap elevations;

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

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

  1068.         /** Update the tile according to the Digital Elevation Model.
  1069.          * @param tile to update
  1070.          */
  1071.         public void updateTile(final UpdatableTile tile) {

  1073.             tile.setGeometry(minLatitude, minLongitude,
  1074.                              latitudeStep, longitudeStep,
  1075.                              latitudeRows, longitudeColumns);

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

  1087.         }

  1089.     }

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

  1094.         /** Name of the sensor. */
  1095.         private final String name;

  1097.         /** Number of pixels. */
  1098.         private int nbPixels;

  1100.         /** Position. */
  1101.         private Vector3D position;

  1103.         /** Mean plane crossing finder. */
  1104.         private ParsedMeanPlane meanPlane;

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

  1109.         /** Datation. */
  1110.         private final List<Pair<Double, AbsoluteDate>> datation;

  1112.         /** Rate. */
  1113.         private final List<Pair<Double, Double>> rates;

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

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

  1132.         /** Set the position.
  1133.          * @param position position
  1134.          */
  1135.         public void setPosition(final Vector3D position) {
  1136.             this.position = position;
  1137.         }

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

  1146.         /** {@inheritDoc} */
  1147.         @Override
  1148.         public int getNbPixels() {
  1149.             return nbPixels;
  1150.         }

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

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

  1182.             if (list.size() < 2) {
  1183.                 return list.get(0).getSecond();
  1184.             }

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

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

  1203.         }

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

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

  1231.         /** {@inheritDoc} */
  1232.         @Override
  1233.         public AbsoluteDate getDate(final double lineNumber) {

  1235.             if (datation.size() < 2) {
  1236.                 return datation.get(0).getSecond();
  1237.             }

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

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

  1256.         }

  1258.         /** {@inheritDoc} */
  1259.         @Override
  1260.         public double getLine(final AbsoluteDate date) {

  1262.             if (datation.size() < 2) {
  1263.                 return datation.get(0).getFirst();
  1264.             }

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

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

  1283.         }

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

  1301.         /** {@inheritDoc} */
  1302.         @Override
  1303.         public double getRate(final double lineNumber) {

  1305.             if (rates.size() < 2) {
  1306.                 return rates.get(0).getSecond();
  1307.             }

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

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

  1326.         }

  1328.         /** {@inheritDoc} */
  1329.         @Override
  1330.         public Stream<ParameterDriver> getParametersDrivers() {
  1331.             return Stream.<ParameterDriver>empty();
  1332.         }

  1334.     }

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

  1339.         /** Min line. */
  1340.         private final int minLine;

  1342.         /** Max line. */
  1343.         private final int maxLine;

  1345.         /** Maximum number of evaluations. */
  1346.         private final int maxEval;

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

  1351.         /** Mean plane normal. */
  1352.         private final Vector3D normal;

  1354.         /** Cached results. */
  1355.         private final CrossingResult[] cachedResults;

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

  1376.     }

  1378.     /** Local interface for dumped calls. */
  1379.     private abstract static class DumpedCall {

  1381.         /** Expected result. */
  1382.         private Object expected;

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

  1390.     }

  1392. }
Created with JaCoCo 0.8.12.202403310830