ruby-vips 0.3.14 → 1.0.0

data/example/wobble.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby
+
+require 'vips'
+
+image = Vips::Image.new_from_file ARGV[0]
+
+module Vips
+    class Image
+        def wobble
+            # this makes an image where pixel (0, 0) (at the top-left) has 
+            # value [0, 0], and pixel (image.width, image.height) at the 
+            # bottom-right has value [image.width, image.height]
+            index = Vips::Image.xyz width, height 
+
+            # make a version with (0, 0) at the centre, negative values up 
+            # and left, positive down and right
+            centre = index - [width / 2, height / 2]
+
+            # to polar space, so each pixel is now distance and angle in degrees
+            polar = centre.polar
+
+            # scale sin(distance) by 1/distance to make a wavey pattern
+            d = ((polar[0] * 3).sin * 10000) / (polar[0] + 1)
+
+            # and back to rectangular coordinates again to make a set of 
+            # vectors we can apply to the original index image
+            index += d.bandjoin(polar[1]).rect
+
+            # finally, use our modified index image to distort!
+            mapim index 
+        end
+    end
+end
+
+image = image.wobble
+image.write_to_file ARGV[1]

data/lib/vips.rb

@@ -1,16 +1,153 @@
-# 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'
-
-module VIPS
-  class << self
-    def sequential_mode_supported?
-      comp = VIPS::LIB_VERSION_ARRAY <=> [7,28,0]
-      comp >= 0
+# This module provides a set of overrides for the vips image processing library
+# used via the gobject-introspection gem. 
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+# @private
+def log str 
+    if $vips_debug
+        puts str
+    end
+end
+
+# copied from ruby-gnome2/gstreamer/lib/gst.rb without much understanding
+
+require 'pathname'
+require 'gobject-introspection'
+
+# pick up a local girepository/lib in preference to the system one 
+base_dir = Pathname.new(__FILE__).dirname.dirname.expand_path
+vendor_dir = base_dir + "vendor" + "local"
+vendor_bin_dir = vendor_dir + "bin"
+GLib.prepend_dll_path(vendor_bin_dir)
+vendor_girepository_dir = vendor_dir + "lib" + "girepository-1.0"
+GObjectIntrospection.prepend_typelib_path(vendor_girepository_dir)
+
+module Vips
+    # @private
+    LOG_DOMAIN = "VIPS"
+    GLib::Log.set_log_domain(LOG_DOMAIN)
+
+    # about as crude as you could get
+    $vips_debug = false
+
+    # Turn debug logging on and off.
+    #
+    # @param dbg [Boolean] Set true to print debug log messages
+    def self.set_debug dbg 
+        $vips_debug = dbg
+    end
+
+    class << self
+        # @private
+        def const_missing(name)
+            log "Vips::const_missing: #{name}"
+        
+            init()
+            if const_defined?(name)
+                const_get(name)
+            else
+              super
+            end
+        end
+
+        # @private
+        def method_missing(name, *args, &block)
+            log "Vips::method_missing: #{name}, #{args}, #{block}"
+
+            init()
+            if respond_to?(name)
+                __send__(name, *args, &block)
+            else
+                super
+            end
+        end
+
+        # @private
+        def init(*argv)
+            log "Vips::init: #{argv}"
+
+            class << self
+                remove_method(:init)
+                remove_method(:const_missing)
+                remove_method(:method_missing)
+            end
+
+            loader = Loader.new(self, argv)
+            begin
+                loader.load("Vips")
+            rescue 
+                puts "Unable to load Vips"
+                puts "  Check that the vips library has been installed and is"
+                puts "  on your library path."
+                puts "  Check that the typelib `Vips-8.0.typelib` has been "
+                puts "  installed, and that it is on your GI_TYPELIB_PATH."
+                raise
+            end
+
+            require 'vips/error'
+            require 'vips/argument'
+            require 'vips/operation'
+            require 'vips/call'
+            require 'vips/image'
+        end
+    end
+
+    # @private
+    class Loader < GObjectIntrospection::Loader
+        def initialize(base_module, init_arguments)
+            log "Vips::Loader.initialize: #{base_module}, #{init_arguments}"
+
+            super(base_module)
+            @init_arguments = init_arguments
+        end
+
+        private
+        def pre_load(repository, namespace)
+            log "Vips::Loader.pre_load: #{repository}, #{namespace}"
+
+            call_init_function(repository, namespace)
+            define_value_modules
+        end
+
+        def call_init_function(repository, namespace)
+            log "Vips::Loader.call_init_function: #{repository}, #{namespace}"
+
+            # call Vips::init
+            init = repository.find(namespace, "init")
+            succeeded, argv, error = init.invoke(:arguments => [$PROGRAM_NAME])
+
+            # TODO get the vips error buffer
+            raise error unless succeeded
+        end
+
+        def define_value_modules
+            @value_functions_module = Module.new
+            @value_methods_module = Module.new
+            @base_module.const_set("ValueFunctions", @value_functions_module)
+            @base_module.const_set("ValueMethods",   @value_methods_module)
+        end
+
+        def post_load(repository, namespace)
+            log "Vips::Loader.post_load:"
+        end
+
+    end
+end
+
+at_exit {
+        Vips::shutdown if Vips.respond_to? :shutdown
+}
+
+# this makes vips keep a list of all active objects which we can print out
+Vips::leak_set true if $vips_debug
+
+# @private
+def showall 
+    if $vips_debug
+        GC.start 
+        Vips::Object::print_all 
     end
