ruby-libgd 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7aa6764204d6e185d6ba8ba4ed606c5f2a13e9cff220cec8557cc12a99b6ce2
-  data.tar.gz: 73916e75296f31ef431b34c22124aef6b293985b2a27d670fcb1073f03bf5bad
+  metadata.gz: 310bd931469060390ec5d475ce151934d42afb9e51e3d9ddaa59075c8a4f88db
+  data.tar.gz: 4d5dcef0cb4eb3556f4aa88733fd541539b49e489b4820469425270662b06b4c
 SHA512:
-  metadata.gz: 7f34d5a36d7c1db0daa1770f7406006a17a4bdcf0e778b172581c6f0a9863c62d510fef76535310358a39a57d74e5f2cffff3cbfea3e46b66844832db230b307
-  data.tar.gz: e1409b46676c61e39970bfd3f8a5ef773bce0c9dcae07f15ce6a255f609d97a0e6ee29f03036f10f0b50949aa02e94e397e2b5a9bab30140410ad26a85dd0252
+  metadata.gz: c3bb2ad496f6764c13c00d25f0e4d30b8b388915f45d16421ae85982148bd2ab0ee6e3abd5e5eba16e155fbeb2d1cd74e71fa509a733b49543f8ba0702a1eea8
+  data.tar.gz: 1cabca6431ea0b7db31f0341ff63e68420c70b137a3b902b09f7b0bcf86a98d9ce71c3e7e4de67a85d07af47d2c1213e688665333657bc30b0d1ab5c64a55345

data/ext/gd/filter.c

@@ -1,6 +1,48 @@
 #include "ruby_gd.h"
 #include <string.h>
 
