1   /* Copyright 2013 Applied Defense Solutions, Inc.
2    * Licensed to CS Communication & Systèmes (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.utils;
18  
19  import java.io.Serial;
20  import java.io.Serializable;
21  import java.util.Arrays;
22  
23  import org.hipparchus.util.FastMath;
24  import org.hipparchus.util.MathUtils;
25  import org.orekit.errors.OrekitIllegalArgumentException;
26  import org.orekit.errors.OrekitMessages;
27  
28  /**
29   * Class for modeling the ground elevation values around a given point.
30   * <p>
31   * Instances of this class can be considered to be immutable
32   * @author Hank Grabowski
33   * @since 6.1
34   */
35  public class ElevationMask implements Serializable {
36  
37      /** Serializable UID. */
38      @Serial
39      private static final long serialVersionUID = 20131118L;
40  
41      /** Azimuth-elevation mask. */
42      private final double[][] azelmask;
43  
44      /**
45       * Creates an instance of an Elevation mask based on the passed in parameter.
46       * @param mask azimuth-elevation mask (rad). First column (i.e. mask[i][0])
47       *             should contain azimuth values and the second column (i.e. mask[i][1])
48       *             should contain corresponding elevations
49       */
50      public ElevationMask(final double[][] mask) {
51          this.azelmask = checkMask(mask);
52      }
53  
54      /** Get the interpolated elevation for a given azimuth according to the mask.
55       * @param azimuth azimuth (rad)
56       * @return elevation angle (rad)
57       */
58      public double getElevation(final double azimuth) {
59          double elevation = 0.0;
60          boolean fin = false;
61          for (int i = 1; i < azelmask.length & !fin; i++) {
62              if (azimuth <= azelmask[i][0]) {
63                  fin = true;
64                  final double azd = azelmask[i - 1][0];
65                  final double azf = azelmask[i][0];
66                  final double eld = azelmask[i - 1][1];
67                  final double elf = azelmask[i][1];
68                  elevation = eld + (azimuth - azd) * (elf - eld) / (azf - azd);
69              }
70          }
71          return elevation;
72      }
73  
74      /** Checking and ordering the azimuth-elevation tabulation.
75       * @param azimelev azimuth-elevation tabulation to be checked and ordered
76       * @return ordered azimuth-elevation tabulation ordered
77       */
78      private static double[][] checkMask(final double[][] azimelev) {
79  
80          // Copy of the given mask
81          final double[][] mask = new double[azimelev.length + 2][azimelev[0].length];
82          for (int i = 0; i < azimelev.length; i++) {
83              System.arraycopy(azimelev[i], 0, mask[i + 1], 0, azimelev[i].length);
84              // Reducing azimuth between 0 and 2*Pi
85              mask[i + 1][0] = MathUtils.normalizeAngle(mask[i + 1][0], FastMath.PI);
86          }
87  
88          // Sorting the mask with respect to azimuth
89          Arrays.sort(mask, 1, mask.length - 1, (d1, d2) -> Double.compare(d1[0], d2[0]));
90  
91          // Extending the mask in order to cover [0, 2PI] in azimuth
92          mask[0][0] = mask[mask.length - 2][0] - MathUtils.TWO_PI;
93          mask[0][1] = mask[mask.length - 2][1];
94          mask[mask.length - 1][0] = mask[1][0] + MathUtils.TWO_PI;
95          mask[mask.length - 1][1] = mask[1][1];
96  
97          // Checking the sorted mask: same azimuth modulo 2PI must have same elevation
98          for (int i = 1; i < mask.length; i++) {
99              if (Double.compare(mask[i - 1][0], mask[i][0]) == 0) {
100                 if (Double.compare(mask[i - 1][1], mask[i][1]) != 0) {
101                     throw new OrekitIllegalArgumentException(OrekitMessages.UNEXPECTED_TWO_ELEVATION_VALUES_FOR_ONE_AZIMUTH,
102                                                              mask[i - 1][1], mask[i][1], mask[i][0]);
103                 }
104             }
105         }
106 
107         return mask;
108     }
109 
110 
111 }