gd2-ffij 0.0.2

data/lib/gd2/palette.rb

@@ -0,0 +1,253 @@
+#
+# Ruby/GD2 -- Ruby binding for gd 2 graphics library
+#
+# Copyright © 2005 Robert Leslie, 2010 J Smith
+#
+# This file is part of Ruby/GD2.
+#
+# Ruby/GD2 is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+module GD2
+  # = Description
+  #
+  # Palette objects are associated with an Image and hold the selection of
+  # pixel colors available to the Image. This is primarily a concern for
+  # Image::IndexedColor images, but their use with Image::TrueColor images is
+  # supported for consistency.
+  #
+  # == Obtaining
+  #
+  # Obtain a Palette object from the associated Image:
+  #
+  #   palette = image.palette
+  #
+  class Palette
+    class PaletteFullError < StandardError; end
+    class ColorNotFoundError < StandardError; end
+
+    # The Image associated with this Palette
+    attr_reader :image
+
+    def initialize(image)   #:nodoc:
+      @image = image
+    end
+
+    # Return the maximum number of colors this palette can hold.
+    def size
+      MAX_COLORS
+    end
+    alias length size
+
+    def allocated?(index)   #:nodoc:
+      @image.image_ptr[:open][index].zero?
+    end
+    protected :allocated?
+
+    # Return the number of colors presently allocated in this palette.
+    def used
+      (0...size).inject(0) do |sum, i|
+        sum + (allocated?(i) ? 1 : 0)
+      end
+    end
+
+    # Return the number of palette entries available to be allocated for new
+    # colors.
+    def available
+      size - used
+    end
+
+    # Return the color allocated to the specified +index+, or *nil* if the
+    # entry is unallocated.
+    def [](index)
+      index = size + index if index < 0
+      raise RangeError unless (0...size).include? index
+      return nil unless allocated?(index)
+      get_color(index)
+    end
+
+    # Assign (allocate) the given +color+ to the palette entry identified by
+    # +index+. If the entry was previously allocated to a different color,
+    # every pixel in the image having the given color +index+ will effectively
+    # be changed to the new color. This method cannot be used with
+    # Image::TrueColor palettes.
+    def []=(index, color)
+      raise RangeError unless (0...MAX_COLORS).include? index
+      if color.nil?
+        deallocate(self[index] ||
+          Color.new_from_palette(0, 0, 0, 0, index, self))
+      else
+        ptr = @image.image_ptr
+        ptr[:red][index] = color.red
+        ptr[:green][index] = color.green
+        ptr[:blue][index] = color.blue
+        ptr[:alpha][index] = color.alpha
+        ptr[:open][index] = 0
+      end
+    end
+
+    # Locate the given +color+ in this palette and return it if found;
+    # otherwise try to allocate the +color+, or if the palette is full, return
+    # a color from the palette that is closest to it.
+    def resolve(color)
+      raise TypeError unless color.kind_of? Color
+      c = GD2FFI.send(:gdImageColorResolveAlpha, @image.image_ptr,
+        color.red, color. green, color.blue, color.alpha)
+      c == -1 ? nil : get_color(c)
+    end
+
+    # Locate the given +color+ in this palette and return it. Returns *nil*
+    # if the color is not presently in the palette.
+    def exact(color)
+      raise TypeError unless color.kind_of? Color
+      c = GD2FFI.send(:gdImageColorExactAlpha, @image.image_ptr,
+        color.red, color.green, color.blue, color.alpha)
+      c == -1 ? nil : get_color(c)
+    end
+
+    # Like Palette#exact except an error is raised if the color is not
+    # presently in the palette.
+    def exact!(color)
+      exact(color) or raise Palette::ColorNotFoundError,
+        "Color #{color} is not in the palette"
+    end
+
+    # Return the color in this palette that is closest to the given +color+
+    # according to Euclidian distance.
+    def closest(color)
+      raise TypeError unless color.kind_of? Color
+      c = GD2FFI.send(:gdImageColorClosestAlpha, @image.image_ptr,
+        color.red, color.green, color.blue, color.alpha)
+      c == -1 ? nil : get_color(c)
+    end
+
+    # Return the color in this palette that is closest to the given +color+
+    # according to hue, whiteness, and blackness.
+    def closest_hwb(color)
+      raise TypeError unless color.kind_of? Color
+      c = GD2FFI.send(:gdImageColorClosestHWB, @image.image_ptr,
+        color.red, color.green, color.blue)
+      c == -1 ? nil : get_color(c)
+    end
+
+    # Assign the given +color+ to an unoccupied entry in this palette and
+    # return it. Does not check whether the color is already allocated, and
+    # raises an error for Image::IndexedColor palettes if the palette is full.
+    def allocate(color)
+      raise TypeError unless color.kind_of? Color
+      c = GD2FFI.send(:gdImageColorAllocateAlpha, @image.image_ptr,
+        color.red, color.green, color.blue, color.alpha)
+      c == -1 ? raise(Palette::PaletteFullError, 'Palette is full') :
+        get_color(c)
+    end
+
+    # Ensure the given +color+ is present in this palette, allocating it if
+    # necessary. Returns the palette so calls may be stacked.
+    def <<(color)
+      exact(color) or allocate(color)
+      self
+    end
+
+    # Remove the given +color+ from this palette.
+    def deallocate(color)
+      color = exact(color) unless color.index
+      return nil if color.nil? || color.index.nil?
+      GD2FFI.send(:gdImageColorDeallocate, @image.image_ptr, color.index)
+      nil
+    end
+
+    # Remove all colors from this palette that are not currently in use by the
+    # associated Image. This is an expensive operation. Returns the number of
+    # palette entries deallocated.
+    def deallocate_unused
+      # implemented by subclass
+    end
+  end
+
+  class Palette::IndexedColor < Palette
+    include Enumerable
+
+    def inspect   #:nodoc:
+      "#<#{self.class} [#{used}]>"
+    end
+
+    def get_color(index)  #:nodoc:
+      ptr = @image.image_ptr
+      Color.new_from_palette(
+        ptr[:red][index],
+        ptr[:green][index],
+        ptr[:blue][index],
+        ptr[:alpha][index],
+        index, self)
+    end
+    protected :get_color
+
+    # Iterate through every color allocated in this palette.
+    def each  #:yields: color
+      (0...MAX_COLORS).each do |i|
+        color = self[i]
+        yield color unless color.nil?
+      end
+      self
+    end
+
+    def deallocate_unused   #:nodoc:
+      used = @image.collect.flatten.uniq.inject(Array.new(MAX_COLORS)) do
+          |ary, c|
+        ary[c] = true
+        ary
+      end
+      count = 0
+      each do |color|
+        unless used.at(color.index)
+          self[color.index] = nil
+          count += 1
+        end
+      end
+      count.zero? ? nil : count
+    end
+  end
+
+  class Palette::TrueColor < Palette
+    def inspect   #:nodoc:
+      "#<#{self.class}>"
+    end
+
+    def size  #:nodoc:
+      ((1 + RGB_MAX) ** 3) * (1 + ALPHA_MAX)
+    end
+    alias length size
+    alias used size
+
+    def allocated?(index)   #:nodoc:
+      true
+    end
+    protected :allocated?
+
+    # Return *true*.
+    def include?(color)
+      true
+    end
+
+    def get_color(index)  #:nodoc:
+      Color.new_from_rgba(index)
+    end
+    protected :get_color
+
+    def []=(index, color)   #:nodoc:
+      raise "Palette assignment not supported for #{self.class}"
+    end
+  end
+end

