axon 0.0.1

data/ext/axon/nearest_neighbor_interpolation.c

@@ -0,0 +1,50 @@
+#include <ruby.h>
+
+static ID id_image, id_components, id_width_ratio, id_width;
+
+/*
+*  call-seq:
+*     image.interpolate_scanline(original_scanlines, q) -> interpolated_scanline
+*/
+static VALUE
+interpolate_scanline(VALUE self, VALUE rb_scanline)
+{
+    VALUE rb_components, rb_width_ratio, rb_dest_sl, rb_image, rb_width;
+    double width_ratio;
+    unsigned char *scanline, *dest_sl;
+    size_t width, components, i, j;
+
+    rb_width = rb_ivar_get(self, id_width);
+    width = FIX2INT(rb_width);
+
+    rb_image = rb_ivar_get(self, id_image);
+    rb_components = rb_funcall(rb_image, id_components, 0);
+    components = FIX2INT(rb_components);
+
+    rb_width_ratio = rb_ivar_get(self, id_width_ratio);
+    width_ratio = NUM2DBL(rb_width_ratio);
+
+    scanline = RSTRING_PTR(rb_scanline);
+    
+    rb_dest_sl = rb_str_new(0, width * components);
+    dest_sl = RSTRING_PTR(rb_dest_sl);
+
+    for (i = 0; i < width; i++)
+        for (j = 0; j < components; j++)
+            dest_sl[i * components + j] = scanline[(int)(i / width_ratio)];
+    
+    return rb_dest_sl;
+}
+
+void
+Init_nearest_neighbor_interpolation()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    VALUE mNearestNeighborScaling = rb_define_module_under(mAxon, "NearestNeighborScaling");
+    rb_define_method(mNearestNeighborScaling, "interpolate_scanline", interpolate_scanline, 1);
+    
+    id_width_ratio = rb_intern("@width_ratio");
+    id_image = rb_intern("@image");
+    id_components = rb_intern("components");
+    id_width = rb_intern("@width");
+}

data/ext/axon/png_common.c

@@ -0,0 +1,21 @@
+#include "png_common.h"
+
+void
+png_error_fn(png_structp png_ptr, png_const_charp message)
+{
+    rb_raise(rb_eRuntimeError, "pnglib: %s", message);
+}
+
+void
+png_warning_fn(png_structp png_ptr, png_const_charp message)
+{
+    /* do nothing */
+}
+
+void
+Init_png()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    rb_const_set(mAxon, rb_intern("PNG_LIB_VERSION"),
+		 INT2FIX(PNG_LIBPNG_VER));
+}

data/ext/axon/png_common.h

@@ -0,0 +1,18 @@
+#ifndef  AXON_PNG_COMMON_H
+#define  AXON_PNG_COMMON_H
+
+#include <ruby.h>
+#include <png.h>
+
+#ifndef HAVE_RB_BLOCK_CALL
+#define rb_block_call(arg1, arg2, arg3, arg4, arg5, arg6) rb_iterate(rb_each, arg1, arg5, arg6)
+#endif
+
+void png_error_fn(png_structp, png_const_charp);
+void png_warning_fn(png_structp, png_const_charp);
+
+void Init_png();
+void Init_png_native_writer();
+void Init_png_reader();
+
+#endif

data/ext/axon/png_native_writer.c

