emf-converter 4.8.5 → 4.8.7

package/dist/browser.js

@@ -16534,153 +16534,26 @@ function applyTint(src, hue, amount) {
 var TINT_FULL = 254;
 function applyRedEyeCorrection(src, width, height, areas) {
   const out = new Uint8ClampedArray(src);
+  const carry = { x: 0, y: 0 };
   for (const a of areas) {
-    correctRedEyeArea(out, width, clamp(a.left, 0, width), clamp(a.top, 0, height), clamp(a.right, 0, width), clamp(a.bottom, 0, height));
+    correctRedEyeArea(out, width, clamp(a.left, 0, width), clamp(a.top, 0, height), clamp(a.right, 0, width), clamp(a.bottom, 0, height), carry);
   }
   return out;
 }
-var RED_EYE_FALLOFF = new Float64Array(
-  [
-    24930,
-    24570,
-    24201,
-    23836,
-    23471,
-    23107,
-    22744,
-    22367,
-    21976,
-    21587,
-    21198,
-    20824,
-    20490,
-    20165,
-    19832,
-    19499,
-    19157,
-    18817,
-    18480,
-    18151,
-    17820,
-    17490,
-    17160,
-    16831,
-    16506,
-    16189,
-    15878,
-    15569,
-    15273,
-    14973,
-    14668,
-    14362,
-    14059,
-    13768,
-    13484,
-    13203,
-    12923,
-    12642,
-    12366,
-    12094,
-    11828,
-    11564,
-    11301,
-    11034,
-    10770,
-    10507,
-    10253,
-    10011,
-    9771,
-    9530,
-    9290,
-    9053,
-    8819,
-    8588,
-    8359,
-    8134,
-    7914,
-    7697,
-    7481,
-    7267,
-    7056,
-    6851,
-    6651,
-    6453,
-    6256,
-    6061,
-    5871,
-    5684,
-    5499,
-    5317,
-    5138,
-    4962,
-    4789,
-    4619,
-    4452,
-    4289,
-    4130,
-    3974,
-    3820,
-    3669,
-    3520,
-    3375,
-    3232,
-    3093,
-    2958,
-    2825,
-    2695,
-    2568,
-    2444,
-    2325,
-    2207,
-    2092,
-    1980,
-    1872,
-    1768,
-    1666,
-    1567,
-    1470,
-    1377,
-    1287,
-    1200,
-    1116,
-    1034,
-    956,
-    881,
-    808,
-    739,
-    674,
-    612,
-    541,
-    462,
-    381,
-    299,
-    220,
-    147,
-    85,
-    36,
-    3,
-    0
-  ].map((v) => v / 1e5)
-);
-function redEyeFalloff(u) {
-  const t = u * 128;
-  const i = Math.floor(t);
-  if (i >= RED_EYE_FALLOFF.length - 1) {
-    return 0;
-  }
-  return RED_EYE_FALLOFF[i] + (t - i) * (RED_EYE_FALLOFF[i + 1] - RED_EYE_FALLOFF[i]);
-}
 var RED_EYE_SECTORS = 60;
 var RED_EYE_BLUE_WEIGHT = 0.225;
-var RED_EYE_WEIGHT_CAP = 6;
-var RED_EYE_PURE_WEIGHT = RED_EYE_WEIGHT_CAP;
-var RED_EYE_DARK_STRENGTH = 0.49;
-var RED_EYE_DARK_RATIO = 0.6;
-var RED_EYE_GREEN_SHARE = 80 / 255;
-function correctRedEyeArea(out, stride, x0, y0, x1, y1) {
+var RED_EYE_PURE_WEIGHT = 1 / (1 + RED_EYE_BLUE_WEIGHT);
+var RED_EYE_CARRY = 0.81;
+var RED_EYE_GREEN_SHARE = 5 / 16;
+var RED_EYE_SPREAD_STEPS = [31.5, 50, 98.78];
+var RED_EYE_STRENGTHS = [0.25, 0.5, 0.661, 0.75];
+function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
   const w = x1 - x0;
   const h = y1 - y0;
   const count = w * h;
+  if (!(count > 0)) {
+    return;
+  }
   const redness = new Float64Array(count);
   const dark = new Float64Array(count);
   let sx = 0;
@@ -16693,34 +16566,44 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1) {
       const g = out[i + 1];
       const b = out[i + 2];
       const k = y * w + x;
-      dark[k] = Math.min(g, b);
+      const d = g + RED_EYE_BLUE_WEIGHT * b;
+      dark[k] = d;
       const v = r - Math.max(g, b);
       if (v > 0) {
         redness[k] = v;
-        const denominator = g + RED_EYE_BLUE_WEIGHT * b;
-        {
-          const weight = denominator >= 1 ? Math.min(RED_EYE_WEIGHT_CAP, v / denominator) : RED_EYE_PURE_WEIGHT;
-          sx += weight * (x + 0.5);
-          sy += weight * (y + 0.5);
-          sw += weight;
-        }
+        const weight = d >= 1 ? v / d : RED_EYE_PURE_WEIGHT;
+        sx += weight * (x + 0.5);
+        sy += weight * (y + 0.5);
+        sw += weight;
       }
     }
   }
   if (sw === 0) {
-    if (!redness.some((v) => v > 0)) {
-      return;
-    }
-    sx = w / 2;
-    sy = h / 2;
-    sw = 1;
+    return;
   }
