@srsergio/taptapp-ar 1.0.8 → 1.0.10

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

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

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

@@ -1,50 +0,0 @@
-import * as FakeShader from "./fakeShader.js";
-function GetKernels(image) {
-    const imageWidth = image.shape[1];
-    const imageHeight = image.shape[0];
-    const kernel1 = {
-        variableNames: ["p"],
-        outputShape: [imageHeight, imageWidth],
-        userCode: function () {
-            const coords = this.getOutputCoords();
-            let sum = this.getP(coords[0], coords[1] - 2);
-            sum += this.getP(coords[0], coords[1] - 1) * 4;
-            sum += this.getP(coords[0], coords[1]) * 6;
-            sum += this.getP(coords[0], coords[1] + 1) * 4;
-            sum += this.getP(coords[0], coords[1] + 2);
-            this.setOutput(sum);
-        },
-    };
-    const kernel2 = {
-        variableNames: ["p"],
-        outputShape: [imageHeight, imageWidth],
-        userCode: function () {
-            const coords = this.getOutputCoords();
-            let sum = this.getP(coords[0] - 2, coords[1]);
-            sum += this.getP(coords[0] - 1, coords[1]) * 4;
-            sum += this.getP(coords[0], coords[1]) * 6;
-            sum += this.getP(coords[0] + 1, coords[1]) * 4;
-            sum += this.getP(coords[0] + 2, coords[1]);
-            sum /= 256;
-            this.setOutput(sum);
-        },
-    };
-    return [kernel1, kernel2];
-    //}
-}
-export const binomialFilter = (args) => {
-    //{inputs: UnaryInputs, backend: MathBackendCPU}
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const image = args.inputs.image;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    const [kernel1, kernel2] = GetKernels(image);
-    const result1 = FakeShader.runCode(backend, kernel1, [image], image.dtype);
-    return FakeShader.runCode(backend, kernel2, [result1], image.dtype);
-};
-export const binomialFilterConfig = {
-    //: KernelConfig
-    kernelName: "BinomialFilter",
-    backendName: "cpu",
-    kernelFunc: binomialFilter, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/buildExtremas.d.ts

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

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

@@ -1,89 +0,0 @@
-import * as FakeShader from "./fakeShader.js";
-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;
-function GetProgram(image) {
-    const imageWidth = image.shape[1];
-    const imageHeight = image.shape[0];
-    const kernel = {
-        variableNames: ["image0", "image1", "image2"],
-        outputShape: [imageHeight, imageWidth],
-        userCode: function () {
-            const coords = this.getOutputCoords();
-            const y = coords[0];
-            const x = coords[1];
-            const value = this.getImage1(y, x);
-            // Step 1: find local maxima/minima
-            if (value * value < LAPLACIAN_SQR_THRESHOLD) {
-                this.setOutput(0.0);
-                return;
-            }
-            if (y < FREAK_EXPANSION_FACTOR || y > imageHeight - 1 - FREAK_EXPANSION_FACTOR) {
-                this.setOutput(0.0);
-                return;
-            }
-            if (x < FREAK_EXPANSION_FACTOR || x > imageWidth - 1 - FREAK_EXPANSION_FACTOR) {
-                this.setOutput(0.0);
-                return;
-            }
-            let isMax = true;
-            let isMin = true;
-            for (let dy = -1; dy <= 1; dy++) {
-                for (let dx = -1; dx <= 1; dx++) {
-                    const value0 = this.getImage0(y + dy, x + dx);
-                    const value1 = this.getImage1(y + dy, x + dx);
-                    const value2 = this.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) {
-                this.setOutput(0.0);
-                return;
-            }
-            // compute edge score and reject based on threshold
-            const dxx = this.getImage1(y, x + 1) + this.getImage1(y, x - 1) - 2 * this.getImage1(y, x);
-            const dyy = this.getImage1(y + 1, x) + this.getImage1(y - 1, x) - 2 * this.getImage1(y, x);
-            const dxy = 0.25 *
-                (this.getImage1(y - 1, x - 1) +
-                    this.getImage1(y + 1, x + 1) -
-                    this.getImage1(y - 1, x + 1) -
-                    this.getImage1(y + 1, x - 1));
-            const det = dxx * dyy - dxy * dxy;
-            if (Math.abs(det) < 0.0001) {
-                // determinant undefined. no solution
-                this.setOutput(0.0);
-                return;
-            }
-            const edgeScore = ((dxx + dyy) * (dxx + dyy)) / det;
-            if (Math.abs(edgeScore) >= EDGE_HESSIAN_THRESHOLD) {
-                this.setOutput(0.0);
-                return;
-            }
-            this.setOutput(this.getImage1(y, x));
-        },
-    };
-    return kernel;
-}
-export const buildExtremas = (args) => {
-    let { image0, image1, image2 } = args.inputs;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    image0 = engine().runKernel("DownsampleBilinear", { image: image0 });
-    image2 = engine().runKernel("UpsampleBilinear", { image: image2, targetImage: image1 });
-    const program = GetProgram(image1);
-    return FakeShader.runCode(backend, program, [image0, image1, image2], image1.dtype);
-};
-export const buildExtremasConfig = {
-    //: KernelConfig
-    kernelName: "BuildExtremas",
-    backendName: "cpu",
-    kernelFunc: buildExtremas, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/computeExtremaAngles.d.ts

@@ -1,7 +0,0 @@
-export function computeExtremaAnglesImpl(histogram: any): Float32Array<any>;
-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/cpu/computeExtremaAngles.js

@@ -1,79 +0,0 @@
-const ORIENTATION_NUM_BINS = 36;
-export function computeExtremaAnglesImpl(histogram) {
-    const resultValues = new Float32Array(histogram.height);
-    function getHistogram(featureIndex, prev) {
-        return histogram.values[featureIndex * histogram.width + prev];
-    }
-    function setOutput(featureIndex, an) {
-        resultValues[featureIndex] = an;
-    }
-    function imod(x, y) {
-        return Math.trunc(x - y * Math.floor(x / y));
-    }
-    for (let featureIndex = 0; featureIndex < histogram.height; featureIndex++) {
-        let maxIndex = 0;
-        for (let i = 1; i < ORIENTATION_NUM_BINS; i++) {
-            if (getHistogram(featureIndex, i) > getHistogram(featureIndex, maxIndex)) {
-                maxIndex = i;
-            }
-        }
-        let prev = imod(maxIndex - 1 + ORIENTATION_NUM_BINS, ORIENTATION_NUM_BINS);
-        let 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.
-         */
-        const p10 = maxIndex - 1;
-        const p11 = getHistogram(featureIndex, prev);
-        const p20 = maxIndex;
-        const p21 = getHistogram(featureIndex, maxIndex);
-        const p30 = maxIndex + 1;
-        const p31 = getHistogram(featureIndex, next);
-        const d1 = (p30 - p20) * (p30 - p10);
-        const d2 = (p10 - p20) * (p30 - p10);
-        const d3 = p10 - p20;
-        // If any of the denominators are zero then, just use maxIndex.
-        let fbin = maxIndex;
-        if (Math.abs(d1) > 0.00001 && Math.abs(d2) > 0.00001 && Math.abs(d3) > 0.00001) {
-            const a = p10 * p10;
-            const b = p20 * p20;
-            // Solve for the coefficients A,B,C
-            let A = (p31 - p21) / d1 - (p11 - p21) / d2;
-            if (Number.isNaN(A))
-                A = 0;
-            const B = (p11 - p21 + A * (b - a)) / d3;
-            //const C = p11 - (A * a) - (B * p10);
-            fbin = -B / (2.0 * A);
-            if (Number.isNaN(fbin))
-                fbin = 0; //console.warn(`computeExtremaAngles::NaN! fbin=${fbin} maxIndex=${maxIndex} A=${A} B=${B} p31=${p31} p21=${p21} p11=${p11}`);
-        }
-        const an = (2.0 * Math.PI * (fbin + 0.5)) / ORIENTATION_NUM_BINS - Math.PI;
-        setOutput(featureIndex, an);
-    }
-    return resultValues;
-}
-export const computeExtremaAngles = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const { histograms } = args.inputs;
-    /** @type {import('@tensorflow/tfjs-backend-cpu').MathBackendCPU} */
-    const backend = args.backend;
-    /** @type {TypedArray} */
-    const histogramValues = {
-        values: backend.data.get(histograms.dataId).values,
-        width: histograms.shape[1],
-        height: histograms.shape[0],
-    };
-    const resultValues = computeExtremaAnglesImpl(histogramValues);
-    return backend.makeOutput(resultValues, [histograms.shape[0]], histograms.dtype);
-};
-export const computeExtremaAnglesConfig = {
-    //: KernelConfig
-    kernelName: "ComputeExtremaAngles",
-    backendName: "cpu",
-    kernelFunc: computeExtremaAngles, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/computeExtremaFreak.d.ts

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

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

@@ -1,68 +0,0 @@
-import { FREAKPOINTS } from "../../freak.js";
-import * as FakeShader from "./fakeShader.js";
-const FREAK_EXPANSION_FACTOR = 7.0;
-function GetProgram(prunedExtremasHeight, pyramidImagesLength) {
-    const imageVariableNames = [];
-    for (let i = 1; i < pyramidImagesLength; i++) {
-        imageVariableNames.push("image" + i);
-    }
-    const kernel = {
-        variableNames: [...imageVariableNames, "extrema", "angles", "freakPoints"],
-        outputShape: [prunedExtremasHeight, FREAKPOINTS.length],
-        userCode: function () {
-            const getPixel = (octave, y, x) => {
-                const key = "getImage" + octave;
-                if (octave < 1 || octave >= pyramidImagesLength)
-                    return 0.0;
-                return this[key](y, x);
-            };
-            const coords = this.getOutputCoords();
-            const featureIndex = coords[0];
-            const freakIndex = coords[1];
-            //const freakSigma = this.getFreakPoints(freakIndex, 0);
-            const freakX = this.getFreakPoints(freakIndex, 1);
-            const freakY = this.getFreakPoints(freakIndex, 2);
-            const octave = this.int(this.getExtrema(featureIndex, 1));
-            const inputY = this.getExtrema(featureIndex, 2);
-            const inputX = this.getExtrema(featureIndex, 3);
-            const inputAngle = this.getAngles(featureIndex);
-            const cos = FREAK_EXPANSION_FACTOR * Math.cos(inputAngle);
-            const sin = FREAK_EXPANSION_FACTOR * Math.sin(inputAngle);
-            const yp = inputY + freakX * sin + freakY * cos;
-            const xp = inputX + freakX * cos + freakY * -sin;
-            const x0 = this.int(Math.floor(xp));
-            const x1 = x0 + 1;
-            const y0 = this.int(Math.floor(yp));
-            const y1 = y0 + 1;
-            const f1 = getPixel(octave, y0, x0);
-            const f2 = getPixel(octave, y0, x1);
-            const f3 = getPixel(octave, y1, x0);
-            const f4 = getPixel(octave, y1, x1);
-            /* const x1f = float(x1);
-                  const y1f = float(y1);
-                  const x0f = float(x0);
-                  const y0f = float(y0); */
-            // ratio for interpolation between four neighbouring points
-            const value = (x1 - xp) * (y1 - yp) * f1 +
-                (xp - x0) * (y1 - yp) * f2 +
-                (x1 - xp) * (yp - y0) * f3 +
-                (xp - x0) * (yp - y0) * f4;
-            this.setOutput(value);
-        },
-    };
-    return kernel;
-}
-export const computeExtremaFreak = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const { gaussianImagesT, prunedExtremas, prunedExtremasAngles, freakPointsT, pyramidImagesLength, } = args.inputs;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    const prog = GetProgram(prunedExtremas.shape[0], pyramidImagesLength);
-    return FakeShader.runCode(backend, prog, [...gaussianImagesT, prunedExtremas, prunedExtremasAngles, freakPointsT], "float32");
-};
-export const computeExtremaFreakConfig = {
-    //: KernelConfig
-    kernelName: "ComputeExtremaFreak",
-    backendName: "cpu",
-    kernelFunc: computeExtremaFreak, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/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 };
-}

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

@@ -1,57 +0,0 @@
-import { FREAKPOINTS } from "../../freak.js";
-const FREAK_CONPARISON_COUNT = ((FREAKPOINTS.length - 1) * FREAKPOINTS.length) / 2;
-const descriptorCount = Math.ceil(FREAK_CONPARISON_COUNT / 8);
-function computeFreakDescriptorImpl(extremaFreaks, positionT) {
-    const resultValues = new Float32Array(extremaFreaks.height * descriptorCount);
-    function getP(y, x) {
-        return positionT.values[y * positionT.width + x];
-    }
-    function getFreak(y, x) {
-        return extremaFreaks.values[y * extremaFreaks.width + x];
-    }
-    function setOutput(y, x, o) {
-        resultValues[y * descriptorCount + x] = o;
-    }
-    for (let featureIndex = 0; featureIndex < extremaFreaks.height; featureIndex++) {
-        for (let _descIndex = 0; _descIndex < descriptorCount; _descIndex++) {
-            const descIndex = _descIndex * 8;
-            let sum = 0;
-            for (let i = 0; i < 8; i++) {
-                if (descIndex + i >= FREAK_CONPARISON_COUNT) {
-                    continue;
-                }
-                const p1 = Math.trunc(getP(descIndex + i, 0));
-                const p2 = Math.trunc(getP(descIndex + i, 1));
-                const v1 = getFreak(featureIndex, p1);
-                const v2 = getFreak(featureIndex, p2);
-                if (v1 < v2 + 0.01) {
-                    sum += Math.trunc(Math.pow(2.0, 7.0 - i));
-                }
-            }
-            setOutput(featureIndex, _descIndex, sum);
-        }
-    }
-    return resultValues;
-}
-export const computeFreakDescriptor = (args) => {
-    const { extremaFreaks, positionT } = args.inputs;
-    const { backend } = args;
-    const freaksData = {
-        values: backend.data.get(extremaFreaks.dataId).values,
-        height: extremaFreaks.shape[0],
-        width: extremaFreaks.shape[1],
-    };
-    const positionData = {
-        values: backend.data.get(positionT.dataId).values,
-        width: positionT.shape[1],
-    };
-    //backend.runWebGLProgram(program,[extremaFreaks, positionT],'int32');
-    const resultValues = computeFreakDescriptorImpl(freaksData, positionData);
-    return backend.makeOutput(resultValues, [extremaFreaks.shape[0], descriptorCount], "int32");
-};
-export const computeFreakDescriptorConfig = {
-    //: KernelConfig
-    kernelName: "ComputeFreakDescriptors",
-    backendName: "cpu",
-    kernelFunc: computeFreakDescriptor, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/computeLocalization.d.ts

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

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

@@ -1,50 +0,0 @@
-import { tensor } from "@tensorflow/tfjs";
-import * as FakeShader from "./fakeShader.js";
-function GetProgram(numDogPyramidImages, extremasListLength) {
-    const dogVariableNames = [];
-    for (let i = 1; i < numDogPyramidImages; i++) {
-        dogVariableNames.push("image" + i);
-    }
-    const program = {
-        variableNames: [...dogVariableNames, "extrema"],
-        outputShape: [extremasListLength, 3, 3], // 3x3 pixels around the extrema
-        userCode: function () {
-            const getPixel = (octave, y, x) => {
-                const k = "getImage" + octave;
-                if (!this.hasOwnProperty(k)) {
-                    throw new Error(`ComputeLocalization:: ${k} does not exist`);
-                }
-                return this[k](y, x);
-            };
-            const coords = this.getOutputCoords();
-            const featureIndex = coords[0];
-            const score = this.getExtrema(featureIndex, 0);
-            if (score == 0.0) {
-                return;
-            }
-            const dy = coords[1] - 1;
-            const dx = coords[2] - 1;
-            const octave = this.int(this.getExtrema(featureIndex, 1));
-            const y = this.int(this.getExtrema(featureIndex, 2));
-            const x = this.int(this.getExtrema(featureIndex, 3));
-            this.setOutput(getPixel(octave, y + dy, x + dx));
-        },
-    };
-    //}
-    return program;
-}
-export const computeLocalization = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const { prunedExtremasList, dogPyramidImagesT } = args.inputs;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    const program = GetProgram(dogPyramidImagesT.length, prunedExtremasList.length);
-    const prunedExtremasT = tensor(prunedExtremasList, [prunedExtremasList.length, prunedExtremasList[0].length], "int32");
-    return FakeShader.runCode(backend, program, [...dogPyramidImagesT.slice(1), prunedExtremasT], dogPyramidImagesT[0].dtype);
-};
-export const computeLocalizationConfig = {
-    //: KernelConfig
-    kernelName: "ComputeLocalization",
-    backendName: "cpu",
-    kernelFunc: computeLocalization, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/computeOrientationHistograms.d.ts

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

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

@@ -1,100 +0,0 @@
-import * as FakeShader from "./fakeShader.js";
-const oneOver2PI = 0.159154943091895;
-const ORIENTATION_NUM_BINS = 36;
-function GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength) {
-    const imageVariableNames = [];
-    for (let i = 1; i < pyramidImagesLength; i++) {
-        imageVariableNames.push("image" + i);
-    }
-    const kernel1 = {
-        variableNames: [...imageVariableNames, "extrema", "radial"],
-        outputShape: [prunedExtremasT.shape[0], radialPropertiesT.shape[0], 2], // last dimension: [fbin, magnitude]
-        userCode: function () {
-            //${ kernel1SubCodes }
-            const getPixel = (octave, y, x) => {
-                const k = "getImage" + octave;
-                if (!this.hasOwnProperty(k)) {
-                    //console.error(`ComputeOrientationHistograms:: ${k} does not exist! y:${y} x:${x}`);
-                    return 0.0;
-                }
-                return this[k](y, x);
-            };
-            //void main() {
-            const coords = this.getOutputCoords();
-            const featureIndex = coords[0];
-            const radialIndex = coords[1];
-            const propertyIndex = coords[2];
-            const radialY = this.int(this.getRadial(radialIndex, 0));
-            const radialX = this.int(this.getRadial(radialIndex, 1));
-            const radialW = this.getRadial(radialIndex, 2);
-            const octave = this.int(this.getExtrema(featureIndex, 1));
-            const y = this.int(this.getExtrema(featureIndex, 2));
-            const x = this.int(this.getExtrema(featureIndex, 3));
-            const xp = x + radialX;
-            const yp = y + radialY;
-            const dy = getPixel(octave, yp + 1, xp) - getPixel(octave, yp - 1, xp);
-            const 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
-                const angle = this.atan(dy, dx) + Math.PI;
-                const fbin = angle * ORIENTATION_NUM_BINS * oneOver2PI;
-                this.setOutput(fbin);
-                return;
-            }
-            if (propertyIndex == 1) {
-                const mag = Math.sqrt(dx * dx + dy * dy);
-                const magnitude = radialW * mag;
-                this.setOutput(magnitude);
-                return;
-            }
-            // }
-        },
-    };
-    const kernel2 = {
-        variableNames: ["fbinMag"],
-        outputShape: [prunedExtremasT.shape[0], ORIENTATION_NUM_BINS],
-        userCode: function () {
-            function imod(x, y) {
-                return Math.trunc(x - y * Math.floor(x / y));
-            }
-            const coords = this.getOutputCoords();
-            const featureIndex = coords[0];
-            const binIndex = coords[1];
-            let sum = 0;
-            for (let i = 0; i < radialPropertiesT.shape[0]; i++) {
-                const fbin = this.getFbinMag(featureIndex, i, 0);
-                const bin = Math.trunc(Math.floor(fbin - 0.5));
-                const b1 = imod(bin + ORIENTATION_NUM_BINS, ORIENTATION_NUM_BINS);
-                const b2 = imod(bin + 1 + ORIENTATION_NUM_BINS, ORIENTATION_NUM_BINS);
-                if (b1 == binIndex || b2 == binIndex) {
-                    const magnitude = this.getFbinMag(featureIndex, i, 1);
-                    const w2 = fbin - bin - 0.5;
-                    const w1 = w2 * -1 + 1;
-                    if (b1 == binIndex) {
-                        sum += w1 * magnitude;
-                    }
-                    if (b2 == binIndex) {
-                        sum += w2 * magnitude;
-                    }
-                }
-            }
-            this.setOutput(sum);
-        },
-    };
-    return [kernel1, kernel2];
-    //}
-    //return cache[key];
-}
-export const computeOrientationHistograms = (args) => {
-    const { gaussianImagesT, prunedExtremasT, radialPropertiesT, pyramidImagesLength } = args.inputs;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    const [program1, program2] = GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength);
-    const result1 = FakeShader.runCode(backend, program1, [...gaussianImagesT, prunedExtremasT, radialPropertiesT], radialPropertiesT.dtype);
-    return FakeShader.runCode(backend, program2, [result1], radialPropertiesT.dtype);
-};
-export const computeOrientationHistogramsConfig = {
-    kernelName: "ComputeOrientationHistograms",
-    backendName: "cpu",
-    kernelFunc: computeOrientationHistograms, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/downsampleBilinear.d.ts

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

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

@@ -1,29 +0,0 @@
-import * as FakeShader from "./fakeShader.js";
-export const downsampleBilinear = (args) => {
-    /** @type {import('@tensorflow/tfjs').TensorInfo} */
-    const x = args.inputs.image;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    const kernel = {
-        variableNames: ["p"],
-        outputShape: [Math.floor(x.shape[0] / 2), Math.floor(x.shape[1] / 2)],
-        userCode: function () {
-            const coords = this.getOutputCoords();
-            const y = coords[0] * 2;
-            const x = coords[1] * 2;
-            let sum = new Float32Array(1);
-            sum[0] = Math.fround(this.getP(y, x) * 0.25);
-            sum[0] += Math.fround(this.getP(y + 1, x) * 0.25);
-            sum[0] += Math.fround(this.getP(y, x + 1) * 0.25);
-            sum[0] += Math.fround(this.getP(y + 1, x + 1) * 0.25);
-            this.setOutput(sum[0]);
-        },
-    };
-    return FakeShader.runCode(backend, kernel, [x], x.dtype);
-};
-export const downsampleBilinearConfig = {
-    //: KernelConfig
-    kernelName: "DownsampleBilinear",
-    backendName: "cpu",
-    kernelFunc: downsampleBilinear, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/extremaReduction.d.ts

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

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

@@ -1,50 +0,0 @@
-import * as FakeShader from "./fakeShader.js";
-function GetProgram(outHeight, outWidth) {
-    const kernel = {
-        variableNames: ["extrema"],
-        outputShape: [outHeight, outWidth],
-        userCode: function () {
-            const coords = this.getOutputCoords();
-            const y = coords[0] * 2;
-            const x = coords[1] * 2;
-            let location = 0.0;
-            let values = this.getExtrema(y, x);
-            if (this.getExtrema(y + 1, x) != 0.0) {
-                location = 1.0;
-                values = this.getExtrema(y + 1, x);
-            }
-            else if (this.getExtrema(y, x + 1) != 0.0) {
-                location = 2.0;
-                values = this.getExtrema(y, x + 1);
-            }
-            else if (this.getExtrema(y + 1, x + 1) != 0.0) {
-                location = 3.0;
-                values = this.getExtrema(y + 1, x + 1);
-            }
-            if (values < 0.0) {
-                this.setOutput(location * -1000.0 + values);
-            }
-            else {
-                this.setOutput(location * 1000.0 + values);
-            }
-        },
-    };
-    return kernel;
-}
-export const extremaReduction = (args) => {
-    const { extremasResultT } = args.inputs;
-    /** @type {MathBackendCPU} */
-    const backend = args.backend;
-    const extremaHeight = extremasResultT.shape[0];
-    const extremaWidth = extremasResultT.shape[1];
-    const outHeight = Math.floor(extremaHeight / 2.0);
-    const outWidth = Math.floor(extremaWidth / 2.0);
-    const program = GetProgram(outHeight, outWidth);
-    return FakeShader.runCode(backend, program, [extremasResultT], extremasResultT.dtype);
-};
-export const extremaReductionConfig = {
-    //: KernelConfig
-    kernelName: "ExtremaReduction",
-    backendName: "cpu",
-    kernelFunc: extremaReduction, // as {} as KernelFunc,
-};

package/dist/compiler/detector/kernels/cpu/fakeShader.d.ts

@@ -1,20 +0,0 @@
-export type Kernel = {
-    variableNames: string[];
-    outputShape: number[];
-    userCode: Function;
-};
-/**
- * @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}
- */
-export function runCode(backend: MathBackendCPU, kernel: Kernel, inputs: any, dtype: DataType): Tensor;