@u1f992/pdfdiff 0.0.1 → 0.2.0

package/src/cli.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import util from "node:util";
+
+import {
+  isValidAlignStrategy,
+  defaultOptions,
+  withIndex,
+  parseHex,
+  formatHex,
+  visualizeDifferences,
+} from "./index.ts";
+
+const {
+  positionals,
+  values: {
+    dpi: dpi_,
+    alpha: alpha_,
+    mask: mask_,
+    align: align_,
+    "addition-color": additionColorHex,
+    "deletion-color": deletionColorHex,
+    "modification-color": modificationColorHex,
+    workers: workers_,
+    version,
+    help,
+  },
+} = util.parseArgs({
+  allowPositionals: true,
+  options: {
+    dpi: { type: "string" },
+    alpha: { type: "boolean" },
+    mask: { type: "string" },
+    align: { type: "string" },
+    "addition-color": { type: "string" },
+    "deletion-color": { type: "string" },
+    "modification-color": { type: "string" },
+    workers: { type: "string" },
+    version: { type: "boolean", short: "v" },
+    help: { type: "boolean", short: "h" },
+  },
+});
+
+if (help) {
+  console.log(`USAGE:
+    pdfdiff <A> <B> <OUTDIR> [OPTIONS]
+
+OPTIONS:
+    --dpi <DPI>                    default: ${defaultOptions.dpi}
+    --alpha                        default: ${defaultOptions.alpha}
+    --mask <PATH>                  default: ${defaultOptions.mask}
+    --align <resize | top-left | top-center | top-right
+             | middle-left | middle-center | middle-right
+             | bottom-left | bottom-center | bottom-right>    default: ${defaultOptions.align}
+    --addition-color <#HEX>        default: ${formatHex(defaultOptions.pallet.addition)}
+    --deletion-color <#HEX>        default: ${formatHex(defaultOptions.pallet.deletion)}
+    --modification-color <#HEX>    default: ${formatHex(defaultOptions.pallet.modification)}
+    --workers <N>                  default: ${defaultOptions.workers}
+    -v, --version
+    -h, --help
+
+NOTES:
+    Approximate per-worker memory:
+        a_size_MB + b_size_MB [+ mask_size_MB]    (PDF buffers in wasm)
+        + 300 MB                                  (mupdf + V8 base)
+        + (dpi / 150)^2 * 50 MB                   (pixmap working set)
+    The main process adds ~500 MB - 1 GB (varies with --workers).
+    Choose --workers so the total stays under ~80% of available memory.
+`);
+  process.exit(0);
+}
+if (version) {
+  try {
+    const versionStr = JSON.parse(
+      fs.readFileSync(new URL("../package.json", import.meta.url), {
+        encoding: "utf-8",
+      }),
+    ).version;
+    console.log(versionStr);
+  } catch {
+    console.log("unknown");
+  }
+  process.exit(0);
+}
+
+if (positionals.length !== 3) {
+  throw new Error("Expected 3 positional arguments: <A> <B> <OUTDIR>");
+}
+
+const pdfA = fs.readFileSync(path.resolve(positionals[0]!));
+const pdfB = fs.readFileSync(path.resolve(positionals[1]!));
+const outDir = path.resolve(positionals[2]!);
+
+const dpi =
+  typeof dpi_ !== "undefined" ? parseInt(dpi_, 10) : defaultOptions.dpi;
+if (Number.isNaN(dpi)) {
+  throw new Error("Invalid DPI value");
+}
+
+const alpha = alpha_ ?? defaultOptions.alpha;
+
+const pdfMask =
+  typeof mask_ !== "undefined"
+    ? fs.readFileSync(path.resolve(mask_))
+    : undefined;
+
+const align = align_ ?? defaultOptions.align;
+if (!isValidAlignStrategy(align)) {
+  throw new Error(`Invalid alignment strategy`);
+}
+
+const additionColor =
+  typeof additionColorHex !== "undefined"
+    ? parseHex(additionColorHex)
+    : defaultOptions.pallet.addition;
+const deletionColor =
+  typeof deletionColorHex !== "undefined"
+    ? parseHex(deletionColorHex)
+    : defaultOptions.pallet.deletion;
+const modificationColor =
+  typeof modificationColorHex !== "undefined"
+    ? parseHex(modificationColorHex)
+    : defaultOptions.pallet.modification;
+if (
+  additionColor === null ||
+  deletionColor === null ||
+  modificationColor === null
+) {
+  throw new Error("Invalid color format");
+}
+
+const workers =
+  typeof workers_ !== "undefined"
+    ? parseInt(workers_, 10)
+    : defaultOptions.workers;
+if (Number.isNaN(workers) || workers < 1) {
+  throw new Error("Invalid workers value");
+}
+
+fs.mkdirSync(outDir, { recursive: true });
+for await (const [
+  i,
+  { a, b, diff, addition, deletion, modification },
+] of withIndex(
+  visualizeDifferences(pdfA, pdfB, {
+    dpi,
+    alpha,
+    mask: pdfMask,
+    align,
+    pallet: {
+      addition: additionColor,
+      deletion: deletionColor,
+      modification: modificationColor,
+    },
+    workers,
+  }),
+  1,
+)) {
+  console.log(
+    `Page ${i}, Addition: ${addition.length}, Deletion: ${deletion.length}, Modification: ${modification.length}`,
+  );
+  const dir = path.join(outDir, i.toString(10));
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, "a.png"),
+    new Uint8Array(await a.getBuffer("image/png")),
+  );
+  fs.writeFileSync(
+    path.join(dir, "b.png"),
+    new Uint8Array(await b.getBuffer("image/png")),
+  );
+  fs.writeFileSync(
+    path.join(dir, "diff.png"),
+    new Uint8Array(await diff.getBuffer("image/png")),
+  );
+}

