chunky_png 0.0.5 → 0.5.0

data/spec/spec_helper.rb

@@ -12,16 +12,19 @@ module ResourceFileHelper
 end
 
 
-module MatrixDisplayingHelper
-  def display(matrix)
-    image = ChunkyPNG::Image.from_pixel_matrix(matrix)
+module MatrixSpecHelper
+  def display(canvas)
     filename = resource_file('_tmp.png')
-    image.save(filename)
+    canvas.to_datastream.save(filename)
     `open #{filename}`
   end
+  
+  def reference_canvas(name)
+    ChunkyPNG::Canvas.from_file(resource_file("#{name}.png"))
+  end
 end
 
 Spec::Runner.configure do |config|
   config.include ResourceFileHelper
-  config.include MatrixDisplayingHelper
+  config.include MatrixSpecHelper
 end

data/tasks/github-gem.rake

@@ -229,7 +229,7 @@ module GithubGem
     def rubyforge_release_task
       sh 'rubyforge', 'add_release', gemspec.rubyforge_project, gemspec.name, gemspec.version.to_s, "pkg/#{gemspec.name}-#{gemspec.version}.gem"
     end
-    
+
     def gemcutter_release_task
       sh "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chunky_png
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.5.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-13 00:00:00 +01:00
+date: 2010-01-16 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.2.9
     version: 
-description: Pure ruby library for read/write, chunk-level access to PNG files
+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
 executables: []
@@ -33,39 +33,54 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - spec/spec_helper.rb
+- spec/resources/ztxt_chunk.png
+- spec/resources/text_chunk.png
+- spec/resources/replaced.png
 - spec/resources/pixelstream.rgb
 - spec/resources/gray_10x10_grayscale.png
+- spec/resources/damaged_signature.png
+- spec/resources/damaged_chunk.png
+- spec/chunky_png/canvas/png_encoding_spec.rb
 - spec/resources/gray_10x10.png
+- lib/chunky_png/color.rb
+- lib/chunky_png/canvas/operations.rb
 - .gitignore
 - spec/resources/gray_10x10_truecolor_alpha.png
-- lib/chunky_png/pixel_matrix.rb
+- spec/chunky_png/canvas_spec.rb
 - LICENSE
 - spec/resources/gray_10x10_truecolor.png
-- lib/chunky_png/pixel_matrix/decoding.rb
+- spec/resources/composited.png
+- spec/chunky_png/color_spec.rb
+- spec/chunky_png/canvas/adam7_interlacing_spec.rb
 - lib/chunky_png/chunk.rb
-- spec/unit/encoding_spec.rb
+- lib/chunky_png/canvas/png_encoding.rb
+- lib/chunky_png/canvas/adam7_interlacing.rb
 - spec/resources/operations.png
+- spec/chunky_png/canvas/png_decoding_spec.rb
+- lib/chunky_png/canvas.rb
 - Rakefile
 - spec/resources/transparent_gray_10x10.png
+- spec/resources/pixelstream.rgba
+- spec/resources/cropped.png
 - README.rdoc
 - spec/resources/gray_10x10_indexed.png
 - spec/resources/16x16_non_interlaced.png
-- spec/integration/image_spec.rb
-- lib/chunky_png/pixel_matrix/operations.rb
-- lib/chunky_png/pixel.rb
+- spec/chunky_png_spec.rb
 - lib/chunky_png/palette.rb
 - lib/chunky_png/datastream.rb
 - chunky_png.gemspec
 - tasks/github-gem.rake
-- spec/unit/decoding_spec.rb
 - spec/resources/pixelstream_reference.png
 - spec/resources/gray_10x10_grayscale_alpha.png
 - spec/resources/16x16_interlaced.png
+- spec/chunky_png/image_spec.rb
+- lib/chunky_png/canvas/drawing.rb
 - spec/resources/adam7.png
-- lib/chunky_png/pixel_matrix/encoding.rb
+- lib/chunky_png/rmagick.rb
 - lib/chunky_png/image.rb
