@blazediff/bin 1.4.1 → 1.6.0

package/dist/cli.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,55 +30,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/index.ts
-var import_core = __toESM(require("@blazediff/core"));
-async function blazeDiffBin(image1Path, image2Path, options) {
-  const [image1, image2] = await Promise.all([
-    options.transformer.transform(image1Path),
-    options.transformer.transform(image2Path)
-  ]);
-  if (image1.width !== image2.width || image1.height !== image2.height) {
+// src/commands/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  default: () => main
+});
+function parseRGB(colorStr) {
+  const parts = colorStr.split(",").map((s) => parseInt(s.trim(), 10));
+  if (parts.length !== 3 || parts.some((p) => Number.isNaN(p) || p < 0 || p > 255)) {
     throw new Error(
-      `Image dimensions do not match: ${image1.width}x${image1.height} vs ${image2.width}x${image2.height}`
-    );
-  }
-  let outputData;
-  if (options.outputPath) {
-    outputData = new Uint8Array(image1.data.length);
-  }
-  const startTime = performance.now();
-  const diffCount = (0, import_core.default)(
-    image1.data,
-    image2.data,
-    outputData,
-    image1.width,
-    image1.height,
-    options.coreOptions
-  );
-  const duration = performance.now() - startTime;
-  if (diffCount > 0 && options.outputPath && outputData) {
-    await options.transformer.write(
-      {
-        data: outputData,
-        width: image1.width,
-        height: image1.height
-      },
-      options.outputPath
+      `Invalid RGB color format: ${colorStr}. Expected format: r,g,b (e.g., 255,0,0)`
     );
   }
-  return {
-    diffCount,
-    width: image1.width,
-    height: image1.height,
-    outputData,
-    duration
-  };
+  return [parts[0], parts[1], parts[2]];
 }
-
-// src/cli.ts
 function printUsage() {
   console.log(`
-Usage: blazediff <image1> <image2> [options]
+Usage: blazediff diff <image1> <image2> [options]
 
 Arguments:
   image1    Path to the first image
@@ -86,161 +61,822 @@ Options:
   --diff-color-alt <r,g,b>  Alternative color for dark differences (default: same as diff-color)
   --include-aa              Include anti-aliasing detection
   --diff-mask               Draw diff over transparent background
-  --transformer <name>      Specify transformer to use (e.g. pngjs, sharp)
   --color-space <name>      Specify color space to use (e.g. yiq, ycbcr)
+  --transformer <name>      Specify transformer to use (e.g. pngjs, sharp)
   -h, --help                Show this help message
 
 Examples:
-  blazediff image1.png image2.png
-  blazediff image1.png image2.png -o diff.png -t 0.05
-  blazediff image1.png image2.png --threshold 0.2 --alpha 0.3
+  blazediff diff image1.png image2.png
+  blazediff diff image1.png image2.png -o diff.png -t 0.05
+  blazediff diff image1.png image2.png --threshold 0.2 --alpha 0.3
 `);
 }
