@pixerate/editor 0.189.0 → 0.191.0

package/dist/{chunk-M7XIC2FC.js → chunk-RQ2EM5TY.js}

@@ -1,3 +1,331 @@
+import {
+  fitCubics,
+  simplifyRing
+} from "./chunk-PWBZH3FK.js";
+
+// src/vector/trace.ts
+var VECTOR_TRACE_MAX_PIXELS = 4e6;
+function signedArea(p) {
+  let a = 0;
+  for (let i = 0; i < p.length; i++) {
+    const [x0, y0] = p[i];
+    const [x1, y1] = p[(i + 1) % p.length];
+    a += x0 * y1 - x1 * y0;
+  }
+  return a / 2;
+}
+function pointInPoly(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const [xi, yi] = poly[i];
+    const [xj, yj] = poly[j];
+    if (yi > p[1] !== yj > p[1] && p[0] < (xj - xi) * (p[1] - yi) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+function vectorTraceContours(field, w, h, threshold) {
+  const gw = w + 2;
+  const gh = h + 2;
+  const val = (i, j) => i === 0 || j === 0 || i > w || j > h ? -Infinity : field[(j - 1) * w + (i - 1)];
+  const inside = (i, j) => val(i, j) >= threshold;
+  const pos = (i, j) => [i - 0.5, j - 0.5];
+  const cross = (a, b) => {
+    const va = val(a[0], a[1]);
+    const vb = val(b[0], b[1]);
+    let t;
+    if (Number.isFinite(va) && Number.isFinite(vb) && Math.abs(vb - va) > 1e-12) t = Math.min(1, Math.max(0, (threshold - va) / (vb - va)));
+    else if (Number.isFinite(va)) t = va >= threshold ? 0.5 : 0;
+    else t = vb >= threshold ? 0.5 : 1;
+    const pa = pos(a[0], a[1]);
+    const pb = pos(b[0], b[1]);
+    return [pa[0] + (pb[0] - pa[0]) * t, pa[1] + (pb[1] - pa[1]) * t];
+  };
+  const hid = (i, j) => 2 * (j * gw + i);
+  const vid = (i, j) => 2 * (j * gw + i) + 1;
+  const next = /* @__PURE__ */ new Map();
+  const point = /* @__PURE__ */ new Map();
+  for (let j = 0; j < gh - 1; j++) {
+    for (let i = 0; i < gw - 1; i++) {
+      const tl = inside(i, j);
+      const tr = inside(i + 1, j);
+      const br = inside(i + 1, j + 1);
+      const bl = inside(i, j + 1);
+      const code = +tl << 3 | +tr << 2 | +br << 1 | +bl;
+      if (code === 0 || code === 15) continue;
+      const top = hid(i, j);
+      const bottom = hid(i, j + 1);
+      const left = vid(i, j);
+      const right = vid(i + 1, j);
+      const seg = (a, b) => next.set(a, b);
+      const mean = () => (val(i, j) + val(i + 1, j) + val(i + 1, j + 1) + val(i, j + 1)) / 4;
+      switch (code) {
+        case 1:
+          seg(left, bottom);
+          break;
+        case 2:
+          seg(bottom, right);
+          break;
+        case 3:
+          seg(left, right);
+          break;
+        case 4:
+          seg(right, top);
+          break;
+        case 5:
+          if (mean() >= threshold) {
+            seg(left, top);
+            seg(right, bottom);
+          } else {
+            seg(left, bottom);
+            seg(right, top);
+          }
+          break;
+        case 6:
+          seg(bottom, top);
+          break;
+        case 7:
+          seg(left, top);
+          break;
+        case 8:
+          seg(top, left);
+          break;
+        case 9:
+          seg(top, bottom);
+          break;
+        case 10:
+          if (mean() >= threshold) {
+            seg(top, right);
+            seg(bottom, left);
+          } else {
+            seg(top, left);
+            seg(bottom, right);
+          }
+          break;
+        case 11:
+          seg(top, right);
+          break;
+        case 12:
+          seg(right, left);
+          break;
+        case 13:
+          seg(right, bottom);
+          break;
+        case 14:
+          seg(bottom, left);
+          break;
+      }
+      const edges = [
+        [top, [i, j], [i + 1, j]],
+        [bottom, [i, j + 1], [i + 1, j + 1]],
+        [left, [i, j], [i, j + 1]],
+        [right, [i + 1, j], [i + 1, j + 1]]
+      ];
+      for (const [e, a, b] of edges) if (inside(a[0], a[1]) !== inside(b[0], b[1]) && !point.has(e)) point.set(e, cross(a, b));
+    }
+  }
+  const out = [];
+  for (const start of [...next.keys()].sort((a, b) => a - b)) {
+    if (!next.has(start)) continue;
+    const poly = [];
+    let e = start;
+    for (; ; ) {
+      const n = next.get(e);
+      if (n === void 0) break;
+      next.delete(e);
+      const p = point.get(e);
+      if (p) poly.push(p);
+      e = n;
+      if (e === start) break;
+    }
+    if (poly.length >= 3) out.push(poly);
+  }
+  return out;
+}
+function squareContourCorners(ring) {
+  const n = ring.length;
+  if (n < 4) return ring;
+  const eq = (u, v) => Math.abs(u - v) < 1e-9;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    const p = ring[(i - 1 + n) % n];
+    const q = ring[(i + 2) % n];
+    const diagonal = Math.abs(Math.abs(b[0] - a[0]) - 0.5) < 0.02 && Math.abs(Math.abs(b[1] - a[1]) - 0.5) < 0.02;
+    const wraps = i === n - 1;
+    let corner = null;
+    if (diagonal && (!wraps || out[0] === ring[0])) {
+      if (eq(p[1], a[1]) && !eq(p[0], a[0]) && eq(q[0], b[0]) && !eq(q[1], b[1])) corner = [b[0], a[1]];
+      else if (eq(p[0], a[0]) && !eq(p[1], a[1]) && eq(q[1], b[1]) && !eq(q[0], b[0])) corner = [a[0], b[1]];
+    }
+    if (!corner) {
+      out.push(a);
+      continue;
+    }
+    out.push(corner);
+    if (wraps) out.shift();
+    else i++;
+  }
+  if (out.length < 3) return ring;
+  const m = out.length;
+  for (let k = 0; k < m; k++) {
+    const p = out[(k - 1 + m) % m];
+    const a = out[k];
+    const q = out[(k + 1) % m];
+    if (Math.abs((a[0] - p[0]) * (q[1] - a[1]) - (a[1] - p[1]) * (q[0] - a[0])) > 1e-6) return k ? [...out.slice(k), ...out.slice(0, k)] : out;
+  }
+  return out;
+}
+function loopsOf(field, w, h, threshold, tolerance, minArea, square = false) {
+  const loops = [];
+  for (const contour of vectorTraceContours(field, w, h, threshold)) {
+    const raw = square ? squareContourCorners(contour) : contour;
+    const area = signedArea(raw);
+    if (Math.abs(area) < Math.max(0, minArea)) continue;
+    const simple = simplifyRing(raw, Math.max(0.01, tolerance));
+    if (simple.length < 3) continue;
+    loops.push({ raw, simple, area, depth: 0 });
+  }
+  for (const l of loops) l.depth = loops.filter((o) => o !== l && Math.abs(o.area) > Math.abs(l.area) && pointInPoly(l.simple[0], o.simple)).length;
+  return loops.sort((a, b) => a.depth - b.depth || Math.abs(b.area) - Math.abs(a.area));
+}
+function loopSubpath(l, tolerance, roundness) {
+  if (roundness <= 0) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
+  const cornerAngleDeg = 25 + roundness * 125;
+  const cubics = fitCubics(l.raw, Math.max(0.05, tolerance), {
+    closed: true,
+    cornerAngleDeg
+  });
+  if (!cubics.length) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
+  const anchors = cubics.map((c, k) => {
+    const prev = cubics[(k - 1 + cubics.length) % cubics.length];
+    return {
+      x: c.p0[0],
+      y: c.p0[1],
+      in: { x: prev.p2[0], y: prev.p2[1] },
+      out: { x: c.p1[0], y: c.p1[1] }
+    };
+  });
+  return { closed: true, anchors };
+}
+function traceField(field, w, h, threshold, o) {
+  const tolerance = o.tolerance ?? 1;
+  const roundness = Math.min(1, Math.max(0, o.cornerRoundness ?? 0.5));
+  return loopsOf(field, w, h, threshold, tolerance, o.minArea ?? 10, o.squareCorners === true).map((l) => loopSubpath(l, tolerance, roundness));
+}
+function quantizeVectorTraceColors(pixels, count) {
+  const n = pixels.width * pixels.height;
+  const d = pixels.data;
+  const opaque = [];
+  for (let i = 0; i < n; i++) if (d[i * 4 + 3] >= 128) opaque.push(i);
+  const boxes = opaque.length ? [opaque] : [];
+  const range = (box, c) => {
+    let lo = 255;
+    let hi = 0;
+    for (const i of box) {
+      const v = d[i * 4 + c];
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    }
+    return hi - lo;
+  };
+  while (boxes.length < count) {
+    let best = -1;
+    let bestRange = 0;
+    let bestC = 0;
+    boxes.forEach((b, k) => {
+      if (b.length < 2) return;
+      for (let c = 0; c < 3; c++) {
+        const r = range(b, c);
+        if (r > bestRange) {
+          bestRange = r;
+          best = k;
+          bestC = c;
+        }
+      }
+    });
+    if (best < 0) break;
+    const box = boxes[best].slice().sort((a, b) => d[a * 4 + bestC] - d[b * 4 + bestC]);
+    const key = (k) => d[box[k] * 4 + bestC];
+    const v = key(box.length >> 1);
+    let mid = box.findIndex((_, k) => key(k) >= v);
+    if (mid <= 0) mid = box.findIndex((_, k) => key(k) > v);
+    boxes.splice(best, 1, box.slice(0, mid), box.slice(mid));
+  }
+  const palette = boxes.map((b) => {
+    const s = [0, 0, 0];
+    for (const i of b) for (let c = 0; c < 3; c++) s[c] += d[i * 4 + c];
+    return [Math.round(s[0] / b.length), Math.round(s[1] / b.length), Math.round(s[2] / b.length)];
+  });
+  const index = new Int16Array(n).fill(-1);
+  const counts = palette.map(() => 0);
+  for (const i of opaque) {
+    let best = 0;
+    let bestD = Infinity;
+    palette.forEach((p, k) => {
+      const dd = (d[i * 4] - p[0]) ** 2 + (d[i * 4 + 1] - p[1]) ** 2 + (d[i * 4 + 2] - p[2]) ** 2;
+      if (dd < bestD) {
+        bestD = dd;
+        best = k;
+      }
+    });
+    index[i] = best;
+    counts[best]++;
+  }
+  return { palette, index, counts };
+}
+var hex = (c) => `#${c.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
+function traceVectorImage(pixels, options = {}) {
+  const { width: w, height: h, data } = pixels;
+  if (!(w > 0 && h > 0) || data.length < w * h * 4) throw new Error("The image has no pixels (or fewer than width \xD7 height \xD7 4 values).");
+  if (w * h > VECTOR_TRACE_MAX_PIXELS) throw new Error(`The image has ${w * h} pixels; scale it down to at most ${VECTOR_TRACE_MAX_PIXELS} to trace it.`);
+  const n = w * h;
+  if ((options.mode ?? "threshold") === "threshold") {
+    const field = new Float32Array(n);
+    const byAlpha = options.channel === "alpha";
+    for (let i = 0; i < n; i++) {
+      const a = data[i * 4 + 3] / 255;
+      field[i] = byAlpha ? a : a * (1 - (0.2126 * data[i * 4] + 0.7152 * data[i * 4 + 1] + 0.0722 * data[i * 4 + 2]) / 255);
+    }
+    const subpaths = traceField(field, w, h, Math.min(1, Math.max(0, options.threshold ?? 0.5)), options);
+    return subpaths.length ? [
+      {
+        id: "trace-1",
+        type: "path",
+        name: "Trace",
+        fill: options.color ?? "#000000",
+        stroke: null,
+        fillRule: "evenodd",
+        subpaths
+      }
+    ] : [];
+  }
+  const count = Math.min(32, Math.max(2, Math.round(options.colors ?? 6)));
+  const q = quantizeVectorTraceColors(pixels, count);
+  const order = q.palette.map((_, k) => k).filter((k) => q.counts[k] > 0).sort((a, b) => q.counts[b] - q.counts[a]);
+  const rank = new Map(order.map((k, r) => [k, r]));
+  const out = [];
+  order.forEach((k, r) => {
+    const field = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+      const ix = q.index[i];
+      field[i] = ix >= 0 && rank.get(ix) >= r ? 1 : 0;
+    }
+    const subpaths = traceField(field, w, h, 0.5, options);
+    if (subpaths.length)
+      out.push({
+        id: `trace-${out.length + 1}`,
+        type: "path",
+        name: hex(q.palette[k]),
+        fill: hex(q.palette[k]),
+        stroke: null,
+        fillRule: "evenodd",
+        subpaths
+      });
+  });
+  return out;
+}
+
 // src/text/opentype.ts
 var fail = (message) => {
   throw new Error(message);
@@ -923,6 +1251,11 @@ async function unwoff(view) {
 }
 
 export {
+  VECTOR_TRACE_MAX_PIXELS,
+  vectorTraceContours,
+  traceField,
+  quantizeVectorTraceColors,
+  traceVectorImage,
   parseOpenTypeFont,
   loadOpenTypeFont
 };