-- spec/unit/pixel_spec.rb
-- spec/unit/pixel_matrix_spec.rb
+- spec/chunky_png/rmagick_spec.rb
+- spec/chunky_png/datastream_spec.rb
+- lib/chunky_png/canvas/png_decoding.rb
 - lib/chunky_png.rb
 has_rdoc: true
 homepage: http://wiki.github.com/wvanbergen/chunky_png
@@ -101,8 +116,12 @@ signing_key:
 specification_version: 3
 summary: Pure ruby library for read/write, chunk-level access to PNG files
 test_files: 
-- spec/unit/encoding_spec.rb
-- spec/integration/image_spec.rb
-- spec/unit/decoding_spec.rb
-- spec/unit/pixel_spec.rb
-- spec/unit/pixel_matrix_spec.rb
+- spec/chunky_png/canvas/png_encoding_spec.rb
+- spec/chunky_png/canvas_spec.rb
+- spec/chunky_png/color_spec.rb
+- spec/chunky_png/canvas/adam7_interlacing_spec.rb
+- spec/chunky_png/canvas/png_decoding_spec.rb
+- spec/chunky_png_spec.rb
+- spec/chunky_png/image_spec.rb
+- spec/chunky_png/rmagick_spec.rb
+- spec/chunky_png/datastream_spec.rb

data/lib/chunky_png/pixel.rb

