@srsergio/taptapp-ar 1.0.0

package/dist/compiler/tracker/tracker.js

@@ -0,0 +1,327 @@
+import * as tf from "@tensorflow/tfjs";
+import { buildModelViewProjectionTransform, computeScreenCoordiate } from "../estimation/utils.js";
+const AR2_DEFAULT_TS = 6;
+const AR2_DEFAULT_TS_GAP = 1;
+const AR2_SEARCH_SIZE = 10;
+const AR2_SEARCH_GAP = 1;
+const AR2_SIM_THRESH = 0.8;
+const TRACKING_KEYFRAME = 1; // 0: 256px, 1: 128px
+// For some mobile device, only 16bit floating point texture is supported
+//   ref: https://www.tensorflow.org/js/guide/platform_environment#precision
+// Empirical results shows that modelViewProjectTransform can go up beyond that, resulting in error
+// We get around this by dividing the transform matrix by 1000, and then multiply back inside webgl program
+const PRECISION_ADJUST = 1000;
+class Tracker {
+    constructor(markerDimensions, trackingDataList, projectionTransform, inputWidth, inputHeight, debugMode = false) {
+        this.markerDimensions = markerDimensions;
+        this.trackingDataList = trackingDataList;
+        this.projectionTransform = projectionTransform;
+        this.debugMode = debugMode;
+        this.trackingKeyframeList = [];
+        for (let i = 0; i < trackingDataList.length; i++) {
+            this.trackingKeyframeList.push(trackingDataList[i][TRACKING_KEYFRAME]);
+        }
+        // prebuild feature and marker pixel tensors
+        let maxCount = 0;
+        for (let i = 0; i < this.trackingKeyframeList.length; i++) {
+            maxCount = Math.max(maxCount, this.trackingKeyframeList[i].points.length);
+        }
+        this.featurePointsListT = [];
+        this.imagePixelsListT = [];
+        this.imagePropertiesListT = [];
+        for (let i = 0; i < this.trackingKeyframeList.length; i++) {
+            const { featurePoints, imagePixels, imageProperties } = this._prebuild(this.trackingKeyframeList[i], maxCount);
+            this.featurePointsListT[i] = featurePoints;
+            this.imagePixelsListT[i] = imagePixels;
+            this.imagePropertiesListT[i] = imageProperties;
+        }
+        this.kernelCaches = {};
+    }
+    dummyRun(inputT) {
+        let transform = [
+            [1, 1, 1, 1],
+            [1, 1, 1, 1],
+            [1, 1, 1, 1],
+        ];
+        for (let targetIndex = 0; targetIndex < this.featurePointsListT.length; targetIndex++) {
+            this.track(inputT, transform, targetIndex);
+        }
+    }
+    track(inputImageT, lastModelViewTransform, targetIndex) {
+        let debugExtra = {};
+        const modelViewProjectionTransform = buildModelViewProjectionTransform(this.projectionTransform, lastModelViewTransform);
+        const modelViewProjectionTransformT = this._buildAdjustedModelViewTransform(modelViewProjectionTransform);
+        const markerWidth = this.markerDimensions[targetIndex][0];
+        const markerHeight = this.markerDimensions[targetIndex][1];
+        const keyframeWidth = this.trackingKeyframeList[targetIndex].width;
+        const keyframeHeight = this.trackingKeyframeList[targetIndex].height;
+        const featurePointsT = this.featurePointsListT[targetIndex];
+        const imagePixelsT = this.imagePixelsListT[targetIndex];
+        const imagePropertiesT = this.imagePropertiesListT[targetIndex];
+        const projectedImageT = this._computeProjection(modelViewProjectionTransformT, inputImageT, targetIndex);
+        const { matchingPointsT, simT } = this._computeMatching(featurePointsT, imagePixelsT, imagePropertiesT, projectedImageT);
+        const matchingPoints = matchingPointsT.arraySync();
+        const sim = simT.arraySync();
+        const trackingFrame = this.trackingKeyframeList[targetIndex];
+        const worldCoords = [];
+        const screenCoords = [];
+        const goodTrack = [];
+        for (let i = 0; i < matchingPoints.length; i++) {
+            if (sim[i] > AR2_SIM_THRESH && i < trackingFrame.points.length) {
+                goodTrack.push(i);
+                const point = computeScreenCoordiate(modelViewProjectionTransform, matchingPoints[i][0], matchingPoints[i][1]);
+                screenCoords.push(point);
+                worldCoords.push({
+                    x: trackingFrame.points[i].x / trackingFrame.scale,
+                    y: trackingFrame.points[i].y / trackingFrame.scale,
+                    z: 0,
+                });
+            }
+        }
+        if (this.debugMode) {
+            debugExtra = {
+                projectedImage: projectedImageT.arraySync(),
+                matchingPoints: matchingPointsT.arraySync(),
+                goodTrack,
+                trackedPoints: screenCoords,
+            };
+        }
+        // tensors cleanup
+        modelViewProjectionTransformT.dispose();
+        projectedImageT.dispose();
+        matchingPointsT.dispose();
+        simT.dispose();
+        return { worldCoords, screenCoords, debugExtra };
+    }
+    _computeMatching(featurePointsT, imagePixelsT, imagePropertiesT, projectedImageT) {
+        const templateOneSize = AR2_DEFAULT_TS;
+        const templateSize = templateOneSize * 2 + 1;
+        const templateGap = AR2_DEFAULT_TS_GAP;
+        const searchOneSize = AR2_SEARCH_SIZE * templateGap;
+        const searchGap = AR2_SEARCH_GAP;
+        const searchSize = searchOneSize * 2 + 1;
+        const targetHeight = projectedImageT.shape[0];
+        const targetWidth = projectedImageT.shape[1];
+        const featureCount = featurePointsT.shape[0];
+        if (!this.kernelCaches.computeMatching) {
+            const kernel1 = {
+                variableNames: ["features", "markerPixels", "markerProperties", "targetPixels"],
+                outputShape: [featureCount, searchSize * searchSize],
+                userCode: `
+	  void main() {
+	    ivec2 coords = getOutputCoords();
+
+	    int featureIndex = coords[0];
+	    int searchOffsetIndex = coords[1];
+
+	    int markerWidth = int(getMarkerProperties(0));
+	    int markerHeight = int(getMarkerProperties(1));
+	    float markerScale = getMarkerProperties(2);
+
+	    int searchOffsetX = imod(searchOffsetIndex, ${searchSize}) * ${searchGap};
+	    int searchOffsetY = searchOffsetIndex / ${searchSize} * ${searchGap};
+
+	    int sCenterX = int(getFeatures(featureIndex, 0) * markerScale);
+	    int sCenterY = int(getFeatures(featureIndex, 1) * markerScale);
+
+	    int sx = sCenterX + searchOffsetX - ${searchOneSize};
+	    int sy = sCenterY + searchOffsetY - ${searchOneSize};
+
+	    if (sx < ${templateOneSize} || sx >= (${targetWidth} - ${templateOneSize}) || sy < ${templateOneSize} || sy >= (${targetHeight} - ${templateOneSize})) {
+	      setOutput(-2.);
+	    } 
+	    else {
+	      float sumPoint = 0.;
+	      float sumPointSquare = 0.;
+	      float sumTemplate = 0.;
+	      float sumTemplateSquare = 0.;
+	      float sumPointTemplate = 0.;
+
+	      for (int templateOffsetY = 0; templateOffsetY < ${templateSize}; templateOffsetY++) {
+		for (int templateOffsetX = 0; templateOffsetX < ${templateSize}; templateOffsetX++) {
+		  int fx2 = sCenterX + templateOffsetX - ${templateOneSize};
+		  int fy2 = sCenterY + templateOffsetY - ${templateOneSize};
+
+		  int sx2 = sx + templateOffsetX - ${templateOneSize};
+		  int sy2 = sy + templateOffsetY - ${templateOneSize};
+
+		  int markerPixelIndex = fy2 * markerWidth + fx2;
+		  float markerPixel = getMarkerPixels(markerPixelIndex);
+		  float targetPixel = getTargetPixels(sy2, sx2);
+
+		  sumTemplate += markerPixel;
+		  sumTemplateSquare += markerPixel * markerPixel;
+		  sumPoint += targetPixel;
+		  sumPointSquare += targetPixel * targetPixel;
+		  sumPointTemplate += targetPixel * markerPixel;
+		}
+	      }
+
+	      // Normalized cross-correlation
+	      // !important divide first avoid overflow (e.g. sumPoint / count * sumPoint)
+	      float count = float(${templateSize} * ${templateSize});
+	      float pointVariance = sqrt(sumPointSquare - sumPoint / count * sumPoint);
+	      float templateVariance = sqrt(sumTemplateSquare - sumTemplate / count * sumTemplate);
+
+	      if (pointVariance < 0.0000001) {
+		setOutput(-3.);
+	      } else if (templateVariance < 0.0000001) {
+		//setOutput(sumTemplate);
+		setOutput(-4.);
+	      } else {
+		sumPointTemplate -= sumPoint / count * sumTemplate;
+		float sim = sumPointTemplate / pointVariance / templateVariance;  
+		setOutput(sim);
+	      }
+	    }
+	  }
+	`,
+            };
+            const kernel2 = {
+                variableNames: ["featurePoints", "markerProperties", "maxIndex"],
+                outputShape: [featureCount, 2], // [x, y]
+                userCode: `
+	  void main() {
+	    ivec2 coords = getOutputCoords();
+
+	    float markerScale = getMarkerProperties(2);
+
+	    int featureIndex = coords[0];
+
+	    int maxIndex = int(getMaxIndex(featureIndex));
+	    int searchLocationIndex = maxIndex / ${searchSize * searchSize};
+	    int searchOffsetIndex = imod(maxIndex, ${searchSize * searchSize});
+
+	    if (coords[1] == 0) {
+	      int searchOffsetX = imod(searchOffsetIndex, ${searchSize}) * ${searchGap};
+	      setOutput(getFeaturePoints(featureIndex, 0) + float(searchOffsetX - ${searchOneSize}) / markerScale);
+	    }
+	    else if (coords[1] == 1) {
+	      int searchOffsetY = searchOffsetIndex / ${searchSize} * ${searchGap};
+	      setOutput(getFeaturePoints(featureIndex, 1) + float(searchOffsetY - ${searchOneSize}) / markerScale);
+	    }
+	  }
+	`,
+            };
+            const kernel3 = {
+                variableNames: ["sims", "maxIndex"],
+                outputShape: [featureCount],
+                userCode: `
+	  void main() {
+	    int featureIndex = getOutputCoords();
+	    int maxIndex = int(getMaxIndex(featureIndex));
+	    setOutput(getSims(featureIndex, maxIndex));
+	  }
+	`,
+            };
+            this.kernelCaches.computeMatching = [kernel1, kernel2, kernel3];
+        }
+        return tf.tidy(() => {
+            const programs = this.kernelCaches.computeMatching;
+            const allSims = this._compileAndRun(programs[0], [
+                featurePointsT,
+                imagePixelsT,
+                imagePropertiesT,
+                projectedImageT,
+            ]);
+            const maxIndex = allSims.argMax(1);
+            const matchingPointsT = this._compileAndRun(programs[1], [
+                featurePointsT,
+                imagePropertiesT,
+                maxIndex,
+            ]);
+            const simT = this._compileAndRun(programs[2], [allSims, maxIndex]);
+            return { matchingPointsT, simT };
+        });
+    }
+    _computeProjection(modelViewProjectionTransformT, inputImageT, targetIndex) {
+        const markerWidth = this.trackingKeyframeList[targetIndex].width;
+        const markerHeight = this.trackingKeyframeList[targetIndex].height;
+        const markerScale = this.trackingKeyframeList[targetIndex].scale;
+        const kernelKey = markerWidth + "-" + markerHeight + "-" + markerScale;
+        if (!this.kernelCaches.computeProjection) {
+            this.kernelCaches.computeProjection = {};
+        }
+        if (!this.kernelCaches.computeProjection[kernelKey]) {
+            const kernel = {
+                variableNames: ["M", "pixel"],
+                outputShape: [markerHeight, markerWidth],
+                userCode: `
+	  void main() {
+	      ivec2 coords = getOutputCoords();
+
+	      float m00 = getM(0, 0) * ${PRECISION_ADJUST}.;
+	      float m01 = getM(0, 1) * ${PRECISION_ADJUST}.;
+	      float m03 = getM(0, 3) * ${PRECISION_ADJUST}.;
+	      float m10 = getM(1, 0) * ${PRECISION_ADJUST}.;
+	      float m11 = getM(1, 1) * ${PRECISION_ADJUST}.;
+	      float m13 = getM(1, 3) * ${PRECISION_ADJUST}.;
+	      float m20 = getM(2, 0) * ${PRECISION_ADJUST}.;
+	      float m21 = getM(2, 1) * ${PRECISION_ADJUST}.;
+	      float m23 = getM(2, 3) * ${PRECISION_ADJUST}.;
+
+	      float y = float(coords[0]) / float(${markerScale});
+	      float x = float(coords[1]) / float(${markerScale});
+	      float uz = (x * m20) + (y * m21) + m23;
+	      float oneOverUz = 1. / uz;
+
+	      float ux = (x * m00) + (y * m01) + m03;
+	      float uy = (x * m10) + (y * m11) + m13;
+
+	      ux = floor(ux * oneOverUz + 0.5);
+	      uy = floor(uy * oneOverUz + 0.5);
+	      setOutput(getPixel(int(uy), int(ux)));
+	    }
+	`,
+            };
+            this.kernelCaches.computeProjection[kernelKey] = kernel;
+        }
+        return tf.tidy(() => {
+            const program = this.kernelCaches.computeProjection[kernelKey];
+            const result = this._compileAndRun(program, [modelViewProjectionTransformT, inputImageT]);
+            return result;
+        });
+    }
+    _buildAdjustedModelViewTransform(modelViewProjectionTransform) {
+        return tf.tidy(() => {
+            let modelViewProjectionTransformAdjusted = [];
+            for (let i = 0; i < modelViewProjectionTransform.length; i++) {
+                modelViewProjectionTransformAdjusted.push([]);
+                for (let j = 0; j < modelViewProjectionTransform[i].length; j++) {
+                    modelViewProjectionTransformAdjusted[i].push(modelViewProjectionTransform[i][j] / PRECISION_ADJUST);
+                }
+            }
+            const t = tf.tensor(modelViewProjectionTransformAdjusted, [3, 4]);
+            return t;
+        });
+    }
+    _prebuild(trackingFrame, maxCount) {
+        return tf.tidy(() => {
+            const scale = trackingFrame.scale;
+            const p = [];
+            for (let k = 0; k < maxCount; k++) {
+                if (k < trackingFrame.points.length) {
+                    p.push([trackingFrame.points[k].x / scale, trackingFrame.points[k].y / scale]);
+                }
+                else {
+                    p.push([-1, -1]);
+                }
+            }
+            const imagePixels = tf.tensor(trackingFrame.data, [
+                trackingFrame.width * trackingFrame.height,
+            ]);
+            const imageProperties = tf.tensor([trackingFrame.width, trackingFrame.height, trackingFrame.scale], [3]);
+            const featurePoints = tf.tensor(p, [p.length, 2], "float32");
+            return {
+                featurePoints,
+                imagePixels,
+                imageProperties,
+            };
+        });
+    }
+    _compileAndRun(program, inputs) {
+        const outInfo = tf.backend().compileAndRun(program, inputs);
+        return tf.engine().makeTensorFromDataId(outInfo.dataId, outInfo.shape, outInfo.dtype);
+    }
+}
+export { Tracker };

