InterpolatingTransformProvider.java

  1. /* Copyright 2002-2013 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.  */

  18. package org.orekit.frames;

  20. import java.io.Serializable;
  21. import java.util.ArrayList;
  22. import java.util.List;

  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.errors.OrekitExceptionWrapper;
  26. import org.orekit.time.AbsoluteDate;
  27. import org.orekit.utils.GenericTimeStampedCache;
  28. import org.orekit.utils.TimeStampedGenerator;

  30. /** Transform provider using thread-safe interpolation on transforms sample.
  31.  * <p>
  32.  * The interpolation is a polynomial Hermite interpolation, which
  33.  * can either use or ignore the derivatives provided by the raw
  34.  * provider. This means that simple raw providers that do not compute
  35.  * derivatives can be used, the derivatives will be added appropriately
  36.  * by the interpolation process.
  37.  * </p>
  38.  * @see GenericTimeStampedCache
  39.  * @author Luc Maisonobe
  40.  */
  41. public class InterpolatingTransformProvider implements TransformProvider {

  43.     /** Serializable UID. */
  44.     private static final long serialVersionUID = -1750070230136582364L;

  46.     /** Provider for raw (non-interpolated) transforms. */
  47.     private final TransformProvider rawProvider;

  49.     /** Flag for use of sample transforms velocities. */
  50.     private final boolean useVelocities;

  52.     /** Flag for use sample points rotation rates. */
  53.     private final boolean useRotationRates;

  55.     /** Earliest supported date. */
  56.     private final AbsoluteDate earliest;

  58.     /** Latest supported date. */
  59.     private final AbsoluteDate latest;

  61.     /** Grid points time step. */
  62.     private final double step;

  64.     /** Cache for sample points. */
  65.     private final transient GenericTimeStampedCache<Transform> cache;

  67.     /** Simple constructor.
  68.      * @param rawProvider provider for raw (non-interpolated) transforms
  69.      * @param useVelocities if true, use sample transforms velocities,
  70.      * otherwise ignore them and use only positions
  71.      * @param useRotationRates if true, use sample points rotation rates,
  72.      * otherwise ignore them and use only rotations
  73.      * @param earliest earliest supported date
  74.      * @param latest latest supported date
  75.      * @param gridPoints number of interpolation grid points
  76.      * @param step grid points time step
  77.      * @param maxSlots maximum number of independent cached time slots
  78.      * in the {@link GenericTimeStampedCache time-stamped cache}
  79.      * @param maxSpan maximum duration span in seconds of one slot
  80.      * in the {@link GenericTimeStampedCache time-stamped cache}
  81.      * @param newSlotInterval time interval above which a new slot is created
  82.      * in the {@link GenericTimeStampedCache time-stamped cache}
  83.      */
  84.     public InterpolatingTransformProvider(final TransformProvider rawProvider,
  85.                                           final boolean useVelocities, final boolean useRotationRates,
  86.                                           final AbsoluteDate earliest, final AbsoluteDate latest,
  87.                                           final int gridPoints, final double step,
  88.                                           final int maxSlots, final double maxSpan, final double newSlotInterval) {
  89.         this.rawProvider      = rawProvider;
  90.         this.useVelocities    = useVelocities;
  91.         this.useRotationRates = useRotationRates;
  92.         this.earliest         = earliest;
  93.         this.latest           = latest;
  94.         this.step             = step;
  95.         this.cache            = new GenericTimeStampedCache<Transform>(gridPoints, maxSlots, maxSpan, newSlotInterval,
  96.                                                                 new Generator(), Transform.class);
  97.     }

  99.     /** Get the underlying provider for raw (non-interpolated) transforms.
  100.      * @return provider for raw (non-interpolated) transforms
  101.      */
  102.     public TransformProvider getRawProvider() {
  103.         return rawProvider;
  104.     }

  106.     /** Get the number of interpolation grid points.
  107.      * @return number of interpolation grid points
  108.      */
  109.     public int getGridPoints() {
  110.         return cache.getNeighborsSize();
  111.     }

  113.     /** Get the grid points time step.
  114.      * @return grid points time step
  115.      */
  116.     public double getStep() {
  117.         return step;
  118.     }

  120.     /** {@inheritDoc} */
  121.     public Transform getTransform(final AbsoluteDate date) throws OrekitException {
  122.         try {

  124.             // retrieve a sample from the thread-safe cache
  125.             final List<Transform> sample = cache.getNeighbors(date);

  127.             // interpolate to specified date
  128.             return Transform.interpolate(date, useVelocities, useRotationRates, sample);

  130.         } catch (OrekitExceptionWrapper oew) {
  131.             // something went wrong while generating the sample,
  132.             // we just forward the exception up
  133.             throw oew.getException();
  134.         }
  135.     }

  137.     /** Replace the instance with a data transfer object for serialization.
  138.      * <p>
  139.      * This intermediate class serializes only the data needed for generation,
  140.      * but does <em>not</em> serializes the cache itself (in fact the cache is
  141.      * not serializable).
  142.      * </p>
  143.      * @return data transfer object that will be serialized
  144.      */
  145.     private Object writeReplace() {
  146.         return new DataTransferObject(rawProvider, useVelocities, useRotationRates,
  147.                                       earliest, latest, cache.getNeighborsSize(), step,
  148.                                       cache.getMaxSlots(), cache.getMaxSpan(), cache.getNewSlotQuantumGap());
  149.     }

  151.     /** Internal class used only for serialization. */
  152.     private static class DataTransferObject implements Serializable {

  154.         /** Serializable UID. */
  155.         private static final long serialVersionUID = 8127819004703645170L;

  157.         /** Provider for raw (non-interpolated) transforms. */
  158.         private final TransformProvider rawProvider;

  160.         /** Flag for use of sample transforms velocities. */
  161.         private final boolean useVelocities;

  163.         /** Flag for use sample points rotation rates. */
  164.         private final boolean useRotationRates;

  166.         /** Earliest supported date. */
  167.         private final AbsoluteDate earliest;

  169.         /** Latest supported date. */
  170.         private final AbsoluteDate latest;

  172.         /** Number of grid points. */
  173.         private final int gridPoints;

  175.         /** Grid points time step. */
  176.         private final double step;

  178.         /** Maximum number of independent cached time slots. */
  179.         private final int maxSlots;

  181.         /** Maximum duration span in seconds of one slot. */
  182.         private final double maxSpan;

  184.         /** Time interval above which a new slot is created. */
  185.         private final double newSlotInterval;

  187.         /** Simple constructor.
  188.          * @param rawProvider provider for raw (non-interpolated) transforms
  189.          * @param useVelocities if true, use sample transforms velocities,
  190.          * otherwise ignore them and use only positions
  191.          * @param useRotationRates if true, use sample points rotation rates,
  192.          * otherwise ignore them and use only rotations
  193.          * @param earliest earliest supported date
  194.          * @param latest latest supported date
  195.          * @param gridPoints number of interpolation grid points
  196.          * @param step grid points time step
  197.          * @param maxSlots maximum number of independent cached time slots
  198.          * in the {@link GenericTimeStampedCache time-stamped cache}
  199.          * @param maxSpan maximum duration span in seconds of one slot
  200.          * in the {@link GenericTimeStampedCache time-stamped cache}
  201.          * @param newSlotInterval time interval above which a new slot is created
  202.          * in the {@link GenericTimeStampedCache time-stamped cache}
  203.          */
  204.         private DataTransferObject(final TransformProvider rawProvider,
  205.                                    final boolean useVelocities, final boolean useRotationRates,
  206.                                    final AbsoluteDate earliest, final AbsoluteDate latest,
  207.                                    final int gridPoints, final double step,
  208.                                    final int maxSlots, final double maxSpan, final double newSlotInterval) {
  209.             this.rawProvider      = rawProvider;
  210.             this.useVelocities    = useVelocities;
  211.             this.useRotationRates = useRotationRates;
  212.             this.earliest         = earliest;
  213.             this.latest           = latest;
  214.             this.gridPoints       = gridPoints;
  215.             this.step             = step;
  216.             this.maxSlots         = maxSlots;
  217.             this.maxSpan          = maxSpan;
  218.             this.newSlotInterval  = newSlotInterval;
  219.         }

  221.         /** Replace the deserialized data transfer object with a {@link InterpolatingTransformProvider}.
  222.          * @return replacement {@link InterpolatingTransformProvider}
  223.          */
  224.         private Object readResolve() {
  225.             // build a new provider, with an empty cache
  226.             return new InterpolatingTransformProvider(rawProvider, useVelocities, useRotationRates,
  227.                                                       earliest, latest, gridPoints, step,
  228.                                                       maxSlots, maxSpan, newSlotInterval);
  229.         }

  231.     }

  233.     /** Local generator for thread-safe cache. */
  234.     private class Generator implements TimeStampedGenerator<Transform> {

  236.         /** {@inheritDoc} */
  237.         public List<Transform> generate(final Transform existing, final AbsoluteDate date) {

  239.             try {
  240.                 final List<Transform> generated = new ArrayList<Transform>();

  242.                 if (existing == null) {

  244.                     // no prior existing transforms, just generate a first set
  245.                     for (int i = 0; i < cache.getNeighborsSize(); ++i) {
  246.                         generated.add(rawProvider.getTransform(date.shiftedBy(i * step)));
  247.                     }

  249.                 } else {

  251.                     // some transforms have already been generated
  252.                     // add the missing ones up to specified date

  254.                     AbsoluteDate t = existing.getDate();
  255.                     if (date.compareTo(t) > 0) {
  256.                         // forward generation
  257.                         do {
  258.                             t = t.shiftedBy(step);
  259.                             generated.add(generated.size(), rawProvider.getTransform(t));
  260.                         } while (t.compareTo(date) <= 0);
  261.                     } else {
  262.                         // backward generation
  263.                         do {
  264.                             t = t.shiftedBy(-step);
  265.                             generated.add(0, rawProvider.getTransform(t));
  266.                         } while (t.compareTo(date) >= 0);
  267.                     }
  268.                 }

  270.                 // return the generated transforms
  271.                 return generated;
  272.             } catch (OrekitException oe) {
  273.                 throw new OrekitExceptionWrapper(oe);
  274.             }

  276.         }

  278.     }

  280. }
Created with JaCoCo 0.6.3.201306030806