bench9000 0.1

data/vendor/chunky_png/lib/chunky_png/canvas/adam7_interlacing.rb

@@ -0,0 +1,72 @@
+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
+    # stream separately so the image can be built up progressively. The module is included into
+    # 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)]
+      end
+
+      # Returns the pixel dimensions of the requested pass.
+      # @param [Integer] pass The pass number, should be in 0..6.
+      # @param [Integer] original_width The width of the original image.
+      # @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]
+      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.
+      # @return [Array<Array<Integer>>] Returns an array with 7 pairs of dimensions.
+      # @see #adam7_pass_size
+      def adam7_pass_sizes(original_width, original_height)
+        (0...7).map { |pass| adam7_pass_size(pass, original_width, original_height) }
+      end
+
+      # Merges a pass image into a total image that is being constructed.
+      # @param [Integer] pass The pass number, should be in 0..6.
+      # @param [ChunkyPNG::Canvas] canvas The image that is being constructed.
+      # @param [ChunkyPNG::Canvas] subcanvas The pass image that should be merged
+      def adam7_merge_pass(pass, canvas, subcanvas)
+        x_shift, x_offset, y_shift, y_offset = adam7_multiplier_offset(pass)
+        for y in 0...subcanvas.height do
+          for x in 0...subcanvas.width do
+            new_x = (x << x_shift) | x_offset
+            new_y = (y << y_shift) | y_offset
+            canvas[new_x, new_y] = subcanvas[x, y]
+          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.
+      # @return [ChunkyPNG::Canvas] The extracted pass image.
+      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
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/canvas/data_url_exporting.rb

@@ -0,0 +1,15 @@
+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/, '')
+      end
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/canvas/data_url_importing.rb

@@ -0,0 +1,21 @@
+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.
+      # @raise ChunkyPNG::SignatureMismatch if the provides string is not a properly
+      #    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)
+        else
+          raise SignatureMismatch, "The string was not a properly formatted data URL for a PNG image."
+        end
+      end
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/canvas/drawing.rb

@@ -0,0 +1,338 @@
+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.
+    #
+    # @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.
+      #
+      # @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 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
+        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
+            i += 1
+          end
+
+          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
+
+        curve_points.each_cons(2) do |p1, p2|
+          line_xiaolin_wu(p1.x.round, p1.y.round, p2.x.round, p2.y.round, stroke_color)
+        end
+
+        self
+      end
+
+      # Draws an anti-aliased line using Xiaolin Wu's algorithm.
+      #
+      # @param [Integer] x0 The x-coordinate of the first control point.
+      # @param [Integer] y0 The y-coordinate of the first control point.
+      # @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.
+      # @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
+            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))
+            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
+            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))
+            end
+            x0 += sx
+          end
+          compose_pixel(x1, y1, stroke_color) if inclusive
+        end
+
+        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.
+      #
+      # @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)
+
+        vector = ChunkyPNG::Vector(*path)
+        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)
+
+        # Fill
+        unless fill_color == ChunkyPNG::Color::TRANSPARENT
+          vector.y_range.each do |y|
+            intersections = []
+            vector.edges.each do |p1, p2|
+              if (p1.y < y && p2.y >= y) || (p2.y < y && p1.y >= y)
+                intersections << (p1.x + (y - p1.y).to_f / (p2.y - p1.y) * (p2.x - p1.x)).round
+              end
+            end
+
+            intersections.sort!
+            0.step(intersections.length - 1, 2) do |i|
+              intersections[i].upto(intersections[i + 1]) do |x|
+                compose_pixel(x, y, fill_color)
+              end
+            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
+
+        self
+      end
+
+      # Draws a rectangle on the canvas, using two control points.
+      #
+      # @param [Integer] x0 The x-coordinate of the first control point.
+      # @param [Integer] y0 The y-coordinate of the first control point.
+      # @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 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)
+
+        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|
+            [y0, y1].min.upto([y0, y1].max) do |y|
+              compose_pixel(x, y, fill_color)
+            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)
+
+        self
+      end
+
+      # Draws a circle on the canvas.
+      #
+      # @param [Integer] x0 The x-coordinate of the center of the circle.
+      # @param [Integer] y0 The y-coordinate of the center of the circle.
+      # @param [Integer] radius The radius of the circle from the center point.
+      # @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)
+
+        stroke_color = ChunkyPNG::Color.parse(stroke_color)
+        fill_color   = ChunkyPNG::Color.parse(fill_color)
+
+        f = 1 - radius
+        ddF_x = 1
+        ddF_y = -2 * radius
+        x = 0
+        y = radius
+
+        compose_pixel(x0, y0 + radius, stroke_color)
+        compose_pixel(x0, y0 - radius, stroke_color)
+        compose_pixel(x0 + radius, y0, stroke_color)
+        compose_pixel(x0 - radius, y0, stroke_color)
+
+        lines = [radius - 1] unless fill_color == ChunkyPNG::Color::TRANSPARENT
+
+        while x < y
+
+          if f >= 0
+            y -= 1
+            ddF_y += 2
+            f += ddF_y
+          end
+
+          x += 1
+          ddF_x += 2
+          f += ddF_x
+
+          unless fill_color == ChunkyPNG::Color::TRANSPARENT
+            lines[y] = lines[y] ? [lines[y], x - 1].min : x - 1
+            lines[x] = lines[x] ? [lines[x], y - 1].min : y - 1
+          end
+
+          compose_pixel(x0 + x, y0 + y, stroke_color)
+          compose_pixel(x0 - x, y0 + y, stroke_color)
+          compose_pixel(x0 + x, y0 - y, stroke_color)
+          compose_pixel(x0 - x, y0 - y, stroke_color)
+
+          unless x == y
+            compose_pixel(x0 + y, y0 + x, stroke_color)
+            compose_pixel(x0 - y, y0 + x, stroke_color)
+            compose_pixel(x0 + y, y0 - x, stroke_color)
+            compose_pixel(x0 - y, y0 - x, stroke_color)
+          end
+        end
+
+        unless fill_color == ChunkyPNG::Color::TRANSPARENT
+          lines.each_with_index do |length, y|
+            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
+
+        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)
+      # @return [Integer] The binomial coeffcient of (n,k)
+      def binomial_coefficient(n, k)
+        return  1 if n == k || k == 0
+        return  n if k == 1
+        return -1 if n < k
+
+        # calculate factorials
+        fact_n = (2..n).inject(1) { |carry, i| carry * i }
+        fact_k = (2..k).inject(1) { |carry, i| carry * i }
+        fact_n_sub_k = (2..(n - k)).inject(1) { |carry, i| carry * i }
+
+        fact_n / (fact_k * fact_n_sub_k)
+      end
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/canvas/masking.rb

