chunky_png 0.7.0 → 0.7.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 = "0.7.0"
-  s.date    = "2010-03-15"
+  s.version = "0.7.1"
+  s.date    = "2010-03-23"
 
   s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"
   s.description = <<-EOT

data/lib/chunky_png.rb

@@ -27,7 +27,7 @@ module ChunkyPNG
 
   # The current version of ChunkyPNG. This value will be updated automatically
   # by them gem:release rake task.
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 
   ###################################################
   # PNG international standard defined constants

data/lib/chunky_png/canvas.rb

@@ -59,7 +59,7 @@ module ChunkyPNG
 
       @width, @height = width, height
 
-      if initial.kind_of?(Fixnum)
+      if initial.kind_of?(Integer)
         @pixels = Array.new(width * height, initial)
       elsif initial.kind_of?(Array) && initial.size == width * height
         @pixels = initial

data/lib/chunky_png/canvas/png_decoding.rb

@@ -179,12 +179,12 @@ module ChunkyPNG
       # scanline, combining them using a color mode dependent color decoder.
       #
       # @param [Integer] filter The filter used to encode the bytes.
-      # @param [Array<Fixnum>] bytes The filtered bytes to decode.
-      # @param [Array<Fixnum>] previous_bytes The decoded bytes of the 
+      # @param [Array<Integer>] bytes The filtered bytes to decode.
+      # @param [Array<Integer>] previous_bytes The decoded bytes of the 
       #      previous scanline.
       # @param [Integer] pixelsize The amount of bytes used for every pixel.
       #      This depends on the used color mode and color depth.
-      # @return [Array<Fixnum>] The array of original bytes for the scanline,
+      # @return [Array<Integer>] The array of original bytes for the scanline,
       #      before they were encoded.
       def decode_png_scanline(filter, bytes, previous_bytes, pixelsize = 3)
         case filter

data/lib/chunky_png/canvas/png_encoding.rb

@@ -202,7 +202,7 @@ module ChunkyPNG
 
       # Passes to this canvas of pixel values line by line.
       # @yield [line] Yields the scanlines of this image one by one.
-      # @yieldparam [Array<Fixnum>] line An line of fixnums representing pixels
+      # @yieldparam [Array<Integer>] line An line of fixnums representing pixels
       def each_scanline(&block)
         for line_no in 0...height do
           scanline = pixels[width * line_no, width]
@@ -212,10 +212,10 @@ module ChunkyPNG
 
       # Encodes the bytes of a scanline with a given filter.
       # @param [Integer] filter The filter method to use.
-      # @param [Array<Fixnum>]  bytes The scanline bytes to encode.
-      # @param [Array<Fixnum>]  previous_bytes The original bytes of the previous scanline.
+      # @param [Array<Integer>]  bytes The scanline bytes to encode.
+      # @param [Array<Integer>]  previous_bytes The original bytes of the previous scanline.
       # @param [Integer] pixelsize The number of bytes per pixel.
-      # @return [Array<Fixnum>] The filtered array of bytes.
+      # @return [Array<Integer>] The filtered array of bytes.
       def encode_png_scanline(filter, bytes, previous_bytes = nil, pixelsize = 3)
         case filter
         when ChunkyPNG::FILTER_NONE    then encode_png_scanline_none(    bytes, previous_bytes, pixelsize)
@@ -228,10 +228,10 @@ module ChunkyPNG
       end
 
       # Encodes the bytes of a scanline without filtering.
-      # @param [Array<Fixnum>]  bytes The scanline bytes to encode.
-      # @param [Array<Fixnum>]  previous_bytes The original bytes of the previous scanline.
+      # @param [Array<Integer>]  bytes The scanline bytes to encode.
+      # @param [Array<Integer>]  previous_bytes The original bytes of the previous scanline.
       # @param [Integer] pixelsize The number of bytes per pixel.
