@srsergio/taptapp-ar 1.0.2 → 1.0.3

package/dist/compiler/detector/detector.js

@@ -5,20 +5,12 @@ import { FREAKPOINTS } from "./freak.js";
 import "./kernels/webgl/index.js";
 const PYRAMID_MIN_SIZE = 8;
 const PYRAMID_MAX_OCTAVE = 5;
-const LAPLACIAN_THRESHOLD = 3.0;
-const LAPLACIAN_SQR_THRESHOLD = LAPLACIAN_THRESHOLD * LAPLACIAN_THRESHOLD;
-const EDGE_THRESHOLD = 4.0;
-const EDGE_HESSIAN_THRESHOLD = ((EDGE_THRESHOLD + 1) * (EDGE_THRESHOLD + 1)) / EDGE_THRESHOLD;
 const NUM_BUCKETS_PER_DIMENSION = 10;
 const MAX_FEATURES_PER_BUCKET = 5;
-const NUM_BUCKETS = NUM_BUCKETS_PER_DIMENSION * NUM_BUCKETS_PER_DIMENSION;
-// total max feature points = NUM_BUCKETS * MAX_FEATURES_PER_BUCKET
-const ORIENTATION_NUM_BINS = 36;
-const ORIENTATION_SMOOTHING_ITERATIONS = 5;
+// total max feature points
 const ORIENTATION_GAUSSIAN_EXPANSION_FACTOR = 3.0;
 const ORIENTATION_REGION_EXPANSION_FACTOR = 1.5;
