Skip to content

Libs/Mesh/PreviewMeshQC/math3d.h

Classes

Name
class vec2d
class vec3d
class vec6d
class mat3d
class matrix
class quatd
class GLCOLOR

Types

Name
typedef unsigned char uchar

Functions

Name
quatd operator*(const double a, const quatd & q)

Types Documentation

typedef uchar

typedef unsigned char uchar;

Functions Documentation

function operator*

inline quatd operator*(
    const double a,
    const quatd & q
)

Source code

#pragma once
#include <math.h>
#include <assert.h>
#include <vector>
using namespace std;

//-----------------------------------------------------------------------------
// class vec2d defines a 2D vector
class vec2d
{
public:
    vec2d() { x = y = 0.0; }
    vec2d(double X, double Y) { x = X; y = Y; }

    vec2d operator - () { return vec2d(-x, -y); }

    vec2d operator - (const vec2d& r) { return vec2d(x - r.x, y - r.y); }
    vec2d operator + (const vec2d& r) { return vec2d(x + r.x, y + r.y); }
    vec2d operator * (double g) { return vec2d(x*g, y*g); }

    double operator * (const vec2d& r) { return (x*r.x + y*r.y); }

    double norm() { return sqrt(x*x + y*y); }
    double unit() { double R = sqrt(x*x + y*y); if (R != 0) {x /= R; y/= R; }; return R; }

    bool operator == (const vec2d& r) const { return (x==r.x)&&(y==r.y); }

public:
    double  x, y;
};

//-----------------------------------------------------------------------------
// class vec3d defines a 3D vector
//
class vec3d
{
public:
    vec3d() { x = y = z = 0; }
    vec3d(double rx, double ry, double rz) { x = rx; y = ry; z = rz; }
    vec3d(const vec2d& r) { x = r.x; y = r.y; z = 0; }

    vec3d operator + (const vec3d& v) const { return vec3d( x + v.x, y + v.y, z + v.z); }
    vec3d operator - (const vec3d& v) const { return vec3d( x - v.x, y - v.y, z - v.z); }
    vec3d operator ^ (const vec3d& v) const
    { 
        return vec3d( y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x); 
    }

    double operator * (const vec3d& v) const { return (x*v.x + y*v.y + z*v.z); }

    vec3d operator * (const double g) const { return vec3d(x*g, y*g, z*g); }
    vec3d operator / (const double g) const { return vec3d(x/g, y/g, z/g); }

    const vec3d& operator += (const vec3d& v) { x += v.x; y += v.y; z += v.z; return (*this); }
    const vec3d& operator -= (const vec3d& v) { x -= v.x; y -= v.y; z -= v.z; return (*this); }
    const vec3d& operator /= (const double f) { x /= f; y /= f; z /= f; return (*this); }
    const vec3d& operator /= (const int n) { x /= n; y /= n; z /= n; return (*this); }
    const vec3d& operator *= (const double f) { x*=f; y*=f; z*=f; return (*this); }

    vec3d operator - () const { return vec3d(-x, -y, -z); }

    double Length() const { return (double) sqrt(x*x + y*y + z*z); }
    double SqrLength() const { return x*x + y*y + z*z; }

    vec3d& Normalize()
    {
        double L = Length();
        if (L != 0) { x /= L; y /= L; z /= L; }

        return (*this);
    }

public:
    double x, y, z;
};

// vec6d

class vec6d
{
public:
    vec6d() { x = y = z = xy = yz = xz = 0; }

public:
    double x, y, z;
    double xy, yz, xz;
};


// mat3d

class mat3d
{
public:
    mat3d() 
    {
        zero();
    }

    mat3d(double a00, double a01, double a02, double a10, double a11, double a12, double a20, double a21, double a22);

    double* operator [] (int i) { return m_data[i]; }
    double& operator () (int i, int j) { return m_data[i][j]; }

    mat3d operator * (mat3d& m)
    {
        mat3d a;

        int k;
        for (k=0; k<3; k++)
        {
            a[0][0] += m_data[0][k]*m[k][0]; a[0][1] += m_data[0][k]*m[k][1]; a[0][2] += m_data[0][k]*m[k][2];
            a[1][0] += m_data[1][k]*m[k][0]; a[1][1] += m_data[1][k]*m[k][1]; a[1][2] += m_data[1][k]*m[k][2];
            a[2][0] += m_data[2][k]*m[k][0]; a[2][1] += m_data[2][k]*m[k][1]; a[2][2] += m_data[2][k]*m[k][2];
        }

        return a;
    }

    mat3d& operator *=(mat3d& m)
    {
        mat3d a;

        int k;
        for (k=0; k<3; k++)
        {
            a[0][0] += m_data[0][k]*m[k][0]; a[0][1] += m_data[0][k]*m[k][1]; a[0][2] += m_data[0][k]*m[k][2];
            a[1][0] += m_data[1][k]*m[k][0]; a[1][1] += m_data[1][k]*m[k][1]; a[1][2] += m_data[1][k]*m[k][2];
            a[2][0] += m_data[2][k]*m[k][0]; a[2][1] += m_data[2][k]*m[k][1]; a[2][2] += m_data[2][k]*m[k][2];
        }

        m_data[0][0] = a.m_data[0][0]; m_data[0][1] = a.m_data[0][1]; m_data[0][2] = a.m_data[0][2];
        m_data[1][0] = a.m_data[1][0]; m_data[1][1] = a.m_data[1][1]; m_data[1][2] = a.m_data[1][2];
        m_data[2][0] = a.m_data[2][0]; m_data[2][1] = a.m_data[2][1]; m_data[2][2] = a.m_data[2][2];

        return (*this);
    }

    mat3d& operator +=(mat3d& m)
    {
        m_data[0][0] += m[0][0]; m_data[0][1] += m[0][1]; m_data[0][2] += m[0][2];
        m_data[1][0] += m[1][0]; m_data[1][1] += m[1][1]; m_data[1][2] += m[1][2];
        m_data[2][0] += m[2][0]; m_data[2][1] += m[2][1]; m_data[2][2] += m[2][2];

        return (*this);
    }
    mat3d& operator -=(mat3d& m)
    {
        m_data[0][0] -= m[0][0]; m_data[0][1] -= m[0][1]; m_data[0][2] -= m[0][2];
        m_data[1][0] -= m[1][0]; m_data[1][1] -= m[1][1]; m_data[1][2] -= m[1][2];
        m_data[2][0] -= m[2][0]; m_data[2][1] -= m[2][1]; m_data[2][2] -= m[2][2];

        return (*this);
    }

    mat3d& operator /=(const double f)
    {
        m_data[0][0] /= f; m_data[0][1] /= f; m_data[0][2] /= f;
        m_data[1][0] /= f; m_data[1][1] /= f; m_data[1][2] /= f;
        m_data[2][0] /= f; m_data[2][1] /= f; m_data[2][2] /= f;

        return (*this);
    }

    vec3d operator * (vec3d b)
    {
        vec3d r;
        r.x = m_data[0][0]*b.x + m_data[0][1]*b.y + m_data[0][2]*b.z;
        r.y = m_data[1][0]*b.x + m_data[1][1]*b.y + m_data[1][2]*b.z;
        r.z = m_data[2][0]*b.x + m_data[2][1]*b.y + m_data[2][2]*b.z;

        return r;
    }

    double det() const
    {
        double det = 0;
        det += m_data[0][0]*m_data[1][1]*m_data[2][2];
        det += m_data[0][1]*m_data[1][2]*m_data[2][0];
        det += m_data[0][2]*m_data[1][0]*m_data[2][1];
        det -= m_data[0][2]*m_data[1][1]*m_data[2][0];
        det -= m_data[0][1]*m_data[1][0]*m_data[2][2];
        det -= m_data[0][0]*m_data[1][2]*m_data[2][1];
        return det;
    }

    double Invert();

    mat3d inverse() const;

    void zero()
    {
        m_data[0][0] = m_data[0][1] = m_data[0][2] = 0;
        m_data[1][0] = m_data[1][1] = m_data[1][2] = 0;
        m_data[2][0] = m_data[2][1] = m_data[2][2] = 0;
    }

    void unit()
    {
        m_data[0][0] = m_data[1][1] = m_data[2][2] = 1;
        m_data[0][1] = m_data[0][2] = m_data[1][2] = 0;
        m_data[1][0] = m_data[2][0] = m_data[2][1] = 0;
    }

    mat3d transpose();

protected:
    double  m_data[3][3];
};



// matrix

class matrix
{
public:
    matrix(int r, int c);
    ~matrix() { delete [] d; }

    void zero();

