Update the computation of the modelViewMatrix

src/geometry/camera-model.ts

@@ -315,25 +315,6 @@ export class CameraModel
     }
 
     /**
-     * The inverse of denormalizer()
-     * @returns 4x4 matrix
-     */
-    denormalizerInverse(): SpeedyMatrix
-    {
-        const w = this._screenSize.width / 2;
-        const h = this._screenSize.height / 2;
-        const d = Math.min(w, h);
-        const b = 1 / d;
-
-        return Speedy.Matrix(4, 4, [
-            b, 0, 0, 0,
-            0,-b, 0, 0,
-            0, 0,-b, 0,
-            -w*b, h*b, 0, 1,
-        ]);
-    }
-
-    /**
      * Size of the AR screen space, in pixels
      * @returns size in pixels
      */

src/geometry/pose.ts

@@ -22,34 +22,35 @@
 
 import Speedy from 'speedy-vision';
 import { SpeedyMatrix } from 'speedy-vision/types/core/speedy-matrix';
-import { RigidTransform } from './transform';
+import { RigidTransform, StandardTransform } from './transform';
 
 
 
 /**
  * A pose represents a position and an orientation in a 3D space
+ * (and sometimes a scale, too...)
  */
 export class Pose
 {
-    /** A rigid transform in 3D world space */
-    private _transform: RigidTransform;
+    /** A transform in 3D world space */
+    private _transform: StandardTransform;
 
 
 
     /**
      * Constructor
-     * @param transform a rigid transform in a 3D space (e.g., world space, viewer space or other)
+     * @param transform usually a rigid transform in a 3D space (e.g., world space, viewer space or other)
      */
-    constructor(transform: RigidTransform)
+    constructor(transform: StandardTransform)
     {
         this._transform = transform;
     }
 
     /**
-     * A rigid transform describing the position and the orientation
+     * A transform describing the position and the orientation
      * of the pose relative to the 3D space to which it belongs
      */
-    get transform(): RigidTransform
+    get transform(): StandardTransform
     {
         return this._transform;
     }

src/geometry/transform.ts

@@ -58,41 +58,84 @@ abstract class BaseTransform
 /**
  * An invertible 3D transformation
  */
-abstract class InvertibleTransform extends BaseTransform
+class InvertibleTransform extends BaseTransform
 {
-    abstract get inverse(): InvertibleTransform;
+    /**
+     * Constructor
+     * @param matrix a 4x4 matrix
+     */
+    constructor(matrix: SpeedyMatrix)
+    {
+        // WARNING: we do not check if the matrix actually encodes an invertible transform!
+        super(matrix);
+    }
+
+    /**
+     * The inverse of the transform
+     */
+    get inverse(): InvertibleTransform
+    {
+        const inverseMatrix = Speedy.Matrix(this._matrix.inverse());
+        return new InvertibleTransform(inverseMatrix);
+    }
 }
 
 /**
- * A 3D transformation described by position and orientation
+ * A 3D transformation described by translation, rotation and scale
  */
-export class RigidTransform extends InvertibleTransform
+export class StandardTransform extends InvertibleTransform
 {
-    // TODO: position and orientation attributes
+    // TODO: position, rotation and scale attributes
 
     /**
      * Constructor
      * @param matrix a 4x4 matrix
      */
-    private constructor(matrix: SpeedyMatrix)
+    constructor(matrix: SpeedyMatrix)
     {
+        // WARNING: we do not check if the matrix actually encodes a standard transform!
         super(matrix);
     }
 
     /**
-     * Create a new rigid transform using a pre-computed transformation matrix
-     * @param matrix a 4x4 matrix encoding a rigid transform
-     * @returns a new rigid transform
-     * @internal
+     * The inverse of the transform
+     */
+    get inverse(): StandardTransform
+    {
+        /*
+
+        The inverse of a 4x4 standard transform T * R * S...
+
+        [  RS  t  ]    is    [  ZR' -ZR't ]
+        [  0'  1  ]          [  0'    1   ]
+
+        where S is 3x3, R is 3x3, t is 3x1, 0' is 1x3 and Z is the inverse of S
+
+        */
+
+        return super.inverse as StandardTransform;
+    }
+}
+
+/**
+ * A 3D transformation described by position and orientation
+ */
+export class RigidTransform extends StandardTransform
+{
+    // TODO: position and rotation attributes (need to decompose the matrix)
+
+    /**
+     * Constructor
+     * @param matrix a 4x4 matrix
      */
-    static fromMatrix(matrix: SpeedyMatrix): RigidTransform
+    constructor(matrix: SpeedyMatrix)
     {
         // WARNING: we do not check if the matrix actually encodes a rigid transform!
-        return new RigidTransform(matrix);
+        super(matrix);
     }
 
     /**
-     * The inverse of the rigid transform
+     * The inverse of the transform
      */
     get inverse(): RigidTransform
     {

src/geometry/viewer-pose.ts

@@ -46,17 +46,10 @@ export class ViewerPose extends Pose
     {
         // compute the view matrix and its inverse in AR screen space
         const viewMatrix = ViewerPose._computeViewMatrix(camera);
-        const viewMatrixInverse = RigidTransform.fromMatrix(viewMatrix).inverse.matrix;
+        const inverseTransform = new RigidTransform(viewMatrix);
 
-        // perform a change of coordinates
-        const M = camera.denormalizer();
-        const W = camera.denormalizerInverse();
-        const myViewMatrix = Speedy.Matrix(viewMatrix.times(M));
-        const myViewMatrixInverse = Speedy.Matrix(W.times(viewMatrixInverse));
-
-        // create the viewer pose
-        super(RigidTransform.fromMatrix(myViewMatrixInverse));
-        this._viewMatrix = myViewMatrix;
+        super(inverseTransform.inverse);
+        this._viewMatrix = viewMatrix;
     }
 
     /**

src/geometry/viewer.ts

@@ -26,7 +26,7 @@ import { CameraModel } from './camera-model';
 import { Pose } from './pose';
 import { ViewerPose } from './viewer-pose';
 import { View, PerspectiveView } from './view';
-import { RigidTransform } from './transform';
+import { StandardTransform } from './transform';
 import { IllegalOperationError } from '../utils/errors';
 
 
@@ -97,7 +97,7 @@ export class Viewer
         const viewMatrix = this._pose.viewMatrix;
         const modelViewMatrix = Speedy.Matrix(viewMatrix.times(modelMatrix));
 
-        const transform = RigidTransform.fromMatrix(modelViewMatrix);
+        const transform = new StandardTransform(modelViewMatrix);
         return new Pose(transform);
     }
 }

src/trackers/image-tracker/states/tracking.ts

@@ -46,7 +46,7 @@ import { ReferenceImage } from '../reference-image';
 import { CameraModel } from '../../../geometry/camera-model';
 import { Viewer } from '../../../geometry/viewer';
 import { Pose } from '../../../geometry/pose';
-import { RigidTransform } from '../../../geometry/transform';
+import { RigidTransform, StandardTransform } from '../../../geometry/transform';
 import { IllegalOperationError, IllegalArgumentError, TrackingError } from '../../../utils/errors';
 import {
     TRACK_RECTIFIED_BORDER, TRACK_CLIPPING_BORDER, TRACK_MIN_MATCHES, TRACK_LOST_TOLERANCE,
@@ -70,12 +70,6 @@ const NUMBER_OF_PBOS = 2;
 /** Frame skipping; meaningful only when using turbo */
 const TURBO_SKIP = 2;
 
-/** An identity transform computed lazily */
-const identityTransform: () => RigidTransform = (() => {
-    let transform: Nullable<RigidTransform> = null;
-    return () => (transform = transform || RigidTransform.fromMatrix(Speedy.Matrix.Eye(4)));
-})();
-
 /** A pair (a,b) of arrays of keypoints such that keypoint a[i] is a match to keypoint b[i] for all i */
 type QualityMatches = [ SpeedyMatchedKeypoint[], SpeedyKeypoint[] ];
 
@@ -389,7 +383,11 @@ export class ImageTrackerTrackingState extends ImageTrackerState
         }).then(polyline => {
 
             // we let the target object be at the origin of the world space
-            const pose = new Pose(identityTransform());
+            // (identity transform). We also perform a change of coordinates,
+            // so that we move out from pixel space and into normalized space
+            const modelMatrix = this._camera.denormalizer(); // ~ "identity matrix"
+            const transform = new StandardTransform(modelMatrix);
+            const pose = new Pose(transform);
 
             // given the current state of the camera model, we get a viewer
             // compatible with the pose of the target