@srsergio/taptapp-ar 1.0.9 → 1.0.10

package/src/compiler/detector/kernels/cpu/fakeShader.js

@@ -1,88 +0,0 @@
-import { zeros, map, flatten as mathjsflatten } from "mathjs";
-/**
- * @typedef {Object} Kernel
- * @property {string[]} variableNames
- * @property {number[]} outputShape
- * @property {Function} userCode
- */
-
-/**
- *
- * @param {MathBackendCPU} backend
- * @param {Kernel} kernel
- * @param {Array<.TensorInfo>} inputs
- * @param {DataType} dtype
- * @returns {Tensor}
- */
-function runCode(backend, kernel, inputs, dtype) {
-  const inputData = inputs.map((value) => {
-    return backend.data.get(value.dataId).values;
-  });
-
-  //create getter functions for every variable name, clamping the input.
-  const tempData = {};
-  kernel.variableNames.forEach((name, index) => {
-    const funName = `get${capFirstLetter(name)}`;
-    //console.log("Making function:",funName,inputs[index].shape);
-    tempData[funName] = function (...args) {
-      const inputIndex = index;
-      for (let i = 0; i < args.length; i++) {
-        args[i] = clampInt(args[i], 0, inputs[inputIndex].shape[i]);
-      }
-      return inputData[index][flatten(args, inputs[inputIndex].shape)];
-    };
-  });
-  tempData.int = Math.trunc;
-  tempData.atan = Math.atan2;
-  //create an empty matrix to map the output size, because i'm lazy and want to use Matrix.map(...)
-  //const temp = new Matrix();
-  //console.log("Creating output shape:",kernel.outputShape);
-  const temp = zeros(kernel.outputShape); //reshape([0,0,0],kernel.outputShape);
-  const output = map(temp, (_value, index) => {
-    tempData.getOutputCoords = () => {
-      return index;
-    };
-    let out;
-
-    tempData.setOutput = (newValue) => {
-      out = Number.isNaN(newValue) ? 0 : Math.fround(newValue);
-    };
-    //bind the method calls and run the code
-    kernel.userCode.bind(tempData)();
-    return out;
-  });
-
-  //output.flat()
-  //convert the output from a matrix into a tensor
-
-  return backend.makeOutput(mathjsflatten(output), kernel.outputShape, dtype);
-}
-
-/**
- *
- * @param {string} word
- * @returns
- */
-function capFirstLetter(word) {
-  return word[0].toUpperCase() + word.substring(1);
-}
-
-function clampInt(n, min, max) {
-  return Math.min(Math.max(n, min), max - 1);
-}
-/**
- *
- * @param {number[]} input
- * @param {number[]} max
- * @returns
- */
-function flatten(input, max) {
-  return input.reduce((prev, current, index) => {
-    for (let i = index + 1; i < max.length; i++) {
-      current *= max[i];
-    }
-    return prev + current;
-  }, 0);
-}
-
-export { runCode };

package/src/compiler/detector/kernels/cpu/index.js

@@ -1,26 +0,0 @@
-import { registerKernel } from "@tensorflow/tfjs";
-import { binomialFilterConfig } from "./binomialFilter.js";
-import { buildExtremasConfig } from "./buildExtremas.js";
-import { computeExtremaAnglesConfig } from "./computeExtremaAngles.js";
-import { computeExtremaFreakConfig } from "./computeExtremaFreak.js";
-import { computeFreakDescriptorConfig } from "./computeFreakDescriptors.js";
-import { computeLocalizationConfig } from "./computeLocalization.js";
-import { computeOrientationHistogramsConfig } from "./computeOrientationHistograms.js";
-import { downsampleBilinearConfig } from "./downsampleBilinear.js";
-import { extremaReductionConfig } from "./extremaReduction.js";
-import { smoothHistogramsConfig } from "./smoothHistograms.js";
-import { upsampleBilinearConfig } from "./upsampleBilinear.js";
-
-//export function Register(){
-registerKernel(binomialFilterConfig);
-registerKernel(buildExtremasConfig);
-registerKernel(computeExtremaAnglesConfig);
-registerKernel(computeExtremaFreakConfig);
-registerKernel(computeFreakDescriptorConfig);
-registerKernel(computeLocalizationConfig);
-registerKernel(computeOrientationHistogramsConfig);
-registerKernel(downsampleBilinearConfig);
-registerKernel(extremaReductionConfig);
-registerKernel(smoothHistogramsConfig);
-registerKernel(upsampleBilinearConfig);
-//}

