ruby-libgd 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0a3de385842f0cf17fc56e102fc0dd9614512227bf9a07dc8b8cd96929dd2a4
-  data.tar.gz: 3b47534f1017febc504cb328c1d1db1b2fa7f58f5e15047504abff2e119d347b
+  metadata.gz: 310bd931469060390ec5d475ce151934d42afb9e51e3d9ddaa59075c8a4f88db
+  data.tar.gz: 4d5dcef0cb4eb3556f4aa88733fd541539b49e489b4820469425270662b06b4c
 SHA512:
-  metadata.gz: de84a2dc1be0454faea9fad0105cf7bda0e4a0684ed90ff62bf91e914e246afcd0ce21b666793b86d198e335324464a31b173b3e7d589d6d01ff8b73c76eee02
-  data.tar.gz: 2c699498111605b390e3b9c25f9f5a157e806612094fdee1aa0e2ffaf858bb7fecfe0c45e8d3a651f7ea8e7ae2c777f016623c38fa4742c5a9b236351623a669
+  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);
   }
@@ -84,6 +123,181 @@ static VALUE gd_image_filter(int argc, VALUE *argv, VALUE self) {
   else if (strcmp(name, "sepia") == 0) {
     gd_image_apply_sepia(wrap->img);
   }
+  else if (strcmp(name, "convolve") == 0) {
+
+    Check_Type(arg1, T_ARRAY);
+    if (RARRAY_LEN(arg1) != 3) {
+      rb_raise(rb_eArgError, "kernel must be a 3x3 array");
+    }
+
+    float filter[3][3];
+
+    for (int i = 0; i < 3; i++) {
+      VALUE row = rb_ary_entry(arg1, i);
+      Check_Type(row, T_ARRAY);
+
+      if (RARRAY_LEN(row) != 3) {
+        rb_raise(rb_eArgError, "kernel must be a 3x3 array");
+      }
+
+      for (int j = 0; j < 3; j++) {
+        filter[i][j] = (float)NUM2DBL(rb_ary_entry(row, j));
+      }
+    }
+
+    float divisor = NIL_P(arg2) ? 1.0f : (float)NUM2DBL(arg2);
+    float offset  = NIL_P(arg3) ? 0.0f : (float)NUM2DBL(arg3);
+
+    if (!gdImageConvolution(wrap->img, filter, divisor, offset)) {
+      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.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Germán Alberto Giménez Silva
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Native Ruby bindings for libgd
 test_files: []