data/test/canvas_test.rb

@@ -0,0 +1,186 @@
+require 'test/unit'
+require 'tmpdir'
+
+require 'rubygems'
+require 'gd2-ffij'
+
+require 'test/test_helper'
+
+class CanvasTest < Test::Unit::TestCase
+  include TestHelper
+
+  def test_line
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.line(64, 64, 192, 192)
+    end
+    assert(image == load_image('test_canvas_line.gd2'))
+  end
+
+  def test_rectangle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.rectangle(64, 64, 192, 192)
+    end
+    assert(image == load_image('test_canvas_rectangle.gd2'))
+  end
+
+  def test_filled_rectangle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.rectangle(64, 64, 192, 192, true)
+    end
+    assert(image == load_image('test_canvas_filled_rectangle.gd2'))
+  end
+
+  def test_polygon
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.polygon([
+        [ 64, 64 ],
+        [ 192, 192 ],
+        [ 64, 128 ]
+      ])
+    end
+    assert(image == load_image('test_canvas_polygon.gd2'))
+  end
+
+  def test_filled_polygon
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.polygon([
+        [ 64, 64 ],
+        [ 192, 192 ],
+        [ 64, 128 ]
+      ], true)
+    end
+    assert(image == load_image('test_canvas_filled_polygon.gd2'))
+  end
+
+  def test_move_to_and_line_to
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+      pen.move_to(64, 64)
+      pen.line_to(128, 128)
+    end
+    assert(image == load_image('test_canvas_move_to_and_line_to.gd2'))
+  end
+
+  def test_fill
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.rectangle(64, 64, 192, 192)
+      pen.move_to(65, 65)
+      pen.fill
+    end
+    assert(image == load_image('test_fill.gd2'))
+  end
+
+  def test_arc
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.arc(128, 128, 128, 128, 0..256)
+    end
+    assert(image == load_image('test_arc.gd2'))
+  end
+
+  def test_text
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
+      pen.move_to(0, 128)
+      pen.text("HELLO")
+      pen.move_to(256, 128)
+      pen.text("WORLD", Math::PI)
+    end
+    assert(image == load_image('test_text.gd2'))
+  end
+
+  def test_text_circle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
+      pen.move_to(128, 128)
+      pen.text_circle('HELLO', 'WORLD', 100, 20, 1)
+    end
+    assert(image == load_image('test_text_circle.gd2'))
+  end
+
+  def test_wedge
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.wedge(128, 128, 256, 256, 0..180)
+    end
+    assert(image == load_image('test_wedge.gd2'))
+  end
+
+  def test_filled_wedge
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.wedge(128, 128, 256, 256, 0..180, true)
+    end
+    assert(image == load_image('test_filled_wedge.gd2'))
+  end
+
+  def test_ellipse
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.ellipse(128, 128, 64, 32)
+    end
+    assert(image == load_image('test_ellipse.gd2'))
+  end
+
+  def test_filled_ellipse
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.ellipse(128, 128, 64, 32, true)
+    end
+    assert(image == load_image('test_filled_ellipse.gd2'))
+  end
+
+  def test_circle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.circle(128, 128, 128)
+    end
+    assert(image == load_image('test_circle.gd2'))
+  end
+
+  def test_filled_circle
+    image = new_image
+    image.draw do |pen|
+      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+      pen.circle(128, 128, 128, true)
+    end
+    assert(image == load_image('test_filled_circle.gd2'))
+  end
+
+  def test_fill_to
+    image = new_image
+    image.draw do |pen|
+      blue = image.palette.resolve(GD2::Color[32, 64, 128])
+      red  = image.palette.resolve(GD2::Color[255, 0, 0])
+      pen.color = blue
+      pen.arc(128, 128, 256, 64, 0..(Math::PI))
+      pen.color = red
+      pen.move(128, 128)
+      pen.fill_to(blue)
+    end
+    assert(image == load_image('test_fill_to.gd2'))
+  end
+end