-function parseRGB(colorStr) {
-  const parts = colorStr.split(",").map((s) => parseInt(s.trim(), 10));
-  if (parts.length !== 3 || parts.some((p) => Number.isNaN(p) || p < 0 || p > 255)) {
-    throw new Error(
-      `Invalid RGB color format: ${colorStr}. Expected format: r,g,b (e.g., 255,0,0)`
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+      printUsage();
+      process.exit(0);
+    }
+    if (args.length < 2) {
+      console.error("Error: Two image paths are required");
+      printUsage();
+      process.exit(1);
+    }
+    const image1 = args[0];
+    const image2 = args[1];
+    const options = {};
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      const nextArg = args[i + 1];
+      switch (arg) {
+        case "-o":
+        case "--output":
+          if (nextArg) {
+            options.outputPath = nextArg;
+            i++;
+          }
+          break;
+        case "-t":
+        case "--threshold":
+          if (nextArg) {
+            const threshold = parseFloat(nextArg);
+            if (Number.isNaN(threshold) || threshold < 0 || threshold > 1) {
+              throw new Error(
+                `Invalid threshold: ${nextArg}. Must be between 0 and 1`
+              );
+            }
+            options.threshold = threshold;
+            i++;
+          }
+          break;
+        case "-a":
+        case "--alpha":
+          if (nextArg) {
+            const alpha = parseFloat(nextArg);
+            if (Number.isNaN(alpha) || alpha < 0 || alpha > 1) {
+              throw new Error(
+                `Invalid alpha: ${nextArg}. Must be between 0 and 1`
+              );
+            }
+            options.alpha = alpha;
+            i++;
+          }
+          break;
+        case "--aa-color":
+          if (nextArg) {
+            options.aaColor = parseRGB(nextArg);
+            i++;
+          }
+          break;
+        case "--diff-color":
+          if (nextArg) {
+            options.diffColor = parseRGB(nextArg);
+            i++;
+          }
+          break;
+        case "--diff-color-alt":
+          if (nextArg) {
+            options.diffColorAlt = parseRGB(nextArg);
+            i++;
+          }
+          break;
+        case "--include-aa":
+          options.includeAA = true;
+          break;
+        case "--diff-mask":
+          options.diffMask = true;
+          break;
+        case "--transformer":
+          if (nextArg) {
+            options.transformer = nextArg;
+            i++;
+          }
+          break;
+        case "--color-space":
+          if (nextArg) {
+            options.colorSpace = nextArg;
+            i++;
+          }
+          break;
+        default:
+          console.error(`Unknown option: ${arg}`);
+          printUsage();
+          process.exit(1);
+      }
+    }
+    const transformer = await getTransformer(
+      options.transformer
+    );
+    const [img1, img2] = await Promise.all([
+      transformer.transform(image1),
+      transformer.transform(image2)
+    ]);
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(
+        `Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`
+      );
+    }
+    let outputData;
+    if (options.outputPath) {
+      outputData = new Uint8Array(img1.data.length);
+    }
+    const coreOptions = {
+      threshold: options.threshold,
+      alpha: options.alpha,
+      aaColor: options.aaColor,
+      diffColor: options.diffColor,
+      diffColorAlt: options.diffColorAlt,
+      includeAA: options.includeAA,
+      diffMask: options.diffMask
+    };
+    const startTime = performance.now();
+    const diffCount = (0, import_core.default)(
+      img1.data,
+      img2.data,
+      outputData,
+      img1.width,
+      img1.height,
+      coreOptions
     );
+    const duration = performance.now() - startTime;
+    if (diffCount > 0 && options.outputPath && outputData) {
+      await transformer.write(
+        {
+          data: outputData,
+          width: img1.width,
+          height: img1.height
+        },
+        options.outputPath
+      );
+    }
+    const result = {
+      diffCount,
+      width: img1.width,
+      height: img1.height,
+      duration
+    };
+    console.log(`completed in: ${result.duration.toFixed(2)}ms`);
+    console.log(`dimensions: ${result.width}x${result.height}`);
+    console.log(`different pixels: ${result.diffCount}`);
+    console.log(
+      `error: ${(result.diffCount / (result.width * result.height) * 100).toFixed(2)}%`
+    );
+    if (result.diffCount > 0 && outputData && options.outputPath) {
+      console.log(`diff image: ${options.outputPath}`);
+    }
+    if (result.diffCount > 0) {
+      process.exit(1);
+    } else {
+      console.log(`Images are identical!`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
   }
-  return [parts[0], parts[1], parts[2]];
 }
