free-image 0.6.2 → 0.7.0

data/free-image.gemspec

@@ -1,30 +1,31 @@
-# encoding: utf-8
-
-Gem::Specification.new do |spec|
-  spec.name        = 'free-image'
-  spec.version     = '0.6.2'
-  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
-    popular graphics image formats like PNG, BMP, JPEG, TIFF and others as needed by
-    today's multimedia applications. FreeImage is easy to use, fast, multithreading
-    safe, compatible with all 32-bit or 64-bit versions of Windows, and
-    cross-platform (works both with Linux and Mac OS X).
-  EOS
-  spec.authors = [ 'Charlie Savage']
-  spec.platform = Gem::Platform::RUBY
-  spec.files = Dir.glob(['HISTORY',
-                         'LICENSE',
-                         'free-image.gemspec',
-                         'Rakefile',
-                         '*.rdoc',
-                         'lib/**/*.rb',
-                         'test/**/*'])
-  spec.test_files = Dir.glob("test/test_*.rb")
-  spec.required_ruby_version = '>= 1.8.7'
-  spec.date = Time.now
-
-  spec.add_dependency('ffi', '>=1.0.10')
-  spec.add_development_dependency('hanna-nouveau')
-  spec.add_development_dependency('open4')
+# encoding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name        = 'free-image'
+  spec.version     = '0.7.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
+    popular graphics image formats like PNG, BMP, JPEG, TIFF and others as needed by
+    today's multimedia applications. FreeImage is easy to use, fast, multithreading
+    safe, compatible with all 32-bit or 64-bit versions of Windows, and
+    cross-platform (works both with Linux and Mac OS X).
+  EOS
+  spec.authors = [ 'Charlie Savage']
+  spec.platform = Gem::Platform::RUBY
+  spec.files = Dir.glob(['HISTORY',
+                         'LICENSE',
+                         'free-image.gemspec',
+                         'Rakefile',
+                         '*.rdoc',
+                         'lib/**/*.rb',
+                         'test/**/*'])
+  spec.test_files = Dir.glob("test/test_*.rb")
+  spec.required_ruby_version = '>= 1.8.7'
+  spec.date = Time.now
+
+  spec.add_dependency('ffi', '>=1.0.10')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('hanna-nouveau')
+  spec.add_development_dependency('open4')
 end

data/lib/free-image.rb

@@ -49,8 +49,6 @@ module FreeImage
 
   if free_image_library_paths.any?
     ffi_lib(*free_image_library_paths)
-  elsif FFI::Platform.windows?
-    ffi_lib("FreeImaged")
   else
     ffi_lib("freeimage")
   end
@@ -71,6 +69,7 @@ require 'free-image/types/rgba16'
 require 'free-image/types/rgbf'
 require 'free-image/types/rgbaf'
 require 'free-image/types/complex'
+require 'free-image/types/info_header'
 
 # Enums
 require 'free-image/enums/color_types'

data/lib/free-image/bitmap.rb

@@ -153,8 +153,8 @@ module FreeImage
     # dst::     The destination where the image will be saved.
     # format::  The format[rdoc-ref:FreeImage.formats] to save the image to.
     # flags::   Format specific flags that control how a bitmap is saved.  These flags are defined
-    #            as constants on the AbstractSource class.  Flags can be combined using
-    #            Ruby's bitwise or operator (|)
+    #           as constants on the AbstractSource[rdoc-ref:FreeImage::AbstractSource::Encoder] class.
+    #           Flags can be combined using Ruby's bitwise or operator (|)
     #
     def save(source, format, flags = 0)
       self.class.figure_source(source).save(self, format, flags)

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