package/src/diff.ts

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { type JimpInstance } from "./jimp.ts";
+import { alignSize, createEmptyImage, type AlignStrategy } from "./image.ts";
+import { type RGBAColor } from "./rgba-color.ts";
+
+export type Pallet = {
+  addition: RGBAColor;
+  deletion: RGBAColor;
+  modification: RGBAColor;
+};
+
+export function drawDifference(
+  a: JimpInstance,
+  b: JimpInstance,
+  mask: JimpInstance,
+  pallet: Readonly<Pallet>,
+  align: AlignStrategy,
+) {
+  const [aNew, bNew, maskNew] = alignSize([a, b, mask], align);
+  const width = aNew.width;
+  const height = aNew.height;
+  const aData = aNew.bitmap.data;
+  const bData = bNew.bitmap.data;
+  const mData = maskNew.bitmap.data;
+
+  const diffImage = createEmptyImage(width, height);
+  const dData = diffImage.bitmap.data;
+
+  const addition: [number, number][] = [];
+  const deletion: [number, number][] = [];
+  const modification: [number, number][] = [];
+
+  for (let x = 0; x < width; x++) {
+    for (let y = 0; y < height; y++) {
+      const idx = (y * width + x) * 4;
+      if (mData[idx + 3]! !== 0) continue;
+      const aAlpha = aData[idx + 3]!;
+      const bAlpha = bData[idx + 3]!;
+      if (
+        aAlpha === bAlpha &&
+        aData[idx] === bData[idx] &&
+        aData[idx + 1] === bData[idx + 1] &&
+        aData[idx + 2] === bData[idx + 2]
+      ) {
+        continue;
+      }
+      if (aAlpha === 0 && bAlpha === 0) continue;
+      let target: [number, number][];
+      let color: Readonly<RGBAColor>;
+      if (aAlpha === 0) {
+        target = addition;
+        color = pallet.addition;
+      } else if (bAlpha === 0) {
+        target = deletion;
+        color = pallet.deletion;
+      } else {
+        target = modification;
+        color = pallet.modification;
+      }
+      target.push([x, y]);
+      dData[idx] = color[0];
+      dData[idx + 1] = color[1];
+      dData[idx + 2] = color[2];
+      dData[idx + 3] = color[3];
+    }
+  }
+
+  return { diff: diffImage, addition, deletion, modification };
+}

