MathTypes.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
 
#ifndef CVCORE_Math_H
#define CVCORE_Math_H
 
#include <algorithm>
#include <cassert>
#include <cmath>
#include <vector>
 
#include "Tensor.h"
 
namespace cvcore {
 
using Matrixf = Tensor<CHW, C1, F32>;
using Matrixd = Tensor<CHW, C1, F64>;
 
template<class T>
struct Vector2
{
    T x; 
    T y; 
    inline T &operator[](size_t i)
    {
        if (i == 0)
        {
            return x;
        }
        else if (i == 1)
        {
            return y;
        }
        else
        {
            throw std::out_of_range("cvcore::Vector2 ==> Requested index is out of bounds");
        }
    }
};
 
template<class T>
struct Vector3
{
    T x; 
    T y; 
    T z; 
    inline T &operator[](size_t i)
    {
        if (i == 0)
        {
            return x;
        }
        else if (i == 1)
        {
            return y;
        }
        else if (i == 2)
        {
            return z;
        }
        else
        {
            throw std::out_of_range("cvcore::Vector3 ==> Requested index is out of bounds");
        }
    }
};
 
using Vector2i = Vector2<int>;
using Vector3i = Vector3<int>;
 
using Vector2f = Vector2<float>;
using Vector3f = Vector3<float>;
 
using Vector2d = Vector2<double>;
using Vector3d = Vector3<double>;
 
struct AxisAngleRotation
{
    double angle;  
    Vector3d axis; 
    AxisAngleRotation()
        : angle(0.0)
        , axis{0, 0, 0}
    {
    }
 
    AxisAngleRotation(double angleinput, Vector3d axisinput)
        : angle(angleinput)
        , axis(axisinput)
    {
    }
};
 
struct Quaternion
{
    double qx, qy, qz; 
    double qw;         
    Quaternion()
        : qx(0.0)
        , qy(0.0)
        , qz(0.0)
        , qw(0.0)
    {
    }
 
    Quaternion(double qxinput, double qyinput, double qzinput, double qwinput)
        : qx(qxinput)
        , qy(qyinput)
        , qz(qzinput)
        , qw(qwinput)
    {
    }
};
 
Vector3d RotationMatrixToRotationVector(const std::vector<double> &rotMatrix);
 
AxisAngleRotation RotationMatrixToAxisAngleRotation(const std::vector<double> &rotMatrix);
 
std::vector<double> AxisAngleToRotationMatrix(const AxisAngleRotation &axisangle);
 
Vector3d AxisAngleRotationToRotationVector(const AxisAngleRotation &axisangle);
 
AxisAngleRotation RotationVectorToAxisAngleRotation(const Vector3d &rotVector);
 
Quaternion AxisAngleRotationToQuaternion(const AxisAngleRotation &axisangle);
 
AxisAngleRotation QuaternionToAxisAngleRotation(const Quaternion &qrotation);
 
std::vector<double> QuaternionToRotationMatrix(const Quaternion &qrotation);
 
Quaternion RotationMatrixToQuaternion(const std::vector<double> &rotMatrix);
 
template<class T>
struct Pose3
{
    AxisAngleRotation rotation; 
    Vector3<T> translation;     /*Translation expressed as x,y,z coordinates.*/
};
 
using Pose3d = Pose3<double>;
using Pose3f = Pose3<float>;
 
} // namespace cvcore
 
#endif // CVCORE_Math_H