free-image 0.5.0

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

@@ -0,0 +1,42 @@
+module FreeImage
+  #DLL_API const char *DLL_CALLCONV FreeImage_GetVersion(void);
+  attach_function('FreeImage_GetVersion', [], :string)
+
+  #DLL_API const char *DLL_CALLCONV FreeImage_GetCopyrightMessage(void);
+  attach_function('FreeImage_GetCopyrightMessage', [], :string)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_IsLittleEndian(void);
+  attach_function('FreeImage_IsLittleEndian', [], FreeImage::Boolean)
+
+  ##
+  # :call-seq:
+  #   version -> string
+  #
+  # Returns the current version of the FreeImage library
+  #
+  def self.version
+    FreeImage.FreeImage_GetVersion
+  end
+  
+  ##
+  # :call-seq:
+  #   copyright -> string
+  #
+  # Returns a standard copyright message you can show in your program.
+  #
+  def self.copyright
+    FreeImage.FreeImage_GetCopyrightMessage
+  end
+
+  ##
+  # :call-seq:
+  #   is_little_endian? -> boolean
+  #
+  # Returns TRUE if the platform running FreeImage uses the Little Endian
+  # convention (Intel processors) and returns FALSE if it uses the Big Endian
+  # (Motorola processors).
+  #
+  def self.little_endian?
+    FreeImage.FreeImage_IsLittleEndian
+  end
+end

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

