area_2d.hpp

#pragma once
 
#include "global.hpp"
 
#include "affine_matrix_2d.hpp"
#include "matrix_2d.hpp"
#include "point_2d.hpp"
#include "rect.hpp"
#include "size_2d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS

  class Area2D final
  {
  public:

    Area2D() noexcept = default;


    Area2D(Point2D<double> p0, Point2D<double> p1, Point2D<double> p2) noexcept
        : p0_(p0)
        , p1_(p1)
        , p2_(p2)
    {
    }
    Area2D(Point2D<double> p0, Point2D<double> p1, Point2D<double> p2) noexcept {…}


    Area2D(Rect<double> rect, AffineMatrix2D affineMatrix) noexcept
    {
      Area2D area(rect);
      CExports::CoordinateMapTransformArea(*reinterpret_cast<CExports::TArea *>(&area),
                                           *reinterpret_cast<CExports::TCoordinateMap *>(&affineMatrix),
                                           reinterpret_cast<CExports::TArea &>(*this));
    }
    Area2D(Rect<double> rect, AffineMatrix2D affineMatrix) noexcept {…}


    Area2D(double x0, double y0, double x1, double y1, double x2, double y2) noexcept
        : Area2D(Point2D<double>(x0, y0), Point2D<double>(x1, y1), Point2D<double>(x2, y2))
    {
    }
    Area2D(double x0, double y0, double x1, double y1, double x2, double y2) noexcept {…}


    explicit Area2D(Rect<double> rect) noexcept
        : Area2D(rect.Left(), rect.Top(), rect.Right(), rect.Top(), rect.Left(), rect.Bottom())
    {
    }
    explicit Area2D(Rect<double> rect) noexcept {…}


    explicit Area2D(double radius) noexcept
        : Area2D(-radius, -radius, -radius, radius, radius, -radius)
    {
    }
    explicit Area2D(double radius) noexcept {…}


    Point2D<double> P0() const noexcept
    {
      return p0_;
    }
    Point2D<double> P0() const noexcept {…}


    void SetP0(Point2D<double> p0) noexcept
    {
      p0_ = p0;
    }
    void SetP0(Point2D<double> p0) noexcept {…}


    Point2D<double> P1() const noexcept
    {
      return p1_;
    }
    Point2D<double> P1() const noexcept {…}


    void SetP1(Point2D<double> p1) noexcept
    {
      p1_ = p1;
    }
    void SetP1(Point2D<double> p1) noexcept {…}


    Point2D<double> P2() const noexcept
    {
      return p2_;
    }
    Point2D<double> P2() const noexcept {…}


    void SetP2(Point2D<double> p2) noexcept
    {
      p2_ = p2;
    }
    void SetP2(Point2D<double> p2) noexcept {…}


    Point2D<double> P3() const noexcept
    {
      return p1_ + p2_ - p0_;
    }
    Point2D<double> P3() const noexcept {…}


    Rect<double> BoundingRectangle() const noexcept
    {
      Rect<double> bb(p0_, Size2D<double>());
      ExpandBBByPoint(bb, p1_);
      ExpandBBByPoint(bb, p2_);
      ExpandBBByPoint(bb, P3());
 
      return bb;
    }
    Rect<double> BoundingRectangle() const noexcept {…}


    Size2D<double> Size() const noexcept
    {
      auto vP0P2 = p2_ - p0_;
      auto vP0P1 = p1_ - p0_;
      return Size2D<double>(vP0P2.Length(), vP0P1.Length());
    }
    Size2D<double> Size() const noexcept {…}


    double Area() const noexcept
    {
      auto vP0P2 = p2_ - p0_;
      auto vP0P1 = p1_ - p0_;
      return std::abs(vP0P2.X() * vP0P1.Y() - vP0P2.Y() * vP0P1.X());
    }
    double Area() const noexcept {…}


    void Transform(Matrix2D matrix) noexcept
    {
      p0_ = matrix * p0_;
      p1_ = matrix * p1_;
      p2_ = matrix * p2_;
    }
    void Transform(Matrix2D matrix) noexcept {…}


    void Transform(AffineMatrix2D affineMatrix) noexcept
    {
      p0_ = affineMatrix * p0_;
      p1_ = affineMatrix * p1_;
      p2_ = affineMatrix * p2_;
    }
    void Transform(AffineMatrix2D affineMatrix) noexcept {…}


    void SwapOrientation() noexcept
    {
      auto tmp = p1_;
      p1_      = p2_;
      p2_      = tmp;
    }
    void SwapOrientation() noexcept {…}


    CoordinateSystemType CoordinateSystem() const noexcept
    {
      return CoordinateSystemType::ImageCoordinates;
    }
    CoordinateSystemType CoordinateSystem() const noexcept {…}


    bool operator==(const Area2D &area) const noexcept
    {
      return p0_ == area.p0_ && p1_ == area.p1_ && p2_ == area.p2_;
    }
    bool operator==(const Area2D &area) const noexcept {…}


    bool operator!=(const Area2D &area) const noexcept
    {
      return !(*this == area);
    }
    bool operator!=(const Area2D &area) const noexcept {…}
 
  private:
    static void ExpandBBByPoint(Rect<double> &bb, Point2D<double> p)
    {
      if (p.X() < bb.Left())
        bb.SetLeft(p.X());
      else if (p.X() > bb.Right())
        bb.SetRight(p.X());
      if (p.Y() < bb.Top())
        bb.SetTop(p.Y());
      else if (p.Y() > bb.Bottom())
        bb.SetBottom(p.Y());
    }
 
    Point2D<double> p0_;
    Point2D<double> p1_;
    Point2D<double> p2_;
  };
  class Area2D final {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb