@blazediff/bin 1.4.1 → 1.6.0

package/dist/commands/msssim.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/msssim.ts
+var msssim_exports = {};
+__export(msssim_exports, {
+  default: () => main
+});
+module.exports = __toCommonJS(msssim_exports);
+var import_msssim = __toESM(require("@blazediff/ssim/msssim"));
+function printUsage() {
+  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
+`);
+}
+var 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}`);
+};
+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 "--transformer":
+          if (nextArg) {
+            options.transformer = 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 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);
+  }
+}
+if (typeof require !== "undefined" && require.main === module) {
+  main();
+}

package/dist/commands/ssim.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/ssim.ts
+var ssim_exports = {};
+__export(ssim_exports, {
+  default: () => main
+});
+module.exports = __toCommonJS(ssim_exports);
+var import_ssim = __toESM(require("@blazediff/ssim/ssim"));
+function printUsage() {
+  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
+`);
+}
+var 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}`);
+};
+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 "--transformer":
+          if (nextArg) {
+            options.transformer = 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 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);
+  }
+}
+if (typeof require !== "undefined" && require.main === module) {
+  main();
+}

package/dist/index.d.mts

@@ -1,17 +1,69 @@
-import { BlazeDiffTransformer, BlazeDiffOptions } from '@blazediff/types';
-
-interface BlazeDiffBinOptions {
+interface Image {
+    data: Buffer | Uint8Array | Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+interface Transformer {
+    transform: (input: string | Buffer) => Promise<Image>;
+    write: (image: Image, output: string | Buffer) => Promise<void>;
+}
+type ComparisonMode = "diff" | "gmsd" | "ssim" | "msssim";
+interface DiffModeOptions {
+    outputPath?: string;
+    transformer: Transformer;
+    mode?: "diff";
+    options?: Record<string, unknown>;
+}
+interface GmsdModeOptions {
     outputPath?: string;
-    transformer: BlazeDiffTransformer;
-    coreOptions?: BlazeDiffOptions;
+    transformer: Transformer;
+    mode: "gmsd";
+    options?: Record<string, unknown>;
 }
-interface BlazeDiffBinResult {
+interface SsimModeOptions {
+    outputPath?: string;
+    transformer: Transformer;
+    mode: "ssim";
+    options?: Record<string, unknown>;
+}
+interface MsssimModeOptions {
+    outputPath?: string;
+    transformer: Transformer;
+    mode: "msssim";
+    options?: Record<string, unknown>;
+}
+interface DiffModeResult {
+    mode: "diff";
     diffCount: number;
     width: number;
     height: number;
     outputData?: Uint8Array;
     duration: number;
 }
-declare function blazeDiffBin(image1Path: string, image2Path: string, options: BlazeDiffBinOptions): Promise<BlazeDiffBinResult>;
+interface GmsdModeResult {
+    mode: "gmsd";
+    score: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+interface SsimModeResult {
+    mode: "ssim";
+    score: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+interface MsssimModeResult {
+    mode: "msssim";
+    score: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+type BlazeDiffBinResult = DiffModeResult | GmsdModeResult | SsimModeResult | MsssimModeResult;
 
-export { type BlazeDiffBinOptions, type BlazeDiffBinResult, blazeDiffBin as default };
+export type { BlazeDiffBinResult, ComparisonMode, DiffModeOptions, DiffModeResult, GmsdModeOptions, GmsdModeResult, Image, MsssimModeOptions, MsssimModeResult, SsimModeOptions, SsimModeResult, Transformer };

package/dist/index.d.ts

@@ -1,17 +1,69 @@
-import { BlazeDiffTransformer, BlazeDiffOptions } from '@blazediff/types';
-
-interface BlazeDiffBinOptions {
+interface Image {
+    data: Buffer | Uint8Array | Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+interface Transformer {
+    transform: (input: string | Buffer) => Promise<Image>;
+    write: (image: Image, output: string | Buffer) => Promise<void>;
+}
+type ComparisonMode = "diff" | "gmsd" | "ssim" | "msssim";
+interface DiffModeOptions {
+    outputPath?: string;
+    transformer: Transformer;
+    mode?: "diff";
+    options?: Record<string, unknown>;
+}
+interface GmsdModeOptions {
     outputPath?: string;
-    transformer: BlazeDiffTransformer;
-    coreOptions?: BlazeDiffOptions;
+    transformer: Transformer;
+    mode: "gmsd";
+    options?: Record<string, unknown>;
 }
-interface BlazeDiffBinResult {
+interface SsimModeOptions {
+    outputPath?: string;
+    transformer: Transformer;
+    mode: "ssim";
+    options?: Record<string, unknown>;
+}
+interface MsssimModeOptions {
+    outputPath?: string;
+    transformer: Transformer;
+    mode: "msssim";
+    options?: Record<string, unknown>;
+}
+interface DiffModeResult {
+    mode: "diff";
     diffCount: number;
     width: number;
     height: number;
     outputData?: Uint8Array;
     duration: number;
 }
-declare function blazeDiffBin(image1Path: string, image2Path: string, options: BlazeDiffBinOptions): Promise<BlazeDiffBinResult>;
+interface GmsdModeResult {
+    mode: "gmsd";
+    score: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+interface SsimModeResult {
+    mode: "ssim";
+    score: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+interface MsssimModeResult {
+    mode: "msssim";
+    score: number;
+    width: number;
+    height: number;
+    outputData?: Uint8Array;
+    duration: number;
+}
+type BlazeDiffBinResult = DiffModeResult | GmsdModeResult | SsimModeResult | MsssimModeResult;
 
-export { type BlazeDiffBinOptions, type BlazeDiffBinResult, blazeDiffBin as default };
+export type { BlazeDiffBinResult, ComparisonMode, DiffModeOptions, DiffModeResult, GmsdModeOptions, GmsdModeResult, Image, MsssimModeOptions, MsssimModeResult, SsimModeOptions, SsimModeResult, Transformer };

package/dist/index.js

@@ -1 +1 @@
-'use strict';var m=require('@blazediff/core');function _interopDefault(e){return e&&e.__esModule?e:{default:e}}var m__default=/*#__PURE__*/_interopDefault(m);async function u(n,f,i){let[t,e]=await Promise.all([i.transformer.transform(n),i.transformer.transform(f)]);if(t.width!==e.width||t.height!==e.height)throw new Error(`Image dimensions do not match: ${t.width}x${t.height} vs ${e.width}x${e.height}`);let r;i.outputPath&&(r=new Uint8Array(t.data.length));let h=performance.now(),a=m__default.default(t.data,e.data,r,t.width,t.height,i.coreOptions),o=performance.now()-h;return a>0&&i.outputPath&&r&&await i.transformer.write({data:r,width:t.width,height:t.height},i.outputPath),{diffCount:a,width:t.width,height:t.height,outputData:r,duration:o}}module.exports=u;
+'use strict';

package/dist/index.mjs

@@ -1 +0,0 @@
-import m from'@blazediff/core';async function u(n,f,i){let[t,e]=await Promise.all([i.transformer.transform(n),i.transformer.transform(f)]);if(t.width!==e.width||t.height!==e.height)throw new Error(`Image dimensions do not match: ${t.width}x${t.height} vs ${e.width}x${e.height}`);let r;i.outputPath&&(r=new Uint8Array(t.data.length));let h=performance.now(),a=m(t.data,e.data,r,t.width,t.height,i.coreOptions),o=performance.now()-h;return a>0&&i.outputPath&&r&&await i.transformer.write({data:r,width:t.width,height:t.height},i.outputPath),{diffCount:a,width:t.width,height:t.height,outputData:r,duration:o}}export{u as default};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blazediff/bin",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "Command-line interface for the blazediff image comparison library",
   "private": false,
   "publishConfig": {
@@ -37,10 +37,11 @@
   "homepage": "https://blazediff.dev",
   "license": "MIT",
   "dependencies": {
-    "@blazediff/core": "1.4.1",
-    "@blazediff/pngjs-transformer": "1.4.1",
-    "@blazediff/sharp-transformer": "1.4.1",
-    "@blazediff/types": "1.4.1"
+    "@blazediff/core": "1.6.0",
+    "@blazediff/gmsd": "1.6.0",
+    "@blazediff/pngjs-transformer": "1.6.0",
+    "@blazediff/sharp-transformer": "1.6.0",
+    "@blazediff/ssim": "1.6.0"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",