ruby-libgd 0.1.0

data/ext/gd/polygon.c

@@ -0,0 +1,98 @@
+/**
+    - [ ] imagefilledpolygon — Draw a filled polygon
+    - [ ] imageopenpolygon — Draws an open polygon
+    - [ ] imagepolygon — Draws a polygon
+*/
+#include "ruby_gd.h"
+#include <string.h>
+
+static gdPointPtr build_points(VALUE points, int *count_out) {
+  Check_Type(points, T_ARRAY);
+
+  long n = RARRAY_LEN(points);
+  if (n <= 0) {
+    *count_out = 0;
+    return NULL;
+  }
+
+  // Primero construimos todos los puntos (como antes)
+  gdPoint *raw_pts = ALLOC_N(gdPoint, n);
+  for (long i = 0; i < n; i++) {
+    VALUE pair = rb_ary_entry(points, i);
+    Check_Type(pair, T_ARRAY);
+    if (RARRAY_LEN(pair) < 2) {
+      xfree(raw_pts);
+      rb_raise(rb_eArgError, "each point must be [x, y]");
+    }
+    raw_pts[i].x = NUM2INT(rb_ary_entry(pair, 0));
+    raw_pts[i].y = NUM2INT(rb_ary_entry(pair, 1));
+  }
+
+  // Ahora eliminamos duplicados consecutivos
+  long unique_n = 0;
+  for (long i = 0; i < n; i++) {
+    if (unique_n == 0 ||
+        raw_pts[unique_n - 1].x != raw_pts[i].x ||
+        raw_pts[unique_n - 1].y != raw_pts[i].y) {
+      raw_pts[unique_n++] = raw_pts[i];
+    }
+  }
+
+  *count_out = (int)unique_n;
+
+  // Si hay menos de 3 puntos únicos, fallamos
+  if (unique_n < 3) {
+    xfree(raw_pts);
+    *count_out = 0;
+    return NULL;
+  }
+
+  // Reasignamos memoria para evitar desperdicio (opcional pero limpio)
+  gdPoint *clean_pts = ALLOC_N(gdPoint, unique_n);
+  MEMCPY(clean_pts, raw_pts, gdPoint, unique_n);
+  xfree(raw_pts);
+
+  return (gdPointPtr)clean_pts;
+}
+
+static VALUE gd_image_polygon(VALUE self, VALUE points, VALUE color) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  int count = 0;
+  gdPointPtr pts = build_points(points, &count);
+  int c = color_to_gd(wrap->img, color);
+
+  gdImagePolygon(wrap->img, pts, count, c);
+
+  xfree(pts);
+  return self;
+}
+
+static VALUE gd_image_filled_polygon(VALUE self, VALUE points, 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 count = 0;
+  gdPointPtr pts = build_points(points, &count);
+
+  if (!pts || count < 3) {
+    if (pts) xfree(pts);
+    rb_raise(rb_eArgError, "points must be an Array of at least 3 [x,y] pairs");
+  }
+
+  int c = color_to_gd(wrap->img, color);
+  gdImageFilledPolygon(wrap->img, pts, count, c);
+
+  xfree(pts);
+  return self;
+}
+
+void gd_define_polygon(VALUE cGDImage) {
+  rb_define_method(cGDImage, "polygon", gd_image_polygon, 2);
+  rb_define_method(cGDImage, "filled_polygon", gd_image_filled_polygon, 2);
+}

data/ext/gd/rectangle.c

