matrix_2d.hpp

#pragma once
 
#include "global.hpp"
 
#include "angle.hpp"
#include "point_2d.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
class Matrix2D final
{
  public:
 
 
    static Matrix2D Identity() noexcept
    {
      return Matrix2D(1.0, 0.0, 0.0, 1.0);
    }
 
 
    Matrix2D() noexcept = default;
 
 
    template<std::size_t N>
    Matrix2D(const double(&list)[N]) noexcept // NOLINT
    {
      static_assert(N == 4, "CVB: Matrix2D must have 4 elements");
      std::copy(std::begin(list), std::end(list), &a11_);
    }
 
 
    Matrix2D(double a11, double a12, double a21, double a22) noexcept
      : a11_(a11)
      , a12_(a12)
      , a21_(a21)
      , a22_(a22)
    {
    }
 
 
    explicit Matrix2D(Angle rotation, double scale = 1.0) noexcept
    {
      a11_ = (scale * Cos(rotation)); // NOLINT(cppcoreguidelines-prefer-member-initializer)
      a22_ = a11_; // NOLINT(cppcoreguidelines-prefer-member-initializer)
      a21_ = scale * Sin(rotation); // NOLINT(cppcoreguidelines-prefer-member-initializer)
      a12_ = -a21_; // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
 
 
 
    explicit Matrix2D(double scale) noexcept
      : Matrix2D(scale, scale)
    {
    }
 
 
    Matrix2D(double scaleX, double scaleY) noexcept
      : Matrix2D(scaleX, 0.0, scaleY, 0.0)
    {
    }
 
 
    Matrix2D(Cvb::Point2D<double> column1, Cvb::Point2D<double> column2) noexcept
      : Matrix2D(column1.X(), column2.X(), column1.Y(), column2.Y())
    {
    }
 
 
 
    const double* operator[](int row) const noexcept
    {
 
      return &((&a11_)[row << 1]);
    }
 
 
    double* operator[](int row) noexcept
    {
      return &((&a11_)[row << 1]);
    }
 
 
 
    const double& At(int row, int column) const noexcept
    {
      return (*this)[row][column];
    }
 
 
    double& At(int row, int column) noexcept
    {
      return (*this)[row][column];
    }
 
 
 
    double A11() const noexcept
    {
      return a11_;
    }
 
 
    void SetA11(double a11) noexcept
    {
      a11_ = a11;
    }
 
 
    double A12() const noexcept
    {
      return a12_;
    }
 
 
    void SetA12(double a12) noexcept
    {
      a12_ = a12;
    }
 
 
    double A21() const noexcept
    {
      return a21_;
    }
 
 
    void SetA21(double a21) noexcept
    {
      a21_ = a21;
    }
 
 
    double A22() const noexcept
    {
      return a22_;
    }
 
 
    void SetA22(double a22) noexcept
    {
      a22_ = a22;
    }
 
 
    double Det() const noexcept
    {
      return a11_ * a22_ - a21_ * a12_;
    }
 
 
 
    void Invert()
    {
      *this = Inverse();
    }
 
 
    Matrix2D Inverse()
    {
      if (std::fabs(Det()) < 1e-9)      
        throw std::invalid_argument("matrix is not invertible");
      
      double det_1 = 1.0 / Det();
      return Matrix2D(a22_ * det_1, -a12_ * det_1, -a21_ * det_1, a11_ * det_1);
    }
 
 
    bool operator==(const Matrix2D& matrix) const noexcept
    {
      return a11_ == matrix.a11_
        && a12_ == matrix.a12_
        && a21_ == matrix.a21_
        && a22_ == matrix.a22_;
    }
 
 
    bool operator!=(const Matrix2D& matrix) const noexcept
    {
      return !(*this == matrix);
    }
 
 
    Matrix2D& operator +=(const Matrix2D & matrix) noexcept
    {
      a11_ += matrix.a11_;
      a12_ += matrix.a12_;
      a21_ += matrix.a21_;
      a22_ += matrix.a22_;
      return *this;
    }
 
 
    Matrix2D& operator -=(const Matrix2D & matrix) noexcept
    {
      a11_ -= matrix.a11_;
      a12_ -= matrix.a12_;
      a21_ -= matrix.a21_;
      a22_ -= matrix.a22_;
      return *this;
    }
 
 
    Matrix2D& operator *=(const Matrix2D & matrix) noexcept
    {
      *this = Matrix2D(a11_ * matrix.a11_ + a12_ * matrix.a21_,
        a11_ * matrix.a12_ + a12_ * matrix.a22_,
        a21_ * matrix.a11_ + a22_ * matrix.a21_,
        a21_ * matrix.a12_ + a22_ * matrix.a22_);
      return *this;
    }
 
 
    Matrix2D& operator *=(const double & value) noexcept
    {
      a11_ *= value;
      a12_ *= value;
      a21_ *= value;
      a22_ *= value;
      return *this;
    }
 
 
    Matrix2D& operator /=(const double & value) noexcept
    {
      a11_ /= value;
      a12_ /= value;
      a21_ /= value;
      a22_ /= value;
      return *this;
    }
 
 
 
  private:
 
    double a11_ = 0.0;
    double a12_ = 0.0;
    double a21_ = 0.0;
    double a22_ = 0.0;
};
 
 
 
 
inline Matrix2D operator+(const Matrix2D & lhs, const Matrix2D & rhs)
{
  return Matrix2D(lhs.A11() + rhs.A11(), lhs.A12() + rhs.A12(), lhs.A21() + rhs.A21(), lhs.A22() + rhs.A22());
}
 
 
inline Matrix2D operator-(const Matrix2D & lhs, const Matrix2D & rhs)
{
  return Matrix2D(lhs.A11() - rhs.A11(), lhs.A12() - rhs.A12(), lhs.A21() - rhs.A21(), lhs.A22() - rhs.A22());
}
 
 
inline Matrix2D operator*(const Matrix2D & lhs, const Matrix2D & rhs)
{
  return Matrix2D(lhs.A11() * rhs.A11() + lhs.A12() * rhs.A21(),
    lhs.A11() * rhs.A12() + lhs.A12() * rhs.A22(),
    lhs.A21() * rhs.A11() + lhs.A22() * rhs.A21(),
    lhs.A21() * rhs.A12() + lhs.A22() * rhs.A22());
}
 
 
inline Point2D<double> operator*(const Matrix2D & lhs, const Point2D<double> & rhs)
{
  return Point2D<double>(lhs.A11() * rhs.X() + lhs.A12() * rhs.Y(), lhs.A21() * rhs.X() + lhs.A22() * rhs.Y());
}
 
 
inline Matrix2D operator*(const Matrix2D & lhs, const double & rhs)
{
  return Matrix2D(lhs.A11() * rhs, lhs.A12() * rhs, lhs.A21() * rhs, lhs.A22() * rhs);
}
 
 
inline Matrix2D operator*(const double & lhs, const Matrix2D & rhs)
{
  return rhs * lhs;
}
 
 
inline Matrix2D operator/(const Matrix2D & lhs, const double & rhs)
{
  return Matrix2D(lhs.A11() / rhs, lhs.A12() / rhs, lhs.A21() / rhs, lhs.A22() / rhs);
}
 
 
 
 
 
 
CVB_END_INLINE_NS
 
}