emf-converter 4.6.7 → 4.6.9

package/dist/index.js

@@ -16486,11 +16486,11 @@ function mirror(p, n) {
   }
   return p;
 }
-function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical = false, edgeWidth = w, edgeHeight = h, verticalRows = Math.ceil(h / w)) {
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows = Math.ceil(h / w)) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = taps >= edgeWidth ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = taps >= edgeHeight ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = taps >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = taps >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row2 = y * w * 4;
@@ -16501,22 +16501,22 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
       let s3 = 0;
       for (let j = -taps; j <= taps; j++) {
         const p = row2 + horizontalIndex(x + j) * 4;
-        const kw = k[j + taps];
-        s0 += kw * src[p];
-        s1 += kw * src[p + 1];
-        s2 += kw * src[p + 2];
-        s3 += kw * src[p + 3];
+        const kw = k[j + taps] * 256;
+        s0 += Math.round(kw * src[p]);
+        s1 += Math.round(kw * src[p + 1]);
+        s2 += Math.round(kw * src[p + 2]);
+        s3 += Math.round(kw * src[p + 3]);
       }
       const o = row2 + x * 4;
-      out[o] = Math.round(s0);
-      out[o + 1] = Math.round(s1);
-      out[o + 2] = Math.round(s2);
-      out[o + 3] = Math.round(s3);
+      out[o] = Math.floor((s0 + 128) / 256);
+      out[o + 1] = Math.floor((s1 + 128) / 256);
+      out[o + 2] = Math.floor((s2 + 128) / 256);
+      out[o + 3] = Math.floor((s3 + 128) / 256);
     }
   }
   if (taps > 0 && vRow >= 0 && vRow < h) {
     const horizontal = out.slice();
-    const endRow = fullVertical ? h : Math.min(h, vRow + verticalRows);
+    const endRow = Math.min(h, vRow + verticalRows);
     for (let row2 = vRow; row2 < endRow; row2++) {
       const col = new Float64Array(w * 4);
       for (let j = -taps; j <= taps; j++) {
@@ -16526,7 +16526,7 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
         }
         const base = verticalIndex(yy) * w * 4;
         for (let i = 0; i < w * 4; i++) {
-          col[i] += k[j + taps] * horizontal[base + i];
+          col[i] += Math.round(k[j + taps] * horizontal[base + i] * 256) / 256;
         }
       }
       out.set(col, row2 * w * 4);
@@ -16537,48 +16537,56 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
 function blurReduction(radius) {
   return radius < 20 ? 1 : radius < 40 ? 2 : radius <= 80 ? 4 : radius < 160 ? 8 : 16;
 }
-function effectBlur(src, width, height, radius, expanded = false) {
-  const factor = blurReduction(radius);
-  if (factor === 1 || (width < 4 || height < 4) && (width % factor !== 0 || height % factor !== 0)) {
-    return gdipBlur(src, width, height, radius);
-  }
-  const w = Math.ceil(width / factor);
-  const h = Math.ceil(height / factor);
-  const reduced = new Uint8ClampedArray(w * h * 4);
-  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-    const x1 = Math.min(width, (x + 1) * factor), y1 = Math.min(height, (y + 1) * factor);
-    const count = (x1 - x * factor) * (y1 - y * factor);
-    for (let c = 0; c < 4; c++) {
+function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start: 0, size: length, pad: 0 }) {
+  const inner = Math.ceil(span.size / factor);
+  const n = inner + 2 * span.pad;
+  const taps = (k.length - 1) / 2;
+  const index = taps >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
+  const reduced = new Float64Array(n);
+  const filtered = new Float64Array(n);
+  const k256 = k.map((w) => w * 256);
+  for (let lane = 0; lane < lanes; lane++) for (let c = 0; c < 4; c++) {
+    for (let b = span.pad; b < span.pad + inner; b++) {
+      const from = span.start + (b - span.pad) * factor;
+      const end = Math.min(span.start + span.size, from + factor);
       let sum = 0;
-      for (let yy = y * factor; yy < y1; yy++) for (let xx = x * factor; xx < x1; xx++) sum += src[(yy * width + xx) * 4 + c];
-      reduced[(y * w + x) * 4 + c] = Math.floor(sum / count);
+      for (let i = from; i < end; i++) sum += get(i, lane, c);
+      reduced[b] = Math.floor(sum / (end - from));
     }
-  }
-  const filtered = gdipBlur(reduced, w, h, radius / factor, 0, false, true, Math.floor(width / factor), Math.floor(height / factor));
-  if (!expanded) {
-    const out2 = new Float64Array(src.length);
-    for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-      const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-      const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-      const x1 = Math.min(w - 1, ix + 1), y1 = Math.min(h - 1, iy + 1);
-      for (let c = 0; c < 4; c++) {
-        const at = (xx, yy) => filtered[(yy * w + xx) * 4 + c];
-        const top = Math.floor((1 - fx) * at(ix, iy) + fx * at(x1, iy));
-        const bottom = Math.floor((1 - fx) * at(ix, y1) + fx * at(x1, y1));
-        out2[(y * width + x) * 4 + c] = Math.floor((1 - fy) * top + fy * bottom);
+    for (let b = 0; b < n; b++) {
+      let sum = 0;
+      if (b >= taps && b + taps < n) {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[b - taps + j]);
+      } else {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[index(b - taps + j)]);
       }
+      filtered[b] = Math.floor((sum + 128) / 256);
+    }
+    for (let i = 0; i < length; i++) {
+      const p = (i - span.start + 0.5) / factor - 0.5 + span.pad;
+      const a = clamp(Math.floor(p), 0, Math.max(0, n - 2));
+      const t = p - a;
+      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[a] + t * filtered[Math.min(n - 1, a + 1)] + 1e-9), 0, 255));
     }
