Tune the algorithm

src/trackers/image-tracker/image-tracker-utils.ts

             }
 
             // compute the interpolation factor t = t(alpha, beta)
-            // t is (clamped) alpha if beta is zero
+            // t is alpha if beta is zero
             const gamma = alpha * Math.pow(2, -beta);
             const f = 1 - Math.sqrt(d[i] / max); // f is zero when d[i] is max (hence, it minimizes t and contributes to src)
             const g = (alpha - gamma) * f + gamma; // gamma when f is zero; alpha when f is one
-            const t = Math.max(0, Math.min(g, 1)); // clamp
+            //const t = Math.max(0, Math.min(g, 1)); // clamp
+            const t = g; // allow extrapolation; don't clamp
             const _t = 1 - t;
 
-            // a (1-t) + b t
+            // a (1-t) + b t == a + (b-a) t
             q[ j ] = ax * _t + bx * t;
             q[j+1] = ay * _t + by * t;
         }

src/trackers/image-tracker/settings.ts

 export const PRE_TRACK_FILTER_BETA = 1;
 
 /** Maximum number of iterations in Pre-tracking B */
-export const PRE_TRACK_MAX_ITERATIONS = 6; // the less the interpolation factor, the more iterations are needed
+export const PRE_TRACK_MAX_ITERATIONS = 8; //6; // the less the interpolation factor, the more iterations are needed
 
 /** Minimum acceptable number of matched keypoints when in the tracking state */
 export const TRACK_MIN_MATCHES = 4;//10; //20;
 export const TRACK_LOST_TOLERANCE = 20; //15;
 
 /** Interpolation filter: interpolation factor */
-export const TRACK_FILTER_ALPHA = 0.3;
+export const TRACK_FILTER_ALPHA = 0.3; //0.4;
 
 /** Interpolation filter: correction strength for noisy corners */
 export const TRACK_FILTER_BETA = 1;
 export const TRACK_FILTER_TAU = 0;
 
 /** Interpolation filter: rotational factor */
-export const TRACK_FILTER_OMEGA = 0; // keep it zero or close to zero
+export const TRACK_FILTER_OMEGA = 0; // keep it zero or close to zero
+
+/** Extrapolation filter: extrapolation factor */
+export const TRACK_EXTRAPOLATION_ALPHA = 6;
+
+/** Extrapolation filter: correction strength for noisy corners */
+export const TRACK_EXTRAPOLATION_BETA = 1.33;

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

     TRACK_HARRIS_QUALITY, TRACK_DETECTOR_CAPACITY, TRACK_MAX_KEYPOINTS,
     TRACK_RANSAC_REPROJECTIONERROR_NDC, TRACK_MATCH_RATIO,
     TRACK_FILTER_ALPHA, TRACK_FILTER_BETA, TRACK_FILTER_TAU, TRACK_FILTER_OMEGA,
+    TRACK_EXTRAPOLATION_ALPHA, TRACK_EXTRAPOLATION_BETA,
     NIGHTVISION_QUALITY, SUBPIXEL_METHOD,
 } from '../settings';
 import { Settings } from '../../../core/settings';
     /** current homography (for computing the pose) */
     private _poseHomography: SpeedyMatrix;
 
+    /* previous homography */
+    private _prevHomography: SpeedyMatrix;
+
     /** initial keypoints (i.e., the keypoints we found when we first started tracking) */
     private _templateKeypoints: SpeedyKeypoint[];
 
         this._referenceImage = null;
         this._warpHomography = Speedy.Matrix.Eye(3);
         this._poseHomography = Speedy.Matrix.Eye(3);
+        this._prevHomography = Speedy.Matrix.Eye(3);
         this._templateKeypoints = [];
         this._initialScreenSize = Speedy.Size(1, 1);
         this._lastOutput = {};
 
         // set attributes
         this._referenceImage = referenceImage;
-        this._warpHomography = Speedy.Matrix(homography);
-        this._poseHomography = Speedy.Matrix(homography);
+        this._warpHomography.setToSync(homography);
+        this._poseHomography.setToSync(homography);
+        this._prevHomography.setToSync(homography);
         this._templateKeypoints = templateKeypoints;
         this._initialScreenSize = Speedy.Size(initialScreenSize.width, initialScreenSize.height);
         this._lastOutput = {};
         .then(warpMotion => {
 
             // update warp homography
+            this._prevHomography.setToSync(this._warpHomography);
             this._warpHomography.setToSync(warpMotion.times(this._warpHomography));
-            return this._warpHomography;
+            //return this._warpHomography;
+
+            // extrapolate to compensante a bit the delay introduced by the
+            // previous filter
+            return ImageTrackerUtils.interpolateHomographies(
+                this._prevHomography,
+                this._warpHomography,
+                TRACK_EXTRAPOLATION_ALPHA,
+                TRACK_EXTRAPOLATION_BETA
+            );
 
             /*
             const lowPower = (Settings.powerPreference == 'low-power');