ruby-libgd 0.1.0

data/ext/gd/encode.c

@@ -0,0 +1,66 @@
+#include "ruby_gd.h"
+
+/**
+  - [ ] imagegif — Output image to browser or file
+  - [x] imagewbmp — Output image to browser or file
+  - [x] imagewebp — Output a WebP image to browser or file
+  - [ ] imagexbm — Output an XBM image to browser or file
+  - [x] imagepng — Output a PNG image to either the browser or a file
+  - [x] imagejpeg — Output image to browser or file
+  - [ ] imagegd — Output GD image to browser or file
+  - [ ] imagegd2 — Output GD2 image to browser or file
+  - [ ] imageavif — Output image to browser or file
+  - [ ] imagebmp — Output a BMP image to browser or file
+ **/
+static VALUE gd_image_save(int argc, VALUE *argv, VALUE self) {
+  VALUE path, opts;
+  rb_scan_args(argc, argv, "11", &path, &opts);
+
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  const char *filename = StringValueCStr(path);
+
+  const char *ext = strrchr(filename, '.');
+  if (!ext) rb_raise(rb_eArgError, "file extension required");
+
+  FILE *f = fopen(filename, "wb");
+  if (!f) rb_sys_fail(filename);
+
+  if (strcmp(ext, ".png") == 0) {
+    gdImagePng(wrap->img, f);
+  } else if (strcmp(ext, ".jpg") == 0 || strcmp(ext, ".jpeg") == 0) {
+    int quality = 90;
+    if (opts != Qnil) {
+      VALUE q = rb_hash_aref(opts, ID2SYM(rb_intern("quality")));
+      if (!NIL_P(q)) quality = NUM2INT(q);
+    }
+    gdImageJpeg(wrap->img, f, quality);
+  } else if (strcmp(ext, ".webp") == 0) {
+    gdImageWebp(wrap->img, f);
+  } else {
+    fclose(f);
+    rb_raise(rb_eArgError, "unsupported format");
+  }
+
+  fclose(f);
+  return Qtrue;
+}
+
+static VALUE gd_image_to_png(VALUE self) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  int size = 0;
+  void *data = gdImagePngPtr(wrap->img, &size);
+  if (!data) rb_raise(rb_eRuntimeError, "PNG encode failed");
+
+  VALUE str = rb_str_new((const char*)data, size);
+  gdFree(data);
+  return str;
+}
+
+void gd_define_encode(VALUE cGDImage) {
+  rb_define_method(cGDImage, "save", gd_image_save, -1);
+  rb_define_method(cGDImage, "to_png", gd_image_to_png, 0);
+}

data/ext/gd/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+abort "libgd not found" unless have_library("gd")
+have_library("m")
+create_makefile("gd/gd")

data/ext/gd/fill.c

@@ -0,0 +1,24 @@
+#include "ruby_gd.h"
+
+/**
+    - [x] imagefill — Flood fill
+ */
+static VALUE gd_image_fill(VALUE self, VALUE color) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  if (!wrap || !wrap->img)
+    rb_raise(rb_eRuntimeError, "uninitialized GD::Image");
+
+  int r = NUM2INT(rb_ary_entry(color,0));
+  int g = NUM2INT(rb_ary_entry(color,1));
+  int b = NUM2INT(rb_ary_entry(color,2));
+  int c = gdImageColorAllocate(wrap->img,r,g,b);
+
+  gdImageFilledRectangle(wrap->img,0,0,wrap->img->sx,wrap->img->sy,c);
+  return Qnil;
+}
+
+void gd_define_fill(VALUE cGDImage) {
+  rb_define_method(cGDImage,"fill",gd_image_fill,1);
+}

data/ext/gd/filter.c

