@srsergio/taptapp-ar 1.0.0

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

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

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

@@ -0,0 +1,105 @@
+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/src/compiler/detector/kernels/webgl/computeFreakDescriptors.js

@@ -0,0 +1,56 @@
+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/src/compiler/detector/kernels/webgl/computeLocalization.js

@@ -0,0 +1,70 @@
+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/src/compiler/detector/kernels/webgl/computeOrientationHistograms.js

@@ -0,0 +1,129 @@
+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/src/compiler/detector/kernels/webgl/downsampleBilinear.js

@@ -0,0 +1,50 @@
+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/src/compiler/detector/kernels/webgl/extremaReduction.js

@@ -0,0 +1,50 @@
+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/src/compiler/detector/kernels/webgl/index.js

@@ -0,0 +1,26 @@
+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);
+//}