-  end
 end
+

data/lib/vips/access.rb

@@ -0,0 +1,14 @@
+module Vips
+    # The type of access an operation has to supply. 
+    # 
+    # *   `:random` means requests can come in any order. 
+    # 
+    # *   `:sequential` means requests will be top-to-bottom, but with some
+    #     amount of buffering behind the read point for small non-local
+    #     accesses. 
+    #
+    # *   `:sequential_unbuffered` means requests will be strictly
+    #     top-to-bottom with no read-behind. This can save some memory.
+    class Access
+    end
+end

data/lib/vips/align.rb

@@ -0,0 +1,11 @@
+module Vips
+
+    # Various types of alignment. See {Vips::Image.join}, for example.
+    #
+    # * `:low` Align on the low coordinate edge
+    # * `:centre` Align on the centre
+    # * `:high` Align on the high coordinate edge
+
+    class Align
+    end
+end

data/lib/vips/angle.rb

@@ -0,0 +1,12 @@
+module Vips
+
+    # Various fixed 90 degree rotation angles. See {Vips::Image.rot}.
+    #
+    # * `:d0` no rotate
+    # * `:d90` 90 degrees clockwise
+    # * `:d180` 180 degrees 
+    # * `:d270` 90 degrees anti-clockwise
+
+    class Angle
+    end
+end

data/lib/vips/angle45.rb

@@ -0,0 +1,16 @@
+module Vips
+
+    # Various fixed 45 degree rotation angles. See {Vips::Image.rot45}.
+    #
+    # * `:d0` no rotate
+    # * `:d45` 45 degrees clockwise 
+    # * `:d90` 90 degrees clockwise
+    # * `:d135` 135 degrees clockwise
+    # * `:d180` 180 degrees 
+    # * `:d225` 135 degrees anti-clockwise
+    # * `:d270` 90 degrees anti-clockwise
+    # * `:d315` 45 degrees anti-clockwise
+
+    class Angle45
+    end
+end

data/lib/vips/argument.rb

