gd2 1.0 → 1.1

data/Rakefile

@@ -16,7 +16,7 @@ spec = Gem::Specification.new do |s|
 
   s.files             = FileList['README', 'COPY*', 'Rakefile', 'lib/**/*.rb']
   s.autorequire       = 'gd2'
-  s.requirements      << 'libgd, v2.0.33 or greater'
+  s.requirements     << 'libgd, v2.0.33 or greater'
   s.test_files        = FileList['test/*.rb']
 
   s.has_rdoc          = true

data/lib/gd2.rb

@@ -24,9 +24,9 @@ require 'dl'
 require 'rbconfig'
 
 module GD2
-  VERSION = '1.0'.freeze
+  VERSION = '1.1'.freeze
 
-  LIB = DL.dlopen(Config::CONFIG['arch'] == 'powerpc-darwin' ?
+  LIB = DL.dlopen(Config::CONFIG['arch'].include?('powerpc-darwin') ?
     'libgd.2.dylib' : 'libgd.so.2')
   SYM = {
     :gdImageCreate                      => 'PII',
@@ -70,6 +70,12 @@ module GD2
     :gdImagePolygon                     => '0PPII',
     :gdImageOpenPolygon                 => '0PPII',
     :gdImageFilledPolygon               => '0PPII',
+    :gdImageArc                         => '0PIIIIIII',
+    :gdImageFilledArc                   => '0PIIIIIIII',
+#   :gdImageEllipse                     => '0PIIIII',
+    :gdImageFilledEllipse               => '0PIIIII',
+    :gdImageFill                        => '0PIII',
+    :gdImageFillToBorder                => '0PIIII',
     :gdImageSetClip                     => '0PIIII',
     :gdImageGetClip                     => '0Piiii',
     :gdImageBoundsSafe                  => 'IPII',
@@ -127,7 +133,7 @@ module GD2
   CMP_INTERLACE     = 128  # Interlaced setting
   CMP_TRUECOLOR     = 256  # Truecolor vs palette differs
 
-  # Format flags for Image#gd2_data
+  # Format flags for Image#gd2
 
   FMT_RAW           =   1
   FMT_COMPRESSED    =   2
@@ -158,6 +164,7 @@ class Numeric
     def degrees
       self * 2 * Math::PI / 360
     end
+    alias degree degrees
   end
 
   if not self.instance_methods.include? 'to_degrees'

data/lib/gd2/canvas.rb

@@ -20,6 +20,8 @@
 # 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 
+require 'matrix'
+
 module GD2
   class Canvas
     class NoColorSelectedError < StandardError; end
@@ -36,6 +38,15 @@ module GD2
         [@x, @y]
       end
 
+      def transform!(matrix)
+        @x, @y = (Matrix.row_vector([@x, @y, 1]) * matrix)[0, 0..1]
+        self
+      end
+
+      def transform(matrix)
+        dup.transform!(matrix)
+      end
+
       def draw(image, mode)
         image.set_pixel(@x, @y, mode)
       end
@@ -103,6 +114,73 @@ module GD2
       end
     end
 
+    class Arc
+      def initialize(center, width, height, range)
+        @center, @width, @height = center, width, height
+        @range = Range.new(360.degrees - range.end, 360.degrees - range.begin,
+          range.exclude_end?)
+      end
+
+      def draw(image, mode)
+        SYM[:gdImageArc].call(image.image_ptr, @center.x, @center.y,
+          @width, @height,
+          @range.begin.to_degrees.round, @range.end.to_degrees.round, mode)
+        nil
+      end
+    end
+
+    class Wedge < Arc
+      # Arc styles
+
+      ARC             = 0
+      PIE             = ARC
+      CHORD           = 1
+      NO_FILL         = 2
+      EDGED           = 4
+
+      def initialize(center, width, height, range, chord = false)
+        super(center, width, height, range)
+        @chord = chord
+      end
+
+      def draw(image, mode)
+        SYM[:gdImageFilledArc].call(image.image_ptr, @center.x, @center.y,
+          @width, @height,
+          @range.begin.to_degrees.round, @range.end.to_degrees.round,
+          mode, style)
+        nil
+      end
+
+      def style
+        (@chord ? CHORD : ARC) | NO_FILL | EDGED
+      end
+    end
+
+    class FilledWedge < Wedge
+      def style
+        super & ~(NO_FILL | EDGED)
+      end
+    end
+
+    class Ellipse
+      def initialize(center, width, height)
+        @center, @width, @height = center, width, height
+      end
+
+      def draw(image, mode)
+        SYM[:gdImageArc].call(image.image_ptr, @center.x, @center.y,
+          @width, @height, 0, 360, mode)
+        nil
+      end
+    end
+
+    class FilledEllipse < Ellipse
+      def draw(image, mode)
+        SYM[:gdImageFilledEllipse].call(image.image_ptr, @center.x, @center.y,
+          @width, @height, mode)
+      end
+    end
+
     class Text
       def initialize(font, point, angle, string)
         @font = font
@@ -134,23 +212,25 @@ module GD2
       end
     end
 
-    attr_reader :color, :thickness, :style, :brush, :tile, :dont_blend
+    attr_reader :color, :thickness, :style, :brush, :tile, :dont_blend,
+      :transformation_matrix
     attr_accessor :anti_aliasing, :font
 
     # Special colors
 
-    STYLED            = -2
-    BRUSHED           = -3
-    STYLED_BRUSHED    = -4
-    TILED             = -5
+    STYLED          = -2
+    BRUSHED         = -3
+    STYLED_BRUSHED  = -4
+    TILED           = -5
 
-    TRANSPARENT       = -6  # Line styles only; not a color index
-    ANTI_ALIASED      = -7
+    TRANSPARENT     = -6  # Line styles only; not a color index
+    ANTI_ALIASED    = -7
 
     def initialize(image)
       @image = image
       self.thickness = 1
       self.anti_aliasing = false
+      @transformation_matrix = Matrix.identity(3)
       move_to(0, 0)
     end
 
@@ -167,7 +247,7 @@ module GD2
       if @style = ary
         SYM[:gdImageSetStyle].call(@image.image_ptr,
           ary.map { |c|
-            !c ? TRANSPARENT : c == true ? -1 : @image.color2pixel(c)
+            !c ? TRANSPARENT : true == c ? -1 : @image.color2pixel(c)
           }, ary.length)
       end
     end
@@ -190,8 +270,37 @@ module GD2
       @dont_blend = color ? @image.color2pixel(color) : nil
     end
 
+    def affine_transform(a, b, c, d, tx, ty)
+      old_matrix = @transformation_matrix
+      begin
+        @transformation_matrix = Matrix[[a, b, 0], [c, d, 0], [tx, ty, 1]] *
+          @transformation_matrix
+        yield
+      ensure
+        @transformation_matrix = old_matrix
+      end
+    end
+
+    def translate(tx, ty, &block)
+      affine_transform(1, 0, 0, 1, tx, ty, &block)
+    end
+
+    def scale(sx, sy = sx, &block)
+      affine_transform(sx, 0, 0, sy, 0, 0, &block)
+    end
+
+    def rotate(angle, &block)
+      cos = Math.cos(angle)
+      sin = Math.sin(angle)
+      affine_transform(cos, sin, -sin, cos, 0, 0, &block)
+    end
+
+    def cartesian(&block)
+      affine_transform(1, 0, 0, -1, 0, @image.height - 1, &block)
+    end
+
     def point(x, y)
-      Point.new(x, y)
+      Point.new(x, y).transform!(transformation_matrix)
     end
 
     def move_to(x, y)
@@ -200,12 +309,14 @@ module GD2
     end
 
     def move(x, y)
-      @point = point(@point.x + x, @point.y + y)
+      @point.transform!(Matrix[[1, 0, 0], [0, 1, 0], [x, y, 1]] *
+        @transformation_matrix)
+      # @point = point(@point.x + x, @point.y + y)
       self
     end
 
     def location
-      @point.coordinates
+      @point.transform(transformation_matrix.inverse).coordinates
     end
 
     def line(x1, y1, x2, y2)
@@ -214,14 +325,26 @@ module GD2
 
     def line_to(x, y)
       point2 = point(x, y)
-      line(@point.x, @point.y, point2.x, point2.y)
+      Line.new(@point, point2).draw(@image, line_pixel)
       @point = point2
       self
     end
 
+    def fill
+      SYM[:gdImageFill].call(@image.image_ptr, @point.x, @point.y, fill_pixel)
+      self
+    end
+
+    def fill_to(border)
+      # An apparent bug in gd prevents us from using fill_pixel
+      SYM[:gdImageFillToBorder].call(@image.image_ptr, @point.x, @point.y,
+        @image.color2pixel(border), pixel)
+      self
+    end
+
     def rectangle(x1, y1, x2, y2, filled = false)
-      (filled ? FilledRectangle : Rectangle).new(point(x1, y1),
-        point(x2, y2)).draw(@image, filled ? fill_pixel : line_pixel)
+      (filled ? FilledRectangle : Rectangle).new(point(x1, y1), point(x2, y2)).
+        draw(@image, filled ? fill_pixel : line_pixel)
     end
 
     def polygon(points, filled = false, open = false)
@@ -233,6 +356,24 @@ module GD2
       end
     end
 
+    def arc(cx, cy, width, height, range)
+      Arc.new(point(cx, cy), width, height, range).draw(@image, line_pixel)
+    end
+
+    def wedge(cx, cy, width, height, range, filled = false, chord = false)
+      (filled ? FilledWedge : Wedge).new(point(cx, cy), width, height,
+        range, chord).draw(@image, filled ? fill_pixel : line_pixel)
+    end
+
+    def ellipse(cx, cy, width, height, filled = false)
+      (filled ? FilledEllipse : Ellipse).new(point(cx, cy), width, height).
+        draw(@image, filled ? fill_pixel : line_pixel)
+    end
+
+    def circle(cx, cy, diameter, filled = false)
+      ellipse(cx, cy, diameter, diameter, filled)
+    end
+
     def text(string, angle = 0.0)
       Text.new(get_font, @point, angle, string).draw(@image, pixel)
     end

data/lib/gd2/color.rb

@@ -127,7 +127,7 @@ module GD2
     # Compare this color with another color. Returns *true* if the associated
     # red, green, blue, and alpha components are identical.
     def ==(other)
-      rgba == other.rgba
+      other.kind_of?(Color) && rgba == other.rgba
     end
 
     # Return *true* if this color is visually identical to another color.

data/lib/gd2/font.rb

@@ -30,11 +30,11 @@ module GD2
   #
   # The following font classes may be used without further instantiation:
   #
+  #   Font::Tiny
   #   Font::Small
-  #   Font::Large
   #   Font::MediumBold
+  #   Font::Large
   #   Font::Giant
-  #   Font::Tiny
   #
   # == TrueType Fonts
   #

data/lib/gd2/image.rb

@@ -144,47 +144,52 @@ module GD2
     end
     private_class_method :data_type
 
-    # Import an image from a file with the given +filename+. The file extension
-    # is used to determine the image type (JPEG, PNG, GIF, WBMP, GD, GD2, XBM,
-    # or XPM). The resulting image will be either of class Image::TrueColor or
-    # Image::IndexedColor.
+    # Import an image from a file with the given +filename+. The :format option
+    # or the file extension is used to determine the image type (jpeg, png,
+    # gif, wbmp, gd, gd2, xbm, or xpm). The resulting image will be either of
+    # class Image::TrueColor or Image::IndexedColor.
     #
-    # If the file type is GD2, it is optionally possible to extract only a part
-    # of the image. Use options :x, :y, :w, and :h to specify the part of the
-    # image to import.
+    # If the file format is gd2, it is optionally possible to extract only a
+    # part of the image. Use options :x, :y, :width, and :height to specify the
+    # part of the image to import.
     def self.import(filename, options = {})
-      md = filename.match /\.([^.]+)\z/
-      ext = md ? md[1].downcase : nil
-      if ext == 'xpm'
+      unless format = options.delete(:format)
+        md = filename.match /\.([^.]+)\z/
+        format = md ? md[1].downcase : nil
+      end
+      format = format.to_sym if format
+
+      if format == :xpm
         raise ArgumentError, "Unexpected options #{options.inspect}" unless
           options.empty?
         ptr = SYM[:gdImageCreateFromXpm].call(filename)[0]
-      elsif ext == 'gd2' && !options.empty?
-        x, y, w, h =
+      elsif format == :gd2 && !options.empty?
+        x, y, width, height =
           options.delete(:x) || 0, options.delete(:y) || 0,
-          options.delete(:w), options.delete(:h)
+          options.delete(:width)  || options.delete(:w),
+          options.delete(:height) || options.delete(:h)
         raise ArgumentError, "Unexpected options #{options.inspect}" unless
           options.empty?
-        raise ArgumentError, 'Missing required option :w' if w.nil?
-        raise ArgumentError, 'Missing required option :h' if h.nil?
+        raise ArgumentError, 'Missing required option :width' if width.nil?
+        raise ArgumentError, 'Missing required option :height' if height.nil?
         ptr = File.open(filename) do |file|
-          SYM[:gdImageCreateFromGd2Part].call(file, x, y, w, h)[0]
+          SYM[:gdImageCreateFromGd2Part].call(file, x, y, width, height)[0]
         end
       else
         raise ArgumentError, "Unexpected options #{options.inspect}" unless
           options.empty?
         create_sym = {
-          'jpeg'  => :gdImageCreateFromJpeg,
-          'jpg'   => :gdImageCreateFromJpeg,
-          'png'   => :gdImageCreateFromPng,
-          'gif'   => :gdImageCreateFromGif,
-          'wbmp'  => :gdImageCreateFromWBMP,
-          'gd'    => :gdImageCreateFromGd,
-          'gd2'   => :gdImageCreateFromGd2,
-          'xbm'   => :gdImageCreateFromXbm
-        }[ext]
+          :jpeg => :gdImageCreateFromJpeg,
+          :jpg  => :gdImageCreateFromJpeg,
+          :png  => :gdImageCreateFromPng,
+          :gif  => :gdImageCreateFromGif,
+          :wbmp => :gdImageCreateFromWBMP,
+          :gd   => :gdImageCreateFromGd,
+          :gd2  => :gdImageCreateFromGd2,
+          :xbm  => :gdImageCreateFromXbm
+        }[format]
         raise UnrecognizedImageTypeError,
-          'File extension is not recognized' unless create_sym
+          'Format (or file extension) is not recognized' unless create_sym
         ptr = File.open(filename) { |file| SYM[create_sym].call(file)[0] }
       end
       raise LibraryError unless ptr
@@ -405,8 +410,8 @@ module GD2
     # operations.
     def with_clipping(x1, y1, x2, y2)   #:yields: image
       clip = clipping
+      set_clip = SYM[:gdImageSetClip]
       begin
-        set_clip = SYM[:gdImageSetClip]
         set_clip.call(image_ptr, x1, y1, x2, y2)
         yield self
         self
@@ -434,37 +439,42 @@ module GD2
     end
 
     # Export this image to a file with the given +filename+. The image format
-    # is determined by the file extension (JPEG, PNG, GIF, WBMP, GD, or GD2).
-    # Returns the size of the written image data. The +options+ are as
-    # arguments for the Image#jpeg, Image#png, Image#wbmp, or Image#gd2
-    # methods.
+    # is determined by the :format option, or by the file extension (jpeg, png,
+    # gif, wbmp, gd, or gd2). Returns the size of the written image data.
+    # Additional +options+ are as arguments for the Image#jpeg, Image#png,
+    # Image#wbmp, or Image#gd2 methods.
     def export(filename, options = {})
-      md = filename.match /\.([^.]+)\z/
-      case ext = md ? md[1].downcase : nil
-      when 'jpeg', 'jpg'
+      unless format = options.delete(:format)
+        md = filename.match /\.([^.]+)\z/
+        format = md ? md[1].downcase : nil
+      end
+      format = format.to_sym if format
+
+      case format
+      when :jpeg, :jpg
         write_sym = :gdImageJpeg
         args = [nil, options.delete(:quality) || -1]
-      when 'png'
+      when :png
         write_sym = :gdImagePngEx
         args = [nil, options.delete(:level) || -1]
-      when 'gif'
+      when :gif
         write_sym = :gdImageGif
         args = [nil]
-      when 'wbmp'
+      when :wbmp
         write_sym = :gdImageWBMP
         fgcolor = options.delete(:fgcolor)
         raise ArgumentError, 'Missing required option :fgcolor' if fgcolor.nil?
         args = [color2pixel(fgcolor), nil]
-      when 'gd'
+      when :gd
         write_sym = :gdImageGd
         args = [nil]
-      when 'gd2'
+      when :gd2
         write_sym = :gdImageGd2
         args = [nil, options.delete(:chunk_size) || 0,
-          options.delete(:fmt) || options.delete(:format) || FMT_COMPRESSED]
+          options.delete(:fmt) || FMT_COMPRESSED]
       else
         raise UnrecognizedImageTypeError,
-          'File extension is not recognized'
+          'Format (or file extension) is not recognized'
       end
 
       raise ArgumentError, "Unrecognized options #{options.inspect}" unless
@@ -549,9 +559,9 @@ module GD2
     end
 
     # Copy a portion of another image to this image, rotating the source
-    # portion first by the indicated +angle+. The +dst_x+ and +dst_y+ arguments
-    # indicate the _center_ of the desired destination, and may be floating
-    # point.
+    # portion first by the indicated +angle+ (in radians). The +dst_x+ and
+    # +dst_y+ arguments indicate the _center_ of the desired destination, and
+    # may be floating point.
     def copy_from_rotated(other, dst_x, dst_y, src_x, src_y, w, h, angle)
       SYM[:gdImageCopyRotated].call(image_ptr, other.image_ptr,
         dst_x.to_f, dst_y.to_f, src_x, src_y, w, h, angle.to_degrees.round)
@@ -568,8 +578,8 @@ module GD2
       self
     end
 
-    # Rotate this image by the given +angle+ about the given axis coordinates.
-    # Note that some of the edges of the image may be lost.
+    # Rotate this image by the given +angle+ (in radians) about the given axis
+    # coordinates. Note that some of the edges of the image may be lost.
     def rotate!(angle, axis_x = width / 2.0, axis_y = height / 2.0)
       ptr = self.class.create_image_ptr(width, height, alpha_blending?)
       SYM[:gdImageCopyRotated].call(ptr, image_ptr,
@@ -696,8 +706,7 @@ module GD2
     end
 
     def color2pixel(color)  #:nodoc:
-      return color.index if color.from_palette?(palette)
-      palette.exact!(color).index
+      color.from_palette?(palette) ? color.index : palette.exact!(color).index
     end
 
     def alpha_blending?   #:nodoc:
@@ -735,8 +744,7 @@ module GD2
     end
 
     def to_indexed_color(colors = MAX_COLORS, dither = true)  #:nodoc:
-      return self if palette.used <= colors
-      super
+      palette.used <= colors ? self : super
     end
 
     # Like Image#merge_from except an optional final argument can be specified

data/test/dl.rb

@@ -4,7 +4,7 @@ require 'dl'
 class DLTest < Test::Unit::TestCase
   def test_dlopen
     assert_nothing_raised {
-      DL.dlopen(Config::CONFIG['arch'] == 'powerpc-darwin' ?
+      DL.dlopen(Config::CONFIG['arch'].include?('powerpc-darwin') ?
         'libgd.2.dylib' : 'libgd.so.2')
     }
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: gd2
 version: !ruby/object:Gem::Version 
-  version: "1.0"
-date: 2005-11-14 00:00:00 -08:00
+  version: "1.1"
+date: 2006-03-03 00:00:00 -08:00
 summary: Ruby interface to gd 2 library.
 require_paths: 
   - lib