@@ -1,272 +0,0 @@
-module ChunkyPNG
-
-  # The Pixel class represents a pixel, which has a single color. Within the
-  # ChunkyPNG library, the concepts of pixels and colors are both used, and
-  # they are both represented by the pixel class.
-  #
-  # Pixels/colors are represented in RGBA moduds. Each of the four components
-  # is stored with a depth of 8 biths (maximum value = 255). Together, these
-  # components are stored in a 4-bye Fixnum. 
-  class Pixel
-    
-    # @return [Fixnum] The 4-byte fixnum representation of the pixel's
-    #    color, where red compenent uses the most significant byte and the
-    #    alpha component the least significant byte.
-    attr_reader :value
-    
-    alias :to_i :value
-
-    # Initalizes a new pixel instance. Usually, it is more convenient to
-    # use one of the constructors below.
-    # @param [Fixnum] value The 4-byte fixnum representation of the pixel's
-    #    color, where red compenent uses the most significant byte and the
-    #    alpha component the least significant byte.
-    def initialize(value)
-      @value = value.to_i
-    end
-    
-    ####################################################################
-    # PIXEL LOADING
-    ####################################################################
-
-    # Creates a new pixels using an r, g, b triple.
-    # @return [ChunkyPNG::Pixel] The newly constructed pixel.
-    def self.rgb(r, g, b, a = 255)
-      rgba(r, g, b, a)
-    end
-    
-    # Creates a new pixels using an r, g, b triple and an alpha value.
-    # @return [ChunkyPNG::Pixel] The newly constructed pixel.
-    def self.rgba(r, g, b, a)
-      self.new(r << 24 | g << 16 | b << 8 | a)
-    end
-    
-    # Creates a new pixels using a grayscale teint.
-    # @return [ChunkyPNG::Pixel] The newly constructed pixel.
-    def self.grayscale(teint, a = 255)
-      rgba(teint, teint, teint, a)
-    end
-
-    # Creates a new pixels using a grayscale teint and alpha value.
-    # @return [ChunkyPNG::Pixel] The newly constructed pixel.
-    def self.grayscale_alpha(teint, a)
-      rgba(teint, teint, teint, a)
-    end
-    
-    # Creates a pixel by unpacking an rgb triple from a string
-    # @return [ChunkyPNG::Pixel] The newly constructed pixel.
-    def self.from_rgb_stream(stream)
-      self.rgb(*stream.unpack('C3'))
-    end
-
-    # Creates a pixel by unpacking an rgba triple from a string
-    # @return [ChunkyPNG::Pixel] The newly constructed pixel.
-    def self.from_rgba_stream(stream)
-      self.rgba(*stream.unpack('C4'))
-    end
-    
-    ####################################################################
-    # COLOR CONSTANTS
-    ####################################################################
-    
-    BLACK = rgb(  0,   0,   0)
-    WHITE = rgb(255, 255, 255)
-    
-    TRANSPARENT = rgba(0, 0, 0, 0)
-    
-    ####################################################################
-    # PROPERTIES
-    ####################################################################
-    
-    # Returns the red-component from the pixel value
-    # @return [Fixnum] A value between 0 and 255
-    def r
-      (@value & 0xff000000) >> 24
-    end
-
-    # Returns the green-component from the pixel value
-    # @return [Fixnum] A value between 0 and 255
-    def g
-      (@value & 0x00ff0000) >> 16
-    end
-
-    # Returns the blue-component from the pixel value
-    # @return [Fixnum] A value between 0 and 255
-    def b
-      (@value & 0x0000ff00) >> 8
-    end
-
-    # Returns the alpha channel value for the pixel
-    # @return [Fixnum] A value between 0 and 255
-    def a
-      @value & 0x000000ff
-    end
-    
-    # Returns true if this pixel is fully opaque
-    # @return [true, false] True if the alpha channel equals 255
-    def opaque?
-      a == 0x000000ff
-    end
-    
-    # Returns true if this pixel is fully transparent
-    # @return [true, false] True if the alpha channel equals 0
-    def fully_transparent?
-      a == 0x000000ff
-    end
-    
-    # Returns true if this pixel is fully transparent
-    # @return [true, false] True if the r, g and b component are equal
-    def grayscale?
-      r == g && r == b
-    end
-    
-    ####################################################################
-    # COMPARISON
-    ####################################################################
-    
-    # Returns a nice string representation for this pixel using hex notation
-    # @return [String]
-    def inspect
-      '#%08x' % @value
-    end
-    
-    # Returns a hash for determining the uniqueness of a pixel
-    # @return [Fixnum] The hash of the fixnum that is representing this pixel.
-    def hash
-      @value.hash
-    end
-
-    # Checks whether to pixels are the same (i.e. have the same color)
-    # @param [Object] The object to compare this pixel with
-    # @return [true, false] Returns true iff th pixels' fixnum representations is the same
-    def eql?(other)
-      other.kind_of?(self.class) && other.value == self.value
-    end
-    
-    alias :== :eql?
-    
-    # Compares to pixels for ordering, using the pixel's fixnum representation.
-    # @param [Object] The object to compare this pixel with.
-    # @return [Fixnum] A number used for sorting.
-    def <=>(other)
-      other.value <=> self.value
-    end
-    
-    ####################################################################
-    # CONVERSIONS
-    ####################################################################
-    
-    def to_truecolor_alpha_bytes
-      [r,g,b,a]
-    end
-
-    def to_truecolor_bytes
-      [r,g,b]
-    end
-    
-    def to_indexed_bytes(palette)
-      [index(palette)]
-    end
-    
-    def to_grayscale_bytes
-      [r] # Assumption: r == g == b
-    end
-
-    def to_grayscale_alpha_bytes
-      [r, a] # Assumption: r == g == b
-    end
-    
-    ####################################################################
-    # ALPHA COMPOSITION
-    ####################################################################
-    
-    # Multiplies two fractions using integer math, where the fractions are stored using an
-    # integer between 0 and 255. This method is used as a helper method for compositing
-    # pixels when using integer math.
-    #
-    # @param [Fixnum] a The first fraction.
-    # @param [Fixnum] b The second fraction.
-    # @return [Fixnum] The result of the multiplication.
-    def int8_mult(a, b)
-      t = a * b + 0x80
-      ((t >> 8) + t) >> 8
-    end
-
-    # Composes two pixels with an alpha channel using integer math.
-    #
-    # The pixel instance is used as background color, the pixel provided as +other+
-    # parameter is used as foreground pixel in the composition formula.
-    #
-    # This version is faster than the version based on floating point math, so this
-    # compositing function is used by default.
-    #
-    # @param [ChunkyPNG::Pixel] other The foreground pixel to compose with
-    # @return [ChunkyPNG::Pixel] The composited pixel
-    # @see ChunkyPNG::Pixel#compose_precise
-    def compose_quick(other)
-      if other.a    == 0xff
-        other
-      elsif other.a == 0x00
-        self
-      else
-        a_com = int8_mult(0xff - other.a, a)
-        new_r = int8_mult(other.a, other.r) + int8_mult(a_com, r)
-        new_g = int8_mult(other.a, other.g) + int8_mult(a_com, g)
-        new_b = int8_mult(other.a, other.b) + int8_mult(a_com, b)
-        new_a = other.a + a_com
-        ChunkyPNG::Pixel.rgba(new_r, new_g, new_b, new_a)
-      end
-    end
-
-    # Composes two pixels with an alpha channel using floating point math.
-    #
-    # The pixel instance is used as background color, the pixel provided as +other+
-    # parameter is used as foreground pixel in the composition formula.
-    #
-    # This method uses more precise floating point math, but this precision is lost
-    # 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 [ChunkyPNG::Pixel] other The foreground pixel to compose with
-    # @return [ChunkyPNG::Pixel] The composited pixel
-    # @see ChunkyPNG::Pixel#compose_quick
-    def compose_precise(other)
-      if other.a == 255
-        other
-      elsif other.a == 0
-        self
-      else
-        alpha       = other.a / 255.0
-        other_alpha = a / 255.0
-        alpha_com   = (1.0 - alpha) * other_alpha
-
-        new_r = (alpha * other.r + alpha_com * r).round
-        new_g = (alpha * other.g + alpha_com * g).round
-        new_b = (alpha * other.b + alpha_com * b).round
-        new_a = ((alpha + alpha_com) * 255).round
-        ChunkyPNG::Pixel.rgba(new_r, new_g, new_b, new_a)
-      end
-    end
-    
-    alias :compose :compose_quick
-    alias :& :compose
-    
-    ####################################################################
-    # STATIC UTILITY METHODS
-    ####################################################################
-    
-    # Returns the size in bytes of a pixel whe 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.
-    def self.bytesize(color_mode)
-      case color_mode
-        when ChunkyPNG::COLOR_INDEXED         then 1
-        when ChunkyPNG::COLOR_TRUECOLOR       then 3
-        when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then 4
-        when ChunkyPNG::COLOR_GRAYSCALE       then 1
-        when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then 2
-        else raise "Don't know the bytesize of pixels in this colormode: #{color_mode}!"
-      end
-    end
-  end
-end

