@srsergio/taptapp-ar 1.0.0

package/src/compiler/tracker/tracker.js

@@ -0,0 +1,397 @@
+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/src/compiler/utils/cumsum.js

@@ -0,0 +1,40 @@
+// 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/src/compiler/utils/geometry.js

@@ -0,0 +1,114 @@
+// 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/src/compiler/utils/homography.js

@@ -0,0 +1,150 @@
+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 };