    double* operator [] (int i) { return d + i*m_nc; }
    double& operator () (int i, int j) { return d[i*m_nc + j]; }

    bool solve(vector<double>& x, vector<double>& b);

    bool lsq_solve(vector<double>& x, vector<double>& b);
    bool eigen_vectors(matrix& Eigen,vector<double>& eigen_values);
    int Rows() { return m_nr; }

    void mult_transpose(vector<double>& x, vector<double>& y);

    void mult_transpose_self(matrix& AAt);

private:
    double* d;
    int     m_nr, m_nc;
    int     m_ne;
};


// quatd

class quatd
{
public:
    // constructors
    quatd () { x = y = z = 0; w = 1; }

    quatd( const double angle, vec3d v)
    {
        w = (double) cos(angle * 0.5);

        double sina = (double) sin(angle * 0.5);

        v.Normalize();

        x = v.x*sina;
        y = v.y*sina;
        z = v.z*sina;
    }

    quatd (vec3d v1, vec3d v2)
    {
        vec3d n = v1^v2;
        n.Normalize();

        double d = v1*v2;

        double sina = (double) sqrt((1.0-d)*0.5);
        double cosa = (double) sqrt((1.0+d)*0.5);

        w = cosa;

        x = n.x*sina;
        y = n.y*sina;
        z = n.z*sina;

    }

    quatd(const double qx, const double qy, const double qz, const double qw = 1.0)
    {
        w = qw;
        x = qx;
        y = qy;
        z = qz;
    }

    bool operator != (const quatd& q) { return ((x!=q.x) || (y!=q.y) || (z!=q.z) || (w!=q.w)); }

    quatd operator - () { return quatd(-x, -y, -z, -w); }

    // addition and substraction

    quatd operator + (const quatd& q) const
    {
        return quatd(x + q.x, y + q.y, z + q.z, w + q.w);
    }

    quatd operator - (const quatd& q) const
    {
        return quatd(x - q.x, y - q.y, z - q.z, w - q.w);
    }

    quatd& operator += (const quatd& q)
    {
        x += q.x;
        y += q.y;
        z += q.z;
        w += q.w;

        return *this;
    }

    quatd& operator -= (const quatd& q)
    {
        x -= q.x;
        y -= q.y;
        z -= q.z;
        w -= q.w;

        return *this;
    }


    // multiplication

    quatd operator * (const quatd& q) const
    {
        double qw = w*q.w - x*q.x - y*q.y - z*q.z;
        double qx = w*q.x + x*q.w + y*q.z - z*q.y;
        double qy = w*q.y + y*q.w + z*q.x - x*q.z;
        double qz = w*q.z + z*q.w + x*q.y - y*q.x;

        return quatd(qx, qy, qz, qw);
    }

    quatd& operator *= (const quatd& q)
    {
        double qw = w*q.w - x*q.x - y*q.y - z*q.z;
        double qx = w*q.x + x*q.w + y*q.z - z*q.y;
        double qy = w*q.y + y*q.w + z*q.x - x*q.z;
        double qz = w*q.z + z*q.w + x*q.y - y*q.x;

        x = qx;
        y = qy;
        z = qz;
        w = qw;

        return *this;
    }

    quatd operator*(const double a) const
    {
        return quatd(x*a, y*a, z*a, w*a);
    }

    // division

    quatd operator / (const double a) const
    {
        return quatd(x/a, y/a, z/a, w/a);
    }

    quatd& operator /= (const double a)
    {
        x /= a;
        y /= a;
        z /= a;
        w /= a;

        return *this;
    }

    // Special ops

    quatd Conjugate() const { return quatd(-x, -y, -z, w); }

    double Norm() const { return w*w + x*x + y*y + z*z; } 

    void MakeUnit() 
    {
        double N = (double) sqrt(w*w + x*x + y*y + z*z);

        if (N != 0)
        {
            x /= N;
            y /= N;
            z /= N;
            w /= N;
        }
        else w = 1.f;
    }

    quatd Inverse() const
    {
        double N = w*w + x*x + y*y + z*z;

        return quatd(-x/N, -y/N, -z/N, w/N);
    }

    double DotProduct(const quatd& q) const
    {
        return w*q.w + x*q.x + y*q.y + z*q.z;
    }

    vec3d GetVector() const
    {
        return vec3d(x, y, z).Normalize();
    }

