@srsergio/taptapp-ar 1.0.0

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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,6 @@
+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

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

@@ -0,0 +1,6 @@
+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/webgl/computeFreakDescriptors.js

@@ -0,0 +1,52 @@
+import { FREAKPOINTS } from "../../freak.js";
+const FREAK_CONPARISON_COUNT = ((FREAKPOINTS.length - 1) * FREAKPOINTS.length) / 2;
+const descriptorCount = Math.ceil(FREAK_CONPARISON_COUNT / 8);
+const cache = {};
+function GetProgram(extremaFreaks) {
+    const key = `${extremaFreaks.shape[0]}`;
+    if (!cache.hasOwnProperty(key)) {
+        const kernel = {
+            variableNames: ["freak", "p"],
+            outputShape: [extremaFreaks.shape[0], descriptorCount],
+            userCode: `
+  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}) {
+        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));
+  }
+`,
+        };
+        cache[key] = kernel;
+    }
+    return cache[key];
+}
+export const computeFreakDescriptor = (args) => {
+    const { extremaFreaks, positionT } = args.inputs;
+    const { backend } = args;
+    const program = GetProgram(extremaFreaks);
+    return backend.runWebGLProgram(program, [extremaFreaks, positionT], "int32");
+};
+export const computeFreakDescriptorConfig = {
+    //: KernelConfig
+    kernelName: "ComputeFreakDescriptors",
+    backendName: "webgl",
+    kernelFunc: computeFreakDescriptor, // as {} as KernelFunc,
+};

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

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

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

@@ -0,0 +1,58 @@
+import { tensor } from "@tensorflow/tfjs";
+const cache = {};
+function GetProgram(numDogPyramidImages, extremasListLength) {
+    const kernelKey = `${numDogPyramidImages}|${extremasListLength}`;
+    if (!cache.hasOwnProperty(kernelKey)) {
+        const dogVariableNames = [];
+        let dogSubCodes = `float getPixel(int octave, int y, int x) {`;
+        for (let i = 1; i < numDogPyramidImages; i++) {
+            // extrema starts from second octave
+            dogVariableNames.push("image" + i);
+            dogSubCodes += `
+				if (octave == ${i}) {
+					return getImage${i}(y, x);
+				}
+			`;
+        }
+        dogSubCodes += `}`;
+        cache[kernelKey] = {
+            variableNames: [...dogVariableNames, "extrema"],
+            outputShape: [extremasListLength, 3, 3], // 3x3 pixels around the extrema
+            userCode: `
+			${dogSubCodes}
+		
+			void main() {
+				ivec3 coords = getOutputCoords();
+				int featureIndex = coords[0];
+				float score = getExtrema(featureIndex, 0);
+				if (score == 0.0) {
+					return;
+				}
+		
+				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));
+			}
+			`,
+        };
+    }
+    return cache[kernelKey];
+}
+export const computeLocalization = (args) => {
+    /** @type {import('@tensorflow/tfjs').TensorInfo} */
+    const { prunedExtremasList, dogPyramidImagesT } = args.inputs;
+    /** @type {MathBackendWebGL} */
+    const backend = args.backend;
+    const program = GetProgram(dogPyramidImagesT.length, prunedExtremasList.length);
+    const prunedExtremasT = tensor(prunedExtremasList, [prunedExtremasList.length, prunedExtremasList[0].length], "int32");
+    return backend.runWebGLProgram(program, [...dogPyramidImagesT.slice(1), prunedExtremasT], dogPyramidImagesT[0].dtype);
+};
+export const computeLocalizationConfig = {
+    //: KernelConfig
+    kernelName: "ComputeLocalization",
+    backendName: "webgl",
+    kernelFunc: computeLocalization, // as {} as KernelFunc,
+};

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

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

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

@@ -0,0 +1,116 @@
+const oneOver2PI = 0.159154943091895;
+const ORIENTATION_NUM_BINS = 36;
+const cache = {};
+function GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength) {
+    const key = `${pyramidImagesLength}|${prunedExtremasT.shape[0]}|${radialPropertiesT.shape[0]}`;
+    if (!cache.hasOwnProperty(key)) {
+        const imageVariableNames = [];
+        for (let i = 1; i < pyramidImagesLength; i++) {
+            imageVariableNames.push("image" + i);
+        }
+        let kernel1SubCodes = `float getPixel(int octave, int y, int x) {`;
+        for (let i = 1; i < pyramidImagesLength; i++) {
+            kernel1SubCodes += `
+            if (octave == ${i}) {
+                return getImage${i}(y, x);
+            }
+            `;
+        }
+        kernel1SubCodes += `}`;
+        const kernel1 = {
+            variableNames: [...imageVariableNames, "extrema", "radial"],
+            outputShape: [prunedExtremasT.shape[0], radialPropertiesT.shape[0], 2], // last dimension: [fbin, magnitude]
+            userCode: `
+                ${kernel1SubCodes}
+
+                void main() {
+                    ivec3 coords = getOutputCoords();
+                    int featureIndex = coords[0];
+                    int radialIndex = coords[1];
+                    int propertyIndex = coords[2];
+
+                    int radialY = int(getRadial(radialIndex, 0));
+                    int radialX = int(getRadial(radialIndex, 1));
+                    float radialW = getRadial(radialIndex, 2);
+
+                    int octave = int(getExtrema(featureIndex, 1));
+                    int y = int(getExtrema(featureIndex, 2));
+                    int x = int(getExtrema(featureIndex, 3));
+
+                    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) {
+                    // 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 mag = sqrt(dx * dx + dy * dy);
+                        float magnitude = radialW * mag;
+                        setOutput(magnitude);
+                        return;
+                    }
+                }
+
+                `,
+        };
+        const kernel2 = {
+            variableNames: ["fbinMag"],
+            outputShape: [prunedExtremasT.shape[0], ORIENTATION_NUM_BINS],
+            userCode: `
+            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++) {
+                    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) {
+                        float magnitude = getFbinMag(featureIndex, i, 1);
+                        float w2 = fbin - float(bin) - 0.5;
+                        float w1 = w2 * -1. + 1.;
+
+                        if (b1 == binIndex) {
+                            sum += w1 * magnitude;
+                        }
+                        if (b2 == binIndex) {
+                            sum += w2 * magnitude;
+                        }
+                    }
+                }
+                setOutput(sum);
+            }
+            `,
+        };
+        cache[key] = [kernel1, kernel2];
+    }
+    return cache[key];
+}
+export const computeOrientationHistograms = (args) => {
+    const { gaussianImagesT, prunedExtremasT, radialPropertiesT, pyramidImagesLength } = args.inputs;
+    /** @type {MathBackendWebGL} */
+    const backend = args.backend;
+    const [program1, program2] = GetPrograms(prunedExtremasT, radialPropertiesT, pyramidImagesLength);
+    const result1 = backend.runWebGLProgram(program1, [...gaussianImagesT, prunedExtremasT, radialPropertiesT], radialPropertiesT.dtype);
+    const result2 = backend.runWebGLProgram(program2, [result1], radialPropertiesT.dtype);
+    backend.disposeIntermediateTensorInfo(result1);
+    return result2;
+};
+export const computeOrientationHistogramsConfig = {
+    kernelName: "ComputeOrientationHistograms",
+    backendName: "webgl",
+    kernelFunc: computeOrientationHistograms, // as {} as KernelFunc,
+};

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

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

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