package/dist/compiler/utils/cumsum.d.ts

@@ -0,0 +1,5 @@
+export class Cumsum {
+    constructor(data: any, width: any, height: any);
+    cumsum: never[][];
+    query(x1: any, y1: any, x2: any, y2: any): any;
+}

package/dist/compiler/utils/cumsum.js

@@ -0,0 +1,39 @@
+// fast 2D submatrix sum using cumulative sum algorithm
+class Cumsum {
+    constructor(data, width, height) {
+        this.cumsum = [];
+        for (let j = 0; j < height; j++) {
+            this.cumsum.push([]);
+            for (let i = 0; i < width; i++) {
+                this.cumsum[j].push(0);
+            }
+        }
+        this.cumsum[0][0] = data[0];
+        for (let i = 1; i < width; i++) {
+            this.cumsum[0][i] = this.cumsum[0][i - 1] + data[i];
+        }
+        for (let j = 1; j < height; j++) {
+            this.cumsum[j][0] = this.cumsum[j - 1][0] + data[j * width];
+        }
+        for (let j = 1; j < height; j++) {
+            for (let i = 1; i < width; i++) {
+                this.cumsum[j][i] =
+                    data[j * width + i] +
+                        this.cumsum[j - 1][i] +
+                        this.cumsum[j][i - 1] -
+                        this.cumsum[j - 1][i - 1];
+            }
+        }
+    }
+    query(x1, y1, x2, y2) {
+        let ret = this.cumsum[y2][x2];
+        if (y1 > 0)
+            ret -= this.cumsum[y1 - 1][x2];
+        if (x1 > 0)
+            ret -= this.cumsum[y2][x1 - 1];
+        if (x1 > 0 && y1 > 0)
+            ret += this.cumsum[y1 - 1][x1 - 1];
+        return ret;
+    }
+}
+export { Cumsum };

