ellipse.hpp

#pragma once
 
#include "global.hpp"
 
#include "point_2d.hpp"
#include "angle.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  class Ellipse final
  {
  public:

    Ellipse(Point2D<double> center, double radiusA, double radiusB, Angle rotation)
        : center_(center)
        , radiusA_(std::max(std::abs(radiusA), std::abs(radiusB)))
        , radiusB_(std::min(std::abs(radiusA), std::abs(radiusB)))
        , rotation_(rotation)
    {
      rotation_.SetIsTrimmed(true);
 
      if (radiusA < 0.0)
        throw std::invalid_argument("invalid radius value");
      if (radiusB < 0.0)
        throw std::invalid_argument("invalid radius value");
    }
    Ellipse(Point2D<double> center, double radiusA, double radiusB, Angle rotation) {…}


    Point2D<double> Center() const noexcept
    {
      return center_;
    }
    Point2D<double> Center() const noexcept {…}


    void SetCenter(Point2D<double> center) noexcept
    {
      center_ = center;
    }
    void SetCenter(Point2D<double> center) noexcept {…}


    double RadiusA() const noexcept
    {
      return radiusA_;
    }
    double RadiusA() const noexcept {…}


    void SetRadiusA(double radiusA)
    {
      if (radiusA <= radiusB_)
        throw std::invalid_argument("invalid radius value");
      radiusA_ = std::abs(radiusA);
    }
    void SetRadiusA(double radiusA) {…}


    double RadiusB() const noexcept
    {
      return radiusB_;
    }
    double RadiusB() const noexcept {…}


    void SetRadiusB(double radiusB)
    {
      if (radiusB < 0.0 || radiusB > radiusA_)
        throw std::invalid_argument("invalid radius value");
      radiusB_ = std::abs(radiusB);
    }
    void SetRadiusB(double radiusB) {…}


    Angle Rotation() const noexcept
    {
      return rotation_;
    }
    Angle Rotation() const noexcept {…}


    void SetRotation(Angle rotation) noexcept
    {
      rotation_ = rotation;
      rotation_.SetIsTrimmed(true);
    }
    void SetRotation(Angle rotation) noexcept {…}


    bool operator==(const Ellipse &ellipse) const noexcept
    {
      return (center_ == ellipse.center_ && radiusA_ == ellipse.radiusA_ && radiusB_ == ellipse.radiusB_
              && rotation_ == ellipse.rotation_);
    }
    bool operator==(const Ellipse &ellipse) const noexcept {…}


    bool operator!=(const Ellipse &ellipse) const noexcept
    {
      return !(*this == ellipse);
    }
    bool operator!=(const Ellipse &ellipse) const noexcept {…}
 
  private:
    Point2D<double> center_;
    double radiusA_;
    double radiusB_;
    Angle rotation_;
  };
  class Ellipse final {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb