chunky_png 1.3.0 → 1.3.1

data/README.rdoc

@@ -54,6 +54,9 @@ provides a massive speed boost to encoding and decoding.
   png_stream = ChunkyPNG::Datastream.from_file('filename.png')
   png_stream.each_chunk { |chunk| p chunk.type }
 
+Also check out the following screencast by John Davison, which illustrates 
+basic usage of the library: http://devcasts.co/ruby-chunky_png-a-great-gem-for-on-the-fly-png-manipulation.
+
 For more information, see the project wiki on http://github.com/wvanbergen/chunky_png/wiki
 or the RDOC documentation on http://rdoc.info/gems/chunky_png/frames
 

data/lib/chunky_png/canvas.rb

@@ -11,7 +11,6 @@ require 'chunky_png/canvas/resampling'
 require 'chunky_png/canvas/masking'
 
 module ChunkyPNG
-
   # The ChunkyPNG::Canvas class represents a raster image as a matrix of
   # pixels.
   #
@@ -32,7 +31,6 @@ module ChunkyPNG
   # the whole canvas, like cropping and alpha compositing. Simple drawing
   # functions are imported from the {ChunkyPNG::Canvas::Drawing} module.
   class Canvas
-
     include PNGEncoding
     extend  PNGDecoding
     extend  Adam7Interlacing
@@ -55,7 +53,7 @@ module ChunkyPNG
     attr_reader :height
 
     # @return [Array<ChunkyPNG::Color>] The list of pixels in this canvas.
-    #     This array always should have +width * height+ elements.
+    #   This array always should have +width * height+ elements.
     attr_reader :pixels
 
 
@@ -68,26 +66,28 @@ module ChunkyPNG
     # @overload initialize(width, height, background_color)
     #   @param [Integer] width The width in pixels of this canvas
     #   @param [Integer] height The height in pixels of this canvas
-    #   @param [Integer, ...] background_color The initial background color of this canvas.
-    #      This can be a color value or any value that {ChunkyPNG::Color.parse} can handle.
+    #   @param [Integer, ...] background_color The initial background color of
+    #     this canvas. This can be a color value or any value that
+    #     {ChunkyPNG::Color.parse} can handle.
     #
     # @overload initialize(width, height, initial)
     #   @param [Integer] width The width in pixels of this canvas
     #   @param [Integer] height The height in pixels of this canvas
-    #   @param [Array<Integer>] initial The initial pizel values. Must be an array with 
-    #     <tt>width * height</tt> elements.
+    #   @param [Array<Integer>] initial The initial pizel values. Must be an
+    #     array with <tt>width * height</tt> elements.
     def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT)
-
       @width, @height = width, height
 
       if initial.kind_of?(Array)
-        raise ArgumentError, "The initial array should have #{width}x#{height} = #{width*height} elements!" unless initial.length == width * height
+        unless initial.length == width * height
+          raise ArgumentError, "The initial array should have #{width}x#{height} = #{width*height} elements!"
+        end
         @pixels = initial
       else
         @pixels = Array.new(width * height, ChunkyPNG::Color.parse(initial))
       end
     end
-    
+
     # Initializes a new Canvas instances when being cloned.
     # @param [ChunkyPNG::Canvas] other The canvas to duplicate
     # @return [void]
@@ -101,7 +101,7 @@ module ChunkyPNG
     # @param [ChunkyPNG::Canvas] canvas The canvas to duplicate
     # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
     def self.from_canvas(canvas)
-      self.new(canvas.width, canvas.height, canvas.pixels.dup)
+      new(canvas.width, canvas.height, canvas.pixels.dup)
     end
 
 
@@ -110,11 +110,12 @@ module ChunkyPNG
     #################################################################
 
     # Returns the dimension (width x height) for this canvas.
-    # @return [ChunkyPNG::Dimension] A dimension instance with the width and height set for this canvas.
+    # @return [ChunkyPNG::Dimension] A dimension instance with the width and
+    #   height set for this canvas.
     def dimension
       ChunkyPNG::Dimension.new(width, height)
     end
-    
+
     # Returns the area of this canvas in number of pixels.
     # @return [Integer] The number of pixels in this canvas
     def area
@@ -125,8 +126,10 @@ module ChunkyPNG
     # @param [Integer] x The x-coordinate of the pixel (column)
     # @param [Integer] y The y-coordinate of the pixel (row)
     # @param [Integer] color The new color for the provided coordinates.
