@pixerate/editor 0.203.0 → 0.205.0

package/dist/image-editor/index.js

@@ -4108,6 +4108,49 @@ function refineSelection(pixels, mask, params = {}) {
   }
   return createSelectionMask(mask.width, mask.height, out);
 }
+function decontaminateColors(rgba, coverage, w, h, amount, radius = 8) {
+  const out = Uint8ClampedArray.from(rgba);
+  const n = w * h;
+  const k = Math.min(1, Math.max(0, amount));
+  if (k === 0) return out;
+  const r = Math.max(2, Math.round(radius));
+  const fgW = new Float32Array(n);
+  const bgW = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    fgW[i] = coverage[i] >= 250 ? 1 : 0;
+    bgW[i] = coverage[i] <= 5 ? 1 : 0;
+  }
+  const meanOf = (weights, radiusPx) => {
+    const wm = boxMean(weights, w, h, radiusPx);
+    const planes = [0, 1, 2].map((c) => {
+      const v = new Float32Array(n);
+      for (let i = 0; i < n; i++) v[i] = rgba[i * 4 + c] * weights[i];
+      const m = boxMean(v, w, h, radiusPx);
+      for (let i = 0; i < n; i++) m[i] = wm[i] > 1e-6 ? m[i] / wm[i] : NaN;
+      return m;
+    });
+    return { weight: wm, planes };
+  };
+  const fg = meanOf(fgW, r);
+  const fgWide = meanOf(fgW, r * 3);
+  const bg = meanOf(bgW, r);
+  for (let i = 0; i < n; i++) {
+    const c = coverage[i];
+    if (c <= 5 || c >= 250) continue;
+    const a = c / 255;
+    for (let ch = 0; ch < 3; ch++) {
+      const C = rgba[i * 4 + ch];
+      const B = bg.planes[ch][i];
+      const Fm = Number.isNaN(fg.planes[ch][i]) ? fgWide.planes[ch][i] : fg.planes[ch][i];
+      let F;
+      if (a >= 0.5 && !Number.isNaN(B)) F = (C - (1 - a) * B) / a;
+      else if (!Number.isNaN(Fm)) F = Fm;
+      else F = C;
+      out[i * 4 + ch] = Math.round(C + k * (Math.min(255, Math.max(0, F)) - C));
+    }
+  }
+  return out;
+}
 
 // src/image-editor/selection/segment/guided.ts
 function workPlanes(work) {
@@ -10280,6 +10323,84 @@ var ImageEditorController = class {
     const pixels = (params.radius ?? 0) > 0 ? await this.requirePixels(options) : null;
     return this.setSelection(refineSelection(pixels, sel, params));
   }
+  /**
+   * Select and Mask's output: refines the selection with `params`, then puts the result where
+   * `output` says, as one undo step:
+   * - `selection`: the refined selection;
+   * - `layer-mask`: a mask on the layer (`layerId`, default the active one), then deselects;
+   * - `new-layer`: a new layer of the layer's selected pixels (Layer via Copy), the source hidden;
+   * - `new-layer-with-mask`: a copy of the layer masked by the selection, the source hidden.
+   * `decontaminate` (0..100, new-layer outputs only) replaces the old background's colour in the
+   * soft edge with the subject's own (see `decontaminateColors`).
+   */
+  async refineSelectionTo(params, output = "selection", options = {}) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) throw new Error("Nothing is selected; select first.");
+    const amount = Math.min(100, Math.max(0, options.decontaminate ?? 0)) / 100;
+    const toLayer = output === "new-layer" || output === "new-layer-with-mask";
+    if (amount > 0 && !toLayer) throw new Error("Decontaminate colors writes the cleaned colours to a new layer: use output new-layer or new-layer-with-mask.");
+    let layerId;
+    if (output !== "selection") {
+      layerId = options.layerId ?? this.state.activeLayerId ?? void 0;
+      if (!layerId) throw new LayerOperationError("No layer given and none is active; pass layerId (see list_layers).");
+      const layer = requireLayer(this.state.layers, layerId).layer;
+      if (toLayer && layer.type !== "pixel") throw new LayerOperationError(`Output ${output} needs a pixel layer; "${layerId}" is a ${layer.type} layer.`);
+    }
+    const pixels = (params.radius ?? 0) > 0 ? await this.requirePixels(options) : null;
+    const refined = refineSelection(pixels, sel, params);
+    if (!refined.bounds) throw new Error("Refining left nothing selected; use a smaller shiftEdge or contrast.");
+    return this.asOneStep(() => {
+      this.setSelection(refined);
+      if (output === "selection") return { output };
+      if (output === "layer-mask") {
+        this.addLayerMask(layerId, "selection");
+        this.setSelection(null);
+        return { output, layerId };
+      }
+      let newLayerId2;
+      if (output === "new-layer") newLayerId2 = this.layerViaCopy({ layerId });
+      else {
+        newLayerId2 = this.duplicateLayer(layerId);
+        this.addLayerMask(newLayerId2, "selection");
+        this.state.activeTarget = "pixels";
+      }
+      if (amount > 0) this.decontaminateLayer(newLayerId2, layerId, refined, amount, Math.max(4, params.radius ?? 0));
+      this.setLayerProperties(layerId, { visible: false });
+      this.setSelection(null);
+      return { output, layerId, newLayerId: newLayerId2 };
+    });
+  }
+  /**
+   * Decontaminate Colors along the soft edge of `coverage`: the colours are estimated from the
+   * source layer (whose background is still there) and written into layer `id`'s RGB, keeping
+   * its alpha.
+   */
+  decontaminateLayer(id, sourceId, coverage, amount, radius) {
+    const layer = requireLayer(this.state.layers, id).layer;
+    const source = requireLayer(this.state.layers, sourceId).layer;
+    if (layer.type !== "pixel" || source.type !== "pixel" || !coverage.bounds) return;
+    const { width, height } = this.naturalSize;
+    const pad = Math.ceil(radius * 3);
+    const b = coverage.bounds;
+    const x0 = Math.max(0, b.x - pad);
+    const y0 = Math.max(0, b.y - pad);
+    const box = { x: x0, y: y0, width: Math.min(width, b.x + b.width + pad) - x0, height: Math.min(height, b.y + b.height + pad) - y0 };
+    const src = { x: box.x - layer.offset.x, y: box.y - layer.offset.y, width: box.width, height: box.height };
+    const surface = this.surfaceOf(layer);
+    const rgba = readRegion(surface, src);
+    const original = readRegion(this.surfaceOf(source), { x: box.x - source.offset.x, y: box.y - source.offset.y, width: box.width, height: box.height });
+    const cov = new Uint8Array(box.width * box.height);
+    const all = coverage.data;
+    for (let y = 0; y < box.height; y++) cov.set(all.subarray((box.y + y) * width + box.x, (box.y + y) * width + box.x + box.width), y * box.width);
+    const cleaned = decontaminateColors(original, cov, box.width, box.height, amount, radius);
+    for (let i = 3; i < cleaned.length; i += 4) cleaned[i] = rgba[i];
+    const next = mapLayer(this.state.layers, id, (l) => {
+      const updated = { ...l, surface: writeRegion(surface, src, cleaned) };
+      delete updated.source;
+      return updated;
+    });
+    this.commitLayers(next);
+  }
   /**
    * Loads a selection from a mask image (an AI segmentation, a saved mask): a data URL / URL or
    * RGBA pixels, by luminance (white = selected) or a channel. Any size; it is resampled.
@@ -13251,6 +13372,12 @@ var REFINE_EDGE_CONTROLS = [
   { id: "contrast", label: "Contrast", min: 0, max: 100, step: 1, unit: "%" },
   { id: "shiftEdge", label: "Shift Edge", min: -100, max: 100, step: 1, unit: "%" }
 ];
+var REFINE_OUTPUTS = [
+  { id: "selection", label: "Selection" },
+  { id: "layer-mask", label: "Layer Mask" },
+  { id: "new-layer", label: "New Layer" },
+  { id: "new-layer-with-mask", label: "New Layer with Layer Mask" }
+];
 function describeSelection(mask) {
   if (!mask || !mask.bounds) return "No selection";
   const pct2 = selectionArea(mask) / (mask.width * mask.height) * 100;
@@ -13459,31 +13586,42 @@ function createImageSelectionTools(controller) {
   const refine = {
     name: "refine_selection",
     title: "Refine the selection edge",
-    description: "Refine Edge: snaps the selection edge to the image within radius pixels (edge-aware guided filter), then smooth (0-100), feather (px), contrast (0-100) and shiftEdge (-100..100 %). Use it after loading a coarse AI mask. One undoable step.",
+    description: "Select and Mask / Refine Edge: snaps the selection edge to the image within radius pixels (edge-aware guided filter), then smooth (0-100), feather (px), contrast (0-100) and shiftEdge (-100..100 %), and puts the result where output says: the selection (default), a layer-mask on layerId (default the active layer; then deselects), a new-layer of its selected pixels, or a new-layer-with-mask (a masked copy); the new-layer outputs hide the source layer. decontaminate (0-100, new-layer outputs only) replaces the old background colour in soft edges (hair, fur) with the subject's own. Use it after loading a coarse AI mask, or to cut a subject out cleanly. One undoable step. Returns the selection and, for layer outputs, layerId and newLayerId.",
     inputSchema: {
       type: "object",
       properties: {
-        radius: { type: "number", minimum: 0, maximum: 64, description: "Edge detection radius in pixels." },
+        radius: { type: "number", minimum: 0, maximum: 64, description: "Edge detection radius in pixels (default 8)." },
         smartRadius: { type: "boolean", description: "Adapt the radius to hard and soft edges." },
         smooth: { type: "number", minimum: 0, maximum: 100, description: "Smooth the edge outline (0-100)." },
         feather: { type: "number", minimum: 0, maximum: 250, description: "Feather the edge (pixels)." },
         contrast: { type: "number", minimum: 0, maximum: 100, description: "Sharpen the edge transition (0-100)." },
-        shiftEdge: { type: "number", minimum: -100, maximum: 100, description: "Move the edge out (+) or in (-), in percent." }
+        shiftEdge: { type: "number", minimum: -100, maximum: 100, description: "Move the edge out (+) or in (-), in percent." },
+        output: {
+          type: "string",
+          enum: ["selection", "layer-mask", "new-layer", "new-layer-with-mask"],
+          description: "Where the result goes (default selection). layer-mask keeps every pixel and is easiest to revise; new-layer-with-mask too, on a copy."
+        },
+        layerId: { type: "string", description: "The layer for layer outputs (default the active layer; see list_layers). New-layer outputs need a pixel layer." },
+        decontaminate: { type: "number", minimum: 0, maximum: 100, description: "Decontaminate Colors amount 0-100 (default 0), only with output new-layer or new-layer-with-mask." }
       },
       additionalProperties: false
     },
     annotations: writeAnnotations("Refine the selection edge"),
     handler: async (params) => {
       if (!controller.getSelection()) throw new Error("Nothing is selected.");
-      await controller.refineSelection({
-        radius: num2(params.radius, 8),
-        smartRadius: params.smartRadius === true,
-        smooth: num2(params.smooth, 0),
-        feather: num2(params.feather, 0),
-        contrast: num2(params.contrast, 0),
-        shiftEdge: num2(params.shiftEdge, 0)
-      });
-      return summary(controller);
+      const result = await controller.refineSelectionTo(
+        {
+          radius: num2(params.radius, 8),
+          smartRadius: params.smartRadius === true,
+          smooth: num2(params.smooth, 0),
+          feather: num2(params.feather, 0),
+          contrast: num2(params.contrast, 0),
+          shiftEdge: num2(params.shiftEdge, 0)
+        },
+        params.output ?? "selection",
+        { layerId: typeof params.layerId === "string" ? params.layerId : void 0, decontaminate: num2(params.decontaminate, 0) }
+      );
+      return { ...summary(controller), ...result };
     }
   };
   const applyMask = {
@@ -20702,6 +20840,7 @@ export {
   PsdError,
   QUICK_MASK_TARGET,
   REFINE_EDGE_CONTROLS,
+  REFINE_OUTPUTS,
   RETOUCH_CHOICES,
   RETOUCH_OPTION_CONTROLS,
   RETOUCH_SAMPLES,
@@ -20950,6 +21089,7 @@ export {
   decodePng,
   decodePngDataUrl,
   decodeSelectionRle,
+  decontaminateColors,
   deepBytes,
   deepTile,
   defaultActiveLayerId,

package/dist/image-editor/selection/refine.d.cts

@@ -54,3 +54,12 @@ export declare function guidePlanes(pixels: PixelBuffer, win?: CropBox): [Float3
  * selection on a large image stays cheap.
  */
 export declare function refineSelection(pixels: PixelBuffer | null, mask: SelectionMask, params?: RefineEdgeParams): SelectionMask;
