GlobeRectangle.h

#pragma once
 
#include "Cartographic.h"
#include "Library.h"
 
#include <CesiumGeometry/Rectangle.h>
#include <CesiumUtility/Math.h>
 
#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 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;
 
  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