devil 0.1.7-x86-mswin32-60 → 0.1.8-x86-mswin32-60

data/ext/devil/ruby_ilu.c

@@ -103,17 +103,66 @@ static VALUE ilu_Rotate(VALUE obj, VALUE rb_angle) {
     return flag ? Qtrue : Qfalse;
 }
 
-static VALUE ilu_Crop(VALUE obj, VALUE rb_XOff, VALUE rb_YOff, VALUE rb_width, VALUE rb_height)
+static VALUE ilu_Crop(VALUE obj, VALUE rb_XOff, VALUE rb_YOff, VALUE rb_ZOff, VALUE rb_width, VALUE rb_height, VALUE rb_depth)
 {
     ILuint XOff = NUM2INT(rb_XOff);
     ILuint YOff = NUM2INT(rb_YOff);
+    ILuint ZOff = NUM2INT(rb_ZOff);
     ILuint width = NUM2INT(rb_width);
     ILuint height = NUM2INT(rb_height);
+    ILuint depth = NUM2INT(rb_depth);
                        	
-    ILboolean flag = iluCrop(XOff, YOff, 1, width, height, 1);
+    ILboolean flag = iluCrop(XOff, YOff, ZOff, width, height, depth);
 
     return flag ? Qtrue : Qfalse;
 }