-    # @return [Integer] The new color value for this pixel, i.e. <tt>color</tt>. 
-    # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the image's dimensions.
+    # @return [Integer] The new color value for this pixel, i.e.
+    #   <tt>color</tt>.
+    # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
+    #   image's dimensions.
     # @see #set_pixel
     def []=(x, y, color)
       assert_xy!(x, y)
@@ -135,25 +138,26 @@ module ChunkyPNG
 
     # Replaces a single pixel in this canvas, without bounds checking.
     #
-    # This method return value and effects are undefined for coordinates 
+    # This method return value and effects are undefined for coordinates
     # out of bounds of the canvas.
     #
     # @param [Integer] x The x-coordinate of the pixel (column)
     # @param [Integer] y The y-coordinate of the pixel (row)
     # @param [Integer] pixel The new color for the provided coordinates.
-    # @return [Integer] The new color value for this pixel, i.e. <tt>color</tt>. 
+    # @return [Integer] The new color value for this pixel, i.e.
+    #   <tt>color</tt>.
     def set_pixel(x, y, color)
       @pixels[y * width + x] = color
     end
-   
+
     # Replaces a single pixel in this canvas, with bounds checking. It will do
     # noting if the provided coordinates are out of bounds.
     #
     # @param [Integer] x The x-coordinate of the pixel (column)
     # @param [Integer] y The y-coordinate of the pixel (row)
     # @param [Integer] pixel The new color value for the provided coordinates.
-    # @return [Integer] The new color value for this pixel, i.e. <tt>color</tt>, or 
-    #    <tt>nil</tt> if the coordinates are out of bounds.
+    # @return [Integer] The new color value for this pixel, i.e.
+    #   <tt>color</tt>, or <tt>nil</tt> if the coordinates are out of bounds.
     def set_pixel_if_within_bounds(x, y, color)
       return unless include_xy?(x, y)
       @pixels[y * width + x] = color
@@ -163,15 +167,18 @@ module ChunkyPNG
     # @param [Integer] x The x-coordinate of the pixel (column)
     # @param [Integer] y The y-coordinate of the pixel (row)
     # @return [Integer] The current color value at the provided coordinates.
-    # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the image's dimensions.
+    # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
+    #   image's dimensions.
     # @see #get_pixel
     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
-    # this method is undefined if the coordinates are out of bounds.
+    # Returns a single pixel from this canvas, without checking bounds. The
+    # return value for this method is undefined if the coordinates are out of
+    # bounds.
+    #
     # @param (see #[])
     # @return [Integer] The current pixel at the provided coordinates.
     def get_pixel(x, y)
@@ -196,7 +203,8 @@ module ChunkyPNG
 
     # Replaces a row of pixels on this canvas.
     # @param [Integer] y The 0-based row index.
-    # @param [Array<Integer>] vector The vector of pixels to replace the row with.
+    # @param [Array<Integer>] vector The vector of pixels to replace the row
+    #   with.
     # @return [void]
     def replace_row!(y, vector)
       assert_y!(y) && assert_width!(vector.length)
@@ -205,7 +213,8 @@ module ChunkyPNG
 
     # Replaces a column of pixels on this canvas.
     # @param [Integer] x The 0-based column index.
-    # @param [Array<Integer>] vector The vector of pixels to replace the column with.
+    # @param [Array<Integer>] vector The vector of pixels to replace the column
+    #   with.
     # @return [void]
     def replace_column!(x, vector)
       assert_x!(x) && assert_height!(vector.length)
@@ -215,49 +224,55 @@ module ChunkyPNG
     end
 
     # Checks whether the given coordinates are in the range of the canvas
-    # @param [ChunkyPNG::Point, Array, Hash, String] point_like The point to check.
-    # @return [true, false] True if the x and y coordinates of the point are  
-    #    within the limits of this canvas.
+    # @param [ChunkyPNG::Point, Array, Hash, String] point_like The point to
+    #   check.
+    # @return [true, false] True if the x and y coordinates of the point are
+    #   within the limits of this canvas.
     # @see ChunkyPNG.Point
     def include_point?(*point_like)
       dimension.include?(ChunkyPNG::Point(*point_like))
     end
-    
+
     alias_method :include?,    :include_point?
