affine_matrix_3d.hpp

#pragma once
 
#include "_cexports/c_core_3d.h"
 
#include "global.hpp"
#include "matrix_3d.hpp"
#include "point_3d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  struct AffineTransformationParameters
  {
    Vector3D<double> RotationAngles;

    Factors3D Scale;

    double Syx = 0;

    double Syz = 0;

    double InclinationX = 0;

    double InclinationZ = 0;

    AffineTransformationParameters()
        : RotationAngles(Vector3D<double>(0, 0, 0))
        , Scale(Factors3D(1, 1, 1))
    {
    }
  };
 
  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
      : translation_(translation)
      , matrix_(matrix)
    {
    }


    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));
      });
    }


    AffineMatrix3D Inverse()
    {
      auto result = *this;
      result.Invert();
      return result;
    }


    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
 
}  // namespace Cvb