DCM.hpp

Go to the documentation of this file.

#pragma once
 
#include "NumCpp/Functions/dot.hpp"
#include "NumCpp/Functions/round.hpp"
#include "NumCpp/Linalg/det.hpp"
#include "NumCpp/NdArray.hpp"
#include "NumCpp/Rotations/Quaternion.hpp"
#include "NumCpp/Utils/essentiallyEqual.hpp"
#include "NumCpp/Vector/Vec3.hpp"
 
namespace nc::rotations
{
    //================================================================================
    class DCM
    {
    public:
        //============================================================================
        // Method Description:
        static NdArray<double> eulerAngles(double roll, double pitch, double yaw)
        {
            return Quaternion(roll, pitch, yaw).toDCM();
        }
 
        //============================================================================
        // Method Description:
        static NdArray<double> eulerAngles(const NdArray<double>& angles)
        {
            return Quaternion(angles).toDCM();
        }
 
        //============================================================================
        // Method Description:
        static NdArray<double> eulerAxisAngle(const NdArray<double>& inAxis, double inAngle)
        {
            return Quaternion(inAxis, inAngle).toDCM();
        }
 
        //============================================================================
        // Method Description:
        static NdArray<double> eulerAxisAngle(const Vec3& inAxis, double inAngle)
        {
            return Quaternion(inAxis, inAngle).toDCM();
        }
 
        //============================================================================
        // Method Description:
        static bool isValid(const NdArray<double>& inArray)
        {
            const Shape inShape = inArray.shape();
            return inShape.rows == inShape.cols &&
                   utils::essentiallyEqual(round(linalg::det<double>(inArray), 2), 1.) &&
                   utils::essentiallyEqual(round(linalg::det<double>(inArray.transpose()), 2), 1.);
        }
 
        //============================================================================
        // Method Description:
        static double roll(const NdArray<double>& dcm)
        {
            return Quaternion(dcm).roll();
        }
 
        //============================================================================
        // Method Description:
        static double pitch(const NdArray<double>& dcm)
        {
            return Quaternion(dcm).pitch();
        }
 
        //============================================================================
        // Method Description:
        static double yaw(const NdArray<double>& dcm)
        {
            return Quaternion(dcm).yaw();
        }
 
        //============================================================================
        // Method Description:
        static NdArray<double> xRotation(double inAngle)
        {
            return DCM::eulerAxisAngle(Vec3{ 1., 0., 0. }, inAngle);
        }
 
        //============================================================================
        // Method Description:
        static NdArray<double> yRotation(double inAngle)
        {
            return DCM::eulerAxisAngle(Vec3{ 0., 1., 0. }, inAngle);
        }
 
        //============================================================================
        // Method Description:
        static NdArray<double> zRotation(double inAngle)
        {
            return DCM::eulerAxisAngle(Vec3{ 0., 0., 1. }, inAngle);
        }
    };
} // namespace nc::rotations