package/src/compiler/detector/kernels/cpu/prune.js

@@ -1,78 +0,0 @@
-
-function clamp(n, min, max) {
-  return Math.min(Math.max(min, n), max - 1);
-}
-
-const pruneImpl = (vals, width, height) => {
-  const w = Math.floor(width / 2);
-  const h = Math.floor(height / 2);
-  const resultValues = new Float32Array(w * h);
-  function getExtrema(x, y) {
-    x = clamp(x, 0, width);
-    y = clamp(y, 0, height);
-    return vals[y * width + x];
-  }
-  function setOutput(x, y, o) {
-    resultValues[y * width + x] = o;
-  }
-
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) {
-      const x2 = x * 2;
-      const y2 = y * 2;
-
-      let location = 0.0;
-      let values = getExtrema(x2, y2);
-
-      if (getExtrema(x2, y2 + 1) != 0.0) {
-        location = 1.0;
-        values = getExtrema(x2, y2 + 1);
-      } else if (getExtrema(x2 + 1, y2) != 0.0) {
-        location = 2.0;
-        values = getExtrema(x2 + 1, y2);
-      } else if (getExtrema(x2 + 1, y2 + 1) != 0.0) {
-        location = 3.0;
-        values = getExtrema(x2 + 1, y2 + 1);
-      }
-
-      if (values < 0.0) {
-        setOutput(x, y, location * -1000.0 + values);
-      } else {
-        setOutput(x, y, location * 1000.0 + values);
-      }
-    }
-  }
-  return resultValues;
-};
-
-const prune = (args) => {
-  /** @type {import('@tensorflow/tfjs').TensorInfo} */
-  const x = args.inputs.x;
-  /** @type {MathBackendCPU} */
-  const cpuBackend = args.backend;
-  const imageHeight = x.shape[0];
-  const imageWidth = x.shape[1];
-  /** @type {TypedArray} */
-  const values = cpuBackend.data.get(x.dataId).values;
-
-  const resultValues = pruneImpl(values, imageWidth, imageHeight);
-
-  return cpuBackend.makeOutput(
-    resultValues,
-    [Math.floor(imageHeight / 2), Math.floor(imageWidth / 2)],
-    "float32",
-  );
-};
-
-const pruneConfig = {
-  //: KernelConfig
-  kernelName: "Prune",
-  backendName: "cpu",
-  kernelFunc: prune, // as {} as KernelFunc,
-};
-
-export {
-  pruneConfig,
-  prune,
-  pruneImpl,
-};

package/src/compiler/detector/kernels/cpu/smoothHistograms.js

@@ -1,57 +0,0 @@
-const ORIENTATION_NUM_BINS = 36;
-const ORIENTATION_SMOOTHING_ITERATIONS = 5;
-
-function smoothHistogramsImpl(histograms) {
-  const resultValues = new Float32Array(histograms.height * ORIENTATION_NUM_BINS);
-  function getHistogram(y, x) {
-    return histograms.values[y * histograms.width + x];
-  }
-  function setOutput(y, x, o) {
-    resultValues[y * ORIENTATION_NUM_BINS + x] = o;
-  }
-  function imod(x, y) {
-    return Math.trunc(x - y * Math.floor(x / y));
-  }
-  for (let featureIndex = 0; featureIndex < histograms.height; featureIndex++) {
-    for (let binIndex = 0; binIndex < ORIENTATION_NUM_BINS; binIndex++) {
-      const prevBin = imod(binIndex - 1 + ORIENTATION_NUM_BINS, ORIENTATION_NUM_BINS);
-      const nextBin = imod(binIndex + 1, ORIENTATION_NUM_BINS);
-      const result =
-        0.274068619061197 * getHistogram(featureIndex, prevBin) +
-        0.451862761877606 * getHistogram(featureIndex, binIndex) +
-        0.274068619061197 * getHistogram(featureIndex, nextBin);
-
-      setOutput(featureIndex, binIndex, result);
-    }
-  }
-
-  return resultValues;
-}
-
-export const smoothHistograms = (args) => {
-  /** @type {import('@tensorflow/tfjs').TensorInfo} */
-  const { histograms } = args.inputs;
-  /** @type {MathBackendCPU} */
-  const backend = args.backend;
-  const histogramsData = {
-    values: backend.data.get(histograms.dataId).values,
-    height: histograms.shape[0],
-    width: histograms.shape[1],
-  };
-  //const program = GetProgram(histograms);
-  for (let i = 0; i < ORIENTATION_SMOOTHING_ITERATIONS; i++) {
-    histogramsData.values = smoothHistogramsImpl(histogramsData); //backend.runWebGLProgram(program, [histograms], histograms.dtype);//this._compileAndRun(program, [histograms]);
-  }
-  return backend.makeOutput(
-    histogramsData.values,
-    [histograms.shape[0], ORIENTATION_NUM_BINS],
-    histograms.dtype,
-  );
-};
-
-export const smoothHistogramsConfig = {
-  //: KernelConfig
-  kernelName: "SmoothHistograms",
-  backendName: "cpu",
-  kernelFunc: smoothHistograms, // as {} as KernelFunc,
-};

package/src/compiler/detector/kernels/cpu/upsampleBilinear.js

@@ -1,51 +0,0 @@
-import * as FakeShader from "./fakeShader.js";
-function getProgram(targetImage) {
-  const kernel = {
-    variableNames: ["p"],
-    outputShape: [targetImage.shape[0], targetImage.shape[1]],
-    userCode: function () {
-      const coords = this.getOutputCoords();
-      const j = coords[0];
-      const i = coords[1];
-
-      const sj = Math.fround(0.5 * j) - 0.25;
-      const si = Math.fround(0.5 * i) - 0.25;
-
-      const sj0 = Math.floor(sj);
-      const sj1 = Math.ceil(sj);
-      const si0 = Math.floor(si);
-      const si1 = Math.ceil(si);
-
-      const sj0I = this.int(sj0);
-      const sj1I = this.int(sj1);
-      const si0I = this.int(si0);
-      const si1I = this.int(si1);
-
-      let sum = 0.0;
-      sum += this.getP(sj0I, si0I) * Math.fround((si1 - si) * (sj1 - sj));
-      sum += this.getP(sj1I, si0I) * Math.fround((si1 - si) * (sj - sj0));
-      sum += this.getP(sj0I, si1I) * Math.fround((si - si0) * (sj1 - sj));
-      sum += this.getP(sj1I, si1I) * Math.fround((si - si0) * (sj - sj0));
-      this.setOutput(sum);
-    },
-  };
-  return kernel;
-}
-
-export const upsampleBilinear = (args) => {
-  /** @type {import('@tensorflow/tfjs').TensorInfo} */
-  const { image, targetImage } = args.inputs;
-
-  /** @type {MathBackendCPU} */
-  const cpuBackend = args.backend;
-
-  const program = getProgram(targetImage);
-  return FakeShader.runCode(cpuBackend, program, [image], image.dtype);
-};
-
-export const upsampleBilinearConfig = {
-  //: KernelConfig
-  kernelName: "UpsampleBilinear",
-  backendName: "cpu",
-  kernelFunc: upsampleBilinear, // as {} as KernelFunc,
-};

package/src/compiler/detector/kernels/index.js

@@ -1,2 +0,0 @@
-import "./webgl/index.js";
-import "./cpu/index.js";

package/src/compiler/detector/kernels/webgl/binomialFilter.js