-      # @return [Array<Fixnum>] The filtered array of bytes.
+      # @return [Array<Integer>] The filtered array of bytes.
       def encode_png_scanline_none(original_bytes, previous_bytes = nil, pixelsize = 3)
         [ChunkyPNG::FILTER_NONE] + original_bytes
       end

data/lib/chunky_png/chunk.rb

@@ -31,7 +31,7 @@ module ChunkyPNG
     # Verifies the CRC of a chunk.
     # @param [String] type The chunk's type.
     # @param [String] content The chunk's content.
-    # @param [Fixnum] content The chunk's content.
+    # @param [Integer] content The chunk's content.
     # @raise [RuntimeError] An exception is raised if the found CRC value
     #    is not equal to the expected CRC value.
     def self.verify_crc!(type, content, found_crc)

data/lib/chunky_png/color.rb

@@ -2,12 +2,12 @@ module ChunkyPNG
 
   # The Color module defines methods for handling colors. Within the ChunkyPNG
   # library, the concepts of pixels and colors are both used, and they are
-  # both represented by a Fixnum.
+  # both represented by a Integer.
   #
   # Pixels/colors are represented in RGBA componetns. Each of the four
   # components is stored with a depth of 8 bits (maximum value = 255 =
   # {ChunkyPNG::Color::MAX}). Together, these components are stored in a 4-byte
-  # Fixnum.
+  # Integer.
   #
   # A color will always be represented using these 4 components in memory.
   # When the image is encoded, a more suitable representation can be used
@@ -24,13 +24,13 @@ module ChunkyPNG
     ####################################################################
 
     # Creates a new color using an r, g, b triple and an alpha value.
-    # @return [Fixnum] The newly constructed color value.
+    # @return [Integer] The newly constructed color value.
     def rgba(r, g, b, a)
       r << 24 | g << 16 | b << 8 | a
     end
 
     # Creates a new color using an r, g, b triple.
-    # @return [Fixnum] The newly constructed color value.
+    # @return [Integer] The newly constructed color value.
     def rgb(r, g, b)
       r << 24 | g << 16 | b << 8 | 0xff
     end
@@ -42,7 +42,7 @@ module ChunkyPNG
     end
 
     # Creates a new color using a grayscale teint and alpha value.
-    # @return [Fixnum] The newly constructed color value.
+    # @return [Integer] The newly constructed color value.
     def grayscale_alpha(teint, a)
       teint << 24 | teint << 16 | teint << 8 | a
     end
@@ -55,8 +55,8 @@ module ChunkyPNG
     #
     # @param [String] stream The string to load the color from. It should be 
     #     at least 3 + pos bytes long.
-    # @param [Fixnum] pos The position in the string to load the triple from.
-    # @return [Fixnum] The newly constructed color value.
+    # @param [Integer] pos The position in the string to load the triple from.
+    # @return [Integer] The newly constructed color value.
     def from_rgb_stream(stream, pos = 0)
       rgb(*stream.unpack("@#{pos}C3"))
     end
@@ -65,8 +65,8 @@ module ChunkyPNG
     #
     # @param [String] stream The string to load the color from. It should be 
     #      at least 4 + pos bytes long.
-    # @param [Fixnum] pos The position in the string to load the triple from.
-    # @return [Fixnum] The newly constructed color value.
+    # @param [Integer] pos The position in the string to load the triple from.
+    # @return [Integer] The newly constructed color value.
     def from_rgba_stream(stream, pos = 0)
       rgba(*stream.unpack("@#{pos}C4"))
     end
@@ -76,7 +76,7 @@ module ChunkyPNG
     # It supports colors with (#rrggbbaa) or without (#rrggbb) alpha channel.
     # Color strings may include the prefix "0x" or "#".
     #
-    # @param [String] str The color in hex notation. @return [Fixnum] The
+    # @param [String] str The color in hex notation. @return [Integer] The
     # converted color value.
     def from_hex(str)
       case str
@@ -92,54 +92,54 @@ module ChunkyPNG
 
     # Returns the red-component from the color value.
     #
