chunky_png 1.3.11 → 1.3.12

data/lib/chunky_png/canvas.rb

@@ -1,14 +1,14 @@
-require 'chunky_png/canvas/png_encoding'
-require 'chunky_png/canvas/png_decoding'
-require 'chunky_png/canvas/adam7_interlacing'
-require 'chunky_png/canvas/stream_exporting'
-require 'chunky_png/canvas/stream_importing'
-require 'chunky_png/canvas/data_url_exporting'
-require 'chunky_png/canvas/data_url_importing'
-require 'chunky_png/canvas/operations'
-require 'chunky_png/canvas/drawing'
-require 'chunky_png/canvas/resampling'
-require 'chunky_png/canvas/masking'
+require "chunky_png/canvas/png_encoding"
+require "chunky_png/canvas/png_decoding"
+require "chunky_png/canvas/adam7_interlacing"
+require "chunky_png/canvas/stream_exporting"
+require "chunky_png/canvas/stream_importing"
+require "chunky_png/canvas/data_url_exporting"
+require "chunky_png/canvas/data_url_importing"
+require "chunky_png/canvas/operations"
+require "chunky_png/canvas/drawing"
+require "chunky_png/canvas/resampling"
+require "chunky_png/canvas/masking"
 
 module ChunkyPNG
   # The ChunkyPNG::Canvas class represents a raster image as a matrix of
@@ -56,7 +56,6 @@ module ChunkyPNG
     #   This array always should have +width * height+ elements.
     attr_reader :pixels
 
-
     #################################################################
     # CONSTRUCTORS
     #################################################################
@@ -68,7 +67,7 @@ module ChunkyPNG
     #   @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.
+    #     {ChunkyPNG::Color#parse} can handle.
     #
     # @overload initialize(width, height, initial)
     #   @param [Integer] width The width in pixels of this canvas
@@ -78,9 +77,10 @@ module ChunkyPNG
     def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT)
       @width, @height = width, height
 
-      if initial.kind_of?(Array)
-        unless initial.length == width * height
-          raise ArgumentError, "The initial array should have #{width}x#{height} = #{width*height} elements!"
+      if initial.is_a?(Array)
+        pixel_count = width * height
+        unless initial.length == pixel_count
+          raise ArgumentError, "The initial array should have #{width}x#{height} = #{pixel_count} elements!"
         end
         @pixels = initial
       else
@@ -104,7 +104,6 @@ module ChunkyPNG
       new(canvas.width, canvas.height, canvas.pixels.dup)
     end
 
-
     #################################################################
     # PROPERTIES
     #################################################################
@@ -143,7 +142,7 @@ module ChunkyPNG
     #
     # @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.
+    # @param [Integer] color The new color for the provided coordinates.
     # @return [Integer] The new color value for this pixel, i.e.
     #   <tt>color</tt>.
     def set_pixel(x, y, color)
@@ -155,7 +154,7 @@ module ChunkyPNG
     #
     # @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.
+    # @param [Integer] color 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.
     def set_pixel_if_within_bounds(x, y, color)
@@ -233,7 +232,7 @@ module ChunkyPNG
       dimension.include?(ChunkyPNG::Point(*point_like))
     end
 
-    alias_method :include?,    :include_point?
+    alias include? include_point?
 
     # Checks whether the given x- and y-coordinate are in the range of the
     # canvas
@@ -274,11 +273,13 @@ module ChunkyPNG
     # @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
+      other.is_a?(self.class) &&
+        other.pixels == pixels &&
+        other.width == width &&
+        other.height == height
     end
 
-    alias :== :eql?
+    alias == eql?
 
     #################################################################
     # EXPORTING
@@ -296,7 +297,7 @@ module ChunkyPNG
     def inspect
       inspected = "<#{self.class.name} #{width}x#{height} ["
       for y in 0...height
-        inspected << "\n\t[" << row(y).map { |p| ChunkyPNG::Color.to_hex(p) }.join(' ') << ']'
+        inspected << "\n\t[" << row(y).map { |p| ChunkyPNG::Color.to_hex(p) }.join(" ") << "]"
       end
       inspected << "\n]>"
     end
