free-image 0.5.0

data/lib/free-image/types/boolean.rb

@@ -0,0 +1,14 @@
+module FreeImage
+  class Boolean
+    extend FFI::DataConverter
+    native_type :uint32
+
+    def self.to_native(val, ctx)
+      val == false ? 0 : 1
+    end
+
+    def self.from_native(val, ctx)
+      val == 0 ? false : true
+    end
+  end
+end

data/lib/free-image/types/complex.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module FreeImage
+  # Structure for COMPLEX type (complex number) images
+  class Complex < FFI::Struct
+    layout :r, :double,
+           :i, :double
+  end
+end

data/lib/free-image/types/ffi.rb

@@ -0,0 +1,14 @@
+module FreeImage
+  if !self.msvc?
+    typedef :int32,  :bool
+    typedef :uint32, :byte
+    typedef :uint16, :word
+    typedef :uint32, :dword
+    typedef :int32,  :long
+  else
+    typedef :long,   :bool
+    typedef :uchar,  :byte
+    typedef :ushort, :word
+    typedef :ulong,  :dword
+  end
+end

data/lib/free-image/types/rgb16.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module FreeImage
+  # Used to specify a color for a :rgb16
+  # {image type}[rdoc-ref:FreeImage.images_types].
+  class RGB16 < FFI::Struct
+    layout :red, :word,
+           :green, :word,
+           :blue, :word
+  end
+end

data/lib/free-image/types/rgb_quad.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+module FreeImage
+  # Used to specify a color for a :bitmap
+  # {image type}[rdoc-ref:FreeImage.images_types].
+  #--
+  # This structure is packed with pragma (1)
+  class RGBQuad < FFI::Struct
+    if FFI::Platform::BYTE_ORDER == FFI::Platform::LITTLE_ENDIAN
+      layout :blue,     :byte, 0,
+             :green,    :byte, 1,
+             :red,      :byte, 2,
+             :reserved, :byte, 3
+    else
+      layout :red,      :byte, 0,
+             :green,    :byte, 1,
+             :blue,     :byte, 2,
+             :reserved, :byte, 3
+    end
+
+    # Define masks to extract colors from bytes
+    if FFI::Platform::BYTE_ORDER == FFI::Platform::LITTLE_ENDIAN
+      # Little Endian (x86 / MS Windows, Linux) : BGR(A) order
+      RED         = 2
+      GREEN		    = 1
+      BLUE			  = 0
+      ALPHA			  = 3
+      RED_MASK	  = 0x00FF0000
+      GREEN_MASK  = 0x0000FF00
+      BLUE_MASK	  = 0x000000FF
+      ALPHA_MASK  = 0xFF000000
+      RED_SHIFT   = 16
+      GREEN_SHIFT = 8
+      BLUE_SHIFT  =	0
+      ALPHA_SHIFT =	24
+    else
+      # Big Endian (PPC / Linux, MaxOSX) : RGB(A) order
+      RED			    =	0
+      GREEN			  = 1
+      BLUE		    =	2
+      ALPHA			  = 3
+      RED_MASK		= 0xFF000000
+      GREEN_MASK	=	0x00FF0000
+      BLUE_MASK		= 0x0000FF00
+      ALPHA_MASK	=	0x000000FF
+      RED_SHIFT		= 24
+      GREEN_SHIFT	=	16
+      BLUE_SHIFT	=	8
+      ALPHA_SHIFT	=	0
+    end
+    RGB_MASK  = (RED_MASK | GREEN_MASK | BLUE_MASK)
+
+    # Creates a new RGBQuad color
+    #
+    # == Parameters
+    # red:: Value for red, should be between 0 and 255
+    # green:: Value for green, should be between 0 and 255
+    # blue:: Value for blue, should be between 0 and 255
+    # reserved:: Reserved value, by default is 0
+    def self.create(red, green, blue, reserved = 0)
+      result = self.new
+      result[:red] = red
+      result[:green] = green
+      result[:blue] = blue
+      result[:reserved] = reserved
+      result
+    end
+
+    def eql?(other)
+      other.instance_of?(RGBQuad) and
+      self[:red]   == other[:red] and
+      self[:green] == other[:green] and
+      self[:blue]  == other[:blue] and
+      self[:reserved]  == other[:reserved]
+    end
+    alias :== :eql?
+
+    def to_s
+      "RGBQuad - Red: #{self[:red]}, Green: #{self[:green]}, Blue: #{self[:blue]}, Alpha: #{self[:reserved]}"
+    end
+  end
+end