package/dist/compiler/utils/geometry.d.ts

@@ -0,0 +1,8 @@
+export function matrixInverse33(A: any, threshold: any): number[] | null;
+export function matrixMul33(A: any, B: any): number[];
+export function quadrilateralConvex(x1: any, x2: any, x3: any, x4: any): boolean;
+export function smallestTriangleArea(x1: any, x2: any, x3: any, x4: any): number;
+export function multiplyPointHomographyInhomogenous(x: any, H: any): number[];
+export function checkThreePointsConsistent(x1: any, x2: any, x3: any, x1p: any, x2p: any, x3p: any): boolean;
+export function checkFourPointsConsistent(x1: any, x2: any, x3: any, x4: any, x1p: any, x2p: any, x3p: any, x4p: any): boolean;
+export function determinant(A: any): number;

package/dist/compiler/utils/geometry.js

@@ -0,0 +1,101 @@
+// check which side point C on the line from A to B
+const linePointSide = (A, B, C) => {
+    return (B[0] - A[0]) * (C[1] - A[1]) - (B[1] - A[1]) * (C[0] - A[0]);
+};
+// srcPoints, dstPoints: array of four elements [x, y]
+const checkFourPointsConsistent = (x1, x2, x3, x4, x1p, x2p, x3p, x4p) => {
+    if (linePointSide(x1, x2, x3) > 0 !== linePointSide(x1p, x2p, x3p) > 0)
+        return false;
+    if (linePointSide(x2, x3, x4) > 0 !== linePointSide(x2p, x3p, x4p) > 0)
+        return false;
+    if (linePointSide(x3, x4, x1) > 0 !== linePointSide(x3p, x4p, x1p) > 0)
+        return false;
+    if (linePointSide(x4, x1, x2) > 0 !== linePointSide(x4p, x1p, x2p) > 0)
+        return false;
+    return true;
+};
+const checkThreePointsConsistent = (x1, x2, x3, x1p, x2p, x3p) => {
+    if (linePointSide(x1, x2, x3) > 0 !== linePointSide(x1p, x2p, x3p) > 0)
+        return false;
+    return true;
+};
+const determinant = (A) => {
+    const C1 = A[4] * A[8] - A[5] * A[7];
+    const C2 = A[3] * A[8] - A[5] * A[6];
+    const C3 = A[3] * A[7] - A[4] * A[6];
+    return A[0] * C1 - A[1] * C2 + A[2] * C3;
+};
+const matrixInverse33 = (A, threshold) => {
+    const det = determinant(A);
+    if (Math.abs(det) <= threshold)
+        return null;
+    const oneOver = 1.0 / det;
+    const B = [
+        (A[4] * A[8] - A[5] * A[7]) * oneOver,
+        (A[2] * A[7] - A[1] * A[8]) * oneOver,
+        (A[1] * A[5] - A[2] * A[4]) * oneOver,
+        (A[5] * A[6] - A[3] * A[8]) * oneOver,
+        (A[0] * A[8] - A[2] * A[6]) * oneOver,
+        (A[2] * A[3] - A[0] * A[5]) * oneOver,
+        (A[3] * A[7] - A[4] * A[6]) * oneOver,
+        (A[1] * A[6] - A[0] * A[7]) * oneOver,
+        (A[0] * A[4] - A[1] * A[3]) * oneOver,
+    ];
+    return B;
+};
+const matrixMul33 = (A, B) => {
+    const C = [];
+    C[0] = A[0] * B[0] + A[1] * B[3] + A[2] * B[6];
+    C[1] = A[0] * B[1] + A[1] * B[4] + A[2] * B[7];
+    C[2] = A[0] * B[2] + A[1] * B[5] + A[2] * B[8];
+    C[3] = A[3] * B[0] + A[4] * B[3] + A[5] * B[6];
+    C[4] = A[3] * B[1] + A[4] * B[4] + A[5] * B[7];
+    C[5] = A[3] * B[2] + A[4] * B[5] + A[5] * B[8];
+    C[6] = A[6] * B[0] + A[7] * B[3] + A[8] * B[6];
+    C[7] = A[6] * B[1] + A[7] * B[4] + A[8] * B[7];
+    C[8] = A[6] * B[2] + A[7] * B[5] + A[8] * B[8];
+    return C;
+};
+const multiplyPointHomographyInhomogenous = (x, H) => {
+    const w = H[6] * x[0] + H[7] * x[1] + H[8];
+    const xp = [];
+    xp[0] = (H[0] * x[0] + H[1] * x[1] + H[2]) / w;
+    xp[1] = (H[3] * x[0] + H[4] * x[1] + H[5]) / w;
+    return xp;
+};
+const smallestTriangleArea = (x1, x2, x3, x4) => {
+    const v12 = _vector(x2, x1);
+    const v13 = _vector(x3, x1);
+    const v14 = _vector(x4, x1);
+    const v32 = _vector(x2, x3);
+    const v34 = _vector(x4, x3);
+    const a1 = _areaOfTriangle(v12, v13);
+    const a2 = _areaOfTriangle(v13, v14);
+    const a3 = _areaOfTriangle(v12, v14);
+    const a4 = _areaOfTriangle(v32, v34);
+    return Math.min(Math.min(Math.min(a1, a2), a3), a4);
+};
+// check if four points form a convex quadrilaternal.
+// all four combinations should have same sign
+const quadrilateralConvex = (x1, x2, x3, x4) => {
+    const first = linePointSide(x1, x2, x3) <= 0;
+    if (linePointSide(x2, x3, x4) <= 0 !== first)
+        return false;
+    if (linePointSide(x3, x4, x1) <= 0 !== first)
+        return false;
+    if (linePointSide(x4, x1, x2) <= 0 !== first)
+        return false;
+    //if (linePointSide(x1, x2, x3) <= 0) return false;
+    //if (linePointSide(x2, x3, x4) <= 0) return false;
+    //if (linePointSide(x3, x4, x1) <= 0) return false;
+    //if (linePointSide(x4, x1, x2) <= 0) return false;
+    return true;
+};
+const _vector = (a, b) => {
+    return [a[0] - b[0], a[1] - b[1]];
+};
+const _areaOfTriangle = (u, v) => {
+    const a = u[0] * v[1] - u[1] * v[0];
+    return Math.abs(a) * 0.5;
+};
+export { matrixInverse33, matrixMul33, quadrilateralConvex, smallestTriangleArea, multiplyPointHomographyInhomogenous, checkThreePointsConsistent, checkFourPointsConsistent, determinant, };

