termux-vision 1.6.0 → 1.8.0

package/lib/cv.js

@@ -1,142 +1,146 @@
-/**
- * Fast Pure-JS Spatial Filters & Classical Computer Vision for Node.js.
- * Open-Source under Apache License 2.0.
- */
-
-'use strict';
-
-function gaussianBlur(grayPixels, width, height) {
-  const output = new Float32Array(width * height);
-  // 5x5 normalized Gaussian kernel with sigma=1.4
-  const kernel = [
-    2/159,  4/159,  5/159,  4/159, 2/159,
-    4/159,  9/159, 12/159,  9/159, 4/159,
-    5/159, 12/159, 15/159, 12/159, 5/159,
-    4/159,  9/159, 12/159,  9/159, 4/159,
-    2/159,  4/159,  5/159,  4/159, 2/159
-  ];
-
-  for (let y = 2; y < height - 2; y++) {
-    for (let x = 2; x < width - 2; x++) {
-      let sum = 0;
-      let k = 0;
-      for (let ky = -2; ky <= 2; ky++) {
-        for (let kx = -2; kx <= 2; kx++) {
-          sum += grayPixels[(y + ky) * width + (x + kx)] * kernel[k++];
-        }
-      }
-      output[y * width + x] = sum;
-    }
-  }
-  return output;
-}
-
-function sobel(grayPixels, width, height) {
-  const gradX = new Float32Array(width * height);
-  const gradY = new Float32Array(width * height);
-  const magnitude = new Float32Array(width * height);
-  const angleDeg = new Float32Array(width * height);
-
-  for (let y = 1; y < height - 1; y++) {
-    for (let x = 1; x < width - 1; x++) {
-      const idx = y * width + x;
-      const gx =
-        -grayPixels[(y - 1) * width + (x - 1)] + grayPixels[(y - 1) * width + (x + 1)] +
-        -2 * grayPixels[y * width + (x - 1)] + 2 * grayPixels[y * width + (x + 1)] +
-        -grayPixels[(y + 1) * width + (x - 1)] + grayPixels[(y + 1) * width + (x + 1)];
-
-      const gy =
-        -grayPixels[(y - 1) * width + (x - 1)] - 2 * grayPixels[(y - 1) * width + x] - grayPixels[(y - 1) * width + (x + 1)] +
-        grayPixels[(y + 1) * width + (x - 1)] + 2 * grayPixels[(y + 1) * width + x] + grayPixels[(y + 1) * width + (x + 1)];
-
-      gradX[idx] = gx;
-      gradY[idx] = gy;
-      magnitude[idx] = Math.sqrt(gx * gx + gy * gy);
-      let deg = Math.atan2(gy, gx) * (180.0 / Math.PI);
-      if (deg < 0) deg += 180.0;
-      angleDeg[idx] = deg;
-    }
-  }
-
-  return { gradX, gradY, magnitude, angleDeg };
-}
-
-function canny(grayPixels, width, height, lowThreshold = 40.0, highThreshold = 120.0) {
-  const blurred = gaussianBlur(grayPixels, width, height);
-  const { magnitude, angleDeg } = sobel(blurred, width, height);
-  const dst = new Uint8Array(width * height);
-  const queue = [];
-
-  // 1. NMS & Double Thresholding
-  for (let y = 1; y < height - 1; y++) {
-    for (let x = 1; x < width - 1; x++) {
-      const idx = y * width + x;
-      const c = magnitude[idx];
-      if (c < lowThreshold) continue;
-
-      const deg = angleDeg[idx];
-      let p1 = 0.0, p2 = 0.0;
-
-      if ((deg >= 0 && deg < 22.5) || (deg >= 157.5 && deg <= 180)) {
-        p1 = magnitude[y * width + (x - 1)];
-        p2 = magnitude[y * width + (x + 1)];
-      } else if (deg >= 22.5 && deg < 67.5) {
-        p1 = magnitude[(y - 1) * width + (x + 1)];
-        p2 = magnitude[(y + 1) * width + (x - 1)];
-      } else if (deg >= 67.5 && deg < 112.5) {
-        p1 = magnitude[(y - 1) * width + x];
-        p2 = magnitude[(y + 1) * width + x];
-      } else {
-        p1 = magnitude[(y - 1) * width + (x - 1)];
-        p2 = magnitude[(y + 1) * width + (x + 1)];
-      }
-
-      if (c >= p1 && c >= p2) {
-        if (c >= highThreshold) {
-          dst[idx] = 255;
-          queue.push(idx);
-        } else {
-          dst[idx] = 75; // Weak edge candidate
-        }
-      }
-    }
-  }
-
-  // 2. 8-connected BFS Hysteresis Tracking
-  const dx = [-1,  0,  1, -1, 1, -1, 0, 1];
-  const dy = [-1, -1, -1,  0, 0,  1, 1, 1];
-  let qHead = 0;
-
-  while (qHead < queue.length) {
-    const curr = queue[qHead++];
-    const cx = curr % width;
-    const cy = Math.floor(curr / width);
-
-    for (let k = 0; k < 8; k++) {
-      const nx = cx + dx[k];
-      const ny = cy + dy[k];
-      if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
-        const nIdx = ny * width + nx;
-        if (dst[nIdx] === 75) {
-          dst[nIdx] = 255;
-          queue.push(nIdx);
-        }
-      }
-    }
-  }
-
-  // 3. Suppress remaining unconnected weak edges
-  for (let i = 0; i < dst.length; i++) {
-    if (dst[i] === 75) {
-      dst[i] = 0;
-    }
-  }
-
-  return dst;
-}
-
-module.exports = {
-  gaussianBlur,
-  sobel,
-  canny
-};
+/**
+ * Copyright (c) 2026 Uno Kim / AMEVA Foundation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 OR Commercial-License
+ */
+/**
+ * Fast Pure-JS Spatial Filters & Classical Computer Vision for Node.js.
+ * Open-Source under Apache License 2.0.
+ */
+
+'use strict';
+
+function gaussianBlur(grayPixels, width, height) {
+  const output = new Float32Array(width * height);
+  // 5x5 normalized Gaussian kernel with sigma=1.4
+  const kernel = [
+    2/159,  4/159,  5/159,  4/159, 2/159,
+    4/159,  9/159, 12/159,  9/159, 4/159,
+    5/159, 12/159, 15/159, 12/159, 5/159,
+    4/159,  9/159, 12/159,  9/159, 4/159,
+    2/159,  4/159,  5/159,  4/159, 2/159
+  ];
+
+  for (let y = 2; y < height - 2; y++) {
+    for (let x = 2; x < width - 2; x++) {
+      let sum = 0;
+      let k = 0;
+      for (let ky = -2; ky <= 2; ky++) {
+        for (let kx = -2; kx <= 2; kx++) {
+          sum += grayPixels[(y + ky) * width + (x + kx)] * kernel[k++];
+        }
+      }
+      output[y * width + x] = sum;
+    }
+  }
+  return output;
+}
+
+function sobel(grayPixels, width, height) {
+  const gradX = new Float32Array(width * height);
+  const gradY = new Float32Array(width * height);
+  const magnitude = new Float32Array(width * height);
+  const angleDeg = new Float32Array(width * height);
+
+  for (let y = 1; y < height - 1; y++) {
+    for (let x = 1; x < width - 1; x++) {
+      const idx = y * width + x;
+      const gx =
+        -grayPixels[(y - 1) * width + (x - 1)] + grayPixels[(y - 1) * width + (x + 1)] +
+        -2 * grayPixels[y * width + (x - 1)] + 2 * grayPixels[y * width + (x + 1)] +
+        -grayPixels[(y + 1) * width + (x - 1)] + grayPixels[(y + 1) * width + (x + 1)];
+
+      const gy =
+        -grayPixels[(y - 1) * width + (x - 1)] - 2 * grayPixels[(y - 1) * width + x] - grayPixels[(y - 1) * width + (x + 1)] +
+        grayPixels[(y + 1) * width + (x - 1)] + 2 * grayPixels[(y + 1) * width + x] + grayPixels[(y + 1) * width + (x + 1)];
+
+      gradX[idx] = gx;
+      gradY[idx] = gy;
+      magnitude[idx] = Math.sqrt(gx * gx + gy * gy);
+      let deg = Math.atan2(gy, gx) * (180.0 / Math.PI);
+      if (deg < 0) deg += 180.0;
+      angleDeg[idx] = deg;
+    }
+  }
+
+  return { gradX, gradY, magnitude, angleDeg };
+}
+
+function canny(grayPixels, width, height, lowThreshold = 40.0, highThreshold = 120.0) {
+  const blurred = gaussianBlur(grayPixels, width, height);
+  const { magnitude, angleDeg } = sobel(blurred, width, height);
+  const dst = new Uint8Array(width * height);
+  const queue = [];
+
+  // 1. NMS & Double Thresholding
+  for (let y = 1; y < height - 1; y++) {
+    for (let x = 1; x < width - 1; x++) {
+      const idx = y * width + x;
+      const c = magnitude[idx];
+      if (c < lowThreshold) continue;
+
+      const deg = angleDeg[idx];
+      let p1 = 0.0, p2 = 0.0;
+
+      if ((deg >= 0 && deg < 22.5) || (deg >= 157.5 && deg <= 180)) {
+        p1 = magnitude[y * width + (x - 1)];
+        p2 = magnitude[y * width + (x + 1)];
+      } else if (deg >= 22.5 && deg < 67.5) {
+        p1 = magnitude[(y - 1) * width + (x + 1)];
+        p2 = magnitude[(y + 1) * width + (x - 1)];
+      } else if (deg >= 67.5 && deg < 112.5) {
+        p1 = magnitude[(y - 1) * width + x];
+        p2 = magnitude[(y + 1) * width + x];
+      } else {
+        p1 = magnitude[(y - 1) * width + (x - 1)];
+        p2 = magnitude[(y + 1) * width + (x + 1)];
+      }
+
+      if (c >= p1 && c >= p2) {
+        if (c >= highThreshold) {
+          dst[idx] = 255;
+          queue.push(idx);
+        } else {
+          dst[idx] = 75; // Weak edge candidate
+        }
+      }
+    }
+  }
+
+  // 2. 8-connected BFS Hysteresis Tracking
+  const dx = [-1,  0,  1, -1, 1, -1, 0, 1];
+  const dy = [-1, -1, -1,  0, 0,  1, 1, 1];
+  let qHead = 0;
+
+  while (qHead < queue.length) {
+    const curr = queue[qHead++];
+    const cx = curr % width;
+    const cy = Math.floor(curr / width);
+
+    for (let k = 0; k < 8; k++) {
+      const nx = cx + dx[k];
+      const ny = cy + dy[k];
+      if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+        const nIdx = ny * width + nx;
+        if (dst[nIdx] === 75) {
+          dst[nIdx] = 255;
+          queue.push(nIdx);
+        }
+      }
+    }
+  }
+
+  // 3. Suppress remaining unconnected weak edges
+  for (let i = 0; i < dst.length; i++) {
+    if (dst[i] === 75) {
+      dst[i] = 0;
+    }
+  }
+
+  return dst;
+}
+
+module.exports = {
+  gaussianBlur,
+  sobel,
+  canny
+};