data/lib/free-image/types/rgb_triple.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module FreeImage
+  class RGBTriple < FFI::Struct
+    if FFI::Platform::BYTE_ORDER == FFI::Platform::LITTLE_ENDIAN
+      layout :blue,     :byte, 0,
+             :green,    :byte, 1,
+             :red,      :byte, 2
+    else
+      layout :red,      :byte, 0,
+             :green,    :byte, 1,
+             :blue,     :byte, 2
+    end
+
+    # Creates a new RGBTriple color
+    #
+    # == Parameters
+    # red:: Value for red, should be between 0 and 255
+    # green:: Value for green, should be between 0 and 255
+    # blue:: Value for blue, should be between 0 and 255
+    #
+    def self.create(red, green, blue)
+      result = self.new
+      result[:red] = red
+      result[:green] = green
+      result[:blue] = blue
+      result
+    end
+
+    def eql?(other)
+      other.instance_of?(RGBQuad) and
+      self[:red]   == other[:red] and
+      self[:green] == other[:green] and
+      self[:blue]  == other[:blue]
+    end
+    alias :== :eql?
+
+    def to_s
+      "RGBQuad - Red: #{self[:red]}, Green: #{self[:green]}, Blue: #{self[:blue]}"
+    end
+  end
+end

data/lib/free-image/types/rgba16.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+module FreeImage
+  # Used to specify a color for a :rgb16a
+  # {image type}[rdoc-ref:FreeImage.images_types].
+  class RGBA16 < FFI::Struct
+    layout :red, :word,
+           :green, :word,
+           :blue, :word,
+           :alpha, :word
+  end
+end

data/lib/free-image/types/rgbaf.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+module FreeImage
+  # Used to specify a color for a :rgbaf
+  # {image type}[rdoc-ref:FreeImage.images_types].
+  class RGBAF < FFI::Struct
+    layout :red, :float,
+           :green, :float,
+           :blue, :float,
+           :alpha, :float
+  end
+end

data/lib/free-image/types/rgbf.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module FreeImage
+  # Used to specify a color for a :rgbf
+  # {image type}[rdoc-ref:FreeImage.images_types].
+  class RGBF < FFI::Struct
+    layout :red, :float,
+           :green, :float,
+           :blue, :float
+  end
+end

data/test/cookbook.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+def set_to_red(color)
+  color[:red] = 255
+  color[:green] = 0
+  color[:blue] = 0
+end
+
+image = FreeImage::Bitmap.open('images/lena.png')
+thumbnail = image.make_thumbnail(100)
+
+# Make the bottom row red
+scanline = thumbnail.scanline(0)
+
+# Draw bottom border
+(0..3).each do |index|
+  scanline = thumbnail.scanline(index)
+  scanline.each do |color|
+    set_to_red(color)
+  end
+end
+
+# Draw top border
+((thumbnail.height - 5)..(thumbnail.height - 1)).each do |index|
+  scanline = thumbnail.scanline(index)
+  scanline.each do |color|
+    set_to_red(color)
+  end
+end
+
+# Draw left and right borders
+(1..(thumbnail.height - 2)).each do |index|
+  scanline = thumbnail.scanline(index)
+  (0..4).each do |index|
+    set_to_red(scanline[index])
+  end
+
+  ((thumbnail.width - 5)..(thumbnail.width - 1)).each do |index|
+    set_to_red(scanline[index])
+  end
+end
+
+thumbnail.save("images/lena_thumbnail_border_scanline.png", :png)