package/dist/compiler/utils/homography.d.ts

@@ -0,0 +1 @@
+export function solveHomography(srcPoints: any, dstPoints: any): any[] | null;

package/dist/compiler/utils/homography.js

@@ -0,0 +1,138 @@
+import { Matrix, inverse } from "ml-matrix";
+const solveHomography = (srcPoints, dstPoints) => {
+    const { normPoints: normSrcPoints, param: srcParam } = _normalizePoints(srcPoints);
+    const { normPoints: normDstPoints, param: dstParam } = _normalizePoints(dstPoints);
+    const num = normDstPoints.length;
+    const AData = [];
+    const BData = [];
+    for (let j = 0; j < num; j++) {
+        const row1 = [
+            normSrcPoints[j][0],
+            normSrcPoints[j][1],
+            1,
+            0,
+            0,
+            0,
+            -(normSrcPoints[j][0] * normDstPoints[j][0]),
+            -(normSrcPoints[j][1] * normDstPoints[j][0]),
+        ];
+        const row2 = [
+            0,
+            0,
+            0,
+            normSrcPoints[j][0],
+            normSrcPoints[j][1],
+            1,
+            -(normSrcPoints[j][0] * normDstPoints[j][1]),
+            -(normSrcPoints[j][1] * normDstPoints[j][1]),
+        ];
+        AData.push(row1);
+        AData.push(row2);
+        BData.push([normDstPoints[j][0]]);
+        BData.push([normDstPoints[j][1]]);
+    }
+    try {
+        const A = new Matrix(AData);
+        const B = new Matrix(BData);
+        const AT = A.transpose();
+        const ATA = AT.mmul(A);
+        const ATB = AT.mmul(B);
+        const ATAInv = inverse(ATA);
+        const C = ATAInv.mmul(ATB).to1DArray();
+        const H = _denormalizeHomography(C, srcParam, dstParam);
+        return H;
+    }
+    catch (e) {
+        return null;
+    }
+};
+// centroid at origin and avg distance from origin is sqrt(2)
+const _normalizePoints = (coords) => {
+    //return {normalizedCoords: coords, param: {meanX: 0, meanY: 0, s: 1}}; // skip normalization
+    let sumX = 0;
+    let sumY = 0;
+    for (let i = 0; i < coords.length; i++) {
+        sumX += coords[i][0];
+        sumY += coords[i][1];
+    }
+    let meanX = sumX / coords.length;
+    let meanY = sumY / coords.length;
+    let sumDiff = 0;
+    for (let i = 0; i < coords.length; i++) {
+        const diffX = coords[i][0] - meanX;
+        const diffY = coords[i][1] - meanY;
+        sumDiff += Math.sqrt(diffX * diffX + diffY * diffY);
+    }
+    let s = (Math.sqrt(2) * coords.length) / sumDiff;
+    const normPoints = [];
+    for (let i = 0; i < coords.length; i++) {
+        normPoints.push([(coords[i][0] - meanX) * s, (coords[i][1] - meanY) * s]);
+    }
+    return { normPoints, param: { meanX, meanY, s } };
+};
+// Denormalize homography
+// where T is the normalization matrix, i.e.
+//
+//     [1  0  -meanX]
+// T = [0  1  -meanY]
+//     [0  0     1/s]
+//
+//          [1  0  s*meanX]
+// inv(T) = [0  1  s*meanY]
+// 	    [0  0        s]
+//
+// H = inv(Tdst) * Hn * Tsrc
+//
+// @param {
+//   nH: normH,
+//   srcParam: param of src transform,
+//   dstParam: param of dst transform
+// }
+const _denormalizeHomography = (nH, srcParam, dstParam) => {
+    /*
+    Matrix version
+    const normH = new Matrix([
+      [nH[0], nH[1], nH[2]],
+      [nH[3], nH[4], nH[5]],
+      [nH[6], nH[7], 1],
+    ]);
+    const Tsrc = new Matrix([
+      [1, 0, -srcParam.meanX],
+      [0, 1, -srcParam.meanY],
+      [0, 0,    1/srcParam.s],
+    ]);
+  
+    const invTdst = new Matrix([
+      [1, 0, dstParam.s * dstParam.meanX],
+      [0, 1, dstParam.s * dstParam.meanY],
+      [0, 0, dstParam.s],
+    ]);
+    const H = invTdst.mmul(normH).mmul(Tsrc);
+    */
+    // plain implementation of the above using Matrix
+    const sMeanX = dstParam.s * dstParam.meanX;
+    const sMeanY = dstParam.s * dstParam.meanY;
+    const H = [
+        nH[0] + sMeanX * nH[6],
+        nH[1] + sMeanX * nH[7],
+        (nH[0] + sMeanX * nH[6]) * -srcParam.meanX +
+            (nH[1] + sMeanX * nH[7]) * -srcParam.meanY +
+            (nH[2] + sMeanX) / srcParam.s,
+        nH[3] + sMeanY * nH[6],
+        nH[4] + sMeanY * nH[7],
+        (nH[3] + sMeanY * nH[6]) * -srcParam.meanX +
+            (nH[4] + sMeanY * nH[7]) * -srcParam.meanY +
+            (nH[5] + sMeanY) / srcParam.s,
+        dstParam.s * nH[6],
+        dstParam.s * nH[7],
+        dstParam.s * nH[6] * -srcParam.meanX +
+            dstParam.s * nH[7] * -srcParam.meanY +
+            dstParam.s / srcParam.s,
+    ];
+    // make H[8] === 1;
+    for (let i = 0; i < 9; i++) {
+        H[i] = H[i] / H[8];
+    }
+    return H;
+};
+export { solveHomography };

package/dist/compiler/utils/images.d.ts

@@ -0,0 +1,24 @@
+export function downsampleBilinear({ image }: {
+    image: any;
+}): {
+    data: Float32Array<ArrayBuffer>;
+    width: number;
+    height: number;
+};
+export function upsampleBilinear({ image, padOneWidth, padOneHeight }: {
+    image: any;
+    padOneWidth: any;
+    padOneHeight: any;
+}): {
+    data: Float32Array<ArrayBuffer>;
+    width: number;
+    height: number;
+};
+export function resize({ image, ratio }: {
+    image: any;
+    ratio: any;
+}): {
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+};