@srsergio/taptapp-ar 1.0.9 → 1.0.10

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

@@ -1,80 +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/dist/compiler/detector/kernels/cpu/index.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,25 +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/dist/compiler/detector/kernels/cpu/prune.d.ts

@@ -1,7 +0,0 @@
-export namespace pruneConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { prune as kernelFunc };
-}
-export function prune(args: any): any;
-export function pruneImpl(vals: any, width: any, height: any): Float32Array<ArrayBuffer>;

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

@@ -1,62 +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/dist/compiler/detector/kernels/cpu/smoothHistograms.d.ts

@@ -1,6 +0,0 @@
-export function smoothHistograms(args: any): any;
-export namespace smoothHistogramsConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { smoothHistograms as kernelFunc };
-}

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

@@ -1,47 +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/dist/compiler/detector/kernels/cpu/upsampleBilinear.d.ts

@@ -1,6 +0,0 @@
-export function upsampleBilinear(args: any): Tensor;
-export namespace upsampleBilinearConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { upsampleBilinear as kernelFunc };
-}

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

@@ -1,43 +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/dist/compiler/detector/kernels/index.d.ts

@@ -1 +0,0 @@
-export {};

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

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

package/dist/compiler/detector/kernels/webgl/binomialFilter.d.ts

@@ -1,6 +0,0 @@
-export function binomialFilter(args: any): any;
-export namespace binomialFilterConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { binomialFilter as kernelFunc };
-}

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

@@ -1,67 +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/dist/compiler/detector/kernels/webgl/buildExtremas.d.ts

@@ -1,6 +0,0 @@
-export function buildExtremas(args: any): any;
-export namespace buildExtremasConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { buildExtremas as kernelFunc };
-}

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

@@ -1,101 +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/dist/compiler/detector/kernels/webgl/computeExtremaAngles.d.ts

@@ -1,6 +0,0 @@
-export function computeExtremaAngles(args: any): any;
-export namespace computeExtremaAnglesConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { computeExtremaAngles as kernelFunc };
-}

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

@@ -1,78 +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/dist/compiler/detector/kernels/webgl/computeExtremaFreak.d.ts

@@ -1,6 +0,0 @@
-export function computeExtremaFreak(args: any): any;
-export namespace computeExtremaFreakConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { computeExtremaFreak as kernelFunc };
-}

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

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

package/dist/compiler/detector/kernels/webgl/computeFreakDescriptors.d.ts

@@ -1,6 +0,0 @@
-export function computeFreakDescriptor(args: any): any;
-export namespace computeFreakDescriptorConfig {
-    export let kernelName: string;
-    export let backendName: string;
-    export { computeFreakDescriptor as kernelFunc };
-}