Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  Spheroid classes
       4             :  * Purpose:  Provide spheroid lookup table base classes.
       5             :  * Author:   Gillian Walter
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 1999, Frank Warmerdam
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #include "atlsci_spheroid.h"
      14             : #include "cpl_string.h"
      15             : 
      16             : /**********************************************************************/
      17             : /* ================================================================== */
      18             : /*          Spheroid definitions                                      */
      19             : /* ================================================================== */
      20             : /**********************************************************************/
      21             : 
      22       15104 : SpheroidItem::SpheroidItem()
      23             :     : spheroid_name(nullptr), equitorial_radius(-1.0), polar_radius(-1.0),
      24       15104 :       inverse_flattening(-1.0)
      25             : {
      26       15104 : }
      27             : 
      28       30208 : SpheroidItem::~SpheroidItem()
      29             : {
      30       15104 :     CPLFree(spheroid_name);
      31       15104 : }
      32             : 
      33         270 : void SpheroidItem::SetValuesByRadii(const char *spheroidname, double eq_radius,
      34             :                                     double p_radius)
      35             : {
      36         270 :     spheroid_name = CPLStrdup(spheroidname);
      37         270 :     equitorial_radius = eq_radius;
      38         270 :     polar_radius = p_radius;
      39         270 :     inverse_flattening =
      40         270 :         eq_radius == polar_radius ? 0 : eq_radius / (eq_radius - polar_radius);
      41         270 : }
      42             : 
      43        2552 : void SpheroidItem::SetValuesByEqRadiusAndInvFlattening(const char *spheroidname,
      44             :                                                        double eq_radius,
      45             :                                                        double inverseflattening)
      46             : {
      47        2552 :     spheroid_name = CPLStrdup(spheroidname);
      48        2552 :     equitorial_radius = eq_radius;
      49        2552 :     inverse_flattening = inverseflattening;
      50        5104 :     polar_radius = inverse_flattening == 0
      51        2552 :                        ? eq_radius
      52        2552 :                        : eq_radius * (1.0 - (1.0 / inverse_flattening));
      53        2552 : }
      54             : 
      55       15163 : SpheroidList::SpheroidList() : num_spheroids(0), epsilonR(0.0), epsilonI(0.0)
      56             : {
      57          59 : }
      58             : 
      59       15163 : SpheroidList::~SpheroidList()
      60             : {
      61          59 : }
      62             : 
      63           0 : char *SpheroidList::GetSpheroidNameByRadii(double eq_radius,
      64             :                                            double polar_radius)
      65             : {
      66           0 :     for (int index = 0; index < num_spheroids; index++)
      67             :     {
      68           0 :         const double er = spheroids[index].equitorial_radius;
      69           0 :         const double pr = spheroids[index].polar_radius;
      70           0 :         if ((fabs(er - eq_radius) < epsilonR) &&
      71           0 :             (fabs(pr - polar_radius) < epsilonR))
      72           0 :             return CPLStrdup(spheroids[index].spheroid_name);
      73             :     }
      74             : 
      75           0 :     return nullptr;
      76             : }
      77             : 
      78          35 : char *SpheroidList::GetSpheroidNameByEqRadiusAndInvFlattening(
      79             :     double eq_radius, double inverse_flattening)
      80             : {
      81         878 :     for (int index = 0; index < num_spheroids; index++)
      82             :     {
      83         869 :         const double er = spheroids[index].equitorial_radius;
      84         869 :         const double invf = spheroids[index].inverse_flattening;
      85         869 :         if ((fabs(er - eq_radius) < epsilonR) &&
      86          60 :             (fabs(invf - inverse_flattening) < epsilonI))
      87          26 :             return CPLStrdup(spheroids[index].spheroid_name);
      88             :     }
      89             : 
      90           9 :     return nullptr;
      91             : }
      92             : 
      93          10 : double SpheroidList::GetSpheroidEqRadius(const char *spheroid_name)
      94             : {
      95          66 :     for (int index = 0; index < num_spheroids; index++)
      96             :     {
      97          66 :         if (EQUAL(spheroids[index].spheroid_name, spheroid_name))
      98          10 :             return spheroids[index].equitorial_radius;
      99             :     }
     100             : 
     101           0 :     return -1.0;
     102             : }
     103             : 
     104          23 : int SpheroidList::SpheroidInList(const char *spheroid_name)
     105             : {
     106             :     /* Return 1 if the spheroid name is recognized; 0 otherwise */
     107         474 :     for (int index = 0; index < num_spheroids; index++)
     108             :     {
     109         474 :         if (EQUAL(spheroids[index].spheroid_name, spheroid_name))
     110          23 :             return 1;
     111             :     }
     112             : 
     113           0 :     return 0;
     114             : }
     115             : 
     116          10 : double SpheroidList::GetSpheroidInverseFlattening(const char *spheroid_name)
     117             : {
     118          66 :     for (int index = 0; index < num_spheroids; index++)
     119             :     {
     120          66 :         if (EQUAL(spheroids[index].spheroid_name, spheroid_name))
     121          10 :             return spheroids[index].inverse_flattening;
     122             :     }
     123             : 
     124           0 :     return -1.0;
     125             : }
     126             : 
     127           0 : double SpheroidList::GetSpheroidPolarRadius(const char *spheroid_name)
     128             : {
     129           0 :     for (int index = 0; index < num_spheroids; index++)
     130             :     {
     131           0 :         if (strcmp(spheroids[index].spheroid_name, spheroid_name) == 0)
     132           0 :             return spheroids[index].polar_radius;
     133             :     }
     134             : 
     135           0 :     return -1.0;
     136             : }