+/**
+ * Decontaminate Colors: along a soft edge, a pixel's colour is part subject and part the old
+ * background (C = αF + (1 − α)B), which shows as a fringe once the subject is on a new background.
+ * Each edge pixel's colour is replaced (by `amount`, 0..1) with an estimate of the subject's own
+ * colour: unmixed from the background's local mean where the pixel is mostly subject, and the
+ * subject's local mean where it is mostly background. Only RGB changes; pixels fully in or out
+ * are kept. `rgba` and `coverage` (0..255) cover the same `w × h` region; returns new RGBA.
+ */
+export declare function decontaminateColors(rgba: ArrayLike<number>, coverage: ArrayLike<number>, w: number, h: number, amount: number, radius?: number): Uint8ClampedArray;

package/dist/image-editor/selection/refine.d.ts

@@ -54,3 +54,12 @@ export declare function guidePlanes(pixels: PixelBuffer, win?: CropBox): [Float3
  * selection on a large image stays cheap.
  */
 export declare function refineSelection(pixels: PixelBuffer | null, mask: SelectionMask, params?: RefineEdgeParams): SelectionMask;
+/**
+ * Decontaminate Colors: along a soft edge, a pixel's colour is part subject and part the old
+ * background (C = αF + (1 − α)B), which shows as a fringe once the subject is on a new background.
+ * Each edge pixel's colour is replaced (by `amount`, 0..1) with an estimate of the subject's own
+ * colour: unmixed from the background's local mean where the pixel is mostly subject, and the
+ * subject's local mean where it is mostly background. Only RGB changes; pixels fully in or out
+ * are kept. `rgba` and `coverage` (0..255) cover the same `w × h` region; returns new RGBA.
+ */
+export declare function decontaminateColors(rgba: ArrayLike<number>, coverage: ArrayLike<number>, w: number, h: number, amount: number, radius?: number): Uint8ClampedArray;

package/dist/image-editor/selection/tool-options.d.cts

@@ -79,5 +79,10 @@ export interface RefineEdgeControl {
 }
 /** Sliders of the Refine Edge panel. */
 export declare const REFINE_EDGE_CONTROLS: readonly RefineEdgeControl[];
+/** Select and Mask's outputs, in menu order. */
+export declare const REFINE_OUTPUTS: readonly {
+    id: 'selection' | 'layer-mask' | 'new-layer' | 'new-layer-with-mask';
+    label: string;
+}[];
 /** A one-line status: "No selection" or "W × H px selected (n % of the image)". */
 export declare function describeSelection(mask: SelectionMask | null | undefined): string;

package/dist/image-editor/selection/tool-options.d.ts

@@ -79,5 +79,10 @@ export interface RefineEdgeControl {
 }
 /** Sliders of the Refine Edge panel. */
 export declare const REFINE_EDGE_CONTROLS: readonly RefineEdgeControl[];
+/** Select and Mask's outputs, in menu order. */
+export declare const REFINE_OUTPUTS: readonly {
+    id: 'selection' | 'layer-mask' | 'new-layer' | 'new-layer-with-mask';
+    label: string;
+}[];
 /** A one-line status: "No selection" or "W × H px selected (n % of the image)". */
 export declare function describeSelection(mask: SelectionMask | null | undefined): string;

package/dist/vector/controller.d.cts

@@ -1378,6 +1378,16 @@ export declare class VectorEditorController {
      * placed by position.
      */
     reorderNode(id: string, index: number): VectorActionResult;
+    /**
+     * Moves a node into group `parentId` (null: the top level; left out: where it is) at `index`
+     * among its new siblings (bottom to top, 0 the bottom; left out: the top), as dragging it in a
+     * layers panel does. It stays where it is on the canvas. Clipping groups and blends keep their
+     * children: their mask and keys are placed by position.
+     */
+    moveNode(id: string, options?: {
+        parentId?: string | null;
+        index?: number;
+    }): VectorActionResult;
     /**
      * Combines the selected paths (two or more) into one with a boolean operation. `subtract`
      * removes the upper shapes from the lowest one. The result takes the lowest shape's style

package/dist/vector/controller.d.ts

@@ -1378,6 +1378,16 @@ export declare class VectorEditorController {
      * placed by position.
      */
     reorderNode(id: string, index: number): VectorActionResult;
+    /**
+     * Moves a node into group `parentId` (null: the top level; left out: where it is) at `index`
+     * among its new siblings (bottom to top, 0 the bottom; left out: the top), as dragging it in a
+     * layers panel does. It stays where it is on the canvas. Clipping groups and blends keep their
+     * children: their mask and keys are placed by position.
+     */
+    moveNode(id: string, options?: {
+        parentId?: string | null;
+        index?: number;
+    }): VectorActionResult;
     /**
      * Combines the selected paths (two or more) into one with a boolean operation. `subtract`
      * removes the upper shapes from the lowest one. The result takes the lowest shape's style