gmagick 0.0.1

data/ext/gmagick/gmimage.c

@@ -0,0 +1,346 @@
+#include "gmagick.h"
+
+void 
+gmi_free(GmImage *ptr)
+{
+  if (ptr != (GmImage *)NULL) {
+    if (ptr->wand != (MagickWand *)NULL) {
+      DestroyMagickWand(ptr->wand);
+    }
+    ruby_xfree(ptr);
+  }
+}
+
+VALUE 
+gmi_alloc(VALUE klass) {
+  GmImage *ptr = ALLOC(GmImage);
+  ptr->wand = (MagickWand *)NULL;
+  return Data_Wrap_Struct(klass, 0, gmi_free, ptr);
+}
+
+/*
+ * Document-method: new
+ *
+ * call-seq:
+ *   Gmagick::Image.new -> image
+ *   Gmagick::Image.new(path) -> image
+ *
+ * Create a GraphicsMagick Object
+ *
+ * [+path+]
+ *   image file path
+ *
+ * Examples:
+ *
+ *   # Make image object
+ *   Gmagick::Image.new
+ *
+ *   # Make image object with path
+ *   Gmagick::Image.new(path)
+ *
+ */
+VALUE
+gmi_initialize(int argc, VALUE *argv, VALUE self) {
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc);
+  }
+  volatile GmImage *gmImage;
+  Data_Get_Struct(self, GmImage, gmImage);
+  gmImage->wand = NewMagickWand();
+  if (argc > 0) {
+    gmi_read_image(self, argv[0]);
+  }
+  return Qnil;
+}
+
+VALUE 
+gmi_read_image(VALUE self, VALUE path_arg) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  char *path = StringValuePtr(path_arg);
+  if (NULL == wand) {
+    puts("null");
+  }
+  MagickPassFail status = MagickReadImage(wand, path);
+  gum_check_image_exception(wand, status);
+  MagickSetImageFilename(wand, path);
+  return Qnil;
+}
+
+VALUE 
+gmi_write_image(int argc, VALUE *argv, VALUE self) {
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc);
+  }
+  MagickWand *wand = gmu_get_image_wand(self);
+  char* path;
+  if (argc > 0) {
+    path = StringValuePtr(argv[0]);
+  } else {
+    path = MagickGetImageFilename(wand);
+    if (NULL == path) {
+      rb_raise(rb_eRuntimeError, "filename never setted");
+    }
+  }
+  MagickPassFail status = MagickWriteImage(wand, path);
+  gum_check_image_exception(wand, status);
+  return Qnil;
+}
+
+VALUE 
+gmi_get_width(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  return LONG2NUM(MagickGetImageWidth(wand));
+}
+
+VALUE 
+gmi_get_height(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  return LONG2NUM(MagickGetImageHeight(wand));
+}
+
+VALUE 
+gmi_get_format(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  return rb_str_new2(MagickGetImageFormat(wand));
+}
+
+VALUE 
+gmi_get_depth(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  return LONG2NUM(MagickGetImageDepth(wand));
+}
+
+VALUE 
+gmi_get_colors(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  return LONG2NUM(MagickGetImageColors(wand));
+}
+
+VALUE 
+gmi_get_resolution(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  double x;
+  double y;
+  MagickPassFail status = MagickGetImageResolution(wand, &x, &y);
+  gum_check_image_exception(wand, status);
+  VALUE ary = rb_ary_new2(2);
+  rb_ary_push(ary, DBL2NUM(x));
+  rb_ary_push(ary, DBL2NUM(y));
+  return ary;
+}
+
+VALUE
+gmi_get_number_images(VALUE self) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  return LONG2NUM(MagickGetNumberImages(wand));
+}
+
+VALUE 
+gmi_read_image_blob(VALUE self, VALUE blob_arg) {
+  MagickWand *wand = gmu_get_image_wand(self);
+  unsigned char *blob;
+  long length;
+  Image* image;
+
+  blob = (unsigned char *)gmu_str2cstr(blob_arg, &length);
+  MagickPassFail status = MagickReadImageBlob(wand, blob, length);
+  gum_check_image_exception(wand, status);
+  return Qnil;
+}
+
+VALUE
+gmi_write_image_blob(VALUE self) {
+  MagickWand *image = gmu_get_image_wand(self);
+  unsigned char *blob;
+  size_t length;
+  VALUE result;
+
+  blob = MagickWriteImageBlob(image, &length);
+  result = rb_str_new((char *)blob, (long)length);
+  MagickRelinquishMemory(blob);
+  return result;
+}
+
+VALUE 
+gmi_resize(int argc, VALUE *argv, VALUE self) {
+  if (argc < 2 || argc > 4) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 4)", argc);
+  }
+  long width = NUM2LONG(argv[0]);
+  long height = NUM2LONG(argv[1]);
+  int filter = argc > 2 ? NUM2INT(argv[2]) : 0;
+  double blur = argc > 3 ? NUM2DBL(argv[3]) : 1.0;
+
+  MagickWand *image = gmu_get_image_wand(self);
+  MagickPassFail status = MagickResizeImage(image, width, height, filter, blur);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_rotate(VALUE self, VALUE pixel_arg, VALUE degree_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  PixelWand *pixel = gmu_get_pixel_string_or_pixel(pixel_arg);
+  double degree = NUM2DBL(degree_arg);
+  MagickPassFail status = MagickRotateImage(image, pixel, degree);
+  gmu_clear_pixel_string_or_pixel(pixel_arg, pixel);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE 
+gmi_draw(VALUE self, VALUE drawing_arg)
+{
+  MagickWand *image = gmu_get_image_wand(self);
+  DrawingWand *drawing =  gmu_get_drawing_wand(drawing_arg);
+  MagickPassFail status = MagickDrawImage(image, drawing);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE 
+gmi_resample(int argc, VALUE *argv, VALUE self) {
+  if (argc < 2 || argc > 4) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 4)", argc);
+  }
+  long x = NUM2LONG(argv[0]);
+  long y = NUM2LONG(argv[1]);
+  int filter = argc > 2 ? NUM2INT(argv[2]) : 0;
+  double blur = argc > 3 ? NUM2DBL(argv[3]) : 1.0;
+
+  MagickWand *image = gmu_get_image_wand(self);
+  MagickPassFail status = MagickResampleImage(image, x, y, filter, blur);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE 
+gmi_flip(VALUE self) {
+  MagickWand *image = gmu_get_image_wand(self);
+  MagickPassFail status = MagickFlipImage(image);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE 
+gmi_flop(VALUE self) {
+  MagickWand *image = gmu_get_image_wand(self);
+  MagickPassFail status = MagickFlopImage(image);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_crop(VALUE self, VALUE width_arg, VALUE height_arg, VALUE x_arg, VALUE y_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  unsigned long width = NUM2LONG(width_arg);
+  unsigned long height = NUM2LONG(height_arg);
+  long x = NUM2LONG(x_arg);
+  long y = NUM2LONG(y_arg);
+  MagickPassFail status = MagickCropImage(image, width, height, x, y);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_set_format(VALUE self, VALUE format_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  char *format = StringValuePtr(format_arg);
+  MagickPassFail status = MagickSetImageFormat(image, format);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE 
+gmi_border(VALUE self, VALUE pixel_arg, VALUE width_arg, VALUE height_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  PixelWand *pixel = gmu_get_pixel_string_or_pixel(pixel_arg);
+  unsigned long width = NUM2LONG(width_arg);
+  unsigned long height = NUM2LONG(height_arg);
+  MagickPassFail status = MagickBorderImage(image, pixel, width, height);
+  gmu_clear_pixel_string_or_pixel(pixel_arg, pixel);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_frame(VALUE self, VALUE pixel_arg, VALUE width_arg, VALUE height_arg, VALUE inner_arg, VALUE outer_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  PixelWand *pixel = gmu_get_pixel_string_or_pixel(pixel_arg);
+  unsigned long width = NUM2LONG(width_arg);
+  unsigned long height = NUM2LONG(height_arg);
+  long inner = NUM2LONG(inner_arg);
+  long outer = NUM2LONG(outer_arg);
+  MagickPassFail status = MagickFrameImage(image, pixel, width, height, inner, outer);
+  gmu_clear_pixel_string_or_pixel(pixel_arg, pixel);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_blur(VALUE self, VALUE radius_arg, VALUE sigma_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  double radius = NUM2DBL(radius_arg);
+  double sigma = NUM2DBL(sigma_arg);
+  MagickPassFail status = MagickBlurImage(image, radius, sigma);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_swirl(VALUE self, VALUE degree_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  double degree = NUM2DBL(degree_arg);
+  MagickPassFail status = MagickSwirlImage(image, degree);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_charcoal(VALUE self, VALUE radius_arg, VALUE sigma_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  double radius = NUM2DBL(radius_arg);
+  double sigma = NUM2DBL(sigma_arg);
+  MagickPassFail status = MagickCharcoalImage(image, radius, sigma);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_oil_paint(VALUE self, VALUE radius_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  double radius = NUM2DBL(radius_arg);
+  MagickPassFail status = MagickOilPaintImage(image, radius);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_cycle_colormap(VALUE self, VALUE displace_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  long displace = NUM2LONG(displace_arg);
+  MagickPassFail status = MagickCycleColormapImage(image, displace);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_solarize(VALUE self, VALUE threshold_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  double threshold = NUM2DBL(threshold_arg);
+  MagickPassFail status = MagickSolarizeImage(image, threshold);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}
+
+VALUE
+gmi_shear(VALUE self, VALUE pixel_arg, VALUE x_arg, VALUE y_arg) {
+  MagickWand *image = gmu_get_image_wand(self);
+  PixelWand *pixel = gmu_get_pixel_string_or_pixel(pixel_arg);
+  double x = NUM2DBL(x_arg);
+  double y = NUM2DBL(y_arg);
+  MagickPassFail status = MagickShearImage(image, pixel, x, y);
+  gmu_clear_pixel_string_or_pixel(pixel_arg, pixel);
+  gum_check_image_exception(image, status);
+  return Qnil;
+}

data/ext/gmagick/gminit.c

@@ -0,0 +1,97 @@
+#include "gmagick.h"
+
+VALUE Module_Gmagick;
+VALUE Class_Image;
+VALUE Class_Pixel;
+VALUE Class_Drawing;
+
+ID id_new;
+
+void 
+Init_gmagickn(){
+  InitializeMagick(NULL);
+
+  Module_Gmagick = rb_define_module("Gmagick");
+  Class_Image = rb_define_class_under(Module_Gmagick, "Image", rb_cObject);
+  rb_define_alloc_func(Class_Image, gmi_alloc);
+  rb_define_private_method(Class_Image, "initialize", gmi_initialize, -1);
+  rb_define_method(Class_Image, "read", gmi_read_image, 1);
+  rb_define_method(Class_Image, "write", gmi_write_image, -1);
+  rb_define_method(Class_Image, "width", gmi_get_width, 0);
+  rb_define_method(Class_Image, "height", gmi_get_height, 0);
+  rb_define_method(Class_Image, "format", gmi_get_format, 0);
+  rb_define_method(Class_Image, "depth", gmi_get_depth, 0);
+  rb_define_method(Class_Image, "colors", gmi_get_colors, 0);
+  rb_define_method(Class_Image, "resolution", gmi_get_resolution, 0);
+  rb_define_method(Class_Image, "count", gmi_get_number_images, 0);
+  rb_define_method(Class_Image, "read_blob", gmi_read_image_blob, 1);
+  rb_define_method(Class_Image, "write_blob", gmi_write_image_blob, 0);
+  rb_define_method(Class_Image, "resize", gmi_resize, -1);
+  rb_define_method(Class_Image, "rotate", gmi_rotate, 2);
+  rb_define_method(Class_Image, "draw", gmi_draw, 1);
+  rb_define_method(Class_Image, "resample", gmi_resample, -1);
+  rb_define_method(Class_Image, "flip", gmi_flip, 0);
+  rb_define_method(Class_Image, "flop", gmi_flop, 0);
+  rb_define_method(Class_Image, "crop", gmi_crop, 4);
+  rb_define_method(Class_Image, "format=", gmi_set_format, 1);
+  rb_define_method(Class_Image, "border", gmi_border, 3);
+  rb_define_method(Class_Image, "frame", gmi_frame, 5);
+  rb_define_method(Class_Image, "blur", gmi_blur, 2);
+  rb_define_method(Class_Image, "swirl", gmi_swirl, 1);
+  rb_define_method(Class_Image, "charcoal", gmi_charcoal, 2);
+  rb_define_method(Class_Image, "oil_paint", gmi_oil_paint, 1);
+  rb_define_method(Class_Image, "cycle_colormap", gmi_cycle_colormap, 1);
+  rb_define_method(Class_Image, "solarize", gmi_solarize, 1);
+  rb_define_method(Class_Image, "shear", gmi_shear, 3);
+
+  Class_Pixel = rb_define_class_under(Module_Gmagick, "Pixel", rb_cObject);
+  rb_define_alloc_func(Class_Pixel, gmp_alloc);
+  rb_define_private_method(Class_Pixel, "initialize", gmp_initialize, -1);
+  rb_define_method(Class_Pixel, "color=", gmp_set_color, 1);
+  rb_define_method(Class_Pixel, "color", gmp_get_color, 0);
+  rb_define_method(Class_Pixel, "color_count=", gmp_set_color_count, 1);
+  rb_define_method(Class_Pixel, "color_count", gmp_get_color_count, 0);
+
+  Class_Drawing = rb_define_class_under(Module_Gmagick, "Drawing", rb_cObject);
+  rb_define_alloc_func(Class_Drawing, gmd_alloc);
+  rb_define_private_method(Class_Drawing, "initialize", gmd_initialize, 0);
+  rb_define_method(Class_Drawing, "annotation", gmd_annotation, 3);
+  rb_define_method(Class_Drawing, "arc", gmd_arc, 6);
+  rb_define_method(Class_Drawing, "circle", gmd_circle, 4);
+  rb_define_method(Class_Drawing, "ellipse", gmd_ellipse, -1);
+  rb_define_method(Class_Drawing, "line", gmd_line, 4);
+  rb_define_method(Class_Drawing, "point", gmd_point, 2);
+  rb_define_method(Class_Drawing, "rectangle", gmd_rectangle, 4);
+  rb_define_method(Class_Drawing, "rotate", gmd_rotate, 1);
+  rb_define_method(Class_Drawing, "scale", gmd_scale, 2);
+  rb_define_method(Class_Drawing, "fill_color=", gmd_set_fill_color, 1);
+  rb_define_method(Class_Drawing, "fill_color", gmd_get_fill_color, 0);
+  rb_define_method(Class_Drawing, "fill_opacity=", gmd_set_fill_opacity, 1);
+  rb_define_method(Class_Drawing, "fill_opacity", gmd_get_fill_opacity, 0);
+  rb_define_method(Class_Drawing, "font=", gmd_set_font, 1);
+  rb_define_method(Class_Drawing, "font", gmd_get_font, 0);
+  rb_define_method(Class_Drawing, "font_family=", gmd_set_font_family, 1);
+  rb_define_method(Class_Drawing, "font_family", gmd_get_font_family, 0);
+  rb_define_method(Class_Drawing, "font_size=", gmd_set_font_size, 1);
+  rb_define_method(Class_Drawing, "font_size", gmd_get_font_size, 0);
+  rb_define_method(Class_Drawing, "font_stretch=", gmd_set_font_stretch, 1);
+  rb_define_method(Class_Drawing, "font_stretch", gmd_get_font_stretch, 0);
+  rb_define_method(Class_Drawing, "font_style=", gmd_set_font_style, 1);
+  rb_define_method(Class_Drawing, "font_style", gmd_get_font_style, 0);
+  rb_define_method(Class_Drawing, "font_weight=", gmd_set_font_weight, 1);
+  rb_define_method(Class_Drawing, "font_weight", gmd_get_font_weight, 0);
+  rb_define_method(Class_Drawing, "round_rectangle", gmd_round_rectangle, 6);
+  rb_define_method(Class_Drawing, "stroke_color=", gmd_set_stroke_color, 1);
+  rb_define_method(Class_Drawing, "stroke_color", gmd_get_stroke_color, 0);
+  rb_define_method(Class_Drawing, "stroke_opacity=", gmd_set_stroke_opacity, 1);
+  rb_define_method(Class_Drawing, "stroke_opacity", gmd_get_stroke_opacity, 0);
+  rb_define_method(Class_Drawing, "stroke_width=", gmd_set_stroke_width, 1);
+  rb_define_method(Class_Drawing, "stroke_width", gmd_get_stroke_width, 0);
+  rb_define_method(Class_Drawing, "text_decoration=", gmd_set_text_decoration, 1);
+  rb_define_method(Class_Drawing, "text_decoration", gmd_get_text_decoration, 0);
+  rb_define_method(Class_Drawing, "text_encoding=", gmd_set_text_encoding, 1);
+  rb_define_method(Class_Drawing, "text_encoding", gmd_get_text_encoding, 0);
+
+
+  id_new = rb_intern("new");
+}

data/ext/gmagick/gmpixel.c

@@ -0,0 +1,82 @@
+#include "gmagick.h"
+
+void 
+gmp_free(GmPixel *ptr)
+{
+  if (ptr != (GmPixel *)NULL) {
+    if (ptr->wand != (PixelWand *)NULL) {
+      DestroyPixelWand(ptr->wand);
+    }
+    ruby_xfree(ptr);
+  }
+}
+
+VALUE 
+gmp_alloc(VALUE klass) {
+  GmPixel *ptr = ALLOC(GmPixel);
+  ptr->wand = (PixelWand *)NULL;
+  return Data_Wrap_Struct(klass, 0, gmp_free, ptr);
+}
+
+/*
+ * Document-method: new
+ *
+ * call-seq:
+ *   Gmagick::Pixel.new -> pixel
+ *   Gmagick::Pixel.new(color) -> pixel
+ *
+ * Create a GraphicsMagick Object
+ *
+ * [+color+]
+ *   initialize color
+ *
+ * Examples:
+ *
+ *   # Make pixel object
+ *   Gmagick::Pixel.new
+ *
+ *   # Make pixel object with color
+ *   Gmagick::Pixel.new("#000000")
+ *
+ */
+VALUE
+gmp_initialize(int argc, VALUE *argv, VALUE self) {
+  volatile GmPixel *ptr;
+  Data_Get_Struct(self, GmPixel, ptr);
+  ptr->wand = NewPixelWand();
+  if (argc > 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc);
+  }
+  if (argc > 0) {
+    gmp_set_color(self, argv[0]);
+  }
+  return Qnil;
+}
+
+VALUE
+gmp_set_color(VALUE self, VALUE color_arg) {
+  char *color = StringValuePtr(color_arg);
+  PixelWand *pixel = gmu_get_pixel_wand(self);
+  PixelSetColor(pixel, color);
+  return Qnil;
+}
+
+VALUE
+gmp_get_color(VALUE self) {
+  PixelWand *pixel = gmu_get_pixel_wand(self);
+  return rb_str_new2(PixelGetColorAsString(pixel));
+}
+
+VALUE
+gmp_set_color_count(VALUE self, VALUE color_count_arg) {
+  unsigned long color_count = NUM2LONG(color_count_arg);
+  PixelWand *pixel = gmu_get_pixel_wand(self);
+  PixelSetColorCount(pixel, color_count);
+  return Qnil;
+}
+
+VALUE
+gmp_get_color_count(VALUE self) {
+  PixelWand *pixel = gmu_get_pixel_wand(self);
+  return LONG2NUM(PixelGetColorCount(pixel));
+}