@@ -358,13 +359,13 @@ module ChunkyPNG
 
     # Throws an exception if the matrix width and height does not match this canvas' dimensions.
     def assert_size!(matrix_width, matrix_height)
-      if width  != matrix_width
+      if width != matrix_width
         raise ChunkyPNG::ExpectationFailed,
-          'The width of the matrix does not match the canvas width!'
+          "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!'
+          "The height of the matrix does not match the canvas height!"
       end
       true
     end

data/lib/chunky_png/canvas/adam7_interlacing.rb

@@ -1,6 +1,5 @@
 module ChunkyPNG
   class Canvas
-    
     # Methods for decoding and encoding Adam7 interlacing.
     #
     # Adam7 interlacing extracts 7 pass images out of a single image, that can be encoded to a
@@ -8,12 +7,15 @@ module ChunkyPNG
     # ChunkyPNG canvas and is used to extract the pass images from the original image, or to
     # reconstruct an original image from separate pass images.
     module Adam7Interlacing
-      
       # Returns an array with the x-shift, x-offset, y-shift and y-offset for the requested pass.
       # @param [Integer] pass The pass number, should be in 0..6.
       def adam7_multiplier_offset(pass)
-        [3 - (pass >> 1), (pass & 1 == 0) ? 0 : 8 >> ((pass + 1) >> 1),
-         pass == 0 ? 3 : 3 - ((pass - 1) >> 1), (pass == 0 || pass & 1 == 1) ? 0 : 8 >> (pass >> 1)]
+        [
+          3 - (pass >> 1),
+          pass & 1 == 0 ? 0 : 8 >> ((pass + 1) >> 1),
+          pass == 0 ? 3 : 3 - ((pass - 1) >> 1),
+          pass == 0 || pass & 1 == 1 ? 0 : 8 >> (pass >> 1),
+        ]
       end
 
       # Returns the pixel dimensions of the requested pass.
@@ -22,10 +24,12 @@ module ChunkyPNG
       # @param [Integer] original_height The height of the original image.
       def adam7_pass_size(pass, original_width, original_height)
         x_shift, x_offset, y_shift, y_offset = adam7_multiplier_offset(pass)
-        [ (original_width  - x_offset + (1 << x_shift) - 1) >> x_shift,
-          (original_height - y_offset + (1 << y_shift) - 1) >> y_shift]
+        [
+          (original_width  - x_offset + (1 << x_shift) - 1) >> x_shift,
+          (original_height - y_offset + (1 << y_shift) - 1) >> y_shift,
+        ]
       end
-      
+
       # Returns an array of the dimension of all the pass images.
       # @param [Integer] original_width The width of the original image.
       # @param [Integer] original_height The height of the original image.
@@ -49,7 +53,7 @@ module ChunkyPNG
           end
         end
       end
-      
+
       # Extracts a pass from a complete image
       # @param [Integer] pass The pass number, should be in 0..6.
       # @param [ChunkyPNG::Canvas] canvas The image that is being deconstructed.
@@ -57,13 +61,13 @@ module ChunkyPNG
       def adam7_extract_pass(pass, canvas)
         x_shift, x_offset, y_shift, y_offset = adam7_multiplier_offset(pass)
         sm_pixels = []
-        
+
         y_offset.step(canvas.height - 1, 1 << y_shift) do |y|
           x_offset.step(canvas.width - 1, 1 << x_shift) do |x|
             sm_pixels << canvas[x, y]
           end
         end
-        
+
         new_canvas_args = adam7_pass_size(pass, canvas.width, canvas.height) + [sm_pixels]
         ChunkyPNG::Canvas.new(*new_canvas_args)
       end

data/lib/chunky_png/canvas/data_url_exporting.rb

@@ -1,14 +1,12 @@
 module ChunkyPNG
   class Canvas
-
     # Methods to export a canvas to a PNG data URL.
     module DataUrlExporting
-
       # Exports the canvas as a data url (e.g. data:image/png;base64,<data>) that can
       # easily be used inline in CSS or HTML.
       # @return [String] The canvas formatted as a data URL string.
       def to_data_url