-  const cx = sx / sw;
-  const cy = sy / sw;
-  const radius = Math.min(cx, cy) - 0.5;
+  let cx = (sx + RED_EYE_CARRY * carry.x) / sw;
+  let cy = (sy + RED_EYE_CARRY * carry.y) / sw;
+  carry.x = x0 + cx;
+  carry.y = y0 + cy;
+  if (Math.hypot(cx - w / 2, cy - h / 2) >= Math.max(Math.min(w, h) / 2, (w + h) / 6)) {
+    cx = w / 2;
+    cy = h / 2;
+  }
+  const ax = x0 + cx;
+  const ay = y0 + cy;
+  const edgeX = Math.round(cx) > w / 2 ? w - cx + 0.5 : cx - 0.5;
+  const edgeY = Math.round(cy) > h / 2 ? h - cy + 0.5 : cy - 0.5;
+  const radius = ax > ay ? Math.min(edgeX, ay - 0.5) : Math.min(edgeY, ax - 0.5);
   if (!(radius > 0)) {
     return;
   }
+  const sorted = Float64Array.from(dark).sort();
+  const spread = sorted[Math.floor(0.7 * count)] - sorted[Math.floor(0.3 * count)];
+  let level = 0;
+  while (level < RED_EYE_SPREAD_STEPS.length && spread >= RED_EYE_SPREAD_STEPS[level]) {
+    level++;
+  }
+  const strength = RED_EYE_STRENGTHS[level];
   const sector = new Uint8Array(count);
   const distance = new Float64Array(count);
   const sectorSum = new Float64Array(RED_EYE_SECTORS);