@@ -0,0 +1,41 @@
+#include "ruby_gd.h"
+/**
+ - [ ] imagerectangle — Draw a rectangle
+ - [ ] imagefilledrectangle — Draw a filled rectangle
+ */
+static VALUE gd_image_rect(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, 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);
+  gdImageRectangle(wrap->img,
+                   NUM2INT(x1), NUM2INT(y1),
+                   NUM2INT(x2), NUM2INT(y2),
+                   c);
+  return Qnil;
+}
+
+static VALUE gd_image_filled_rect(VALUE self, VALUE x1, VALUE y1, VALUE x2, VALUE y2, 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);
+  gdImageFilledRectangle(wrap->img,
+                         NUM2INT(x1), NUM2INT(y1),
+                         NUM2INT(x2), NUM2INT(y2),
+                         c);
+  return Qnil;
+}
+
+void gd_define_rect(VALUE cGDImage) {
+  rb_define_method(cGDImage, "rect", gd_image_rect, 5);
+  rb_define_method(cGDImage, "filled_rect", gd_image_filled_rect, 5);
+}

data/ext/gd/ruby_gd.h

@@ -0,0 +1,38 @@
+#ifndef RUBY_GD_H
+#define RUBY_GD_H
+
+#include <ruby.h>
+#include <gd.h>
+
+typedef struct {
+    gdImagePtr img;
+    int owner;
+} gd_image_wrapper;
+
+extern const rb_data_type_t gd_image_type;
+
+int color_to_gd(gdImagePtr im, VALUE color);
+
+/* Image */
+void gd_define_image(VALUE mGD);
+void gd_define_blit(VALUE cGDImage);
+void gd_define_fill(VALUE cGDImage);
+
+void gd_define_pixel(VALUE cGDImage);
+void gd_define_line(VALUE cGDImage);
+void gd_define_arc(VALUE cGDImage);
+void gd_define_rect(VALUE cGDImage);
+void gd_define_circle(VALUE cGDImage);
+void gd_define_polygon(VALUE cGDImage);
+
+void gd_define_text(VALUE cGDImage);
+
+void gd_define_transform(VALUE cGDImage);
+void gd_define_filter(VALUE cGDImage);
+void gd_define_encode(VALUE cGDImage);
+
+/* Color */
+void gd_define_color(VALUE mGD);
+void gd_define_version(VALUE mGD);
+
+#endif

data/ext/gd/text.c

@@ -0,0 +1,48 @@
+#include "ruby_gd.h"
+/*
+ - [ ] imagefontheight — Get font height
+ - [ ] imagefontwidth — Get font width
+ - [ ] imageftbbox — Give the bounding box of a text using fonts via freetype2
+ - [ ] imagefttext — Write text to the image using fonts using FreeType 2
+*/
+
+static VALUE gd_image_text(VALUE self, VALUE text, VALUE opts) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  VALUE x = rb_hash_aref(opts, ID2SYM(rb_intern("x")));
+  VALUE y = rb_hash_aref(opts, ID2SYM(rb_intern("y")));
+  VALUE size = rb_hash_aref(opts, ID2SYM(rb_intern("size")));
+  VALUE color = rb_hash_aref(opts, ID2SYM(rb_intern("color")));
+  VALUE font = rb_hash_aref(opts, ID2SYM(rb_intern("font")));
+
+  if (NIL_P(x) || NIL_P(y) || NIL_P(size) || NIL_P(color) || NIL_P(font))
+    rb_raise(rb_eArgError, "missing options");
+
+  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 fg = gdImageColorAllocate(wrap->img, r, g, b);
+
+  int brect[8];
+  char *err = gdImageStringFT(
+    wrap->img,
+    brect,
+    fg,
+    StringValueCStr(font),
+    NUM2DBL(size),
+    0,
+    NUM2INT(x),
+    NUM2INT(y),
+    StringValueCStr(text)
+  );
+
+  if (err) rb_raise(rb_eRuntimeError, "%s", err);
+
+  return Qnil;
+}
+
+void gd_define_text(VALUE cGDImage) {
+  rb_define_method(cGDImage, "text", gd_image_text, 2);
+}

data/ext/gd/transform.c

