chunky_png 1.0.0 → 1.0.1

data/chunky_png.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
 
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "1.0.0"
-  s.date    = "2011-03-06"
+  s.version = "1.0.1"
+  s.date    = "2011-03-08"
 
   s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"
   s.description = <<-EOT

data/lib/chunky_png.rb

@@ -25,7 +25,7 @@ module ChunkyPNG
 
   # The current version of ChunkyPNG. This value will be updated 
   # automatically by them <tt>gem:release</tt> rake task.
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 
   ###################################################
   # PNG international standard defined constants

data/lib/chunky_png/canvas.rb

@@ -74,7 +74,7 @@ module ChunkyPNG
       if initial.kind_of?(Array) && initial.length == width * height
         @pixels = initial
       else
-        @pixels = Array.new(width * height, ChunkyPNG::Color(initial))
+        @pixels = Array.new(width * height, ChunkyPNG::Color.parse(initial))
       end
     end
     
@@ -128,10 +128,9 @@ module ChunkyPNG
     #
     # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the image's dimensions.
     # @see #set_pixel
-    def []=(*args)
-      point = args.length == 2 ? ChunkyPNG::Point(args.first) : ChunkyPNG::Point(args[0], args[1])
-      assert_xy!(point.x, point.y)
-      @pixels[point.y * width + point.x] = args.last
+    def []=(x, y, color)
+      assert_xy!(x, y)
+      @pixels[y * width + x] = ChunkyPNG::Color.parse(color)
     end
 
     # Replaces a single pixel in this canvas, without bounds checking.
@@ -175,10 +174,9 @@ module ChunkyPNG
     #
     # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the image's dimensions.
     # @see #get_pixel
-    def [](*args)
-      point = ChunkyPNG::Point(*args)
-      assert_xy!(point.x, point.y)
-      @pixels[point.y * width + point.x]
+    def [](x, y)
+      assert_xy!(x, y)
+      @pixels[y * width + x]
     end
 
     # Returns a single pixel from this canvas, without checking bounds. The return value for
@@ -235,7 +233,14 @@ module ChunkyPNG
     end
     
     alias_method :include?,    :include_point?
-    alias_method :include_xy?, :include_point?
+    
+    # Checks whether the given x- and y-coordinate are in the range of the canvas
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @return [true, false] True if the x- and y-coordinate is in the range of this canvas.
+    def include_xy?(x, y)
+      y >= 0 && y < height && x >= 0 && x < width
+    end
     
     # Checks whether the given y-coordinate is in the range of the canvas
     # @param [Integer] y The y-coordinate of the pixel (row)

data/lib/chunky_png/canvas/drawing.rb

@@ -12,18 +12,21 @@ module ChunkyPNG
     module Drawing
       
       # Composes a pixel on the canvas by alpha blending a color with its background color.
-      # @overload compose_pixel(x, y, color)
-      #   @param [Integer] x The x-coordinate of the pixel to blend.
-      #   @param [Integer] y The y-coordinate of the pixel to blend.
-      #   @param [Integer] color The foreground color to blend with
-      # @overload compose_pixel(point, color)
-      #   @param [ChunkyPNG::Point, ...] point The point on the canvas to blend.
-      #   @param [Integer] color The foreground color to blend with
-      def compose_pixel(*args)
-        point = args.length == 2 ? ChunkyPNG::Point(args.first) : ChunkyPNG::Point(args[0], args[1])
-        return unless include?(point)
-        color = ChunkyPNG::Color(args.last)
-        set_pixel(point.x, point.y, ChunkyPNG::Color.compose(color, get_pixel(point.x, point.y)))
+      # @param [Integer] x The x-coordinate of the pixel to blend.
+      # @param [Integer] y The y-coordinate of the pixel to blend.
+      # @param [Integer] color The foreground color to blend with
+      # @return [Integer] The composed color.
+      def compose_pixel(x, y, color)
+        return unless include_xy?(x, y)
+        compose_pixel_unsafe(x, y, ChunkyPNG::Color.parse(color))
+      end
+      
+      # Composes a pixel on the canvas by alpha blending a color with its background color,
+      # without bounds checking.
+      # @param (see #compose_pixel)
+      # @return [Integer] The composed color.
+      def compose_pixel_unsafe(x, y, color)
+        set_pixel(x, y, ChunkyPNG::Color.compose(color, get_pixel(x, y)))
       end
       
       # Draws an anti-aliased line using Xiaolin Wu's algorithm.
@@ -38,7 +41,7 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] Itself, with the line drawn.
       def line_xiaolin_wu(x0, y0, x1, y1, stroke_color, inclusive = true)
         
