ruby-vips 0.1.1

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# master
+
+### Changed
+
+* Upgrade spec/* code to latest RSpec  [Stanislaw Pankevich]
+
+### Added
+
+* Added CHANGELOG.md file (thanks to jnicklas/capybara - using the layout of their History.txt) [Stanislaw Pankevich]
+* Added Gemfile with the only 'rspec' dependency. [Stanislaw Pankevich]
+* Added Jeweler Rakefile contents to release ruby-vips as a gem. [Stanislaw Pankevich]
+
+# Before (initial unreleased version 0.1.0)
+
+Long-long history here undocumented...

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.3)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler (~> 1.8.3)
+  rdoc (~> 3.12)
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Timothy Elliott
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+## ruby-vips : A fast image processing extension for Ruby.
+
+note: this fork aims to track the latest stable vips. There are no plans to
+add more features, just to keep it working.
+
+ruby-vips is a ruby extension for [vips](http://www.vips.ecs.soton.ac.uk). It is
+extremely fast and it can process huge images without requiring the entire image
+to be loaded into memory.
+
+ruby-vips allows you to set up pipelines that don't get executed until you
+output the image to disk or to a string. This means you can create,
+manipulate, and pass around Image objects without incurring any memory or CPU
+costs. The image is not actually processed until you write the image to memory
+or to disk.
+
+## Requirements.
+
+  * OS X or Linux
+  * MRI 1.8.6, 1.8.7, 1.9.2 or Rubinius 1.0.1
+  * libvips 7.12.x, 7.20.x, 7.22.x, or 7.23.x
+
+## Installation.
+
+### Ubuntu Prerequisites.
+
+    $ apt-get install libvips-dev
+
+The above installs libvips 7.20.x in Ubuntu 10.04 and 7.12.x in Ubuntu 8.04.
+Though ruby-vips will work with libvips 7.12.x, many features are disabled, and
+there are a few caveats.
+
+### OS X Prerequisites.
+
+    $ brew install vips -HEAD
+
+The above installs libvips 7.22.x
+
+TODO: Describe & test with macports.
+
+### Installing the gem.
+
+```bash
+$ gem install ruby-vips
+```
+
+or include it in Gemfile:
+
+```ruby
+gem 'ruby-vips'
+```
+
+## Documentation.
+
+ruby-vips has [rdoc documentation](http://rubyvips.holymonkey.com).
+
+## Example.
+
+    require 'rubygems'
+    require 'vips'
+    include VIPS
+
+    # Create an image object. It will not actually load the image until needed.
+    im = Image.jpeg('mypic.jpg')
+
+    # Shrink the jpeg by a factor of four when loading -- huge speed and CPU
+    # improvements on large images.
+    im = Image.jpeg('mypic.jpg', :shrink_factor => 4)
+
+    # Add a shrink by a factor of two to the pipeline. This will not actually be
+    # executed yet.
+    im_shrink_by_two = im.shrink(2)
+
+    # Write out the shrunk image to a PNG file. This is where the image is
+    # actually loaded and resized. With images that allow for random access from
+    # the hard drive (VIPS native format, tiled OpenEXR, ppm/pbm/pgm/pfm, tiled
+    # tiff, and RAW images), the entire image is never read into memory.
+    im_shrink_by_two.png('out.png', :interlace => true)
+
+    # All ruby-vips image commands can be chained, so the above sequence could
+    # be written as:
+    Image.jpeg('mypic.jpg', :shrink_factor => 4).shrink(2).png('out.png')
+
+    # The statement above will load the jpeg (pre-shrunk by a factor of four),
+    # shrink the image again by a factor of two, and then save as a png image.
+
+    # If you want to let vips determine file formats, you can use the generic
+    # reader and writer:
+    Image.new('mypic.jpg').shrink(2).write('out.png')
+
+## Why use ruby-vips?
+
+  - It supports over 250 low-level image and color manipulation operations.
+  - Operations are chainable, and do not get executed until the image is sent to
+    an output.
+  - Fastest ruby library for resizing large images. See [benchmarks at the
+    official libvips website](http://www.vips.ecs.soton.ac.uk/index.php?title=Speed_and_Memory_Use).

data/TODO

@@ -0,0 +1,18 @@
+TODO
+* Verify that all memory gets released when vips ops return errors. Namely,
+  make sure that the allocated IMAGEs get released via ruby's free callbacks.
+* Allow for injecting ruby code into an image transformation pipeline (may be
+  slow to call out to ruby with every read, but may be worthwhile for fun custom
+  image processors).
+* Tap into VIPS callback system to allow progress updates, etc.
+* Allow for creating a ruby endpoint to the pipeline could be useful for
+  streaming.
+* Image#to_a
+* look into other.h, audit all libvips methods and make sure they are all
+  implemented
+* JRuby support
+* Optional extensions to core Ruby classes, allowing operations such as
+  [1, 2, 3] & im . This could be optionally enabled by requiring e.g.
+  vips/core_ext
+* Put groups of image operations into modules, breaking docs into themes and
+  possibly allowing for selective loading of image ops.

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require "mkmf"
+
+File::unlink("Makefile") if (File::exist?("Makefile"))
+
+%w{7.28 7.27 7.26 7.24 7.23 7.22 7.20}.each{|x| break if pkg_config("vips-#{x}")}
+
+have_header('vips/vips.h')
+create_makefile('vips_ext')

data/ext/header.c

@@ -0,0 +1,440 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "header.h"
+
+VALUE mVIPSHeader;
+
+static ID id_notset, id_uchar, id_char, id_ushort, id_short, id_uint, id_int,
+	id_float, id_complex, id_double, id_dbcomplex;
+
+ID
+header_band_fmt_to_id(VipsBandFmt band_fmt)
+{
+    switch(band_fmt) {
+        case IM_BANDFMT_NOTSET:    return id_notset;
+        case IM_BANDFMT_UCHAR:     return id_uchar;
+        case IM_BANDFMT_CHAR:      return id_char;
+        case IM_BANDFMT_USHORT:    return id_ushort;
+        case IM_BANDFMT_SHORT:     return id_short;
+        case IM_BANDFMT_UINT:      return id_uint;
+        case IM_BANDFMT_INT:       return id_int;
+        case IM_BANDFMT_FLOAT:     return id_float;
+        case IM_BANDFMT_COMPLEX:   return id_complex; // two floats
+        case IM_BANDFMT_DOUBLE:    return id_double;
+        case IM_BANDFMT_DPCOMPLEX: return id_dbcomplex; // two doubles
+    }
+    return id_notset;
+}
+
+VipsBandFmt
+header_id_to_band_fmt(ID rb)
+{
+    if(rb == id_notset)         return IM_BANDFMT_NOTSET;
+    else if(rb == id_uchar)     return IM_BANDFMT_UCHAR;
+    else if(rb == id_char)      return IM_BANDFMT_CHAR;
+    else if(rb == id_ushort)    return IM_BANDFMT_USHORT;
+    else if(rb == id_short)     return IM_BANDFMT_SHORT;
+    else if(rb == id_uint)      return IM_BANDFMT_UINT;
+    else if(rb == id_int)       return IM_BANDFMT_INT;
+    else if(rb == id_float)     return IM_BANDFMT_FLOAT;
+    else if(rb == id_complex)   return IM_BANDFMT_COMPLEX;
+    else if(rb == id_double)    return IM_BANDFMT_DOUBLE;
+    else if(rb == id_dbcomplex) return IM_BANDFMT_DPCOMPLEX;
+
+    return (VipsBandFmt)NULL;
+}
+
+/*
+ *  call-seq:
+ *     im.x_size -> number
+ *
+ *  Get the width in pixels of the image.
+ */
+
+static VALUE
+header_x_size(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(im->Xsize);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.y_size -> number
+ *
+ *  Get the height in pixels of the image.
+ */
+
+static VALUE
+header_y_size(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(im->Ysize);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.bands -> number
+ *
+ *  Get the number of bands in the image.
+ */
+
+static VALUE
+header_bands(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(im->Bands);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.band_fmt -> band_format_sym
+ *
+ *  Get the band format of the image.
+ */
+
+static VALUE
+header_band_fmt(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return ID2SYM(header_band_fmt_to_id(im->BandFmt));
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.x_res -> number
+ *
+ *  Get the x-resolution of the image.
+ */
+
+static VALUE
+header_x_res(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return rb_float_new(im->Xres);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.y_res -> number
+ *
+ *  Get the y-resolution of the image.
+ */
+
+static VALUE
+header_y_res(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return rb_float_new(im->Yres);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.x_offset -> number
+ *
+ *  Get the x-offset of the image.
+ */
+
+static VALUE
+header_x_offset(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(im->Xoffset);
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     im.y_offset -> number
+ *
+ *  Get the y-offset of the image.
+ */
+
+static VALUE
+header_y_offset(VALUE obj)
+{
+	GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(im->Yoffset);
+
+    return Qnil;
+}
+
+/* VipsImage macros with useful information */
+
+/*
+ *  call-seq:
+ *     im.sizeof_element -> number
+ *
+ *  Returns the size of a single image band item, in bytes.
+ */
+
+static VALUE
+header_sizeof_element(VALUE obj)
+{
+    GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(IM_IMAGE_SIZEOF_ELEMENT(im));
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     im.sizeof_pel -> number
+ *
+ *  Returns the size of a pixel in the image, in bytes.
+ */
+
+static VALUE
+header_sizeof_pel(VALUE obj)
+{
+    GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(IM_IMAGE_SIZEOF_PEL(im));
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    im.sizeof_line -> number
+ *
+ *  Returns the size of all pixels in the row of the image, uncompressed, in
+ *  bytes.
+ */
+
+static VALUE
+header_sizeof_line(VALUE obj)
+{
+    GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(IM_IMAGE_SIZEOF_LINE(im));
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     im.n_elements -> number
+ *
+ *  Returns the number of elements in an image row, i.e. bands * x_size.
+ */
+
+static VALUE
+header_n_elements(VALUE obj)
+{
+    GetImg(obj, data, im);
+
+    if (im)
+        return INT2FIX(IM_IMAGE_N_ELEMENTS(im));
+
+    return Qnil;
+}
+
+static VALUE
+header_meta_get(VALUE obj, const char* name)
+{
+    GetImg(obj, data, im);
+
+    void *buf;
+    size_t len;
+
+    if (im_meta_get_blob(im, name, &buf, &len))
+        return Qnil;
+
+    return rb_tainted_str_new((char *)buf, len);
+}
+
+static VALUE
+header_meta_get_string(VALUE obj, const char* name)
+{
+    GetImg(obj, data, im);
+
+    char *str;
+    VALUE result;
+
+    if (vips_image_get_as_string(im, name, &str))
+        vips_lib_error();
+    result = rb_tainted_str_new(str, strlen(str));
+    g_free(str);
+
+    return result;
+}
+
+static void
+header_meta_set_string(VALUE obj, const char* name, const char* value)
+{
+    GetImg(obj, data, im);
+
+    vips_image_set_string(im, name, value);
+}
+
+static VALUE
+header_meta_p(VALUE obj, const char* name)
+{
+    GetImg(obj, data, im);
+
+    if (im_header_get_typeof(im, name))
+        return Qtrue;
+
+    return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     im.exif -> string
+ *
+ *  Returns a binary string containing the raw exif header data.
+ */
+
+static VALUE
+header_exif(VALUE obj)
+{
+    return header_meta_get(obj, IM_META_EXIF_NAME);
+}
+
+/*
+ *  call-seq:
+ *    im.exif? -> true or false
+ *
+ *  Indicates whether the image has an exif header attached to it.
+ */
+
+static VALUE
+header_exif_p(VALUE obj)
+{
+    return header_meta_p(obj, IM_META_EXIF_NAME);
+}
+
+/*
+ *  call-seq:
+ *     im.icc -> string
+ *
+ *  Returns a binary string containing the raw icc header data.
+ */
+
+static VALUE
+header_icc(VALUE obj)
+{
+    return header_meta_get(obj, IM_META_ICC_NAME);
+}
+
+/*
+ *  call-seq:
+ *     im.icc? -> true or false
+ *
+ *  Indicates whether the image has an icc header attached to it.
+ */
+
+static VALUE
+header_icc_p(VALUE obj)
+{
+    return header_meta_p(obj, IM_META_ICC_NAME);
+}
+
+/*
+ *  call-seq:
+ *     im.get(name) -> string
+ *
+ *  Return metadata item 'name' as a string.
+ */
+
+static VALUE
+header_get(VALUE obj, VALUE name)
+{
+    return header_meta_get_string(obj, StringValuePtr(name));
+}
+
+/*
+ *  call-seq:
+ *     im.set(name, value)
+ *
+ *  Set metadata item 'name' to value.
+ */
+
+static VALUE
+header_set(VALUE obj, VALUE name, VALUE value)
+{
+    header_meta_set_string(obj, 
+                StringValuePtr(name), StringValuePtr(value));
+
+    return Qnil;
+}
+
+/*
+ * The header module holds image header operations that are common to readers,
+ * writers and image objects.
+ */
+
+void
+init_Header()
+{
+    mVIPSHeader = rb_define_module_under(mVIPS, "Header");
+
+    rb_define_method(mVIPSHeader, "x_size", header_x_size, 0);
+    rb_define_method(mVIPSHeader, "y_size", header_y_size, 0);
+    rb_define_method(mVIPSHeader, "bands", header_bands, 0);
+    rb_define_method(mVIPSHeader, "band_fmt", header_band_fmt, 0);
+    rb_define_method(mVIPSHeader, "x_res", header_x_res, 0);
+    rb_define_method(mVIPSHeader, "y_res", header_y_res, 0);
+    rb_define_method(mVIPSHeader, "x_offset", header_x_offset, 0);
+    rb_define_method(mVIPSHeader, "y_offset", header_y_offset, 0);
+    rb_define_method(mVIPSHeader, "sizeof_element", header_sizeof_element, 0);
+    rb_define_method(mVIPSHeader, "sizeof_pel", header_sizeof_pel, 0);
+    rb_define_method(mVIPSHeader, "sizeof_line", header_sizeof_line, 0);
+    rb_define_method(mVIPSHeader, "n_elements", header_n_elements, 0);
+    rb_define_method(mVIPSHeader, "exif", header_exif, 0);
+    rb_define_method(mVIPSHeader, "exif?", header_exif_p, 0);
+    rb_define_method(mVIPSHeader, "icc", header_icc, 0);
+    rb_define_method(mVIPSHeader, "icc?", header_icc_p, 0);
+    rb_define_method(mVIPSHeader, "get", header_get, 1);
+    rb_define_method(mVIPSHeader, "set", header_set, 2);
+
+	id_notset = rb_intern("NOTSET");
+	id_uchar = rb_intern("UCHAR");
+	id_char = rb_intern("CHAR");
+	id_ushort = rb_intern("USHORT");
+	id_short = rb_intern("SHORT");
+	id_uint = rb_intern("UINT");
+	id_int = rb_intern("INT");
+	id_float = rb_intern("FLOAT");
+	id_complex = rb_intern("COMPLEX");
+	id_double = rb_intern("DOUBLE");
+	id_dbcomplex = rb_intern("DBCOMPLEX");
+
+#if 0
+    VALUE mVIPS = rb_define_module("VIPS");
+#endif
+}