@@ -0,0 +1,44 @@
+#include "ruby_gd.h"
+
+static VALUE wrap_new_image(gdImagePtr im, VALUE klass) {
+    gd_image_wrapper *w;
+    VALUE obj = TypedData_Make_Struct(klass, gd_image_wrapper, &gd_image_type, w);
+    w->img = im;
+    w->owner = 1;
+    return obj;
+}
+
+static VALUE gd_image_crop(VALUE self, VALUE vx, VALUE vy, VALUE vw, VALUE vh) {
+    gd_image_wrapper *wrap;
+    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+    gdRect r;
+    r.x = NUM2INT(vx);
+    r.y = NUM2INT(vy);
+    r.width  = NUM2INT(vw);
+    r.height = NUM2INT(vh);
+
+    gdImagePtr out = gdImageCrop(wrap->img, &r);
+    if (!out) rb_raise(rb_eRuntimeError, "crop failed");
+
+    return wrap_new_image(out, CLASS_OF(self));
+}
+
+static VALUE gd_image_scale(VALUE self, VALUE vw, VALUE vh) {
+    gd_image_wrapper *wrap;
+    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+    int w = NUM2INT(vw);
+    int h = NUM2INT(vh);
+
+    gdImagePtr out = gdImageScale(wrap->img, w, h);
+    if (!out) rb_raise(rb_eRuntimeError, "scale failed");
+
+    return wrap_new_image(out, CLASS_OF(self));
+}
+
+void gd_define_transform(VALUE cGDImage) {
+    rb_define_method(cGDImage, "crop", gd_image_crop, 4);
+    rb_define_method(cGDImage, "scale", gd_image_scale, 2);
+    rb_define_method(cGDImage, "resize", gd_image_scale, 2);
+}

data/ext/gd/version.c

@@ -0,0 +1,9 @@
+#include "ruby_gd.h"
+
+VALUE rb_gd_version(VALUE self) {
+  return rb_str_new_cstr(gdVersionString());
+}
+
+void gd_define_version(VALUE mGD) {
+    rb_define_singleton_method(mGD, "version", rb_gd_version, 0);
+}

data/lib/gd.rb

@@ -0,0 +1,2 @@
+require "gd/gd"
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: ruby-libgd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Germán Alberto Giménez Silva
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-02 00:00:00.000000000 Z
+dependencies: []
+description: High-performance native bindings to libgd for image generation
+email:
+- ggerman@gmail.com
+executables: []
+extensions:
+- ext/gd/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/gd/Makefile
+- ext/gd/arc.c
+- ext/gd/arc.o
+- ext/gd/blit.c
+- ext/gd/blit.o
+- ext/gd/char.c
+- ext/gd/char.o
+- ext/gd/circle.c
+- ext/gd/circle.o
+- ext/gd/clip.c
+- ext/gd/clip.h
+- ext/gd/clip.o
+- ext/gd/color.c
+- ext/gd/color.o
+- ext/gd/draw_line.c
+- ext/gd/draw_line.o
+- ext/gd/ellipse.c
+- ext/gd/ellipse.o
+- ext/gd/encode.c
+- ext/gd/encode.o
+- ext/gd/extconf.rb
+- ext/gd/fill.c
+- ext/gd/fill.o
+- ext/gd/filter.c
+- ext/gd/filter.o
+- ext/gd/gd.c
+- ext/gd/gd.o
+- ext/gd/gd.so
+- ext/gd/image.c
+- ext/gd/image.o
+- ext/gd/join.sh
+- ext/gd/mkmf.log
+- ext/gd/pixel.c
+- ext/gd/pixel.o
+- ext/gd/polygon.c
+- ext/gd/polygon.o
+- ext/gd/rectangle.c
+- ext/gd/rectangle.o
+- ext/gd/ruby_gd.h
+- ext/gd/text.c
+- ext/gd/text.o
+- ext/gd/transform.c
+- ext/gd/transform.o
+- ext/gd/version.c
+- ext/gd/version.o
+- lib/gd.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Native Ruby bindings for libgd
+test_files: []