-        ['data:image/png;base64,', to_blob].pack('A*m').gsub(/\n/, '')
+        ["data:image/png;base64,", to_blob].pack("A*m").delete("\n")
       end
     end
   end

data/lib/chunky_png/canvas/data_url_importing.rb

@@ -1,9 +1,7 @@
 module ChunkyPNG
   class Canvas
-
     # Methods to import a canvas from a PNG data URL.
     module DataUrlImporting
-
       # Imports a canvas from a PNG data URL.
       # @param [String] string The data URL string to load from.
       # @return [Canvas] The imported canvas.
@@ -11,7 +9,7 @@ module ChunkyPNG
       #    formatted PNG data URL (i.e. it should start with "data:image/png;base64,")
       def from_data_url(string)
         if string =~ %r[^data:image/png;base64,((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?)$]
-          from_blob($1.unpack('m').first)
+          from_blob($1.unpack("m").first)
         else
           raise SignatureMismatch, "The string was not a properly formatted data URL for a PNG image."
         end

data/lib/chunky_png/canvas/drawing.rb

@@ -1,6 +1,5 @@
 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
@@ -10,7 +9,6 @@ module ChunkyPNG
     #   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.
       #
@@ -33,44 +31,44 @@ module ChunkyPNG
       end
 
       # Draws a Bezier curve
-      # @param [Array, Point] A collection of control points
+      # @param [Array, Point] points A collection of control points
+      # @param [Integer] stroke_color
       # @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)
+          when 0, 1 then return self
+          when 2 then return line(points[0].x, points[0].y, points[1].x, points[1].y, stroke_color)
         end
 
-        curve_points = Array.new
+        curve_points = []
 
         t     = 0
         n     = points.length - 1
-        bicof = 0
 
         while t <= 100
-          cur_p = ChunkyPNG::Point.new(0,0)
+          bicof = 0
+          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
+          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)
+            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
+          cur_p.x += (t_f**n) * points[n].x
+          cur_p.y += (t_f**n) * points[n].y
 
           curve_points << cur_p
 
-          bicof = 0
           t += 1
         end
 
@@ -127,9 +125,7 @@ module ChunkyPNG
             w = 0xff - (e_acc >> 8)
             compose_pixel(x0, y0, ChunkyPNG::Color.fade(stroke_color, w))
             if inclusive || i > 0
-              compose_pixel(x0 + sx,
-                            y0 + sy,
-                            ChunkyPNG::Color.fade(stroke_color, 0xff - w))
+              compose_pixel(x0 + sx, y0 + sy, ChunkyPNG::Color.fade(stroke_color, 0xff - w))
             end
             y0 += sy
           end
@@ -145,9 +141,7 @@ module ChunkyPNG
             w = 0xff - (e_acc >> 8)
             compose_pixel(x0, y0, ChunkyPNG::Color.fade(stroke_color, w))
             if inclusive || i > 0
-              compose_pixel(x0 + sx,
-                            y0 + sy,
-                            ChunkyPNG::Color.fade(stroke_color, 0xff - w))
+              compose_pixel(x0 + sx, y0 + sy, ChunkyPNG::Color.fade(stroke_color, 0xff - w))
             end
             x0 += sx
           end
@@ -157,23 +151,20 @@ module ChunkyPNG
         self
       end
 
-      alias_method :line, :line_xiaolin_wu
+      alias line line_xiaolin_wu
 
       # 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
+      # @param [Array, String] path 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)
         if path.length < 3
-          raise ArgumentError, 'A polygon requires at least 3 points'
+          raise ArgumentError, "A polygon requires at least 3 points"
         end
 
         stroke_color = ChunkyPNG::Color.parse(stroke_color)
@@ -215,10 +206,7 @@ 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)
 
@@ -248,16 +236,13 @@ 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)
 
         f = 1 - radius
-        ddF_x = 1
-        ddF_y = -2 * radius
+        dd_f_x = 1
+        dd_f_y = -2 * radius
         x = 0
         y = radius
 
@@ -272,13 +257,13 @@ module ChunkyPNG
 
           if f >= 0
             y -= 1