package/src/image.ts

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as jimp from "jimp";
+import { type JimpInstance } from "./jimp.ts";
+
+export function createEmptyImage(width: number, height: number) {
+  return new jimp.Jimp({
+    width,
+    height,
+    color: jimp.rgbaToInt(0, 0, 0, 0),
+  }) as JimpInstance;
+}
+
+export function fillWithEmpty(
+  images:
+    | [JimpInstance, JimpInstance]
+    | [JimpInstance, null]
+    | [null, JimpInstance],
+): [JimpInstance, JimpInstance];
+export function fillWithEmpty(
+  images:
+    | [JimpInstance, JimpInstance, JimpInstance]
+    | [JimpInstance, JimpInstance, null]
+    | [JimpInstance, null, JimpInstance]
+    | [JimpInstance, null, null]
+    | [null, JimpInstance, JimpInstance]
+    | [null, JimpInstance, null]
+    | [null, null, JimpInstance],
+): [JimpInstance, JimpInstance, JimpInstance];
+export function fillWithEmpty(images: (JimpInstance | null)[]): JimpInstance[] {
+  return images.map((img) => (img !== null ? img : createEmptyImage(1, 1)));
+}
+
+const alignStrategyValues = new Set([
+  "resize",
+  "top-left",
+  "top-center",
+  "top-right",
+  "middle-left",
+  "middle-center",
+  "middle-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right",
+] as const);
+type UnwrapSet<T> = T extends Set<infer U> ? U : never;
+export type AlignStrategy = UnwrapSet<typeof alignStrategyValues>;
+export const isValidAlignStrategy = (str: string): str is AlignStrategy =>
+  (alignStrategyValues as Set<string>).has(str);
+
+function alignImage(
+  img: JimpInstance,
+  targetWidth: number,
+  targetHeight: number,
+  align: AlignStrategy,
+) {
+  if (align === "resize") {
+    return img.resize({ w: targetWidth, h: targetHeight });
+  } else {
+    const newImg = createEmptyImage(targetWidth, targetHeight);
+    const x = align.includes("center")
+      ? Math.floor((targetWidth - img.width) / 2)
+      : align.includes("right")
+        ? targetWidth - img.width
+        : 0;
+    const y = align.includes("middle")
+      ? Math.floor((targetHeight - img.height) / 2)
+      : align.includes("bottom")
+        ? targetHeight - img.height
+        : 0;
+    newImg.composite(img, x, y);
+    return newImg;
+  }
+}
+
+export function alignSize(
+  images: [JimpInstance, JimpInstance],
+  align: AlignStrategy,
+): [JimpInstance, JimpInstance];
+export function alignSize(
+  images: [JimpInstance, JimpInstance, JimpInstance],
+  align: AlignStrategy,
+): [JimpInstance, JimpInstance, JimpInstance];
+export function alignSize(
+  images: JimpInstance[],
+  align: AlignStrategy,
+): JimpInstance[] {
+  if (images.length === 0) {
+    return [];
+  }
+  const largerWidth = Math.max(...images.map((img) => img.width));
+  const largerHeight = Math.max(...images.map((img) => img.height));
+  return images.map((img) =>
+    img.width === largerWidth && img.height === largerHeight
+      ? img
+      : alignImage(img, largerWidth, largerHeight, align),
+  );
+}
+
+export function composeLayers(
+  canvasWidth: number,
+  canvasHeight: number,
+  layers: [JimpInstance, number][],
+) {
+  const canvas = createEmptyImage(canvasWidth, canvasHeight);
+  const dData = canvas.bitmap.data;
+  for (const [image, opacity] of layers) {
+    const sData = image.bitmap.data;
+    const srcWidth = image.width;
+    const w = Math.min(canvasWidth, srcWidth);
+    const h = Math.min(canvasHeight, image.height);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const dIdx = (y * canvasWidth + x) * 4;
+        const sIdx = (y * srcWidth + x) * 4;
+        const sa = (sData[sIdx + 3]! / 255) * opacity;
+        if (sa === 0) continue;
+        const da = dData[dIdx + 3]! / 255;
+        const oa = sa + da * (1 - sa);
+        if (oa === 0) continue;
+        const sw = sa / oa;
+        const dw = (da * (1 - sa)) / oa;
+        dData[dIdx] = Math.round(sData[sIdx]! * sw + dData[dIdx]! * dw);
+        dData[dIdx + 1] = Math.round(
+          sData[sIdx + 1]! * sw + dData[dIdx + 1]! * dw,
+        );
+        dData[dIdx + 2] = Math.round(
+          sData[sIdx + 2]! * sw + dData[dIdx + 2]! * dw,
+        );
+        dData[dIdx + 3] = Math.round(oa * 255);
+      }
+    }
+  }
+  return canvas;
+}

package/src/index.html