@@ -0,0 +1,41 @@
+module FreeImage
+  # DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsICCProfiles(FREE_IMAGE_FORMAT fif)
+  attach_function(:icc_supported, 'FreeImage_FIFSupportsICCProfiles', [:format], FreeImage::Boolean)
+  module_function :icc_supported
+
+  module ICC
+    class Profile < FFI::Struct
+      layout :flags, :int,
+             :size,  :uint,
+             :data,  :pointer
+    end
+
+    # DLL_API FIICCPROFILE *DLL_CALLCONV FreeImage_GetICCProfile(FIBITMAP *dib)
+    FreeImage.attach_function('FreeImage_GetICCProfile', [:pointer], FreeImage::ICC::Profile)
+
+    def icc_profile
+      result = FreeImage.FreeImage_GetICCProfile(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # DLL_API FIICCPROFILE *DLL_CALLCONV FreeImage_CreateICCProfile(FIBITMAP *dib, void *data, long size);
+    FreeImage.attach_function('FreeImage_CreateICCProfile', [:pointer, :pointer, :long], FreeImage::ICC::Profile)
+    # DLL_API void DLL_CALLCONV FreeImage_DestroyICCProfile(FIBITMAP *dib);
+    FreeImage.attach_function('FreeImage_DestroyICCProfile', [:pointer], :void)
+
+    def icc_profile=(value)
+      result = if value
+        FreeImage.FreeImage_CreateICCProfile(self, value[:data], value[:size])
+      else
+        FreeImage.FreeImage_DestroyICCProfile(self)
+      end
+      FreeImage.check_last_error
+      result
+    end
+
+    def icc_supported?
+      FreeImage.icc_supported(self)
+    end
+  end
+end

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

@@ -0,0 +1,305 @@
+module FreeImage
+  #DLL_API BOOL DLL_CALLCONV FreeImage_HasPixels(FIBITMAP *dib);
+  attach_function('FreeImage_HasPixels', [:pointer], FreeImage::Boolean)
+
+  #DLL_API FREE_IMAGE_TYPE DLL_CALLCONV FreeImage_GetImageType(FIBITMAP *dib)
+  attach_function('FreeImage_GetImageType', [:pointer], :image_type)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetHeight(FIBITMAP *dib);
+  attach_function('FreeImage_GetHeight', [:pointer], :uint)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetWidth(FIBITMAP *dib);
+  attach_function('FreeImage_GetWidth', [:pointer], :uint)
+  
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetBPP(FIBITMAP *dib);
+  attach_function('FreeImage_GetBPP', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetLine(FIBITMAP *dib);
+  attach_function('FreeImage_GetLine', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetPitch(FIBITMAP *dib);
+  attach_function('FreeImage_GetPitch', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetDIBSize(FIBITMAP *dib);
+  attach_function('FreeImage_GetDIBSize', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetDotsPerMeterX(FIBITMAP *dib);
+  attach_function('FreeImage_GetDotsPerMeterX', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetDotsPerMeterY(FIBITMAP *dib);
+  attach_function('FreeImage_GetDotsPerMeterY', [:pointer], :ulong)
+
+  #DLL_API void DLL_CALLCONV FreeImage_SetDotsPerMeterX(FIBITMAP *dib, unsigned res);
+  attach_function('FreeImage_SetDotsPerMeterX', [:pointer, :ulong], :void)
+
+  #DLL_API void DLL_CALLCONV FreeImage_SetDotsPerMeterY(FIBITMAP *dib, unsigned res);
+  attach_function('FreeImage_SetDotsPerMeterY', [:pointer, :ulong], :void)
+
+  #DLL_API FREE_IMAGE_COLOR_TYPE DLL_CALLCONV FreeImage_GetColorType(FIBITMAP *dib);
+  attach_function('FreeImage_GetColorType', [:pointer], :color_type)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetBlueMask(FIBITMAP *dib);
+  attach_function('FreeImage_GetBlueMask', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetRedMask(FIBITMAP *dib);
+  attach_function('FreeImage_GetRedMask', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetGreenMask(FIBITMAP *dib);
+  attach_function('FreeImage_GetGreenMask', [:pointer], :ulong)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_GetTransparencyCount(FIBITMAP *dib);
+  attach_function('FreeImage_GetTransparencyCount', [:pointer], :ulong)
+
+  #DLL_API void DLL_CALLCONV FreeImage_SetTransparent(FIBITMAP *dib, BOOL enabled);
+  attach_function('FreeImage_SetTransparent', [:pointer, FreeImage::Boolean], :void)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_IsTransparent(FIBITMAP *dib);
+  attach_function('FreeImage_IsTransparent', [:pointer], FreeImage::Boolean)
+
+  #DLL_API void DLL_CALLCONV FreeImage_SetTransparentIndex(FIBITMAP *dib, int index);
+  attach_function('FreeImage_SetTransparentIndex', [:pointer, :int], :void)
+
+  #DLL_API int DLL_CALLCONV FreeImage_GetTransparentIndex(FIBITMAP *dib);
+  attach_function('FreeImage_GetTransparentIndex', [:pointer], :int)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_HasBackgroundColor(FIBITMAP *dib);
+  attach_function('FreeImage_HasBackgroundColor', [:pointer], FreeImage::Boolean)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_GetBackgroundColor(FIBITMAP *dib, RGBQUAD *bkcolor);
+  attach_function('FreeImage_GetBackgroundColor', [:pointer, :pointer], FreeImage::Boolean)
+
+  # DLL_API BOOL DLL_CALLCONV FreeImage_SetBackgroundColor(FIBITMAP *dib, RGBQUAD *bkcolor);
+  attach_function('FreeImage_SetBackgroundColor', [:pointer, :pointer], FreeImage::Boolean)
+  
+  # Once a bitmap is loaded into memory, you can use the following methods to
+  # retrieve information about is type, dimensions, colors, etc.
+  module Information
+
+    # Returns the background color of a bitmap. For 8-bit images, the color index
+    # in the palette is returned in the rgbReserved member of the bkcolor parameter.
+    def background_color
+      ptr = FFI::MemoryPointer.new(:pointer)
+      FreeImage.FreeImage_GetBackgroundColor(self, ptr)
+      FreeImage.check_last_error
+      RGBQuad.new(ptr)
+    end
+
+    # Set the  background color of a bitmap. The color should be an instance
+    # of RGBQuad.
+    #
+    # When saving an image to PNG, this background
+    # color is transparently saved to the PNG file. When the bkcolor parameter is nil,
+    # the background color is removed from the image.
+    def background_color=(value)
+      result = FreeImage.FreeImage_GetBackgroundColor(self, value)
+      FreeImage.check_last_error
+      if !result
+        raise(RuntimeError, "Could not save background color")
+      end
+    end
+
+    # Returns the size of one pixel in the bitmap in bits. For example if each
+    # pixel takes 32-bits of space in the bitmap, this function returns 32.
+    # Possible bit depths are 1, 4, 8, 16, 24, 32 for standard bitmaps and
+    # 16-, 32-, 48-, 64-, 96- and 128-bit for non standard bitmaps
+    def bits_per_pixel
+      result = FreeImage.FreeImage_GetBPP(self)
+      FreeImage.check_last_error
+      result
+    end
+    alias :bpp :bits_per_pixel
+    
+    # Returns a bit pattern describing the blue color component of a pixel in a bitmap.
+    def blue_mask
+      result = FreeImage.FreeImage_GetBlueMask(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    def color_type
+      result = FreeImage.FreeImage_GetColorType(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns the size of the DIB-element of a bitmap in memory, which is the
+    # header size + palette size + data bits.  Note that this is not the real
+    # size of a bitmap, just the size of its DIB-element.
+    def dib_size
+      result = FreeImage.FreeImage_GetDIBSize(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns the horizontal resolution, in pixels-per-meter,
+    # of the target device for the bitmap.
+    def dots_per_meter_x
+      result = FreeImage.FreeImage_GetDotsPerMeterX(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Sets the horizontal resolution, in pixels-per-meter,
+    # of the target device for the bitmap.
+    def dots_per_meter_x=(value)
+      result = FreeImage.FreeImage_SetDotsPerMeterX(self, value)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns the vertical resolution, in pixels-per-meter,
+    # of the target device for the bitmap.
+    def dots_per_meter_y
+      result = FreeImage.FreeImage_GetDotsPerMeterY(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Sets the vertical resolution, in pixels-per-meter,
+    # of the target device for the bitmap.
+    def dots_per_meter_y=(value)
+      result = FreeImage.FreeImage_SetDotsPerMeterY(self, value)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns a bit pattern describing the green color component of a pixel in a bitmap.
+    def green_mask
+      result = FreeImage.FreeImage_GetGreenMask(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns true when the image has a file background color, false otherwise
+    def has_background_color
+      result = FreeImage.FreeImage_HasBackgroundColor(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns true if the bitmap contains pixel data, otherwise false.  Bitmaps
+    # can be loaded using the FIF_LOAD_NOPIXELS load flag whic tells the decoder
+    # to read header data and available metadata and skip pixel data decoding.
+    # This reduces memory usage and load speed.
+    def has_pixels
+      result = FreeImage.FreeImage_HasPixels(self)
+      FreeImage.check_last_error
+      result
+    end
+    
+    # Returns the height of the bitmap in pixel units
+    def height
+      result = FreeImage.FreeImage_GetHeight(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns the {image type}[rdoc-ref:FreeImage.image_types] of a bitmap.
+    def image_type
+      result = FreeImage.FreeImage_GetImageType(self)
+      FreeImage.check_last_error
+      result
+    end
+    
+    # Returns the width of the bitmap in bytes.  See also FreeImage::Information.pitch.
+    # There has been some criticism on the name of this function. Some people expect it to
+    # return a scanline in the pixel data, while it actually returns the width of the bitmap in
+    # bytes. As far as I know the term Line is common terminology for the width of a bitmap
+    # in bytes. It is at least used by Microsoft DirectX.
+    def line
+      result = FreeImage.FreeImage_GetLine(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns a bitmap's palette. If the bitmap doesn’t have a palette (i.e. when the
+    # pixel bit depth is greater than 8), this return nil.
+    def palette
+      @palette ||= Palette.new(self)
+    end
+
+    # Returns the width of the bitmap in bytes, rounded to the next 32-bit boundary,
+    # also known as pitch or stride or scan width.
+    # In FreeImage each scanline starts at a 32-bit boundary for performance reasons.
+    # This accessor is essential when using low level {pixel manipulation}[rdoc-ref:FreeImage::Pixels]
+    # functions.
+    def pitch
+      result = FreeImage.FreeImage_GetPitch(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns a bit pattern describing the red color component of a pixel in a bitmap.
+    def red_mask
+      result = FreeImage.FreeImage_GetRedMask(self)
+      FreeImage.check_last_error
+      result
+    end
+    
+    # Returns the number of transparent colors in a palletized bitmap,
+    # otherwise returns 0.
+    def transparency_count
+      result = FreeImage.FreeImage_GetTransparencyCount(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns true if the transparency table is enabled (1-, 4- or 8-bit images) or
+    # when the input dib contains alpha values (32-bit images, RGBA16 or RGBAF images).
+    # Returns false otherwise.
+    def transparent
+      result = FreeImage.FreeImage_IsTransparent(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Tells FreeImage if it should make use of the transparency table or the alpha
+    # channel that may accompany a bitmap. When calling this function with a
+    # bitmap whose bitdepth is different from 1-, 4-, 8- or 32-bit, transparency
+    # is disabled whatever the value of the Boolean parameter.
+    def transparent=(value)
+      result = FreeImage.FreeImage_SetTransparent(self, value)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Returns the palette entry used as transparent color for the image specified.
+    # Works for palletised images only and returns -1 for high color images or
+    # if the image has no color set to be transparent.
+    # Although it is possible for palletised images to have more than one transparent
+    # color, this function always returns the index of the first palette entry,
+    # set to be transparent.
+    def transparent_index
+      result = FreeImage.FreeImage_GetTransparentIndex(self)
+      FreeImage.check_last_error
+      result
+    end
+
+    # Sets the index of the palette entry to be used as transparent color for
+    # the image specified. This works on palletised images only and does nothing
+    # for high color images.
+    #
+    # Although it is possible for palletised images to have more than one transparent
+    # color, this method sets the palette entry specified as the single transparent
+    # color for the image. All other colors will be set to be non-transparent by this method.
+    #
+    # As with FreeImage::Bitmap.transparency_table=, this method also sets the
+    # image's transparency property to true for palletised images.
+    def transparent_index=(value)
+      result = FreeImage.FreeImage_SetTransparentIndex(self, value)
+      FreeImage.check_last_error
+      result
+    end
+
+#  #DLL_API BOOL DLL_CALLCONV FreeImage_HasBackgroundColor(FIBITMAP *dib);
+#  attach_function('FreeImage_HasBackgroundColor', [:pointer], FreeImage::Boolean)
+#
+
+    # Returns the width of the bitmap in pixel units
+    def width
+      result = FreeImage.FreeImage_GetWidth(self)
+      FreeImage.check_last_error
+      result
+    end
+  end
+end

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

@@ -0,0 +1,261 @@
+module FreeImage
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Copy(FIBITMAP *dib, int left, int top, int right, int bottom);
+  attach_function('FreeImage_Copy', [:pointer, :int, :int, :int, :int], :pointer)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_Paste(FIBITMAP *dst, FIBITMAP *src, int left, int top, int alpha);
+  attach_function('FreeImage_Paste', [:pointer, :pointer, :int, :int, :int], FreeImage::Boolean)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Composite(FIBITMAP *fg, BOOL useFileBkg FI_DEFAULT(FALSE), RGBQUAD *appBkColor FI_DEFAULT(NULL), FIBITMAP *bg FI_DEFAULT(NULL));
+  attach_function('FreeImage_Composite', [:pointer, FreeImage::Boolean, FreeImage::RGBQuad, :pointer], :pointer)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_PreMultiplyWithAlpha(FIBITMAP *dib);
+  #attach_function('FreeImage_PreMultiplyWithAlpha', [:pointer, :int, :int, :int, :int], FreeImage::Boolean)
+
+  # DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Rescale(FIBITMAP *dib, int dst_width, int dst_height, FREE_IMAGE_FILTER filter);
+  attach_function('FreeImage_Rescale', [:pointer, :int, :int, :filter], :pointer)
+
+  # DLL_API FIBITMAP *DLL_CALLCONV FreeImage_MakeThumbnail(FIBITMAP *dib, int max_pixel_size, BOOL convert FI_DEFAULT(TRUE));
+  attach_function('FreeImage_MakeThumbnail', [:pointer, :int, FreeImage::Boolean], :pointer)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_FillBackground(FIBITMAP *dib, const void *color, int options FI_DEFAULT(0));
+  attach_function('FreeImage_FillBackground', [:pointer, :pointer, :int], FreeImage::Boolean)
+
+  #DLL_API FIBITMAP *DLL_CALLCONV FreeImage_EnlargeCanvas(FIBITMAP *src, int left, int top, int right, int bottom, const void *color, int options FI_DEFAULT(0));
+  attach_function('FreeImage_EnlargeCanvas', [:pointer, :int, :int, :int, :int, :pointer, :int], :pointer)
+
+  # Background Filling Options
+ 
+  # RGBQUAD color is a RGB color (contains no valid alpha channel)
+  COLOR_IS_RGB_COLOR = 0x00	
+
+  # RGBQUAD color is a RGBA color (contains a valid alpha channel)
+  COLOR_IS_RGBA_COLOR = 0x01	
+
+  # For palettized images: lookup equal RGB color from palette
+  COLOR_FIND_EQUAL_COLOR = 0x02	
+
+  # The color's rgbReserved member (alpha) contains the palette index to be used
+  COLOR_ALPHA_IS_INDEX = 0x04	
+
+  # No color lookup is performed
+  COLOR_PALETTE_SEARCH_MASK = (COLOR_FIND_EQUAL_COLOR | COLOR_ALPHA_IS_INDEX)	
+
+  # The \Modify module provides methods that can copy, paste, composite,
+  # and enlarge images.  It also allows the creation of thumbnails and
+  # filling background colors.
+  #
+  module Modify
+    # Composites a transparent foreground image against a background image.
+    # The equation for computing a composited sample value is:
+    #
+    #  output = alpha * foreground + (1-alpha) * background
+    #
+    # 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)
+      ptr = FreeImage.FreeImage_Composite(self, false, nil, background_bitmap)
+      FreeImage.check_last_error
+      self.class.new(ptr)
+    end
+
+    # Composites a transparent foreground image against a background color.
+    # The equation for computing a composited sample value is:
+    #
+    #  output = alpha * foreground + (1-alpha) * background
+    #
+    # 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)
+      ptr = FreeImage.FreeImage_Composite(self, false, background_color, nil)
+      FreeImage.check_last_error
+      self.class.new(ptr)
+    end
+
+    # 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)
+      ptr = FreeImage.FreeImage_Copy(self, left, top, right, bottom)
+      FreeImage.check_last_error
+      self.class.new(ptr)
+    end
+
+    # 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.
+    #
+    # To add a border to any of the image's sides, a positive integer value must be passed in
+    # any of the parameters left, top, right or bottom.  This value represents the border's
+    # width in pixels. Newly created parts of the image (the border areas)
+    # are filled with the specified color.
+    #
+    # Specifying a negative integer value for a certain side, will shrink or crop the image on
+    # this side. Consequently, specifying zero for a certain side will not
+    # change the image's extension on that side.
+    #
+    # For palletized images, the palette of the current image src is transparently
+    # copied to the newly created enlarged or shrunken image, so any color look-ups
+    # are performed on this palette.
+    #
+    # == Parameters:
+    #
+    # left:: The number of pixels the image should be enlarged on its left side. Negative
+    #        values shrink the image on its left side.
+    # top:: The number of pixels the image should be enlarged on its top side. Negative
+    #       values shrink the image on its top side.
+    # right:: The number of pixels the image should be enlarged on its right side. Negative
+    #         values shrink the image on its right side.
+    # bottom:: The number of pixels, the image should be enlarged on its bottom side.
+    #          Negative values shrink the image on its bottom side.
+    # color:: The color value to be used for filling the image.  See #fill_background for
+    #         more details.
+    # options:: Used to control color search process for palletized images. See
+    #           #fill_background for more details.
+    #
+    # Returns a new image on success or nil.
+    #
+    def enlarge_canvas(left, top, right, bottom, color, options = 0)
+      ptr = FreeImage.FreeImage_EnlargeCanvas(self, left, top, right, bottom, color, options)
+      FreeImage.check_last_error
+      self.class.new(ptr)
+    end
+
+    # Sets all pixels of an image to the specified color.
+    #
+    # == Parameters:
+    #
+    # color:: The color value to be used for filling the image.
+    #
+    #          The type of the color parameter depends on the
+    #          {image type}[rdoc-ref:FreeImage.image_types]
+    #
+    #          bitmap::  RGBQuad
+    #          rgb16::   RGB16
+    #          rgba16::  RGBA16
+    #          rgbf::    RGBF
+    #          rgbaf::   RGBFA
+    #          complex:: Complex
+    #          others::  A value of the specific type (double, int, etc.).
+    #
+    # options:: Used to control color search process for palletized images.
+    #            Allowed values are defined as constants on the FreeImage
+    #            module and include:
+    #            COLOR_IS_RGB_COLOR = 0x00
+    #            COLOR_IS_RGBA_COLOR = 0x01
+    #            COLOR_FIND_EQUAL_COLOR = 0x02
+    #            COLOR_ALPHA_IS_INDEX = 0x04
+    #            COLOR_PALETTE_SEARCH_MASK = (FI_COLOR_FIND_EQUAL_COLOR | FI_COLOR_ALPHA_IS_INDEX)
+    #
+    # Returns true on success, false on failure.
+    #
+    def fill_background!(color, options = 0)
+      result = FreeImage.FreeImage_FillBackground(self, color, options)
+      FreeImage.check_last_error
+      result
+    end
+
+    # :call-seq:
+    #   bitmap.make_thumbnail(max_pixel_size, convert = true) -> 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
+    # {filter}[rdoc-ref:FreeImage::Sampling.rescale].
+    #
+    # == Parameters:
+    #
+    # max_pixel_size:: The maximum width/height of the returned image
+    # convert:: When set to true, High Dynamic Range images (FIT_UINT16,
+    #           FIT_RGB16, FIT_RGBA16, FIT_FLOAT) are transparently converted
+    #           to standard images (i.e. 8-, 24 or 32-bit images).  The
+    #           default value is true.
+    #
+    def make_thumbnail(max_pixel_size, convert = true)
+      ptr = FreeImage.FreeImage_MakeThumbnail(self, max_pixel_size, convert)
+      FreeImage.check_last_error
+      self.class.new(ptr)
+    end
+
+    # Combines or blends a subpart of another image with the current image.
+    #
+    # == Parameters:
+    #
+    # other:: Source subimage
+    # left::  Specifies the left position of the sub image.
+    # top::   Specifies the top position of the sub image.
+    # alpha:: Alpha blend factor. If alpha is 0..255, the other images is
+    #          alpha blended withe current image. If alpha > 255, then
+    #          the other image is combined to the current image.
+    #
+    # The function returns true if successful, otherwise false.
+    #
+    def paste!(other, left, top, alpha)
+      result = FreeImage.FreeImage_Paste(self, other, left, top, alpha)
+      FreeImage.check_last_error
+      result
+    end
+
+    # :call-seq:
+    #   bitmap.rescale(width, height, filter) -> bitmap
+    #
+    # Resamples an image to the desired width and height. Resampling changes the
+    # pixel dimensions (and therefore display size) of an image.
+    # When you downsample (or decrease the number of pixels), information is deleted from
+    # the image. When you upsample (or increase the number of pixels), new pixels are
+    # added based on color values of existing pixels. You can specify an interpolation
+    # filter to determine how pixels are added or deleted using the filter parameter.
+    #
+    # Returns the newly resample image or nil if the image cannot be resampled.
+    #
+    # == Parameters:
+    #
+    # width:: The width of the new image
+    # height:: The height of the new image
+    # filter:: The filter to use when rescaling
+    #
+    # Filter options include:
+    #
+    # :box:: The simplest and fastest of the scaling algorithms.  The technique achieves
+    #        magnification by pixel replication, and minification by sparse point sampling.
+    #        For large-scale changes, box interpolation produces images with a
+    #        blocky appearance. In addition, shift errors of up to one-half pixel are
+    #        possible. These problems make this technique inappropriate when
+    #        sub-pixel accuracy is required.
+    #
+    # :bicubic:: An advanced parameterized scaling filter. It uses a cubic
+    #            to produce very smooth output while maintaining dynamic range
+    #            and sharpness. Bicubic scaling takes approximately twice the
+    #            processing time as Bilinear. This filter can be used for any
+    #            scaling application, especially when scaling factors are 2X
+    #            or greater.
+    #
+    # :bilinear:: The second-fastest scaling function. It employs linear interpolation
+    #             to determine the output image. Bilinear scaling provides reasonably
+    #             good results at moderate cost for most applications where scale
+    #             factors are relatively small (4X or less).
+    #
+    # :bspline:: Produces the smoothest output, but tends to smooth over fine details.
+    #            This function requires the same processing time as :bicubic filter.
+    #            It is recommended for applications where the smoothest output is required.
+    #
+    # :catmullrom:: The Catmull-Rom filter is generally accepted as the best cubic interpolant filter.
+    #
+    # :lanczos3:: A sinc based filter. It is the most theoretically correct filter
+    #             that produces the best output for photographic images that do not have
+    #             sharp transitions in them. However, Lanczos will produce ripple artefacts
+    #             especially for block text, due to aliasing.  It requires three times the
+    #             processing time of Bilinear. Lanczos is not recommended except in very
+    #             rare applications using band-limited photographic images with
+    #             no sharp edges.
+    #
+    def rescale(width, height, filter = :bilinear)
+      ptr = FreeImage.FreeImage_Rescale(self, width, height, filter)
+      FreeImage.check_last_error
+      self.class.new(ptr)
+    end
+  end
+end