@@ -1,72 +0,0 @@
-const cache = {};
-
-/**
- *
- * @param {string} key
- * @param {TensorInfo} image
- * @returns {[GPGPUProgram,GPGPUProgram]}
- */
-function GetKernels(image) {
-  const imageWidth = image.shape[1];
-  const imageHeight = image.shape[0];
-  const key = "w" + imageWidth + "h" + imageHeight;
-  if (!cache.hasOwnProperty(key)) {
-    const kernel1 = {
-      variableNames: ["p"],
-      outputShape: [imageHeight, imageWidth],
-      userCode: `
-        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);
-        }
-      `,
-    };
-    const kernel2 = {
-      variableNames: ["p"],
-      outputShape: [imageHeight, imageWidth],
-      userCode: `
-        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);
-        }
-      `,
-    };
-    cache[key] = [kernel1, kernel2];
-  }
-  return cache[key];
-}
-
-export const binomialFilter = (args) => {
-  //{inputs: UnaryInputs, backend: MathBackendCPU}
-  /** @type {import('@tensorflow/tfjs').TensorInfo} */
-  const image = args.inputs.image;
-  /** @type {MathBackendWebGL} */
-  const backend = args.backend;
-
-  const [kernel1, kernel2] = GetKernels(image);
-
-  const result1 = backend.runWebGLProgram(kernel1, [image], image.dtype);
-  const result2 = backend.runWebGLProgram(kernel2, [result1], image.dtype);
-  backend.disposeIntermediateTensorInfo(result1);
-  return result2;
-};
-
-export const binomialFilterConfig = {
-  //: KernelConfig
-  kernelName: "BinomialFilter",
-  backendName: "webgl",
-  kernelFunc: binomialFilter, // as {} as KernelFunc,
-};

package/src/compiler/detector/kernels/webgl/buildExtremas.js

@@ -1,109 +0,0 @@
-import { engine } from "@tensorflow/tfjs";
-
-const FREAK_EXPANSION_FACTOR = 7.0;
-
-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 cache = {};
-function GetProgram(image) {
-  const imageWidth = image.shape[1];
-  const imageHeight = image.shape[0];
-  const kernelKey = "w" + imageWidth + "h" + imageHeight;
-  if (!cache.hasOwnProperty(kernelKey)) {
-    const kernel = {
-      variableNames: ["image0", "image1", "image2"],
-      outputShape: [imageHeight, imageWidth],
-      userCode: `
-        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;
-          }
-    
-          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);
-    
-        if (value < value0 || value < value1 || value < value2) {
-          isMax = false;
-        }
-        if (value > value0 || value > value1 || value > value2) {
-          isMin = false;
-        }
-            }
-          }
-    
-          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 det = (dxx * dyy) - (dxy * dxy);
-    
-          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));
-        }
-      `,
-    };
-    cache[kernelKey] = kernel;
-  }
-  return cache[kernelKey];
-}
-
-export const buildExtremas = (args) => {
-  let { image0, image1, image2 } = args.inputs;
-  /** @type {MathBackendWebGL} */
-  const backend = args.backend;
-
-  const program = GetProgram(image1);
-
-  image0 = engine().runKernel("DownsampleBilinear", { image: image0 });
-  image2 = engine().runKernel("UpsampleBilinear", { image: image2, targetImage: image1 });
-  return backend.runWebGLProgram(program, [image0, image1, image2], image1.dtype);
-};
-
-export const buildExtremasConfig = {
-  //: KernelConfig
-  kernelName: "BuildExtremas",
-  backendName: "webgl",
-  kernelFunc: buildExtremas, // as {} as KernelFunc,
-};

package/src/compiler/detector/kernels/webgl/computeExtremaAngles.js

