Angles2d.h

Go to the documentation of this file.

// Angles2d.h:
// -----------
//

#ifndef __IPSDKMATH_ANGLES2D_H__
#define __IPSDKMATH_ANGLES2D_H__

#include <IPSDKMath/Geometry/Angles.h>
#include <IPSDKMath/Geometry/2d/Point2d.h>
#include <IPSDKMath/Tools/MathUtils.h>
#include <IPSDKMath/LinearAlgebra/LinearAlgebraTypes.h>

namespace ipsdk {
namespace math {


template <typename TOut, typename TIn>
IPSDK_FORCEINLINE TOut
polarToXCartesian(const TIn rho, const TIn cosTheta, const TIn sinTheta)
{
    return round<TOut>(rho * cosTheta);
}
template <typename TOut, typename TIn>
IPSDK_FORCEINLINE TOut
polarToYCartesian(const TIn rho, const TIn cosTheta, const TIn sinTheta)
{
    return round<TOut>(rho * sinTheta);
}
template <typename TOut, typename TIn>
IPSDK_FORCEINLINE void
polarToCartesian(const TIn rho, const TIn cosTheta, const TIn sinTheta,
                 TOut& x, TOut& y)
{
    x = polarToXCartesian<TOut>(rho, cosTheta, sinTheta);
    y = polarToYCartesian<TOut>(rho, cosTheta,sinTheta);
}
template <typename TOut, typename TIn>
IPSDK_FORCEINLINE void
polarToCartesian(const TIn rho, const TIn theta,
                 TOut& x, TOut& y)
{
    polarToCartesian(rho, std::cos(theta), std::sin(theta), x, y);
}

template <typename TOut, typename TIn>
IPSDK_FORCEINLINE void
cartesianToPolar(const TIn x, const TIn y,
                 TOut& rho, TOut& theta)
{
    rho = round<TOut>(normL2(x, y));
    theta = std::atan2(y, x);
}

template <typename T>
IPSDK_FORCEINLINE void
angleToMatrix(const T cosTheta, const T sinTheta,
              T& rxx, T& rxy,
              T& ryx, T& ryy)
{
    rxx = cosTheta; rxy = -sinTheta;
    ryx = sinTheta; ryy = cosTheta;
}
template <typename T>
IPSDK_FORCEINLINE void
angleToMatrix(const T theta,
              T& rxx, T& rxy,
              T& ryx, T& ryy)
{
    angleToMatrix(std::cos(theta), std::sin(theta),
                  rxx, rxy,
                  ryx, ryy);
}
IPSDK_FORCEINLINE Matrix2d
angleToMatrix(const ipReal64 theta)
{
    Matrix2d matRot;
    angleToMatrix(theta,
                  matRot(0, 0), matRot(0, 1),
                  matRot(1, 0), matRot(1, 1));
    return matRot;
}

template <typename T>
IPSDK_FORCEINLINE void
matrixToAngle(const T rxx, const T rxy,
              T& theta)
{
    theta = std::atan2(-rxy, rxx);
    if (theta == -M_PI)
        theta = M_PI;
}
template <typename T>
IPSDK_FORCEINLINE void
matrixToAngle(const T rxx, const T rxy,
              const T ryx, const T ryy,
              T& theta)
{
    matrixToAngle(rxx, rxy, theta);
}
IPSDK_FORCEINLINE ipReal64
matrixToAngle(const Matrix2d& matRot)
{
    ipReal64 theta;
    matrixToAngle(matRot(0, 0), matRot(0, 1), theta);

    return theta;
}

template <typename T>
IPSDK_FORCEINLINE void
rotate2d(const T xIn, const T yIn,
         const ipReal64 cosTheta, const ipReal64 sinTheta,
         T& xOut, T& yOut)
{
    xOut = round<T>(cosTheta * xIn - sinTheta * yIn);
    yOut = round<T>(sinTheta * xIn + cosTheta * yIn);
}
template <typename T>
IPSDK_FORCEINLINE void
rotate2dInSitu(const ipReal64 cosTheta, const ipReal64 sinTheta,
               T& x, T& y)
{
    rotate2d(x, y,
             cosTheta, sinTheta,
             x, y);
}
template <typename T>
IPSDK_FORCEINLINE void
rotate2d(const T xIn, const T yIn,
         const ipReal64 theta,
         T& xOut, T& yOut)
{
    rotate2d(xIn, yIn,
             std::cos(theta), std::sin(theta),
             xOut, yOut);
}


} // end of namespace math
} // end of namespace ipsdk

#endif // __IPSDKMATH_ANGLES2D_H__