transformutils.h

Go to the documentation of this file.

#ifndef ION_MATH_TRANSFORMUTILS_H_
#define ION_MATH_TRANSFORMUTILS_H_


#include "ion/math/angle.h"
#include "ion/math/matrix.h"
#include "ion/math/rotation.h"
#include "ion/math/vector.h"

namespace ion {
namespace math {




template <int Dimension, typename T>
const Vector<Dimension, T> operator*(const Matrix<Dimension + 1, T>& m,
                                     const Vector<Dimension, T>& v) {
  Vector<Dimension, T> result = Vector<Dimension, T>::Zero();
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col)
      result[row] += m(row, col) * v[col];
  }
  return result;
}

template <int Dimension, typename T>
const Point<Dimension, T> operator*(const Matrix<Dimension + 1, T>& m,
                                    const Point<Dimension, T>& p) {
  Point<Dimension, T> result = Point<Dimension, T>::Zero();
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col)
      result[row] += m(row, col) * p[col];
    result[row] += m(row, Dimension);  // Homogeneous coordinate.
  }
  return result;
}

template <int Dimension, typename T>
const Point<Dimension, T> ProjectPoint(const Matrix<Dimension + 1, T>& m,
                                       const Point<Dimension, T>& p) {
  Point<Dimension, T> result = Point<Dimension, T>::Zero();
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col)
      result[row] += m(row, col) * p[col];
    result[row] += m(row, Dimension);
  }

  T homogeneous_coordinate = m(Dimension, Dimension);
  for (int col = 0; col < Dimension; ++col)
    homogeneous_coordinate += m(Dimension, col) * p[col];

  if (homogeneous_coordinate != T(0))
    result /= homogeneous_coordinate;
  return result;
}



template <typename T>
inline Matrix<3, T> NonhomogeneousSubmatrixH(const Matrix<4, T>& m) {
  return Matrix<3, T>(m(0, 0), m(0, 1), m(0, 2),
                      m(1, 0), m(1, 1), m(1, 2),
                      m(2, 0), m(2, 1), m(2, 2));
}

template <typename T>
const Matrix<4, T> OrthoInverseH(const Matrix<4, T>& m);




template <int Dimension, typename T>
const Matrix<Dimension + 1, T> TranslationMatrix(
    const VectorBase<Dimension, T>& t) {
  typedef Matrix<Dimension + 1, T> MatrixType;
  MatrixType result = MatrixType::Identity();
  for (int row = 0; row < Dimension; ++row)
    result[row][Dimension] = t[row];
  return result;
}

template <int Dimension, typename T>
const Matrix<Dimension + 1, T> ScaleMatrixH(const Vector<Dimension, T>& s) {
  Matrix<Dimension + 1, T> result;
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension + 1; ++col)
      result[row][col] = row == col ? s[row] : static_cast<T>(0);
  }
  for (int col = 0; col < Dimension; ++col)
    result[Dimension][col] = static_cast<T>(0);
  result[Dimension][Dimension] = static_cast<T>(1);
  return result;
}

template <int Dimension, typename T>
const Matrix<Dimension, T> ScaleMatrixNH(const Vector<Dimension, T>& s) {
  Matrix<Dimension, T> result;
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col)
      result[row][col] = row == col ? s[row] : static_cast<T>(0);
  }
  return result;
}

template <typename T> ION_API
const Matrix<4, T> RotationMatrixH(const Rotation<T>& r);

template <typename T> ION_API
const Matrix<3, T> RotationMatrixNH(const Rotation<T>& r);

template <typename T>
const Matrix<4, T> RotationMatrixAxisAngleH(const Vector<3, T>& axis,
                                            const Angle<T>& angle) {
  return RotationMatrixH(Rotation<T>::FromAxisAndAngle(axis, angle));
}

template <typename T>
const Matrix<3, T> RotationMatrixAxisAngleNH(const Vector<3, T>& axis,
                                             const Angle<T>& angle) {
  return RotationMatrixNH(Rotation<T>::FromAxisAndAngle(axis, angle));
}




template <typename T> ION_API
const Matrix<4, T> LookAtMatrixFromCenter(
    const Point<3, T>& eye, const Point<3, T>& center, const Vector<3, T>& up);

template <typename T> ION_API
const Matrix<4, T> LookAtMatrixFromDir(
    const Point<3, T>& eye, const Vector<3, T>& dir, const Vector<3, T>& up);




template <typename T> ION_API
const Matrix<4, T> OrthographicMatrixFromFrustum(
    T x_left, T x_right, T y_bottom, T y_top, T z_near, T z_far);

template <typename T> ION_API
const Matrix<4, T> PerspectiveMatrixFromFrustum(
    T x_left, T x_right, T y_bottom, T y_top, T z_near, T z_far);

template <typename T> ION_API
const Matrix<4, T> PerspectiveMatrixFromView(const Angle<T>& fovy, T aspect,
                                             T z_near, T z_far);

template <typename T>
const Matrix<4, T> PerspectiveMatrixInverse(const Matrix<4, T>& m);

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_TRANSFORMUTILS_H_