Ellipsoid.h

#pragma once
 
#include <CesiumGeospatial/Cartographic.h>
#include <CesiumGeospatial/Library.h>
#include <CesiumUtility/Math.h>
 
#include <glm/vec3.hpp>
 
#include <optional>
 
// The comments are copied here so that the doc comment always shows up in
// Intellisense whether the default is toggled or not.
#ifndef CESIUM_DISABLE_DEFAULT_ELLIPSOID
// To keep from breaking our API, a lot of things now need default Ellipsoid
// parameters. However, we shouldn't rely on these defaults internally, so
// disabling them is a good way to get a compile-time check that they're not
// being used. This macro allows us to toggle this check.
#define CESIUM_DEFAULT_ELLIPSOID = CesiumGeospatial::Ellipsoid::WGS84
#else
// To keep from breaking our API, a lot of things now need default Ellipsoid
// parameters. However, we shouldn't rely on these defaults internally, so
// disabling them is a good way to get a compile-time check that they're not
// being used. This macro allows us to toggle this check.
#define CESIUM_DEFAULT_ELLIPSOID
#endif
 
namespace CesiumGeospatial {
 
class CESIUMGEOSPATIAL_API Ellipsoid final {
public:
  static /*constexpr*/ const Ellipsoid WGS84;
 
  static const Ellipsoid UNIT_SPHERE;
 
  constexpr Ellipsoid(double x, double y, double z) noexcept
      : Ellipsoid(glm::dvec3(x, y, z)) {}
 
  constexpr Ellipsoid(const glm::dvec3& radii) noexcept
      : _radii(radii),
        _radiiSquared(radii.x * radii.x, radii.y * radii.y, radii.z * radii.z),
        _oneOverRadii(1.0 / radii.x, 1.0 / radii.y, 1.0 / radii.z),
        _oneOverRadiiSquared(
            1.0 / (radii.x * radii.x),
            1.0 / (radii.y * radii.y),
            1.0 / (radii.z * radii.z)),
        _centerToleranceSquared(CesiumUtility::Math::Epsilon1) {}
 
  constexpr const glm::dvec3& getRadii() const noexcept { return this->_radii; }
 
  glm::dvec3 geodeticSurfaceNormal(const glm::dvec3& position) const noexcept;
 
  glm::dvec3
  geodeticSurfaceNormal(const Cartographic& cartographic) const noexcept;
 
  glm::dvec3
  cartographicToCartesian(const Cartographic& cartographic) const noexcept;
 
  std::optional<Cartographic>
  cartesianToCartographic(const glm::dvec3& cartesian) const noexcept;
 
  std::optional<glm::dvec3>
  scaleToGeodeticSurface(const glm::dvec3& cartesian) const noexcept;
 
  std::optional<glm::dvec3>
  scaleToGeocentricSurface(const glm::dvec3& cartesian) const noexcept;
 
  constexpr double getMaximumRadius() const noexcept {
    return glm::max(this->_radii.x, glm::max(this->_radii.y, this->_radii.z));
  }
 
  constexpr double getMinimumRadius() const noexcept {
    return glm::min(this->_radii.x, glm::min(this->_radii.y, this->_radii.z));
  }
 
  constexpr bool operator==(const Ellipsoid& rhs) const noexcept {
    return this->_radii == rhs._radii;
  };
 
  constexpr bool operator!=(const Ellipsoid& rhs) const noexcept {
    return !(*this == rhs);
  };
 
private:
  glm::dvec3 _radii;
  glm::dvec3 _radiiSquared;
  glm::dvec3 _oneOverRadii;
  glm::dvec3 _oneOverRadiiSquared;
  double _centerToleranceSquared;
};
} // namespace CesiumGeospatial