web-sdk-pp-detection 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -141,6 +141,7 @@ interface PPDetectionProgressEvent {
     readonly fallback?: PPDetectionFallback;
 }
 interface CreatePPDetectionOptions {
+    readonly allowExperimental?: boolean;
     readonly allowFallback?: boolean;
     readonly backend?: BackendPreference;
     readonly cache?: boolean | "memory" | "indexeddb";
@@ -401,6 +402,7 @@ declare class PPDetectionError extends Error {
 }
 
 interface SelectExecutionOptions {
+    readonly allowExperimental?: boolean;
     readonly backend?: BackendPreference;
     readonly precision?: Precision;
     readonly executionMode?: ExecutionMode;
@@ -633,7 +635,7 @@ declare class IndexedDBModelCache implements ModelCache {
 declare global {
     var __PPDETECTION_SCRIPT_URL__: string | undefined;
 }
-declare const CURRENT_SDK_VERSION = "0.2.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],
@@ -2031,13 +2072,19 @@ function selectExecutionPlan(options, capabilities, manifest) {
   if (executionMode === "worker" && !capabilities.worker) {
     fail("CAPABILITY_UNSUPPORTED", "\u8BF7\u6C42\u7684 worker \u4E0D\u53EF\u7528", { executionMode });
   }
-  const variant3 = manifest.variants?.find(
-    (candidate) => candidate.precision === requestedPrecision && candidate.status !== "labs" && candidate.status !== "blocked"
-  );
+  const matchingVariants = manifest.variants?.filter(
+    (candidate) => candidate.precision === requestedPrecision && candidate.status !== "blocked"
+  ) ?? [];
+  const variant3 = matchingVariants.find((candidate) => candidate.status !== "labs") ?? (options.allowExperimental === true ? matchingVariants.find((candidate) => candidate.status === "labs") : void 0);
   if (!variant3) {
-    fail("MODEL_INCOMPATIBLE", `manifest \u6CA1\u6709\u53EF\u7528\u7684 ${requestedPrecision} \u7A33\u5B9A\u53D8\u4F53`, {
-      requestedPrecision
-    });
+    fail(
+      "MODEL_INCOMPATIBLE",
+      options.allowExperimental === true ? `manifest \u6CA1\u6709\u53EF\u7528\u7684 ${requestedPrecision} \u53D8\u4F53` : `manifest \u6CA1\u6709\u53EF\u7528\u7684 ${requestedPrecision} \u7A33\u5B9A\u53D8\u4F53`,
+      {
+        requestedPrecision,
+        allowExperimental: options.allowExperimental === true
+      }
+    );
   }
   const candidates = candidatesForBackend(requestedBackend, capabilities).filter(
     (backend) => variant3.backends.includes(backend)
@@ -2213,7 +2260,7 @@ var WorkerBridge = class {
 };
 
 // src/index.ts
-var CURRENT_SDK_VERSION = "0.2.0";
+var CURRENT_SDK_VERSION = "0.3.1";
 function probePPDetectionCapabilities(options = {}) {
   return probeCapabilities(options);
 }
@@ -2328,6 +2375,7 @@ async function createPPDetection(options = {}) {
   options.onProgress?.({ phase: "manifest", status: "complete" });
   const plan = selectExecutionPlan(
     {
+      allowExperimental: options.allowExperimental,
       backend: options.backend,
       precision: options.precision === "auto" ? void 0 : options.precision,
       executionMode: options.executionMode,