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(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(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(Rect<double> rect) noexcept
      : Area2D(rect.Left(), rect.Top(), rect.Right(), rect.Top(), rect.Left(), rect.Bottom())
  {
  }
 
 
  Area2D(double radius) noexcept : Area2D(-radius, -radius, -radius, radius, radius, -radius) {}
 
 
  Point2D<double> P0() const noexcept { return p0_; }
 
 
  void SetP0(Point2D<double> p0) noexcept { p0_ = p0; }
 
 
  Point2D<double> P1() const noexcept { return p1_; }
 
 
  void SetP1(Point2D<double> p1) noexcept { p1_ = p1; }
 
 
  Point2D<double> P2() const noexcept { return p2_; }
 
 
  void SetP2(Point2D<double> p2) noexcept { p2_ = p2; }
 
 
  Point2D<double> P3() const noexcept { return p1_ + p2_ - p0_; }
 
 
  Rect<double> BoundingRectangle() const noexcept
  {
    Rect<double> bb(p0_, Size2D<double>());
    ExpandBBByPoint(bb, p1_);
    ExpandBBByPoint(bb, p2_);
    ExpandBBByPoint(bb, P3());
 
    return bb;
  }
 
 
  Size2D<double> Size() const noexcept
  {
    auto vP0P2 = p2_ - p0_;
    auto vP0P1 = p1_ - p0_;
    return Size2D<double>(vP0P2.Length(), vP0P1.Length());
  }
 
 
  double Area() const noexcept
  {
    auto vP0P2 = p2_ - p0_;
    auto vP0P1 = p1_ - p0_;
    return abs(vP0P2.X() * vP0P1.Y() - vP0P2.Y() * vP0P1.X());
  }
 
 
  void Transform(Matrix2D matrix) noexcept
  {
    p0_ = matrix * p0_;
    p1_ = matrix * p1_;
    p2_ = matrix * p2_;
  }
 
 
  void Transform(AffineMatrix2D affineMatrix) noexcept
  {
    p0_ = affineMatrix * p0_;
    p1_ = affineMatrix * p1_;
    p2_ = affineMatrix * p2_;
  }
 
 
  void SwapOrientation() noexcept
  {
    auto tmp = p1_;
    p1_ = p2_;
    p2_ = tmp;
  }
 
 
  CoordinateSystemType CoordinateSystem() const noexcept { return CoordinateSystemType::ImageCoordinates; }
 
 
  bool operator==(const Area2D &area) const noexcept { return p0_ == area.p0_ && p1_ == area.p1_ && p2_ == area.p2_; }
 
 
  bool operator!=(const Area2D &area) const noexcept { return !(*this == area); }
 
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_;
};
 
CVB_END_INLINE_NS
 
}