matrix_3d_h.hpp

#pragma once



#include "_cexports/c_core_3d.h"

#include "global.hpp"


#include "point_3d_h.hpp"
#include "matrix_3d.hpp"

namespace Cvb
{



CVB_BEGIN_INLINE_NS

class Matrix3DH;


inline Matrix3DH operator+(const Matrix3DH & lhs, const Matrix3DH & rhs);



inline Matrix3DH operator-(const Matrix3DH & lhs, const Matrix3DH & rhs);


class Matrix3DH final
{
  public:


    static Matrix3DH Identity() noexcept
    {
      return  {{
                1.0, 0.0, 0.0, 0.0,
                0.0, 1.0, 0.0, 0.0,
                0.0, 0.0, 1.0, 0.0,
                0.0, 0.0, 0.0, 1.0
              }};
    }


    Matrix3DH() noexcept = default;


    template<std::size_t N>
    Matrix3DH(const double(&list)[N]) noexcept
    {
      static_assert(N == 16, "CVB: Matrix3D must have 16 elements");
      std::copy(std::begin(list), std::end(list), matrix_.data()->data());
    }


    Matrix3DH(const Matrix3D & matrix) noexcept
    {
      *this = {{
                matrix[0][0], matrix[0][1], matrix[0][2], 0.0,
                matrix[1][0], matrix[1][1], matrix[1][2], 0.0,
                matrix[2][0], matrix[2][1], matrix[2][2], 0.0,
                0.0, 0.0, 0.0, 1.0,
              }};
    }





    const double* operator[](int row) const noexcept
    {
      return matrix_[row].data();
    }



    double* operator[](int row) noexcept
    {
      return matrix_[row].data();
    }


    const double& At(int row, int column) const noexcept
    {
      return (*this)[row][column];
    }


    double& At(int row, int column) noexcept
    {
      return (*this)[row][column];
    }







    bool operator==(const Matrix3DH& matrix) const noexcept
    {
      return matrix_ == matrix.matrix_;
    }


    bool operator!=(const Matrix3DH& matrix) const noexcept
    {
      return !(*this == matrix);
    }


    Matrix3DH& operator +=(const Matrix3DH & matrix) noexcept
    {
      *this = *this + matrix;
      return *this;
    }


    Matrix3DH& operator -=(const Matrix3DH & matrix) noexcept
    {
      *this = *this - matrix;
      return *this;
    }




    Matrix3DH& operator *=(const double & value) noexcept
    {
      for (auto & line : matrix_)
        for (auto & element : line)
          element *= value;
      return *this;
    }


    Matrix3DH& operator /=(const double & value) noexcept
    {
      for(auto & line : matrix_)
        for(auto & element : line)
          element /= value;
      return *this;
    }



  private:

    std::array<std::array<double, 4>, 4> matrix_{};
};




inline Matrix3DH operator+(const Matrix3DH & lhs, const Matrix3DH & rhs)
{
  return
  {{
      lhs[0][0] + rhs[0][0], lhs[0][1] + rhs[0][1], lhs[0][2] + rhs[0][2], lhs[0][3] + rhs[0][3],
      lhs[1][0] + rhs[1][0], lhs[1][1] + rhs[1][1], lhs[1][2] + rhs[1][2], lhs[1][3] + rhs[1][3],
      lhs[2][0] + rhs[2][0], lhs[2][1] + rhs[2][1], lhs[2][2] + rhs[2][2], lhs[2][3] + rhs[2][3],
      lhs[3][0] + rhs[3][0], lhs[3][1] + rhs[3][1], lhs[3][2] + rhs[3][2], lhs[3][3] + rhs[3][3],
  }};
}


inline Matrix3DH operator-(const Matrix3DH & lhs, const Matrix3DH & rhs)
{
  return
  {{
      lhs[0][0] - rhs[0][0], lhs[0][1] - rhs[0][1], lhs[0][2] - rhs[0][2], lhs[0][3] - rhs[0][3],
      lhs[1][0] - rhs[1][0], lhs[1][1] - rhs[1][1], lhs[1][2] - rhs[1][2], lhs[1][3] - rhs[1][3],
      lhs[2][0] - rhs[2][0], lhs[2][1] - rhs[2][1], lhs[2][2] - rhs[2][2], lhs[2][3] - rhs[2][3],
      lhs[3][0] - rhs[3][0], lhs[3][1] - rhs[3][1], lhs[3][2] - rhs[3][2], lhs[3][3] - rhs[3][3],
  }};
}




inline Point3DH<double> operator*(const Matrix3DH & lhs, const Point3DH<double> & rhs)
{
  return
  {{
      lhs[0][0] * rhs[0] + lhs[0][1] * rhs[1] + lhs[0][2] * rhs[2] + lhs[0][3] * rhs[3],
      lhs[1][0] * rhs[0] + lhs[1][1] * rhs[1] + lhs[1][2] * rhs[2] + lhs[1][3] * rhs[3],
      lhs[2][0] * rhs[0] + lhs[2][1] * rhs[1] + lhs[2][2] * rhs[2] + lhs[2][3] * rhs[3],
      lhs[3][0] * rhs[0] + lhs[3][1] * rhs[1] + lhs[3][2] * rhs[2] + lhs[3][3] * rhs[3],
  }};
}


inline Matrix3DH operator*(const Matrix3DH & lhs, const double & rhs)
{
  return
  {{
      lhs[0][0] * rhs, lhs[0][1] * rhs, lhs[0][2] * rhs, lhs[0][3] * rhs,
      lhs[1][0] * rhs, lhs[1][1] * rhs, lhs[1][2] * rhs, lhs[1][3] * rhs,
      lhs[2][0] * rhs, lhs[2][1] * rhs, lhs[2][2] * rhs, lhs[2][3] * rhs,
      lhs[3][0] * rhs, lhs[3][1] * rhs, lhs[3][2] * rhs, lhs[3][3] * rhs,
  }};
}


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


inline Matrix3DH operator/(const Matrix3DH & lhs, const double & rhs)
{
  return
  {{
      lhs[0][0] / rhs, lhs[0][1] / rhs, lhs[0][2] / rhs, lhs[0][3] / rhs,
      lhs[1][0] / rhs, lhs[1][1] / rhs, lhs[1][2] / rhs, lhs[1][3] / rhs,
      lhs[2][0] / rhs, lhs[2][1] / rhs, lhs[2][2] / rhs, lhs[2][3] / rhs,
      lhs[3][0] / rhs, lhs[3][1] / rhs, lhs[3][2] / rhs, lhs[3][3] / rhs
  }};
}






CVB_END_INLINE_NS

}