-const FREAK_EXPANSION_FACTOR = 7.0;
-const FREAK_CONPARISON_COUNT = ((FREAKPOINTS.length - 1) * FREAKPOINTS.length) / 2; // 666
+//const FREAK_CONPARISON_COUNT = ((FREAKPOINTS.length - 1) * FREAKPOINTS.length) / 2; // 666
 class Detector {
     constructor(width, height, debugMode = false) {
         this.debugMode = debugMode;
@@ -175,37 +167,36 @@ class Detector {
         const { positionT } = this.tensorCaches.computeFreakDescriptors;
         // encode 8 bits into one number
         // trying to encode 16 bits give wrong result in iOS. may integer precision issue
-        const descriptorCount = Math.ceil(FREAK_CONPARISON_COUNT / 8);
         /*
             if (!this.kernelCaches.computeFreakDescriptors) {
                 const kernel = {
                     variableNames: ['freak', 'p'],
                     outputShape: [extremaFreaks.shape[0], descriptorCount],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
             int featureIndex = coords[0];
             int descIndex = coords[1] * 8;
     
             int sum = 0;
-            for (int i = 0; i < 8; i++) {
-              if (descIndex + i >= ${FREAK_CONPARISON_COUNT}) {
+    for (int i = 0; i < 8; i++) {
+        if (descIndex + i >= ${ FREAK_CONPARISON_COUNT }) {
             continue;
-              }
+        }
     
               int p1 = int(getP(descIndex + i, 0));
               int p2 = int(getP(descIndex + i, 1));
     
               float v1 = getFreak(featureIndex, p1);
               float v2 = getFreak(featureIndex, p2);
-    
-              if (v1 < v2 + 0.01) {
-                sum += int(pow(2.0, float(7 - i)));
-              }
-            }
-            setOutput(float(sum));
-          }
-        `
+
+        if (v1 < v2 + 0.01) {
+            sum += int(pow(2.0, float(7 - i)));
+        }
+    }
+    setOutput(float(sum));
+}
+`
                 }
                 this.kernelCaches.computeFreakDescriptors = [kernel];
             }
@@ -237,22 +228,23 @@ class Detector {
                     imageVariableNames.push('image' + i);
                 }
     
-                let pixelsSubCodes = `float getPixel(int octave, int y, int x) {`;
+                let pixelsSubCodes = `float getPixel(int octave, int y, int x) {
+    `;
                 for (let i = 1; i < pyramidImagesT.length; i++) {
                     pixelsSubCodes += `
-          if (octave == ${i}) {
-            return getImage${i}(y, x);
-          }
-        `
+    if (octave == ${ i }) {
+        return getImage${ i } (y, x);
+    }
+    `
                 }
-                pixelsSubCodes += `}`;
+                pixelsSubCodes += `} `;
     
                 const kernel = {
                     variableNames: [...imageVariableNames, 'extrema', 'angles', 'freakPoints'],
                     outputShape: [prunedExtremas.shape[0], FREAKPOINTS.length],
                     userCode: `
-          ${pixelsSubCodes}
-          void main() {
+          ${ pixelsSubCodes }
+void main() {
             ivec2 coords = getOutputCoords();
             int featureIndex = coords[0];
             int freakIndex = coords[1];
@@ -265,8 +257,8 @@ class Detector {
             float inputY = getExtrema(featureIndex, 2);
             float inputX = getExtrema(featureIndex, 3);
             float inputAngle = getAngles(featureIndex);
-            float cos = ${FREAK_EXPANSION_FACTOR}. * cos(inputAngle);
-            float sin = ${FREAK_EXPANSION_FACTOR}. * sin(inputAngle);
+            float cos = ${ FREAK_EXPANSION_FACTOR }. * cos(inputAngle);
+            float sin = ${ FREAK_EXPANSION_FACTOR }. * sin(inputAngle);
     
             float yp = inputY + freakX * sin + freakY * cos;
             float xp = inputX + freakX * cos + freakY * -sin;
@@ -285,16 +277,16 @@ class Detector {
             float y1f = float(y1);
             float x0f = float(x0);
             float y0f = float(y0);
-    
+
             // ratio for interpolation between four neighbouring points
             float value = (x1f - xp) * (y1f - yp) * f1
-                + (xp - x0f) * (y1f - yp) * f2
-                + (x1f - xp) * (yp - y0f) * f3
-                + (xp - x0f) * (yp - y0f) * f4;
-    
-            setOutput(value);
-          }
-        `
+        + (xp - x0f) * (y1f - yp) * f2
+        + (x1f - xp) * (yp - y0f) * f3
+        + (xp - x0f) * (yp - y0f) * f4;
+
+    setOutput(value);
+}
+`
                 }
     
                 this.kernelCaches._computeExtremaFreak = [kernel];
@@ -323,56 +315,56 @@ class Detector {
                     variableNames: ['histogram'],
                     outputShape: [histograms.shape[0]],
                     userCode: `
-          void main() {
+void main() {
             int featureIndex = getOutputCoords();
     
             int maxIndex = 0;
-            for (int i = 1; i < ${ORIENTATION_NUM_BINS}; i++) {
-              if (getHistogram(featureIndex, i) > getHistogram(featureIndex, maxIndex)) {
+    for (int i = 1; i < ${ ORIENTATION_NUM_BINS }; i++) {
+        if (getHistogram(featureIndex, i) > getHistogram(featureIndex, maxIndex)) {
             maxIndex = i;
-              }
-            }
+        }
+    }
     
-            int prev = imod(maxIndex - 1 + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-            int next = imod(maxIndex + 1, ${ORIENTATION_NUM_BINS});
+            int prev = imod(maxIndex - 1 + ${ ORIENTATION_NUM_BINS }, ${ ORIENTATION_NUM_BINS });
+            int next = imod(maxIndex + 1, ${ ORIENTATION_NUM_BINS });
     
             **
-             * Fit a quatratic to 3 points. The system of equations is:
+             * Fit a quatratic to 3 points.The system of equations is:
              *
-             * y0 = A*x0^2 + B*x0 + C
-             * y1 = A*x1^2 + B*x1 + C
-             * y2 = A*x2^2 + B*x2 + C
+             * y0 = A * x0 ^ 2 + B * x0 + C
+        * y1 = A * x1 ^ 2 + B * x1 + C
+            * y2 = A * x2 ^ 2 + B * x2 + C
+                *
+             * This system of equations is solved for A, B, C.
              *
-             * This system of equations is solved for A,B,C.
-             *
-            float p10 = float(maxIndex - 1);
-            float p11 = getHistogram(featureIndex, prev);
+        float p10 = float(maxIndex - 1);
+        float p11 = getHistogram(featureIndex, prev);
             float p20 = float(maxIndex);
             float p21 = getHistogram(featureIndex, maxIndex);
             float p30 = float(maxIndex + 1);
             float p31 = getHistogram(featureIndex, next);
     
-            float d1 = (p30-p20)*(p30-p10);
-            float d2 = (p10-p20)*(p30-p10);
-            float d3 = p10-p20;
-    
+            float d1 = (p30 - p20) * (p30 - p10);
+            float d2 = (p10 - p20) * (p30 - p10);
+            float d3 = p10 - p20;
+
             // If any of the denominators are zero then, just use maxIndex.
                 float fbin = float(maxIndex);
-            if ( abs(d1) > 0.00001 && abs(d2) > 0.00001 && abs(d3) > 0.00001) {
-              float a = p10*p10;
-              float b = p20*p20;
-    
+    if (abs(d1) > 0.00001 && abs(d2) > 0.00001 && abs(d3) > 0.00001) {
+              float a = p10 * p10;
+              float b = p20 * p20;
+
               // Solve for the coefficients A,B,C
-              float A = ((p31-p21)/d1)-((p11-p21)/d2);
-              float B = ((p11-p21)+(A*(b-a)))/d3;
-              float C = p11-(A*a)-(B*p10);
-              fbin = -B / (2. * A);
-            }
+              float A = ((p31 - p21) / d1) - ((p11 - p21) / d2);
+              float B = ((p11 - p21) + (A * (b - a))) / d3;
+              float C = p11 - (A * a) - (B * p10);
+        fbin = -B / (2. * A);
+    }
     
-            float an = 2.0 *${Math.PI} * (fbin + 0.5) / ${ORIENTATION_NUM_BINS}. - ${Math.PI};
-            setOutput(an);
-          }
-        `
+            float an = 2.0 * ${ Math.PI } * (fbin + 0.5) / ${ ORIENTATION_NUM_BINS }.- ${ Math.PI };
+    setOutput(an);
+}
+`
                 }
                 this.kernelCaches.computeExtremaAngles = kernel;
             } */
@@ -390,7 +382,6 @@ class Detector {
      * @returns
      */
     _computeOrientationHistograms(prunedExtremasT, pyramidImagesT) {
-        const oneOver2PI = 0.159154943091895;
         const gaussianImagesT = [];
         for (let i = 1; i < pyramidImagesT.length; i++) {
             gaussianImagesT.push(pyramidImagesT[i][1]);
@@ -427,23 +418,24 @@ class Detector {
                     imageVariableNames.push('image' + i);
                 }
     
-                let kernel1SubCodes = `float getPixel(int octave, int y, int x) {`;
+                let kernel1SubCodes = `float getPixel(int octave, int y, int x) {
+    `;
                 for (let i = 1; i < pyramidImagesT.length; i++) {
                     kernel1SubCodes += `
-          if (octave == ${i}) {
-            return getImage${i}(y, x);
-          }
-        `
+    if (octave == ${ i }) {
+        return getImage${ i } (y, x);
+    }
+    `
                 }
-                kernel1SubCodes += `}`;
+                kernel1SubCodes += `} `;
     
                 const kernel1 = {
                     variableNames: [...imageVariableNames, 'extrema', 'radial'],
                     outputShape: [prunedExtremasT.shape[0], radialPropertiesT.shape[0], 2], // last dimension: [fbin, magnitude]
                     userCode: `
-          ${kernel1SubCodes}
-    
-          void main() {
+          ${ kernel1SubCodes }
+
+void main() {
             ivec3 coords = getOutputCoords();
             int featureIndex = coords[0];
             int radialIndex = coords[1];
@@ -460,61 +452,61 @@ class Detector {
             int xp = x + radialX;
             int yp = y + radialY;
     
-            float dy = getPixel(octave, yp+1, xp) - getPixel(octave, yp-1, xp);
-            float dx = getPixel(octave, yp, xp+1) - getPixel(octave, yp, xp-1);
-    
-            if (propertyIndex == 0) {
+            float dy = getPixel(octave, yp + 1, xp) - getPixel(octave, yp - 1, xp);
+            float dx = getPixel(octave, yp, xp + 1) - getPixel(octave, yp, xp - 1);
+
+    if (propertyIndex == 0) {
               // be careful that atan(0, 0) gives 1.57 instead of 0 (different from js), but doesn't matter here, coz magnitude is 0
               
-              float angle = atan(dy, dx) + ${Math.PI};
-              float fbin = angle * ${ORIENTATION_NUM_BINS}. * ${oneOver2PI};
-              setOutput(fbin);
-              return;
-            }
-    
-            if (propertyIndex == 1) {
+              float angle = atan(dy, dx) + ${ Math.PI };
+              float fbin = angle * ${ ORIENTATION_NUM_BINS }. * ${ oneOver2PI };
+        setOutput(fbin);
+        return;
+    }
+
+    if (propertyIndex == 1) {
               float mag = sqrt(dx * dx + dy * dy);
               float magnitude = radialW * mag;
-              setOutput(magnitude);
-              return;
-            }
-          }
-    
-        `
+        setOutput(magnitude);
+        return;
+    }
+}
+
+`
                 }
     
                 const kernel2 = {
                     variableNames: ['fbinMag'],
                     outputShape: [prunedExtremasT.shape[0], ORIENTATION_NUM_BINS],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
             int featureIndex = coords[0];
             int binIndex = coords[1];
     
             float sum = 0.;
-            for (int i = 0; i < ${radialPropertiesT.shape[0]}; i++) {
+    for (int i = 0; i < ${ radialPropertiesT.shape[0] }; i++) {
               float fbin = getFbinMag(featureIndex, i, 0);
               int bin = int(floor(fbin - 0.5));
-              int b1 = imod(bin + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-              int b2 = imod(bin + 1 + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-    
-              if (b1 == binIndex || b2 == binIndex) {
+              int b1 = imod(bin + ${ ORIENTATION_NUM_BINS }, ${ ORIENTATION_NUM_BINS });
+              int b2 = imod(bin + 1 + ${ ORIENTATION_NUM_BINS }, ${ ORIENTATION_NUM_BINS });
+
+        if (b1 == binIndex || b2 == binIndex) {
             float magnitude = getFbinMag(featureIndex, i, 1);
             float w2 = fbin - float(bin) - 0.5;
             float w1 = w2 * -1. + 1.;
-    
+
             if (b1 == binIndex) {
-              sum += w1 * magnitude;
+                sum += w1 * magnitude;
             }
             if (b2 == binIndex) {
-              sum += w2 * magnitude;
-            }
-              }
+                sum += w2 * magnitude;
             }
-            setOutput(sum);
-          }
-        `
+        }
+    }
+    setOutput(sum);
+}
+`
                 }
     
                 this.kernelCaches.computeOrientationHistograms = [kernel1, kernel2];
@@ -539,20 +531,20 @@ class Detector {
                     variableNames: ['histogram'],
                     outputShape: [histograms.shape[0], ORIENTATION_NUM_BINS],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
     
             int featureIndex = coords[0];
             int binIndex = coords[1];
     
-            int prevBin = imod(binIndex - 1 + ${ORIENTATION_NUM_BINS}, ${ORIENTATION_NUM_BINS});
-            int nextBin = imod(binIndex + 1, ${ORIENTATION_NUM_BINS});
+            int prevBin = imod(binIndex - 1 + ${ ORIENTATION_NUM_BINS }, ${ ORIENTATION_NUM_BINS });
+            int nextBin = imod(binIndex + 1, ${ ORIENTATION_NUM_BINS });
     
                 float result = 0.274068619061197 * getHistogram(featureIndex, prevBin) + 0.451862761877606 * getHistogram(featureIndex, binIndex) + 0.274068619061197 * getHistogram(featureIndex, nextBin);
-    
-            setOutput(result);
-          }
-        `
+
+    setOutput(result);
+}
+`
                 }
                 this.kernelCaches.smoothHistograms = kernel;
             } */
@@ -575,39 +567,40 @@ class Detector {
         /*  if (!this.kernelCaches.computeLocalization) {
                const dogVariableNames = [];
          
-               let dogSubCodes = `float getPixel(int octave, int y, int x) {`;
+               let dogSubCodes = `float getPixel(int octave, int y, int x) {
+    `;
                for (let i = 1; i < dogPyramidImagesT.length; i++) {  // extrema starts from second octave
              dogVariableNames.push('image' + i);
              dogSubCodes += `
-               if (octave == ${i}) {
-                 return getImage${i}(y, x);
-               }
-               `;
+    if (octave == ${ i }) {
+        return getImage${ i } (y, x);
+    }
+    `;
                }
-               dogSubCodes += `}`;
+               dogSubCodes += `} `;
          
                const kernel = {
              variableNames: [...dogVariableNames, 'extrema'],
              outputShape: [prunedExtremasList.length, 3, 3], // 3x3 pixels around the extrema
              userCode: `
-               ${dogSubCodes}
-         
-               void main() {
+               ${ dogSubCodes }
+
+void main() {
                  ivec3 coords = getOutputCoords();
                  int featureIndex = coords[0];
                  float score = getExtrema(featureIndex, 0);
-                 if (score == 0.0) {
-                   return;
-                 }
+    if (score == 0.0) {
+        return;
+    }
          
-                 int dy = coords[1]-1;
-                 int dx = coords[2]-1;
+                 int dy = coords[1] - 1;
+                 int dx = coords[2] - 1;
                  int octave = int(getExtrema(featureIndex, 1));
                  int y = int(getExtrema(featureIndex, 2));
                  int x = int(getExtrema(featureIndex, 3));
-                 setOutput(getPixel(octave, y+dy, x+dx));
-               }
-             `
+    setOutput(getPixel(octave, y + dy, x + dx));
+}
+`
                }
          
                this.kernelCaches.computeLocalization = [kernel];
@@ -684,34 +677,34 @@ class Detector {
                     variableNames: ['extrema'],
                     outputShape: [Math.floor(extremaHeight/2), Math.floor(extremaWidth/2)],
                     userCode: `
-                        void main() {
+void main() {
                             ivec2 coords = getOutputCoords();
                             int y = coords[0] * 2;
                             int x = coords[1] * 2;
         
                             float location = 0.0;
                             float values = getExtrema(y, x);
-        
-                            if (getExtrema(y+1, x) != 0.0) {
-                                location = 1.0;
-                            values = getExtrema(y+1, x);
-                            }
-                            else if (getExtrema(y, x+1) != 0.0) {
-                                location = 2.0;
-                            values = getExtrema(y, x+1);
-                            }
-                            else if (getExtrema(y+1, x+1) != 0.0) {
-                                location = 3.0;
-                            values = getExtrema(y+1, x+1);
-                            }
-        
-                            if (values < 0.0) {
-                                setOutput(location * -1000.0 + values);
-                            } else {
-                                setOutput(location * 1000.0 + values);
-                            }
-                        }
-                    `
+
+    if (getExtrema(y + 1, x) != 0.0) {
+        location = 1.0;
+        values = getExtrema(y + 1, x);
+    }
+    else if (getExtrema(y, x + 1) != 0.0) {
+        location = 2.0;
+        values = getExtrema(y, x + 1);
+    }
+    else if (getExtrema(y + 1, x + 1) != 0.0) {
+        location = 3.0;
+        values = getExtrema(y + 1, x + 1);
+    }
+
+    if (values < 0.0) {
+        setOutput(location * -1000.0 + values);
+    } else {
+        setOutput(location * 1000.0 + values);
+    }
+}
+`
                 }
                 reductionKernels.push(kernel);
               }
@@ -803,71 +796,71 @@ class Detector {
                     variableNames: ['image0', 'image1', 'image2'],
                     outputShape: [imageHeight, imageWidth],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
     
             int y = coords[0];
             int x = coords[1];
     
             float value = getImage1(y, x);
-    
-            // Step 1: find local maxima/minima
-            if (value * value < ${LAPLACIAN_SQR_THRESHOLD}.) {
-              setOutput(0.);
-              return;
-            }
-            if (y < ${FREAK_EXPANSION_FACTOR} || y > ${imageHeight - 1 - FREAK_EXPANSION_FACTOR}) {
-              setOutput(0.);
-              return;
-            }
-            if (x < ${FREAK_EXPANSION_FACTOR} || x > ${imageWidth - 1 - FREAK_EXPANSION_FACTOR}) {
-              setOutput(0.);
-              return;
-            }
+
+    // Step 1: find local maxima/minima
+    if (value * value < ${ LAPLACIAN_SQR_THRESHOLD }.) {
+        setOutput(0.);
+        return;
+    }
+    if (y < ${ FREAK_EXPANSION_FACTOR } || y > ${ imageHeight - 1 - FREAK_EXPANSION_FACTOR }) {
+        setOutput(0.);
+        return;
+    }
+    if (x < ${ FREAK_EXPANSION_FACTOR } || x > ${ imageWidth - 1 - FREAK_EXPANSION_FACTOR }) {
+        setOutput(0.);
+        return;
+    }
     
             bool isMax = true;
             bool isMin = true;
-            for (int dy = -1; dy <= 1; dy++) {
-              for (int dx = -1; dx <= 1; dx++) {
-                float value0 = getImage0(y+dy, x+dx);
-                float value1 = getImage1(y+dy, x+dx);
-                float value2 = getImage2(y+dy, x+dx);
-    
+    for (int dy = -1; dy <= 1; dy++) {
+        for (int dx = -1; dx <= 1; dx++) {
+                float value0 = getImage0(y + dy, x + dx);
+                float value1 = getImage1(y + dy, x + dx);
+                float value2 = getImage2(y + dy, x + dx);
+
             if (value < value0 || value < value1 || value < value2) {
-              isMax = false;
+                isMax = false;
             }
             if (value > value0 || value > value1 || value > value2) {
-              isMin = false;
+                isMin = false;
             }
-              }
-            }
-    
-            if (!isMax && !isMin) {
-              setOutput(0.);
-              return;
-            }
-    
+        }
+    }
+
+    if (!isMax && !isMin) {
+        setOutput(0.);
+        return;
+    }
+
             // compute edge score and reject based on threshold
-            float dxx = getImage1(y, x+1) + getImage1(y, x-1) - 2. * getImage1(y, x);
-            float dyy = getImage1(y+1, x) + getImage1(y-1, x) - 2. * getImage1(y, x);
-            float dxy = 0.25 * (getImage1(y-1,x-1) + getImage1(y+1,x+1) - getImage1(y-1,x+1) - getImage1(y+1,x-1));
+            float dxx = getImage1(y, x + 1) + getImage1(y, x - 1) - 2. * getImage1(y, x);
+            float dyy = getImage1(y + 1, x) + getImage1(y - 1, x) - 2. * getImage1(y, x);
+            float dxy = 0.25 * (getImage1(y - 1, x - 1) + getImage1(y + 1, x + 1) - getImage1(y - 1, x + 1) - getImage1(y + 1, x - 1));
     
             float det = (dxx * dyy) - (dxy * dxy);
-    
-            if (abs(det) < 0.0001) { // determinant undefined. no solution
-              setOutput(0.);
-              return;
-            }
+
+    if (abs(det) < 0.0001) { // determinant undefined. no solution
+        setOutput(0.);
+        return;
+    }
     
             float edgeScore = (dxx + dyy) * (dxx + dyy) / det;
-    
-            if (abs(edgeScore) >= ${EDGE_HESSIAN_THRESHOLD} ) {
-              setOutput(0.);
-              return;
-            }
-            setOutput(getImage1(y,x));
-          }
-        `
+
+    if (abs(edgeScore) >= ${ EDGE_HESSIAN_THRESHOLD } ) {
+        setOutput(0.);
+        return;
+    }
+    setOutput(getImage1(y, x));
+}
+`
                 };
                 this.kernelCaches.buildExtremas[kernelKey] = kernel;
             } */
@@ -906,35 +899,35 @@ class Detector {
                     variableNames: ['p'],
                     outputShape: [imageHeight, imageWidth],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
     
-            float sum = getP(coords[0], coords[1]-2);
-            sum += getP(coords[0], coords[1]-1) * 4.;
-            sum += getP(coords[0], coords[1]) * 6.;
-            sum += getP(coords[0], coords[1]+1) * 4.;
-            sum += getP(coords[0], coords[1]+2);
-            setOutput(sum);
-          }
-        `
+            float sum = getP(coords[0], coords[1] - 2);
+    sum += getP(coords[0], coords[1] - 1) * 4.;
+    sum += getP(coords[0], coords[1]) * 6.;
+    sum += getP(coords[0], coords[1] + 1) * 4.;
+    sum += getP(coords[0], coords[1] + 2);
+    setOutput(sum);
+}
+`
                 };
     
                 const kernel2 = {
                     variableNames: ['p'],
                     outputShape: [imageHeight, imageWidth],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
     
-            float sum = getP(coords[0]-2, coords[1]);
-            sum += getP(coords[0]-1, coords[1]) * 4.;
-            sum += getP(coords[0], coords[1]) * 6.;
-            sum += getP(coords[0]+1, coords[1]) * 4.;
-            sum += getP(coords[0]+2, coords[1]);
-            sum /= 256.;
-            setOutput(sum);
-          }
-        `
+            float sum = getP(coords[0] - 2, coords[1]);
+    sum += getP(coords[0] - 1, coords[1]) * 4.;
+    sum += getP(coords[0], coords[1]) * 6.;
+    sum += getP(coords[0] + 1, coords[1]) * 4.;
+    sum += getP(coords[0] + 2, coords[1]);
+    sum /= 256.;
+    setOutput(sum);
+}
+`
                 };
                 this.kernelCaches.applyFilter[kernelKey] = [kernel1, kernel2];
             }
@@ -962,7 +955,7 @@ class Detector {
                   variableNames: ['p'],
                   outputShape: [targetImage.shape[0], targetImage.shape[1]],
                   userCode: `
-        void main() {
+void main() {
           ivec2 coords = getOutputCoords();
           int j = coords[0];
           int i = coords[1];
@@ -981,13 +974,13 @@ class Detector {
           int si1I = int(si1);
   
           float sum = 0.0;
-          sum += getP(sj0I, si0I) * (si1 - si) * (sj1 - sj);
-          sum += getP(sj1I, si0I) * (si1 - si) * (sj - sj0);
-          sum += getP(sj0I, si1I) * (si - si0) * (sj1 - sj);
-          sum += getP(sj1I, si1I) * (si - si0) * (sj - sj0);
-          setOutput(sum);
-        }
-      `
+    sum += getP(sj0I, si0I) * (si1 - si) * (sj1 - sj);
+    sum += getP(sj1I, si0I) * (si1 - si) * (sj - sj0);
+    sum += getP(sj0I, si1I) * (si - si0) * (sj1 - sj);
+    sum += getP(sj1I, si1I) * (si - si0) * (sj - sj0);
+    setOutput(sum);
+}
+`
               };
               this.kernelCaches.upsampleBilinear[kernelKey] = kernel;
           }
@@ -1011,18 +1004,18 @@ class Detector {
                     variableNames: ['p'],
                     outputShape: [Math.floor(imageHeight / 2), Math.floor(imageWidth / 2)],
                     userCode: `
-          void main() {
+void main() {
             ivec2 coords = getOutputCoords();
             int y = coords[0] * 2;
             int x = coords[1] * 2;
     
             float sum = getP(y, x) * 0.25;
-            sum += getP(y+1,x) * 0.25;
-            sum += getP(y, x+1) * 0.25;
-            sum += getP(y+1,x+1) * 0.25;
-            setOutput(sum);
-          }
-        `
+    sum += getP(y + 1, x) * 0.25;
+    sum += getP(y, x + 1) * 0.25;
+    sum += getP(y + 1, x + 1) * 0.25;
+    setOutput(sum);
+}
+`
                 };
                 this.kernelCaches.downsampleBilinear[kernelKey] = kernel;
             } */
@@ -1039,11 +1032,11 @@ class Detector {
      */
     _compileAndRun(program, inputs) {
         const outInfo = tf.backend().compileAndRun(program, inputs);
-        return tf.engine().makeTensorFromDataId(outInfo.dataId, outInfo.shape, outInfo.dtype);
+        return tf.engine().makeTensor(outInfo.dataId, outInfo.shape, outInfo.dtype);
     }
     _runWebGLProgram(program, inputs, outputType) {
         const outInfo = tf.backend().runWebGLProgram(program, inputs, outputType);
-        return tf.engine().makeTensorFromDataId(outInfo.dataId, outInfo.shape, outInfo.dtype);
+        return tf.engine().makeTensor(outInfo.dataId, outInfo.shape, outInfo.dtype);
     }
 }
 export { Detector };