glwidget: crude rewrite to simple-mat header

2 files changed, 63 insertions, 115 deletions

diff --git a/pose-widget/glwidget.cpp b/pose-widget/glwidget.cpp
index 07445c8a..b7aa0908 100644
--- a/pose-widget/glwidget.cpp
+++ b/pose-widget/glwidget.cpp
@@ -46,109 +46,109 @@ void GLWidget::rotateBy(double xAngle, double yAngle, double zAngle)
         c1*s3+c3*s1*s2,  c1*c3-s1*s2*s3,  -c2*s1,
         s1*s3-c1*c3*s2,  c3*s1+c1*s2*s3,  c1*c2,
     };
-
-    for (int i = 0; i < 9; i++)
-        matrix[i] = foo[i];
+    
+    matrix = rmat(foo);
 
     update();
 }
 
+
+static __inline double dot(const vec2& p1, const vec2& p2) {
+    return p1(0,0) * p2(0,0) + p1(1,0) * p2(1,0);
+}
+
 class Triangle {
 public:
-    Triangle(const Vec2f& p1,
-             const Vec2f& p2,
-             const Vec2f& p3)
+    Triangle(const vec2& p1,
+             const vec2& p2,
+             const vec2& p3)
     {
         origin = p1;
-        v0 = Vec2f(p3.x - p1.x, p3.y - p1.y);
-        v1 = Vec2f(p2.x - p1.x, p2.y - p1.y);
+        v0 = vec2({ p3(0,0) - p1(0,0), p3(1,0) - p1(1,0) });
+        v1 = vec2({ p2(0,0) - p1(0,0), p2(1,0) - p1(1,0) });
         dot00 = dot(v0, v0);
         dot01 = dot(v0, v1);
         dot11 = dot(v1, v1);
         invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
     }
-    bool barycentric_coords(const Vec2f& px, Vec2f& uv) const
+    bool barycentric_coords(const vec2& px, vec2& uv) const
     {
-        Vec2f v2(px.x - origin.x, px.y - origin.y);
+        vec2 v2({ px(0,0) - origin(0,0), px(1,0) - origin(1,0) });
         double dot12 = dot(v1, v2);
         double dot02 = dot(v0, v2);
         double u = (dot11 * dot02 - dot01 * dot12) * invDenom;
         double v = (dot00 * dot12 - dot01 * dot02) * invDenom;
-        uv.x = u;
-        uv.y = v;
+        uv = vec2({u, v});
         return (u >= 0) && (v >= 0) && (u + v <= 1);
     }
     
 private:
     double dot00, dot01, dot11, invDenom;
-    Vec2f v0, v1, origin;
-    double dot(const Vec2f& p1, const Vec2f& p2) const {
-        return p1.x * p2.x + p1.y * p2.y;
-    }
+    vec2 v0, v1, origin;
 };
 
-static __inline Vec3f cross(const Vec3f& p1, const Vec3f& p2)
+static __inline vec3 cross(const vec3& p1, const vec3& p2)
 {
-    return Vec3f(p1.y * p2.z - p2.y * p1.z,
-                 p2.x * p1.z - p1.x * p2.z,
-                 p1.x * p2.y - p1.y * p2.x);
+    return vec3({p1(1,0) * p2(2,0) - p2(1,0) * p1(2,0),
+                 p2(0,0) * p1(2,0) - p1(0,0) * p2(2,0),
+                 p1(0,0) * p2(1,0) - p1(1,0) * p2(0,0)});
 }
 