@@ -0,0 +1,166 @@
+#include "png_common.h"
+
+static ID id_write, id_GRAYSCALE, id_RGB, id_image, id_each, id_width,
+	  id_height, id_color_model, id_components;
+
+void
+write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+    VALUE str, io, write_len;
+    int write_len_i;
+
+    if (png_ptr == NULL)
+	return;
+
+    str = rb_str_new(data, length);
+    io = (VALUE)png_get_io_ptr(png_ptr);
+    write_len = rb_funcall(io, id_write, 1, str);
+    write_len_i = FIX2INT(write_len);
+    
+    if ((size_t)write_len_i != length)
+	rb_raise(rb_eRuntimeError, "Write Error. Wrote %d instead of %d bytes.",
+		 write_len_i, (int)length);
+}
+
+void
+flush_data(png_structp png_ptr)
+{
+    /* do nothing */
+}
+
+static VALUE
+write_scanline(VALUE scan_line, VALUE *args)
+{
+    png_structp png_ptr = (png_structp)args[1];
+    png_infop info_ptr = (png_infop)args[2];
+    png_uint_32 width;
+    png_byte components;
+
+    if (TYPE(scan_line) != T_STRING)
+	scan_line = rb_obj_as_string(scan_line);
+
+    width = png_get_image_width(png_ptr, info_ptr);
+    components = png_get_channels(png_ptr, info_ptr);
+    if ((png_uint_32)RSTRING_LEN(scan_line) != width * components)
+	rb_raise(rb_eRuntimeError, "Scanline has a bad size. Expected %d but got %d.",
+		 (int)(width * components), (int)RSTRING_LEN(scan_line));
+
+    png_write_row(png_ptr, (png_bytep)RSTRING_PTR(scan_line));
+    return Qnil;
+}
+
+static int
+id_to_color_type(ID rb, int components)
+{
+    if      (rb == id_GRAYSCALE && components == 1) return PNG_COLOR_TYPE_GRAY;
+    else if (rb == id_GRAYSCALE && components == 2) return PNG_COLOR_TYPE_GRAY_ALPHA;
+    else if (rb == id_RGB       && components == 3) return PNG_COLOR_TYPE_RGB;
+    else if (rb == id_RGB       && components == 4) return PNG_COLOR_TYPE_RGB_ALPHA;
+
+    rb_raise(rb_eRuntimeError, "Color Space not recognized.");
+}
+
+static void
+size_and_colors(VALUE self, png_structp png_ptr, png_infop info_ptr)
+{
+    VALUE image, width, height, color_model, components;
+    int color_type;
+
+    image = rb_funcall(self, id_image, 0);
+
+    width       = rb_funcall(image, id_width, 0);
+    height      = rb_funcall(image, id_height, 0);
+    components  = rb_funcall(image, id_components, 0);
+    color_model = rb_funcall(image, id_color_model, 0);
+
+    color_type = id_to_color_type(SYM2ID(color_model), FIX2INT(components));
+
+    png_set_IHDR(png_ptr, info_ptr, FIX2INT(width), FIX2INT(height), 8,
+		 color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+		 PNG_FILTER_TYPE_DEFAULT);
+}
+
+static VALUE
+write2(VALUE *args)
+{
+    VALUE self = args[0];
+    png_structp png_ptr = (png_structp)args[1];
+    png_infop info_ptr = (png_infop)args[2];
+
+    VALUE image = rb_funcall(self, id_image, 0);
+
+    size_and_colors(self, png_ptr, info_ptr);
+
+    png_write_info(png_ptr, info_ptr);
+    rb_block_call(image, id_each, 0, 0, write_scanline, (VALUE)args);
+    png_write_end(png_ptr, info_ptr);
+
+    return Qnil;
+}
+
+static VALUE
+write2_ensure(VALUE *args)
+{
+    png_structp png_ptr = (png_structp)args[1];
+    png_infop info_ptr = (png_infop)args[2];
+
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    return Qnil;
+}
+
+/*
+*  call-seq:
+*     writer.write(io) -> nil
+*
+*  Compress image and write the png to io.
+*/
+
+static VALUE
+pngwrite(VALUE self, VALUE io)
+{
+    VALUE ensure_args[3];
+
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
+				      (png_error_ptr)png_error_fn,
+				      (png_error_ptr)png_warning_fn);
+
+    if (png_ptr == NULL)
+	rb_raise(rb_eRuntimeError, "unable to allocate a png object");
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (info_ptr == NULL) {
+	png_destroy_write_struct(&png_ptr, png_infopp_NULL);
+	rb_raise(rb_eRuntimeError, "unable to allocate a png info object");
+    }
+
+    png_set_write_fn(png_ptr, (void *)io, write_data, flush_data);
+
+    ensure_args[0] = self;
+    ensure_args[1] = (VALUE)png_ptr;
+    ensure_args[2] = (VALUE)info_ptr;
+
+    return rb_ensure(write2, (VALUE)ensure_args, write2_ensure,
+                     (VALUE)ensure_args);
+}
+
+void
+Init_png_native_writer()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    VALUE mNativeWriter = rb_define_module_under(mAxon, "PNGNativeWriter");
+
+    rb_define_method(mNativeWriter, "png_native_write", pngwrite, 1);
+
+    id_GRAYSCALE = rb_intern("GRAYSCALE");
+    id_RGB = rb_intern("RGB");
+    id_write = rb_intern("write");
+    id_image = rb_intern("image");
+    id_each = rb_intern("each");
+    id_width = rb_intern("width");
+    id_height = rb_intern("height");
+    id_color_model = rb_intern("color_model");
+    id_components = rb_intern("components");
+}

