Increase the stability of the tracking

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

      * In its simplest form, it's similar to linear interpolation: src (1-alpha) + dest alpha
      * @param src homography
      * @param dest homography
-     * @param alpha interpolation factor in [0,1]
+     * @param alpha interpolation factor in [0,1] (1 means no interpolation)
      * @param beta correction strength for noisy corners (optional)
      * @param tau translation factor (optional)
      * @param omega rotational factor (optional)
         let tx = 0, ty = 0, sin = 0, cos = 1;
         const max = Math.max(d[0], d[1], d[2], d[3]); // max = Math.max(...d)
         const min = Math.min(d[0], d[1], d[2], d[3]);
+        //const quality = min / max;
+
+        // no change?
+        if(max < 1e-5)
+            return Speedy.Promise.resolve(Speedy.Matrix(dest));
+
         for(let i = 0, j = 0; i < 4; i++, j += 2) {
             const x = p[j], y = p[j+1];
 
             const bx = hbx/hbz, by = hby/hbz;
 
             // correct noisy corners, if any
-            if(d[i] == min && min <= 0.5 * max) {
+            if(d[i] == min) {
                 // we take the min for the translation
                 // because there may be noisy corners
                 tx = bx - ax;

src/trackers/image-tracker/settings.ts

 export const TRACK_RECTIFIED_SCALE = 1 - 2 * TRACK_RECTIFIED_BORDER;
 
 /** Reprojection error, in NIS pixels, used when estimating a motion model (tracking state) */
-export const TRACK_RANSAC_REPROJECTIONERROR_NIS = (NIS_SIZE * 0.0125 * 0.5) | 0;
+export const TRACK_RANSAC_REPROJECTIONERROR_NIS = (NIS_SIZE * 0.0125) | 0;
 
 /** Reprojection error, in NDC, used when estimating a motion model (tracking state) */
 export const TRACK_RANSAC_REPROJECTIONERROR_NDC = TRACK_RANSAC_REPROJECTIONERROR_NIS / (NIS_SIZE / 2);
 export const TRACK_GRID_GRANULARITY = 15; //20; //10; // the value of N
 
 /** Used to identify the best maches */
-export const TRACK_MATCH_RATIO = 0.65; // usually a value in [0.6, 0.8] - low values => strict tracking
+export const TRACK_MATCH_RATIO = 0.7; // usually a value in [0.6, 0.8] - low values => strict tracking
 
 /** Number of consecutive frames in which we tolerate a  "target lost" situation */
-export const TRACK_LOST_TOLERANCE = 15;
+export const TRACK_LOST_TOLERANCE = 20; //15;
 
 /** Interpolation filter: interpolation factor */
-export const TRACK_FILTER_ALPHA = 0.2;
+export const TRACK_FILTER_ALPHA = 0.3;
 
 /** Interpolation filter: correction strength for noisy corners */
 export const TRACK_FILTER_BETA = 1;
 
 /** Interpolation filter: translation factor */
-export const TRACK_FILTER_TAU = 0.2;
+export const TRACK_FILTER_TAU = 0;
 
 /** Interpolation filter: rotational factor */
-export const TRACK_FILTER_OMEGA = 0.05; // keep it zero or close to zero
+export const TRACK_FILTER_OMEGA = 0; // keep it zero or close to zero

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

         })
         .then(warpMotion => {
 
+            // apply filter
+            return ImageTrackerUtils.interpolateHomographies(
+                NO_MOTION,
+                Speedy.Matrix(warpMotion),
+                TRACK_FILTER_ALPHA,
+                TRACK_FILTER_BETA,
+                TRACK_FILTER_TAU,
+                TRACK_FILTER_OMEGA
+            );
+
+        })
+        .then(warpMotion => {
+
+            // update warp homography
+            this._warpHomography.setToSync(warpMotion.times(this._warpHomography));
+            return this._warpHomography;
+
+            /*
             const lowPower = (Settings.powerPreference == 'low-power');
             const delay = NUMBER_OF_PBOS * (!lowPower ? 2 : 1);
 
             // apply filter
             return ImageTrackerUtils.interpolateHomographies(
                 this._poseHomography,
-                Speedy.Matrix(warpMotion.times(this._warpHomography)),
-                TRACK_FILTER_ALPHA,
-                TRACK_FILTER_BETA,
-                TRACK_FILTER_TAU,
-                TRACK_FILTER_OMEGA
+                this._warpHomography,
+                0.4,//TRACK_FILTER_ALPHA,
+                1,//TRACK_FILTER_BETA,
+                0.4,//TRACK_FILTER_TAU,
+                0.05,//TRACK_FILTER_OMEGA
             );
+            */
 
         })
         .then(filteredHomography => {
 
-            // update pose homography
-            this._poseHomography.setToSync(filteredHomography);
-            if(Number.isNaN(this._poseHomography.at(0,0)))
-                throw new NumericalError('Bad homography'); // normalize? 1 / h33
-
             /*
             // test
             console.log("WARP ", this._warpHomography.toString());
             console.log("FILT ", filteredHomography.toString());
             */
 
+            // update pose homography
+            this._poseHomography.setToSync(filteredHomography);
+            if(Number.isNaN(this._poseHomography.at(0,0)))
+                throw new NumericalError('Bad homography'); // normalize? 1 / h33
+
             // We transform the keypoints of the reference image to NDC as a
             // convenience. However, doing so distorts the aspect ratio. Here
             // we undo the distortion.