package/lib/detect.js

@@ -1,131 +1,135 @@
-/**
- * BoundingBox Geometry & Non-Maximum Suppression (NMS) for Node.js.
- * Open-Source under Apache License 2.0.
- */
-
-'use strict';
-
-function computeIoU(boxA, boxB) {
-  const x1 = Math.max(boxA.x, boxB.x);
-  const y1 = Math.max(boxA.y, boxB.y);
-  const x2 = Math.min(boxA.x + boxA.width, boxB.x + boxB.width);
-  const y2 = Math.min(boxA.y + boxA.height, boxB.y + boxB.height);
-
-  const interArea = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
-  const areaA = boxA.width * boxA.height;
-  const areaB = boxB.width * boxB.height;
-  const unionArea = areaA + areaB - interArea;
-
-  return unionArea <= 0 ? 0 : interArea / unionArea;
-}
-
-function nms(boxes, iouThreshold = 0.45) {
-  if (!boxes || boxes.length === 0) return [];
-  const sorted = [...boxes].sort((a, b) => (b.score || 0) - (a.score || 0));
-  const keep = [];
-
-  for (let i = 0; i < sorted.length; i++) {
-    const current = sorted[i];
-    let suppressed = false;
-    for (let j = 0; j < keep.length; j++) {
-      if (computeIoU(current, keep[j]) > iouThreshold) {
-        suppressed = true;
-        break;
-      }
-    }
-    if (!suppressed) {
-      keep.push(current);
-    }
-  }
-
-  return keep;
-}
-
-function computeIntegralImage(grayPixels, width, height) {
-  const stride = width + 1;
-  const integral = new Float64Array((width + 1) * (height + 1));
-
-  for (let y = 0; y < height; y++) {
-    let rowSum = 0.0;
-    const dstRow = (y + 1) * stride;
-    const srcRow = y * width;
-
-    for (let x = 0; x < width; x++) {
-      rowSum += grayPixels[srcRow + x];
-      integral[dstRow + x + 1] = integral[dstRow - stride + x + 1] + rowSum;
-    }
-  }
-  return integral;
-}
-
-function boxSum(integral, stride, x1, y1, x2, y2) {
-  return (
-    integral[y2 * stride + x2] -
-    integral[y1 * stride + x2] -
-    integral[y2 * stride + x1] +
-    integral[y1 * stride + x1]
-  );
-}
-
-function detectFaces(grayPixels, width, height, options = {}) {
-  const scaleFactor = options.scaleFactor || 1.2;
-  const minSize = options.minSize || 24;
-  const maxSize = options.maxSize || Math.min(width, height);
-  const integral = computeIntegralImage(grayPixels, width, height);
-  const stride = width + 1;
-
-  const candidates = [];
-  let scale = minSize / 24.0;
-
-  while (true) {
-    const winW = Math.floor(24 * scale);
-    const winH = Math.floor(24 * scale);
-    if (winW > width || winH > height || winW > maxSize || winH > maxSize) break;
-
-    const step = Math.max(2, Math.floor(4 * scale));
-    const s2 = scale * scale;
-
-    for (let y = 0; y <= height - winH; y += step) {
-      for (let x = 0; x <= width - winW; x += step) {
-        // Stage 1: Eye darkness vs cheek
-        const eX = x + Math.floor(2 * scale), eY = y + Math.floor(6 * scale), eW = Math.floor(20 * scale), eH = Math.floor(6 * scale);
-        const eyes = boxSum(integral, stride, eX, eY, eX + eW, eY + eH);
-        const cX = x + Math.floor(2 * scale), cY = y + Math.floor(12 * scale), cW = Math.floor(20 * scale), cH = Math.floor(6 * scale);
-        const cheeks = boxSum(integral, stride, cX, cY, cX + cW, cY + cH);
-        const val1 = -1.0 * eyes + 1.0 * cheeks;
-        if (val1 < -10.0 * s2 ? -1.0 : 1.2 < 0.2) continue;
-
-        // Stage 2: Nose bridge
-        const nX = x + Math.floor(10 * scale), nY = y + Math.floor(6 * scale), nW = Math.floor(4 * scale), nH = Math.floor(12 * scale);
-        const nose = boxSum(integral, stride, nX, nY, nX + nW, nY + nH);
-        const lX = x + Math.floor(6 * scale), rX = x + Math.floor(14 * scale);
-        const lCheek = boxSum(integral, stride, lX, nY, lX + nW, nY + nH);
-        const rCheek = boxSum(integral, stride, rX, nY, rX + nW, nY + nH);
-        const val2 = -1.0 * lCheek + 2.0 * nose - 1.0 * rCheek;
-        if (val2 < -5.0 * s2 ? -0.8 : 1.5 < 0.3) continue;
-
-        const area = winW * winH;
-        const meanScore = boxSum(integral, stride, x, y, x + winW, y + winH) / (area || 1);
-        candidates.push({
-          x,
-          y,
-          width: winW,
-          height: winH,
-          score: meanScore,
-          className: 'face_candidate'
-        });
-      }
-    }
-    scale *= scaleFactor;
-  }
-
-  return nms(candidates, 0.3);
-}
-
-module.exports = {
-  computeIoU,
-  nms,
-  computeIntegralImage,
-  boxSum,
-  detectFaces
-};
+/**
+ * Copyright (c) 2026 Uno Kim / AMEVA Foundation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 OR Commercial-License
+ */
+/**
+ * BoundingBox Geometry & Non-Maximum Suppression (NMS) for Node.js.
+ * Open-Source under Apache License 2.0.
+ */
+
+'use strict';
+
+function computeIoU(boxA, boxB) {
+  const x1 = Math.max(boxA.x, boxB.x);
+  const y1 = Math.max(boxA.y, boxB.y);
+  const x2 = Math.min(boxA.x + boxA.width, boxB.x + boxB.width);
+  const y2 = Math.min(boxA.y + boxA.height, boxB.y + boxB.height);
+
+  const interArea = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+  const areaA = boxA.width * boxA.height;
+  const areaB = boxB.width * boxB.height;
+  const unionArea = areaA + areaB - interArea;
+
+  return unionArea <= 0 ? 0 : interArea / unionArea;
+}
+
+function nms(boxes, iouThreshold = 0.45) {
+  if (!boxes || boxes.length === 0) return [];
+  const sorted = [...boxes].sort((a, b) => (b.score || 0) - (a.score || 0));
+  const keep = [];
+
+  for (let i = 0; i < sorted.length; i++) {
+    const current = sorted[i];
+    let suppressed = false;
+    for (let j = 0; j < keep.length; j++) {
+      if (computeIoU(current, keep[j]) > iouThreshold) {
+        suppressed = true;
+        break;
+      }
+    }
+    if (!suppressed) {
+      keep.push(current);
+    }
+  }
+
+  return keep;
+}
+
+function computeIntegralImage(grayPixels, width, height) {
+  const stride = width + 1;
+  const integral = new Float64Array((width + 1) * (height + 1));
+
+  for (let y = 0; y < height; y++) {
+    let rowSum = 0.0;
+    const dstRow = (y + 1) * stride;
+    const srcRow = y * width;
+
+    for (let x = 0; x < width; x++) {
+      rowSum += grayPixels[srcRow + x];
+      integral[dstRow + x + 1] = integral[dstRow - stride + x + 1] + rowSum;
+    }
+  }
+  return integral;
+}
+
+function boxSum(integral, stride, x1, y1, x2, y2) {
+  return (
+    integral[y2 * stride + x2] -
+    integral[y1 * stride + x2] -
+    integral[y2 * stride + x1] +
+    integral[y1 * stride + x1]
+  );
+}
+
+function detectFaces(grayPixels, width, height, options = {}) {
+  const scaleFactor = options.scaleFactor || 1.2;
+  const minSize = options.minSize || 24;
+  const maxSize = options.maxSize || Math.min(width, height);
+  const integral = computeIntegralImage(grayPixels, width, height);
+  const stride = width + 1;
+
+  const candidates = [];
+  let scale = minSize / 24.0;
+
+  while (true) {
+    const winW = Math.floor(24 * scale);
+    const winH = Math.floor(24 * scale);
+    if (winW > width || winH > height || winW > maxSize || winH > maxSize) break;
+
+    const step = Math.max(2, Math.floor(4 * scale));
+    const s2 = scale * scale;
+
+    for (let y = 0; y <= height - winH; y += step) {
+      for (let x = 0; x <= width - winW; x += step) {
+        // Stage 1: Eye darkness vs cheek
+        const eX = x + Math.floor(2 * scale), eY = y + Math.floor(6 * scale), eW = Math.floor(20 * scale), eH = Math.floor(6 * scale);
+        const eyes = boxSum(integral, stride, eX, eY, eX + eW, eY + eH);
+        const cX = x + Math.floor(2 * scale), cY = y + Math.floor(12 * scale), cW = Math.floor(20 * scale), cH = Math.floor(6 * scale);
+        const cheeks = boxSum(integral, stride, cX, cY, cX + cW, cY + cH);
+        const val1 = -1.0 * eyes + 1.0 * cheeks;
+        if (val1 < -10.0 * s2 ? -1.0 : 1.2 < 0.2) continue;
+
+        // Stage 2: Nose bridge
+        const nX = x + Math.floor(10 * scale), nY = y + Math.floor(6 * scale), nW = Math.floor(4 * scale), nH = Math.floor(12 * scale);
+        const nose = boxSum(integral, stride, nX, nY, nX + nW, nY + nH);
+        const lX = x + Math.floor(6 * scale), rX = x + Math.floor(14 * scale);
+        const lCheek = boxSum(integral, stride, lX, nY, lX + nW, nY + nH);
+        const rCheek = boxSum(integral, stride, rX, nY, rX + nW, nY + nH);
+        const val2 = -1.0 * lCheek + 2.0 * nose - 1.0 * rCheek;
+        if (val2 < -5.0 * s2 ? -0.8 : 1.5 < 0.3) continue;
+
+        const area = winW * winH;
+        const meanScore = boxSum(integral, stride, x, y, x + winW, y + winH) / (area || 1);
+        candidates.push({
+          x,
+          y,
+          width: winW,
+          height: winH,
+          score: meanScore,
+          className: 'face_candidate'
+        });
+      }
+    }
+    scale *= scaleFactor;
+  }
+
+  return nms(candidates, 0.3);
+}
+
+module.exports = {
+  computeIoU,
+  nms,
+  computeIntegralImage,
+  boxSum,
+  detectFaces
+};