eyes_core 3.1.1 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6bfdf93e062d2d12f52900e4e161d86064443a4
-  data.tar.gz: 49420a387dc5327c6cd31a5f814e4e1e29f90948
+  metadata.gz: c88e7c7471138c545eb26cd0d3071f2dbf913b96
+  data.tar.gz: af7acdaacc4fdad1954e0c7882d4d548bf1ef4b2
 SHA512:
-  metadata.gz: 4a3d745e90548ce9c1d9d73471a369e6c2d3eda0fa4dbabf2bfe50159180e3081248f707f15db8d3f488bf80a6a51920e3ed605ea6138b2e39cdc345e18d10f4
-  data.tar.gz: 47fdcf476ad6fa1894e70a303b5c8793c6207688e8b9749f9058818761d3277a92ea907f129430f7ac5edbed74bcd62002753ce586caf33a4ce6b844ec45f8eb
+  metadata.gz: 462827e9166de30c60354313015f28172b4d7010320ebbe069a8a707634f661002658369c5d7cbf8f8383e10d77434373279c2eb98ee52e77a8037791a481c9d
+  data.tar.gz: b2faaa4260c1f8fbda48e70a91b4bb94b369f8eda013de55c1d1549665ebbef7ff888f53bf29b41e390cd2a5d95c8050de5d2b038edc5d2b2c9feab82b86e04a

data/ext/eyes_core/eyes_core.c

@@ -3,26 +3,73 @@
 void Init_eyes_core() {
   VALUE Applitools = rb_define_module("Applitools");
   VALUE Resampling = rb_define_module_under(Applitools, "ResamplingFast");
-  rb_define_method(Resampling, "interpolate_cubic", c_interpolate_cubic, 1);
-  rb_define_method(Resampling, "merge_pixels", c_merge_pixels, 1);
-  rb_define_method(Resampling, "bicubic_points2", c_bicubic_points, 3);
-  rb_define_method(Resampling, "scale_points2", scale_points2, 4);
+  rb_define_method(Resampling, "resampling_first_step", c_resampling_first_step, 2);
 };
 