@@ -0,0 +1,72 @@
+<!doctype html>
+<html lang="ja">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>pdfdiff</title>
+    <link rel="stylesheet" href="./style.css" />
+    <script src="./coi-serviceworker.min.js"></script>
+    <script type="module" src="./browser.js"></script>
+  </head>
+  <body>
+    <h1>pdfdiff</h1>
+    <div class="form-container">
+      <form id="pdf-diff-form">
+        <div>
+          <label for="pdf-a">A:</label>
+          <input type="file" id="pdf-a" accept="application/pdf" required />
+        </div>
+        <div>
+          <label for="pdf-b">B:</label>
+          <input type="file" id="pdf-b" accept="application/pdf" required />
+        </div>
+        <div>
+          <label for="pdf-mask">Mask:</label>
+          <input type="file" id="pdf-mask" accept="application/pdf" />
+        </div>
+        <div>
+          <label for="dpi">DPI:</label>
+          <input type="number" id="dpi" value="150" />
+        </div>
+        <div>
+          <label for="alpha">Alpha:</label>
+          <input type="checkbox" id="alpha" checked />
+        </div>
+        <div>
+          <label for="align">Align:</label>
+          <select id="align">
+            <option value="resize">resize</option>
+            <option value="top-left">top-left</option>
+            <option value="top-center">top-center</option>
+            <option value="top-right">top-right</option>
+            <option value="middle-left">middle-left</option>
+            <option value="middle-center">middle-center</option>
+            <option value="middle-right">middle-right</option>
+            <option value="bottom-left">bottom-left</option>
+            <option value="bottom-center">bottom-center</option>
+            <option value="bottom-right">bottom-right</option>
+          </select>
+        </div>
+        <div>
+          <label for="workers">Workers:</label>
+          <input type="number" id="workers" value="1" min="1" />
+        </div>
+        <div>
+          <label for="addition-color">Addition:</label>
+          <input type="color" id="addition-color" value="#4cae4f" />
+        </div>
+        <div>
+          <label for="deletion-color">Deletion:</label>
+          <input type="color" id="deletion-color" value="#ff5724" />
+        </div>
+        <div>
+          <label for="modification-color">Modification:</label>
+          <input type="color" id="modification-color" value="#ffc105" />
+        </div>
+        <button type="submit">Submit</button>
+      </form>
+    </div>
+    <div class="error" id="error-message"></div>
+    <div class="results" id="results"></div>
+  </body>
+</html>

package/src/index.test.ts

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import test from "node:test";
+
+import {
+  defaultOptions,
+  formatHex,
+  isValidAlignStrategy,
+  parseHex,
+  visualizeDifferences,
+  withIndex,
+} from "./index.ts";
+
+const fixtures = new URL("../test/", import.meta.url);
+const readFixture = (name: string) =>
+  new Uint8Array(fs.readFileSync(new URL(name, fixtures)));
+
+test("re-exports are exposed as runtime values", () => {
+  assert.equal(typeof withIndex, "function");
+  assert.equal(typeof isValidAlignStrategy, "function");
+  assert.equal(typeof parseHex, "function");
+  assert.equal(typeof formatHex, "function");
+});
+
+test("defaultOptions", () => {
+  assert.deepEqual(defaultOptions, {
+    dpi: 150,
+    alpha: true,
+    mask: undefined,
+    align: "resize",
+    pallet: {
+      addition: [0x4c, 0xae, 0x4f, 0xff],
+      deletion: [0xff, 0x57, 0x24, 0xff],
+      modification: [0xff, 0xc1, 0x05, 0xff],
+    },
+    workers: 1,
+  });
+});
+
+test("isValidAlignStrategy", async (ctx) => {
+  for (const s of [
+    "resize",
+    "top-left",
+    "top-center",
+    "top-right",
+    "middle-left",
+    "middle-center",
+    "middle-right",
+    "bottom-left",
+    "bottom-center",
+    "bottom-right",
+  ]) {
+    await ctx.test(s, () => {
+      assert.equal(isValidAlignStrategy(s), true);
+    });
+  }
+  await ctx.test("invalid", () => {
+    assert.equal(isValidAlignStrategy("invalid"), false);
+  });
+});
+
+test("visualizeDifferences pins counts for fixtures at dpi 300", async () => {
+  const a = readFixture("a.pdf");
+  const b = readFixture("b.pdf");
+  const mask = readFixture("mask.pdf");
+
+  const pages: { addition: number; deletion: number; modification: number }[] =
+    [];
+  for await (const page of visualizeDifferences(a, b, { dpi: 300, mask })) {
+    pages.push({
+      addition: page.addition.length,
+      deletion: page.deletion.length,
+      modification: page.modification.length,
+    });
+  }
+
+  assert.deepEqual(pages, [
+    { addition: 7500, deletion: 7500, modification: 7500 },
+  ]);
+});