@@ -0,0 +1,163 @@
+
+module Vips
+
+    # This class is used internally to convert Ruby values to arguments to 
+    # libvips operations. 
+    # @private
+    class Argument 
+        attr_reader :op, :name, :flags, :priority, :isset, :prop
+        attr_reader :blurb, :gtype, :type
+
+        # map gobject-introspection's ruby class names to ours
+        @@map_goi_to_vips = {
+            "TrueClass" => "Boolean",
+            "Vips::ArrayDouble" => "Array<Double>",
+            "Vips::ArrayInt" => "Array<Integer>",
+            "Vips::ArrayImage" => "Array<Image>",
+            "Vips::ArrayString" => "Array<String>",
+        }
+
+        def initialize(op, name)
+            @op = op
+            @name = name.tr '-', '_'
+            @prop = op.gtype.to_class.property name
+            @blurb = @prop.blurb
+            @gtype = prop.value_type
+            @flags = op.get_argument_flags name
+            @priority = op.get_argument_priority @name
+            @isset = op.argument_isset @name
+
+            type = GLib::Type[gtype.name].to_class.name
+            type = @@map_goi_to_vips[type] if @@map_goi_to_vips.include? type
+            @type = type
+        end
+
+        private
+
+        def self.imageize match_image, value
+            return value if match_image == nil
+            return value if value.is_a? Vips::Image
+
+            # 2D array values become tiny 2D images
+            if value.is_a? Array and value[0].is_a? Array
+                return Vips::Image.new_from_array value
+            end
+
+            # if there's nothing to match to, we also make a 2D image
+            if match_image == nil
+                return Vips::Image.new_from_array value
+            end
+
+            # we have a 1D array ... use that as a pixel constant and expand 
+            # to match match_image
+            pixel = (Vips::Image.black(1, 1) + value).cast(match_image.format)
+            pixel = pixel.copy :interpretation => match_image.interpretation,
+                :xres => match_image.xres, :yres =>  match_image.yres
+            pixel.embed(0, 0, match_image.width, match_image.height, 
+                        :extend => :copy)
+        end
+
+        # @private
+        class ArrayImageConst < Vips::ArrayImage 
+            def self.new(value)
+                if not value.is_a? Array
+                    value = [value]
+                end
+
+                match_image = value.find {|x| x.is_a? Vips::Image}
+                if match_image == nil
+                    raise Vips::Error, 
+                        "Argument must contain at least one image."
+                end
+
+                value = value.map {|x| Argument::imageize match_image, x}
+
+                # we'd like to just 
+                #   super(value)
+                # to construct, but the gobject-introspection gem does not
+                # support new from object array ... instead, we build in stages
+                array = Vips::ArrayImage.empty
+                value.each {|x| array = array.append(x)}
+
+                return array
+            end
+        end
+
+        # if this gtype needs an array, try to transform the value into one
+        def self.arrayize(gtype, value)
+            arrayize_map = {
+                GLib::Type["VipsArrayDouble"] => Vips::ArrayDouble,
+                GLib::Type["VipsArrayInt"] => Vips::ArrayInt,
+                GLib::Type["VipsArrayImage"] => ArrayImageConst
+            }
+
+            if arrayize_map.has_key? gtype
+                if not value.is_a? Array
+                    value = [value]
+                end
+
+                value = arrayize_map[gtype].new(value)
+            end
+
+            value
+        end
+
+        def self.unwrap value
+            [Vips::Blob, Vips::ArrayDouble, Vips::ArrayImage, 
+                Vips::ArrayInt, Vips::RefString].each do |cls|
+                if value.is_a? cls
+                    value, length = value.get
+
+                    # blobs come from gobject-introspection as arrays ... 
+                    # repack as strings for convenience
+                    if value and cls == Vips::Blob
+                        value = value.pack("C*")
+                    end
+
+                end
+
+            end
+
+            value
+        end
+
+        public
+
+        def set_value(match_image, value)
+            # array-ize
+            value = Argument::arrayize gtype, value
+
+            # blob-ize
+            if gtype.type_is_a? GLib::Type["VipsBlob"]
+                if not value.is_a? Vips::Blob
+                    value = Vips::Blob.copy value
+                end
+            end
+
+            # image-ize
+            if gtype.type_is_a? GLib::Type["VipsImage"]
+                if not value.is_a? Vips::Image
+                    value = Argument::imageize match_image, value
+                end
+            end
+
+            # MODIFY input images need to be copied before assigning them
+            if (flags & :modify) != 0
+                # don't use .copy(): we want to make a new pipeline with no
+                # reference back to the old stuff ... this way we can free the
+                # previous image earlier 
+                new_image = Vips::Image.memory
+                value.write new_image
+                value = new_image
+            end
+
+            op.set_property @name, value
+        end
+
+        def get_value
+            Argument::unwrap @op.get_property(@name)
+        end
+
+    end
+
+end

data/lib/vips/bandformat.rb

@@ -0,0 +1,20 @@
+module Vips
+
+    # The format used for each band element. Each corresponds to a native C type
+    # for the current machine.
+    #
+    # * `:notset` invalid setting
+    # * `:uchar` unsigned char format
+    # * `:char` char format
+    # * `:ushort` unsigned short format
+    # * `:short` short format
+    # * `:uint` unsigned int format
+    # * `:int` int format
+    # * `:float` float format
+    # * `:complex` complex (two floats) format
+    # * `:double` double float format
+    # * `:dpcomplex` double complex (two double) format
+    class BandFormat
+    end
+
+end