@@ -1,12 +1,12 @@
-module FreeImage
-  ##
-  #FreeImage supports the following rescaling filters:
-  #
-  # :method: filters
-  enum :filter, [:box, 0,
-                 :bicubic, 1,
-                 :bilinear, 2,
-                 :bspline, 3,
-                 :catmullrom, 4,
-                 :lanczos3, 5]
+module FreeImage
+  ##
+  #FreeImage supports the following rescaling filters:
+  #
+  # :method: filters
+  enum :filter, [:box, 0,
+                 :bicubic, 1,
+                 :bilinear, 2,
+                 :bspline, 3,
+                 :catmullrom, 4,
+                 :lanczos3, 5]
 end

data/lib/free-image/errors.rb

@@ -1,44 +1,44 @@
-module FreeImage
-  LAST_ERROR = 'free_image_error'
-
-  #typedef void (*FreeImage_OutputMessageFunction)(FREE_IMAGE_FORMAT fif, const char *msg);
-  #typedef void (DLL_CALLCONV *FreeImage_OutputMessageFunctionStdCall)(FREE_IMAGE_FORMAT fif, const char *msg);
-  callback(:output_message_callback, [:format, :pointer], :void)
-
-  if FFI::Platform.windows?
-    #DLL_API void DLL_CALLCONV FreeImage_SetOutputMessageStdCall(FreeImage_OutputMessageFunctionStdCall omf);
-    attach_function('FreeImage_SetOutputMessage', 'FreeImage_SetOutputMessageStdCall', [:output_message_callback], :void)
-  else
-    #DLL_API void DLL_CALLCONV FreeImage_SetOutputMessage(FreeImage_OutputMessageFunction omf);
-    attach_function('FreeImage_SetOutputMessage', [:output_message_callback], :void)
-  end
-
-  class Error < StandardError
-    attr_reader :format
-
-    def initialize(format, message)
-      @format = format
-      super(message)
-    end
-
-#    def to_s
-#      "#{self.message}  Format: #{self.format}"
-#    end
-  end
-
-  CALLBACK = Proc.new do |format, ptr|
-    # Create an exception object and stash it away.  We can't raise it here
-    # because FreeImage won't be able to clean up any resources it needs to.
-    # Instead, the calling code must call check_last_error.
-    message = ptr.get_string(0)
-    Thread.current[LAST_ERROR] = Error.new(format, message)
-  end
-  FreeImage_SetOutputMessage(CALLBACK)
-
-  def check_last_error
-    error = Thread.current[LAST_ERROR]
-    Thread.current[LAST_ERROR] = nil
-    raise(error) if error
-  end
-  module_function :check_last_error
+module FreeImage
+  LAST_ERROR = 'free_image_error'
+
+  #typedef void (*FreeImage_OutputMessageFunction)(FREE_IMAGE_FORMAT fif, const char *msg);
+  #typedef void (DLL_CALLCONV *FreeImage_OutputMessageFunctionStdCall)(FREE_IMAGE_FORMAT fif, const char *msg);
+  callback(:output_message_callback, [:format, :pointer], :void)
+
+  if FFI::Platform.windows?
+    #DLL_API void DLL_CALLCONV FreeImage_SetOutputMessageStdCall(FreeImage_OutputMessageFunctionStdCall omf);
+    attach_function('FreeImage_SetOutputMessage', 'FreeImage_SetOutputMessageStdCall', [:output_message_callback], :void)
+  else
+    #DLL_API void DLL_CALLCONV FreeImage_SetOutputMessage(FreeImage_OutputMessageFunction omf);
+    attach_function('FreeImage_SetOutputMessage', [:output_message_callback], :void)
+  end
+
+  class Error < StandardError
+    attr_reader :format
+
+    def initialize(format, message)
+      @format = format
+      super(message)
+    end
+
+#    def to_s
+#      "#{self.message}  Format: #{self.format}"
+#    end
+  end
+
+  CALLBACK = Proc.new do |format, ptr|
+    # Create an exception object and stash it away.  We can't raise it here
+    # because FreeImage won't be able to clean up any resources it needs to.
+    # Instead, the calling code must call check_last_error.
+    message = ptr.get_string(0)
+    Thread.current[LAST_ERROR] = Error.new(format, message)
+  end
+  FreeImage_SetOutputMessage(CALLBACK)
+
+  def check_last_error
+    error = Thread.current[LAST_ERROR]
+    Thread.current[LAST_ERROR] = nil
+    raise(error) if error
+  end
+  module_function :check_last_error
 end

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