data/test/image_test.rb

@@ -0,0 +1,149 @@
+require 'test/unit'
+require 'tmpdir'
+
+require 'rubygems'
+require 'gd2-ffij'
+
+require 'test/test_helper'
+
+class ImageTest < Test::Unit::TestCase
+  include TestHelper
+
+  def test_image_new_and_release
+    img = GD2::Image.new(50, 50)
+  end
+
+  def test_image_true_color_new_and_release
+    img = GD2::Image::TrueColor.new(50, 50)
+  end
+
+  def test_image_indexed_color_new_and_release
+    img = GD2::Image::IndexedColor.new(50, 50)
+  end
+
+  [ :png, :gif, :jpg, :wbmp, :gd2 ].each do |ext|
+    self.class_eval(<<-EOF)
+      def test_load_#{ext}_from_file
+        img = GD2::Image.load(File.open(File.join(PATH_TO_IMAGES, 'test.#{ext}')))
+      end
+
+      def test_load_#{ext}_from_string
+        img = GD2::Image.load(File.read(File.join(PATH_TO_IMAGES, 'test.#{ext}')))
+      end
+    EOF
+  end
+
+  # TODO: add xbm, xpm and wbmp tests
+  [ :png, :gif, :jpg, :gd, :gd2 ].each do |ext|
+    self.class_eval(<<-EOF)
+      def test_import_#{ext}_from_file
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+      end
+
+      def test_export_#{ext}
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2'))
+        out = File.join(Dir.tmpdir, 'test.#{ext}')
+        img.export(out)
+
+        assert(File.exists?(out))
+
+        imgA = GD2::Image.import(out)
+        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+
+        assert(imgA == imgB)
+
+        File.unlink(out)
+      end
+
+      def test_compare_#{ext}
+        imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        assert_equal(imgA.compare(imgB), 0)
+        assert_equal(imgA.compare(imgA.dup), 0)
+      end
+
+      def test_eqeq_#{ext}
+        imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        assert(imgA == imgB)
+        assert(imgA == imgA.dup)
+      end
+
+      def test_height_#{ext}
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        assert_equal(img.height, 256)
+      end
+
+      def test_width_#{ext}
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        assert_equal(img.width, 256)
+      end
+
+      def test_size_#{ext}
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        assert_equal(img.size, [ 256, 256 ])
+      end
+
+      def test_aspect_#{ext}
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+        assert_in_delta(img.aspect, 1.0, 0.00000001)
+      end
+    EOF
+  end
+
+  def test_rotate
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).rotate!(Math::PI)
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_rotated_180.gd2'))
+
+    assert(imgA == imgB)
+  end
+
+  def test_crop
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).crop!(64, 64, 128, 128)
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_cropped.gd2'))
+
+    assert(imgA == imgB)
+  end
+
+  def test_uncrop
+    img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).crop!(64, 64, 128, 128)
+    img.uncrop!(64)
+
+    assert_equal(img.size, [ 256, 256 ])
+  end
+
+  def test_resize
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).resize!(512, 512)
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_resized.gd2'))
+
+    assert(imgA == imgB)
+  end
+
+  def test_resampled
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).resize!(512, 512, true)
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_resampled.gd2'))
+
+    assert(imgA == imgB)
+  end
+
+  def test_polar_transform
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).polar_transform!(100)
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_polar_transform.gd2'))
+
+    assert(imgA == imgB)
+  end
+
+  def test_color_sharpened
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color.gd2')).sharpen(100)
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color_sharpened.gd2'))
+
+    assert(imgA == imgB)
+  end
+
+  def test_resampled
+    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color.gd2')).to_indexed_color
+    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color_indexed.gd2'))
+
+    assert(imgA == imgB)
+  end
+end