DumpReplayer.java

  1. /* Copyright 2013-2017 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.stream.Stream;

  38. import org.hipparchus.analysis.differentiation.DerivativeStructure;
  39. import org.hipparchus.exception.LocalizedCoreFormats;
  40. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  41. import org.hipparchus.geometry.euclidean.threed.Rotation;
  42. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  43. import org.hipparchus.util.FastMath;
  44. import org.hipparchus.util.OpenIntToDoubleHashMap;
  45. import org.hipparchus.util.Pair;
  46. import org.orekit.bodies.GeodeticPoint;
  47. import org.orekit.bodies.OneAxisEllipsoid;
  48. import org.orekit.errors.OrekitException;
  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.utils.DSGenerator;
  65. import org.orekit.rugged.utils.SpacecraftToObservedBody;
  66. import org.orekit.time.AbsoluteDate;
  67. import org.orekit.time.TimeScalesFactory;
  68. import org.orekit.utils.ParameterDriver;

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

  78.     /** Comment start marker. */
  79.     private static final String COMMENT_START = "#";

  81.     /** Keyword for latitude fields. */
  82.     private static final String LATITUDE = "latitude";

  84.     /** Keyword for longitude fields. */
  85.     private static final String LONGITUDE = "longitude";

  87.     /** Keyword for elevation fields. */
  88.     private static final String ELEVATION = "elevation";

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

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

  96.     /** Keyword for frame fields. */
  97.     private static final String FRAME = "frame";

  99.     /** Keyword for date fields. */
  100.     private static final String DATE = "date";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  201.     /** Keyword for accuracy. */
  202.     private static final String ACCURACY = "accuracy";

  204.     /** Keyword for normal. */
  205.     private static final String NORMAL = "normal";

  207.     /** Keyword for rate. */
  208.     private static final String RATE = "rate";

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

  213.     /** Keyword for target. */
  214.     private static final String TARGET = "target";

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

  219.     /** Constant elevation for constant elevation algorithm. */
  220.     private double constantElevation;

  222.     /** Algorithm identifier. */
  223.     private AlgorithmId algorithmId;

  225.     /** Ellipsoid. */
  226.     private OneAxisEllipsoid ellipsoid;

  228.     /** Tiles list. */
  229.     private final List<ParsedTile> tiles;

  231.     /** Sensors list. */
  232.     private final List<ParsedSensor> sensors;

  234.     /** Interpolator min date. */
  235.     private AbsoluteDate minDate;

  237.     /** Interpolator max date. */
  238.     private AbsoluteDate maxDate;

  240.     /** Interpolator step. */
  241.     private double tStep;

  243.     /** Interpolator overshoot tolerance. */
  244.     private double tolerance;

  246.     /** Inertial frame. */
  247.     private Frame inertialFrame;

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

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

  255.     /** Flag for light time correction. */
  256.     private boolean lightTimeCorrection;

  258.     /** Flag for aberration of light correction. */
  259.     private boolean aberrationOfLightCorrection;

  261.     /** Dumped calls. */
  262.     private final List<DumpedCall> calls;

  264.     /** Simple constructor.
  265.      */
  266.     public DumpReplayer() {
  267.         tiles   = new ArrayList<ParsedTile>();
  268.         sensors = new ArrayList<ParsedSensor>();
  269.         calls   = new ArrayList<DumpedCall>();
  270.     }

  272.     /** Parse a dump file.
  273.      * @param file dump file to parse
  274.      * @exception RuggedException if file cannot be parsed
  275.      */
  276.     public void parse(final File file) throws RuggedException {
  277.         try {
  278.             final BufferedReader reader =
  279.                     new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
  280.             int l = 0;
  281.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  282.                 LineParser.parse(++l, file, line, this);
  283.             }
  284.             reader.close();
  285.         } catch (IOException ioe) {
  286.             throw new RuggedException(ioe, LocalizedCoreFormats.SIMPLE_MESSAGE, ioe.getLocalizedMessage());
  287.         }
  288.     }

  290.     /** Create a Rugged instance from parsed data.
  291.      * @return rugged instance
  292.      * @exception RuggedException if some data are inconsistent or incomplete
  293.      */
  294.     public Rugged createRugged() throws RuggedException {
  295.         try {
  296.             final RuggedBuilder builder = new RuggedBuilder();

  298.             if (algorithmId == null) {
  299.                 algorithmId = AlgorithmId.IGNORE_DEM_USE_ELLIPSOID;
  300.             }
  301.             builder.setAlgorithm(algorithmId);
  302.             if (algorithmId == AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID) {
  303.                 builder.setConstantElevation(constantElevation);
  304.             } else if (algorithmId != AlgorithmId.IGNORE_DEM_USE_ELLIPSOID) {
  305.                 builder.setDigitalElevationModel(new TileUpdater() {

  307.                     /** {@inheritDoc} */
  308.                     @Override
  309.                     public void updateTile(final double latitude, final double longitude, final UpdatableTile tile)
  310.                         throws RuggedException {
  311.                         for (final ParsedTile parsedTile : tiles) {
  312.                             if (parsedTile.isInterpolable(latitude, longitude)) {
  313.                                 parsedTile.updateTile(tile);
  314.                                 return;
  315.                             }
  316.                         }
  317.                         throw new RuggedException(RuggedMessages.NO_DEM_DATA,
  318.                                                   FastMath.toDegrees(latitude), FastMath.toDegrees(longitude));
  319.                     }

  321.                 }, 8);
  322.             }

  324.             builder.setLightTimeCorrection(lightTimeCorrection);
  325.             builder.setAberrationOfLightCorrection(aberrationOfLightCorrection);

  327.             builder.setEllipsoid(ellipsoid);

  329.             // build missing transforms by extrapolating the parsed ones
  330.             final int n = (int) FastMath.ceil(maxDate.durationFrom(minDate) / tStep);
  331.             final List<Transform> b2iList = new ArrayList<Transform>(n);
  332.             final List<Transform> s2iList = new ArrayList<Transform>(n);
  333.             for (int i = 0; i < n; ++i) {
  334.                 if (bodyToInertial.containsKey(i)) {
  335.                     // the i-th transform was dumped
  336.                     b2iList.add(bodyToInertial.get(i));
  337.                     s2iList.add(scToInertial.get(i));
  338.                 } else {
  339.                     // the i-th transformed was not dumped, we have to extrapolate it
  340.                     final Map.Entry<Integer, Transform> lower  = bodyToInertial.lowerEntry(i);
  341.                     final Map.Entry<Integer, Transform> higher = bodyToInertial.higherEntry(i);
  342.                     final int closest;
  343.                     if (lower == null) {
  344.                         closest = higher.getKey();
  345.                     } else if (higher == null) {
  346.                         closest = lower.getKey();
  347.                     } else {
  348.                         closest = (i - lower.getKey() <= higher.getKey() - i) ? lower.getKey() : higher.getKey();
  349.                     }
  350.                     b2iList.add(bodyToInertial.get(closest).shiftedBy((i - closest) * tStep));
  351.                     s2iList.add(scToInertial.get(closest).shiftedBy((i - closest) * tStep));
  352.                 }
  353.             }

  355.             // we use Rugged transforms reloading mechanism to ensure the spacecraft
  356.             // to body transforms will be the same as the ones dumped
  357.             final SpacecraftToObservedBody scToBody =
  358.                     new SpacecraftToObservedBody(inertialFrame, ellipsoid.getBodyFrame(),
  359.                                                  minDate, maxDate, tStep, tolerance,
  360.                                                  b2iList, s2iList);
  361.             final ByteArrayOutputStream bos = new ByteArrayOutputStream();
  362.             new ObjectOutputStream(bos).writeObject(scToBody);
  363.             final ByteArrayInputStream  bis = new ByteArrayInputStream(bos.toByteArray());
  364.             builder.setTrajectoryAndTimeSpan(bis);

  366.             final List<SensorMeanPlaneCrossing> planeCrossings = new ArrayList<SensorMeanPlaneCrossing>();
  367.             for (final ParsedSensor parsedSensor : sensors) {
  368.                 final LineSensor sensor = new LineSensor(parsedSensor.name,
  369.                                                          parsedSensor,
  370.                                                          parsedSensor.position,
  371.                                                          parsedSensor);
  372.                 if (parsedSensor.meanPlane != null) {
  373.                     planeCrossings.add(new SensorMeanPlaneCrossing(sensor, scToBody,
  374.                                                                    parsedSensor.meanPlane.minLine,
  375.                                                                    parsedSensor.meanPlane.maxLine,
  376.                                                                    lightTimeCorrection, aberrationOfLightCorrection,
  377.                                                                    parsedSensor.meanPlane.maxEval,
  378.                                                                    parsedSensor.meanPlane.accuracy,
  379.                                                                    parsedSensor.meanPlane.normal,
  380.                                                                    Arrays.stream(parsedSensor.meanPlane.cachedResults)));
  381.                 }
  382.                 builder.addLineSensor(sensor);
  383.             }

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

  387.             final Method setPlaneCrossing = Rugged.class.getDeclaredMethod("setPlaneCrossing",
  388.                                                                            SensorMeanPlaneCrossing.class);
  389.             setPlaneCrossing.setAccessible(true);
  390.             for (final SensorMeanPlaneCrossing planeCrossing : planeCrossings) {
  391.                 setPlaneCrossing.invoke(rugged, planeCrossing);
  392.             }

  394.             return rugged;

  396.         } catch (IOException ioe) {
  397.             throw new RuggedException(ioe, LocalizedCoreFormats.SIMPLE_MESSAGE, ioe.getLocalizedMessage());
  398.         } catch (SecurityException e) {
  399.             // this should never happen
  400.             throw RuggedException.createInternalError(e);
  401.         } catch (NoSuchMethodException e) {
  402.             // this should never happen
  403.             throw RuggedException.createInternalError(e);
  404.         } catch (IllegalArgumentException e) {
  405.             // this should never happen
  406.             throw RuggedException.createInternalError(e);
  407.         } catch (IllegalAccessException e) {
  408.             // this should never happen
  409.             throw RuggedException.createInternalError(e);
  410.         } catch (InvocationTargetException e) {
  411.             // this should never happen
  412.             throw RuggedException.createInternalError(e);
  413.         }

  415.     }

  417.     /** Get a sensor by name.
  418.      * @param name sensor name
  419.      * @return parsed sensor
  420.      */
  421.     private ParsedSensor getSensor(final String name) {
  422.         for (final ParsedSensor sensor : sensors) {
  423.             if (sensor.name.equals(name)) {
  424.                 return sensor;
  425.             }
  426.         }
  427.         final ParsedSensor sensor = new ParsedSensor(name);
  428.         sensors.add(sensor);
  429.         return sensor;
  430.     }

  432.     /** Execute all dumped calls.
  433.      * <p>
  434.      * The dumped calls correspond to computation methods like direct or inverse
  435.      * location.
  436.      * </p>
  437.      * @param rugged Rugged instance on which calls will be performed
  438.      * @return results of all dumped calls
  439.      * @exception RuggedException if a call fails
  440.      */
  441.     public Result[] execute(final Rugged rugged) throws RuggedException {
  442.         final Result[] results = new Result[calls.size()];
  443.         for (int i = 0; i < calls.size(); ++i) {
  444.             results[i] = new Result(calls.get(i).expected,
  445.                                     calls.get(i).execute(rugged));
  446.         }
  447.         return results;
  448.     }

  450.     /** Container for replay results. */
  451.     public static class Result {

  453.         /** Expected result. */
  454.         private final Object expected;

  456.         /** Replayed result. */
  457.         private final Object replayed;

  459.         /** Simple constructor.
  460.          * @param expected expected result
  461.          * @param replayed replayed result
  462.          */
  463.         private Result(final Object expected, final Object replayed) {
  464.             this.expected = expected;
  465.             this.replayed = replayed;
  466.         }

  468.         /** Get the expected result.
  469.          * @return expected result
  470.          */
  471.         public Object getExpected() {
  472.             return expected;
  473.         }

  475.         /** Get the replayed result.
  476.          * @return replayed result
  477.          */
  478.         public Object getReplayed() {
  479.             return replayed;
  480.         }

  482.     }

  484.     /** Line parsers. */
  485.     private enum LineParser {

  487.         /** Parser for algorithm dump lines. */
  488.         ALGORITHM() {

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

  510.         },

  512.         /** Parser for ellipsoid dump lines. */
  513.         ELLIPSOID() {

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

  535.         },

  537.         /** Parser for direct location calls dump lines. */
  538.         DIRECT_LOCATION() {

  540.             /** {@inheritDoc} */
  541.             @Override
  542.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
  543.                 throws RuggedException {
  544.                 try {
  545.                     if (fields.length < 14 ||
  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.                         throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  550.                     }
  551.                     final AbsoluteDate date = new AbsoluteDate(fields[1], TimeScalesFactory.getUTC());
  552.                     final Vector3D position = new Vector3D(Double.parseDouble(fields[3]),
  553.                                                            Double.parseDouble(fields[4]),
  554.                                                            Double.parseDouble(fields[5]));
  555.                     final Vector3D los      = new Vector3D(Double.parseDouble(fields[7]),
  556.                                                            Double.parseDouble(fields[8]),
  557.                                                            Double.parseDouble(fields[9]));
  558.                     if (global.calls.isEmpty()) {
  559.                         global.lightTimeCorrection         = Boolean.parseBoolean(fields[11]);
  560.                         global.aberrationOfLightCorrection = Boolean.parseBoolean(fields[13]);
  561.                     } else {
  562.                         if (global.lightTimeCorrection != Boolean.parseBoolean(fields[11])) {
  563.                             throw new RuggedException(RuggedMessages.LIGHT_TIME_CORRECTION_REDEFINED,
  564.                                                       l, file.getAbsolutePath(), line);
  565.                         }
  566.                         if (global.aberrationOfLightCorrection != Boolean.parseBoolean(fields[13])) {
  567.                             throw new RuggedException(RuggedMessages.ABERRATION_OF_LIGHT_CORRECTION_REDEFINED,
  568.                                                       l, file.getAbsolutePath(), line);
  569.                         }
  570.                     }
  571.                     global.calls.add(new DumpedCall() {

  573.                         /** {@inheritDoc} */
  574.                         @Override
  575.                         public Object execute(final Rugged rugged) throws RuggedException {
  576.                             return rugged.directLocation(date, position, los);
  577.                         }

  579.                     });
  580.                 } catch (OrekitException oe) {
  581.                     throw new RuggedException(oe, oe.getSpecifier(), oe.getParts());
  582.                 }
  583.             }

  585.         },

  587.         /** Parser for direct location result dump lines. */
  588.         DIRECT_LOCATION_RESULT() {

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

  605.         },

  607.         /** Parser for search span dump lines. */
  608.         SPAN() {

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

  636.         },

  638.         /** Parser for observation transforms dump lines. */
  639.         TRANSFORM() {

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

  695.         },

  697.         /** Parser for DEM tile global geometry dump lines. */
  698.         DEM_TILE() {

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

  727.         },

  729.         /** Parser for DEM cells dump lines. */
  730.         DEM_CELL() {

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

  755.         },

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

  760.             /** {@inheritDoc} */
  761.             @Override
  762.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
  763.                 throws RuggedException {
  764.                 if (fields.length < 16 ||
  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.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  770.                 }
  771.                 final String sensorName = fields[1];
  772.                 final GeodeticPoint point = new GeodeticPoint(Double.parseDouble(fields[3]),
  773.                                                               Double.parseDouble(fields[5]),
  774.                                                               Double.parseDouble(fields[7]));
  775.                 final int minLine = Integer.parseInt(fields[9]);
  776.                 final int maxLine = Integer.parseInt(fields[11]);
  777.                 if (global.calls.isEmpty()) {
  778.                     global.lightTimeCorrection         = Boolean.parseBoolean(fields[13]);
  779.                     global.aberrationOfLightCorrection = Boolean.parseBoolean(fields[15]);
  780.                 } else {
  781.                     if (global.lightTimeCorrection != Boolean.parseBoolean(fields[13])) {
  782.                         throw new RuggedException(RuggedMessages.LIGHT_TIME_CORRECTION_REDEFINED,
  783.                                                   l, file.getAbsolutePath(), line);
  784.                     }
  785.                     if (global.aberrationOfLightCorrection != Boolean.parseBoolean(fields[15])) {
  786.                         throw new RuggedException(RuggedMessages.ABERRATION_OF_LIGHT_CORRECTION_REDEFINED,
  787.                                                   l, file.getAbsolutePath(), line);
  788.                     }
  789.                 }
  790.                 global.calls.add(new DumpedCall() {

  792.                     /** {@inheritDoc} */
  793.                     @Override
  794.                     public Object execute(final Rugged rugged) throws RuggedException {
  795.                         return rugged.inverseLocation(sensorName, point, minLine, maxLine);
  796.                     }

  798.                 });
  799.             }

  801.         },

  803.         /** Parser for inverse location result dump lines. */
  804.         INVERSE_LOCATION_RESULT() {

  806.             /** {@inheritDoc} */
  807.             @Override
  808.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
  809.                 throws RuggedException {
  810.                 if (fields.length < 4 || !fields[0].equals(LINE_NUMBER) || !fields[2].equals(PIXEL_NUMBER)) {
  811.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  812.                 }
  813.                 final SensorPixel sp = new SensorPixel(Double.parseDouble(fields[1]),
  814.                                                        Double.parseDouble(fields[3]));
  815.                 final DumpedCall last = global.calls.get(global.calls.size() - 1);
  816.                 last.expected = sp;
  817.             }

  819.         },

  821.         /** Parser for sensor dump lines. */
  822.         SENSOR() {

  824.             /** {@inheritDoc} */
  825.             @Override
  826.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
  827.                 throws RuggedException {
  828.                 if (fields.length < 8 || !fields[0].equals(SENSOR_NAME) ||
  829.                     !fields[2].equals(NB_PIXELS) || !fields[4].equals(POSITION)) {
  830.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  831.                 }
  832.                 final ParsedSensor sensor = global.getSensor(fields[1]);
  833.                 sensor.setNbPixels(Integer.parseInt(fields[3]));
  834.                 sensor.setPosition(new Vector3D(Double.parseDouble(fields[5]),
  835.                                                 Double.parseDouble(fields[6]),
  836.                                                 Double.parseDouble(fields[7])));
  837.             }

  839.         },

  841.         /** Parser for sensor mean plane dump lines. */
  842.         SENSOR_MEAN_PLANE() {

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

  888.                 } catch (OrekitException oe) {
  889.                     throw new RuggedException(oe, oe.getSpecifier(), oe.getParts());
  890.                 }
  891.             }

  893.         },

  895.         /** Parser for sensor LOS dump lines. */
  896.         SENSOR_LOS() {

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

  916.                 } catch (OrekitException oe) {
  917.                     throw new RuggedException(oe, oe.getSpecifier(), oe.getParts());
  918.                 }
  919.             }

  921.         },

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

  926.             /** {@inheritDoc} */
  927.             @Override
  928.             public void parse(final int l, final File file, final String line, final String[] fields, final DumpReplayer global)
  929.                 throws RuggedException {
  930.                 try {
  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);

  940.                 } catch (OrekitException oe) {
  941.                     throw new RuggedException(oe, oe.getSpecifier(), oe.getParts());
  942.                 }

  944.             }

  946.         },

  948.         /** Parser for sensor rate dump lines. */
  949.         SENSOR_RATE() {

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

  964.             }

  966.         };

  968.         /** Parse a line.
  969.          * @param l line number
  970.          * @param file dump file
  971.          * @param line line to parse
  972.          * @param global global parser to store parsed data
  973.          * @exception RuggedException if line is not supported
  974.          */
  975.         public static void parse(final int l, final File file, final String line, final DumpReplayer global)
  976.             throws RuggedException {

  978.             final String trimmed = line.trim();
  979.             if (trimmed.length() == 0 || trimmed.startsWith(COMMENT_START)) {
  980.                 return;
  981.             }

  983.             final int colon = line.indexOf(':');
  984.             if (colon > 0) {
  985.                 final String parsedKey = line.substring(0, colon).trim().replaceAll(" ", "_").toUpperCase();
  986.                 try {
  987.                     final LineParser parser = LineParser.valueOf(parsedKey);
  988.                     final String[] fields;
  989.                     if (colon + 1 >= line.length()) {
  990.                         fields = new String[0];
  991.                     } else {
  992.                         fields = line.substring(colon + 1).trim().split("\\s+");
  993.                     }
  994.                     parser.parse(l, file, line, fields, global);
  995.                 } catch (IllegalArgumentException iae) {
  996.                     throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  997.                 }

  999.             } else {
  1000.                 throw new RuggedException(RuggedMessages.CANNOT_PARSE_LINE, l, file, line);
  1001.             }

  1003.         }

  1005.         /** Parse a line.
  1006.          * @param l line number
  1007.          * @param file dump file
  1008.          * @param line complete line
  1009.          * @param fields data fields from the line
  1010.          * @param global global parser to store parsed data
  1011.          * @exception RuggedException if line cannot be parsed
  1012.          */
  1013.         public abstract void parse(int l, File file, String line, String[] fields, DumpReplayer global)
  1014.             throws RuggedException;

  1016.     }

  1018.     /** Local class for handling already parsed tile data. */
  1019.     private static class ParsedTile {

  1021.         /** Name of the tile. */
  1022.         private final String name;

  1024.         /** Minimum latitude. */
  1025.         private final double minLatitude;

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

  1030.         /** Number of latitude rows. */
  1031.         private int latitudeRows;

  1033.         /** Minimum longitude. */
  1034.         private final double minLongitude;

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

  1039.         /** Number of longitude columns. */
  1040.         private int longitudeColumns;

  1042.         /** Raster elevation data. */
  1043.         private final OpenIntToDoubleHashMap elevations;

  1045.         /** Simple constructor.
  1046.          * @param name of the tile
  1047.          * @param minLatitude minimum latitude
  1048.          * @param latitudeStep step in latitude (size of one raster element)
  1049.          * @param latitudeRows number of latitude rows
  1050.          * @param minLongitude minimum longitude
  1051.          * @param longitudeStep step in longitude (size of one raster element)
  1052.          * @param longitudeColumns number of longitude columns
  1053.          */
  1054.         ParsedTile(final String name,
  1055.                    final double minLatitude, final double latitudeStep, final int latitudeRows,
  1056.                    final double minLongitude, final double longitudeStep, final int longitudeColumns) {
  1057.             this.name             = name;
  1058.             this.minLatitude      = minLatitude;
  1059.             this.latitudeStep     = latitudeStep;
  1060.             this.minLongitude     = minLongitude;
  1061.             this.longitudeStep    = longitudeStep;
  1062.             this.latitudeRows     = latitudeRows;
  1063.             this.longitudeColumns = longitudeColumns;
  1064.             this.elevations       = new OpenIntToDoubleHashMap();
  1065.         }

  1067.         /** Check if a point is in the interpolable region of the tile.
  1068.          * @param latitude point latitude
  1069.          * @param longitude point longitude
  1070.          * @return true if the point is in the interpolable region of the tile
  1071.          */
  1072.         public boolean isInterpolable(final double latitude, final double longitude) {
  1073.             final int latitudeIndex  = (int) FastMath.floor((latitude  - minLatitude)  / latitudeStep);
  1074.             final int longitudeIndex = (int) FastMath.floor((longitude - minLongitude) / longitudeStep);
  1075.             return (latitudeIndex  >= 0) && (latitudeIndex  <= latitudeRows     - 2) &&
  1076.                    (longitudeIndex >= 0) && (longitudeIndex <= longitudeColumns - 2);
  1077.         }

  1079.         /** Update the tile according to the Digital Elevation Model.
  1080.          * @param tile to update
  1081.          * @exception RuggedException if tile cannot be updated
  1082.          */
  1083.         public void updateTile(final UpdatableTile tile)
  1084.             throws RuggedException {

  1086.             tile.setGeometry(minLatitude, minLongitude,
  1087.                              latitudeStep, longitudeStep,
  1088.                              latitudeRows, longitudeColumns);

  1090.             final OpenIntToDoubleHashMap.Iterator iterator = elevations.iterator();
  1091.             while (iterator.hasNext()) {
  1092.                 iterator.advance();
  1093.                 final int    index          = iterator.key();
  1094.                 final int    latitudeIndex  = index / longitudeColumns;
  1095.                 final int    longitudeIndex = index % longitudeColumns;
  1096.                 final double elevation      = iterator.value();
  1097.                 tile.setElevation(latitudeIndex, longitudeIndex, elevation);
  1098.             }

  1100.         }

  1102.     }

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

  1107.         /** Name of the sensor. */
  1108.         private final String name;

  1110.         /** Number of pixels. */
  1111.         private int nbPixels;

  1113.         /** Position. */
  1114.         private Vector3D position;

  1116.         /** Mean plane crossing finder. */
  1117.         private ParsedMeanPlane meanPlane;

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

  1122.         /** Datation. */
  1123.         private final List<Pair<Double, AbsoluteDate>> datation;

  1125.         /** Rate. */
  1126.         private final List<Pair<Double, Double>> rates;

  1128.         /** simple constructor.
  1129.          * @param name name of the sensor
  1130.          */
  1131.         ParsedSensor(final String name) {
  1132.             this.name     = name;
  1133.             this.losMap   = new HashMap<Integer, List<Pair<AbsoluteDate, Vector3D>>>();
  1134.             this.datation = new ArrayList<Pair<Double, AbsoluteDate>>();
  1135.             this.rates    = new ArrayList<Pair<Double, Double>>();
  1136.         }

  1138.         /** Set the mean place finder.
  1139.          * @param meanPlane mean plane finder
  1140.          */
  1141.         public void setMeanPlane(final ParsedMeanPlane meanPlane) {
  1142.             this.meanPlane = meanPlane;
  1143.         }

  1145.         /** Set the position.
  1146.          * @param position position
  1147.          */
  1148.         public void setPosition(final Vector3D position) {
  1149.             this.position = position;
  1150.         }

  1152.         /** Set the number of pixels.
  1153.          * @param nbPixels number of pixels
  1154.          */
  1155.         public void setNbPixels(final int nbPixels) {
  1156.             this.nbPixels = nbPixels;
  1157.         }

  1159.         /** {@inheritDoc} */
  1160.         @Override
  1161.         public int getNbPixels() {
  1162.             return nbPixels;
  1163.         }

  1165.         /** Set a los direction.
  1166.          * @param date date
  1167.          * @param pixelNumber number of the pixel
  1168.          * @param los los direction
  1169.          */
  1170.         public void setLOS(final AbsoluteDate date, final int pixelNumber, final Vector3D los) {
  1171.             List<Pair<AbsoluteDate, Vector3D>> list = losMap.get(pixelNumber);
  1172.             if (list == null) {
  1173.                 list = new ArrayList<Pair<AbsoluteDate, Vector3D>>();
  1174.                 losMap.put(pixelNumber, list);
  1175.             }
  1176.             // find insertion index to have LOS sorted chronologically
  1177.             int index = 0;
  1178.             while (index < list.size()) {
  1179.                 if (list.get(index).getFirst().compareTo(date) > 0) {
  1180.                     break;
  1181.                 }
  1182.                 ++index;
  1183.             }
  1184.             list.add(index, new Pair<AbsoluteDate, Vector3D>(date, los));
  1185.         }

  1187.         /** {@inheritDoc} */
  1188.         @Override
  1189.         public Vector3D getLOS(final int index, final AbsoluteDate date) {
  1190.             final List<Pair<AbsoluteDate, Vector3D>> list = losMap.get(index);
  1191.             if (list == null) {
  1192.                 throw RuggedException.createInternalError(null);
  1193.             }

  1195.             if (list.size() < 2) {
  1196.                 return list.get(0).getSecond();
  1197.             }

  1199.             // find entries bracketing the the date
  1200.             int sup = 0;
  1201.             while (sup < list.size() - 1) {
  1202.                 if (list.get(sup).getFirst().compareTo(date) >= 0) {
  1203.                     break;
  1204.                 }
  1205.                 ++sup;
  1206.             }
  1207.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1209.             final AbsoluteDate dInf  = list.get(inf).getFirst();
  1210.             final Vector3D     lInf  = list.get(inf).getSecond();
  1211.             final AbsoluteDate dSup  = list.get(sup).getFirst();
  1212.             final Vector3D     lSup  = list.get(sup).getSecond();
  1213.             final double       alpha = date.durationFrom(dInf) / dSup.durationFrom(dInf);
  1214.             return new Vector3D(alpha, lSup, 1 - alpha, lInf);

  1216.         }

  1218.         /** {@inheritDoc} */
  1219.         @Override
  1220.         public FieldVector3D<DerivativeStructure> getLOSDerivatives(final int index, final AbsoluteDate date,
  1221.                                                                     final DSGenerator generator) {
  1222.             final Vector3D los = getLOS(index, date);
  1223.             return new FieldVector3D<DerivativeStructure>(generator.constant(los.getX()),
  1224.                                                           generator.constant(los.getY()),
  1225.                                                           generator.constant(los.getZ()));
  1226.         }

  1228.         /** Set a datation pair.
  1229.          * @param lineNumber line number
  1230.          * @param date date
  1231.          */
  1232.         public void setDatation(final double lineNumber, final AbsoluteDate date) {
  1233.             // find insertion index to have datations sorted chronologically
  1234.             int index = 0;
  1235.             while (index < datation.size()) {
  1236.                 if (datation.get(index).getSecond().compareTo(date) > 0) {
  1237.                     break;
  1238.                 }
  1239.                 ++index;
  1240.             }
  1241.             datation.add(index, new Pair<Double, AbsoluteDate>(lineNumber, date));
  1242.         }

  1244.         /** {@inheritDoc} */
  1245.         @Override
  1246.         public AbsoluteDate getDate(final double lineNumber) {

  1248.             if (datation.size() < 2) {
  1249.                 return datation.get(0).getSecond();
  1250.             }

  1252.             // find entries bracketing the line number
  1253.             int sup = 0;
  1254.             while (sup < datation.size() - 1) {
  1255.                 if (datation.get(sup).getFirst() >= lineNumber) {
  1256.                     break;
  1257.                 }
  1258.                 ++sup;
  1259.             }
  1260.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1262.             final double       lInf  = datation.get(inf).getFirst();
  1263.             final AbsoluteDate dInf  = datation.get(inf).getSecond();
  1264.             final double       lSup  = datation.get(sup).getFirst();
  1265.             final AbsoluteDate dSup  = datation.get(sup).getSecond();
  1266.             final double       alpha = (lineNumber - lInf) / (lSup - lInf);
  1267.             return dInf.shiftedBy(alpha * dSup.durationFrom(dInf));

  1269.         }

  1271.         /** {@inheritDoc} */
  1272.         @Override
  1273.         public double getLine(final AbsoluteDate date) {

  1275.             if (datation.size() < 2) {
  1276.                 return datation.get(0).getFirst();
  1277.             }

  1279.             // find entries bracketing the date
  1280.             int sup = 0;
  1281.             while (sup < datation.size() - 1) {
  1282.                 if (datation.get(sup).getSecond().compareTo(date) >= 0) {
  1283.                     break;
  1284.                 }
  1285.                 ++sup;
  1286.             }
  1287.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1289.             final double       lInf  = datation.get(inf).getFirst();
  1290.             final AbsoluteDate dInf  = datation.get(inf).getSecond();
  1291.             final double       lSup  = datation.get(sup).getFirst();
  1292.             final AbsoluteDate dSup  = datation.get(sup).getSecond();
  1293.             final double       alpha = date.durationFrom(dInf) / dSup.durationFrom(dInf);
  1294.             return alpha * lSup + (1 - alpha) * lInf;

  1296.         }

  1298.         /** Set a rate.
  1299.          * @param lineNumber line number
  1300.          * @param rate lines rate
  1301.          */
  1302.         public void setRate(final double lineNumber, final double rate) {
  1303.             // find insertion index to have rates sorted by line numbers
  1304.             int index = 0;
  1305.             while (index < rates.size()) {
  1306.                 if (rates.get(index).getFirst() > lineNumber) {
  1307.                     break;
  1308.                 }
  1309.                 ++index;
  1310.             }
  1311.             rates.add(index, new Pair<Double, Double>(lineNumber, rate));
  1312.         }

  1314.         /** {@inheritDoc} */
  1315.         @Override
  1316.         public double getRate(final double lineNumber) {

  1318.             if (rates.size() < 2) {
  1319.                 return rates.get(0).getSecond();
  1320.             }

  1322.             // find entries bracketing the line number
  1323.             int sup = 0;
  1324.             while (sup < rates.size() - 1) {
  1325.                 if (rates.get(sup).getFirst() >= lineNumber) {
  1326.                     break;
  1327.                 }
  1328.                 ++sup;
  1329.             }
  1330.             final int inf = (sup == 0) ? sup++ : (sup - 1);

  1332.             final double lInf  = rates.get(inf).getFirst();
  1333.             final double rInf  = rates.get(inf).getSecond();
  1334.             final double lSup  = rates.get(sup).getFirst();
  1335.             final double rSup  = rates.get(sup).getSecond();
  1336.             final double alpha = (lineNumber - lInf) / (lSup - lInf);
  1337.             return alpha * rSup + (1 - alpha) * rInf;

  1339.         }

  1341.         /** {@inheritDoc} */
  1342.         @Override
  1343.         public Stream<ParameterDriver> getParametersDrivers() {
  1344.             return Stream.<ParameterDriver>empty();
  1345.         }

  1347.     }

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

  1352.         /** Min line. */
  1353.         private final int minLine;

  1355.         /** Max line. */
  1356.         private final int maxLine;

  1358.         /** Maximum number of evaluations. */
  1359.         private final int maxEval;

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

  1364.         /** Mean plane normal. */
  1365.         private final Vector3D normal;

  1367.         /** Cached results. */
  1368.         private final CrossingResult[] cachedResults;

  1370.         /** simple constructor.
  1371.          * @param minLine min line
  1372.          * @param maxLine max line
  1373.          * @param maxEval maximum number of evaluations
  1374.          * @param accuracy accuracy to use for finding crossing line number
  1375.          * @param normal mean plane normal
  1376.          * @param cachedResults cached results
  1377.          */
  1378.         ParsedMeanPlane(final int minLine, final int maxLine,
  1379.                         final int maxEval, final double accuracy, final Vector3D normal,
  1380.                         final CrossingResult[] cachedResults) {
  1381.             this.minLine       = minLine;
  1382.             this.maxLine       = maxLine;
  1383.             this.maxEval       = maxEval;
  1384.             this.accuracy      = accuracy;
  1385.             this.normal        = normal;
  1386.             this.cachedResults = cachedResults.clone();
  1387.         }

  1389.     }

  1391.     /** Local interface for dumped calls. */
  1392.     private abstract static class DumpedCall {

  1394.         /** Expected result. */
  1395.         private Object expected;

  1397.         /** Execute a call.
  1398.          * @param rugged Rugged instance on which called should be performed
  1399.          * @return result of the call
  1400.          * @exception RuggedException if the call fails
  1401.          */
  1402.         public abstract Object execute(Rugged rugged) throws RuggedException;

  1404.     }

  1406. }
Created with JaCoCo 0.7.9.201702052155