-    # @param [Fixnum] value The color value.
-    # @return [Fixnum] A value between 0 and MAX.
+    # @param [Integer] value The color value.
+    # @return [Integer] A value between 0 and MAX.
     def r(value)
       (value & 0xff000000) >> 24
     end
     
     # Returns the green-component from the color value.
     #
-    # @param [Fixnum] value The color value.
-    # @return [Fixnum] A value between 0 and MAX.
+    # @param [Integer] value The color value.
+    # @return [Integer] A value between 0 and MAX.
     def g(value)
       (value & 0x00ff0000) >> 16
     end
     
     # Returns the blue-component from the color value.
     #
-    # @param [Fixnum] value The color value.
-    # @return [Fixnum] A value between 0 and MAX.
+    # @param [Integer] value The color value.
+    # @return [Integer] A value between 0 and MAX.
     def b(value)
       (value & 0x0000ff00) >> 8
     end
     
     # Returns the alpha channel value for the color value.
     #
-    # @param [Fixnum] value The color value.
-    # @return [Fixnum] A value between 0 and MAX.
+    # @param [Integer] value The color value.
+    # @return [Integer] A value between 0 and MAX.
     def a(value)
       value & 0x000000ff
     end
     
     # Returns true if this color is fully opaque.
     #
-    # @param [Fixnum] value The color to test.
+    # @param [Integer] value The color to test.
     # @return [true, false] True if the alpha channel equals MAX.
     def opaque?(value)
       a(value) == 0x000000ff
     end
     
     # Returns the opaque value of this color by removing the alpha channel.
-    # @param [Fixnum] value The color to transform.
-    # @return [Fixnum] The opauq color
+    # @param [Integer] value The color to transform.
+    # @return [Integer] The opauq color
     def opaque!(value)
       value | 0x000000ff
     end
     
     # Returns true if this color is fully transparent.
     #
-    # @param [Fixnum] value The color to test.
+    # @param [Integer] value The color to test.
     # @return [true, false] True if the r, g and b component are equal.
     def grayscale?(value)
       r(value) == b(value) && b(value) == g(value)
@@ -147,7 +147,7 @@ module ChunkyPNG
     
     # Returns true if this color is fully transparent.
     #
-    # @param [Fixnum] value The color to test.
+    # @param [Integer] value The color to test.
     # @return [true, false] True if the alpha channel equals 0.
     def fully_transparent?(value)
       a(value) == 0x00000000
@@ -163,9 +163,9 @@ module ChunkyPNG
     #
     # This is a quicker implementation of ((a * b) / 255.0).round.
     #
-    # @param [Fixnum] a The first fraction.
-    # @param [Fixnum] b The second fraction.
-    # @return [Fixnum] The result of the multiplication.
+    # @param [Integer] a The first fraction.
+    # @param [Integer] b The second fraction.
+    # @return [Integer] The result of the multiplication.
     def int8_mult(a, b)
       t = a * b + 0x80
       ((t >> 8) + t) >> 8
@@ -176,9 +176,9 @@ module ChunkyPNG
     # This version is faster than the version based on floating point math, so this
     # compositing function is used by default.
     #
-    # @param [Fixnum] fg The foreground color.
-    # @param [Fixnum] bg The foreground color.
-    # @return [Fixnum] The composited color.
+    # @param [Integer] fg The foreground color.
+    # @param [Integer] bg The foreground color.
+    # @return [Integer] The composited color.
     # @see ChunkyPNG::Color#compose_precise
     def compose_quick(fg, bg)
       return fg if opaque?(fg)
@@ -198,9 +198,9 @@ module ChunkyPNG
     # when the result is converted back to an integer. Because it is slower than
     # the version based on integer math, that version is preferred.
     #
-    # @param [Fixnum] fg The foreground color.
-    # @param [Fixnum] bg The foreground color.
-    # @return [Fixnum] The composited color.
+    # @param [Integer] fg The foreground color.
+    # @param [Integer] bg The foreground color.
+    # @return [Integer] The composited color.
     # @see ChunkyPNG::Color#compose_quick
     def compose_precise(fg, bg)
       return fg if opaque?(fg)