@@ -1,82 +0,0 @@
-const ORIENTATION_NUM_BINS = 36;
-
-const cache = {};
-function GetProgram(histograms) {
-  const key = histograms.shape[0];
-  if (!cache.hasOwnProperty(key)) {
-    const kernel = {
-      variableNames: ["histogram"],
-      outputShape: [histograms.shape[0]],
-      userCode: `
-            void main() {
-                int featureIndex = getOutputCoords();
-
-                int maxIndex = 0;
-                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});
-
-                /**
-                 * 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
-                 *
-                 * This system of equations is solved for A,B,C.
-                 */
-                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;
-
-                // 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;
-
-                // 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 an = 2.0 *${Math.PI} * (fbin + 0.5) / ${ORIENTATION_NUM_BINS}. - ${Math.PI};
-                setOutput(an);
-            }
-            `,
-    };
-    cache[key] = kernel;
-  }
-  return cache[key];
-}
-
-export const computeExtremaAngles = (args) => {
-  /** @type {import('@tensorflow/tfjs').TensorInfo} */
-  const { histograms } = args.inputs;
-  /** @type {MathBackendWebGL} */
-  const backend = args.backend;
-
-  const program = GetProgram(histograms);
-  return backend.runWebGLProgram(program, [histograms], histograms.dtype);
-};
-
-export const computeExtremaAnglesConfig = {
-  //: KernelConfig
-  kernelName: "ComputeExtremaAngles",
-  backendName: "webgl",
-  kernelFunc: computeExtremaAngles, // as {} as KernelFunc,
-};

package/src/compiler/detector/kernels/webgl/computeExtremaFreak.js

@@ -1,105 +0,0 @@
-import { FREAKPOINTS } from "../../freak.js";
-
-const FREAK_EXPANSION_FACTOR = 7.0;
-const cache = {};
-function GetProgram(imageCount, prunedExtremas) {
-  const key = `${imageCount}|${prunedExtremas.shape[0]}`;
-  if (!cache.hasOwnProperty(key)) {
-    const imageVariableNames = [];
-    for (let i = 1; i < imageCount; i++) {
-      imageVariableNames.push("image" + i);
-    }
-
-    let pixelsSubCodes = `float getPixel(int octave, int y, int x) {`;
-    for (let i = 1; i < imageCount; i++) {
-      pixelsSubCodes += `
-  if (octave == ${i}) {
-	return getImage${i}(y, x);
-  }
-`;
-    }
-    pixelsSubCodes += `}`;
-
-    const kernel = {
-      variableNames: [...imageVariableNames, "extrema", "angles", "freakPoints"],
-      outputShape: [prunedExtremas.shape[0], FREAKPOINTS.length],
-      userCode: `
-  ${pixelsSubCodes}
-  void main() {
-	ivec2 coords = getOutputCoords();
-	int featureIndex = coords[0];
-	int freakIndex = coords[1];
-
-	float freakSigma = getFreakPoints(freakIndex, 0);
-	float freakX = getFreakPoints(freakIndex, 1);
-	float freakY = getFreakPoints(freakIndex, 2);
-
-	int octave = int(getExtrema(featureIndex, 1));
-	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 yp = inputY + freakX * sin + freakY * cos;
-	float xp = inputX + freakX * cos + freakY * -sin;
-
-	int x0 = int(floor(xp));
-	int x1 = x0 + 1;
-	int y0 = int(floor(yp));
-	int y1 = y0 + 1;
-
-	float f1 = getPixel(octave, y0, x0);
-	float f2 = getPixel(octave, y0, x1);
-	float f3 = getPixel(octave, y1, x0);
-	float f4 = getPixel(octave, y1, x1);
-
-	float x1f = float(x1);
-	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);
-  }
-`,
-    };
-
-    cache[key] = kernel;
-  }
-
-  return cache[key];
-}
-
-export const computeExtremaFreak = (args) => {
-  /** @type {import('@tensorflow/tfjs').TensorInfo} */
-  const {
-    gaussianImagesT,
-    prunedExtremas,
-    prunedExtremasAngles,
-    freakPointsT,
-    pyramidImagesLength,
-  } = args.inputs;
-  /** @type {MathBackendWebGL} */
-  const backend = args.backend;
-
-  const program = GetProgram(pyramidImagesLength, prunedExtremas);
-
-  return backend.runWebGLProgram(
-    program,
-    [...gaussianImagesT, prunedExtremas, prunedExtremasAngles, freakPointsT],
-    "float32",
-  );
-};
-
-export const computeExtremaFreakConfig = {
-  //: KernelConfig
-  kernelName: "ComputeExtremaFreak",
-  backendName: "webgl",
-  kernelFunc: computeExtremaFreak, // as {} as KernelFunc,
-};