free-image 0.5.0 → 0.6.0

data/README.rdoc

@@ -33,11 +33,32 @@ free-image is via Ruby Gems.  To install:
 
  gem install free-image
 
-
 == Getting Started
-Using free-image is easy.  To get you started,  refer to the
-\FreeImage cookbook[rdoc-ref:cookbook.rdoc].
+Getting started is easy - first work through the examples in the cookbook[rdoc-ref:cookbook.rdoc].
+Once you've done that, the refer to rdocs for extensive documentation.
+
+== Memory Management
+Opening and working with images consumes some memory.  Generally you won't have to
+worry about this.  When an image goes out of scope, it will be garbage collected
+and the underlying image memory will be freed.
+
+Having said that, \FreeImage also lets you control when the memory is freed.
+Any method that creates a new image also takes a block.  When the block finishes,
+the underlying image memory is freed.  This works the same way as the File.open
+method.  For example:
+
+  FreeImage::Bitmap.open('images/lena.png') do |image|
+    thumbnail = image.make_thumbail do |thumbail|
+      thumbnail.save('images/thumbnail.png', :png)
+    end
+  end
+
+When the inner block finishes the thumbnail image is freed and when the outer
+block finished the lena image is freed.
 
+If you need even more control, you can  use FreeImage::Bitmap#free which frees 
+the underlying image.  Be careful though - once the image is freed further usage
+of it will result in a segmentation fault.
 
 == Implementation Status
 The FreeImage API is divided into multiple parts.  As summarized below, the Ruby ffi
@@ -74,7 +95,7 @@ extend the coverage.
 * Channel processing - Not Implemented
 * Copy / Paste / Composite routines - FreeImage::Modify
 * Background filling - FreeImage::Modify
-* Miscellaneous algorithms - Not Implemented
+* Miscellaneous algorithms - FreeImage::Helper
 
 == Documentation
 Documentation is available via rdoc, and is installed automatically with the

data/cookbook.rdoc

@@ -17,7 +17,7 @@ via the FreeImage::Bitmap.open method:
 The open method also takes two additional optional parameters, format and flags,
 that provide greater control over opening images if needed.
 
-The open method works similary to File.open, meaning you can pass it a block.
+The open method works similary to File.open, meaning you can also pass it a block.
 
   FreeImage::Bitmap.open('images/lena.png') do |image|
     ... do some stuff..
@@ -25,9 +25,8 @@ The open method works similary to File.open, meaning you can pass it a block.
 
 Once the block completes, the image will be automatically freed for you.  If you don't
 pass block, then the image will be freed by Ruby's Garbage Collector once it goes out
-of scope or you can call the FreeImage::Bitmap#free method.  Once you do that though,
-remember the image no longer exists and further usage of it will result in
-segmentation faults.
+of scope.  For more information about memory management, refer to
+the readme [rdoc-ref:README.rdoc].
 
 Image[link:cookbook/lena.png]
 

data/free-image.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name        = 'free-image'
-  spec.version     = '0.5.0'
+  spec.version     = '0.6.0'
   spec.summary     = 'Ruby Bindings for the Free Image Library'
   spec.description = <<-EOS
     FreeImage is an Open Source library project for developers who would like to support

data/lib/free-image.rb

@@ -52,7 +52,7 @@ module FreeImage
   elsif FFI::Platform.windows?
     ffi_lib("FreeImaged")
   else
-    ffi_lib("free_image")
+    ffi_lib("freeimage")
   end
 
   ffi_convention :stdcall if FFI::Platform.windows?

data/lib/free-image/bitmap.rb

@@ -86,14 +86,28 @@ module FreeImage
     # also be a string which is interpreted as a fully qualified file path.
     def self.open(source)
       bitmap = figure_source(source).open
-      unless block_given?
-        bitmap
+      if block_given?
+        begin
+          yield bitmap
+        ensure
+          bitmap.free
+        end
       else
+        bitmap
+      end
+    end
+
+    def self.new(ptr, source = nil)
+      bitmap = super(ptr, source)
+
+      if block_given?
         begin
           yield bitmap
         ensure
           bitmap.free
         end
+      else
+        bitmap
       end
     end
 
