emf-converter 4.6.4 → 4.6.5

package/dist/browser.js

@@ -31372,42 +31372,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/dist/browser.mjs

@@ -31370,42 +31370,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/dist/index.js

@@ -31373,42 +31373,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/dist/index.mjs

@@ -31371,42 +31371,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "4.6.4",
+	"version": "4.6.5",
 	"description": "Convert EMF/WMF metafile binaries to PNG data URLs or SVG (markup, data URL, React/JSX)",
 	"keywords": [
 		"canvas",