Simplify ImageTrackerUtils.bestFitAspectRatioNDC()

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

 import { SpeedyPoint2 } from 'speedy-vision/types/core/speedy-point';
 import { SpeedyVector2 } from 'speedy-vision/types/core/speedy-vector';
 import { SpeedyKeypoint } from 'speedy-vision/types/core/speedy-keypoint';
-import { ImageTracker } from './image-tracker';
 import { ReferenceImageWithMedia } from './reference-image';
 import { Utils } from '../../utils/utils';
 import { IllegalOperationError, IllegalArgumentError, NumericalError } from '../../utils/errors';
 
     /**
      * Find the best-fit aspect ratio for the rectification of the reference image in NDC
-     * @param imageTracker
+     * @param screenSize
      * @param referenceImage
      * @returns a best-fit aspect ratio
      */
-    static bestFitAspectRatioNDC(imageTracker: ImageTracker, referenceImage: ReferenceImageWithMedia): number
+    static bestFitAspectRatioNDC(screenSize: SpeedySize, referenceImage: ReferenceImageWithMedia): number
     {
-        const screenSize = imageTracker.screenSize;
-        const screenAspectRatio = screenSize.width / screenSize.height;
-
         /*
         
         The best-fit aspectRatio (a) is constructed as follows:
 
         */
 
+        const screenAspectRatio = screenSize.width / screenSize.height;
         return referenceImage.aspectRatio / screenAspectRatio;
     }
 

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

 
         // rectify the image
         const scale = TRACK_RECTIFIED_SCALE;
-        const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this._imageTracker, this._referenceImage!);
+        const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(screenSize, this._referenceImage!);
         const shrink = ImageTrackerUtils.bestFitScaleNDC(aspectRatio, scale);
         const toScreen = ImageTrackerUtils.NDCToRaster(screenSize);
         const toNDC = ImageTrackerUtils.rasterToNDC(screenSize);

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

 import { ImageTracker, ImageTrackerOutput, ImageTrackerStateName } from '../image-tracker';
 import { ImageTrackerUtils, ImageTrackerKeypointPair } from '../image-tracker-utils';
 import { ImageTrackerState, ImageTrackerStateOutput } from './state';
-import { ReferenceImage } from '../reference-image';
+import { ReferenceImageWithMedia } from '../reference-image';
 import { Nullable, Utils } from '../../../utils/utils';
 import { TrackingError } from '../../../utils/errors';
 import {
 export class ImageTrackerPreTrackingBState extends ImageTrackerState
 {
     /** reference image */
-    private _referenceImage: Nullable<ReferenceImage>;
+    private _referenceImage: Nullable<ReferenceImageWithMedia>;
 
     /** a snapshot of the video from the scanning state and corresponding to the initial homography */
     private _snapshot: Nullable<SpeedyPipelineNodeImagePortalSink>;
     onEnterState(settings: Record<string,any>)
     {
         const homography = settings.homography as SpeedyMatrix;
-        const referenceImage = settings.referenceImage as ReferenceImage;
+        const referenceImage = settings.referenceImage as ReferenceImageWithMedia;
         const snapshot = settings.snapshot as SpeedyPipelineNodeImagePortalSink;
         const referenceKeypointPortalSink = settings.referenceKeypointPortalSink as SpeedyPipelineNodeKeypointPortalSink;
 
 
         // rectify the image
         const scale = TRACK_RECTIFIED_SCALE;
-        const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this._imageTracker, this._referenceImage!);
+        const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(screenSize, this._referenceImage!);
         const shrink = ImageTrackerUtils.bestFitScaleNDC(aspectRatio, scale);
         const undistort = this._homography.inverse();
         const toScreen = ImageTrackerUtils.NDCToRaster(screenSize);
         }).then(([ warp, score ]) => {
 
             const scale = TRACK_RECTIFIED_SCALE;
-            const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this._imageTracker, this._referenceImage!);
+            const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this.screenSize, this._referenceImage!);
             const shrink = ImageTrackerUtils.bestFitScaleNDC(aspectRatio, scale);
             const grow = ImageTrackerUtils.inverseBestFitScaleNDC(aspectRatio, scale);
             const scaledWarp = grow.times(warp).times(shrink);

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

 
         // rectify the image
         const scale = TRACK_RECTIFIED_SCALE;
-        const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this._imageTracker, this._referenceImage!);
+        const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(screenSize, this._referenceImage!);
         const shrink = ImageTrackerUtils.bestFitScaleNDC(aspectRatio, scale);
         const undistort = this._warpHomography.inverse();
         const toScreen = ImageTrackerUtils.NDCToRaster(screenSize);
         }).then(([ warp, score ]) => {
 
             const scale = TRACK_RECTIFIED_SCALE;
-            const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this._imageTracker, this._referenceImage!);
+            const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this.screenSize, this._referenceImage!);
             const shrink = ImageTrackerUtils.bestFitScaleNDC(aspectRatio, scale);
             const grow = ImageTrackerUtils.inverseBestFitScaleNDC(aspectRatio, scale);
             const scaledWarp = grow.times(warp).times(shrink);
         }).then(([ warp, score ]) => {
 
             const scale = TRACK_RECTIFIED_SCALE;
-            const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this._imageTracker, this._referenceImage!);
+            const aspectRatio = ImageTrackerUtils.bestFitAspectRatioNDC(this.screenSize, this._referenceImage!);
             const shrink = ImageTrackerUtils.bestFitScaleNDC(aspectRatio, scale);
             const grow = ImageTrackerUtils.inverseBestFitScaleNDC(aspectRatio, scale);
             const scaledWarp = grow.times(warp).times(shrink);