@@ -0,0 +1,46 @@
+const cache = {};
+/**
+ *
+ * @param {TensorInfo} image
+ * @returns {GPGPUProgram}
+ */
+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: ["p"],
+            outputShape: [Math.floor(imageHeight / 2), Math.floor(imageWidth / 2)],
+            userCode: `
+            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);
+            }
+            `,
+        };
+        cache[kernelKey] = kernel;
+    }
+    return cache[kernelKey];
+}
+export const downsampleBilinear = (args) => {
+    /** @type {import('@tensorflow/tfjs').TensorInfo} */
+    const image = args.inputs.image;
+    /** @type {MathBackendWebGL} */
+    const backend = args.backend;
+    const program = GetProgram(image);
+    return backend.runWebGLProgram(program, [image], image.dtype);
+};
+export const downsampleBilinearConfig = {
+    //: KernelConfig
+    kernelName: "DownsampleBilinear",
+    backendName: "webgl",
+    kernelFunc: downsampleBilinear, // as {} as KernelFunc,
+};

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

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

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

@@ -0,0 +1,48 @@
+export const extremaReduction = (args) => {
+    /** @type {import('@tensorflow/tfjs').TensorInfo[]} */
+    const { extremasResultT } = args.inputs;
+    /** @type {MathBackendWebGL} */
+    const backend = args.backend;
+    const extremaHeight = extremasResultT.shape[0];
+    const extremaWidth = extremasResultT.shape[1];
+    const kernel = {
+        variableNames: ["extrema"],
+        outputShape: [Math.floor(extremaHeight / 2), Math.floor(extremaWidth / 2)],
+        userCode: `
+		  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);
+			}
+		  }
+		`,
+    };
+    return backend.runWebGLProgram(kernel, [extremasResultT], extremasResultT.dtype);
+};
+export const extremaReductionConfig = {
+    //: KernelConfig
+    kernelName: "ExtremaReduction",
+    backendName: "webgl",
+    kernelFunc: extremaReduction, // as {} as KernelFunc,
+};

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

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

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

@@ -0,0 +1,25 @@
+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/webgl/smoothHistograms.d.ts

@@ -0,0 +1,6 @@
+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/webgl/smoothHistograms.js

@@ -0,0 +1,49 @@
+const ORIENTATION_NUM_BINS = 36;
+const ORIENTATION_SMOOTHING_ITERATIONS = 5;
+const cache = {};
+function GetProgram(histograms) {
+    const kernelKey = `h${histograms.shape[0]}`;
+    if (!cache.hasOwnProperty(kernelKey)) {
+        const kernel = {
+            variableNames: ["histogram"],
+            outputShape: [histograms.shape[0], ORIENTATION_NUM_BINS],
+            userCode: `
+            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});
+                float result = 0.274068619061197 * getHistogram(featureIndex, prevBin) + 0.451862761877606 * getHistogram(featureIndex, binIndex) + 0.274068619061197 * getHistogram(featureIndex, nextBin);
+
+                setOutput(result);
+            }
+            `,
+        };
+        cache[kernelKey] = kernel;
+    }
+    return cache[kernelKey];
+}
+export const smoothHistograms = (args) => {
+    /** @type {import('@tensorflow/tfjs').TensorInfo} */
+    let { histograms } = args.inputs;
+    /** @type {MathBackendWebGL} */
+    const backend = args.backend;
+    const program = GetProgram(histograms);
+    for (let i = 0; i < ORIENTATION_SMOOTHING_ITERATIONS; i++) {
+        const _histograms = histograms;
+        histograms = backend.runWebGLProgram(program, [histograms], histograms.dtype); //this._compileAndRun(program, [histograms]);
+        if (i > 0) {
+            backend.disposeIntermediateTensorInfo(_histograms);
+        }
+    }
+    return histograms;
+};
+export const smoothHistogramsConfig = {
+    //: KernelConfig
+    kernelName: "SmoothHistograms",
+    backendName: "webgl",
+    kernelFunc: smoothHistograms, // as {} as KernelFunc,
+};

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

@@ -0,0 +1,6 @@
+export function upsampleBilinear(args: any): import("@tensorflow/tfjs-core").TensorInfo;
+export namespace upsampleBilinearConfig {
+    export let kernelName: string;
+    export let backendName: string;
+    export { upsampleBilinear as kernelFunc };
+}