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>());
    }
    static AffineMatrix2D Identity() noexcept {…}


    AffineMatrix2D() noexcept = default;


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


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


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


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


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


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


    AffineMatrix2D Inverse()
    {
      auto matrix = *this;
      matrix.Invert();
      return matrix;
    }
    AffineMatrix2D Inverse() {…}


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


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


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


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


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


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


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


    AffineMatrix2D &operator/=(const double &value) noexcept
    {
      matrix_ /= value;
      translation_ /= value;
      return *this;
    }
    AffineMatrix2D &operator/=(const double &value) noexcept {…}
 
  private:
    Vector2D<double> translation_;
    Cvb::Matrix2D matrix_;
  };
  class AffineMatrix2D final {…};


  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 {…}


  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 {…}


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


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


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


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


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