data/ext/axon/png_reader.c

@@ -0,0 +1,381 @@
+#include "png_common.h"
+
+static ID id_read, id_GRAYSCALE, id_RGB;
+
+struct png_data {
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    int needs_reset;
+    int locked;
+    int rewind_after_scanlines;
+    
+    VALUE io;
+};
+
+static void
+raise_if_locked(struct png_data *reader)
+{
+    if (reader->locked)
+	rb_raise(rb_eRuntimeError, "Can't modify a locked Reader");
+}
+
+static void
+free_png(struct png_data *reader)
+{
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+
+    if (png_ptr && info_ptr)
+	png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
+    else if (png_ptr)
+	png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
+}
+
+static void
+free_reader(struct png_data *reader)
+{
+    free_png(reader);
+    free(reader);
+}
+
+void
+read_data_fn(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+    VALUE io, str;
+    size_t read_len;
+
+    if (png_ptr == NULL)
+	return;
+
+    io = (VALUE)png_get_io_ptr(png_ptr);
+    str = rb_funcall(io, id_read, 1, INT2FIX(length));
+
+    if (NIL_P(str))
+	rb_raise(rb_eRuntimeError, "Read Error. Reader returned nil.");
+
+    StringValue(str);
+    read_len = RSTRING_LEN(str);
+
+    if (read_len != length)
+	rb_raise(rb_eRuntimeError, "Read Error. Read %d instead of %d bytes.",
+		 (int)read_len, (int)length);
+
+    png_memcpy(data, RSTRING_PTR(str), read_len);
+}
+
+static void
+mark(struct png_data *reader)
+{
+    VALUE io = reader->io;
+
+    if (io)
+	rb_gc_mark(io);
+}
+
+static void
+allocate_png(struct png_data *reader)
+{
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
+				     (png_error_ptr)png_error_fn,
+				     (png_error_ptr)png_warning_fn);
+
+    if (png_ptr == NULL)
+	rb_raise(rb_eRuntimeError, "unable to allocate a png object");
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (info_ptr == NULL) {
+	png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
+	rb_raise(rb_eRuntimeError, "unable to allocate a png info object");
+    }
+
+    reader->png_ptr = png_ptr;
+    reader->info_ptr = info_ptr;
+}
+
+static VALUE
+allocate(VALUE klass)
+{
+    VALUE self;
+    struct png_data *reader;
+    
+    self = Data_Make_Struct(klass, struct png_data, mark, free_reader, reader);
+    allocate_png(reader);
+
+    return self;
+}
+
+VALUE
+read_info(struct png_data *reader)
+{
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+    png_read_info(png_ptr, info_ptr);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     Reader.new(string_or_io[, markers]) -> reader
+ *
+ *  Create a new JPEG Reader. string_or_io may be a String or any object that
+ *  responds to read and close.
+ *
+ *  markers should be an array of valid JPEG header marker symbols. Valid
+ *  symbols are :APP0 through :APP15 and :COM.
+ *
+ *  If performance is important, you can avoid reading all header markers by
+ *  supplying an empty array, [].
+ *
+ *  When markers are not specified, we read all known JPEG markers.
+ */
+static VALUE
+initialize(VALUE self, VALUE io)
+{
+    struct png_data *reader;
+
+    Data_Get_Struct(self, struct png_data, reader);
+    raise_if_locked(reader);
+    png_set_read_fn(reader->png_ptr, (void *)io, read_data_fn);
+    reader->io = io;
+    read_info(reader);
+
+    return self;
+}
+
+static int
+get_components(png_structp png_ptr, png_infop info_ptr)
+{
+    switch (png_get_color_type(png_ptr, info_ptr)) {
+    case PNG_COLOR_TYPE_GRAY:       return 1;
+    case PNG_COLOR_TYPE_GRAY_ALPHA: return 2;
+    case PNG_COLOR_TYPE_RGB:        return 3;
+    case PNG_COLOR_TYPE_RGB_ALPHA:  return 4;
+    }
+
+    return 0;
+}
+
+/*
+*  call-seq:
+*     reader.num_components -> number
+*
+*  Retrieve the number of components as stored in the JPEG image.
+*/
+static VALUE
+components(VALUE self)
+{
+    struct png_data *reader;
+    png_structp png_ptr;
+    png_infop info_ptr;
+    int c;
+
+    Data_Get_Struct(self, struct png_data, reader);
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+
+    c = get_components(png_ptr, info_ptr);
+
+    if (c == 0)
+	return Qnil;
+
+    return INT2FIX(c);
+}
+
+static ID
+png_color_type_to_id(png_byte color_type)
+{
+    switch (color_type) {
+    case PNG_COLOR_TYPE_GRAY:       return id_GRAYSCALE;
+    case PNG_COLOR_TYPE_GRAY_ALPHA: return id_GRAYSCALE;
+    case PNG_COLOR_TYPE_RGB:        return id_RGB;
+    case PNG_COLOR_TYPE_RGB_ALPHA:  return id_RGB;
+    }
+
+    rb_raise(rb_eRuntimeError, "PNG Color Type not recognized.");
+}
+
+/*
+ *  call-seq:
+ *     reader.color_model -> symbol
+ *
+ * Returns a symbol representing the color space into which the JPEG will be
+ * transformed as it is read.
+ *
+ * By default this color space is based on Reader#color_space.
+ *
+ * Possible color spaces are: GRAYSCALE, RGB, YCbCr, CMYK, and YCCK. This method
+ * will return nil if the color space is not recognized.
+ */
+static VALUE
+color_model(VALUE self)
+{
+    struct png_data *reader;
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    Data_Get_Struct(self, struct png_data, reader);
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+
+    return ID2SYM(png_color_type_to_id(png_get_color_type(png_ptr, info_ptr)));
+}
+
+static VALUE
+each2(VALUE arg)
+{
+    struct png_data *reader;
+    png_structp png_ptr;
+    png_infop info_ptr;
+    int i, width, height, components, sl_width;
+    VALUE sl;
+
+    reader = (struct png_data *)arg;
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+
+    width = png_get_image_width(png_ptr, info_ptr);
+    height = png_get_image_height(png_ptr, info_ptr);
+    components = get_components(png_ptr, info_ptr);
+    sl_width = width * components;
+
+    for (i = 0; i < height; i++) {
+	sl = rb_str_new(0, sl_width);
+	png_read_row(png_ptr, (png_bytep)RSTRING_PTR(sl), png_bytep_NULL);
+
+	if (rb_block_given_p())
+	    rb_yield(sl);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+each2_ensure(VALUE arg)
+{
+    struct png_data *reader;
+
+    reader = (struct png_data *)arg;
+    reader->locked = 0;
+    reader->needs_reset = 1;
+
+    return Qnil;
+}
+
+static void
+reset_reader(struct png_data *reader)
+{
+    VALUE io;
+
+    io = reader->io;
+    free_png(reader);
+    allocate_png(reader);
+    png_set_read_fn(reader->png_ptr, (void *)io, read_data_fn);
+    reader->io = io;
+    read_info(reader);
+}
+
+/*
+*  call-seq:
+*     reader.each(&block)
+*
+* Iterate over each decoded scanline in the JPEG image.
+*/
+static VALUE
+each(VALUE self)
+{
+    struct png_data *reader;
+
+    Data_Get_Struct(self, struct png_data, reader);
+
+    if (reader->needs_reset)
+	reset_reader(reader);
+
+    raise_if_locked(reader);
+    reader->locked = 1;
+    rb_ensure(each2, (VALUE)reader, each2_ensure, (VALUE)reader);
+
+    return Qnil;
+}
+
+/*
+*  call-seq:
+*     reader.width -> number
+*
+* Retrieve the width of the image as it will be written out. This is primarily
+* affected by scale_num and scale_denom if they are set.
+* 
+* Note that this value is not automatically calculated unless you call
+* Reader#calc_output_dimensions or after Reader#each_scanline has been called.
+*/
+static VALUE
+width(VALUE self)
+{
+    struct png_data *reader;
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    Data_Get_Struct(self, struct png_data, reader);
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+
+    return INT2FIX(png_get_image_width(png_ptr, info_ptr));
+}
+
+/*
+*  call-seq:
+*     reader.height -> number
+*
+* Retrieve the height of the image as it will be written out. This is primarily
+* affected by scale_num and scale_denom if they are set.
+* 
+* Note that this value is not automatically calculated unless you call
+* Reader#calc_output_dimensions or after Reader#each has been called.
+*/
+static VALUE
+height(VALUE self)
+{
+    struct png_data *reader;
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    Data_Get_Struct(self, struct png_data, reader);
+    png_ptr = reader->png_ptr;
+    info_ptr = reader->info_ptr;
+
+    return INT2FIX(png_get_image_height(png_ptr, info_ptr));
+}
+
+void
+Init_png_reader()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    VALUE cPNGReader = rb_define_class_under(mAxon, "PNGReader", rb_cObject);
+    VALUE mImage = rb_define_module_under(mAxon, "Image");
+
+    rb_include_module(cPNGReader, mImage);
+    rb_include_module(cPNGReader, rb_mEnumerable);
+
+    rb_define_alloc_func(cPNGReader, allocate);
+
+    rb_define_method(cPNGReader, "initialize", initialize, 1);
+    rb_define_method(cPNGReader, "color_model", color_model, 0);
+    rb_define_method(cPNGReader, "components", components, 0);
+    rb_define_method(cPNGReader, "width", width, 0);
+    rb_define_method(cPNGReader, "height", height, 0);
+    rb_define_method(cPNGReader, "each", each, 0);
+
+    id_read = rb_intern("read");
+    id_GRAYSCALE = rb_intern("GRAYSCALE");
+    id_RGB = rb_intern("RGB");
+}

data/lib/axon/bilinear_scaler.rb

@@ -0,0 +1,60 @@
+module Axon
+  class BilinearScaler < Scaler
+    include BilinearScaling
+    include Image
+    include Enumerable
+
+    def each
+      source_y = 0
+      destination_y = 0
+      sample_y = 0
+
+      each_scanline_with_next do |sl1, sl2|
+        while sample_y.to_i == source_y
+          yield interpolate_scanline(sl1, sl2, sample_y)
+
+          destination_y += 1
+          sample_y = destination_y / @height_ratio
+        end
+        
+        source_y += 1
+      end
+    end
+
+    private
+
+    # Yields each scanline with the following scanline. The final scanline is
+    # yielded with itself.
+
+    def each_scanline_with_next
+      last_sl = nil
+
+      each_scanline_with_padding do |scanline|
+        yield last_sl, scanline if last_sl
+        last_sl = scanline
+      end
+    end
+
+    # Adds a one pixel padding to the right of the image and one pixel of
+    # padding to the bottom by duplicating the last pixels.
+
+    def each_scanline_with_padding
+      last = nil
+      components = @image.components
+
+      @image.each do |scanline|
+        scanline << scanline[-components, components] # bonus pixel
+        yield scanline
+        last = scanline
+      end
+
+      yield last # bonus scanline
+    end
+  end
+  
+  module Image
+    def scale_bilinear(*args)
+      BilinearScaler.new(self, *args)
+    end
+  end
+end