Moved hamilton tools to compat so they can be used more widely

4 files changed, 2 insertions, 164 deletions

diff --git a/filter-hamilton/ftnoir_filter_hamilton.cpp b/filter-hamilton/ftnoir_filter_hamilton.cpp
index 7bbc91de..c4429ecc 100644
--- a/filter-hamilton/ftnoir_filter_hamilton.cpp
+++ b/filter-hamilton/ftnoir_filter_hamilton.cpp
@@ -9,7 +9,7 @@
 #include <cmath>
 #include <QMutexLocker>
 #include "api/plugin-api.hpp"
-#include "hamilton-tools.h"
+#include "compat/hamilton-tools.h"
 
 hamilton::hamilton() = default;
 
diff --git a/filter-hamilton/ftnoir_filter_hamilton.h b/filter-hamilton/ftnoir_filter_hamilton.h
index b724d973..199eef80 100644
--- a/filter-hamilton/ftnoir_filter_hamilton.h
+++ b/filter-hamilton/ftnoir_filter_hamilton.h
@@ -13,7 +13,7 @@
 #include <QMutex>
 #include "options/options.hpp"
 //#include "compat/timer.hpp"
-#include "hamilton-tools.h"
+#include "compat/hamilton-tools.h"
 
 using namespace options;
 
