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))
    , Syx(0)
    , Syz(0)
    , InclinationX(0)
    , InclinationZ(0)
  {
  }
};
 
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));
      });
    }
 
 
    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