-            ddF_y += 2
-            f += ddF_y
+            dd_f_y += 2
+            f += dd_f_y
           end
 
           x += 1
-          ddF_x += 2
-          f += ddF_x
+          dd_f_x += 2
+          f += dd_f_x
 
           unless fill_color == ChunkyPNG::Color::TRANSPARENT
             lines[y] = lines[y] ? [lines[y], x - 1].min : x - 1

data/lib/chunky_png/canvas/masking.rb

@@ -1,13 +1,11 @@
 module ChunkyPNG
   class Canvas
-    
     # The ChunkyPNG::Canvas::Masking module defines methods to perform masking
     # and theming operations on a {ChunkyPNG::Canvas}. The module is included into the Canvas class so all
     # these methods are available on every canvas.
     #
     # @see ChunkyPNG::Canvas
     module Masking
-
       # Creates a new image, based on the current image but with a new theme color.
       #
       # This method will replace one color in an image with another image. This is done by
@@ -21,8 +19,8 @@ module ChunkyPNG
       # @param [Integer] old_theme_color The original theme color in this image.
       # @param [Integer] new_theme_color The color to replace the old theme color with.
       # @param [Integer] bg_color The background color on which the theme colored pixels are placed.
-      # @param [Integer] tolerance The tolerance level to use when extracting the mask image. Five is 
-      #    the default; increase this if the masked image does not extract all the required pixels, 
+      # @param [Integer] tolerance The tolerance level to use when extracting the mask image. Five is
+      #    the default; increase this if the masked image does not extract all the required pixels,
       #    decrease it if too many pixels get extracted.
       # @return [ChunkyPNG::Canvas] Returns itself, but with the theme colored pixels changed.
       # @see #change_theme_color!
@@ -30,9 +28,9 @@ module ChunkyPNG
       def change_theme_color!(old_theme_color, new_theme_color, bg_color = ChunkyPNG::Color::WHITE, tolerance = 5)
         base, mask = extract_mask(old_theme_color, bg_color, tolerance)
         mask.change_mask_color!(new_theme_color)
-        self.replace!(base.compose!(mask))
+        replace!(base.compose!(mask))
       end
-      
+
       # Creates a base image and a mask image from an original image that has a particular theme color.
       # This can be used to easily change a theme color in an image.
       #
@@ -40,16 +38,16 @@ module ChunkyPNG
       # these in a mask image. All the other pixels will be stored in a base image. Both images will be
       # of the exact same size as the original image. The original image will be left untouched.
       #
-      # The color of the mask image can be changed with {#change_mask_color!}. This new mask image can 
-      # then be composed upon the base image to create an image with a new theme color. A call to 
+      # The color of the mask image can be changed with {#change_mask_color!}. This new mask image can
+      # then be composed upon the base image to create an image with a new theme color. A call to
       # {#change_theme_color!} will perform this in one go.
       #
       # @param [Integer] mask_color The current theme color.
       # @param [Integer] bg_color The background color on which the theme colored pixels are applied.
-      # @param [Integer] tolerance The tolerance level to use when extracting the mask image. Five is 
-      #    the default; increase this if the masked image does not extract all the required pixels, 
+      # @param [Integer] tolerance The tolerance level to use when extracting the mask image. Five is
+      #    the default; increase this if the masked image does not extract all the required pixels,
       #    decrease it if too many pixels get extracted.
-      # @return [Array<ChunkyPNG::Canvas, ChunkyPNG::Canvas>] An array with the base canvas and the mask 
+      # @return [Array<ChunkyPNG::Canvas, ChunkyPNG::Canvas>] An array with the base canvas and the mask
       #    canvas as elements.
       # @see #change_theme_color!
       # @see #change_mask_color!
@@ -66,10 +64,10 @@ module ChunkyPNG
             base_pixels << pixel
           end
         end
-        
-        [ self.class.new(width, height, base_pixels), self.class.new(width, height, mask_pixels) ]
+
+        [self.class.new(width, height, base_pixels), self.class.new(width, height, mask_pixels)]
       end
-      
+
       # Changes the color of a mask image.
       #
       # This method works on a canvas extracted out of another image using the {#extract_mask} method.