data/test/test_bitmap.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class BitmapTest < Test::Unit::TestCase
+  def test_bits
+    bytes = sample_image.bits
+    assert_equal(6466, bytes.size)
+
+    if defined?(Encoding)
+      assert_equal(Encoding::BINARY, bytes.encoding)
+      assert_equal(bytes.size, bytes.bytesize)
+    end
+  end
+
+  def test_open
+    bitmap = FreeImage::Bitmap.open('images/lena.png')
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+  end
+
+  def test_open_yield
+    result = FreeImage::Bitmap.open('images/lena.png') do |bitmap|
+      assert_kind_of(FreeImage::Bitmap, bitmap)
+    end
+    assert_equal(true, result)
+  end
+
+  def test_open_yield_error
+    assert_raise(ArgumentError) do
+      FreeImage::Bitmap.open('images/lena.png') do |bitmap|
+        raise(ArgumentError, "Let's mess things up")
+      end
+    end
+  end
+
+  def test_free
+    1000.times do
+      image = sample_image
+      image.free
+    end
+  end
+end

data/test/test_conversions.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class ConverstionsTest < Test::Unit::TestCase
+  def test_convert_to_4bits
+    bitmap = sample_image.convert_to_4bits
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(4, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_8bits
+    bitmap = sample_image.convert_to_8bits
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(8, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_greyscale
+    bitmap = sample_image.convert_to_greyscale
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(8, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_16bits_555
+    bitmap = sample_image.convert_to_16bits_555
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(16, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_16bits_565
+    bitmap = sample_image.convert_to_16bits_565
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(16, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_24bits
+    bitmap = sample_image.convert_to_24bits
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(24, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_32bits
+    bitmap = sample_image.convert_to_32bits
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(32, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_standard_type
+    bitmap = sample_image.convert_to_standard_type
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(8, bitmap.bits_per_pixel)
+  end
+
+  def test_convert_to_type
+    bitmap = sample_image.convert_to_type(:rgb16)
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(48, bitmap.bits_per_pixel)
+  end
+
+  def test_dither
+    bitmap = sample_image.dither(:bayer4x4)
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(1, bitmap.bits_per_pixel)
+  end
+
+  def test_threshold
+    bitmap = sample_image.threshold(7)
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+    assert_equal(1, bitmap.bits_per_pixel)
+  end
+
+  def test_threshold_low
+    error = assert_raise(RangeError) do
+      sample_image.threshold(-1)
+    end
+    assert_equal("Value is out of range 0..255. Value: -1", error.message)
+  end
+
+  def test_threshold_hight
+    error = assert_raise(RangeError) do
+      sample_image.threshold(5555)
+    end
+    assert_equal("Value is out of range 0..255. Value: 5555", error.message)
+  end
+end

data/test/test_file.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class FIFileTest < Test::Unit::TestCase
+  def file(image = 'sample.png')
+    path = image_path(image)
+    FreeImage::File.new(path)
+  end
+  
+  def test_format
+    assert_equal(:png, file.format)
+  end
+
+  def test_format_unknown
+    assert_equal(:unknown, file('not_an_image.txt').format)
+  end
+
+  def test_load
+    bitmap = file.open
+    assert_kind_of(FreeImage::Bitmap, bitmap)
+  end
+
+  def test_load_format
+    error = assert_raise(FreeImage::Error) do
+      file('not_an_image.txt').open
+    end
+    assert_equal('Cannot load :unknown image format', error.to_s)
+  end
+
+  def test_load_wrong_format
+    error = assert_raise(FreeImage::Error) do
+      file.open(:jpeg)
+    end
+    assert_equal("Not a JPEG file: starts with 0x89 0x50", error.to_s)
+  end
+
+  def test_save
+    tmp_file = Tempfile.new('test_free_image')
+    dst = FreeImage::File.new(tmp_file.path)
+
+    bitmap = file.open
+    result = bitmap.save(dst, :png)
+    assert(result)
+    assert(File.exists?(tmp_file))
+  ensure
+    tmp_file.close
+    tmp_file.unlink
+  end
+end