@@ -1,254 +1,254 @@
-module FreeImage
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo4Bits(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertTo4Bits', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo8Bits(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertTo8Bits', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToGreyscale(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertToGreyscale', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits555(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertTo16Bits555', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits565(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertTo16Bits565', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo24Bits(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertTo24Bits', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo32Bits(FIBITMAP *dib);
-  attach_function('FreeImage_ConvertTo32Bits', [:pointer], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Dither(FIBITMAP *dib, FREE_IMAGE_DITHER algorithm);
-  attach_function('FreeImage_Dither', [:pointer, :dither], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Threshold(FIBITMAP *dib, BYTE T);
-  attach_function('FreeImage_Threshold', [:pointer, :byte], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToStandardType(FIBITMAP *src, BOOL scale_linear FI_DEFAULT(TRUE));
-  attach_function('FreeImage_ConvertToStandardType', [:pointer, FreeImage::Boolean], :pointer)
-
-  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear FI_DEFAULT(TRUE));
-  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. 
-    # 
-    # 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.
-    #
-    # 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, &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.
-    #
-    # 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.
-    #
-    # 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, &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.
-    #
-    # 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, &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.
-    #
-    # 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, &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.
-    #
-    # 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, &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.
-    #
-    # 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, &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.
-    #
-    # 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, &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]
-    # to an integer value between [0..255], where min and max are the minimum
-    # and maximum pixel values in the image. When scale_linear is false, conversion
-    # is done by rounding each pixel value to an integer between [0..255]. Rounding
-    # is done using the following formula:
-    #
-    #  dst_pixel = (BYTE) MIN(255, MAX(0, q)) where int q = int(src_pixel + 0.5)
-    #
-    # 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.
-    #
-    # 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, &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.
-    #
-    # 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, &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.
-    #
-    # 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, &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.
-    #
-    # 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, &block)
-    end
-  end
+module FreeImage
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo4Bits(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertTo4Bits', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo8Bits(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertTo8Bits', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToGreyscale(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertToGreyscale', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits555(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertTo16Bits555', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits565(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertTo16Bits565', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo24Bits(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertTo24Bits', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo32Bits(FIBITMAP *dib);
+  attach_function('FreeImage_ConvertTo32Bits', [:pointer], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Dither(FIBITMAP *dib, FREE_IMAGE_DITHER algorithm);
+  attach_function('FreeImage_Dither', [:pointer, :dither], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Threshold(FIBITMAP *dib, BYTE T);
+  attach_function('FreeImage_Threshold', [:pointer, :byte], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToStandardType(FIBITMAP *src, BOOL scale_linear FI_DEFAULT(TRUE));
+  attach_function('FreeImage_ConvertToStandardType', [:pointer, FreeImage::Boolean], :pointer)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear FI_DEFAULT(TRUE));
+  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. 
+    # 
+    # 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.
+    #
+    # 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, &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.
+    #
+    # 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.
+    #
+    # 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, &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.
+    #
+    # 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, &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.
+    #
+    # 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, &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.
+    #
+    # 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, &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.
+    #
+    # 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, &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.
+    #
+    # 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, &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]
+    # to an integer value between [0..255], where min and max are the minimum
+    # and maximum pixel values in the image. When scale_linear is false, conversion
+    # is done by rounding each pixel value to an integer between [0..255]. Rounding
+    # is done using the following formula:
+    #
+    #  dst_pixel = (BYTE) MIN(255, MAX(0, q)) where int q = int(src_pixel + 0.5)
+    #
+    # 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.
+    #
+    # 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, &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.
+    #
+    # 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, &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.
+    #
+    # 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, &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.
+    #
+    # 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, &block)
+    end
+  end
 end