-    
-    # Checks whether the given x- and y-coordinate are in the range of the canvas
+
+    # 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.
+    # @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)
-    # @return [true, false] True if the y-coordinate is in the range of this canvas.
+    # @return [true, false] True if the y-coordinate is in the range of this
+    #   canvas.
     def include_y?(y)
       y >= 0 && y < height
     end
 
     # Checks whether the given x-coordinate is in the range of the canvas
     # @param [Integer] x The y-coordinate of the pixel (column)
-    # @return [true, false] True if the x-coordinate is in the range of this canvas.
+    # @return [true, false] True if the x-coordinate is in the range of this
+    #   canvas.
     def include_x?(x)
       x >= 0 && x < width
     end
 
     # Returns the palette used for this canvas.
-    # @return [ChunkyPNG::Palette] A palette which contains all the colors that are
-    #    being used for this image.
+    # @return [ChunkyPNG::Palette] A palette which contains all the colors that
+    #   are being used for this image.
     def palette
       ChunkyPNG::Palette.from_canvas(self)
     end
 
     # Equality check to compare this canvas with other matrices.
     # @param other The object to compare this Matrix to.
-    # @return [true, false] True if the size and pixel values of the other canvas
-    #    are exactly the same as this canvas's size and pixel values.
+    # @return [true, false] True if the size and pixel values of the other
+    #   canvas are exactly the same as this canvas's size and pixel values.
     def eql?(other)
       other.kind_of?(self.class) && other.pixels == self.pixels &&
             other.width == self.width && other.height == self.height
@@ -274,7 +289,7 @@ module ChunkyPNG
     def to_image
       ChunkyPNG::Image.from_canvas(self)
     end
-    
+
     # Alternative implementation of the inspect method.
     # @return [String] A nicely formatted string representation of this canvas.
     # @private
@@ -285,51 +300,73 @@ module ChunkyPNG
       end
       inspected << "\n]>"
     end
-    
+
     protected
-    
+
     # Replaces the image, given a new width, new height, and a new pixel array.
     def replace_canvas!(new_width, new_height, new_pixels)
-      raise ArgumentError, "The provided pixel array should have #{new_width * new_height} items" unless new_pixels.length == new_width * new_height
+      unless new_pixels.length == new_width * new_height
+        raise ArgumentError, "The provided pixel array should have #{new_width * new_height} items"
+      end
       @width, @height, @pixels = new_width, new_height, new_pixels
-      return self
+      self
     end
-    
+
     # Throws an exception if the x-coordinate is out of bounds.
     def assert_x!(x)
-      raise ChunkyPNG::OutOfBounds, "Column index #{x} out of bounds!" unless include_x?(x)
-      return true
+      unless include_x?(x)
+        raise ChunkyPNG::OutOfBounds, "Column index #{x} out of bounds!"
+      end
+      true
     end
-    
+
     # Throws an exception if the y-coordinate is out of bounds.
     def assert_y!(y)
-      raise ChunkyPNG::OutOfBounds, "Row index #{y} out of bounds!" unless include_y?(y)
-      return true
+      unless include_y?(y)
+        raise ChunkyPNG::OutOfBounds, "Row index #{y} out of bounds!"
+      end
+      true
     end
-    
+
     # Throws an exception if the x- or y-coordinate is out of bounds.
     def assert_xy!(x, y)
-      raise ChunkyPNG::OutOfBounds, "Coordinates (#{x},#{y}) out of bounds!" unless include_xy?(x, y)
-      return true
+      unless include_xy?(x, y)
+        raise ChunkyPNG::OutOfBounds, "Coordinates (#{x},#{y}) out of bounds!"
+      end
+      true
     end
 
-    # Throws an exception if the vector_length does not match this canvas' height.
+    # Throws an exception if the vector_length does not match this canvas'
+    # height.
     def assert_height!(vector_length)
-      raise ChunkyPNG::ExpectationFailed, "The length of the vector (#{vector_length}) does not match the canvas height (#{height})!" if height != vector_length
-      return true
+      if height != vector_length
+        raise ChunkyPNG::ExpectationFailed,
+          "The length of the vector (#{vector_length}) does not match the canvas height (#{height})!"
+      end
+      true
     end
 
-    # Throws an exception if the vector_length does not match this canvas' width.
+    # Throws an exception if the vector_length does not match this canvas'
+    # width.
     def assert_width!(vector_length)