@@ -0,0 +1,70 @@
+#include "ruby_gd.h"
+#include <string.h>
+
+static VALUE gd_image_filter(int argc, VALUE *argv, VALUE self) {
+  VALUE type, arg1, arg2, arg3, arg4;
+  rb_scan_args(argc, argv, "14", &type, &arg1, &arg2, &arg3, &arg4);
+
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  type = rb_obj_as_string(type);
+  const char *name = StringValueCStr(type);
+
+  if (strcmp(name, "negate") == 0) {
+    gdImageNegate(wrap->img);
+  }
+  else if (strcmp(name, "grayscale") == 0) {
+    gdImageGrayScale(wrap->img);
+  }
+  else if (strcmp(name, "brightness") == 0) {
+    gdImageBrightness(wrap->img, NUM2INT(arg1));
+  }
+  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);
+  }
+  else if (strcmp(name, "emboss") == 0) {
+    gdImageEmboss(wrap->img);
+  }
+  else if (strcmp(name, "gaussian_blur") == 0) {
+    gdImageGaussianBlur(wrap->img);
+  }
+  else if (strcmp(name, "selective_blur") == 0) {
+    gdImageSelectiveBlur(wrap->img);
+  }
+  else if (strcmp(name, "mean_removal") == 0) {
+    gdImageMeanRemoval(wrap->img);
+  }
+  else if (strcmp(name, "smooth") == 0) {
+    gdImageSmooth(wrap->img, NUM2INT(arg1));
+  }
+  else if (strcmp(name, "pixelate") == 0) {
+    gdImagePixelate(
+      wrap->img,
+      NUM2INT(arg1),
+      RTEST(arg2)
+    );
+  }
+  else if (strcmp(name, "scatter") == 0) {
+    gdImageScatter(
+      wrap->img,
+      NUM2INT(arg1),
+      NUM2INT(arg2)
+    );
+  }
+  else {
+    rb_raise(rb_eArgError, "unknown filter");
+  }
+
+  return self;
+}
+
+void gd_define_filter(VALUE cGDImage) {
+  rb_define_method(cGDImage, "filter", gd_image_filter, -1);
+}

data/ext/gd/gd.c

