Merge branch 'main' of https://github.com/dmtrKovalenko/odiff

.ci/release-postinstall.js

@@ -15,7 +15,6 @@ var platform = process.platform;
 
 process.env["OCAML_VERSION"] = "ocaml";
 process.env["OCAML_PKG_NAME"] = "n.00.0000";
-process.env["ESY_RELEASE_REWRITE_PREFIX"] = true;
 
 var packageJson = require("./package.json");
 var binariesToCopy = Object.keys(packageJson.bin)

.vscode/settings.json

@@ -26,6 +26,8 @@
     "system_error": "c",
     "tuple": "c",
     "type_traits": "c",
-    "vector": "c"
+    "vector": "c",
+    "ios": "c",
+    "cstddef": "c"
   }
 }

README.md

@@ -13,7 +13,7 @@
 
 ## Why Odiff?
 
-ODiff is a blazing fast native image comparison tool. Check [benchmarks](#benchmarks) for the results, but it compares the visual difference between 2 images in **milliseconds**. It was originally designed to handle the "big" images. Thanks to [Ocaml](https://ocaml.org/) and its speedy and predictable compiler we can significantly speed up your CI pipeline.
+ODiff is a blazing fast native image comparison tool. Check [benchmarks](#benchmarks) for the results, but it compares the visual difference between 2 images in **milliseconds**. It was originally designed to handle the "big" images. Thanks to [OCaml](https://ocaml.org/) and its speedy and predictable compiler we can significantly speed up your CI pipeline.
 
 ## Demo
 
@@ -179,7 +179,7 @@ Lets compare 2 screenshots of full-size [https://cypress.io](cypress.io) page:
 | ImageMagick `compare www.cypress.io-1.png www.cypress.io.png -compose src diff-magick.png` | 8.881 ± 0.121 |   8.692 |   9.066 | 7.65 ± 0.04 |
 | `odiff www.cypress.io-1.png www.cypress.io.png www.cypress-diff.png`                       | 1.168 ± 0.008 |   1.157 |   1.185 |        1.00 |
 
-Wow. Odiff is mostly 2 times faster than imagemagick and pixelmatch. And this will be even clearer if image will become larger. Lets compare an [8k image](images/water-4k.png) to find a difference with [another 8k image](images/water-4k-2.png):
+Wow. Odiff is mostly 6 times faster than imagemagick and pixelmatch. And this will be even clearer if image will become larger. Lets compare an [8k image](images/water-4k.png) to find a difference with [another 8k image](images/water-4k-2.png):
 
 | Command                                                                       |       Mean [s] | Min [s] | Max [s] |    Relative |
 | :---------------------------------------------------------------------------- | -------------: | ------: | ------: | ----------: |

bin/Main.re

@@ -1,10 +1,13 @@
 open Odiff.ImageIO;
 open Odiff.Diff;
 
-let getIOModule = filename =>
+let getIOModule = (filename, ~antialiasing) =>
   Filename.extension(filename)
   |> (
     fun
+    | ".png" when antialiasing => (
+        (module ODiffIO.PureC_IO_Bigarray.IO): (module ImageIO)
+      )
     | ".png" => ((module ODiffIO.PureC_IO.IO): (module ImageIO))
     | _ => ((module ODiffIO.CamlImagesIO.IO): (module ImageIO))
   );
@@ -24,9 +27,10 @@ let main =
       failOnLayoutChange,
       diffColorHex,
       stdoutParsableString,
+      antialiasing,
     ) => {
-  module IO1 = (val getIOModule(img1Path));
-  module IO2 = (val getIOModule(img2Path));
+  module IO1 = (val getIOModule(img1Path, ~antialiasing));
+  module IO2 = (val getIOModule(img2Path, ~antialiasing));
 
   module Diff = MakeDiff(IO1, IO2);
 
@@ -40,6 +44,7 @@ let main =
       ~outputDiffMask,
       ~threshold,
       ~failOnLayoutChange,
+      ~antialiasing,
       ~diffPixel=
         Color.ofHexString(diffColorHex)
         |> (

bin/ODiffBin.re

@@ -76,9 +76,22 @@ let diffColor =
     & opt(string, "")
     & info(
         ["diff-color"],
-        ~doc="Color used to highlight different pixels in the output (in hex format e.g. #cd2cc9).",
+        ~doc=
+          "Color used to highlight different pixels in the output (in hex format e.g. #cd2cc9).",
+      )
+  );
+
+let antialiasing = {
+  Arg.(
+    value
+    & flag
+    & info(
+        ["aa", "antialiasing"],
+        ~doc=
+          "With this flag enabled, antialiased pixels are not counted to the diff of an image",
       )
   );
+};
 
 let cmd = {
   let man = [
@@ -98,6 +111,7 @@ let cmd = {
       $ failOnLayout
       $ diffColor
       $ parsableOutput
+      $ antialiasing
     ),
     Term.info(
       "odiff",

bin/node-bindings/odiff.d.ts

@@ -7,6 +7,8 @@ export type ODiffOptions = {
   failOnLayoutDiff: boolean;
   /** Color difference threshold (from 0 to 1). Less more precise. */
   threshold: number;
+  /** If this is true, antialiased pixels are not counted to the diff of an image */
+  antialiasing: boolean;
 };
 
 declare function compare(

bin/node-bindings/odiff.js

@@ -41,6 +41,10 @@ function optionsToArgs(options) {
       case "diffColor":
         setArgWithValue("diff-color", value);
         break;
+
+      case "antialiasing":
+        setArgWithValue("antialiasing", value);
+        break;
     }
   });
 

io/CamlImagesIO.re

@@ -22,7 +22,7 @@ module IO: ImageIO.ImageIO = {
     Png.save(filename, [], Images.Rgba32(img.image));
   };
 
-  let readImgColor = (x, y, img: ImageIO.img(t)) => {
+  let readDirectPixel = (~x, ~y, img: ImageIO.img(Rgba32.t)) => {
     let (bytes, position) = Rgba32.unsafe_access(img.image, x, y);
 
     (
@@ -33,9 +33,12 @@ module IO: ImageIO.ImageIO = {
     );
   };
 
+  let readImgColor = (x, y, img: ImageIO.img(t)) =>
+    readDirectPixel(~x, ~y, img);
+
   let setImgColor = (x, y, (r, g, b), img: ImageIO.img(t)) => {
     let (bytes, position) = Rgba32.unsafe_access(img.image, x, y);
-    
+
     Bytes.unsafe_set(bytes, position, r |> char_of_int);
     Bytes.unsafe_set(bytes, position + 1, g |> char_of_int);
     Bytes.unsafe_set(bytes, position + 2, b |> char_of_int);

io/PureC_IO.re

@@ -1,5 +1,5 @@
 module IO: Odiff.ImageIO.ImageIO = {
-  type t;
+  type t = int;
   type row =
     Bigarray.Array1.t(int, Bigarray.int8_unsigned_elt, Bigarray.c_layout);
 
@@ -16,7 +16,8 @@ module IO: Odiff.ImageIO.ImageIO = {
   };
 
   let loadImage = (filename): Odiff.ImageIO.img(t) => {
-    let (width, height, rowPointers) = ReadPng.read_png_image(filename);
+    let (width, height, _rowbytes, rowPointers) =
+      ReadPng.read_png_image(filename);
 
     {width, height, image: rowPointers};
   };
@@ -32,4 +33,8 @@ module IO: Odiff.ImageIO.ImageIO = {
   let makeSameAsLayout = (img: Odiff.ImageIO.img(t)) => {
     {...img, image: ReadPng.create_empty_img(img.height, img.width)};
   };
+
+  let readDirectPixel = (~x, ~y, _img) => {
+    failwith("Direct pixel access is not allowed for imperative C IO");
+  };
 };

io/PureC_IO_Bigarray.re

@@ -0,0 +1,70 @@
+open Odiff.ImageIO;
+
+module IO: Odiff.ImageIO.ImageIO = {
+  type rowPointers = int;
+  type t = {
+    rowPointers,
+    bigarray: Bigarray.Array1.t(int32, Bigarray.int32_elt, Bigarray.c_layout),
+  };
+
+  type row = int;
+  let readDirectPixel = (~x: int, ~y: int, img) => {
+    let pixel = (img.image.bigarray).{y * img.width + x} |> Int32.to_int;
+
+    let a = pixel lsr 24 land 0xFF;
+    let r = pixel lsr 16 land 0xFF;
+    let g = pixel lsr 8 land 0xFF;
+    let b = pixel land 0xFF;
+
+    (r, g, b, a);
+  };
+
+  let readRow = (img: Odiff.ImageIO.img(t), y): row => y;
+  // row is always an int, so we can read pixel directly
+  let readImgColor = (x, row: row, img: Odiff.ImageIO.img(t)) =>
+    readDirectPixel(~x, ~y=row, img);
+
+  let setImgColor = (x, y, pixel, img: Odiff.ImageIO.img(t)) => {
+    ReadPng.set_pixel_data(img.image.rowPointers, x, y, pixel);
+  };
+
+  let loadImage = (filename): Odiff.ImageIO.img(t) => {
+    let (width, height, rowbytes, rowPointers) =
+      ReadPng.read_png_image(filename);
+
+    let bigarray =
+      ReadPng.row_pointers_to_bigarray(rowPointers, rowbytes, height, width);
+
+    {
+      width,
+      height,
+      image: {
+        bigarray,
+        rowPointers,
+      },
+    };
+  };
+
+  let saveImage = (img: Odiff.ImageIO.img(t), filename) => {
+    ReadPng.write_png_file(
+      img.image.rowPointers,
+      img.width,
+      img.height,
+      filename,
+    );
+  };
+
+  let freeImage = (img: Odiff.ImageIO.img(t)) => {
+    ReadPng.free_row_pointers(img.image.rowPointers, img.height);
+  };
+
+  let makeSameAsLayout = (img: Odiff.ImageIO.img(t)) => {
+    {
+      ...img,
+      image: {
+        rowPointers: ReadPng.create_empty_img(img.height, img.width),
+        bigarray: img.image.bigarray,
+      },
+    };
+  };
+};

io/ReadPng.c

@@ -82,10 +82,11 @@ read_png_file_to_tuple(value file)
   png_read_update_info(png, info);
 
   row_pointers = (png_bytep *)malloc(sizeof(png_bytep) * height);
+  int rowbytes = png_get_rowbytes(png, info);
 
   for (int y = 0; y < height; y++)
   {
-    row_pointers[y] = (png_byte *)malloc(png_get_rowbytes(png,info));
+    row_pointers[y] = (png_byte *)malloc(rowbytes);
   }
 
   png_read_image(png, row_pointers);
@@ -94,23 +95,44 @@ read_png_file_to_tuple(value file)
 
   png_destroy_read_struct(&png, &info, NULL);
 
-  res = caml_alloc(3, 0);
+  res = caml_alloc(4, 0);
 
   Store_field(res, 0, Val_int(width));
   Store_field(res, 1, Val_int(height));
-  Store_field(res, 2, row_pointers);
+  Store_field(res, 2, Val_int(rowbytes));
+  Store_field(res, 3, row_pointers);
 
   CAMLreturn(res);
 }
 
+CAMLprim value
+row_pointers_to_bigarray(png_bytep *row_pointers, value rowbytes_val, value height_val, value width_val)
+{
+  CAMLparam3(rowbytes_val, height_val, width_val);
+
+  int width = Int_val(width_val);
+  int height = Int_val(height_val);
+  int rowbytes = Int_val(rowbytes_val);
+
+  unsigned char *total_pixels = malloc(height * rowbytes);
+
+  for (int y = 0; y < height; y++)
+  {
+    memcpy(total_pixels + y * rowbytes, row_pointers[y], rowbytes);
+  }
+
+  long dims[1] = {width * height};
+  CAMLreturn(caml_ba_alloc(CAML_BA_INT32 | CAML_BA_C_LAYOUT, 1, total_pixels, dims));
+}
+
 CAMLprim value
 create_empty_img(value height_val, value width_val)
 {
   CAMLparam2(height_val, width_val);
   int width = Int_val(width_val);
   int height = Int_val(height_val);
-  
-  png_bytep *row_pointers = (png_bytep *)malloc(sizeof(png_bytep) * height);;
+
+  png_bytep *row_pointers = (png_bytep *)malloc(sizeof(png_bytep) * height);
 
   for (int y = 0; y < height; y++)
   {
@@ -128,7 +150,6 @@ read_row(png_bytep *row_pointers, value y_val, value img_width_val)
   int img_width = Int_val(img_width_val);
 
   png_bytep row = row_pointers[y];
-  png_bytep px = &(row[1 * 4]);
 
   long dims[] = {img_width * 4};
   CAMLreturn(caml_ba_alloc(CAML_BA_UINT8 | CAML_BA_C_LAYOUT, 1, row, dims));

io/ReadPng.ml

@@ -1,5 +1,6 @@
 
-external read_png_image: string -> int * int * 'a  = "read_png_file_to_tuple"
+external read_png_image: string -> int * int * int * 'b = "read_png_file_to_tuple"
+external row_pointers_to_bigarray: 'b -> int ->  int -> int-> 'c = "row_pointers_to_bigarray"
 
 external read_row: 'a -> int -> int -> 'b  = "read_row"
 
@@ -9,5 +10,4 @@ external write_png_file: 'a -> int -> int -> string -> unit = "write_png_file" [
 
 external free_row_pointers: 'a -> int -> unit = "free_row_pointers" [@@noalloc]
 
-external create_empty_img: int -> int -> 'a = "create_empty_img" [@@noalloc]
-
+external create_empty_img: int -> int -> 'a = "create_empty_img" [@@noalloc]

io/dune

@@ -5,7 +5,7 @@
   (-w -40 -w +26))
   (foreign_stubs (language c) (names ReadPng) (flags (:include c_flags.sexp)))
   (c_library_flags (:include c_library_flags.sexp))
-  (libraries odiff-core camlimages.png camlimages.jpeg camlimages.tiff camlimages.xpm)
+  (libraries odiff-core console.lib camlimages.png camlimages.jpeg camlimages.tiff camlimages.xpm)
  )
 
 (rule