-      raise ChunkyPNG::ExpectationFailed, "The length of the vector (#{vector_length}) does not match the canvas width (#{width})!" if width != vector_length
-      return true
+      if width != vector_length
+        raise ChunkyPNG::ExpectationFailed,
+          "The length of the vector (#{vector_length}) does not match the canvas width (#{width})!"
+      end
+      true
     end
 
     # Throws an exception if the matrix width and height does not match this canvas' dimensions.
     def assert_size!(matrix_width, matrix_height)
-      raise ChunkyPNG::ExpectationFailed, "The width of the matrix does not match the canvas width!"   if width  != matrix_width
-      raise ChunkyPNG::ExpectationFailed, "The height of the matrix does not match the canvas height!" if height != matrix_height
-      return true
+      if width  != matrix_width
+        raise ChunkyPNG::ExpectationFailed,
+          'The width of the matrix does not match the canvas width!'
+      end
+      if height != matrix_height
+        raise ChunkyPNG::ExpectationFailed,
+          'The height of the matrix does not match the canvas height!'
+      end
+      true
     end
   end
 end

data/lib/chunky_png/canvas/drawing.rb

@@ -1,17 +1,19 @@
 module ChunkyPNG
   class Canvas
-    
+
     # Module that adds some primitive drawing methods to {ChunkyPNG::Canvas}.
     #
-    # All of these methods change the current canvas instance and do not create a new one,
-    # even though the method names do not end with a bang.
+    # All of these methods change the current canvas instance and do not create
+    # a new one, even though the method names do not end with a bang.
     #
-    # @note Drawing operations will not fail when something is drawn outside of the bounds
-    #       of the canvas; these pixels will simply be ignored.
+    # @note Drawing operations will not fail when something is drawn outside of
+    #   the bounds of the canvas; these pixels will simply be ignored.
     # @see ChunkyPNG::Canvas
     module Drawing
-      
-      # Composes a pixel on the canvas by alpha blending a color with its background color.
+
+      # Composes a pixel on the canvas by alpha blending a color with its
+      # background 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
@@ -20,49 +22,49 @@ module ChunkyPNG
         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.
+
+      # 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 a Bezier curve
       # @param [Array, Point] A collection of control points
       # @return [Chunky:PNG::Canvas] Itself, with the curve drawn
       def bezier_curve(points, stroke_color = ChunkyPNG::Color::BLACK)
-        
         points = ChunkyPNG::Vector(*points)
         case points.length
           when 0, 1; return self
           when 2; return line(points[0].x, points[0].y, points[1].x, points[1].y, stroke_color)
         end
-        
+
         curve_points = Array.new
-        
-        t = 0
-        n = points.length - 1
+
+        t     = 0
+        n     = points.length - 1
         bicof = 0
-        
+
         while t <= 100
           cur_p = ChunkyPNG::Point.new(0,0)
-          
+
           # Generate a float of t.
           t_f = t / 100.00
-          
+
           cur_p.x += ((1 - t_f) ** n) * points[0].x
           cur_p.y += ((1 - t_f) ** n) * points[0].y
-          
+
           for i in 1...points.length - 1
             bicof = binomial_coefficient(n , i)
-            
-            cur_p.x += (bicof * (1 - t_f) ** (n - i)) *  (t_f ** i) * points[i].x 
-            cur_p.y += (bicof * (1 - t_f) ** (n - i)) *  (t_f ** i) * points[i].y 
+
+            cur_p.x += (bicof * (1 - t_f) ** (n - i)) *  (t_f ** i) * points[i].x
+            cur_p.y += (bicof * (1 - t_f) ** (n - i)) *  (t_f ** i) * points[i].y
             i += 1
           end
-          
+
           cur_p.x += (t_f ** n) * points[n].x
           cur_p.y += (t_f ** n) * points[n].y
 
@@ -76,10 +78,9 @@ module ChunkyPNG
           line_xiaolin_wu(p1.x.round, p1.y.round, p2.x.round, p2.y.round, stroke_color)
         end
 
-        return self
+        self
       end
-      
-      
+
       # Draws an anti-aliased line using Xiaolin Wu's algorithm.
       #
       # @param [Integer] x0 The x-coordinate of the first control point.
@@ -87,81 +88,93 @@ module ChunkyPNG
       # @param [Integer] x1 The x-coordinate of the second control point.
       # @param [Integer] y1 The y-coordinate of the second control point.
       # @param [Integer] stroke_color The color to use for this line.