+VALUE c_resampling_first_step(VALUE self, VALUE dst_dimension_x, VALUE dst_dimension_y) {
+    PIXEL *source, *destination;
+    unsigned long int source_width, source_height, c_dst_dimension_x, c_dst_dimension_y, w_m, h_m;
+    VALUE result_array;
 
-VALUE c_interpolate_cubic(VALUE self, VALUE data) {
-  double t = NUM2DBL(rb_ary_entry(data, 1));
-  VALUE p0, p1, p2, p3;
+    source_width = NUM2UINT(rb_funcall(self, rb_intern("width"), 0, NULL));
+    source_height = NUM2UINT(rb_funcall(self, rb_intern("height"), 0, NULL));
 
-  p0 = NUM2UINT(rb_ary_entry(data, 2));
-  p1 = NUM2UINT(rb_ary_entry(data, 3));
-  p2 = NUM2UINT(rb_ary_entry(data, 4));
-  p3 = NUM2UINT(rb_ary_entry(data, 5));
+    c_dst_dimension_x = NUM2UINT(dst_dimension_x);
+    c_dst_dimension_y = NUM2UINT(dst_dimension_y);
 
-  return raw_interpolate_cubic(self, t, p0, p1, p2, p3);
+    w_m = source_width / c_dst_dimension_x;
+    h_m = source_height / c_dst_dimension_y;
+
+    if (w_m == 0) {
+      w_m = 1;
+    };
+
+    if (h_m == 0) {
+      h_m = 1;
+    };
+
+    source = get_c_array(self);
+
+    destination = get_bicubic_points(source, source_width, source_height, c_dst_dimension_x * w_m, c_dst_dimension_y * h_m);
+
+    if (w_m * h_m > 1) {
+      source = destination;
+      destination = c_scale_points(source, c_dst_dimension_x, c_dst_dimension_y, w_m, h_m);
+    }
+
+    result_array = get_ruby_array(self, destination, c_dst_dimension_x * c_dst_dimension_y);
+    free(destination);
+    return result_array;
 };
 
-VALUE raw_interpolate_cubic(VALUE self, double t, VALUE p0, VALUE p1, VALUE p2, VALUE p3) {
+VALUE get_ruby_array(VALUE self, PIXEL *pixels, unsigned long int pixels_size) {
+    VALUE result_array;
+    unsigned long int i;
+    result_array = rb_ary_new2(pixels_size);
+    for (i=0; i<pixels_size; i++) {
+      rb_ary_store(result_array, i, UINT2NUM(pixels[i]));
+    };
+    return result_array;
+}
+
+PIXEL* get_c_array(VALUE self) {
+  unsigned long int w,h,i;
+  PIXEL* ary;
+  VALUE pixels;
+
+  pixels = rb_funcall(self, rb_intern("pixels"), 0, NULL);
+  w = NUM2UINT(rb_funcall(self, rb_intern("width"), 0, NULL));
+  h = NUM2UINT(rb_funcall(self, rb_intern("height"), 0, NULL));
+  ary = (PIXEL*)malloc( w*h*sizeof(PIXEL));
+
+  for(i=0; i<w*h; i++) {
+    ary[i] = NUM2UINT(rb_ary_entry(pixels, i));
+  }
+
+  return ary;
+}
+
+PIXEL raw_interpolate_cubic(double t, PIXEL p0, PIXEL p1, PIXEL p2, PIXEL p3) {
   BYTE  new_r, new_g, new_b, new_a;
 
   new_r = interpolate_char(t, R_BYTE(p0), R_BYTE(p1), R_BYTE(p2), R_BYTE(p3));
@@ -30,7 +77,7 @@ VALUE raw_interpolate_cubic(VALUE self, double t, VALUE p0, VALUE p1, VALUE p2,
   new_b = interpolate_char(t, B_BYTE(p0), B_BYTE(p1), B_BYTE(p2), B_BYTE(p3));
   new_a = interpolate_char(t, A_BYTE(p0), A_BYTE(p1), A_BYTE(p2), A_BYTE(p3));
 
-  return UINT2NUM(BUILD_PIXEL(new_r, new_g, new_b, new_a));
+  return BUILD_PIXEL(new_r, new_g, new_b, new_a);
 }
 
 BYTE interpolate_char(double t, BYTE c0, BYTE c1, BYTE c2, BYTE c3) {
@@ -48,45 +95,7 @@ BYTE interpolate_char(double t, BYTE c0, BYTE c1, BYTE c2, BYTE c3) {
   return (BYTE)(res);
 };
 
-VALUE c_merge_pixels(VALUE self, VALUE pixels) {
-  unsigned int i, size, real_colors, acum_r, acum_g, acum_b, acum_a;
-  BYTE new_r, new_g, new_b, new_a;
-  PIXEL pix;
-
-  acum_r = 0;
-  acum_g = 0;
-  acum_b = 0;
-  acum_a = 0;
-
-  new_r = 0;
-  new_g = 0;
-  new_b = 0;
-  new_a = 0;
-
-  size = NUM2UINT(rb_funcall(pixels, rb_intern("size"), 0, Qnil)) - 1;
-  real_colors = 0;
-
-  for(i=1; i < size; i++) {
-    pix = NUM2UINT(rb_ary_entry(pixels, i));
-    if(A_BYTE(pix) != 0) {
-      acum_r += R_BYTE(pix);
-      acum_g += G_BYTE(pix);
-      acum_b += B_BYTE(pix);
-      acum_a += A_BYTE(pix);
-      real_colors += 1;
-    }
-  }
-
-  if(real_colors > 0) {
-    new_r = (BYTE)(acum_r/real_colors + 0.5);
-    new_g = (BYTE)(acum_g/real_colors + 0.5);
-    new_b = (BYTE)(acum_b/real_colors + 0.5);
-  }
-  new_a = (BYTE)(acum_a/(size - 1) + 0.5);
-  return UINT2NUM(BUILD_PIXEL(new_r, new_g, new_b, new_a));
-}
-
-VALUE raw_merge_pixels(VALUE merge_pixels[], unsigned int size) {
+PIXEL raw_merge_pixels(PIXEL* merge_pixels, unsigned int size) {
   unsigned int i, real_colors, acum_r, acum_g, acum_b, acum_a;
   BYTE new_r, new_g, new_b, new_a;
   PIXEL pix;
@@ -104,103 +113,140 @@ VALUE raw_merge_pixels(VALUE merge_pixels[], unsigned int size) {
   real_colors = 0;
 
   for(i=0; i < size; i++) {
-    pix = NUM2UINT(merge_pixels[i]);
+    pix = merge_pixels[i];
     if(A_BYTE(pix) != 0) {
       acum_r += R_BYTE(pix);
       acum_g += G_BYTE(pix);
       acum_b += B_BYTE(pix);
       acum_a += A_BYTE(pix);
       real_colors += 1;
-    }
-  }
+    };
+  };
 
   if(real_colors > 0) {
-    new_r = (BYTE)(acum_r/real_colors + 0.5);
-    new_g = (BYTE)(acum_g/real_colors + 0.5);
-    new_b = (BYTE)(acum_b/real_colors + 0.5);
-  }
-  new_a = (BYTE)(acum_a/(size - 1) + 0.5);
-  return UINT2NUM(BUILD_PIXEL(new_r, new_g, new_b, new_a));
-}
-
-VALUE c_bicubic_points(VALUE self, VALUE src_dimension, VALUE dst_dimension, VALUE direction) {
-  unsigned long y_bounds, pixels_size, c_src_dimension, c_dst_dimension, index, index_y, i, y, x;
-  double step;
-  VALUE result_array;
+    new_r = (BYTE)(acum_r/real_colors);
+    new_g = (BYTE)(acum_g/real_colors);
+    new_b = (BYTE)(acum_b/real_colors);
+  };
+  new_a = (BYTE)(acum_a/size);
+  return BUILD_PIXEL(new_r, new_g, new_b, new_a);
+};
 
-  unsigned long steps [NUM2UINT(dst_dimension)];
-  double residues [NUM2UINT(dst_dimension)];
-  VALUE line_bounds;
+void setup_steps_residues(unsigned long int *steps, double *residues,
+  unsigned long int src_dimension, unsigned long int dst_dimension) {
+  unsigned long int i;
+  double step = (double) (src_dimension - 1) / (dst_dimension - 1);
+  for(i = 0; i < dst_dimension - 1; i++) {
+    steps[i] = (unsigned long int) i*step;
+    residues[i]  = i*step - steps[i];
+  };
 
-  c_src_dimension = NUM2UINT(src_dimension);
-  c_dst_dimension = NUM2UINT(dst_dimension);
-  
-  step = (double)(c_src_dimension - 1) / c_dst_dimension;
+  steps[dst_dimension - 1] = src_dimension - 2;
+  residues[dst_dimension - 1] = 1;
+};
 
-  if (RTEST(direction)) {
-    y_bounds = NUM2UINT(rb_funcall(self, rb_intern("width"), 0, NULL));
+PIXEL get_line_pixel(PIXEL* source, unsigned long int line, long int pixel,
+  unsigned long int src_dimension_x) {
+  if(pixel >= 0 && pixel < (long int)src_dimension_x) {
+    return source[line * src_dimension_x + pixel];
   } else {
-    y_bounds = NUM2UINT(rb_funcall(self, rb_intern("height"), 0, NULL));
+    return 0;
   };
+};
 
-  pixels_size = y_bounds * c_dst_dimension;
-  result_array = rb_ary_new2(pixels_size);
+PIXEL get_column_pixel(PIXEL* source,
+  unsigned long int column, long int pixel,
+  unsigned long int src_dimension_y, unsigned long int src_dimension_x) {
 
-  for (i = 0; i < c_dst_dimension; i++) {
-    steps[i] = (unsigned long)i*step;
-    residues[i] = i*step - steps[i];
+  if(pixel >=0 && pixel < (long int)src_dimension_y) {
+    return source[src_dimension_x * pixel + column];
+  } else {
+    return 0;
   };
+};
 
-  for (y = 0; y < y_bounds; y++) {
-    line_bounds = rb_funcall(self, rb_intern("line_with_bounds"), 3, UINT2NUM(y), src_dimension, direction);
-
-    index_y = c_dst_dimension * y;
-    for (x = 0; x < c_dst_dimension; x++) {
-      if (RTEST(direction)) {
-        index = y_bounds * x + y;
-      } else {
-        index = index_y + x;
-      }
-      rb_ary_store(result_array, index, raw_interpolate_cubic(self, residues[x],
-        NUM2UINT(rb_ary_entry(line_bounds, steps[x])),
-        NUM2UINT(rb_ary_entry(line_bounds, steps[x] + 1)),
-        NUM2UINT(rb_ary_entry(line_bounds, steps[x] + 2)),
-        NUM2UINT(rb_ary_entry(line_bounds, steps[x] + 3)))
+PIXEL* get_bicubic_points(PIXEL* source_array,
+  unsigned long int src_dimension_x, unsigned long int src_dimension_y,
+  unsigned long int dst_dimension_x, unsigned long int dst_dimension_y) {
+  PIXEL* dest, *source;
+  unsigned long int index_y, index, y, x;
+  unsigned long int* steps;
+  double* residues;
+
+  steps = (unsigned long int*) malloc(dst_dimension_x * sizeof(unsigned long int));
+  residues = (double*) malloc(dst_dimension_x * sizeof(double));
+  setup_steps_residues(steps, residues, src_dimension_x, dst_dimension_x);
+
+  source = source_array;
+  dest = (PIXEL*)malloc( src_dimension_y*dst_dimension_x*sizeof(PIXEL) );
+
+  for (y=0; y < src_dimension_y; y++) {
+    index_y = dst_dimension_x * y;
+    for (x=0; x < dst_dimension_x; x++) {
+      index = index_y + x;
+      dest[index] = raw_interpolate_cubic(residues[x],
+        get_line_pixel(source, y, steps[x] - 1, src_dimension_x),
+        get_line_pixel(source, y, steps[x], src_dimension_x),
+        get_line_pixel(source, y, steps[x] + 1, src_dimension_x),
+        get_line_pixel(source, y, steps[x] + 2, src_dimension_x)
       );
-    }
-  }
+    };
+  };
 
-  return result_array;
-}
+  steps = realloc(steps, dst_dimension_y * sizeof(unsigned long int));
+  residues = realloc(residues, dst_dimension_y * sizeof(double));
+  setup_steps_residues(steps, residues, src_dimension_y, dst_dimension_y);
+
+  free(source);
+  source = dest;
+  dest = (PIXEL*)malloc( dst_dimension_x * dst_dimension_y * sizeof(PIXEL));
+
+  for (y=0; y < dst_dimension_x; y++) {
+    for (x=0; x < dst_dimension_y; x++) {
+      index = dst_dimension_x * x + y;
+      dest[index] = raw_interpolate_cubic(residues[x],
+        get_column_pixel(source, y, steps[x] - 1, src_dimension_y, dst_dimension_x),
+        get_column_pixel(source, y, steps[x], src_dimension_y, dst_dimension_x),
+        get_column_pixel(source, y, steps[x] + 1, src_dimension_y, dst_dimension_x),
+        get_column_pixel(source, y, steps[x] + 2, src_dimension_y, dst_dimension_x)
+      );
+    };
+  };
+
+  free(source);
+  free(steps);
+  free(residues);
+
+  return dest;
+};
 
-VALUE scale_points2(VALUE self, VALUE dst_width, VALUE dst_height, VALUE w_m, VALUE h_m) {
-  unsigned long c_dst_height, c_dst_width, y_pos, x_pos, index, i, j;
-  unsigned int c_w_m, c_h_m, buffer_index, buffer_size, x, y;
-  VALUE pixels_to_merge [NUM2UINT(w_m) * NUM2UINT(h_m)];
-  VALUE result;
+PIXEL* c_scale_points(PIXEL* source, unsigned long int dst_width, unsigned long int dst_height,
+  unsigned long int w_m, unsigned long int h_m) {
 
-  c_dst_height = NUM2UINT(dst_height);
-  c_dst_width = NUM2UINT(dst_width);
+  unsigned long int y_pos, x_pos, index, i, j, x, y, buffer_size, buffer_index;
+  PIXEL* pixels_to_merge;
+  PIXEL* result;
 
-  c_w_m = NUM2UINT(w_m);
-  c_h_m = NUM2UINT(h_m);
+  pixels_to_merge = malloc(w_m*h_m*sizeof(PIXEL));
+  result = malloc(dst_width * dst_height * sizeof(PIXEL));
 
-  result = rb_ary_new2(c_dst_width * c_dst_height);
-  buffer_size = c_h_m * c_w_m;
+  buffer_size = h_m * w_m;
 
-  for (i = 0; i < c_dst_height; i++) {
-    for (j = 0; j < c_dst_width; j++) {
+  for (i = 0; i < dst_height; i++) {
+    for (j = 0; j < dst_width; j++) {
       buffer_index = 0;
-      for (y = 0; y < c_h_m; y++) {
-        y_pos = i * c_h_m + y;
-        for (x = 0; x < c_w_m; x++) {
-          x_pos = j * c_w_m + x;
-          pixels_to_merge[buffer_index++] = rb_funcall(self, rb_intern("get_pixel"), 2, UINT2NUM(x_pos), UINT2NUM(y_pos));
-        }
-      }
-      index = i * c_dst_width + j;
-      rb_ary_store(result, index, raw_merge_pixels(pixels_to_merge, buffer_size));
-    }
-  }
+      for (y = 0; y < h_m; y++) {
+        y_pos = i * h_m + y;
+        for (x = 0; x < w_m; x++) {
+          x_pos = j * w_m + x;
+          pixels_to_merge[buffer_index++] = source[dst_width * w_m * y_pos + x_pos];
+        };
+      };
+      index = i * dst_width + j;
+      result[index] = raw_merge_pixels(pixels_to_merge, buffer_size);
+
+    };
+  };
+  free(source);
   return result;
-}
+};

data/ext/eyes_core/eyes_core.h

@@ -17,12 +17,17 @@ typedef unsigned char BYTE; // Bytes use 8 bits unsigned integers
 
 void Init_resampling();
 
-VALUE c_interpolate_cubic(VALUE,VALUE);
-VALUE raw_interpolate_cubic(VALUE, double, VALUE, VALUE, VALUE, VALUE);
-VALUE scale_points2(VALUE, VALUE, VALUE, VALUE, VALUE);
-VALUE c_merge_pixels(VALUE, VALUE);
-VALUE raw_merge_pixels(VALUE[], unsigned int);
-VALUE c_bicubic_points(VALUE, VALUE, VALUE, VALUE);
+
 BYTE interpolate_char(double, BYTE, BYTE, BYTE, BYTE);
 
+PIXEL* get_bicubic_points(PIXEL*, unsigned long int, unsigned long int, unsigned long int, unsigned long int);
+
+PIXEL* get_c_array(VALUE);
+VALUE c_resampling_first_step(VALUE, VALUE, VALUE);
+VALUE get_ruby_array(VALUE, PIXEL*, unsigned long int);
+PIXEL get_line_pixel(PIXEL*, unsigned long int, long int, unsigned long int);
+PIXEL get_column_pixel(PIXEL*, unsigned long int, long int, unsigned long int, unsigned long int);
+PIXEL raw_merge_pixels(PIXEL*, unsigned int);
+PIXEL* c_scale_points(PIXEL*, unsigned long int, unsigned long int, unsigned long int, unsigned long int);
+
 #endif

data/lib/applitools/chunky_png/resampling.rb

@@ -13,22 +13,9 @@ end
 module Applitools::ChunkyPNG
   module Resampling
     def resample_bicubic!(dst_width, dst_height)
-      w_m = [1, width / dst_width].max
-      h_m = [1, height / dst_height].max
-
-      dst_width2 = dst_width * w_m
-      dst_height2 = dst_height * h_m
-
-      pixels = bicubic_x_points(dst_width2)
-      replace_canvas!(dst_width2, height, pixels)
-
-      pixels = bicubic_y_points(dst_height2)
-      replace_canvas!(dst_width2, dst_height2, pixels)
-
-      return self unless w_m * h_m > 1
-
-      pixels = scale_points2(dst_width, dst_height, w_m, h_m)
-      replace_canvas!(dst_width, dst_height, pixels)
+      new_pixels = resampling_first_step(dst_width, dst_height)
+      replace_canvas!(dst_width, dst_height, new_pixels)
+      self
     end
 
     def resample_bicubic(new_width, new_height)

data/lib/applitools/version.rb

@@ -1,3 +1,3 @@
 module Applitools
-  VERSION = '3.1.1'.freeze
+  VERSION = '3.2.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_core
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.1
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-05 00:00:00.000000000 Z
+date: 2017-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oily_png