affine_matrix_3d.hpp

#pragma once



#include "_cexports/c_core_3d.h"

#include "global.hpp"


#include "point_3d.hpp"
#include "matrix_3d.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

class AffineMatrix3D;



inline AffineMatrix3D operator+(const AffineMatrix3D & lhs, const AffineMatrix3D & rhs) noexcept;


inline AffineMatrix3D operator-(const AffineMatrix3D & lhs, const AffineMatrix3D & rhs) noexcept;



inline AffineMatrix3D operator*(const AffineMatrix3D & lhs, const AffineMatrix3D & rhs);




inline AffineMatrix3D operator*(const AffineMatrix3D & lhs, const double & rhs) noexcept;


inline AffineMatrix3D operator*(const double & lhs, const AffineMatrix3D & rhs) noexcept;


inline AffineMatrix3D operator/(const AffineMatrix3D & lhs, const double & rhs);




class AffineMatrix3D final
{
  public:


    static AffineMatrix3D Identity() noexcept
    {
      return  AffineMatrix3D(
              Matrix3D::Identity(),
              Vector3D<double>());
    }


    AffineMatrix3D() noexcept = default;


    AffineMatrix3D(Matrix3D matrix, Vector3D<double> translation) noexcept
      : matrix_(matrix)
      , translation_(translation)
    {
    }



    Matrix3D Matrix() const  noexcept
    {
      return matrix_;
    }


    void SetMatrix(Matrix3D matrix) noexcept
    {
      matrix_ = matrix;
    }


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



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



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


    double Det() const
    {
      return Internal::DoResCallValueOut<double>([&](double & value)
      {
        auto thisData = reinterpret_cast<const CExports::CVC3DTransformation*>(this);
        return CVB_CALL_CAPI(CVC3DTransformationDeterminant(*thisData, value));
      });
    }



    void Invert()
    {
      Internal::DoResCall([&]()
      {
        auto data = reinterpret_cast<const CExports::CVC3DTransformation*>(this);
        auto dataInv = reinterpret_cast<CExports::CVC3DTransformation*>(this);
        return CVB_CALL_CAPI(CVC3DInvertTransformation(*data, *dataInv));
      });
    }


    bool operator==(const AffineMatrix3D& transformation) const noexcept
    {
      return translation_ == transformation.translation_
        && matrix_ == transformation.matrix_;
    }


    bool operator!=(const AffineMatrix3D& transformation) const noexcept
    {
      return !(*this == transformation);
    }


    AffineMatrix3D& operator +=(const AffineMatrix3D & transformation) noexcept
    {
      *this = *this + transformation;
      return *this;
    }


    AffineMatrix3D& operator -=(const AffineMatrix3D & transformation) noexcept
    {
      *this = *this - transformation;
      return *this;
    }




    AffineMatrix3D& operator *=(const AffineMatrix3D & transformation)
    {
      *this = *this * transformation;
      return *this;
    }


    AffineMatrix3D& operator *=(const double & value) noexcept
    {
      *this = *this *value;
      return *this;
    }


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



  private:

    Vector3D<double> translation_;
    Matrix3D matrix_;
};




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

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

inline AffineMatrix3D operator*(const AffineMatrix3D & lhs, const AffineMatrix3D & rhs)
{

  return Internal::DoResCallValueOut<AffineMatrix3D>([&](AffineMatrix3D & value)
  {
    auto valueData = reinterpret_cast<CExports::CVC3DTransformation*>(&value);
    auto lhsData = reinterpret_cast<const CExports::CVC3DTransformation*>(&lhs);
    auto rhsData = reinterpret_cast<const CExports::CVC3DTransformation*>(&rhs);
    return CVB_CALL_CAPI(CVC3DMultiplyTransformations(*lhsData,
      *rhsData,
      *valueData));
  });

}


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


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


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






CVB_END_INLINE_NS

}