data/lib/chunky_png/pixel_matrix.rb

@@ -1,136 +0,0 @@
-module ChunkyPNG
-  
-  # The ChunkPNG::PixelMatrix class represents a matrix of pixels of which an
-  # image consists. This class supports loading a PixelMatrix from a PNG datastream,
-  # and creating a PNG datastream bse don this matrix.
-  #
-  # This class offers per-pixel access to the matrix by using x,y coordinates. It uses
-  # a palette (see {ChunkyPNG::Palette}) to keep track of the different colors used in
-  # this matrix.
-  #
-  # The pixels in the matrix are stored as 4-byte fixnums. When accessing these pixels,
-  # these Fixnums are wrapped in a {ChunkyPNG::Pixel} instance to simplify working with them.
-  #
-  # @see ChunkyPNG::Datastream
-  class PixelMatrix
-    
-    include Encoding
-    extend  Decoding
-    
-    include Operations
-    
-    # @return [Integer] The number of columns in this pixel matrix
-    attr_reader :width
-
-    # @return [Integer] The number of rows in this pixel matrix
-    attr_reader :height
-
-    # @return [Array<ChunkyPNG::Pixel>] The list of pixels in this matrix.
-    #     This array always should have +width * height+ elements.
-    attr_reader :pixels
-
-    # Initializes a new PixelMatrix instance
-    # @param [Integer] width The width in pixels of this matrix
-    # @param [Integer] width The height in pixels of this matrix
-    # @param [ChunkyPNG::Pixel, Array<ChunkyPNG::Pixel>] initial The initial value of te pixels:
-    #
-    #    * If a color is passed to this parameter, this color will be used as background color. 
-    #
-    #    * If an array of pixels is provided, these pixels will be used as initial value. Note 
-    #      that the amount of pixels in this array should equal +width * height+.
-    def initialize(width, height, initial = ChunkyPNG::Pixel::TRANSPARENT)
-      
-      @width, @height = width, height
-      
-      if initial.kind_of?(ChunkyPNG::Pixel)
-        @pixels = Array.new(width * height, initial.to_i)
-      elsif initial.kind_of?(Array) && initial.size == width * height
-        @pixels = initial.map(&:to_i)
-      else 
-        raise "Cannot use this value as initial pixel matrix: #{initial.inspect}!"
-      end
-    end
-    
-    # Returns the size ([width, height]) for this matrix.
-    # @return Array An array with the width and height of this matrix as elements.
-    def size
-      [@width, @height]
-    end
-    
-    # Replaces a single pixel in this matrix.
-    # @param [Integer] x The x-coordinate of the pixel (column)
-    # @param [Integer] y The y-coordinate of the pixel (row)
-    # @param [ChunkyPNG::Pixel] pixel The new pixel for the provided coordinates.
-    def []=(x, y, pixel)
-      @pixels[y * width + x] = pixel.to_i
-    end
-    
-    # Returns a single pixel from this matrix.
-    # @param [Integer] x The x-coordinate of the pixel (column)
-    # @param [Integer] y The y-coordinate of the pixel (row)
-    # @return [ChunkyPNG::Pixel] The current pixel at the provided coordinates.
-    def [](x, y)
-      ChunkyPNG::Pixel.new(@pixels[y * width + x])
-    end
-    
-    # Passes to this matrix of pixels line by line.
-    # @yield [Array<ChunkyPNG::Pixel>] An line of pixels
-    def each_scanline(&block)
-      height.times do |i|
-        scanline = @pixels[width * i, width].map { |fn| ChunkyPNG::Pixel.new(fn) }
-        yield(scanline)
-      end
-    end
-    
-    # Returns the palette used for this pixel matrix.
-    # @return [ChunkyPNG::Palette] A pallete which contains all the colors that are 
-    #    being used for this image.
-    def palette
-      ChunkyPNG::Palette.from_pixel_matrix(self)
-    end
-    
-    # Converts this PixelMatrix to a datastream, so that it can be saved as a PNG image.
-    # @param [Hash] constraints The constraints to use when encoding the matrix.
-    def to_datastream(constraints = {})
-      data = encode(constraints)
-      ds = Datastream.new
-      ds.header_chunk       = Chunk::Header.new(data[:header])
-      ds.palette_chunk      = data[:palette_chunk]      if data[:palette_chunk]
-      ds.transparency_chunk = data[:transparency_chunk] if data[:transparency_chunk]
-      ds.data_chunks        = ds.idat_chunks(data[:pixelstream])
-      ds.end_chunk          = Chunk::End.new
-      return ds
-    end
-    
-    # Equality check to compare this pixel matrix 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 matrix
-    #    are exactly the same as this matrix size and pixel values.
-    def eql?(other)
-      other.kind_of?(self.class) && other.pixels == self.pixels &&
-            other.width == self.width && other.height == self.height
-    end
-    
-    alias :== :eql?
-    
-    #################################################################
-    # CONSTRUCTORS
-    #################################################################
-
-    def self.from_rgb_stream(width, height, stream)
-      pixels = []
-      while pixeldata = stream.read(3)
-        pixels << ChunkyPNG::Pixel.from_rgb_stream(pixeldata)
-      end
-      self.new(width, height, pixels)
-    end
-
-    def self.from_rgba_stream(width, height, stream)
-      pixels = []
-      while pixeldata = stream.read(4)
-        pixels << ChunkyPNG::Pixel.from_rgba_stream(pixeldata)
-      end
-      self.new(width, height, pixels)
-    end
-  end
-end