ConstantElevationAlgorithm.java

  1. /* Copyright 2013-2019 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.intersection;

  18. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  19. import org.orekit.bodies.GeodeticPoint;
  20. import org.orekit.rugged.api.AlgorithmId;
  21. import org.orekit.rugged.errors.DumpManager;
  22. import org.orekit.rugged.utils.ExtendedEllipsoid;
  23. import org.orekit.rugged.utils.NormalizedGeodeticPoint;

  24. /** Intersection ignoring Digital Elevation Model.
  25.  * <p>
  26.  * This dummy implementation simply uses the ellipsoid itself.
  27.  * </p>
  28.  * @author Luc Maisonobe
  29.  */
  30. public class ConstantElevationAlgorithm implements IntersectionAlgorithm {

  31.     /** Constant elevation over ellipsoid. */
  32.     private final double constantElevation;

  33.     /** Simple constructor.
  34.      * @param constantElevation constant elevation over ellipsoid
  35.      */
  36.     public ConstantElevationAlgorithm(final double constantElevation) {
  37.         this.constantElevation = constantElevation;
  38.     }

  39.     /** {@inheritDoc} */
  40.     @Override
  41.     public NormalizedGeodeticPoint intersection(final ExtendedEllipsoid ellipsoid,
  42.                                                 final Vector3D position, final Vector3D los) {
  43.         DumpManager.dumpAlgorithm(AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID, constantElevation);
  44.         final Vector3D      p  = ellipsoid.pointAtAltitude(position, los, constantElevation);
  45.         final GeodeticPoint gp = ellipsoid.transform(p, ellipsoid.getFrame(), null);
  46.         return new NormalizedGeodeticPoint(gp.getLatitude(), gp.getLongitude(), gp.getAltitude(), 0.0);
  47.     }

  48.     /** {@inheritDoc} */
  49.     @Override
  50.     public NormalizedGeodeticPoint refineIntersection(final ExtendedEllipsoid ellipsoid,
  51.                                                       final Vector3D position, final Vector3D los,
  52.                                                       final NormalizedGeodeticPoint closeGuess) {
  53.         DumpManager.dumpAlgorithm(AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID, constantElevation);
  54.         final Vector3D      p  = ellipsoid.pointAtAltitude(position, los, constantElevation);
  55.         final GeodeticPoint gp = ellipsoid.transform(p, ellipsoid.getFrame(), null);
  56.         return new NormalizedGeodeticPoint(gp.getLatitude(), gp.getLongitude(), gp.getAltitude(),
  57.                 closeGuess.getLongitude());
  58.     }

  59.     /** {@inheritDoc}
  60.      * <p>
  61.      * As this algorithm uses a constant elevation,
  62.      * this method always returns the same value.
  63.      * </p>
  64.      */
  65.     @Override
  66.     public double getElevation(final double latitude, final double longitude) {
  67.         DumpManager.dumpAlgorithm(AlgorithmId.CONSTANT_ELEVATION_OVER_ELLIPSOID, constantElevation);
  68.         return constantElevation;
  69.     }

  70. }