Vec3.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <string>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Functions/hypot.hpp"
#include "NumCpp/NdArray.hpp"
#include "NumCpp/Utils/essentiallyEqual.hpp"
#include "NumCpp/Utils/interp.hpp"
#include "NumCpp/Vector/Vec2.hpp"
 
//====================================================================================
 
namespace nc
{
    //================================================================================
    // Class Description:
    class Vec3
    {
    public:
        //====================================Attributes==============================
        double x{ 0. };
        double y{ 0. };
        double z{ 0. };
 
        //============================================================================
        // Method Description:
        constexpr Vec3() = default;
 
        //============================================================================
        // Method Description:
        constexpr Vec3(double inX, double inY, double inZ) noexcept :
            x(inX),
            y(inY),
            z(inZ)
        {
        }
 
        //============================================================================
        // Method Description:
        Vec3(const std::initializer_list<double>& inList)
        {
            if (inList.size() != 3)
            {
                THROW_INVALID_ARGUMENT_ERROR("input initializer list must have a size = 3");
            }
 
            x = *inList.begin();
            y = *(inList.begin() + 1);
            z = *(inList.begin() + 2);
        }
 
        //============================================================================
        // Method Description:
        constexpr Vec3(const Vec2& vec2) noexcept :
            x(vec2.x),
            y(vec2.y)
        {
        }
 
        //============================================================================
        // Method Description:
        Vec3(const NdArray<double>& ndArray)
        {
            if (ndArray.size() != 3)
            {
                THROW_INVALID_ARGUMENT_ERROR("input NdArray must have a size = 3");
            }
 
            x = ndArray[0];
            y = ndArray[1];
            z = ndArray[2];
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double angle(const Vec3& otherVec) const noexcept
        {
            double dotProduct = dot(otherVec);
            dotProduct /= norm();
            dotProduct /= otherVec.norm();
 
            // clamp the value to the acos range just to be safe
            dotProduct = std::max(std::min(dotProduct, 1.), -1.);
 
            return std::acos(dotProduct);
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec3 back() noexcept
        {
            return Vec3(0., 0., -1.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec3 clampMagnitude(double maxLength) const noexcept
        {
            const double magnitude = norm();
            if (magnitude <= maxLength)
            {
                return *this;
            }
 
            Vec3 returnVec = Vec3(*this).normalize();
            returnVec *= maxLength;
            return returnVec;
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec3 cross(const Vec3& otherVec) const noexcept
        {
            const double crossX = y * otherVec.z - z * otherVec.y;
            const double crossY = -(x * otherVec.z - z * otherVec.x);
            const double crossZ = x * otherVec.y - y * otherVec.x;
 
            return Vec3(crossX, crossY, crossZ); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double distance(const Vec3& otherVec) const noexcept
        {
            return (Vec3(*this) -= otherVec).norm();
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double dot(const Vec3& otherVec) const noexcept
        {
            return x * otherVec.x + y * otherVec.y + z * otherVec.z;
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec3 down() noexcept
        {
            return Vec3(0., -1., 0.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec3 forward() noexcept
        {
            return Vec3(0., 0., 1.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec3 left() noexcept
        {
            return Vec3(-1., 0., 0.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec3 lerp(const Vec3& otherVec, double t) const noexcept
        {
            t = std::max(std::min(t, 1.), 0.);
 
            Vec3 trajectory = otherVec;
            trajectory -= *this;
            const double xInterp = utils::interp(0., trajectory.x, t);
            const double yInterp = utils::interp(0., trajectory.y, t);
            const double zInterp = utils::interp(0., trajectory.z, t);
 
            return Vec3(*this) += Vec3(xInterp, yInterp, zInterp);
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double norm() const noexcept
        {
            return hypot(x, y, z);
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec3 normalize() const noexcept
        {
            return Vec3(*this) /= norm();
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec3 project(const Vec3& otherVec) const noexcept
        {
            const double projectedMagnitude = norm() * std::cos(angle(otherVec));
            return otherVec.normalize() *= projectedMagnitude;
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec3 right() noexcept
        {
            return Vec3(1., 0., 0.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] std::string toString() const
        {
            std::stringstream stream;
            stream << "Vec3[" << x << ", " << y << ", " << z << "]";
            return stream.str();
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] NdArray<double> toNdArray() const
        {
            NdArray<double> returnArray = { x, y, z };
            return returnArray.transpose();
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec3 up() noexcept
        {
            return Vec3(0., 1., 0.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        bool operator==(const Vec3& rhs) const noexcept
        {
            return utils::essentiallyEqual(x, rhs.x) && utils::essentiallyEqual(y, rhs.y) &&
                   utils::essentiallyEqual(z, rhs.z);
        }
 
        //============================================================================
        // Method Description:
        bool operator!=(const Vec3& rhs) const noexcept
        {
            return !(*this == rhs);
        }
 
        //============================================================================
        // Method Description:
        Vec3& operator+=(double scalar) noexcept
        {
            x += scalar;
            y += scalar;
            z += scalar;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec3& operator+=(const Vec3& rhs) noexcept
        {
            x += rhs.x;
            y += rhs.y;
            z += rhs.z;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec3& operator-=(double scalar) noexcept
        {
            x -= scalar;
            y -= scalar;
            z -= scalar;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec3& operator-=(const Vec3& rhs) noexcept
        {
            x -= rhs.x;
            y -= rhs.y;
            z -= rhs.z;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec3& operator*=(double scalar) noexcept
        {
            x *= scalar;
            y *= scalar;
            z *= scalar;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec3& operator/=(double scalar) noexcept
        {
            x /= scalar;
            y /= scalar;
            z /= scalar;
            return *this;
        }
    };
 
    //============================================================================
    // Method Description:
    inline Vec3 operator+(const Vec3& lhs, double rhs) noexcept
    {
        return Vec3(lhs) += rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator+(double lhs, const Vec3& rhs) noexcept
    {
        return Vec3(rhs) += lhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator+(const Vec3& lhs, const Vec3& rhs) noexcept
    {
        return Vec3(lhs) += rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator-(const Vec3& vec) noexcept
    {
        return Vec3(-vec.x, -vec.y, -vec.z); // NOLINT(modernize-return-braced-init-list)
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator-(const Vec3& lhs, double rhs) noexcept
    {
        return Vec3(lhs) -= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator-(double lhs, const Vec3& rhs) noexcept
    {
        return -Vec3(rhs) += lhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator-(const Vec3& lhs, const Vec3& rhs) noexcept
    {
        return Vec3(lhs) -= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator*(const Vec3& lhs, double rhs) noexcept
    {
        return Vec3(lhs) *= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator*(double lhs, const Vec3& rhs) noexcept
    {
        return Vec3(rhs) *= lhs;
    }
 
    //============================================================================
    // Method Description:
    inline double operator*(const Vec3& lhs, const Vec3& rhs) noexcept
    {
        return lhs.dot(rhs);
    }
 
    //============================================================================
    // Method Description:
    inline Vec3 operator/(const Vec3& lhs, double rhs) noexcept
    {
        return Vec3(lhs) /= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline std::ostream& operator<<(std::ostream& stream, const Vec3& vec)
    {
        stream << vec.toString() << std::endl;
        return stream;
    }
} // namespace nc