@@ -222,17 +222,17 @@ module ChunkyPNG
     # Blends the foreground and background color by taking the average of 
     # the components.
     #
-    # @param [Fixnum] fg The foreground color.
-    # @param [Fixnum] bg The foreground color.
-    # @return [Fixnum] The blended color.
+    # @param [Integer] fg The foreground color.
+    # @param [Integer] bg The foreground color.
+    # @return [Integer] The blended color.
     def blend(fg, bg)
       (fg + bg) >> 1
     end
 
     # Lowers the intensity of a color, by lowering its alpha by a given factor.
-    # @param [Fixnum] color The color to adjust.
-    # @param [Fixnum] factor Fade factor as an integer between 0 and 255.
-    # @return [Fixnum] The faded color.
+    # @param [Integer] color The color to adjust.
+    # @param [Integer] factor Fade factor as an integer between 0 and 255.
+    # @return [Integer] The faded color.
     def fade(color, factor)
       new_alpha = int8_mult(a(color), factor)
       (color & 0xffffff00) | new_alpha
@@ -246,11 +246,11 @@ module ChunkyPNG
     # If the color cannot be decomposed, this method will return the fully
     # transparentvariant of the mask color.
     #
-    # @param [Fixnum] color The color that was the result of compositing.
-    # @param [Fixnum] mask The opaque variant of the color that was being composed
-    # @param [Fixnum] bg The background color on which the color was composed.
-    # @param [Fixnum] tolerance The decomposition tolerance level, a value between 0 and 255.
-    # @return [Fixnum] The decomposed color,a variant of the masked color with the 
+    # @param [Integer] color The color that was the result of compositing.
+    # @param [Integer] mask The opaque variant of the color that was being composed
+    # @param [Integer] bg The background color on which the color was composed.
+    # @param [Integer] tolerance The decomposition tolerance level, a value between 0 and 255.
+    # @return [Integer] The decomposed color,a variant of the masked color with the 
     #    alpha channel set to an appropriate value.
     def decompose_color(color, mask, bg, tolerance = 1)
       if alpha_decomposable?(color, mask, bg, tolerance)
@@ -264,11 +264,11 @@ module ChunkyPNG
     # given the resulting color, the mask color and a background color,
     # all of which should be opaque. 
     #
-    # @param [Fixnum] color The color that was the result of compositing.
-    # @param [Fixnum] mask The opauqe variant of the color that was being composed
-    # @param [Fixnum] bg The background color on which the color was composed.
-    # @param [Fixnum] tolerance The decomposition tolerance level, a value between 0 and 255.
-    # @return [Fixnum] The decomposed alpha channel value, between 0 and 255.
+    # @param [Integer] color The color that was the result of compositing.
+    # @param [Integer] mask The opauqe variant of the color that was being composed
+    # @param [Integer] bg The background color on which the color was composed.
+    # @param [Integer] tolerance The decomposition tolerance level, a value between 0 and 255.
+    # @return [Integer] The decomposed alpha channel value, between 0 and 255.
     # @see #decompose_alpha
     def alpha_decomposable?(color, mask, bg, tolerance = 1)
       components = decompose_alpha_components(color, mask, bg)
@@ -284,10 +284,10 @@ module ChunkyPNG
     # value can successfully decomposed with a given tolerance, otherwise the return 
     # value of this method is undefined.
     #
-    # @param [Fixnum] color The color that was the result of compositing.
-    # @param [Fixnum] mask The opauqe variant of the color that was being composed
-    # @param [Fixnum] bg The background color on which the color was composed.
-    # @return [Fixnum] The best fitting alpha channel, a value between 0 and 255.
+    # @param [Integer] color The color that was the result of compositing.
+    # @param [Integer] mask The opauqe variant of the color that was being composed
+    # @param [Integer] bg The background color on which the color was composed.
+    # @return [Integer] The best fitting alpha channel, a value between 0 and 255.
     # @see #alpha_decomposable?
     def decompose_alpha(color, mask, bg)
       components = decompose_alpha_components(color, mask, bg)