-function parseArgs() {
-  const args = process.argv.slice(2);
-  if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
-    printUsage();
-    process.exit(0);
+var import_core, getTransformer;
+var init_diff = __esm({
+  "src/commands/diff.ts"() {
+    "use strict";
+    import_core = __toESM(require("@blazediff/core"));
+    getTransformer = async (transformer) => {
+      if (!transformer || transformer === "pngjs") {
+        const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
+        return transformer2;
+      }
+      if (transformer === "sharp") {
+        const { default: transformer2 } = await import("@blazediff/sharp-transformer");
+        return transformer2;
+      }
+      throw new Error(`Unknown transformer: ${transformer}`);
+    };
+    if (typeof require !== "undefined" && require.main === module) {
+      main();
+    }
   }
-  if (args.length < 2) {
-    console.error("Error: Two image paths are required");
-    printUsage();
+});
+
+// src/commands/gmsd.ts
+var gmsd_exports = {};
+__export(gmsd_exports, {
+  default: () => main2
+});
+function printUsage2() {
+  console.log(`
+Usage: blazediff gmsd <image1> <image2> [options]
+
+Arguments:
+  image1    Path to the first image
+  image2    Path to the second image
+
+Options:
+  -o, --output <path>    Output path for GMS similarity map (grayscale visualization)
+  --downsample <0|1>     Downsample factor: 0=full-res, 1=2x downsample (default: 0)
+  --gmsd-c <num>         Stability constant for GMSD (default: 170)
+  --transformer <name>   Specify transformer to use (e.g. pngjs, sharp)
+  -h, --help             Show this help message
+
+Examples:
+  blazediff gmsd image1.png image2.png
+  blazediff gmsd image1.png image2.png --downsample 1
+  blazediff gmsd image1.png image2.png -o gms-map.png
+`);
+}
+async function main2() {
+  try {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+      printUsage2();
+      process.exit(0);
+    }
+    if (args.length < 2) {
+      console.error("Error: Two image paths are required");
+      printUsage2();
+      process.exit(1);
+    }
+    const image1 = args[0];
+    const image2 = args[1];
+    const options = {};
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      const nextArg = args[i + 1];
+      switch (arg) {
+        case "-o":
+        case "--output":
+          if (nextArg) {
+            options.outputPath = nextArg;
+            i++;
+          }
+          break;
+        case "--downsample":
+          if (nextArg) {
+            const downsample = parseInt(nextArg, 10);
+            if (downsample !== 0 && downsample !== 1) {
+              throw new Error(`Invalid downsample: ${nextArg}. Must be 0 or 1`);
+            }
+            options.downsample = downsample;
+            i++;
+          }
+          break;
+        case "--gmsd-c":
+          if (nextArg) {
+            const gmsdC = parseFloat(nextArg);
+            if (Number.isNaN(gmsdC) || gmsdC <= 0) {
+              throw new Error(
+                `Invalid gmsd-c: ${nextArg}. Must be a positive number`
+              );
+            }
+            options.gmsdC = gmsdC;
+            i++;
+          }
+          break;
+        case "--transformer":
+          if (nextArg) {
+            options.transformer = nextArg;
+            i++;
+          }
+          break;
+        default:
+          console.error(`Unknown option: ${arg}`);
+          printUsage2();
+          process.exit(1);
+      }
+    }
+    const transformer = await getTransformer2(
+      options.transformer
+    );
+    const [img1, img2] = await Promise.all([
+      transformer.transform(image1),
+      transformer.transform(image2)
+    ]);
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(
+        `Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`
+      );
+    }
+    let outputData;
+    if (options.outputPath) {
+      outputData = new Uint8Array(img1.data.length);
+    }
+    const gmsdOptions = {
+      downsample: options.downsample || 0,
+      c: options.gmsdC
+    };
+    const startTime = performance.now();
+    const score = (0, import_gmsd.default)(
+      img1.data,
+      img2.data,
+      outputData,
+      img1.width,
+      img1.height,
+      gmsdOptions
+    );
+    const duration = performance.now() - startTime;
+    if (options.outputPath && outputData) {
+      await transformer.write(
+        {
+          data: outputData,
+          width: img1.width,
+          height: img1.height
+        },
+        options.outputPath
+      );
+    }
+    const result = {
+      score,
+      width: img1.width,
+      height: img1.height,
+      duration
+    };
+    console.log(`completed in: ${result.duration.toFixed(2)}ms`);
+    console.log(`dimensions: ${result.width}x${result.height}`);
+    console.log(
+      `similarity score: ${result.score.toFixed(6)} (0=different, 1=identical)`
+    );
+    console.log(`similarity: ${(result.score * 100).toFixed(2)}%`);
+    if (options.outputPath && outputData) {
+      console.log(`GMS map saved to: ${options.outputPath}`);
+    }
+    if (result.score < 0.95) {
+      process.exit(1);
+    } else {
+      console.log(`Images are highly similar!`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
     process.exit(1);
   }
-  const image1 = args[0];
-  const image2 = args[1];
-  const options = {};
-  for (let i = 2; i < args.length; i++) {
-    const arg = args[i];
-    const nextArg = args[i + 1];
-    switch (arg) {
-      case "-o":
-      case "--output":
-        if (nextArg) {
-          options.outputPath = nextArg;
-          i++;
-        }
-        break;
-      case "-t":
-      case "--threshold":
-        if (nextArg) {
-          const threshold = parseFloat(nextArg);
-          if (Number.isNaN(threshold) || threshold < 0 || threshold > 1) {
-            throw new Error(
-              `Invalid threshold: ${nextArg}. Must be between 0 and 1`
-            );
+}
+var import_gmsd, getTransformer2;
+var init_gmsd = __esm({
+  "src/commands/gmsd.ts"() {
+    "use strict";
+    import_gmsd = __toESM(require("@blazediff/gmsd"));
+    getTransformer2 = async (transformer) => {
+      if (!transformer || transformer === "pngjs") {
+        const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
+        return transformer2;
+      }
+      if (transformer === "sharp") {
+        const { default: transformer2 } = await import("@blazediff/sharp-transformer");
+        return transformer2;
+      }
+      throw new Error(`Unknown transformer: ${transformer}`);
+    };
+    if (typeof require !== "undefined" && require.main === module) {
+      main2();
+    }
+  }
+});
+
+// src/commands/ssim.ts
+var ssim_exports = {};
+__export(ssim_exports, {
+  default: () => main3
+});
+function printUsage3() {
+  console.log(`
+Usage: blazediff ssim <image1> <image2> [options]
+
+Arguments:
+  image1    Path to the first image
+  image2    Path to the second image
+
+Options:
+  -o, --output <path>    Output path for SSIM map visualization
+  --transformer <name>   Specify transformer to use (e.g. pngjs, sharp)
+  -h, --help             Show this help message
+
+Examples:
+  blazediff ssim image1.png image2.png
+  blazediff ssim image1.png image2.png -o ssim-map.png
+`);
+}
+async function main3() {
+  try {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+      printUsage3();
+      process.exit(0);
+    }
+    if (args.length < 2) {
+      console.error("Error: Two image paths are required");
+      printUsage3();
+      process.exit(1);
+    }
+    const image1 = args[0];
+    const image2 = args[1];
+    const options = {};
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      const nextArg = args[i + 1];
+      switch (arg) {
+        case "-o":
+        case "--output":
+          if (nextArg) {
+            options.outputPath = nextArg;
+            i++;
           }
-          options.threshold = threshold;
-          i++;
-        }
-        break;
-      case "-a":
-      case "--alpha":
-        if (nextArg) {
-          const alpha = parseFloat(nextArg);
-          if (Number.isNaN(alpha) || alpha < 0 || alpha > 1) {
-            throw new Error(
-              `Invalid alpha: ${nextArg}. Must be between 0 and 1`
-            );
+          break;
+        case "--transformer":
+          if (nextArg) {
+            options.transformer = nextArg;
+            i++;
           }
-          options.alpha = alpha;
-          i++;
-        }
-        break;
-      case "--aa-color":
-        if (nextArg) {
-          options.aaColor = parseRGB(nextArg);
-          i++;
-        }
-        break;
-      case "--diff-color":
-        if (nextArg) {
-          options.diffColor = parseRGB(nextArg);
-          i++;
-        }
-        break;
-      case "--diff-color-alt":
-        if (nextArg) {
-          options.diffColorAlt = parseRGB(nextArg);
-          i++;
-        }
-        break;
-      case "--include-aa":
-        options.includeAA = true;
-        break;
-      case "--diff-mask":
-        options.diffMask = true;
-        break;
-      case "--transformer":
-        if (nextArg) {
-          options.transformer = nextArg;
-          i++;
-        }
-        break;
-      case "--colorSpace":
-        if (nextArg) {
-          options.colorSpace = nextArg;
-          i++;
-        }
-        break;
-      default:
-        console.error(`Unknown option: ${arg}`);
-        printUsage();
-        process.exit(1);
+          break;
+        default:
+          console.error(`Unknown option: ${arg}`);
+          printUsage3();
+          process.exit(1);
+      }
     }
+    const transformer = await getTransformer3(options.transformer);
+    const [img1, img2] = await Promise.all([
+      transformer.transform(image1),
+      transformer.transform(image2)
+    ]);
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(
+        `Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`
+      );
+    }
+    let outputData;
+    if (options.outputPath) {
+      outputData = new Uint8Array(img1.data.length);
+    }
+    const startTime = performance.now();
+    const score = (0, import_ssim.default)(img1.data, img2.data, outputData, img1.width, img1.height, {});
+    const duration = performance.now() - startTime;
+    if (options.outputPath && outputData) {
+      await transformer.write(
+        {
+          data: outputData,
+          width: img1.width,
+          height: img1.height
+        },
+        options.outputPath
+      );
+    }
+    const result = {
+      score,
+      width: img1.width,
+      height: img1.height,
+      duration
+    };
+    console.log(`completed in: ${result.duration.toFixed(2)}ms`);
+    console.log(`dimensions: ${result.width}x${result.height}`);
+    console.log(
+      `SSIM score: ${result.score.toFixed(6)} (0=different, 1=identical)`
+    );
+    console.log(`similarity: ${(result.score * 100).toFixed(2)}%`);
+    if (options.outputPath && outputData) {
+      console.log(`SSIM map saved to: ${options.outputPath}`);
+    }
+    if (result.score < 0.95) {
+      process.exit(1);
+    } else {
+      console.log(`Images are highly similar!`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
   }
-  return { image1, image2, options };
 }
-var getTransformer = async (transformer) => {
-  if (!transformer || transformer === "pngjs") {
-    const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
-    return transformer2;
+var import_ssim, getTransformer3;
+var init_ssim = __esm({
+  "src/commands/ssim.ts"() {
+    "use strict";
+    import_ssim = __toESM(require("@blazediff/ssim/ssim"));
+    getTransformer3 = async (transformer) => {
+      if (!transformer || transformer === "pngjs") {
+        const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
+        return transformer2;
+      }
+      if (transformer === "sharp") {
+        const { default: transformer2 } = await import("@blazediff/sharp-transformer");
+        return transformer2;
+      }
+      throw new Error(`Unknown transformer: ${transformer}`);
+    };
+    if (typeof require !== "undefined" && require.main === module) {
+      main3();
+    }
   }
-  if (transformer === "sharp") {
-    const { default: transformer2 } = await import("@blazediff/sharp-transformer");
-    return transformer2;
+});
+
+// src/commands/msssim.ts
+var msssim_exports = {};
+__export(msssim_exports, {
+  default: () => main4
+});
+function printUsage4() {
+  console.log(`
+Usage: blazediff msssim <image1> <image2> [options]
+
+Arguments:
+  image1    Path to the first image
+  image2    Path to the second image
+
+Options:
+  -o, --output <path>    Output path for MS-SSIM map visualization
+  --transformer <name>   Specify transformer to use (e.g. pngjs, sharp)
+  -h, --help             Show this help message
+
+Examples:
+  blazediff msssim image1.png image2.png
+  blazediff msssim image1.png image2.png -o msssim-map.png
+`);
+}
+async function main4() {
+  try {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+      printUsage4();
+      process.exit(0);
+    }
+    if (args.length < 2) {
+      console.error("Error: Two image paths are required");
+      printUsage4();
+      process.exit(1);
+    }
+    const image1 = args[0];
+    const image2 = args[1];
+    const options = {};
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      const nextArg = args[i + 1];
+      switch (arg) {
+        case "-o":
+        case "--output":
+          if (nextArg) {
+            options.outputPath = nextArg;
+            i++;
+          }
+          break;
+        case "--transformer":
+          if (nextArg) {
+            options.transformer = nextArg;
+            i++;
+          }
+          break;
+        default:
+          console.error(`Unknown option: ${arg}`);
+          printUsage4();
+          process.exit(1);
+      }
+    }
+    const transformer = await getTransformer4(options.transformer);
+    const [img1, img2] = await Promise.all([
+      transformer.transform(image1),
+      transformer.transform(image2)
+    ]);
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(
+        `Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`
+      );
+    }
+    let outputData;
+    if (options.outputPath) {
+      outputData = new Uint8Array(img1.data.length);
+    }
+    const startTime = performance.now();
+    const score = (0, import_msssim.default)(img1.data, img2.data, outputData, img1.width, img1.height, {});
+    const duration = performance.now() - startTime;
+    if (options.outputPath && outputData) {
+      await transformer.write(
+        {
+          data: outputData,
+          width: img1.width,
+          height: img1.height
+        },
+        options.outputPath
+      );
+    }
+    const result = {
+      score,
+      width: img1.width,
+      height: img1.height,
+      duration
+    };
+    console.log(`completed in: ${result.duration.toFixed(2)}ms`);
+    console.log(`dimensions: ${result.width}x${result.height}`);
+    console.log(
+      `MS-SSIM score: ${result.score.toFixed(6)} (0=different, 1=identical)`
+    );
+    console.log(`similarity: ${(result.score * 100).toFixed(2)}%`);
+    if (options.outputPath && outputData) {
+      console.log(`MS-SSIM map saved to: ${options.outputPath}`);
+    }
+    if (result.score < 0.95) {
+      process.exit(1);
+    } else {
+      console.log(`Images are highly similar!`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
   }
-  throw new Error(`Unknown transformer: ${transformer}`);
-};
-async function main() {
+}
+var import_msssim, getTransformer4;
+var init_msssim = __esm({
+  "src/commands/msssim.ts"() {
+    "use strict";
+    import_msssim = __toESM(require("@blazediff/ssim/msssim"));
+    getTransformer4 = async (transformer) => {
+      if (!transformer || transformer === "pngjs") {
+        const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
+        return transformer2;
+      }
+      if (transformer === "sharp") {
+        const { default: transformer2 } = await import("@blazediff/sharp-transformer");
+        return transformer2;
+      }
+      throw new Error(`Unknown transformer: ${transformer}`);
+    };
+    if (typeof require !== "undefined" && require.main === module) {
+      main4();
+    }
+  }
+});
+
+// src/commands/hitchhikers-ssim.ts
+var hitchhikers_ssim_exports = {};
+__export(hitchhikers_ssim_exports, {
+  default: () => main5
+});
+function printUsage5() {
+  console.log(`
+Usage: blazediff hitchhikers-ssim <image1> <image2> [options]
+
+Arguments:
+  image1    Path to the first image
+  image2    Path to the second image
+
+Options:
+  -o, --output <path>      Output path for SSIM map visualization
+  --transformer <name>     Specify transformer to use (e.g. pngjs, sharp)
+  --window-size <size>     Window size (default: 11)
+  --window-stride <size>   Window stride (default: windowSize for non-overlapping)
+  --no-cov-pooling         Use mean pooling instead of CoV pooling
+  -h, --help               Show this help message
+
+About Hitchhiker's SSIM:
+  - Uses rectangular windows with integral images (summed area tables)
+  - O(1) window computation regardless of window size
+  - Coefficient of Variation (CoV) pooling by default
+  - Significantly faster than Gaussian-based SSIM
+
+  Reference: "A Hitchhiker's Guide to Structural Similarity"
+  (IEEE Access, 2021) by Venkataramanan et al.
+
+Examples:
+  blazediff hitchhikers-ssim image1.png image2.png
+  blazediff hitchhikers-ssim image1.png image2.png -o ssim-map.png
+  blazediff hitchhikers-ssim image1.png image2.png --window-size 16 --window-stride 8
+  blazediff hitchhikers-ssim image1.png image2.png --no-cov-pooling
+`);
+}
+async function main5() {
   try {
-    const { image1, image2, options } = parseArgs();
-    const transformer = await getTransformer(options.transformer);
-    const result = await blazeDiffBin(image1, image2, {
-      outputPath: options.outputPath,
-      transformer,
-      coreOptions: {
-        threshold: options.threshold,
-        alpha: options.alpha,
-        aaColor: options.aaColor,
-        diffColor: options.diffColor,
-        diffColorAlt: options.diffColorAlt,
-        includeAA: options.includeAA,
-        diffMask: options.diffMask
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+      printUsage5();
+      process.exit(0);
+    }
+    if (args.length < 2) {
+      console.error("Error: Two image paths are required");
+      printUsage5();
+      process.exit(1);
+    }
+    const image1 = args[0];
+    const image2 = args[1];
+    const options = {
+      covPooling: true
+    };
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      const nextArg = args[i + 1];
+      switch (arg) {
+        case "-o":
+        case "--output":
+          if (nextArg) {
+            options.outputPath = nextArg;
+            i++;
+          }
+          break;
+        case "--transformer":
+          if (nextArg) {
+            options.transformer = nextArg;
+            i++;
+          }
+          break;
+        case "--window-size":
+          if (nextArg) {
+            const size = Number.parseInt(nextArg, 10);
+            if (Number.isNaN(size) || size <= 0) {
+              throw new Error(`Invalid window size: ${nextArg}`);
+            }
+            options.windowSize = size;
+            i++;
+          }
+          break;
+        case "--window-stride":
+          if (nextArg) {
+            const stride = Number.parseInt(nextArg, 10);
+            if (Number.isNaN(stride) || stride <= 0) {
+              throw new Error(`Invalid window stride: ${nextArg}`);
+            }
+            options.windowStride = stride;
+            i++;
+          }
+          break;
+        case "--no-cov-pooling":
+          options.covPooling = false;
+          break;
+        default:
+          console.error(`Unknown option: ${arg}`);
+          printUsage5();
+          process.exit(1);
       }
-    });
-    console.log(`matched in: ${result.duration.toFixed(2)}ms`);
+    }
+    const transformer = await getTransformer5(options.transformer);
+    const [img1, img2] = await Promise.all([
+      transformer.transform(image1),
+      transformer.transform(image2)
+    ]);
+    if (img1.width !== img2.width || img1.height !== img2.height) {
+      throw new Error(
+        `Image dimensions do not match: ${img1.width}x${img1.height} vs ${img2.width}x${img2.height}`
+      );
+    }
+    let outputData;
+    if (options.outputPath) {
+      outputData = new Uint8Array(img1.data.length);
+    }
+    const ssimOptions = {};
+    if (typeof options.windowSize === "number") {
+      ssimOptions.windowSize = options.windowSize;
+    }
+    if (typeof options.windowStride === "number") {
+      ssimOptions.windowStride = options.windowStride;
+    }
+    if (typeof options.covPooling === "boolean") {
+      ssimOptions.covPooling = options.covPooling;
+    }
+    const startTime = performance.now();
+    const score = (0, import_hitchhikers_ssim.default)(img1.data, img2.data, outputData, img1.width, img1.height, ssimOptions);
+    const duration = performance.now() - startTime;
+    if (options.outputPath && outputData) {
+      await transformer.write(
+        {
+          data: outputData,
+          width: img1.width,
+          height: img1.height
+        },
+        options.outputPath
+      );
+    }
+    const result = {
+      score,
+      width: img1.width,
+      height: img1.height,
+      duration,
+      poolingMethod: ssimOptions.covPooling === false ? "mean" : "CoV",
+      windowSize: ssimOptions.windowSize || 11,
+      windowStride: ssimOptions.windowStride || ssimOptions.windowSize || 11
+    };
+    console.log(`completed in: ${result.duration.toFixed(2)}ms`);
     console.log(`dimensions: ${result.width}x${result.height}`);
-    console.log(`different pixels: ${result.diffCount}`);
+    console.log(`window: ${result.windowSize}x${result.windowSize} (stride: ${result.windowStride})`);
+    console.log(`pooling: ${result.poolingMethod}`);
     console.log(
-      `error: ${(result.diffCount / (result.width * result.height) * 100).toFixed(2)}%`
+      `Hitchhiker's SSIM score: ${result.score.toFixed(6)} (0=different, 1=identical)`
     );
-    if (result.diffCount > 0 && result.outputData) {
-      console.log(`diff image: ${options.outputPath}`);
+    console.log(`similarity: ${(result.score * 100).toFixed(2)}%`);
+    if (options.outputPath && outputData) {
+      console.log(`SSIM map saved to: ${options.outputPath}`);
     }
-    if (result.diffCount > 0) {
+    if (result.score < 0.95) {
       process.exit(1);
     } else {
-      console.log(`Images are identical!`);
+      console.log(`Images are highly similar!`);
       process.exit(0);
     }
   } catch (error) {
@@ -251,6 +887,93 @@ async function main() {
     process.exit(1);
   }
 }
+var import_hitchhikers_ssim, getTransformer5;
+var init_hitchhikers_ssim = __esm({
+  "src/commands/hitchhikers-ssim.ts"() {
+    "use strict";
+    import_hitchhikers_ssim = __toESM(require("@blazediff/ssim/hitchhikers-ssim"));
+    getTransformer5 = async (transformer) => {
+      if (!transformer || transformer === "pngjs") {
+        const { default: transformer2 } = await import("@blazediff/pngjs-transformer");
+        return transformer2;
+      }
+      if (transformer === "sharp") {
+        const { default: transformer2 } = await import("@blazediff/sharp-transformer");
+        return transformer2;
+      }
+      throw new Error(`Unknown transformer: ${transformer}`);
+    };
+    if (typeof require !== "undefined" && require.main === module) {
+      main5();
+    }
+  }
+});
+
+// src/cli.ts
+function printUsage6() {
+  console.log(`
+Usage: blazediff <command> <image1> <image2> [options]
+
+Commands:
+  diff               Pixel-by-pixel comparison (default)
+  gmsd               Gradient Magnitude Similarity Deviation metric
+  ssim               Structural Similarity Index (Gaussian-based)
+  msssim             Multi-Scale Structural Similarity Index
+  hitchhikers-ssim   Hitchhiker's SSIM (fast, integral image-based)
+
+Options:
+  -h, --help    Show this help message
+
+Examples:
+  blazediff diff image1.png image2.png -o diff.png
+  blazediff gmsd image1.png image2.png
+  blazediff ssim image1.png image2.png -o ssim-map.png
+  blazediff msssim image1.png image2.png
+  blazediff hitchhikers-ssim image1.png image2.png
+
+  # Default command (diff) if no command specified
+  blazediff image1.png image2.png
+
+For command-specific help, use:
+  blazediff <command> --help
+`);
+}
+async function main6() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    printUsage6();
+    process.exit(0);
+  }
+  const command = args[0];
+  const validCommands = ["diff", "gmsd", "ssim", "msssim", "hitchhikers-ssim"];
+  const isCommand = validCommands.includes(command);
+  if ((args.includes("-h") || args.includes("--help")) && !isCommand) {
+    printUsage6();
+    process.exit(0);
+  }
+  if (isCommand) {
+    process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];
+    switch (command) {
+      case "diff":
+        await Promise.resolve().then(() => (init_diff(), diff_exports));
+        break;
+      case "gmsd":
+        await Promise.resolve().then(() => (init_gmsd(), gmsd_exports));
+        break;
+      case "ssim":
+        await Promise.resolve().then(() => (init_ssim(), ssim_exports));
+        break;
+      case "msssim":
+        await Promise.resolve().then(() => (init_msssim(), msssim_exports));
+        break;
+      case "hitchhikers-ssim":
+        await Promise.resolve().then(() => (init_hitchhikers_ssim(), hitchhikers_ssim_exports));
+        break;
+    }
+  } else {
+    await Promise.resolve().then(() => (init_diff(), diff_exports));
+  }
+}
 if (typeof require !== "undefined" && require.main === module) {
-  main();
+  main6();
 }