GlobeRectangle.h

#pragma once
 
#include <CesiumGeometry/Rectangle.h>
#include <CesiumGeospatial/Cartographic.h>
#include <CesiumGeospatial/Library.h>
#include <CesiumUtility/Math.h>
 
#include <glm/ext/vector_double2.hpp>
 
#include <optional>
 
namespace CesiumGeospatial {

class CESIUMGEOSPATIAL_API GlobeRectangle final {
public:
  static const GlobeRectangle EMPTY;

  static const GlobeRectangle MAXIMUM;

  constexpr GlobeRectangle(
      double west,
      double south,
      double east,
      double north) noexcept
      : _west(west), _south(south), _east(east), _north(north) {}

  static constexpr GlobeRectangle
  fromRectangleRadians(const CesiumGeometry::Rectangle& rectangle) noexcept {
    return GlobeRectangle(
        rectangle.minimumX,
        rectangle.minimumY,
        rectangle.maximumX,
        rectangle.maximumY);
  }

  static constexpr GlobeRectangle fromDegrees(
      double westDegrees,
      double southDegrees,
      double eastDegrees,
      double northDegrees) noexcept {
    return GlobeRectangle(
        CesiumUtility::Math::degreesToRadians(westDegrees),
        CesiumUtility::Math::degreesToRadians(southDegrees),
        CesiumUtility::Math::degreesToRadians(eastDegrees),
        CesiumUtility::Math::degreesToRadians(northDegrees));
  }

  constexpr double getWest() const noexcept { return this->_west; }

  void setWest(double value) noexcept { this->_west = value; }

  constexpr double getSouth() const noexcept { return this->_south; }

  void setSouth(double value) noexcept { this->_south = value; }

  constexpr double getEast() const noexcept { return this->_east; }

  void setEast(double value) noexcept { this->_east = value; }

  constexpr double getNorth() const noexcept { return this->_north; }

  void setNorth(double value) noexcept { this->_north = value; }

  constexpr Cartographic getSouthwest() const noexcept {
    return Cartographic(this->_west, this->_south);
  }

  constexpr Cartographic getSoutheast() const noexcept {
    return Cartographic(this->_east, this->_south);
  }

  constexpr Cartographic getNorthwest() const noexcept {
    return Cartographic(this->_west, this->_north);
  }

  constexpr Cartographic getNortheast() const noexcept {
    return Cartographic(this->_east, this->_north);
  }

  constexpr CesiumGeometry::Rectangle toSimpleRectangle() const noexcept {
    return CesiumGeometry::Rectangle(
        this->getWest(),
        this->getSouth(),
        this->getEast(),
        this->getNorth());
  }

  constexpr double computeWidth() const noexcept {
    double east = this->_east;
    const double west = this->_west;
    if (east < west) {
      east += CesiumUtility::Math::TwoPi;
    }
    return east - west;
  }

  constexpr double computeHeight() const noexcept {
    return this->_north - this->_south;
  }

  Cartographic computeCenter() const noexcept;

  bool contains(const Cartographic& cartographic) const noexcept;

  bool isEmpty() const noexcept;

  std::optional<GlobeRectangle>
  computeIntersection(const GlobeRectangle& other) const noexcept;

  GlobeRectangle computeUnion(const GlobeRectangle& other) const noexcept;

  glm::dvec2
  computeNormalizedCoordinates(const Cartographic& cartographic) const noexcept;

  std::pair<GlobeRectangle, std::optional<GlobeRectangle>>
  splitAtAntiMeridian() const noexcept;

  static bool
  equals(const GlobeRectangle& left, const GlobeRectangle& right) noexcept;

  static bool equalsEpsilon(
      const GlobeRectangle& left,
      const GlobeRectangle& right,
      double relativeEpsilon) noexcept;
 
private:
  double _west;
  double _south;
  double _east;
  double _north;
};
 
} // namespace CesiumGeospatial