@@ -0,0 +1,91 @@
+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
+      # first extracting the pixels with a color close to the original theme color as a mask
+      # image, changing the color of this mask image and then apply it on the original image.
+      #
+      # Mask extraction works best when the theme colored pixels are clearly distinguishable
+      # from a background color (preferably white). You can set a tolerance level to influence
+      # the extraction process.
+      #
+      # @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, 
+      #    decrease it if too many pixels get extracted.
+      # @return [ChunkyPNG::Canvas] Returns itself, but with the theme colored pixels changed.
+      # @see #change_theme_color!
+      # @see #change_mask_color!
+      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))
+      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.
+      #
+      # It will extract all the pixels that look like the theme color (with a tolerance level) and put
+      # 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 
+      # {#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, 
+      #    decrease it if too many pixels get extracted.
+      # @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!
+      def extract_mask(mask_color, bg_color = ChunkyPNG::Color::WHITE, tolerance = 5)
+        base_pixels = []
+        mask_pixels = []
+
+        pixels.each do |pixel|
+          if ChunkyPNG::Color.alpha_decomposable?(pixel, mask_color, bg_color, tolerance)
+            mask_pixels << ChunkyPNG::Color.decompose_color(pixel, mask_color, bg_color, tolerance)
+            base_pixels << bg_color
+          else
+            mask_pixels << (mask_color & 0xffffff00)
+            base_pixels << pixel
+          end
+        end
+        
+        [ 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.
+      # It can then be applied on the extracted base image. See {#change_theme_color!} to perform
+      # these operations in one go.
+      #
+      # @param [Integer] new_color The color to replace the original mask color with.
+      # @raise [ChunkyPNG::ExpectationFailed] when this canvas is not a mask image, i.e. its palette
+      #    has more than once color, disregarding transparency.
+      # @see #change_theme_color!
+      # @see #extract_mask
+      def change_mask_color!(new_color)
+        raise ChunkyPNG::ExpectationFailed, "This is not a mask image!" if palette.opaque_palette.size != 1
+        pixels.map! { |pixel| (new_color & 0xffffff00) | ChunkyPNG::Color.a(pixel) }
+        self
+      end
+    end
+  end
+end