-static __inline Vec3f normal(const Vec3f& p1, const Vec3f& p2, const Vec3f& p3)
+static __inline vec3 normal(const vec3& p1, const vec3& p2, const vec3& p3)
 {
-    Vec3f u(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z);
-    Vec3f v(p3.x - p1.x, p3.y - p1.y, p3.z - p1.z);
+    vec3 u({p2(0,0) - p1(0,0), p2(1,0) - p1(1,0), p2(2,0) - p1(2,0)});
+    vec3 v({p3(0,0) - p1(0,0), p3(1,0) - p1(1,0), p3(2,0) - p1(2,0)});
      
-    Vec3f tmp = cross(u, v);
+    vec3 tmp = cross(u, v);
     
-    double i = 1./sqrt(tmp.x * tmp.x + tmp.y * tmp.y + tmp.z * tmp.z);
+    double i = 1./sqrt(tmp(0,0) * tmp(0,0) + tmp(1,0) * tmp(1,0) + tmp(2,0) * tmp(2,0));
     
-    return Vec3f(i * tmp.x, i * tmp.y, i * tmp.z);
+    return vec3({i * tmp(0,0), i * tmp(1,0), i * tmp(2,0)});
 }
 
 void GLWidget::project_quad_texture() {
     const int sx = width(), sy = height();
-    Point pt[4];
-    static Vec3f corners[] = {
-        Vec3f(0, 0, 0),
-        Vec3f(sx-1, 0, 0),
-        Vec3f(0, sy-1, 0),
-        Vec3f(sx-1, sy-1, 0)
+    vec2 pt[4];
+    static vec3 corners[] = {
+        vec3({0., 0., 0.}),
+        vec3({sx-1., 0., 0.}),
+        vec3({0., sy-1., 0.}),
+        vec3({sx-1., sy-1., 0.})
     };
     
     for (int i = 0; i < 4; i++) {
-        pt[i] = project(Vec3f(corners[i].x - sx/2, corners[i].y - sy/2, 0));
-        pt[i].x += sx/2;
-        pt[i].y += sy/2;
+        pt[i] = project(vec3({corners[i](0,0) - sx/2., corners[i](1,0) - sy/2., 0}));
+        pt[i](0, 0) += sx/2.;
+        pt[i](1, 0) += sy/2.;
     }
     
-    Vec3f normal1(0, 0, 1);
-    Vec3f normal2;
+    vec3 normal1({0, 0, 1});
+    vec3 normal2;
     {
-        Vec3f foo[3];
+        vec3 foo[3];
         for (int i = 0; i < 3; i++)
             foo[i] = project2(corners[i]);
         normal2 = normal(foo[0], foo[1], foo[2]);
     }
     
-    double dir = normal1.x * normal2.x + normal1.y * normal2.y + normal1.z * normal2.z;
+    double dir = normal1(0,0) * normal2(0,0) + normal1(1,0) * normal2(1,0) + normal1(2,0) * normal2(2,0);
     
     QImage& tex = dir < 0 ? back : front;
     
     int ow = tex.width(), oh = tex.height();
        
-    Vec2f p2[4];
+    vec2 p2[4];
 
     for (int i = 0; i < 4; i++)
-        p2[i] = Vec2f(pt[i].x, pt[i].y);
+        p2[i] = vec2({pt[i](0,0), pt[i](1,0)});
     QImage texture(QSize(sx, sy), QImage::Format_RGB888);
     QColor bgColor = palette().color(QPalette::Current, QPalette::Window);
     texture.fill(bgColor);
     
-    const Vec2f projected[2][3] = { { p2[0], p2[1], p2[2] }, { p2[3], p2[1], p2[2] } };
-    const Vec2f origs[2][3] = {
-        { Vec2f(0, 0), Vec2f(ow-1, 0), Vec2f(0, oh-1) },
-        { Vec2f(ow-1, oh-1), Vec2f(ow-1, 0), Vec2f(0, oh-1) }
+    const vec2 projected[2][3] = { { p2[0], p2[1], p2[2] }, { p2[3], p2[1], p2[2] } };
+    const vec2 origs[2][3] = {
+        { vec2({0., 0.}), vec2({ow-1., 0.}), vec2({0., oh-1.}) },
+        { vec2({ow-1., oh-1.}), vec2({ow-1., 0.}), vec2({0., oh-1.}) }
     };
     const Triangle triangles[2] = {
         Triangle(projected[0][0], projected[0][1], projected[0][2]),
@@ -170,19 +170,17 @@ void GLWidget::project_quad_texture() {
 
     for (int y = 0; y < sy; y++)
         for (int x = 0; x < sx; x++) {
-            Vec2f pos;
-            pos.x = x;
-            pos.y = y;
+            vec2 pos({(double)x, (double)y});
             for (int i = 0; i < 2; i++) {
-                Vec2f coords;
+                vec2 coords;
                 if (triangles[i].barycentric_coords(pos, coords))
                 {
-                    int px = origs[i][0].x
-                            + coords.x * (origs[i][2].x - origs[i][0].x)
-                            + coords.y * (origs[i][1].x - origs[i][0].x);
-                    int py = origs[i][0].y
-                            + coords.x * (origs[i][2].y - origs[i][0].y)
-                            + coords.y * (origs[i][1].y - origs[i][0].y);
+                    int px = origs[i][0](0,0)
+                            + coords(0,0) * (origs[i][2](0,0) - origs[i][0](0,0))
+                            + coords(1,0) * (origs[i][1](0,0) - origs[i][0](0,0));
+                    int py = origs[i][0](1,0)
+                            + coords(0,0) * (origs[i][2](1,0) - origs[i][0](1,0))
+                            + coords(1,0) * (origs[i][1](1,0) - origs[i][0](1,0));
                     int r = orig[py * orig_pitch + px * orig_depth + 2];
                     int g = orig[py * orig_pitch + px * orig_depth + 1];
                     int b = orig[py * orig_pitch + px * orig_depth + 0];
diff --git a/pose-widget/glwidget.h b/pose-widget/glwidget.h
index 43a0f853..b4756120 100644
--- a/pose-widget/glwidget.h
+++ b/pose-widget/glwidget.h
@@ -10,42 +10,11 @@
 #include <QWidget>
 #include <QPixmap>
 #include "opentrack/plugin-api.hpp"
+#include "opentrack/simple-mat.hpp"
 
-struct Point {
-    Point(int x, int y) :
-            x(x), y(y)
-    {
-    }
-    Point() :
-            x(0), y(0)
-    {
-    }
-    int x, y;
-};
-
-struct Vec3f {
-    double x, y, z;
-    Vec3f(double x, double y, double z) :
-            x(x), y(y), z(z)
-    {
-    }
-    Vec3f() :
-            x(0), y(0), z(0)
-    {
-    }
-};
-
-struct Vec2f {
-    double x, y;
-    Vec2f(double x, double y) :
-            x(x), y(y)
-    {
-    }
-    Vec2f() :
-            x(0), y(0)
-    {
-    }
-};
+typedef dmat<2, 1> vec2;
+typedef dmat<3, 1> vec3;
+typedef dmat<3, 3> rmat;
 
 class GLWidget : public QWidget
 {
@@ -56,34 +25,15 @@ public:
 protected:
     void paintEvent ( QPaintEvent * event ) override;
 private:
-    Point project(const Vec3f& point) {
-        Point rect;
-
-        rect.x = point.x * matrix[0]
-                 + point.y * matrix[1]
-                 + point.z * matrix[2];
-        rect.y = point.x * matrix[3]
-                 + point.y * matrix[4]
-                 + point.z * matrix[5];
-
-        return rect;
+    vec2 project(const vec3& point) {
+        vec3 ret = matrix * point;
+        return vec2 { ret(0, 0), ret(1, 0) };
     }
-    Vec3f project2(const Vec3f& point) {
-        Vec3f rect;
-
-        rect.x = point.x * matrix[0]
-                 + point.y * matrix[1]
-                 + point.z * matrix[2];
-        rect.y = point.x * matrix[3]
-                 + point.y * matrix[4]
-                 + point.z * matrix[5];
-        rect.z = point.x * matrix[6]
-                 + point.y * matrix[7]
-                 + point.z * matrix[8];
-        return rect;
+    vec3 project2(const vec3& point) {
+        return matrix * point;
     }
     void project_quad_texture();
-    double matrix[9];
+    rmat matrix;
     QImage front;
     QImage back;
     QImage texture;