@@ -0,0 +1,87 @@
+#include "ruby_gd.h"
+
+static VALUE mGD;
+static VALUE cGDImage;
+
+static VALUE gd_info(VALUE self) {
+    return rb_str_new_cstr(gdVersionString());
+}
+
+static VALUE gd_types(VALUE self) {
+    VALUE h = rb_hash_new();
+
+    rb_hash_aset(h, ID2SYM(rb_intern("png")),
+        gdSupportsFileType("test.png", 1) ? Qtrue : Qfalse);
+
+    rb_hash_aset(h, ID2SYM(rb_intern("jpeg")),
+        gdSupportsFileType("test.jpg", 1) ? Qtrue : Qfalse);
+
+    rb_hash_aset(h, ID2SYM(rb_intern("gif")),
+        gdSupportsFileType("test.gif", 1) ? Qtrue : Qfalse);
+
+    rb_hash_aset(h, ID2SYM(rb_intern("webp")),
+        gdSupportsFileType("test.webp", 1) ? Qtrue : Qfalse);
+
+    rb_hash_aset(h, ID2SYM(rb_intern("bmp")),
+        gdSupportsFileType("test.bmp", 1) ? Qtrue : Qfalse);
+
+    return h;
+}
+
+static VALUE gd_mime_for(VALUE self, VALUE sym) {
+    const char *t = rb_id2name(SYM2ID(sym));
+
+    if (!strcmp(t,"png"))  return rb_str_new_cstr("image/png");
+    if (!strcmp(t,"jpeg")) return rb_str_new_cstr("image/jpeg");
+    if (!strcmp(t,"jpg"))  return rb_str_new_cstr("image/jpeg");
+    if (!strcmp(t,"gif"))  return rb_str_new_cstr("image/gif");
+    if (!strcmp(t,"webp")) return rb_str_new_cstr("image/webp");
+    if (!strcmp(t,"bmp"))  return rb_str_new_cstr("image/bmp");
+
+    return Qnil;
+}
+
+static VALUE gd_ext_for(VALUE self, VALUE sym) {
+    const char *t = rb_id2name(SYM2ID(sym));
+
+    if (!strcmp(t,"png"))  return rb_str_new_cstr(".png");
+    if (!strcmp(t,"jpeg")) return rb_str_new_cstr(".jpg");
+    if (!strcmp(t,"jpg"))  return rb_str_new_cstr(".jpg");
+    if (!strcmp(t,"gif"))  return rb_str_new_cstr(".gif");
+    if (!strcmp(t,"webp")) return rb_str_new_cstr(".webp");
+    if (!strcmp(t,"bmp"))  return rb_str_new_cstr(".bmp");
+
+    return Qnil;
+}
+
+void Init_gd(void) {
+  mGD = rb_define_module("GD");
+
+  rb_define_singleton_method(mGD, "info",     gd_info,     0);
+  rb_define_singleton_method(mGD, "types",    gd_types,    0);
+  rb_define_singleton_method(mGD, "mime_for", gd_mime_for, 1);
+  rb_define_singleton_method(mGD, "ext_for",  gd_ext_for,  1);
+
+  gd_define_image(mGD);
+
+  cGDImage = rb_path2class("GD::Image");
+
+  gd_define_blit(cGDImage);
+  gd_define_fill(cGDImage);
+
+  gd_define_pixel(cGDImage);
+  gd_define_line(cGDImage);
+  gd_define_arc(cGDImage);
+  gd_define_rect(cGDImage);
+  gd_define_circle(cGDImage);
+  gd_define_polygon(cGDImage);
+
+  gd_define_text(cGDImage);
+
+  gd_define_filter(cGDImage);
+  gd_define_transform(cGDImage);
+  gd_define_encode(cGDImage);
+
+  gd_define_color(mGD);
+  gd_define_version(mGD);
+}

data/ext/gd/image.c