diff --git a/filter-hamilton/hamilton-tools.cpp b/filter-hamilton/hamilton-tools.cpp
deleted file mode 100644
index e18082a8..00000000
--- a/filter-hamilton/hamilton-tools.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "hamilton-tools.h"
-#include <cmath>
-
-double VectorLength(const tVector v)
-{
-    return(sqrt(v.v[0]*v.v[0] + v.v[1]*v.v[1] + v.v[2]*v.v[2]));
-}
-		
-double sqr(const double v) { return(v*v); }
-
-double VectorDistance(const double v1[], const tVector v2)
-{
-    return(sqrt(sqr(v2.v[0]-v1[0])+sqr(v2.v[1]-v1[1])+sqr(v2.v[2]-v1[2])));
-}
-
-tVector Lerp(const tVector s, const double d[], const double alpha)
-{
-    tVector V;
-    V.v[0] = s.v[0] + (d[0] - s.v[0]) * alpha;
-    V.v[1] = s.v[1] + (d[1] - s.v[1]) * alpha;
-    V.v[2] = s.v[2] + (d[2] - s.v[2]) * alpha;
-    return(V);
-}	
-
-tQuat QuatFromAngleAxe(const double angle, const tVector axe)
-{
-    double a = TO_RAD * 0.5 * angle;
-    double d = sin(a) / VectorLength(axe);
-    return  ( tQuat (
-                        axe.v[0] * d,
-                        axe.v[1] * d,
-                        axe.v[2] * d,
-                        cos(a)
-                    )
-            );
-}
-		
-tQuat QuatMultiply(const tQuat qL, const tQuat qR)
-{
-    tQuat Q;
-    Q.x = qL.w*qR.x + qL.x*qR.w + qL.y*qR.z - qL.z*qR.y;
-    Q.y = qL.w*qR.y + qL.y*qR.w + qL.z*qR.x - qL.x*qR.z;
-    Q.z = qL.w*qR.z + qL.z*qR.w + qL.x*qR.y - qL.y*qR.x;
-    Q.w = qL.w*qR.w - qL.x*qR.x - qL.y*qR.y - qL.z*qR.z;
-    return(Q);
-}
-
-double AngleBetween(const tQuat S, const tQuat D)
-{
-    return( TO_DEG * 2*acos(fabs(S.x*D.x + S.y*D.y + S.z*D.z + S.w*D.w)) );
-}
-
-tQuat QuatFromYPR(const double YPR[])
-{
-    tQuat	Q, Qp, Qy;
-    Q  = QuatFromAngleAxe( -YPR[2], {0, 0, 1} ); //Roll,  Z axe
-    Qp = QuatFromAngleAxe( -YPR[1], {1, 0, 0} ); //Pitch, X axe
-    Qy = QuatFromAngleAxe( -YPR[0], {0, 1, 0} ); //Yaw,   Y axe
-
-    Q  = QuatMultiply(Qp, Q);
-    return(QuatMultiply(Qy, Q));
-}
-
-void Normalize(tQuat Q)
-{
-    double m = sqrt(Q.x*Q.x + Q.y*Q.y + Q.z*Q.z + Q.w*Q.w);
-    if (m > EPSILON)
-    {
-        m   = 1 / m;
-        Q.x = Q.x * m;
-        Q.y = Q.y * m;
-        Q.z = Q.z * m;
-        Q.w = Q.w * m;
-    }
-    else Q = tQuat(0, 0, 0, 1);
-}
-
-tQuat Slerp(const tQuat S, const tQuat D, const double alpha)
-{
-    // calc cosine of half angle
-    double cosin = S.x*D.x + S.y*D.y + S.z*D.z + S.w*D.w;
-
-    // select nearest rotation direction
-    tQuat Q;
-    if (cosin < 0)
-    {
-        cosin = - cosin;
-        Q.x   = - D.x;
-        Q.y   = - D.y;
-        Q.z   = - D.z;
-        Q.w   = - D.w;
-    }
-    else Q = D;
-
-    // calculate coefficients
-    double scale0, scale1;
-    if ((1.0 - cosin) > EPSILON)
-    {
-        double omega = acos(cosin);
-        double sinus = 1 / sin(omega);
-        scale0 = sin((1.0 - alpha) * omega) * sinus;
-        scale1 = sin(alpha * omega)* sinus;
-    }
-    else
-    {
-        scale0 = 1.0 - alpha;
-        scale1 = alpha;
-    }
-
-    Q.x = scale0 * S.x + scale1 * Q.x;
-    Q.y = scale0 * S.y + scale1 * Q.y;
-    Q.z = scale0 * S.z + scale1 * Q.z;
-    Q.w = scale0 * S.w + scale1 * Q.w;
-	
-    Normalize(Q);
-
-    return( Q );
-}
-
-void QuatToYPR(const tQuat Q, double YPR[])
-{
-    const double xx = Q.x * Q.x;
-    const double xy = Q.x * Q.y;
-    const double xz = Q.x * Q.z;
-    const double xw = Q.x * Q.w;
-    const double yy = Q.y * Q.y;
-    const double yz = Q.y * Q.z;
-    const double yw = Q.y * Q.w;
-    const double zz = Q.z * Q.z;
-    const double zw = Q.z * Q.w;
-
-    YPR[0] = TO_DEG * ( -atan2( 2 * ( xz + yw ), 1 - 2 * ( xx + yy ) ));
-    YPR[1] = TO_DEG * (  asin ( 2 * ( yz - xw ) ));
-    YPR[2] = TO_DEG * ( -atan2( 2 * ( xy + zw ), 1 - 2 * ( xx + zz ) ));
-}
diff --git a/filter-hamilton/hamilton-tools.h b/filter-hamilton/hamilton-tools.h
deleted file mode 100644
index 2e288225..00000000
--- a/filter-hamilton/hamilton-tools.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "compat/math.hpp"
-constexpr double TO_RAD = (M_PI / 180);
-constexpr double TO_DEG = (180 / M_PI);
-constexpr double EPSILON = 1e-30;
-
-struct tVector
-{
-    double v[3];
-    tVector(double X = 0, double Y = 0, double Z = 0) {v[0]=X; v[1]=Y; v[2]=Z;}
-    tVector(double V[]) {v[0]=V[0]; v[1]=V[1]; v[2]=V[2];}
-};
-
-struct tQuat
-{
-    double x, y, z, w;
-    tQuat(double X = 0, double Y = 0, double Z = 0, double W = 1)
-        {x = X; y = Y; z = Z; w = W;}
-};
-
-double  VectorDistance(const double v1[], const tVector v2);
-tVector Lerp          (const tVector s, const double d[], const double alpha);
-tQuat   QuatFromYPR   (const double YPR[]);
-double  AngleBetween  (const tQuat S, const tQuat D);
-tQuat   Slerp         (const tQuat S, const tQuat D, const double alpha);
-void    QuatToYPR     (const tQuat Q, double YPR[]);