web-sdk-pp-detection 0.3.0 → 0.3.1

package/dist/index.d.ts

@@ -635,7 +635,7 @@ declare class IndexedDBModelCache implements ModelCache {
 declare global {
     var __PPDETECTION_SCRIPT_URL__: string | undefined;
 }
-declare const CURRENT_SDK_VERSION = "0.3.0";
+declare const CURRENT_SDK_VERSION = "0.3.1";
 
 declare function probePPDetectionCapabilities(options?: CapabilityProbeOptions): DetectionCapabilities;
 

package/dist/index.js

@@ -371,34 +371,58 @@ function clipBicubic(value) {
   const rounded = value >> BICUBIC_PRECISION_BITS;
   return Math.max(0, Math.min(255, rounded));
 }
-function bicubicChannel(raster, resizedWidth, resizedHeight, channel) {
+function writeBicubicChannels(raster, resizedWidth, resizedHeight, target) {
   const horizontal = createBicubicAxis(raster.width, resizedWidth);
   const vertical = createBicubicAxis(raster.height, resizedHeight);
-  const intermediate = new Uint8Array(raster.height * resizedWidth);
+  const rowStride = resizedWidth * 3;
+  const intermediate = new Uint8Array(raster.height * rowStride);
   for (let y = 0; y < raster.height; y += 1) {
+    const sourceRow = y * raster.width * 4;
+    const targetRow = y * rowStride;
     for (let x = 0; x < resizedWidth; x += 1) {
       const [start, count] = horizontal.bounds[x];
       const coefficients = horizontal.coefficients[x];
-      let sum = BICUBIC_ROUNDING;
+      let red = BICUBIC_ROUNDING;
+      let green = BICUBIC_ROUNDING;
+      let blue = BICUBIC_ROUNDING;
+      let source2 = sourceRow + start * 4;
       for (let index = 0; index < count; index += 1) {
-        sum += raster.rgba[(y * raster.width + start + index) * 4 + channel] * coefficients[index];
+        const coefficient = coefficients[index];
+        red += raster.rgba[source2] * coefficient;
+        green += raster.rgba[source2 + 1] * coefficient;
+        blue += raster.rgba[source2 + 2] * coefficient;
+        source2 += 4;
       }
-      intermediate[y * resizedWidth + x] = clipBicubic(sum);
+      const offset = targetRow + x * 3;
+      intermediate[offset] = clipBicubic(red);
+      intermediate[offset + 1] = clipBicubic(green);
+      intermediate[offset + 2] = clipBicubic(blue);
     }
   }
-  const output = new Uint8Array(resizedWidth * resizedHeight);
+  const plane = target.inputWidth * target.inputHeight;
   for (let y = 0; y < resizedHeight; y += 1) {
     const [start, count] = vertical.bounds[y];
     const coefficients = vertical.coefficients[y];
+    const sourceRow = start * rowStride;
+    const targetRow = (y + target.padTop) * target.inputWidth + target.padLeft;
     for (let x = 0; x < resizedWidth; x += 1) {
-      let sum = BICUBIC_ROUNDING;
+      let red = BICUBIC_ROUNDING;
+      let green = BICUBIC_ROUNDING;
+      let blue = BICUBIC_ROUNDING;
+      let source2 = sourceRow + x * 3;
       for (let index = 0; index < count; index += 1) {
-        sum += intermediate[(start + index) * resizedWidth + x] * coefficients[index];
+        const coefficient = coefficients[index];
+        red += intermediate[source2] * coefficient;
+        green += intermediate[source2 + 1] * coefficient;
+        blue += intermediate[source2 + 2] * coefficient;
+        source2 += rowStride;
       }
-      output[y * resizedWidth + x] = clipBicubic(sum);
+      const offset = targetRow + x;
+      target.data[offset] = target.values[clipBicubic(red)];
+      target.data[plane + offset] = target.values[256 + clipBicubic(green)];
+      target.data[plane * 2 + offset] = target.values[512 + clipBicubic(blue)];
     }
   }
-  return output;
 }
 function preprocessImage(raster, preprocessing) {
   const inputWidth = preprocessing.size.width;
@@ -425,18 +449,35 @@ function preprocessImage(raster, preprocessing) {
   const mean = normalize ? preprocessing.mean ?? [0, 0, 0] : [0, 0, 0];
   const std = normalize ? preprocessing.std ?? [1, 1, 1] : [1, 1, 1];
   const interpolation2 = preprocessing.interpolation ?? "bilinear";
+  const bicubicValues = doResize && interpolation2 === "bicubic" ? new Float32Array(256 * 3) : void 0;
   for (let channel = 0; channel < 3; channel += 1) {
     const padding = normalize && mean[channel] !== 0 ? -mean[channel] / std[channel] : 0;
     data.fill(padding, channel * plane, (channel + 1) * plane);
-    const bicubic = doResize && interpolation2 === "bicubic" ? bicubicChannel(raster, resizedWidth, resizedHeight, channel) : void 0;
+    if (bicubicValues) {
+      for (let pixel = 0; pixel < 256; pixel += 1) {
+        const scaled = rescale ? pixel * preprocessing.rescaleFactor : pixel;
+        bicubicValues[channel * 256 + pixel] = normalize ? (scaled - mean[channel]) / std[channel] : scaled;
+      }
+      continue;
+    }
     for (let y = 0; y < resizedHeight; y += 1) {
       for (let x = 0; x < resizedWidth; x += 1) {
-        const pixel = bicubic ? bicubic[y * resizedWidth + x] : doResize ? bilinearChannel(raster, x, y, resizedWidth, resizedHeight, channel) : sampleChannel(raster, x, y, channel);
+        const pixel = doResize ? bilinearChannel(raster, x, y, resizedWidth, resizedHeight, channel) : sampleChannel(raster, x, y, channel);
         const scaled = rescale ? pixel * preprocessing.rescaleFactor : pixel;
         data[channel * plane + (y + padTop) * inputWidth + x + padLeft] = normalize ? (scaled - mean[channel]) / std[channel] : scaled;
       }
     }
   }
+  if (bicubicValues) {
+    writeBicubicChannels(raster, resizedWidth, resizedHeight, {
+      data,
+      inputWidth,
+      inputHeight,
+      padLeft,
+      padTop,
+      values: bicubicValues
+    });
+  }
   return {
     data,
     dims: [1, 3, inputHeight, inputWidth],
@@ -2219,7 +2260,7 @@ var WorkerBridge = class {
 };
 
 // src/index.ts
-var CURRENT_SDK_VERSION = "0.3.0";
+var CURRENT_SDK_VERSION = "0.3.1";
 function probePPDetectionCapabilities(options = {}) {
   return probeCapabilities(options);
 }