affine_matrix_2d.hpp

#pragma once

#include "global.hpp"

#include "matrix_2d.hpp"
#include "point_2d.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS



class AffineMatrix2D final
{
  public:


    static AffineMatrix2D Identity() noexcept
    {
      return AffineMatrix2D(Cvb::Matrix2D::Identity(), Vector2D<double>());
    }


    AffineMatrix2D() noexcept = default;


    AffineMatrix2D(Cvb::Matrix2D matrix, Vector2D<double> translation) noexcept
      : translation_(translation)
      , matrix_(matrix)
    {
    }


    Cvb::Matrix2D Matrix() const  noexcept
    {
      return matrix_;
    }


    void SetMatrix(Cvb::Matrix2D matrix) noexcept
    {
      matrix_ = matrix;
    }


    Vector2D<double> Translation() const noexcept
    {
      return translation_;
    }



    void SetTranslation(Vector2D<double> translation) noexcept
    {
      translation_ = translation;
    }


    void Invert()
    {
      matrix_.Invert();
      translation_ = matrix_ * (-1.0 * translation_);
    }


    bool IsTranslation() const noexcept
    {
      return matrix_ == Cvb::Matrix2D::Identity();
    }


    bool operator==(const AffineMatrix2D& affineMatrix) const noexcept
    {
      return translation_ == affineMatrix.translation_
        && matrix_ == affineMatrix.matrix_;
    }


    bool operator!=(const AffineMatrix2D& affineMatrix) const noexcept
    {
      return !(*this == affineMatrix);
    }



    AffineMatrix2D& operator +=(const AffineMatrix2D & affineMatrix) noexcept
    {
      matrix_ += affineMatrix.matrix_;
      translation_ += affineMatrix.translation_;
      return *this;
    }


    AffineMatrix2D& operator -=(const AffineMatrix2D & affineMatrix) noexcept
    {
      matrix_ -= affineMatrix.matrix_;
      translation_ -= affineMatrix.translation_;
      return *this;
    }


    AffineMatrix2D& operator *=(const AffineMatrix2D & affineMatrix) noexcept
    {
      *this = AffineMatrix2D(matrix_ * affineMatrix.matrix_, matrix_ * affineMatrix.translation_ + translation_);
      return *this;
    }


    AffineMatrix2D& operator *=(const double & value) noexcept
    {
      matrix_ *= value;
      translation_ *= value;
      return *this;
    }


    AffineMatrix2D& operator /=(const double & value) noexcept
    {
      matrix_ /= value;
      translation_ /= value;
      return *this;
    }

  private:

    Vector2D<double> translation_;
    Cvb::Matrix2D matrix_;

};



inline AffineMatrix2D operator+(const AffineMatrix2D & lhs, const AffineMatrix2D & rhs) noexcept
{
  return AffineMatrix2D(lhs.Matrix() + rhs.Matrix(), lhs.Translation() + rhs.Translation());
}


inline AffineMatrix2D operator-(const AffineMatrix2D & lhs, const AffineMatrix2D & rhs) noexcept
{
  return AffineMatrix2D(lhs.Matrix() - rhs.Matrix(), lhs.Translation() - rhs.Translation());
}


inline AffineMatrix2D operator*(const AffineMatrix2D & lhs, const AffineMatrix2D & rhs) noexcept
{
  return AffineMatrix2D(lhs.Matrix() * rhs.Matrix(), lhs.Matrix() * rhs.Translation() + lhs.Translation());
}


inline Point2D<double> operator*(const AffineMatrix2D & lhs, const Point2D<double> & rhs) noexcept
{
  return lhs.Matrix() * rhs + lhs.Translation();
}


inline AffineMatrix2D operator*(const AffineMatrix2D & lhs, const double & rhs) noexcept
{
  return AffineMatrix2D(lhs.Matrix() * rhs, lhs.Translation() * rhs);
}


inline AffineMatrix2D operator*(const double & lhs, const AffineMatrix2D & rhs) noexcept
{
  return rhs * lhs;
}


inline AffineMatrix2D operator/(const AffineMatrix2D & lhs, const double & rhs)
{
  return AffineMatrix2D(lhs.Matrix() / rhs, lhs.Translation() / rhs);
}

CVB_END_INLINE_NS

}