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
 
}