@@ -296,20 +296,20 @@ module ChunkyPNG
     
     # Decomposes an alpha channel for either the r, g or b color channel.
     # @param [:r, :g, :b] The channel to decompose the alpha channel from.
-    # @param [Fixnum] color The color that was the result of compositing.
-    # @param [Fixnum] mask The opauqe variant of the color that was being composed
-    # @param [Fixnum] bg The background color on which the color was composed.
-    # @param [Fixnum] The decomposed alpha value for the channel.
+    # @param [Integer] color The color that was the result of compositing.
+    # @param [Integer] mask The opauqe variant of the color that was being composed
+    # @param [Integer] bg The background color on which the color was composed.
+    # @param [Integer] The decomposed alpha value for the channel.
     def decompose_alpha_component(channel, color, mask, bg)
       ((send(channel, bg) - send(channel, color)).to_f / 
           (send(channel, bg) - send(channel, mask)).to_f * MAX).round
     end
     
     # Decomposes the alpha channels for the r, g and b color channel.
-    # @param [Fixnum] color The color that was the result of compositing.
-    # @param [Fixnum] mask The opauqe variant of the color that was being composed
-    # @param [Fixnum] bg The background color on which the color was composed.    
-    # @return [Array<Fixnum>] The decomposed alpha values for the r, g and b channels.
+    # @param [Integer] color The color that was the result of compositing.
+    # @param [Integer] mask The opauqe variant of the color that was being composed
+    # @param [Integer] bg The background color on which the color was composed.    
+    # @return [Array<Integer>] The decomposed alpha values for the r, g and b channels.
     def decompose_alpha_components(color, mask, bg)
       [
         decompose_alpha_component(:r, color, mask, bg),
@@ -324,7 +324,7 @@ module ChunkyPNG
 
     # Returns a string representing this color using hex notation (i.e. #rrggbbaa).
     #
-    # @param [Fixnum] value The color to convert.
+    # @param [Integer] value The color to convert.
     # @return [String] The color in hex notation, starting with a pound sign.
     def to_hex(color, include_alpha = true)
       include_alpha ? ('#%08x' % color) : ('#%06x' % [color >> 8])
@@ -332,8 +332,8 @@ module ChunkyPNG
 
     # Returns an array with the separate RGBA values for this color.
     #
-    # @param [Fixnum] color The color to convert.
-    # @return [Array<Fixnum>] An array with 4 Fixnum elements.
+    # @param [Integer] color The color to convert.
+    # @return [Array<Integer>] An array with 4 Integer elements.
     def to_truecolor_alpha_bytes(color)
       [r(color), g(color), b(color), a(color)]
     end
@@ -341,8 +341,8 @@ module ChunkyPNG
     # Returns an array with the separate RGB values for this color.
     # The alpha channel will be discarded.
     #
-    # @param [Fixnum] color The color to convert.
-    # @return [Array<Fixnum>] An array with 3 Fixnum elements.
+    # @param [Integer] color The color to convert.
+    # @return [Array<Integer>] An array with 3 Integer elements.
     def to_truecolor_bytes(color)
       [r(color), g(color), b(color)]
     end
@@ -352,8 +352,8 @@ module ChunkyPNG
     # This method expects the r,g and b value to be equal, and the alpha 
     # channel will be discarded.
     #
-    # @param [Fixnum] color The grayscale color to convert.
-    # @return [Array<Fixnum>] An array with 1 Fixnum element.
+    # @param [Integer] color The grayscale color to convert.
+    # @return [Array<Integer>] An array with 1 Integer element.
     def to_grayscale_bytes(color)
       [r(color)] # assumption r == g == b
     end
@@ -363,8 +363,8 @@ module ChunkyPNG
     #
     # This method expects the r,g and b value to be equal.
     #
-    # @param [Fixnum] color The grayscale color to convert.
-    # @return [Array<Fixnum>] An array with 2 Fixnum elements.
+    # @param [Integer] color The grayscale color to convert.
+    # @return [Array<Integer>] An array with 2 Integer elements.
     def to_grayscale_alpha_bytes(color)
       [r(color), a(color)] # assumption r == g == b
     end
@@ -387,8 +387,8 @@ module ChunkyPNG
     ####################################################################
 
     # Returns the size in bytes of a pixel when it is stored using a given color mode.
-    # @param [Fixnum] color_mode The color mode in which the pixels are stored.
-    # @return [Fixnum] The number of bytes used per pixel in a datastream.
+    # @param [Integer] color_mode The color mode in which the pixels are stored.
+    # @return [Integer] The number of bytes used per pixel in a datastream.
     def bytesize(color_mode)
       case color_mode
         when ChunkyPNG::COLOR_INDEXED         then 1

data/lib/chunky_png/palette.rb

@@ -15,7 +15,7 @@ module ChunkyPNG
 
     # Builds a new palette given a set (Enumerable instance) of colors.
     #
-    # @param [Enumerbale<CFixnum>] enum The set of colors to include in this palette.
+    # @param [Enumerbale<Integer>] enum The set of colors to include in this palette.
     #   This Enumerbale can contains duplicates.
     # @param [Array] decoding_map An array of colors in the exact order at which
     #   they appeared in the palette chunk, so that this array can be used for decoding.
@@ -64,7 +64,7 @@ module ChunkyPNG
     end
 
     # Builds a palette instance from a given set of pixels.
-    # @param [Enumerable<Fixnum>] pixels An enumeration of pixels to create a palette for
+    # @param [Enumerable<Integer>] pixels An enumeration of pixels to create a palette for
     # @return [ChunkyPNG::Palette] The palette instance.
     def self.from_pixels(pixels)
       self.new(pixels)
@@ -118,7 +118,7 @@ module ChunkyPNG
     end
 
     # Returns a color, given the position in the original palette chunk.
-    # @param [Fixnum] index The 0-based position of the color in the palette.
+    # @param [Integer] index The 0-based position of the color in the palette.
     # @return [ChunkyPNG::Color] The color that is stored in the palette under the given index
     # @see ChunkyPNG::Palette#can_decode?
     def [](index)
@@ -127,7 +127,7 @@ module ChunkyPNG
 
     # Returns the position of a color in the palette
     # @param [ChunkyPNG::Color] color The color for which to look up the index.
-    # @return [Fixnum] The 0-based position of the color in the palette.
+    # @return [Integer] The 0-based position of the color in the palette.
     # @see ChunkyPNG::Palette#can_encode?
     def index(color)
       @encoding_map[color]
@@ -166,7 +166,7 @@ module ChunkyPNG
     end
 
     # Determines the most suitable colormode for this palette.
-    # @return [Fixnum] The colormode which would create the smalles possible
+    # @return [Integer] The colormode which would create the smalles possible
     #    file for images that use this exact palette.
     def best_colormode
       if grayscale?

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: chunky_png
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 1
+  version: 0.7.1
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -9,19 +14,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 -04:00
+date: 2010-03-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
         version: 1.2.9
-    version: 
+  type: :development
+  version_requirements: *id001
 description: "    This pure Ruby library can read and write PNG images without depending on an external \n    image library, like RMagick. It tries to be memory efficient and reasonably fast.\n    \n    It supports reading and writing all PNG variants that are defined in the specification, \n    with one limitation: only 8-bit color depth is supported. It supports all transparency, \n    interlacing and filtering options the PNG specifications allows. It can also read and \n    write textual metadata from PNG files. Low-level read/write access to PNG chunks is\n    also possible.\n    \n    This library supports simple drawing on the image canvas and simple operations like alpha composition\n    and cropping. Finally, it can import from and export to RMagick for interoperability. \n"
 email: 
 - willem@railsdoctors.com
@@ -110,18 +119,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Pure ruby library for read/write, chunk-level access to PNG files