@@ -0,0 +1,203 @@
+#include "ruby_gd.h"
+
+static VALUE gd_image_initialize(int argc, VALUE *argv, VALUE self) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  wrap->img = NULL;
+
+  if (argc == 0) {
+    return self;
+  }
+  if (argc != 2) {
+    rb_raise(rb_eArgError, "expected 0 or 2 arguments");
+  }
+
+  int w = NUM2INT(argv[0]);
+  int h = NUM2INT(argv[1]);
+  if (w <= 0 || h <= 0)
+    rb_raise(rb_eArgError, "width and height must be positive");
+
+  wrap->img = gdImageCreateTrueColor(w, h);
+  if (!wrap->img)
+    rb_raise(rb_eRuntimeError, "gdImageCreateTrueColor failed");
+
+  return self;
+}
+
+static VALUE gd_image_initialize_empty(VALUE self) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+  wrap->img = NULL;
+  return self;
+}
+
+static VALUE gd_image_initialize_true_color(VALUE self, VALUE width, VALUE height) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  if (wrap->img) {
+    gdImageDestroy(wrap->img);
+  }
+
+  int w = NUM2INT(width);
+  int h = NUM2INT(height);
+  if (w <= 0 || h <= 0) {
+    rb_raise(rb_eArgError, "width and height must be positive");
+  }
+
+  wrap->img = gdImageCreateTrueColor(w, h);
+  if (!wrap->img) {
+    rb_raise(rb_eRuntimeError, "failed to create true color image");
+  }
+
+  // Opcional: desactivar el fondo transparente si no lo necesitas
+  gdImageAlphaBlending(wrap->img, 1);
+  gdImageSaveAlpha(wrap->img, 0);
+
+  return self;
+}
+
+static VALUE gd_image_s_new_true_color(VALUE klass, VALUE width, VALUE height) {
+  VALUE obj = rb_class_new_instance(0, NULL, klass);
+  gd_image_initialize_true_color(obj, width, height);
+  return obj;
+}
+
+static VALUE gd_image_clone(VALUE self) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  if (!wrap->img) rb_raise(rb_eRuntimeError, "cannot clone: image is NULL");
+
+  gdImagePtr copy = gdImageClone(wrap->img);
+  if (!copy) rb_raise(rb_eRuntimeError, "gdImageClone failed");
+
+  VALUE obj = rb_class_new_instance(0, NULL, CLASS_OF(self));
+  gd_image_wrapper *w2;
+  TypedData_Get_Struct(obj, gd_image_wrapper, &gd_image_type, w2);
+  w2->img = copy;
+
+  return obj;
+}
+
+static void gd_image_free(void *ptr) {
+  gd_image_wrapper *wrap = (gd_image_wrapper *)ptr;
+  if (!wrap) return;
+
+  if (wrap->img) {
+    gdImageDestroy(wrap->img);
+    wrap->img = NULL;
+  }
+}
+
+static size_t gd_image_memsize(const void *ptr) {
+  return ptr ? sizeof(gd_image_wrapper) : 0;
+}
+
+const rb_data_type_t gd_image_type = {
+  "GD::Image",
+  { 0, gd_image_free, gd_image_memsize, 0 },  // <-- dcompact agregado
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE gd_image_alloc(VALUE klass) {
+  gd_image_wrapper *wrap;
+  VALUE obj = TypedData_Make_Struct(klass, gd_image_wrapper, &gd_image_type, wrap);
+  wrap->img = NULL;
+  return obj;
+}
+
+static VALUE gd_image_new(VALUE klass, VALUE w, VALUE h) {
+  VALUE obj = rb_class_new_instance(0, NULL, klass);
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(obj, gd_image_wrapper, &gd_image_type, wrap);
+
+  int width  = NUM2INT(w);
+  int height = NUM2INT(h);
+  if (width <= 0 || height <= 0)
+    rb_raise(rb_eArgError, "width and height must be positive");
+
+  wrap->img = gdImageCreateTrueColor(width, height);
+  if (!wrap->img) rb_raise(rb_eRuntimeError, "gdImageCreateTrueColor failed");
+  return obj;
+}
+
+static VALUE gd_image_open(VALUE klass, VALUE path) {
+  const char *filename = StringValueCStr(path);
+
+  FILE *f = fopen(filename, "rb");
+  if (!f) rb_sys_fail(filename);
+
+  gdImagePtr img = NULL;
+
+  const char *ext = strrchr(filename, '.');
+  if (!ext) rb_raise(rb_eArgError, "unknown image type");
+
+  if (strcmp(ext, ".png") == 0) {
+    img = gdImageCreateFromPng(f);
+  } else if (strcmp(ext, ".jpg") == 0 || strcmp(ext, ".jpeg") == 0) {
+    img = gdImageCreateFromJpeg(f);
+  } else if (strcmp(ext, ".webp") == 0) {
+    img = gdImageCreateFromWebp(f);
+  } else if (strcmp(ext, ".gif") == 0) {
+    img = gdImageCreateFromGif(f);
+  } else {
+    fclose(f);
+    rb_raise(rb_eArgError, "unsupported format");
+  }
+
+  fclose(f);
+  if (!img) rb_raise(rb_eRuntimeError, "image decode failed");
+
+  VALUE obj = rb_class_new_instance(0, NULL, klass);
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(obj, gd_image_wrapper, &gd_image_type, wrap);
+  wrap->img = img;
+
+  return obj;
+}
+
+static VALUE gd_image_alpha_blending(VALUE self, VALUE flag) {
+    gd_image_wrapper *wrap;
+    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+    gdImageAlphaBlending(wrap->img, RTEST(flag));
+    return self;
+}
+
+static VALUE gd_image_save_alpha(VALUE self, VALUE flag) {
+    gd_image_wrapper *wrap;
+    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+    gdImageSaveAlpha(wrap->img, RTEST(flag));
+    return self;
+}
+
+static VALUE gd_image_width(VALUE self) {
+    gd_image_wrapper *wrap;
+    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+    return INT2NUM(gdImageSX(wrap->img));
+}
+
+static VALUE gd_image_height(VALUE self) {
+    gd_image_wrapper *wrap;
+    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+    return INT2NUM(gdImageSY(wrap->img));
+}
+
+void gd_define_image(VALUE mGD) {
+  VALUE cGDImage = rb_define_class_under(mGD, "Image", rb_cObject);
+
+  rb_define_alloc_func(cGDImage, gd_image_alloc);
+
+  rb_define_method(cGDImage, "width",  gd_image_width,  0);
+  rb_define_method(cGDImage, "height", gd_image_height, 0);
+  rb_define_method(cGDImage, "initialize", gd_image_initialize, -1);
+  rb_define_method(cGDImage, "clone", gd_image_clone, 0);
+  rb_define_singleton_method(cGDImage, "open", gd_image_open, 1);
+  rb_define_singleton_method(cGDImage, "new_true_color", gd_image_s_new_true_color, 2);
+  rb_define_method(cGDImage, "alpha_blending=", gd_image_alpha_blending, 1);
+  rb_define_method(cGDImage, "save_alpha=", gd_image_save_alpha, 1);
+}

data/ext/gd/join.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+OUT="c_sources_dump.txt"
+
+echo "Generating $OUT ..."
+echo "======================" > "$OUT"
+echo "Generated on $(date)" >> "$OUT"
+echo "" >> "$OUT"
+
+find . -name "*.c" -type f | sort | while read -r file; do
+  echo "----------------------------------------" >> "$OUT"
+  echo "FILE: $file" >> "$OUT"
+  echo "----------------------------------------" >> "$OUT"
+  echo "" >> "$OUT"
+
+  sed 's/\t/  /g' "$file" >> "$OUT"
+
+  echo "" >> "$OUT"
+  echo "" >> "$OUT"
+done
+
+echo "Done."
+echo "Output written to: $OUT"

data/ext/gd/mkmf.log

@@ -0,0 +1,59 @@
+have_library: checking for -lgd... -------------------- yes
+
+LD_LIBRARY_PATH=.:/usr/local/lib "gcc -o conftest -I/usr/local/include/ruby-3.3.0/x86_64-linux -I/usr/local/include/ruby-3.3.0/ruby/backward -I/usr/local/include/ruby-3.3.0 -I.    -O3 -fno-fast-math -ggdb3 -Wall -Wextra -Wdeprecated-declarations -Wdiv-by-zero -Wduplicated-cond -Wimplicit-function-declaration -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wold-style-definition -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable -Wmisleading-indentation -Wundef  -fPIC conftest.c  -L. -L/usr/local/lib -Wl,-rpath,/usr/local/lib -L. -fstack-protector-strong -rdynamic -Wl,-export-dynamic -Wl,--no-as-needed     -Wl,-rpath,/usr/local/lib -L/usr/local/lib -lruby  -lm -lpthread  -lc"
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: int main(int argc, char **argv)
+4: {
+5:   return !!argv[argc];
+6: }
+/* end */
+
+LD_LIBRARY_PATH=.:/usr/local/lib "gcc -o conftest -I/usr/local/include/ruby-3.3.0/x86_64-linux -I/usr/local/include/ruby-3.3.0/ruby/backward -I/usr/local/include/ruby-3.3.0 -I.    -O3 -fno-fast-math -ggdb3 -Wall -Wextra -Wdeprecated-declarations -Wdiv-by-zero -Wduplicated-cond -Wimplicit-function-declaration -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wold-style-definition -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable -Wmisleading-indentation -Wundef  -fPIC conftest.c  -L. -L/usr/local/lib -Wl,-rpath,/usr/local/lib -L. -fstack-protector-strong -rdynamic -Wl,-export-dynamic -Wl,--no-as-needed     -Wl,-rpath,/usr/local/lib -L/usr/local/lib -lruby -lgd  -lm -lpthread  -lc"
+checked program was:
+/* begin */
+ 1: #include "ruby.h"
+ 2: 
+ 3: /*top*/
+ 4: extern int t(void);
+ 5: int main(int argc, char **argv)
+ 6: {
+ 7:   if (argc > 1000000) {
+ 8:     int (* volatile tp)(void)=(int (*)(void))&t;
+ 9:     printf("%d", (*tp)());
+10:   }
+11: 
+12:   return !!argv[argc];
+13: }
+14: 
+15: int t(void) { ; return 0; }
+/* end */
+
+--------------------
+
+have_library: checking for -lm... -------------------- yes
+
+LD_LIBRARY_PATH=.:/usr/local/lib "gcc -o conftest -I/usr/local/include/ruby-3.3.0/x86_64-linux -I/usr/local/include/ruby-3.3.0/ruby/backward -I/usr/local/include/ruby-3.3.0 -I.    -O3 -fno-fast-math -ggdb3 -Wall -Wextra -Wdeprecated-declarations -Wdiv-by-zero -Wduplicated-cond -Wimplicit-function-declaration -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wold-style-definition -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable -Wmisleading-indentation -Wundef  -fPIC conftest.c  -L. -L/usr/local/lib -Wl,-rpath,/usr/local/lib -L. -fstack-protector-strong -rdynamic -Wl,-export-dynamic -Wl,--no-as-needed    -lgd  -Wl,-rpath,/usr/local/lib -L/usr/local/lib -lruby -lm -lgd  -lm -lpthread  -lc"
+checked program was:
+/* begin */
+ 1: #include "ruby.h"
+ 2: 
+ 3: /*top*/
+ 4: extern int t(void);
+ 5: int main(int argc, char **argv)
+ 6: {
+ 7:   if (argc > 1000000) {
+ 8:     int (* volatile tp)(void)=(int (*)(void))&t;
+ 9:     printf("%d", (*tp)());
+10:   }
+11: 
+12:   return !!argv[argc];
+13: }
+14: 
+15: int t(void) { ; return 0; }
+/* end */
+
+--------------------
+

data/ext/gd/pixel.c

@@ -0,0 +1,39 @@
+#include "ruby_gd.h"
+
+static VALUE gd_image_set_pixel(VALUE self, VALUE x, VALUE y, VALUE color) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  int r = NUM2INT(rb_ary_entry(color,0));
+  int g = NUM2INT(rb_ary_entry(color,1));
+  int b = NUM2INT(rb_ary_entry(color,2));
+
+  int c = gdImageColorAllocate(wrap->img, r, g, b);
+
+  gdImageSetPixel(wrap->img, NUM2INT(x), NUM2INT(y), c);
+
+  return Qnil;
+}
+
+static VALUE gd_image_get_pixel(VALUE self, VALUE x, VALUE y) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  int c = gdImageGetPixel(wrap->img, NUM2INT(x), NUM2INT(y));
+
+  int r = gdImageRed(wrap->img, c);
+  int g = gdImageGreen(wrap->img, c);
+  int b = gdImageBlue(wrap->img, c);
+
+  VALUE ary = rb_ary_new_capa(3);
+  rb_ary_push(ary, INT2NUM(r));
+  rb_ary_push(ary, INT2NUM(g));
+  rb_ary_push(ary, INT2NUM(b));
+
+  return ary;
+}
+
+void gd_define_pixel(VALUE cGDImage) {
+  rb_define_method(cGDImage, "set_pixel", gd_image_set_pixel, 3);
+  rb_define_method(cGDImage, "get_pixel", gd_image_get_pixel, 2);
+}