-      # @param [true, false] inclusive Whether to draw the last pixel. 
-      #    Set to false when drawing multiple lines in a path.
+      # @param [true, false] inclusive Whether to draw the last pixel. Set to
+      #   false when drawing multiple lines in a path.
       # @return [ChunkyPNG::Canvas] Itself, with the line drawn.
       def line_xiaolin_wu(x0, y0, x1, y1, stroke_color, inclusive = true)
-        
         stroke_color = ChunkyPNG::Color.parse(stroke_color)
-        
+
         dx = x1 - x0
         sx = dx < 0 ? -1 : 1
         dx *= sx
         dy = y1 - y0
         sy = dy < 0 ? -1 : 1
         dy *= sy
-        
+
         if dy == 0 # vertical line
           x0.step(inclusive ? x1 : x1 - sx, sx) do |x|
             compose_pixel(x, y0, stroke_color)
           end
-          
+
         elsif dx == 0 # horizontal line
           y0.step(inclusive ? y1 : y1 - sy, sy) do |y|
             compose_pixel(x0, y, stroke_color)
           end
-          
+
         elsif dx == dy # diagonal
           x0.step(inclusive ? x1 : x1 - sx, sx) do |x|
             compose_pixel(x, y0, stroke_color)
             y0 += sy
           end
-          
+
         elsif dy > dx  # vertical displacement
           compose_pixel(x0, y0, stroke_color)
           e_acc = 0
           e = ((dx << 16) / dy.to_f).round
           (dy - 1).downto(0) do |i|
             e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xffff
-            x0 += sx if (e_acc <= e_acc_temp)
+            x0 += sx if e_acc <= e_acc_temp
             w = 0xff - (e_acc >> 8)
             compose_pixel(x0, y0, ChunkyPNG::Color.fade(stroke_color, w))
-            compose_pixel(x0 + sx, y0 + sy, ChunkyPNG::Color.fade(stroke_color, 0xff - w)) if inclusive || i > 0
+            if inclusive || i > 0
+              compose_pixel(x0 + sx,
+                            y0 + sy,
+                            ChunkyPNG::Color.fade(stroke_color, 0xff - w))
+            end
             y0 += sy
           end
           compose_pixel(x1, y1, stroke_color) if inclusive
-          
+
         else # horizontal displacement
           compose_pixel(x0, y0, stroke_color)
           e_acc = 0
           e = ((dy << 16) / dx.to_f).round
           (dx - 1).downto(0) do |i|
             e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xffff
-            y0 += sy if (e_acc <= e_acc_temp)
+            y0 += sy if e_acc <= e_acc_temp
             w = 0xff - (e_acc >> 8)
             compose_pixel(x0, y0, ChunkyPNG::Color.fade(stroke_color, w))
-            compose_pixel(x0 + sx, y0 + sy, ChunkyPNG::Color.fade(stroke_color, 0xff - w)) if inclusive || i > 0
+            if inclusive || i > 0
+              compose_pixel(x0 + sx,
+                            y0 + sy,
+                            ChunkyPNG::Color.fade(stroke_color, 0xff - w))
+            end
             x0 += sx
           end
           compose_pixel(x1, y1, stroke_color) if inclusive
         end
-        
-        return self
+
+        self
       end
-      
+
       alias_method :line, :line_xiaolin_wu
-      
-      
-      # Draws a polygon on the canvas using the stroke_color, filled using the fill_color if any.
+
+      # Draws a polygon on the canvas using the stroke_color, filled using the
+      # fill_color if any.
       #
-      # @param [Array, String] The control point vector. Accepts everything {ChunkyPNG.Vector} accepts.
+      # @param [Array, String] The control point vector. Accepts everything
+      #   {ChunkyPNG.Vector} accepts.
       # @param [Integer] stroke_color The stroke color to use for this polygon.
       # @param [Integer] fill_color The fill color to use for this polygon.
       # @return [ChunkyPNG::Canvas] Itself, with the polygon drawn.
-      def polygon(path, stroke_color = ChunkyPNG::Color::BLACK, fill_color = ChunkyPNG::Color::TRANSPARENT)
-        
+      def polygon(path,
+                  stroke_color = ChunkyPNG::Color::BLACK,
+                  fill_color   = ChunkyPNG::Color::TRANSPARENT)
+
         vector = ChunkyPNG::Vector(*path)