@@ -16758,7 +16641,8 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1) {
       const mean = sectorSum[s] / sectorCount[s];
       const meanDark = sectorDark[s] / sectorCount[s];
       const ratio = meanDark > 0 ? dark[k] / meanDark : 1;
-      const falloff = Math.max(redEyeFalloff(distance[k] / radius), RED_EYE_DARK_STRENGTH * Math.max(0, 1 - ratio / RED_EYE_DARK_RATIO));
+      const u = distance[k] / radius;
+      const falloff = Math.max(strength * (1 - u) * (1 - u), 0.5 * Math.max(0, 1 - ratio) ** 2);
       const rest = (1 - falloff) * mean;
       if (rest >= v) {
         continue;
@@ -31934,40 +31818,121 @@ function halftoneReduceTaps(srcLen, dstLen, reverse) {
   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,
+var ENLARGE_INNER = [
+  1e3,
+  992.47,
+  984.9399,
+  977.4099,
+  969.8798,
+  962.3498,
+  954.8198,
+  947.2897,
+  939.7597,
+  932.2296,
+  924.6996,
+  917.1695,
+  909.6395,
+  902.1095,
+  894.5665,
+  886.8087,
+  879.045,
+  871.2813,
+  863.4349,
+  855.5885,
+  847.7421,
+  839.8269,
+  831.9046,
+  823.912,
+  815.9193,
+  807.9266,
+  799.847,
+  791.7283,
+  783.6096,
+  775.449,
+  767.3204,
+  758.9233,
+  750.5263,
+  742.4271,
+  734.0547,
+  725.6823,
+  717.232,
+  708.7675,
+  700.2393,
+  691.7111,
+  683.0734,
+  674.4357,
+  665.7105,
+  656.9854,
+  648.2603,
+  639.3747,
+  630.4873,
+  621.5157,
+  612.5442
+];
+var ENLARGE_OUTER = [
+  375.1388,
+  364.2093,
+  353.2797,
+  342.4714,
+  331.7615,
+  321.1462,
+  310.6456,
+  300.2252,
+  289.9229,
+  279.7227,
+  269.6439,
+  259.6535,
+  249.7825,
+  240.0362,
+  230.3856,
+  220.8799,
+  211.4594,
+  202.1844,
+  192.9996,
+  183.9679,
+  175.1064,
+  166.2864,
+  157.6436,
+  149.1447,
+  140.7609,
+  132.5474,
+  124.4802,
+  116.5636,
+  108.778,
+  101.1602,
+  93.7098,
+  86.4419,
+  79.3251,
+  72.4091,
+  65.6853,
+  59.1472,
+  52.812,
+  46.6978,
+  40.8001,
+  35.1449,
+  29.7494,
+  24.6096,
+  19.7977,
+  15.2801,
+  11.1442,
+  7.3916,
+  4.1415,
+  1.4039,
   0
 ];
-var ENLARGE_BOX = 0.2429;
-var ENLARGE_STEP = 0.05;
+var ENLARGE_HALF = 500.0106;
+var ENLARGE_KNOTS = 96;
 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);
+  if (u >= 1) return 0;
+  if (Math.abs(u - 0.5) < 1e-9) return ENLARGE_HALF;
+  const table = u < 0.5 ? ENLARGE_INNER : ENLARGE_OUTER;
+  const edge = u * ENLARGE_KNOTS - (u < 0.5 ? 0 : ENLARGE_KNOTS / 2);
+  const i = Math.min(table.length - 2, Math.floor(edge + 1e-9));
+  return table[i] + (table[i + 1] - table[i]) * (edge - i);
 }
 function halftoneEnlargeTaps(src, dst) {
   const ratio = dst / src;
-  const reach = Math.ceil((ENLARGE_KERNEL.length - 1) * ENLARGE_STEP * ratio);
+  const reach = Math.ceil(ratio) - 1;
   const fir = [];
   let total = 0;
   for (let k = 0; k <= reach; k++) {
@@ -31996,7 +31961,17 @@ function halftoneEnlargeTaps(src, dst) {
         weights.set(j, (weights.get(j) ?? 0) + w * v);
       }
     }
-    taps.push([...weights.entries()]);
+    const sorted = [...weights.entries()].sort((a, b) => a[0] - b[0]);
+    let prev = 0;
+    let cum = 0;
+    const row2 = [];
+    for (let i = 0; i < sorted.length; i++) {
+      cum += sorted[i][1] * 8192;
+      const c = i === sorted.length - 1 ? 8192 : Math.ceil(cum - 1e-7);
+      row2.push([sorted[i][0], (c - prev) / 8192]);
+      prev = c;
+    }
+    taps.push(row2);
   }
   return taps;
 }
@@ -32213,8 +32188,10 @@ 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 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);
+  const enlargeX = nativeMixed && W > SW;
+  const enlargeY = nativeMixed && H > SH;
+  const cols = axis(SW, sampleW, flipX && !enlargeX);
+  const rows = axis(SH, sampleH, flipY && !enlargeY);
   if (nearestMixed) {
     const nearest = (taps, src2, dst, reverse) => {
       for (let i = 0; i < dst; i++) {
@@ -32323,6 +32300,8 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
       return halftoneEnlargeTaps(src2, dst);
     };
     const xt = axisTaps(sampleW, W), yt = axisTaps(sampleH, H);
+    if (enlargeX && flipX) xt.reverse();
+    if (enlargeY && flipY) yt.reverse();
     for (let y = 0; y < H; y++) {
       for (let x = 0; x < W; x++) {
         for (let c = 0; c < 3; c++) {