@@ -112,11 +126,19 @@ module FreeImage
       super(ptr)
     end
 
+    # :call-seq:
+    #   image.clone -> bitmap
+    #   image.clone {|img| block} -> bitmap
+    # 
     # Creates an exact copy of the current image.
-    def clone
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def clone(&block)
       ptr = FreeImage.FreeImage_Clone(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
     # Save the image to the specified source.
@@ -146,9 +168,5 @@ module FreeImage
         raise(ArgumentError, "Unknown source type: #{source.class.name}")
       end
     end
-
-    def figure_color_klass
-      
-    end
   end
 end

data/lib/free-image/enums/image_types.rb

@@ -14,9 +14,9 @@ module FreeImage
   # :double:: Array of double: 64-bit IEEE floating point
   # :complex:: Array of FICOMPLEX: 2 x 64-bit IEEE floating point
   # :rgb16:: 48-bit rgb image: 3 x 16-bit
-  # :rgba16:: 64-bit rgbA image: 4 x 16-bit
+  # :rgba16:: 64-bit rgba image: 4 x 16-bit
   # :rgbf:: 96-bit rgb float image: 3 x 32-bit IEEE floating point
-  # :rgbaf:: 128-bit rgbA float image: 4 x 32-bit IEEE floating point
+  # :rgbaf:: 128-bit rgba float image: 4 x 32-bit IEEE floating point
   #
   # :method: image_types
   

data/lib/free-image/modules/conversions.rb

@@ -33,6 +33,10 @@ module FreeImage
   attach_function('FreeImage_ConvertToType', [:pointer, :image_type, FreeImage::Boolean], :pointer)
 
   module Conversions
+    # :call-seq:
+    #   image.convert_to_4bits -> bitmap
+    #   image.convert_to_4bits {|img| block} -> bitmap
+    #
     # Converts a bitmap to 4 bits. If the bitmap is a high-color (16, 24 or 32-bit),
     # monochrome or greyscale bitmap (1 or 8-bit) the end result will be a greyscale bitmap.
     # A 1-bit bitmap will become a palletized bitmap. 
@@ -40,12 +44,20 @@ module FreeImage
     # Note that "greyscale" means that the resulting bitmap will have grey colors,
     # but the palette won't be a linear greyscale palette. Thus, FreeImage::Bitmap.color_type
     # will return a :palette.
-    def convert_to_4bits
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_4bits(&block)
       ptr = FreeImage.FreeImage_ConvertTo4Bits(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_8bits -> bitmap
+    #   image.convert_to_8bits {|img| block} -> bitmap
+    #
     # Converts a bitmap to 8 bits. If the bitmap is a high-color (16, 24 or 32-bit),
     # monochrome or greyscale bitmap (1 or 4-bit) the end result will be a greyscale bitmap.
     # A 1-bit or 4-bit bitmap will become a palletized bitmap.
@@ -53,59 +65,107 @@ module FreeImage
     # For 16-bit greyscale images (images whose type is :uint16), conversion is done by
     # dividing the 16-bit channel by 256 (see also FreeImage::Bitmap.ConvertToStandardType).
     # A nil value is returned for other non-standard bitmap types.
-    def convert_to_8bits
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_8bits(&block)
       ptr = FreeImage.FreeImage_ConvertTo8Bits(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_greyscale -> bitmap
+    #   image.convert_to_greyscale {|img| block} -> bitmap
+    #
     # Converts a bitmap to a 8-bit greyscale image with a linear ramp. Contrary to
     # the FreeImage::Conversions#convert_to_8bits function, 1-, 4- and 8-bit palletized
     # bitmaps are correctly converted, as well as images with a :minis_white color type.
-    def convert_to_greyscale
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_greyscale(&block)
       ptr = FreeImage.FreeImage_ConvertToGreyscale(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_16bits_555 -> bitmap
+    #   image.convert_to_16bits_555 {|img| block} -> bitmap
+    #
     # Converts a bitmap to 16 bits, where each pixel has a color pattern of
     # 5 bits red, 5 bits green and 5 bits blue. One bit in each pixel is
     # unused.
-    def convert_to_16bits_555
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_16bits_555(&block)
       ptr = FreeImage.FreeImage_ConvertTo16Bits555(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_16bits_565 -> bitmap
+    #   image.convert_to_16bits_565 {|img| block} -> bitmap
+    #
     # Converts a bitmap to 16 bits, where each pixel has a color pattern of
     # 5 bits red, 6 bits green and 5 bits blue. One bit in each pixel is
     # unused.
-    def convert_to_16bits_565
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_16bits_565(&block)
       ptr = FreeImage.FreeImage_ConvertTo16Bits565(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_24bits -> bitmap
+    #   image.convert_to_24bits {|img| block} -> bitmap
+    #
     # Converts a bitmap to 24 bits. For 48-bit RGB images, conversion is done
     # by dividing each 16-bit channel by 256. A nil value is returned for
     # other non-standard bitmap types.
-    def convert_to_24bits
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_24bits(&block)
       ptr = FreeImage.FreeImage_ConvertTo24Bits(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_32bits -> bitmap
+    #   image.convert_to_32bits {|img| block} -> bitmap
+    #
     # Converts a bitmap to 32 bits. For 48-bit RGB images, conversion is done
     # by dividing each 16-bit channel by 256 and by setting the alpha channel
     # to an opaque value (0xFF). For 64-bit RGBA images, conversion is done
     # by dividing each 16-bit channel by 256. A nil value is returned for
     # other non-standard bitmap types.
-    def convert_to_32bits
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_32bits(&block)
       ptr = FreeImage.FreeImage_ConvertTo32Bits(self)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_standard_type(scale_linear = true) -> bitmap
+    #   image.convert_to_standard_type(scale_linear = true) {|img| block} -> bitmap
+    #
     # Converts a non standard image whose color type is :minis_black to a
     # standard 8-bit greyscale image.  When the scale_linear parameter is
     # true, conversion is done by scaling linearly each pixel value from [min, max]
@@ -119,48 +179,76 @@ module FreeImage
     # For standard bitmaps, a clone of the original bitmap is returned.
     # For complex images, the magnitude is extracted as a double image and then converted
     # according to the scale parameter.
-    def convert_to_standard_type(scale_linear = true)
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_standard_type(scale_linear = true, &block)
       ptr = FreeImage.FreeImage_ConvertToStandardType(self, scale_linear)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.convert_to_type(dst_image_type, scale_linear = true) -> bitmap
+    #   image.convert_to_type(dst_image_type, scale_linear = true) {|img| block} -> bitmap
+    #
     # Converts a bitmap to the specified destination image type.  When the image_type
     # is equal to :bitmap, the function calls FreeImage::Converstions#convert_to_standard_type.
     # Otherwise, conversion is done using standard C language casting conventions. When
     # a conversion is not allowed, a nil value is returned and an error is thrown.
     # Please refer to the FreeImage documentation for allowed conversions.
-    def convert_to_type(dst_image_type, scale_linear = true)
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def convert_to_type(dst_image_type, scale_linear = true, &block)
       ptr = FreeImage.FreeImage_ConvertToType(self, dst_image_type, scale_linear)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.dither(algorithm) -> bitmap
+    #   image.dither(algorithm) {|img| block} -> bitmap
+    #
     # Converts a bitmap to 1-bit monochrome bitmap using the specified
     # {dithering}[rdoc-ref:FreeImage.dithers] algorithm. For 1-bit input
     # bitmaps, the function clones the input bitmap and builds a
     # monochrome palette.  Otherwise the function first converts the
     # bitmap to a 8-bit greyscale bitmap.
-    def dither(algorithm)
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def dither(algorithm, &block)
       ptr = FreeImage.FreeImage_Dither(self, algorithm)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.threshold(value) -> bitmap
+    #   image.threshold(value) {|img| block} -> bitmap
+    #
     # Converts a bitmap to 1-bit monochrome bitmap using a threshold value
     # between 0 and 255.  The function first converts the bitmap to a 8-bit
     # greyscale bitmap. Then any brightness level that is less than the
     # threshold is set to zero and any value above is set to 1.
     # For 1-bit input bitmaps, the function clones the input bitmap and
     # builds a monochrome palette.
-    def threshold(value)
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def threshold(value, &block)
       value = Integer(value)
       unless (0..255).include?(value)
         raise(RangeError, "Value is out of range 0..255. Value: #{value}")
       end
       ptr = FreeImage.FreeImage_Threshold(self, value)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
   end
 end

data/lib/free-image/modules/modify.rb

@@ -45,6 +45,10 @@ module FreeImage
   # filling background colors.
   #
   module Modify
+    # :call-seq:
+    #   image.composite(background_bitmap) -> bitmap
+    #   image.composite(background_bitmap) {|img| block} -> bitmap
+    #
     # Composites a transparent foreground image against a background image.
     # The equation for computing a composited sample value is:
     #
@@ -53,12 +57,20 @@ module FreeImage
     # Where alpha and the input and output sample values are expressed as fractions
     # in the range 0 to 1. For color images, the computation is done separately
     # for R, G, and B samples.
-    def composite(background_bitmap)
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def composite(background_bitmap, &block)
       ptr = FreeImage.FreeImage_Composite(self, false, nil, background_bitmap)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.composite_with_color(background_color) -> bitmap
+    #   image.composite_with_color(background_color) {|img| block} -> bitmap
+    #
     # Composites a transparent foreground image against a background color.
     # The equation for computing a composited sample value is:
     #
@@ -67,25 +79,41 @@ module FreeImage
     # Where alpha and the input and output sample values are expressed as fractions
     # in the range 0 to 1. For color images, the computation is done separately
     # for R, G, and B samples.
-    def composite_with_color(background_color)
+    #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def composite_with_color(background_color, &block)
       ptr = FreeImage.FreeImage_Composite(self, false, background_color, nil)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.copy(left, top, right, bottom) -> bitmap
+    #   image.copy(left, top, right, bottom) {|img| block} -> bitmap
+    #
     # Copy a subpart of the current image. The rectangle defined by the
     # left, top, right, bottom parameters is first normalized such that the
     # value of the left coordinate is less than the right and the top is less
     # than the bottom. Then, the returned bitmap is defined by a width equal to
     # (right - left) and a height equal to (bottom - top).
     #
-    # The function returns the subimage if successful and returns nil otherwise.
-    def copy(left, top, right, bottom)
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    # 
+    # The function returns the subimage if successful and othewise it returns nil.
+    #
+    def copy(left, top, right, bottom, &block)
       ptr = FreeImage.FreeImage_Copy(self, left, top, right, bottom)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
+    # :call-seq:
+    #   image.enlarge_canvas(left, top, right, bottom, color, options = 0) -> bitmap
+    #   image.enlarge_canvas(left, top, right, bottom, color, options = 0) {|img| block} -> bitmap
+    #
     # Enlarges or shrinks an image selectively per side and fills newly added areas with the
     # specified background color.  The common use case is to add borders to an image.
     #
@@ -117,12 +145,15 @@ module FreeImage
     # options:: Used to control color search process for palletized images. See
     #           #fill_background for more details.
     #
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    # 
     # Returns a new image on success or nil.
     #
-    def enlarge_canvas(left, top, right, bottom, color, options = 0)
+    def enlarge_canvas(left, top, right, bottom, color, options = 0, &block)
       ptr = FreeImage.FreeImage_EnlargeCanvas(self, left, top, right, bottom, color, options)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
     # Sets all pixels of an image to the specified color.
@@ -161,6 +192,7 @@ module FreeImage
 
     # :call-seq:
     #   bitmap.make_thumbnail(max_pixel_size, convert = true) -> bitmap
+    #   bitmap.make_thumbnail(max_pixel_size, convert = true) {|img| block} -> bitmap
     #
     # Creates a thumbnail image that fits inside a square of size max_pixel_size,
     # keeping the original aspect ratio intact.  Downsampling is done using a bilinear
@@ -174,10 +206,13 @@ module FreeImage
     #           to standard images (i.e. 8-, 24 or 32-bit images).  The
     #           default value is true.
     #
-    def make_thumbnail(max_pixel_size, convert = true)
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def make_thumbnail(max_pixel_size, convert = true, &block)
       ptr = FreeImage.FreeImage_MakeThumbnail(self, max_pixel_size, convert)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
     # Combines or blends a subpart of another image with the current image.
@@ -201,6 +236,7 @@ module FreeImage
 
     # :call-seq:
     #   bitmap.rescale(width, height, filter) -> bitmap
+    #   bitmap.rescale(width, height, filter) {|img| block} -> bitmap -> bitmap
     #
     # Resamples an image to the desired width and height. Resampling changes the
     # pixel dimensions (and therefore display size) of an image.
@@ -252,10 +288,13 @@ module FreeImage
     #             rare applications using band-limited photographic images with
     #             no sharp edges.
     #
-    def rescale(width, height, filter = :bilinear)
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def rescale(width, height, filter = :bilinear, &block)
       ptr = FreeImage.FreeImage_Rescale(self, width, height, filter)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
   end
 end

data/lib/free-image/modules/transforms.rb

@@ -14,6 +14,7 @@ module FreeImage
   module Transforms
     # call-seq:
     #   bitmap.rotate(angle, bk_color) -> bitmap
+    #   bitmap.rotate(angle, bk_color) -> {|img| block} -> bitmap
     #
     # Rotates an image around the center of the image area by means of 3 shears.
     # The rotated image retains the same size and aspect ratio of source image
@@ -29,14 +30,18 @@ module FreeImage
     #  angle::    Specifies the angle of rotation in degrees
     #  bk_color:: The color used to fill the background.
     #
-    def rotate(angle, bk_color = nil)
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def rotate(angle, bk_color = nil, &block)
       ptr = FreeImage.FreeImage_Rotate(self, angle, bk_color)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
     # call-seq:
     #   bitmap.rotate_ex(aangle, x_shift, y_shift, x_origin, y_origin, use_mask = false) -> bitmap
+    #   bitmap.rotate_ex(aangle, x_shift, y_shift, x_origin, y_origin, use_mask = false) {|img| block} -> bitmap
     #
     # Rotates an image using a 3rd order (cubic) B-Spline. The rotated image will have
     # the same width and height as the source image, so that this function is better
@@ -52,10 +57,13 @@ module FreeImage
     #  use_mask:: When true, irrelevant parts of the image are set to black,
     #             otherwise, a mirroring technique is used to fill irrelevant pixels.
     #
-    def rotate_ex(angle, x_shift, y_shift, x_origin, y_origin, use_mask = false);
+    # If an optional block is provided, it will be passed the new image as an argument.  The
+    # image will be automatically closed when the block completes.
+    #
+    def rotate_ex(angle, x_shift, y_shift, x_origin, y_origin, use_mask = false, &block)
       ptr = FreeImage.FreeImage_RotateEx(self, angle, x_shift, y_shift, x_origin, y_origin, use_mask)
       FreeImage.check_last_error
-      self.class.new(ptr)
+      self.class.new(ptr, &block)
     end
 
     # call-seq:

data/test/test_bitmap.rb

@@ -34,6 +34,18 @@ class BitmapTest < Test::Unit::TestCase
     end
   end
 
+  def test_clone
+    image = lena_image
+    clone = image.clone
+    assert(!clone.equal?(image))
+  end
+
+  def test_clone_block
+    lena_image.clone do |image|
+      assert_not_nil(image)
+    end
+  end
+
   def test_free
     1000.times do
       image = sample_image

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: free-image
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-31 00:00:00.000000000 Z
+date: 2011-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &22083624 !ruby/object:Gem::Requirement
+  requirement: &25091640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.0.10
   type: :runtime
   prerelease: false
-  version_requirements: *22083624
+  version_requirements: *25091640
 - !ruby/object:Gem::Dependency
   name: hanna-nouveau
-  requirement: &22083396 !ruby/object:Gem::Requirement
+  requirement: &25091412 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *22083396
+  version_requirements: *25091412
 - !ruby/object:Gem::Dependency
   name: open4
-  requirement: &22083120 !ruby/object:Gem::Requirement
+  requirement: &25091136 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *22083120
+  version_requirements: *25091136
 description: ! "    FreeImage is an Open Source library project for developers who
   would like to support\n    popular graphics image formats like PNG, BMP, JPEG, TIFF
   and others as needed by\n    today's multimedia applications. FreeImage is easy