    double GetAngle() const
    {
        return (double)(acos(w)*2.0);
    }

/*  quatd& MultiplyAngle(double fa)
    {
        double angle = fa*acos(w)*2.0;

        w = cos(angle * 0.5);

        double sina = sin(angle * 0.5);

        x *= sina;
        y *= sina;
        z *= sina;
    }
*/


    // use only when *this is unit vector
    void RotateVector(vec3d& v) const
    {
        if ((w == 0) || ((x==0) && (y==0) && (z==0))) return;

        // v*q^-1
        double qw = v.x*x + v.y*y + v.z*z;
        double qx = v.x*w - v.y*z + v.z*y;
        double qy = v.y*w - v.z*x + v.x*z;
        double qz = v.z*w - v.x*y + v.y*x;

        // q* (v* q^-1)
        v.x = (double) (w*qx + x*qw + y*qz - z*qy);
        v.y = (double) (w*qy + y*qw + z*qx - x*qz);
        v.z = (double) (w*qz + z*qw + x*qy - y*qx);
    }

    // use only when *this is unit vector
    vec3d operator * (const vec3d& r)
    {
        vec3d n = r;

        // v*q^-1
        double qw = n.x*x + n.y*y + n.z*z;
        double qx = n.x*w - n.y*z + n.z*y;
        double qy = n.y*w - n.z*x + n.x*z;
        double qz = n.z*w - n.x*y + n.y*x;

        // q* (v* q^-1)
        n.x = (w*qx + x*qw + y*qz - z*qy);
        n.y = (w*qy + y*qw + z*qx - x*qz);
        n.z = (w*qz + z*qw + x*qy - y*qx);

        return n;
    }

    mat3d operator * (mat3d m)
    {
        mat3d a;
        double qw, qx, qy, qz;
        for (int i=0; i<3; ++i)
        {
            // v*q^-1
            qw = m[0][i]*x + m[1][i]*y + m[2][i]*z;
            qx = m[0][i]*w - m[1][i]*z + m[2][i]*y;
            qy = m[1][i]*w - m[2][i]*x + m[0][i]*z;
            qz = m[2][i]*w - m[0][i]*y + m[1][i]*x;

            // q* (v* q^-1)
            a[0][i] = (w*qx + x*qw + y*qz - z*qy);
            a[1][i] = (w*qy + y*qw + z*qx - x*qz);
            a[2][i] = (w*qz + z*qw + x*qy - y*qx);
        }

        return a;
    }

    void RotateVectorP(double* v, double* r) const
    {
        static double fx, fy, fz, fw;
        static double qw, qx, qy, qz;

        fx = (double) x;
        fy = (double) y;
        fz = (double) z;
        fw = (double) w;

        qw = v[0]*fx + v[1]*fy + v[2]*fz;
        qx = v[0]*fw - v[1]*fz + v[2]*fy;
        qy = v[1]*fw - v[2]*fx + v[0]*fz;
        qz = v[2]*fw - v[0]*fy + v[1]*fx;

        r[0] = (double) (fw*qx + fx*qw + fy*qz - fz*qy);
        r[1] = (double) (fw*qy + fy*qw + fz*qx - fx*qz);
        r[2] = (double) (fw*qz + fz*qw + fx*qy - fy*qx);
    }

    static double dot(quatd &q1, quatd &q2) 
    { return q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; }

    static quatd lerp(quatd &q1, quatd &q2, double t) 
    { quatd q = (q1*(1-t) + q2*t); q.MakeUnit(); return q; }

    static quatd slerp(quatd &q1, quatd &q2, double t) ;

public:
    double x, y, z;
    double w;
};

inline quatd operator * (const double a, const quatd& q)
{
    return q*a;
}

typedef unsigned char uchar;

class GLCOLOR
{
public:
    uchar   a, b, g, r;

public:
    GLCOLOR() : a(255), b(0), g(0), r(0){}
    GLCOLOR(uchar ur, uchar ug, uchar ub, uchar ua = 255)
    {
        r = ur; g = ug; b = ub; a = ua;
    }

    GLCOLOR operator * (double f)
    {
        return GLCOLOR((uchar) (r*f), (uchar) (g*f), (uchar) (b*f));
    }

    GLCOLOR operator + (GLCOLOR& c)
    {
        return GLCOLOR(r+c.r, g+c.g, b+c.b);
    }
};

Updated on 2024-07-14 at 17:07:25 +0000