+
+static VALUE ilu_EnlargeCanvas(VALUE obj, VALUE rb_width, VALUE rb_height, VALUE rb_depth)
+{
+    ILuint width = NUM2INT(rb_width);
+    ILuint height = NUM2INT(rb_height);
+    ILuint depth = NUM2INT(rb_depth);
+
+    ILboolean flag = iluEnlargeCanvas(width, height, depth);
+
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_EdgeDetectP(VALUE obj)
+{
+    ILboolean flag = iluEdgeDetectP();
+
+    return flag ? Qtrue : Qfalse;    
+}
+
+static VALUE ilu_EdgeDetectS(VALUE obj)
+{
+    ILboolean flag = iluEdgeDetectS();
+
+    return flag ? Qtrue : Qfalse;    
+}
+
+static VALUE ilu_Emboss(VALUE obj)
+{
+    ILboolean flag = iluEmboss();
+
+    return flag ? Qtrue : Qfalse;    
+}
+
+static VALUE ilu_Mirror(VALUE obj)
+{
+    ILboolean flag = iluMirror();
+
+    return flag ? Qtrue : Qfalse;    
+}
+
+static VALUE ilu_SwapColours(VALUE obj)
+{
+    ILboolean flag = iluSwapColours();
+
+    return flag ? Qtrue : Qfalse;    
+}
+
 /* end of functions added by banisterfiend */
 
 void
@@ -138,9 +187,16 @@ InitializeILU() {
     /* methods added by banisterfiend */
     rb_define_module_function(mILU, "FlipImage",  ilu_FlipImage, 0);
     rb_define_module_function(mILU, "Rotate",  ilu_Rotate, 1);
-    rb_define_module_function(mILU, "Crop",  ilu_Crop, 4);
+    rb_define_module_function(mILU, "Crop",  ilu_Crop, 6);
+    rb_define_module_function(mILU, "EnlargeCanvas",  ilu_EnlargeCanvas, 3);
+    rb_define_module_function(mILU, "EdgeDetectP", ilu_EdgeDetectP, 0);
+    rb_define_module_function(mILU, "EdgeDetectS", ilu_EdgeDetectS, 0);
+    rb_define_module_function(mILU, "Emboss", ilu_Emboss, 0);
+    rb_define_module_function(mILU, "Mirror", ilu_Mirror, 0);
+    rb_define_module_function(mILU, "SwapColours", ilu_SwapColours, 0);
     /* end of functions added by banisterfiend */
 
+    /* constants added by banisterfiend */
     rb_define_const(mILU, "FILTER", INT2NUM(ILU_FILTER));
     rb_define_const(mILU, "NEAREST", INT2NUM(ILU_NEAREST));
     rb_define_const(mILU, "LINEAR", INT2NUM(ILU_LINEAR));
@@ -151,4 +207,13 @@ InitializeILU() {
     rb_define_const(mILU, "SCALE_BSPLINE", INT2NUM(ILU_SCALE_BSPLINE));
     rb_define_const(mILU, "SCALE_LANCZOS3", INT2NUM(ILU_SCALE_LANCZOS3));
     rb_define_const(mILU, "SCALE_MITCHELL", INT2NUM(ILU_SCALE_MITCHELL));
+
+    rb_define_const(mILU, "PLACEMENT", INT2NUM(ILU_PLACEMENT));
+    rb_define_const(mILU, "UPPER_LEFT", INT2NUM(ILU_UPPER_LEFT));
+    rb_define_const(mILU, "LOWER_LEFT", INT2NUM(ILU_LOWER_LEFT));
+    rb_define_const(mILU, "LOWER_RIGHT", INT2NUM(ILU_LOWER_RIGHT));
+    rb_define_const(mILU, "UPPER_RIGHT", INT2NUM(ILU_UPPER_RIGHT));
+    rb_define_const(mILU, "CENTER", INT2NUM(ILU_CENTER));
+    /* end of constants added by banisterfiend */
+
 }

data/lib/devil.rb

@@ -1,235 +1,371 @@
-require 'rbconfig'
-
-direc = File.dirname(__FILE__)
-dlext = Config::CONFIG['DLEXT']
-begin
-    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
-        require "#{direc}/1.9/devil.#{dlext}"
-    else
-        require "#{direc}/1.8/devil.#{dlext}"
-    end
-rescue LoadError => e
-    require "#{direc}/devil.#{dlext}"
-end
-
-# Provides a high level wrapper for the low-level DevIL Ruby bindings
-module Devil
-    VERSION = '0.1.7'
-    
-    class << self
-
-        # loads +file+ and returns a new image
-        # Optionally accepts a block and yields the newly created image to the block.
-        def load_image(file, &block)
-            name = IL.GenImages(1).first
-            IL.BindImage(name)
-            IL.LoadImage(file)
-
-            if (error_code = IL.GetError) != IL::NO_ERROR
-                raise RuntimeError, "an error occured while trying to "+
-                    "load the image #{file}. Error code: #{error_code}"
-            end
-
-            img = Image.new(name, file)
-            if block
-                block.call(img)
-            end
-            
-            img
-        end
-
-        alias_method :with_image, :load_image
-        alias_method :load, :load_image
-
-        # convert an image +blob+ with +width+ and +height+
-        # to a bona fide image
-        def from_blob(blob, width, height)
-            Image.new(IL.FromBlob(blob, width, height), nil)
-        end
-
-        # initializes Devil and sets defaults
-        # This method should never need to be called directly.
-        def init
-            # initialize DevIL
-            IL.Init
-
-            # default options
-            IL.Enable(IL::FILE_OVERWRITE)
-            ILU.ImageParameter(ILU::FILTER, ILU::BILINEAR) 
-        end
-
-    end
-
-    class Image
-        attr_reader :name, :file
-
-        def initialize(name, file)
-            @name = name
-            @file = file
-
-            ObjectSpace.define_finalizer( self, proc { IL.DeleteImages(1, [name]) } )
-        end
-        
-        # returns the width of the image
-        def width
-            set_binding
-            IL.GetInteger(IL::IMAGE_WIDTH)
-        end
-
-        alias_method :columns, :width
-
-        # returns the height of the image
-        def height
-            set_binding
-            IL.GetInteger(IL::IMAGE_HEIGHT)
-        end
-
-        alias_method :rows, :height
-
-        # saves the image to +file+. If no +file+ is provided default to the opened file.
-        def save(file = @file)
-            set_binding
-            IL.SaveImage(file)
-            self
-        end
-        
-        # resize the image to +width+ and +height+. Aspect ratios of the image do not have to be the same.
-        def resize(width, height)
-            set_binding
-            ILU.Scale(width, height, 1)
-            self
-        end
-
-        # Creates a proportional thumbnail of the image scaled so its longest
-        # edge is resized to +size+ 
-        def thumbnail(size)
-            # this thumbnail code from image_science.rb
-            
-            w, h = width, height
-            scale = size.to_f / (w > h ? w : h)
-            resize((w * scale).to_i, (h * scale).to_i)
-            self
-        end
-
-        # return a deep copy of the current image
-        def dup
-            set_binding
-            Image.new(IL.CloneCurImage, nil)
-        end
-
-        alias_method :clone, :dup
-
-        # crop the current image
-        # +xoff+ number of pixels to skip in x direction
-        # +yoff+ number of pixels to skip in y direction
-        # +width+ number of pixels to preserve in x direction
-        # +height+ number of pixels to preserve in y direction
-        def crop(xoff, yoff, width, height)
-            set_binding
-            ILU.Crop(xoff, yoff, width, height)
-            self
-        end
-
-        # performs a gaussian blur on the image. The blur is performed +iter+ times.
-        def blur(iter)
-            set_binding
-            ILU.BlurGaussian(iter)
-            self
-        end
-
-        # 'pixelize' the image using a pixel size of +pixel_size+
-        def pixelize(pixel_size)
-            set_binding
-            ILU.Pixelize(pixel_size)
-            self
-        end
-
-        # add random noise to the image. +factor+ is the tolerance to use.
-        # accepeted values range from 0.0 - 1.0
-        def noisify(factor)
-            set_binding
-            ILU.Noisify(factor)
-            self
-        end
-
-        # The sharpening +factor+ must be in the range of 0.0 - 2.5. A value of 1.0 for the sharpening
-        # factor will have no effect on the image. Values in the range 1.0 - 2.5 will sharpen the
-        # image, with 2.5 having the most pronounced sharpening effect. Values from 0.0 to 1.0 do
-        # a type of reverse sharpening, blurring the image. Values outside of the 0.0 - 2.5 range
-        # produce undefined results.
-        #        
-        # The number of +iter+ (iterations) to perform will usually be 1, but to achieve more sharpening,
-        # increase the number of iterations. 
-        def sharpen(factor, iter)
-            set_binding
-            ILU.Sharpen(factor, iter)
-            self
-        end
-
-        # applies gamma correction to an image using an exponential curve.
-        # +factor+ is gamma correction factor to use.
-        # A value of 1.0 leaves the image unmodified.
-        # Values in the range 0.0 - 1.0 darken the image
-        # Values above 1.0 brighten the image.
-        def gamma_correct(factor)
-            set_binding
-            ILU.GammaCorrect(factor)
-            self
-        end
-
-        # invert the color of every pixel in the image.
-        def negative
-            set_binding
-            ILU.Negative
-            self
-        end
-
-        # +factor+ describes desired contrast to use
-        # A value of 1.0 has no effect on the image.
-        # Values between 1.0 and 1.7 increase the amount of contrast (values above 1.7 have no effect)
-        # Valid range of +factor+ is 0.0 - 1.7
-        def contrast(factor)
-            set_binding
-            ILU.Contrast(factor)
-            self
-        end
-
-        # darkens the bright colours and lightens the dark
-        # colours, reducing the contrast in an image or 'equalizing' it.
-        def equalize
-            set_binding
-            ILU.Equalize
-            self
-        end
-
-        # returns the image data in the form of a ruby string
-        # The image data is formatted to RGBA / UNSIGNED BYTE
-        def to_blob
-            set_binding
-            IL.ToBlob
-        end
-
-        # flip the image about its x axis
-        def flip
-            set_binding
-            ILU.FlipImage
-            self
-        end
-
-        # rotate an image about its central point by +angle+ degrees
-        def rotate(angle)
-            set_binding
-            ILU.Rotate(angle)
-            self
-        end
-
-        private
-        
-        def set_binding
-            IL.BindImage(@name)
-        end
-
-    end
-end
-
-Devil.init
+# (C) John Mair 2009, under the MIT licence
+
+require 'rbconfig'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/devil.#{dlext}"
+    else
+        require "#{direc}/1.8/devil.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/devil.#{dlext}"
+end
+
+# Provides a high level wrapper for the low-level DevIL Ruby bindings
+module Devil
+    include IL
+    include ILU
+
+    VERSION = '0.1.8'
+    
+    class << self
+
+        # loads +file+ and returns a new image
+        # Optionally accepts a block and yields the newly created image to the block.
+        def load_image(file, &block)
+            name = IL.GenImages(1).first
+            IL.BindImage(name)
+            IL.LoadImage(file)
+
+            if (error_code = IL.GetError) != IL::NO_ERROR
+                raise RuntimeError, "an error occured while trying to "+
+                    "load the image #{file}. #{ILU.ErrorString(error_code)}"
+            end
+
+            img = Image.new(name, file)
+            if block
+                block.call(img)
+            end
+            
+            img
+        end
+
+        alias_method :with_image, :load_image
+        alias_method :load, :load_image
+        
+        # convert an image +blob+ with +width+ and +height+
+        # to a bona fide image
+        def from_blob(blob, width, height)
+            Image.new(IL.FromBlob(blob, width, height), nil)
+        end
+
+        # configure Devil.
+        # accepts hash parameters: :scale_filter, :placement, :clear_color,
+        # :window_size, :edge_filter.
+        #
+        # :scale_filter accepts a valid scaling algorithm: (default is LANCZOS3).
+        # Devil::NEAREST, Devil::LINEAR, Devil::BILINEAR, Devil::SCALE_BOX,
+        # Devil::SCALE_TRIANGLE, Devil::SCALE_BELL, Devil::SCALE_BSPLINE,
+        # Devil::SCALE_LANCZOS3, Devil::SCALE_MITCHELL
+        #
+        # :placement determines where in the canvas the image will be placed after
+        # the canvas has been enlarged using the 'enlarge_canvas' method.
+        # Valid parameters are: Devil::CENTER, Devil::LOWER_LEFT, Devil::UPPER_RIGHT, etc
+        #
+        # :clear_color  sets the current clearing colour to be used by future
+        # calls to clear. rotate and enlarge_canvas both use these values to
+        # clear blank space in images, too.
+        # e.g Devil.set_options(:clear_color => [255, 255, 0, 255])
+        # Above sets the clear color to yellow with full opacity.
+        #
+        # :window_size sets the display window size Gosu will use when displaying images
+        # that invoked the 'show' method. (default is 1024 x 768)
+        # e.g Devil.set_options(:window_size => [2000, 768])
+        # Example above sets a window size of 2000x768.
+        # Note: :window_size is only relevant when require 'devil/gosu' is used.
+        #
+        # :edge_filter sets the edge detection algorithm to use when invoking
+        # the 'edge_detect' method. (defaults to :prewitt)
+        # Allowed values are :prewitt and :sobel
+        def set_options(options={})
+            @options.merge!(options)
+
+            # update the scale_filter 
+            ILU.ImageParameter(ILU::FILTER, @options[:scale_filter])
+            ILU.ImageParameter(ILU::PLACEMENT, @options[:placement])
+            IL.ClearColour(*@options[:clear_color])
+        end
+
+        # return the current Devil configuration.
+        def get_options
+            @options
+        end
+
+        # initializes Devil and sets defaults.
+        # This method should never need to be called directly.
+        def init
+            # initialize DevIL
+            IL.Init
+            ILU.Init
+
+            set_option_defaults
+        end
+
+        private
+        
+        def set_option_defaults
+            @options = {
+                :scale_filter => ILU::SCALE_LANCZOS3,
+                :edge_filter => :prewitt,
+                :window_size => [1024, 768],
+                :clear_color => [255, 248, 230, 0],
+                :placement => ILU::CENTER,
+            }
+            
+            # configurable options
+            ILU.ImageParameter(ILU::FILTER, @options[:scale_filter])
+            ILU.ImageParameter(ILU::PLACEMENT, @options[:placement])
+            IL.ClearColour(*@options[:clear_color])
+
+            # fixed options
+            IL.Enable(IL::FILE_OVERWRITE)
+        end
+    end
+ 
+    class Image
+        attr_reader :name, :file
+
+        def initialize(name, file)
+            @name = name
+            @file = file
+
+            ObjectSpace.define_finalizer( self, proc { IL.DeleteImages(1, [name]) } )
+        end
+        
+        # returns the width of the image.
+        def width
+            action { IL.GetInteger(IL::IMAGE_WIDTH) }
+        end
+
+        alias_method :columns, :width
+
+        # returns the height of the image.
+        def height
+            action { IL.GetInteger(IL::IMAGE_HEIGHT) }
+        end
+
+        alias_method :rows, :height
+
+        # saves the image to +file+. If no +file+ is provided default to the opened file.
+        def save(file = @file)
+            raise "This image does not have an associated file. Please provide an explicit file name when saving." if !file
+            
+            action { IL.SaveImage(file) }
+            self
+        end
+        
+        # resize the image to +width+ and +height+. Aspect ratios of the image do not have to be the same.
+        def resize(width, height)
+            action { ILU.Scale(width, height, 1) }
+            self
+        end
+
+        # Creates a proportional thumbnail of the image scaled so its longest.
+        # edge is resized to +size+.
+        def thumbnail(size)
+
+            # this thumbnail code from image_science.rb
+            w, h = width, height
+            scale = size.to_f / (w > h ? w : h)
+            resize((w * scale).to_i, (h * scale).to_i)
+            self
+        end
+
+        # return a deep copy of the current image.
+        def dup
+            new_image_name = action { IL.CloneCurImage }
+            Image.new(new_image_name, nil)
+        end
+
+        alias_method :clone, :dup
+
+        # crop the current image.
+        # +xoff+ number of pixels to skip in x direction.
+        # +yoff+ number of pixels to skip in y direction.
+        # +width+ number of pixels to preserve in x direction.
+        # +height+ number of pixels to preserve in y direction.
+        def crop(xoff, yoff, width, height)
+            action { ILU.Crop(xoff, yoff, 1, width, height, 1) }
+            self
+        end
+
+        # enlarge the canvas of current image to +width+ and +height+.
+        def enlarge_canvas(width, height)
+            if width < self.width || height < self.height
+                raise "width and height parameters must be larger than current image width and height"
+            end
+            
+            action { ILU.EnlargeCanvas(width, height, 1) }
+            self
+        end
+
+        # splice the +source+ image into current image at position +x+ and +y+.
+        # Takes an optional +:crop+ hash parameter that has the following format: +:crop => [sx, sy, width, height]+
+        # +sx+, +sy+, +width, +height+ crop the source image to be spliced.
+        # +sx+ is how many pixels to skip in x direction of source image.
+        # +sy+ is how many pixels to skip in y direction of source image.
+        # +width+ number of pixels to preserve in x direction of source image.
+        # +height+ number of pixels to preserve in y direction of source image.
+        # if no +:crop+ parameter is provided then the whole image is spliced in.
+        def blit(source, x, y, options = {})
+            options = {
+                :crop => [0, 0, source.width, source.height]
+            }.merge!(options)
+            
+            action do
+                IL.Blit(source.name, x, y, 0, options[:crop][0], options[:crop][1], 0,
+                        options[:crop][2], options[:crop][3], 1)
+            end
+            
+            self
+        end
+
+        alias_method :composite, :blit
+
+        # reflect image about its y axis.
+        def mirror
+            action { ILU.Mirror }
+            self
+        end
+
+        # use prewitt or sobel filters to detect the edges in the current image.
+        def edge_detect
+            case Devil.get_options[:edge_filter]
+            when :prewitt
+                action { ILU.EdgeDetectP }
+            when :sobel
+                action { ILU.EdgeDetectS }
+            else
+                raise "No such edge filter #{Devil.get_options[:edge_filter]}. Use :prewitt or :sobel"
+            end
+            self
+        end
+
+        # embosses an image, causing it to have a "relief" feel to it using a convolution filter.
+        def emboss
+            action { ILU.Emboss }
+            self
+        end
+
+        # applies a strange color distortion effect to the image giving  a preternatural feel
+        def alienify
+            action { ILU.Alienify }
+            self
+        end
+
+        # performs a gaussian blur on the image. The blur is performed +iter+ times.
+        def blur(iter)
+            action { ILU.BlurGaussian(iter) }
+            self
+        end
+
+        # 'pixelize' the image using a pixel size of +pixel_size+.
+        def pixelize(pixel_size)
+            action { ILU.Pixelize(pixel_size) }
+            self
+        end
+
+        # add random noise to the image. +factor+ is the tolerance to use.
+        # accepeted values range from 0.0 - 1.0.
+        def noisify(factor)
+            action { ILU.Noisify(factor) }
+            self
+        end
+
+        # The sharpening +factor+ must be in the range of 0.0 - 2.5. A value of 1.0 for the sharpening.
+        # factor will have no effect on the image. Values in the range 1.0 - 2.5 will sharpen the
+        # image, with 2.5 having the most pronounced sharpening effect. Values from 0.0 to 1.0 do
+        # a type of reverse sharpening, blurring the image. Values outside of the 0.0 - 2.5 range
+        # produce undefined results.
+        #        
+        # The number of +iter+ (iterations) to perform will usually be 1, but to achieve more sharpening,
+        # increase the number of iterations. 
+        def sharpen(factor, iter)
+            action { ILU.Sharpen(factor, iter) }
+            self
+        end
+
+        # applies gamma correction to an image using an exponential curve.
+        # +factor+ is gamma correction factor to use.
+        # A value of 1.0 leaves the image unmodified.
+        # Values in the range 0.0 - 1.0 darken the image
+        # Values above 1.0 brighten the image.
+        def gamma_correct(factor)
+            action { ILU.GammaCorrect(factor) }
+            self
+        end
+
+        # invert the color of every pixel in the image.
+        def negate
+            action { ILU.Negative }
+            self
+        end
+
+        alias_method :negative, :negate
+
+        # +factor+ describes desired contrast to use
+        # A value of 1.0 has no effect on the image.
+        # Values between 1.0 and 1.7 increase the amount of contrast (values above 1.7 have no effect)
+        # Valid range of +factor+ is 0.0 - 1.7.
+        def contrast(factor)
+            action { ILU.Contrast(factor) }
+            self
+        end
+
+        # darkens the bright colours and lightens the dark
+        # colours, reducing the contrast in an image or 'equalizing' it.
+        def equalize
+            action { ILU.Equalize }
+            self
+        end
+
+        # returns the image data in the form of a ruby string.
+        # The image data is formatted to RGBA / UNSIGNED BYTE.
+        def to_blob
+            action { IL.ToBlob }
+        end
+
+        # flip the image about its x axis.
+        def flip
+            action { ILU.FlipImage }
+            self
+        end
+
+        # rotate an image about its central point by +angle+ degrees (counter clockwise).
+        def rotate(angle)
+            action { ILU.Rotate(angle) }
+            self
+        end
+
+        #  simply clears the image to the 'clear color' (specified using Devil.set_options(:clear_color => [r, g, b, a])
+        def clear
+            action { IL.ClearImage }
+            self
+        end
+
+        private
+
+        def set_binding
+            IL.BindImage(@name)
+        end
+
+        def error_check
+            if (error_code = IL.GetError) != IL::NO_ERROR
+                raise RuntimeError, "An error occured. #{ILU.ErrorString(error_code)}"
+            end
+        end
+
+        def action
+            set_binding
+            result = yield
+            error_check
+            
+            result
+        end
+    end
+end
+
+Devil.init