+static float kernel_sobel[3][3] = {
+  {-1,0,1},
+  {-2,0,2},
+  {-1,0,1}
+};
+
+static float kernel_sharpen[3][3] = {
+  {0,-1,0},
+  {-1,5,-1},
+  {0,-1,0}
+};
+
+static float kernel_edge[3][3] = {
+  {-1,-1,-1},
+  {-1,8,-1},
+  {-1,-1,-1}
+};
+
+static float kernel_box_blur[3][3] = {
+  {1,1,1},
+  {1,1,1},
+  {1,1,1}
+};
+
+static float kernel_gaussian[3][3] = {
+  {1,2,1},
+  {2,4,2},
+  {1,2,1}
+};
+
+static float kernel_emboss2[3][3] = {
+  {-2,-1,0},
+  {-1,1,1},
+  {0,1,2}
+};
+
+static float kernel_laplacian[3][3] = {
+  {0,-1,0},
+  {-1,4,-1},
+  {0,-1,0}
+};
+
 static void gd_image_apply_sepia(gdImagePtr img) {
   int x, y;
   for (y = 0; y < img->sy; y++) {
@@ -46,9 +88,6 @@ static VALUE gd_image_filter(int argc, VALUE *argv, VALUE self) {
   else if (strcmp(name, "contrast") == 0) {
     gdImageContrast(wrap->img, NUM2INT(arg1));
   }
-  else if (strcmp(name, "colorize") == 0) {
-    rb_raise(rb_eNotImpError, "colorize not supported by libgd");
-  }
   else if (strcmp(name, "edge_detect") == 0) {
     gdImageEdgeDetectQuick(wrap->img);
   }
@@ -113,6 +152,152 @@ static VALUE gd_image_filter(int argc, VALUE *argv, VALUE self) {
       rb_raise(rb_eRuntimeError, "convolution failed");
     }
   }
+  else if (strcmp(name, "contrast") == 0) {
+    /* libgd: double contrast */
+    gdImageContrast(wrap->img, NUM2DBL(arg1));
+  }
+  else if (strcmp(name, "colorize") == 0) {
+    /* libgd calls this "gdImageColor": add to channels */
+    /* Ruby: img.filter(:colorize, r, g, b [, a]) */
+    if (NIL_P(arg1) || NIL_P(arg2) || NIL_P(arg3)) {
+      rb_raise(rb_eArgError, "colorize requires r, g, b (and optional alpha)");
+    }
+    int r = NUM2INT(arg1);
+    int g = NUM2INT(arg2);
+    int b = NUM2INT(arg3);
+    int a = NIL_P(arg4) ? 0 : NUM2INT(arg4);
+
+    if (!gdImageColor(wrap->img, r, g, b, a)) {
+      rb_raise(rb_eRuntimeError, "colorize failed");
+    }
+  }
+  else if (strcmp(name, "smooth") == 0) {
+    /* libgd: float weight */
+    gdImageSmooth(wrap->img, (float)NUM2DBL(arg1));
+  }
+  else if (strcmp(name, "scatter_color") == 0) {
+    /* Ruby: img.filter(:scatter_color, sub, plus, [colors...]) */
+    if (NIL_P(arg1) || NIL_P(arg2) || NIL_P(arg3)) {
+      rb_raise(rb_eArgError, "scatter_color requires sub, plus, colors_array");
+    }
+
+    Check_Type(arg3, T_ARRAY);
+    long n = RARRAY_LEN(arg3);
+    if (n <= 0) {
+      rb_raise(rb_eArgError, "colors_array must not be empty");
+    }
+
+    int *colors = ALLOC_N(int, n);
+    for (long i = 0; i < n; i++) {
+      colors[i] = NUM2INT(rb_ary_entry(arg3, i));
+    }
+
+    int ok = gdImageScatterColor(
+      wrap->img,
+      NUM2INT(arg1),
+      NUM2INT(arg2),
+      colors,
+      (unsigned int)n
+    );
+    xfree(colors);
+
+    if (!ok) {
+      rb_raise(rb_eRuntimeError, "scatter_color failed");
+    }
+  }
+  else if (strcmp(name, "scatter_ex") == 0) {
+    /*
+      Ruby: img.filter(:scatter_ex, opts)
+      opts is a Hash:
+        { sub: 2, plus: 5, seed: 123, colors: [ ... ] }
+      colors is optional
+      seed is optional
+    */
+    if (NIL_P(arg1) || TYPE(arg1) != T_HASH) {
+      rb_raise(rb_eArgError, "scatter_ex requires a hash: {sub:, plus:, seed:, colors:}");
+    }
+
+    VALUE v_sub    = rb_hash_aref(arg1, ID2SYM(rb_intern("sub")));
+    VALUE v_plus   = rb_hash_aref(arg1, ID2SYM(rb_intern("plus")));
+    VALUE v_seed   = rb_hash_aref(arg1, ID2SYM(rb_intern("seed")));
+    VALUE v_colors = rb_hash_aref(arg1, ID2SYM(rb_intern("colors")));
+
+    if (NIL_P(v_sub) || NIL_P(v_plus)) {
+      rb_raise(rb_eArgError, "scatter_ex hash must include :sub and :plus");
+    }
+
+    gdScatter s;
+    memset(&s, 0, sizeof(gdScatter));
+
+    s.sub  = NUM2INT(v_sub);
+    s.plus = NUM2INT(v_plus);
+    s.seed = NIL_P(v_seed) ? 0 : (unsigned int)NUM2UINT(v_seed);
+
+    int *colors = NULL;
+    unsigned int num_colors = 0;
+
+    if (!NIL_P(v_colors)) {
+      Check_Type(v_colors, T_ARRAY);
+      long n = RARRAY_LEN(v_colors);
+      if (n > 0) {
+        colors = ALLOC_N(int, n);
+        for (long i = 0; i < n; i++) {
+          colors[i] = NUM2INT(rb_ary_entry(v_colors, i));
+        }
+        num_colors = (unsigned int)n;
+      }
+    }
+
+    s.num_colors = num_colors;
+    s.colors     = colors;
+
+    int ok = gdImageScatterEx(wrap->img, &s);
+
+    if (colors) xfree(colors);
+
+    if (!ok) {
+      rb_raise(rb_eRuntimeError, "scatter_ex failed");
+    }
+  }
+  else if (strcmp(name, "sobel") == 0) {
+    if (!gdImageConvolution(wrap->img, kernel_sobel, 1.0, 0.0)) {
+      rb_raise(rb_eRuntimeError, "sobel convolution failed");
+    }
+  }
+  else if (strcmp(name, "sharpen") == 0) {
+    if (!gdImageConvolution(wrap->img, kernel_sharpen, 1.0, 0.0)) {
+      rb_raise(rb_eRuntimeError, "sharpen convolution failed");
+    }
+  }
+  else if (strcmp(name, "edge") == 0) {
+    if (!gdImageConvolution(wrap->img, kernel_edge, 1.0, 0.0)) {
+      rb_raise(rb_eRuntimeError, "edge convolution failed");
+    }
+  }
+  else if (strcmp(name, "box_blur") == 0) {
+
+    if (!gdImageConvolution(wrap->img, kernel_box_blur, 9.0, 0.0)) {
+      rb_raise(rb_eRuntimeError, "box_blur convolution failed");
+    }
+
+  }
+  else if (strcmp(name, "gaussian_kernel") == 0) {
+
+    if (!gdImageConvolution(wrap->img, kernel_gaussian, 16.0, 0.0)) {
+      rb_raise(rb_eRuntimeError, "gaussian_kernel convolution failed");
+    }
+
+  }
+  else if (strcmp(name, "emboss2") == 0) {
+    if (!gdImageConvolution(wrap->img, kernel_emboss2, 1.0, 128.0)) {
+      rb_raise(rb_eRuntimeError, "emboss2 convolution failed");
+    }
+  }
+  else if (strcmp(name, "laplacian") == 0) {
+    if (!gdImageConvolution(wrap->img, kernel_laplacian, 1.0, 0.0)) {
+      rb_raise(rb_eRuntimeError, "laplacian convolution failed");
+    }
+  }
   else {
     rb_raise(rb_eArgError, "unknown filter");
   }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-libgd
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Germán Alberto Giménez Silva