@u1f992/pdfdiff 0.0.1 → 0.1.0

package/src/cli.ts

@@ -0,0 +1,175 @@
+#!/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.js";
+
+const {
+  positionals,
+  values: {
+    dpi: dpi_,
+    alpha: alpha_,
+    mask: mask_,
+    align: align_,
+    "addition-color": additionColorHex,
+    "deletion-color": deletionColorHex,
+    "modification-color": modificationColorHex,
+    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" },
+    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)}
+    -v, --version
+    -h, --help
+`);
+  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");
+}
+
+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,
+    },
+  }),
+  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,70 @@
+/*
+ * 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.js";
+import { alignSize, createEmptyImage, type AlignStrategy } from "./image.js";
+import { type RGBAColor } from "./rgba-color.js";
+
+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 addColor = jimp.rgbaToInt(...pallet.addition);
+  const delColor = jimp.rgbaToInt(...pallet.deletion);
+  const modColor = jimp.rgbaToInt(...pallet.modification);
+
+  const diffImage = createEmptyImage(aNew.width, aNew.height);
+  const addition = [] as [number, number][];
+  const deletion = [] as [number, number][];
+  const modification = [] as [number, number][];
+
+  for (let x = 0; x < aNew.width; x++) {
+    for (let y = 0; y < aNew.height; y++) {
+      const intA = aNew.getPixelColor(x, y);
+      const intB = bNew.getPixelColor(x, y);
+      const colorA = jimp.intToRGBA(intA);
+      const colorB = jimp.intToRGBA(intB);
+      const masked = jimp.intToRGBA(maskNew.getPixelColor(x, y)).a !== 0;
+      if (masked || intA === intB || (colorA.a === 0 && colorB.a === 0)) {
+        continue;
+      }
+      const [target, color] =
+        colorA.a === 0 && colorB.a !== 0
+          ? [addition, addColor]
+          : colorA.a !== 0 && colorB.a === 0
+            ? [deletion, delColor]
+            : [modification, modColor];
+      target.push([x, y]);
+      diffImage.setPixelColor(color, x, y);
+    }
+  }
+
+  return { diff: diffImage, addition, deletion, modification };
+}

package/src/image.ts

@@ -0,0 +1,128 @@
+/*
+ * 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.js";
+
+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][],
+) {
+  return layers.reduce(
+    (acc, [image, opacity]) =>
+      acc.composite(image, 0, 0, {
+        mode: jimp.BlendMode.SRC_OVER,
+        opacitySource: opacity,
+      }),
+    createEmptyImage(canvasWidth, canvasHeight),
+  );
+}

package/src/index.html

@@ -0,0 +1,67 @@
+<!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 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="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.ts

@@ -0,0 +1,186 @@
+/*
+ * 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 * as mupdf from "mupdf";
+import Worker from "web-worker";
+
+import {
+  createEmptyImage,
+  isValidAlignStrategy,
+  type AlignStrategy,
+} from "./image.js";
+import { withIndex } from "./iterable.js";
+import { pageToImage } from "./pdf.js";
+import { parseHex, formatHex } from "./rgba-color.js";
+import type { Pallet } from "./diff.js";
+import type { JimpInstance } from "./jimp.js";
+
+export { withIndex, isValidAlignStrategy, parseHex, formatHex };
+
+type Options = {
+  dpi: number;
+  alpha: boolean;
+  mask: Uint8Array | undefined;
+  align: AlignStrategy;
+  pallet: Pallet;
+};
+
+type Result = {
+  a: JimpInstance;
+  b: JimpInstance;
+  diff: JimpInstance;
+  addition: [number, number][];
+  deletion: [number, number][];
+  modification: [number, number][];
+};
+
+export const defaultOptions: Options = {
+  dpi: 150,
+  alpha: true,
+  mask: undefined,
+  align: "resize",
+  pallet: {
+    addition: [0x4c, 0xae, 0x4f, 0xff],
+    deletion: [0xff, 0x57, 0x24, 0xff],
+    modification: [0xff, 0xc1, 0x05, 0xff],
+  },
+};
+
+export async function* visualizeDifferences(
+  a: Uint8Array,
+  b: Uint8Array,
+  options: Partial<Omit<Options, "pallet"> & { pallet: Partial<Pallet> }>,
+) {
+  const mergedOptions = {
+    dpi: options?.dpi ?? defaultOptions.dpi,
+    alpha: options?.alpha ?? defaultOptions.alpha,
+    mask: options?.mask ?? defaultOptions.mask,
+    align: options?.align ?? defaultOptions.align,
+    pallet: {
+      addition: options?.pallet?.addition ?? defaultOptions.pallet.addition,
+      deletion: options?.pallet?.deletion ?? defaultOptions.pallet.deletion,
+      modification:
+        options?.pallet?.modification ?? defaultOptions.pallet.modification,
+    },
+  };
+
+  const pdfA = mupdf.PDFDocument.openDocument(a, "application/pdf");
+  const pdfB = mupdf.PDFDocument.openDocument(b, "application/pdf");
+  const pdfMask =
+    typeof mergedOptions.mask !== "undefined"
+      ? mupdf.PDFDocument.openDocument(mergedOptions.mask, "application/pdf")
+      : new mupdf.PDFDocument();
+
+  const maxPages = Math.max(
+    pdfA.countPages(),
+    pdfB.countPages(),
+    pdfMask.countPages(),
+  );
+
+  async function processPage(pageIndex: number) {
+    const [pageA, pageB, pageMask] = await Promise.all([
+      pageIndex < pdfA.countPages()
+        ? pageToImage(
+            pdfA.loadPage(pageIndex),
+            mergedOptions.dpi,
+            mergedOptions.alpha,
+          )
+        : createEmptyImage(1, 1),
+      pageIndex < pdfB.countPages()
+        ? pageToImage(
+            pdfB.loadPage(pageIndex),
+            mergedOptions.dpi,
+            mergedOptions.alpha,
+          )
+        : createEmptyImage(1, 1),
+      pageIndex < pdfMask.countPages()
+        ? pageToImage(
+            pdfMask.loadPage(pageIndex),
+            mergedOptions.dpi,
+            mergedOptions.alpha,
+          )
+        : createEmptyImage(1, 1),
+    ]);
+
+    // NOTE: getBufferはcopyなので、Workerに移譲した後もa, bを使用して問題ない
+    // https://github.com/jimp-dev/jimp/blob/b6b0e418a5f1259211a133b20cddb4f4e5c25679/packages/core/src/index.ts#L444
+    const [bufA, bufB, bufMask] = await Promise.all([
+      pageA
+        .getBuffer(jimp.JimpMime.png)
+        .then((buf) => new Uint8Array(buf).buffer),
+      pageB
+        .getBuffer(jimp.JimpMime.png)
+        .then((buf) => new Uint8Array(buf).buffer),
+      pageMask
+        .getBuffer(jimp.JimpMime.png)
+        .then((buf) => new Uint8Array(buf).buffer),
+    ]);
+
+    const { bufDiff, addition, deletion, modification } = (await new Promise(
+      (resolve, reject) => {
+        const url = new URL("./worker.js", import.meta.url);
+        const worker = new Worker(url, { type: "module" });
+        worker.addEventListener("message", (e) => {
+          resolve(e.data);
+          worker.terminate();
+        });
+        worker.addEventListener("error", (e) => {
+          reject(e);
+          worker.terminate();
+        });
+        worker.postMessage(
+          {
+            bufA,
+            bufB,
+            bufMask,
+            pallet: mergedOptions.pallet,
+            align: mergedOptions.align,
+          },
+          [bufA, bufB, bufMask],
+        );
+      },
+    )) as {
+      bufDiff: ArrayBuffer;
+      addition: [number, number][];
+      deletion: [number, number][];
+      modification: [number, number][];
+    };
+    const diff = await jimp.Jimp.fromBuffer(bufDiff);
+    return { a: pageA, b: pageB, diff, addition, deletion, modification };
+  }
+
+  // ページ処理を並列発行し、順序を保証して出力
+  const concurrency = navigator.hardwareConcurrency;
+  const pending = /** @type {Promise<VisualizeDifferencesResult>[]} */ [];
+  let nextPageToProcess = 0;
+  let nextPageToYield = 0;
+
+  while (nextPageToYield < maxPages) {
+    // プールに空きがあれば新しいページ処理を追加
+    while (nextPageToProcess < maxPages && pending.length < concurrency) {
+      pending.push(processPage(nextPageToProcess));
+      nextPageToProcess++;
+    }
+
+    // 次に出力すべきページのPromiseを待つ
+    const result = await pending[0];
+    pending.shift();
+    yield result as Result;
+    nextPageToYield++;
+  }
+}

package/src/iterable.test.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 "assert";
+import test from "node:test";
+
+import { withIndex } from "./iterable.ts";
+
+test("withIndex", async () => {
+  assert.deepStrictEqual(
+    // @ts-ignore
+    await Array.fromAsync(
+      withIndex(
+        (async function* () {
+          yield "a";
+          yield "b";
+        })(),
+        0,
+      ),
+    ),
+    [
+      [0, "a"],
+      [1, "b"],
+    ],
+  );
+});

package/src/iterable.ts

@@ -0,0 +1,24 @@
+/*
+ * 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/>.
+ */
+
+export async function* withIndex<T>(iter: AsyncIterable<T>, start = 0) {
+  let index = start;
+  for await (const item of iter) {
+    yield [index, item] as [number, T];
+    index++;
+  }
+}