-        raise ArgumentError, "A polygon requires at least 3 points" if path.length < 3
+        if path.length < 3
+          raise ArgumentError, 'A polygon requires at least 3 points'
+        end
 
         stroke_color = ChunkyPNG::Color.parse(stroke_color)
         fill_color   = ChunkyPNG::Color.parse(fill_color)
@@ -184,15 +197,15 @@ module ChunkyPNG
             end
           end
         end
-        
+
         # Stroke
         vector.each_edge do |(from_x, from_y), (to_x, to_y)|
           line(from_x, from_y, to_x, to_y, stroke_color, false)
         end
 
-        return self
+        self
       end
-      
+
       # Draws a rectangle on the canvas, using two control points.
       #
       # @param [Integer] x0 The x-coordinate of the first control point.
@@ -202,11 +215,13 @@ module ChunkyPNG
       # @param [Integer] stroke_color The line color to use for this rectangle.
       # @param [Integer] fill_color The fill color to use for this rectangle.
       # @return [ChunkyPNG::Canvas] Itself, with the rectangle drawn.
-      def rect(x0, y0, x1, y1, stroke_color = ChunkyPNG::Color::BLACK, fill_color = ChunkyPNG::Color::TRANSPARENT)
-      
+      def rect(x0, y0, x1, y1,
+               stroke_color = ChunkyPNG::Color::BLACK,
+               fill_color   = ChunkyPNG::Color::TRANSPARENT)
+
         stroke_color = ChunkyPNG::Color.parse(stroke_color)
         fill_color   = ChunkyPNG::Color.parse(fill_color)
-      
+
         # Fill
         unless fill_color == ChunkyPNG::Color::TRANSPARENT
           [x0, x1].min.upto([x0, x1].max) do |x|
@@ -215,16 +230,16 @@ module ChunkyPNG
             end
           end
         end
-        
+
         # Stroke
         line(x0, y0, x0, y1, stroke_color, false)
         line(x0, y1, x1, y1, stroke_color, false)
         line(x1, y1, x1, y0, stroke_color, false)
         line(x1, y0, x0, y0, stroke_color, false)
-        
-        return self
+
+        self
       end
-      
+
       # Draws a circle on the canvas.
       #
       # @param [Integer] x0 The x-coordinate of the center of the circle.
@@ -233,7 +248,9 @@ module ChunkyPNG
       # @param [Integer] stroke_color The color to use for the line.
       # @param [Integer] fill_color The color to use that fills the circle.
       # @return [ChunkyPNG::Canvas] Itself, with the circle drawn.
-      def circle(x0, y0, radius, stroke_color = ChunkyPNG::Color::BLACK, fill_color = ChunkyPNG::Color::TRANSPARENT)
+      def circle(x0, y0, radius,
+                 stroke_color = ChunkyPNG::Color::BLACK,
+                 fill_color   = ChunkyPNG::Color::TRANSPARENT)
 
         stroke_color = ChunkyPNG::Color.parse(stroke_color)
         fill_color   = ChunkyPNG::Color.parse(fill_color)
@@ -283,20 +300,26 @@ module ChunkyPNG
 
         unless fill_color == ChunkyPNG::Color::TRANSPARENT
           lines.each_with_index do |length, y|
-            line(x0 - length, y0 - y, x0 + length, y0 - y, fill_color) if length > 0
-            line(x0 - length, y0 + y, x0 + length, y0 + y, fill_color) if length > 0 && y > 0
+            if length > 0
+              line(x0 - length, y0 - y, x0 + length, y0 - y, fill_color)
+            end
+            if length > 0 && y > 0
+              line(x0 - length, y0 + y, x0 + length, y0 + y, fill_color)
+            end
           end
         end
 
-        return self
+        self
       end
-      
+
       private
-      
+
       # Calculates the binomial coefficient for n over k.
       #
-      # @param [Integer] n first parameter in coeffient (the number on top when looking at the mathematic formula)
-      # @param [Integer] k k-element, second parameter in coeffient (the number on the bottom when looking at the mathematic formula)
+      # @param [Integer] n first parameter in coeffient (the number on top when
+      #   looking at the mathematic formula)
+      # @param [Integer] k k-element, second parameter in coeffient (the number
+      #   on the bottom when looking at the mathematic formula)
       # @return [Integer] The binomial coeffcient of (n,k)
       def binomial_coefficient(n, k)
         return  1 if n == k || k == 0