-    return out2;
   }
-  for (let i = 0; i < filtered.length; i++) filtered[i] = Math.round(filtered[i]);
-  const out = new Float64Array(src.length);
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-    const a = (iy * w + ix) * 4, b = (iy * w + Math.min(w - 1, ix + 1)) * 4;
-    const d = (Math.min(h - 1, iy + 1) * w + ix) * 4, e = (Math.min(h - 1, iy + 1) * w + Math.min(w - 1, ix + 1)) * 4;
-    for (let c = 0; c < 4; c++) out[(y * width + x) * 4 + c] = Math.round((1 - fy) * ((1 - fx) * filtered[a + c] + fx * filtered[b + c]) + fy * ((1 - fx) * filtered[d + c] + fx * filtered[e + c]));
+}
+function effectBlur(src, width, height, radius, region) {
+  const factor = blurReduction(radius);
+  if (factor === 1) {
+    return gdipBlur(src, width, height, radius);
   }
+  const k = blurKernel(radius / factor);
+  const pad = region ? Math.ceil(Math.ceil(radius) / factor) : 0;
+  const spanX = region ? { start: region.x, size: region.w, pad } : void 0;
+  const spanY = region ? { start: region.y, size: region.h, pad } : void 0;
+  const rows = new Uint8Array(src.length);
+  blurAxis(width, height, factor, k, Math.floor(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
+    rows[(lane * width + i) * 4 + c] = v;
+  }, spanX);
+  const out = new Float64Array(src.length);
+  blurAxis(height, width, factor, k, Math.floor(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
+    out[(i * width + lane) * 4 + c] = v;
+  }, spanY);
   return out;
 }
 function applyBlur(src, w, h, radius) {
@@ -16664,7 +16672,7 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
     const gy1 = Math.min(height, y1 + r);
     copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
   }
-  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, false, bw, bh, Math.ceil((y1 - y0) / (x1 - x0)));
+  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {
@@ -31461,28 +31469,92 @@ function halftoneAxis(start, srcLen, dstLen, reverse) {
   if (reverse) taps.reverse();
   return taps;
 }
-var SOFT_TENT_SIGMA = 0.25;
-var SOFT_TENT_STEPS = 31;
-var SOFT_TENT_SPAN = 3;
-var softTentCache = /* @__PURE__ */ new Map();
-function softTent(d) {
-  const key = Math.round(d * 1024);
-  const cached = softTentCache.get(key);
-  if (cached !== void 0) {
-    return cached;
+function halftoneReduceTaps(srcLen, dstLen, reverse) {
+  if (dstLen >= srcLen) return halftoneAxis(0, srcLen, dstLen, reverse);
+  const taps = [];
+  for (let i = 0; i < dstLen; i++) {
+    const from = i * srcLen;
+    const to = (i + 1) * srcLen;
+    const run = [];
+    let rest = 0;
+    for (let k = Math.floor(from / dstLen); k * dstLen < to; k++) {
+      const overlap = Math.min(to, (k + 1) * dstLen) - Math.max(from, k * dstLen);
+      if (overlap <= 0) continue;
+      const w = Math.ceil(overlap * FIX / srcLen);
+      run.push([k, w]);
+      if (run.length > 1) rest += w;
+    }
+    if (run.length > 1) run[0][1] = FIX - rest;
+    taps.push(run);
   }
-  let sum = 0;
+  if (reverse) taps.reverse();
+  return taps;
+}
+var ENLARGE_KERNEL = [
+  0.7598,
+  0.7276,
+  0.6829,
+  0.6528,
+  0.6106,
+  0.5745,
+  0.5362,
+  0.4955,
+  0.457,
+  0.4121,
+  0.3762,
+  0.3233,
+  0.2741,
+  0.226,
+  0.1822,
+  0.1412,
+  0.1021,
+  0.0685,
+  0.0382,
+  0.0138,
+  0
+];
+var ENLARGE_BOX = 0.2429;
+var ENLARGE_STEP = 0.05;
+function enlargeKernel(u) {
+  const edge = u / ENLARGE_STEP;
+  const i = Math.floor(edge);
+  const smooth = i >= ENLARGE_KERNEL.length - 1 ? 0 : ENLARGE_KERNEL[i] + (ENLARGE_KERNEL[i + 1] - ENLARGE_KERNEL[i]) * (edge - i);
+  return smooth + ENLARGE_BOX * (Math.abs(u - 0.5) < 1e-9 ? 0.5 : u < 0.5 ? 1 : 0);
+}
+function halftoneEnlargeTaps(src, dst) {
+  const ratio = dst / src;
+  const reach = Math.ceil((ENLARGE_KERNEL.length - 1) * ENLARGE_STEP * ratio);
+  const fir = [];
   let total = 0;
-  const half = (SOFT_TENT_STEPS - 1) / 2;
-  for (let i = -half; i <= half; i++) {
-    const x = i / half * SOFT_TENT_SPAN * SOFT_TENT_SIGMA;
-    const g = Math.exp(-(x * x) / (2 * SOFT_TENT_SIGMA * SOFT_TENT_SIGMA));
-    total += g;
-    sum += g * Math.max(0, 1 - Math.abs(key / 1024 + x));
+  for (let k = 0; k <= reach; k++) {
+    const w = enlargeKernel(k / ratio);
+    fir.push(w);
+    total += k === 0 ? w : 2 * w;
+  }
+  const cover = [];
+  for (let x = 0; x < dst; x++) {
+    const lo = x / ratio;
+    const hi = (x + 1) / ratio;
+    const run = [];
+    for (let j = Math.max(0, Math.floor(lo)); j < Math.min(src, hi); j++) {
+      const overlap = Math.min(hi, j + 1) - Math.max(lo, j);
+      if (overlap > 0) run.push([j, overlap * ratio]);
+    }
+    cover.push(run);
+  }
+  const taps = [];
+  for (let x = 0; x < dst; x++) {
+    const weights = /* @__PURE__ */ new Map();
+    for (let k = -reach; k <= reach; k++) {
+      const w = fir[Math.abs(k)] / total;
+      if (w === 0) continue;
+      for (const [j, v] of cover[Math.max(0, Math.min(dst - 1, x + k))]) {
+        weights.set(j, (weights.get(j) ?? 0) + w * v);
+      }
+    }
+    taps.push([...weights.entries()]);
   }
-  const value = sum / total;
-  softTentCache.set(key, value);
-  return value;
+  return taps;
 }
 function ditherPixels(px, w, h, dither, flipX, flipY, phaseX, phaseY) {
   for (let y = 0; y < h; y++) {
@@ -31624,7 +31696,7 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
   const mixed = W > SW && H < SH || W < SW && H > SH;
   const dithered = !!dither && !!adjust && !adjustAfterSampling;
   const nearestMixed = mixed && (!adjust || adjustAfterSampling || dithered) && (W < SW && W * 2 > SW || H < SH && H * 2 > SH);
-  const nativeMixed = mixed && (!adjust || adjustAfterSampling || dithered) && Math.min(SW, W) >= 2 && Math.min(SH, H) >= 2 && (W > SW && H * 2 <= SH || H > SH && W * 2 <= SW);
+  const nativeMixed = mixed && (!adjust || adjustAfterSampling || dithered) && (W > SW && H * 2 <= SH || H > SH && W * 2 <= SW);
   if ((enlarging || nearestMixed) && !directDib) {
     halftoneDespeckle(rect, SW, SH);
   }
@@ -31638,8 +31710,9 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
   }
   const sampleW = nativeMixed ? Math.min(SW, W) : W;
   const sampleH = nativeMixed ? Math.min(SH, H) : H;
-  const cols = halftoneAxis(0, SW, sampleW, flipX);
-  const rows = halftoneAxis(0, SH, sampleH, flipY);
+  const axis = nativeMixed ? (n, d, r) => halftoneReduceTaps(n, d, r) : (n, d, r) => halftoneAxis(0, n, d, r);
+  const cols = axis(SW, sampleW, flipX);
+  const rows = axis(SH, sampleH, flipY);
   if (nearestMixed) {
     const nearest = (taps, src2, dst, reverse) => {
       for (let i = 0; i < dst; i++) {
@@ -31711,29 +31784,15 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
     const source = out;
     out = new Int32Array(W * H * 3);
     const axisTaps = (src2, dst) => {
-      const r = [];
-      for (let i = 0; i < dst; i++) {
-        if (src2 === dst) {
-          r.push([[i, 1]]);
-          continue;
-        }
-        const raw = (i + 0.5) * src2 / dst - 0.5;
-        const pos = Math.max(0, Math.min(src2 - 1, raw));
-        const i0 = Math.floor(pos);
-        if (dst === 2 * src2) {
-          r.push([[i0, 1 - (pos - i0)], [Math.min(src2 - 1, i0 + 1), pos - i0]]);
-          continue;
-        }
-        const taps = [];
-        let total = 0;
-        for (let k = i0 - 2; k <= i0 + 3; k++) {
-          const w = softTent(raw - k);
-          taps.push([Math.max(0, Math.min(src2 - 1, k)), w]);
-          total += w;
-        }
-        r.push(taps.map(([k, w]) => [k, w / total]));
+      if (src2 === dst) return Array.from({ length: dst }, (_, i) => [[i, 1]]);
+      if (dst === 2 * src2) {
+        return Array.from({ length: dst }, (_, i) => {
+          const pos = Math.max(0, Math.min(src2 - 1, (i + 0.5) * src2 / dst - 0.5));
+          const i0 = Math.floor(pos);
+          return [[i0, 1 - (pos - i0)], [Math.min(src2 - 1, i0 + 1), pos - i0]];
+        });
       }
-      return r;
+      return halftoneEnlargeTaps(src2, dst);
     };
     const xt = axisTaps(sampleW, W), yt = axisTaps(sampleH, H);
     for (let y = 0; y < H; y++) {
@@ -31741,7 +31800,7 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
         for (let c = 0; c < 3; c++) {
           let v = 0;
           for (const [yy, wy] of yt[y]) for (const [xx, wx] of xt[x]) v += source[(yy * sampleW + xx) * 3 + c] * wy * wx;
-          out[(y * W + x) * 3 + c] = Math.max(0, Math.min(255, Math.floor(v + 0.5)));
+          out[(y * W + x) * 3 + c] = Math.max(0, Math.min(255, Math.floor(v + 0.5 + 1e-7)));
         }
       }
     }