-        stroke_color = ChunkyPNG::Color(stroke_color)
+        stroke_color = ChunkyPNG::Color.parse(stroke_color)
         
         dx = x1 - x0
         sx = dx < 0 ? -1 : 1
@@ -109,8 +112,8 @@ module ChunkyPNG
         vector = ChunkyPNG::Vector(*path)
         raise ArgumentError, "A polygon requires at least 3 points" if path.length < 3
 
-        stroke_color = ChunkyPNG::Color(stroke_color)
-        fill_color   = ChunkyPNG::Color(fill_color)
+        stroke_color = ChunkyPNG::Color.parse(stroke_color)
+        fill_color   = ChunkyPNG::Color.parse(fill_color)
 
         # Fill
         unless fill_color == ChunkyPNG::Color::TRANSPARENT
@@ -150,8 +153,8 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] Itself, with the rectangle drawn.
       def rect(x0, y0, x1, y1, stroke_color = ChunkyPNG::Color::BLACK, fill_color = ChunkyPNG::Color::TRANSPARENT)
       
-        stroke_color = ChunkyPNG::Color(stroke_color)
-        fill_color   = ChunkyPNG::Color(fill_color)
+        stroke_color = ChunkyPNG::Color.parse(stroke_color)
+        fill_color   = ChunkyPNG::Color.parse(fill_color)
       
         # Fill
         unless fill_color == ChunkyPNG::Color::TRANSPARENT
@@ -181,8 +184,8 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] Itself, with the circle drawn.
       def circle(x0, y0, radius, stroke_color = ChunkyPNG::Color::BLACK, fill_color = ChunkyPNG::Color::TRANSPARENT)
 
-        stroke_color = ChunkyPNG::Color(stroke_color)
-        fill_color   = ChunkyPNG::Color(fill_color)
+        stroke_color = ChunkyPNG::Color.parse(stroke_color)
+        fill_color   = ChunkyPNG::Color.parse(fill_color)
 
         f = 1 - radius
         ddF_x = 1

data/lib/chunky_png/color.rb

@@ -25,18 +25,13 @@ module ChunkyPNG
   # @return [Integer] The determined color value as RGBA integer.
   # @raise [ArgumentError] if the arguments weren't understood as a color.
   # @see ChunkyPNG::Color
+  # @see ChunkyPNG::Color.parse
   def self.Color(*args)
     case args.length
-      when 4; ChunkyPNG::Color.rgba(*args)
+      when 1; ChunkyPNG::Color.parse(args.first)
+      when 2; (ChunkyPNG::Color.parse(args.first) & 0xffffff00) | args[1].to_i
       when 3; ChunkyPNG::Color.rgb(*args)
-      when 2; (ChunkyPNG::Color(args[0]) & 0xffffff00) | args[1].to_i
-      when 1
-        case source = args.first.to_s
-          when Integer, /^\d+$/; source.to_i
-          when ChunkyPNG::Color::HEX_COLOR_REGEXP;  ChunkyPNG::Color.from_hex(source)
-          when ChunkyPNG::Color::HTML_COLOR_REGEXP; ChunkyPNG::Color.html_color(source)
-          else raise ArgumentError, "Don't know how to create a color from #{source.inspect}!"
-        end
+      when 4; ChunkyPNG::Color.rgba(*args)
       else raise ArgumentError, "Don't know how to create a color from #{args.inspect}!"
     end
   end
@@ -72,6 +67,22 @@ module ChunkyPNG
     # CONSTRUCTING COLOR VALUES
     ####################################################################
 
+    # Parses a color value given a numeric or string argument.
+    #
+    # It supports color numbers, colors in hex notation and named HTML colors.
+    #
+    # @param [Integer, String] The color value.
+    # @return [Integer] The color value, with the opacity applied if one was given.
+    def parse(source)
+      return source if source.kind_of?(Integer)
+      case source.to_s
+        when /^\d+$/; source.to_s.to_i
+        when ChunkyPNG::Color::HEX_COLOR_REGEXP;  ChunkyPNG::Color.from_hex(source.to_s)
+        when ChunkyPNG::Color::HTML_COLOR_REGEXP; ChunkyPNG::Color.html_color(source.to_s)
+        else raise ArgumentError, "Don't know how to create a color from #{source.inspect}!"
+      end
+    end
+
     # Creates a new color using an r, g, b triple and an alpha value.
     # @param [Integer] r The r-component (0-255)
     # @param [Integer] g The g-component (0-255)

data/spec/chunky_png/canvas/drawing_spec.rb

@@ -2,27 +2,21 @@ require 'spec_helper'
 
 describe ChunkyPNG::Canvas::Drawing do
   
