@ikijs/editor 0.8.1 → 0.9.0

package/dist/index.mjs

@@ -1420,6 +1420,242 @@ function detectAlphaBbox(rgba, width, height) {
   return { x, y, w: x2 - x + 1, h: y2 - y + 1 };
 }
 
+// src/layer-measure.ts
+var HEAD_BAND = 10;
+var ALPHA_OPAQUE = 128;
+function denseCoreOf(rgba, width, height) {
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (rgba[(y * width + x) * 4 + 3] >= ALPHA_OPAQUE) {
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+    }
+  }
+  if (maxX < 0) return null;
+  return { x: minX, y: minY, w: maxX - minX + 1, h: maxY - minY + 1 };
+}
+var SPECK_CORE_FRACTION = 0.25;
+function isSpeckCore(core, part) {
+  return core.w < SPECK_CORE_FRACTION * part.w || core.h < SPECK_CORE_FRACTION * part.h;
+}
+function foregroundSpan(mask, width, height, rowLo, rowHi) {
+  let left = width;
+  let right = -1;
+  for (let y = Math.max(0, rowLo); y <= Math.min(height - 1, rowHi); y++) {
+    for (let x = 0; x < width; x++) {
+      if (!mask[y * width + x]) continue;
+      if (x < left) left = x;
+      if (x > right) right = x;
+    }
+  }
+  return { left, right };
+}
+function headHalfOf(span) {
+  return (span.right - span.left + 1) / 2;
+}
+function eyeBandRowOf(layers) {
+  const centreY = (role) => {
+    const layer = layers.find((l) => l.role === role);
+    return layer && layer.bbox.y + layer.bbox.h / 2;
+  };
+  const pairRow = (left, right) => {
+    const a = centreY(left);
+    const b = centreY(right);
+    return a === void 0 || b === void 0 ? void 0 : (a + b) / 2;
+  };
+  const row = pairRow("iris_L", "iris_R") ?? pairRow("eye_L", "eye_R");
+  if (row === void 0) {
+    throw new Error("auto-rig: no eye pair to measure the head width at");
+  }
+  return Math.round(row);
+}
+function foregroundSpanOfRows(rowLeft, rowRight, rowLo, rowHi) {
+  let left = Infinity;
+  let right = -Infinity;
+  for (let y = Math.max(0, rowLo); y <= Math.min(rowLeft.length - 1, rowHi); y++) {
+    if (rowLeft[y] < left) left = rowLeft[y];
+    if (rowRight[y] > right) right = rowRight[y];
+  }
+  return { left, right };
+}
+function facePlateHalfOf(layers) {
+  const face = layers.find((l) => l.role === "face");
+  if (face === void 0) {
+    throw new Error("auto-rig: no face layer to measure the plate against");
+  }
+  return face.cropW / 2;
+}
+var STRAND_MIN_RUN_FRACTION = 0.5;
+function createLayerSetMeasurer(canvas) {
+  for (const field of ["width", "height"]) {
+    const value = canvas[field];
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new Error(
+        `auto-rig: createLayerSetMeasurer: canvas.${field} must be a positive safe integer, got ${value}`
+      );
+    }
+  }
+  const { width: canvasW, height: canvasH } = canvas;
+  const rgbaLength = canvasW * canvasH * 4;
+  if (!Number.isSafeInteger(rgbaLength)) {
+    throw new Error(
+      `auto-rig: createLayerSetMeasurer: canvas ${canvasW}x${canvasH} is too large: width \xD7 height \xD7 4 = ${rgbaLength} is not a safe integer`
+    );
+  }
+  const opaque = new Uint8Array(canvasW * canvasH);
+  const layerInputs = [];
+  const rowSpansByRole = [];
+  let hairFrontMask;
+  function add({ role, fileName, rgba }) {
+    if (rgba.length !== rgbaLength) {
+      throw new Error(
+        `auto-rig: layer "${fileName}": rgba length ${rgba.length} is not ${canvasW}x${canvasH}x4 = ${rgbaLength}`
+      );
+    }
+    const bbox = detectAlphaBbox(rgba, canvasW, canvasH);
+    if (bbox === null) return null;
+    const rowLeft = new Int32Array(canvasH).fill(canvasW);
+    const rowRight = new Int32Array(canvasH).fill(-1);
+    const ownMask = role === "hair_front" ? new Uint8Array(canvasW * canvasH) : void 0;
+    for (let y = 0; y < canvasH; y++) {
+      for (let x = 0; x < canvasW; x++) {
+        const p = y * canvasW + x;
+        if (rgba[p * 4 + 3] < ALPHA_OPAQUE) continue;
+        opaque[p] = 1;
+        if (ownMask !== void 0) ownMask[p] = 1;
+        if (x < rowLeft[y]) rowLeft[y] = x;
+        if (x > rowRight[y]) rowRight[y] = x;
+      }
+    }
+    rowSpansByRole.push({ role, rowLeft, rowRight });
+    if (ownMask !== void 0) hairFrontMask = ownMask;
+    const layer = {
+      role,
+      fileName,
+      canvasW,
+      canvasH,
+      bbox,
+      cropW: bbox.w,
+      cropH: bbox.h
+    };
+    if (role === "face") {
+      const rowHalfWidths = [];
+      for (let y = bbox.y; y < bbox.y + bbox.h; y++) {
+        rowHalfWidths.push(
+          rowRight[y] >= rowLeft[y] ? headHalfOf({ left: rowLeft[y], right: rowRight[y] }) : 0
+        );
+      }
+      layer.rowHalfWidths = rowHalfWidths;
+    } else if (role === "nose") {
+      const core = denseCoreOf(rgba, canvasW, canvasH);
+      if (core !== null && !isSpeckCore(core, bbox)) layer.denseCore = core;
+    }
+    layerInputs.push(layer);
+    return layer;
+  }
+  function finish() {
+    const eyeRow = eyeBandRowOf(layerInputs);
+    const span = foregroundSpan(
+      opaque,
+      canvasW,
+      canvasH,
+      eyeRow - HEAD_BAND,
+      eyeRow + HEAD_BAND
+    );
+    const headHalfWidth = span.right > span.left ? headHalfOf(span) : void 0;
+    const headHalfWidthApplied = headHalfWidth !== void 0 && headHalfWidth > facePlateHalfOf(layerInputs);
+    let headEdges;
+    if (headHalfWidthApplied) {
+      const bandLo = eyeRow - HEAD_BAND;
+      const bandHi = eyeRow + HEAD_BAND;
+      const left = [];
+      const right = [];
+      for (const { role, rowLeft, rowRight } of rowSpansByRole) {
+        const own = foregroundSpanOfRows(rowLeft, rowRight, bandLo, bandHi);
+        if (own.right <= own.left) continue;
+        left.push({ role, x: own.left - canvasW / 2 });
+        right.push({ role, x: own.right - canvasW / 2 });
+      }
+      headEdges = { left, right };
+    }
+    let strandEdges;
+    const irisLayers = layerInputs.filter((l) => l.role === "iris_L" || l.role === "iris_R").sort((a, b) => a.bbox.x + a.bbox.w / 2 - (b.bbox.x + b.bbox.w / 2));
+    if (hairFrontMask !== void 0 && irisLayers.length === 2) {
+      const mask = hairFrontMask;
+      const half = canvasW / 2;
+      const strandOn = (iris, other, side) => {
+        const r = Math.floor(iris.bbox.y + iris.bbox.h / 2);
+        const centre = iris.bbox.x + iris.bbox.w / 2;
+        const otherX = other.bbox.x + other.bbox.w / 2 - half;
+        const c = side < 0 ? Math.ceil(centre) - 1 : Math.floor(centre);
+        const span2 = rowSpansByRole.find((s) => s.role === iris.role);
+        if (span2.rowRight[r] < span2.rowLeft[r]) return void 0;
+        const minRun = STRAND_MIN_RUN_FRACTION * (span2.rowRight[r] + 1 - span2.rowLeft[r]);
+        const strand = new Uint8Array(canvasW);
+        for (let a = 0; a < canvasW; ) {
+          if (mask[r * canvasW + a] !== 1) {
+            a++;
+            continue;
+          }
+          let b = a;
+          while (b < canvasW && mask[r * canvasW + b] === 1) b++;
+          if (b - a >= minRun) strand.fill(1, a, b);
+          a = b;
+        }
+        const strandAt = (x2) => x2 >= 0 && x2 < canvasW && strand[x2] === 1;
+        const outerBoundary = (x2) => (side < 0 ? x2 : x2 + 1) - half;
+        let x = c;
+        let runFace;
+        if (!strandAt(c)) {
+          while (x >= 0 && x < canvasW && !strandAt(x)) x += side;
+          if (x < 0 || x >= canvasW) return void 0;
+          runFace = outerBoundary(x - side);
+        } else {
+          let f = c - side;
+          while (strandAt(f)) f -= side;
+          const face = outerBoundary(f);
+          runFace = side * (face - otherX) > 0 ? face : null;
+        }
+        while (strandAt(x)) x += side;
+        return {
+          y: canvasH / 2 - (r + 0.5),
+          irisOuter: (side < 0 ? span2.rowLeft[r] : span2.rowRight[r] + 1) - half,
+          irisInner: (side < 0 ? span2.rowRight[r] + 1 : span2.rowLeft[r]) - half,
+          runOuter: outerBoundary(x - side),
+          runFace
+        };
+      };
+      const [low, high] = irisLayers;
+      const left = strandOn(low, high, -1);
+      const right = strandOn(high, low, 1);
+      if (left !== void 0 || right !== void 0) {
+        strandEdges = {
+          ...left === void 0 ? {} : { left },
+          ...right === void 0 ? {} : { right }
+        };
+      }
+    }
+    return {
+      layers: layerInputs,
+      ...headHalfWidth === void 0 ? {} : { headHalfWidth },
+      headHalfWidthApplied,
+      turnOptions: {
+        ...headHalfWidthApplied ? { turnTargets: { headHalfWidth } } : {},
+        ...headEdges === void 0 ? {} : { headEdges },
+        ...strandEdges === void 0 ? {} : { strandEdges }
+      }
+    };
+  }
+  return { add, finish };
+}
+
 // src/binding-capture.ts
 function captureBindingEndpoint(channel, restValue, posedValue) {
   if (channel === "opacity") {
@@ -4396,6 +4632,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 }
 export {
   ALPHA_BBOX_THRESHOLD,
+  ALPHA_OPAQUE,
   ATLAS_PADDING,
   AddDeformer,
   AddPart,
@@ -4406,6 +4643,8 @@ export {
   DeletePart,
   DeletePhysicsRig,
   EditorDocument,
+  HEAD_BAND,
+  SPECK_CORE_FRACTION,
   SetDeformerBindings,
   SetDeformerParent,
   SetDeformerPivot,
@@ -4429,9 +4668,14 @@ export {
   createDefaultPart,
   createDefaultWarpDeformer,
   createGridMesh,
+  createLayerSetMeasurer,
+  denseCoreOf,
   detectAlphaBbox,
+  foregroundSpan,
   generateIkiFromLayerSet,
+  headHalfOf,
   interpolateGridOffsets,
+  isSpeckCore,
   packAtlas,
   parseLayerRoles,
   upsertGridKeyform,