ruby-vips 0.1.1

data/ext/ruby_vips.h

@@ -0,0 +1,26 @@
+#ifndef RUBY_VIPS_H
+#define RUBY_VIPS_H
+
+#include "ruby.h"
+#include "vips/vips.h"
+
+extern VALUE mVIPS, eVIPSError;
+
+void vips_lib_error();
+
+/* Backports from ruby 1.9.2 for ruby 1.8.7
+ */
+
+#ifndef DBL2NUM
+#define DBL2NUM(dbl) rb_float_new(dbl)
+#endif
+
+#ifndef RARRAY_LENINT
+#define RARRAY_LENINT(ary) RARRAY_LEN(ary)
+#endif
+
+#ifndef rb_str_new_cstr
+#define rb_str_new_cstr(str) rb_str_new(str, (long)strlen(str))
+#endif
+
+#endif

data/ext/writer.c

@@ -0,0 +1,346 @@
+#include "ruby_vips.h"
+#include "image.h"
+#include "header.h"
+
+/* :nodoc: */
+
+static VALUE
+writer_initialize(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE image, opts;
+	rb_scan_args(argc, argv, "11", &image, &opts);
+    GetImg(image, data, im);
+    GetImg(obj, data_new, im_new);
+
+    img_add_dep(data_new, image);
+    if (im_copy(im, im_new))
+        vips_lib_error();
+
+    return obj;
+}
+
+/*
+ *  call-seq:
+ *     writer.image -> image
+ * 
+ *  Returns the image associated with *self*.
+ */
+
+static VALUE
+writer_image(VALUE obj)
+{
+    GetImg(obj, data, im);
+
+    if(data->deps)
+        return data->deps[0];
+
+    return Qnil;
+}
+
+static VALUE
+writer_meta_set(VALUE obj, const char* name, VALUE str)
+{
+    GetImg(obj, data, im);
+
+	size_t len = RSTRING_LEN(str);
+    void *buf = malloc(len);
+    memcpy(buf, RSTRING_PTR(str), len);
+
+    if (im_meta_set_blob(im, name, (im_callback_fn)xfree, buf, len)) {
+        xfree(buf);
+        vips_lib_error();
+    }
+
+    return str;
+}
+
+static VALUE
+writer_meta_remove(VALUE obj, const char* name)
+{
+    GetImg(obj, data, im);
+#if IM_MAJOR_VERSION > 7 || IM_MINOR_VERSION >= 22
+	if (im_meta_remove(im, name))
+		return Qfalse;
+#else
+    rb_raise(eVIPSError, "This method is not implemented in your version of VIPS");
+#endif
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     writer.exif = exif_data
+ *
+ *  Sets the exif header of the writer to <i>exif_data</i>. This will be
+ *  written only if the file format supports embedded exif data.
+ *
+ */
+
+static VALUE
+writer_exif_set(VALUE obj, VALUE str)
+{
+    return writer_meta_set(obj, IM_META_EXIF_NAME, str);
+}
+
+/*
+ *  call-seq:
+ *     writer.remove_exif -> true or false
+ *
+ *  Removes exif data associated with *self*.
+ */
+
+static VALUE
+writer_remove_exif(VALUE obj)
+{
+    return writer_meta_remove(obj, IM_META_EXIF_NAME);
+}
+
+/*
+ *  call-seq:
+ *     writer.icc = icc_data
+ *
+ *  Sets the icc header of the writer to <i>icc_data</i>. This will be written
+ *  only if the file format supports embedded icc data.
+ *
+ */
+
+static VALUE
+writer_icc_set(VALUE obj, VALUE str)
+{
+    return writer_meta_set(obj, IM_META_ICC_NAME, str);
+}
+
+/*
+ *  call-seq:
+ *     writer.remove_icc -> true or false
+ *
+ *  Removes icc data associated with *self*.
+ */
+
+static VALUE
+writer_remove_icc(VALUE obj)
+{
+    return writer_meta_remove(obj, IM_META_ICC_NAME);
+}
+
+/* :nodoc: */
+
+static VALUE
+writer_write_internal(VALUE obj, VALUE path)
+{
+    VipsImage *out;
+    GetImg(obj, data, im);
+
+    if (!(out = im_open(StringValuePtr(path), "w")) || im_copy(im, out))
+        vips_lib_error();
+
+    im_close(out);
+
+    return obj;
+}
+
+/* :nodoc: */
+
+static VALUE
+jpeg_buf_internal(VALUE obj, VALUE quality)
+{
+    VipsImage *im_out;
+    char *buf = NULL;
+    int length;
+    VALUE str;
+
+    GetImg(obj, data, im);
+
+    if (!(im_out = im_open("writer_jpeg_buf", "p")))
+        vips_lib_error();
+
+    if (im_vips2bufjpeg(im, im_out, NUM2INT(quality), &buf, &length)) {
+		im_close(im_out);
+        vips_lib_error();
+	}
+
+    str = rb_tainted_str_new(buf, length);
+    im_close(im_out);
+
+    return str;
+}
+
+/* :nodoc: */
+
+static VALUE
+jpeg_write_internal(VALUE obj, VALUE path)
+{
+    GetImg(obj, data, im);
+
+    if (im_vips2jpeg(im, RSTRING_PTR(path)))
+        vips_lib_error();
+
+    return obj;
+}
+
+/* :nodoc: */
+
+static VALUE
+tiff_write_internal(VALUE obj, VALUE path)
+{
+    GetImg(obj, data, im);
+
+    if (im_vips2tiff(im, RSTRING_PTR(path)))
+        vips_lib_error();
+
+    return obj;
+}
+
+/* :nodoc: */
+
+static VALUE
+ppm_write_internal(VALUE obj, VALUE path)
+{
+    GetImg(obj, data, im);
+
+    if (im_vips2ppm(im, RSTRING_PTR(path)))
+        vips_lib_error();
+
+    return obj;
+}
+
+/* :nodoc: */
+
+static VALUE
+png_buf_internal(VALUE obj, VALUE compression, VALUE interlace)
+{
+#if IM_MAJOR_VERSION > 7 || IM_MINOR_VERSION >= 23
+    VipsImage *im_out;
+    char *buf;
+    size_t length;
+    GetImg(obj, data, im);
+
+    if (!(im_out = im_open("writer_png_buf", "p")))
+        vips_lib_error();
+
+    if (im_vips2bufpng(im, im_out, NUM2INT(compression), NUM2INT(interlace),
+        &buf, &length)) {
+        im_close(im_out);
+        vips_lib_error();
+	}
+
+    im_close(im_out);
+
+    return rb_tainted_str_new(buf, length);
+#else
+    rb_raise(eVIPSError, "This method is not implemented in your version of VIPS");
+#endif
+}
+
+/* :nodoc: */
+
+static VALUE
+png_write_internal(VALUE obj, VALUE path)
+{
+    GetImg(obj, data, im);
+
+    if (im_vips2png(im, RSTRING_PTR(path)))
+        vips_lib_error();
+
+    return obj;
+}
+
+/* :nodoc: */
+
+static VALUE
+csv_write_internal(VALUE obj, VALUE path)
+{
+    GetImg(obj, data, im);
+
+    if (im_vips2csv(im, RSTRING_PTR(path)))
+        vips_lib_error();
+
+    return obj;
+}
+
+/* :nodoc: */
+
+static VALUE
+vips_write_internal(VALUE obj, VALUE path)
+{
+    VipsImage *im_new;
+    GetImg(obj, data, im);
+
+    if (!(im_new = (VipsImage *)im_openout(RSTRING_PTR(path))))
+        vips_lib_error();
+
+    if (im_copy(im, im_new))
+        vips_lib_error();
+
+    im_close(im_new);
+
+    return obj;
+}
+
+/*
+ *  Base class for image format readers.
+ */
+
+void
+init_Writer()
+{
+    VALUE writer = rb_define_class_under(mVIPS, "Writer", rb_cObject);
+
+    rb_include_module(writer, mVIPSHeader);
+    rb_define_alloc_func(writer, img_init_partial_anyclass);
+    rb_define_method(writer, "initialize", writer_initialize, -1);
+    rb_define_method(writer, "image", writer_image, 0);
+    rb_define_method(writer, "exif=", writer_exif_set, 1);
+    rb_define_method(writer, "remove_exif", writer_remove_exif, 0);
+    rb_define_method(writer, "icc=", writer_icc_set, 1);
+    rb_define_method(writer, "remove_icc", writer_remove_icc, 0);
+    rb_define_private_method(writer, "write_internal", writer_write_internal, 1);
+
+    /*
+     * Write JPEG images.
+     */
+
+    VALUE jpeg_writer = rb_define_class_under(mVIPS, "JPEGWriter", writer);
+    rb_define_private_method(jpeg_writer, "buf_internal", jpeg_buf_internal, 1);
+    rb_define_private_method(jpeg_writer, "write_internal", jpeg_write_internal, 1);
+
+    /*
+     * Write TIFF images.
+     */
+
+    VALUE tiff_writer = rb_define_class_under(mVIPS, "TIFFWriter", writer);
+    rb_define_private_method(tiff_writer, "write_internal", tiff_write_internal, 1);
+
+    /*
+     * Write PPM images.
+     */
+
+    VALUE ppm_writer = rb_define_class_under(mVIPS, "PPMWriter", writer);
+    rb_define_private_method(ppm_writer, "write_internal", ppm_write_internal, 1);
+
+    /*
+     * Write PNG images.
+     */
+
+    VALUE png_writer = rb_define_class_under(mVIPS, "PNGWriter", writer);
+    rb_define_private_method(png_writer, "write_internal", png_write_internal, 1);
+    rb_define_private_method(png_writer, "buf_internal", png_buf_internal, 2);
+
+    /*
+     * Write CSV images.
+     */
+
+    VALUE csv_writer = rb_define_class_under(mVIPS, "CSVWriter", writer);
+    rb_define_private_method(csv_writer, "write_internal", csv_write_internal, 1);
+
+    /*
+     * Write native VIPS images.
+     */
+
+    VALUE vips_writer = rb_define_class_under(mVIPS, "VIPSWriter", writer);
+    rb_define_private_method(vips_writer, "write_internal", vips_write_internal, 1);
+
+#if 0
+    VALUE mVIPS = rb_define_module("VIPS");
+#endif
+}

data/lib/vips.rb

@@ -0,0 +1,7 @@
+# Vips will print warnings to stdout unless this is set
+ENV['IM_WARNING'] = "0"
+
+require 'vips_ext'
+require 'vips/version'
+require 'vips/reader'
+require 'vips/writer'

data/lib/vips/reader.rb

@@ -0,0 +1,183 @@
+module VIPS
+  class Reader
+    attr_reader :path
+
+    def initialize(path, options={})
+      @path = path
+      read_header path unless options[:skip_header]
+    end
+
+    def self.read(path, options={})
+      options[:skip_header] = true
+      reader = new path, options
+      reader.read
+    end
+
+    def read
+      read_internal @path
+    end
+  end
+
+  class CSVReader < Reader
+    attr_reader :line_skip, :line_limit
+    attr_accessor :whitespace, :separator
+
+    # Creates a CSV reader.
+    def initialize(path, options={})
+      @line_skip = 0
+      @whitespace = ' "'
+      @separator = ";,\t"
+      @line_limit = 0
+
+      self.line_skip = options[:line_skip] if options.has_key?(:line_skip)
+      self.whitespace = options[:whitespace] if options.has_key?(:whitespace)
+      self.separator = options[:separator] if options.has_key?(:separator)
+      self.line_limit = options[:line_limit] if options.has_key?(:line_limit)
+
+      super path, options
+    end
+
+    # Read the CSV file and return a VIPS Image object.
+    def read
+      str = "#{@path}:ski:#{@line_skip},whi:#{@whitespace}"
+      str << ",lin:#{@line_limit == 0 ? -1 : @line_limit}"
+
+      # VIPS magic open path limitation/bug -- we cannot specify the comma char
+      str << ",sep:#{@separator}" unless @separator[/,/]
+      read_internal str
+    end
+
+    # Set the number of lines to skip at the beginning of the file.
+    def line_skip=(line_skip_v)
+      if line_skip_v < 0
+        raise ArgumentError, "Line skip must be 0 or more."
+      end
+
+      @line_skip = line_skip_v
+    end
+
+    # Set a limit of how many lines to read in.
+    def line_limit=(line_limit_v)
+      if line_limit_v < 0
+        raise ArgumentError, "Line limit must be 0 (read all) or more."
+      end
+
+      @line_limit = line_limit_v
+    end
+  end
+
+  class JPEGReader < Reader
+    attr_reader :shrink_factor
+    attr_accessor :fail_on_warn
+
+    SHRINK_FACTOR = [1, 2, 4, 8]
+
+    # Creates a jpeg image file reader.
+    def initialize(path, options={})
+      @shrink_factor = 1
+      @fail_on_warn = false
+
+      self.shrink_factor = options[:shrink_factor] if options.has_key?(:shrink_factor)
+      self.fail_on_warn = options[:fail_on_warn] if options.has_key?(:fail_on_warn)
+
+      super path, options
+    end
+
+    # Read the jpeg file from disk and return a VIPS Image object.
+    def read
+      str = "#{@path}:#{shrink_factor}"
+      str << ",fail" if @fail_on_warn
+
+      read_internal str
+    end
+
+    # Shrink the jpeg while reading from disk. This means that the entire image
+    # never has to be loaded in memory. Shrink factor can be 1 (no shrink), 2,
+    # 4, or 8.
+    def shrink_factor=(shrink_factor_v)
+      unless SHRINK_FACTOR.include?(shrink_factor_v)
+        raise ArgumentError, "Shrink factor must be one of: #{SHRINK_FACTOR.join ', '}."
+      end
+
+      @shrink_factor = shrink_factor_v
+    end
+  end
+
+  class TIFFReader < Reader
+    attr_reader :page_number
+
+    # Create a tiff image file reader.
+    def initialize(path, options={})
+      self.page_number = options[:page_number] if options.has_key?(:page_number)
+      super path, options
+    end
+
+    # Read the tiff file from disk and return a VIPS Image object.
+    def read
+      str = @path
+      str << ":#{@page_number}" if @page_number
+
+      read_internal str
+    end
+
+    # Select which page in a multiple-page tiff to read. When set to nil, all
+    # pages are read as a single image.
+    def page_number=(page_number_v)
+      unless page_number_v.nil? || page_number_v > 0
+        raise ArgumentError, "Page number has to be nil or larger than zero."
+      end
+
+      @page_number = page_number_v
+    end
+  end
+
+  class Image
+
+    # Load a ppm file straight to a VIPS Image.
+    def self.ppm(*args)
+      PPMReader.read *args
+    end
+
+    # Load an exr file straight to a VIPS Image.
+    def self.exr(*args)
+      EXRReader.read *args
+    end
+
+    # Load a csv file straight to a VIPS Image.
+    def self.csv(*args)
+      CSVReader.read *args
+    end
+
+    # Load a jpeg file straight to a VIPS Image.
+    def self.jpeg(*args)
+      JPEGReader.read *args
+    end
+
+    # Load a file straight to a VIPS Image using the magick library.
+    def self.magick(*args)
+      MagickReader.read *args
+    end
+
+    # Load a png file straight to a VIPS Image.
+    def self.png(*args)
+      PNGReader.read *args
+    end
+
+    # Load a tiff file straight to a VIPS Image.
+    def self.tiff(*args)
+      TIFFReader.read *args
+    end
+
+    # Load a native vips file straight to a VIPS Image.
+    def self.vips(*args)
+      VIPSReader.read *args
+    end
+
+    # Load any file straight to a VIPS Image. VIPS will determine the format
+    # based on the file extension. If the extension is not recognized, VIPS
+    # will look at the file signature.
+    def self.new(*args)
+      Reader.read *args
+    end
+  end
+end