-  describe '#point' do
+  describe '#compose_pixel' do
     subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100)) }
     
     it "should compose colors correctly" do
       subject.compose_pixel(0,0, ChunkyPNG::Color(100, 150, 200, 128))
-      subject['0,0'].should == ChunkyPNG::Color(150, 150, 150)
+      subject[0, 0].should == ChunkyPNG::Color(150, 150, 150)
     end
     
     it "should return the composed color" do
       subject.compose_pixel(0, 0, ChunkyPNG::Color.rgba(100, 150, 200, 128)).should == ChunkyPNG::Color.rgb(150, 150, 150)
     end
     
-    it "should accept point-like arguments as well" do
-      lambda { subject.compose_pixel('0,0', ChunkyPNG::Color.rgba(100, 150, 200, 128)) }.should change { subject['0,0'] }
-      lambda { subject.compose_pixel({:x => 0, :y => 0}, ChunkyPNG::Color.rgba(100, 150, 200, 128)) }.should change { subject['0,0'] }
-      lambda { subject.compose_pixel(ChunkyPNG::Point.new(0, 0), ChunkyPNG::Color.rgba(100, 150, 200, 128)) } .should change { subject['0,0'] }
-    end
-    
     it "should do nothing when the coordinates are out of bounds" do
       subject.compose_pixel(1, -1, :black).should be_nil
-      lambda { subject.compose_pixel(1, -1, :black) }.should_not change { subject['0,0'] }
+      lambda { subject.compose_pixel(1, -1, :black) }.should_not change { subject[0, 0] }
     end
   end
   

data/spec/chunky_png/color_spec.rb

@@ -1,5 +1,25 @@
 require 'spec_helper'
 
+describe 'ChunyPNG.Color' do
+  it "should interpret 4 arguments as RGBA values" do
+    ChunkyPNG::Color(1, 2, 3, 4).should == ChunkyPNG::Color.rgba(1, 2, 3, 4)
+  end
+  
+  it "should interpret 3 arguments as RGBA values" do
+    ChunkyPNG::Color(1, 2, 3).should == ChunkyPNG::Color.rgb(1, 2, 3)
+  end
+  
+  it "should interpret 2 arguments as a color to parse and an opacity value" do
+    ChunkyPNG::Color('0x0a649664', 0xaa).should == 0x0a6496aa
+    ChunkyPNG::Color('spring green @ 0.6666', 0xff).should == 0x00ff7fff
+  end
+  
+  it "should interpret 1 argument as a color to parse" do
+    ChunkyPNG::Color.should_receive(:parse).with('0x0a649664')
+    ChunkyPNG::Color('0x0a649664')
+  end
+end
+
 describe ChunkyPNG::Color do
   include ChunkyPNG::Color
 
@@ -11,25 +31,21 @@ describe ChunkyPNG::Color do
     @fully_transparent = 0x0a649600
   end
   
-  it "should interpret 4 arguments as RGBA values" do
-    ChunkyPNG::Color(1, 2, 3, 4).should == ChunkyPNG::Color.rgba(1, 2, 3, 4)
-  end
-  
-  it "should interpret 3 arguments as RGBA values" do
-    ChunkyPNG::Color(1, 2, 3).should == ChunkyPNG::Color.rgb(1, 2, 3)
-  end
-  
-  it "should interpret a hex string correctly" do
-    ChunkyPNG::Color('0x0a649664').should == ChunkyPNG::Color.from_hex('#0a649664')
-    ChunkyPNG::Color('0x0a649664', 0xff).should == ChunkyPNG::Color.from_hex('#0a6496', 0xff)
-  end
-  
-  it "should interpret a color name correctly" do
-    ChunkyPNG::Color(:spring_green).should == 0x00ff7fff
-    ChunkyPNG::Color('spring green').should == 0x00ff7fff
-    ChunkyPNG::Color('spring green @ 0.6666').should == 0x00ff7faa
-    ChunkyPNG::Color('spring green', 0xaa).should == 0x00ff7faa
-    ChunkyPNG::Color('spring green @ 0.6666', 0xff).should == 0x00ff7fff
+  describe '#parse' do
+    it "should interpret a hex string correctly" do
+      parse('0x0a649664').should == ChunkyPNG::Color.from_hex('#0a649664')
+    end
+
+    it "should interpret a color name correctly" do
+      parse(:spring_green).should == 0x00ff7fff
+      parse('spring green').should == 0x00ff7fff
+      parse('spring green @ 0.6666').should == 0x00ff7faa
+    end
+    
+    it "should return numbers as is" do
+      parse('12345').should == 12345
+      parse(12345).should == 12345
+    end
   end
 
   describe '#pixel_bytesize' do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-06 00:00:00 -05:00
+date: 2011-03-08 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency