pruim 0.1.0

data/README

@@ -0,0 +1,44 @@
++------------------------------------+
+| Pruim -- a Pure RUby IMage library |
++------------------------------------+
+
+Introduction
+------------
+
+Pruim is a Pure RUby IMage library, with the indent of supporting 
+multiple image formats. Currently only supports loading from and 
+saving to PPM files and paletted BMP files. Contributions of 
+other formats are welcome. :)
+
+Requirements
+------------
+
+BinData (gem install bindata) is required. It makes decoding images much easier.
+Watch and autowatchr for testing.
+Run watchr test/test.watchr to run the tests.
+
+ 
+License
+-------
+
+You may use Pruim under the Zlib license: 
+
+Pruim is Copyright (C) 2011 Beoran beoran@rubyforge.org
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rake/clean'
+CLEAN.include("pkg/*.gem")
+
+
+PRUIM_VERSION = "0.1.0"
+
+def apply_spec_defaults(s)
+end
+
+
+ spec = Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Pure Ruby Image Library."
+  s.name        = 'pruim'
+  s.version     = '0.1.0'
+  s.add_dependency('bindata', '>= 1.0.0')
+  s.add_development_dependency('atto', '>= 0.9.2')
+  s.require_path = 'lib'
+  s.files        = ['README', 'Rakefile'] +
+                   FileList["lib/pruim.rb", "lib/pruim/*.rb",
+                   "test/*.rb"  , "test/pruim/*.rb" ].to_a
+  s.description = <<EOF
+  Pruim is a Pure Ruby Image Library. Currently only supports BMP, PPM and PBM
+  formats, but preserves palette ordering on reading and writing.
+EOF
+  s.author      = 'beoran'
+  s.email       = 'beoran@rubyforge.org'
+  s.homepage    = 'http://github.com/beoran/pruim'
+  s.date        = Time.now.strftime '%Y-%m-%d'
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+        pkg.need_zip = false
+        pkg.need_tar = false
+end
+
+
+task :test do
+  for file in FileList["test/*.rb"  , "test/pruim/*.rb" ] do
+    puts("Running tests for #{file}:")
+    res = system("ruby -I lib #{file}")
+    puts res ? "OK!" : "Failed!"
+  end
+end
+
+task :default => :test
+

data/lib/pruim/bmp.rb

@@ -0,0 +1,238 @@
+require 'bindata'
+
+module Pruim
+  class BMP
+    include Codec
+    
+    class Header < BinData::Record
+      endian :little
+      string :magic, :length => 2
+      uint32 :filesize
+      uint16 :creator1
+      uint16 :creator2
+      uint32 :bitmap_offset
+      def set(*args)
+        self.magic, self.filesize, self.creator1, self.creator2, 
+        self.bitmap_offset = *args
+        self
+      end
+    end
+
+    class CoreHeader < BinData::Record
+      endian :little
+      uint32 :header_size
+      int32  :width
+      int32  :height
+      uint16 :nplanes
+      uint16 :bitspp
+      def set(*args)
+        self.header_size, self.width, self.height, self.nplanes, 
+        self.bitspp = *args
+        self
+      end
+    end
+
+    class ExtraHeader < BinData::Record
+      endian :little
+#       uint32 :header_size
+#       int32  :width
+#       int32  :height
+#       uint16 :nplanes
+#       uint16 :bitspp
+      uint32 :compress_type
+      uint32 :bmp_bytesz
+      int32  :hres
+      int32  :vres
+      uint32 :ncolors
+      uint32 :nimpcolors
+      
+      def set(*args) 
+        self.compress_type, self.bmp_bytesz, self.hres, self.vres, self.ncolors,
+        self.nimpcolors  = *args
+        self
+      end
+    end
+
+    BI_RGB   = 0        # 
+    BI_RLE8  = 1        # RLE 8-bit/pixel   Can be used only with 8-bit/pixel bitmaps
+    BI_RLE4  = 2        # RLE 4-bit/pixel   Can be used only with 4-bit/pixel bitmaps
+    BI_BITFIELDS  = 3   # Bit field or Huffman 1D compression for BITMAPCOREHEADER2   
+    BI_JPEG       = 4   # JPEG or RLE-24 compression for BITMAPCOREHEADER2  
+    BI_PNG        = 5   # PNG  The bitmap contains a PNG image.
+    BITMAPINFOHEADER=40 # Commonly used
+    BITMAPV5HEADER  =124# Latest version
+    HEADER_SIZE     = 14
+    
+          
+    class BGRX < BinData::Record
+      uint8 :b
+      uint8 :g
+      uint8 :r
+      uint8 :x
+      def set(b, g, r, x)
+        self.b = b
+        self.g = g
+        self.r = r
+        self.x = x
+        self
+      end
+    end
+    
+    class BGR < BinData::Record
+      uint8 :b
+      uint8 :g
+      uint8 :r
+      
+      def set(b, g, r)        
+        self.b = b
+        self.g = g
+        self.r = r
+        self
+      end
+    end
+    
+    class ColorTableRGBX < BinData::Record
+      array :type => BGRX
+    end
+      
+    def can_decode?(io)
+      header = Header.read(io)
+      io.rewind
+      return header && header.magic == 'BM'
+    end
+    
+    
+    def read_palette(io, header, core, extra)
+      palette = Pruim::Palette.new
+      ncolors = 2 ** core.bitspp
+      for i in 0..255
+        color = BGRX.read(io)
+        palette.new_rgb(color.r, color.g, color.b)
+        raise "Unexpected end of file whilst reading bmp palette!" if io.eof?
+      end
+      return palette
+    end
+    
+    
+    def decode_bpp8_rgb(io, header, core, extra, padding)
+      data = []
+      for ypos in (0...core.height) 
+        size = core.width + padding
+        # read a line with padding
+        raise "End of file when reading BMP btyes!" if io.eof?
+        str  = io.read(size)
+        raise "Short read when reading BMP bytes!" unless str && str.bytesize == size
+        # make an array out of it and drop the padding
+        arr  = str.bytes.to_a
+        arr.pop(padding)
+        data = arr + data # prepend data
+      end      
+      return data
+    end
+    
+    # Calculate padding size
+    def calc_padding(wide, palette = true)
+      bs      = palette ? 1 : 3
+      padding = (1 * bs * wide) % 4;
+      padding = 4 - padding if padding != 0
+      return padding
+    end
+
+    
+    def decode_bpp8(io, header, core, extra)
+      # p header, core, extra
+      io.seek(HEADER_SIZE + core.header_size)      
+      palette = read_palette(io, header, core, extra)
+      # Skip to the bitmap, gap may be there...
+      io.seek(header.bitmap_offset)
+      # Calculate padding size
+      padding = calc_padding(core.width, true)
+      data    = nil
+      case extra.compress_type
+        when BI_RGB
+          data = decode_bpp8_rgb(io, header, core, extra, padding)
+        else
+          return nil
+      end
+      image   = Image.new(core.width, core.height, :depth => core.bitspp, 
+                        :palette => palette, :pages => 1, :data => [data])
+      return image
+    end
+    
+    def decode(io)
+      header = Header.read(io)
+      core   = CoreHeader.read(io)
+      extra  = nil
+      if (core.header_size == BITMAPINFOHEADER)
+        extra = ExtraHeader.read(io)
+      end
+      io.seek(HEADER_SIZE + core.header_size)
+      # skip rest of header that we don't support
+      if core.bitspp == 8
+        return decode_bpp8(io, header, core, extra)
+      end
+      # TODO: real color bitmaps.
+      return nil
+    end
+    
+    def encode_palette(image, io)
+      image.palette.each do |color|
+        r, g, b = *Color.to_rgb(color)
+        bgrx    = BGRX.new.set(b, g, r, 0)
+        bgrx.write(io)
+      end
+    end
+    
+    def encode_bpp8_rgb(image, io, padding)
+      page = image.active
+      ypos = image.h - 1
+      while ypos >= 0
+        row   = page.row(ypos)
+        row   = row + [0] * padding
+        str   = row.pack('C*')
+        io.write(str)
+        ypos -= 1
+      end
+    end
+    
+    
+    def encode_bpp8(image, io, padding)
+      encode_palette(image, io)
+      encode_bpp8_rgb(image, io, padding)
+    end
+    
+    def encode_bpp24(image, io, padding)
+    end
+    
+    def encode(image, io)
+      bitcount    = (image.palette? ? 8 : 24)
+      bitmap_size = ((image.w * bitcount) / 8) * image.h
+      info_size   = BITMAPINFOHEADER
+      # Data for the palette
+      if image.palette?
+        info_size += image.palette.size * 4
+      end
+      total_size = 14 + info_size + bitmap_size
+      # write bmp header info 
+      header = Header.new.set('BM', total_size, 0, 0, 14 + info_size)
+      header.write(io)
+      core   = CoreHeader.new.set(BITMAPINFOHEADER, image.w, image.h, 1, bitcount)
+      core.write(io)
+      extra  = ExtraHeader.new.set(BI_RGB, 0, 0, bitcount, image.palette.size, 0)
+      extra.write(io)
+      # Calculate padding size
+      padding = calc_padding(image.active.w, image.palette?)
+      if image.palette?
+        encode_bpp8(image, io, padding)
+      else
+        encode_bpp24(image, io, padding)
+      end
+      return image
+    end
+    
+    
+    
+  end
+end  
+
+

data/lib/pruim/codec.rb

@@ -0,0 +1,74 @@
+module Pruim
+  module Codec
+    
+    def self.register(name, klass)
+      @codecs     ||= {} 
+      @codecs[name] = klass
+    end
+    
+    # Returns a codec based on it's short name.
+    def self.for_name(name)
+      return Pruim.const_get(name.upcase) 
+    end
+    
+    # Returns the codec to use for the given filename, based on the extension
+    def self.for_filename(filename)
+      ext = File.extname(flename) # get filename extension
+      return self.codec_for(name)
+    end
+    
+    # Returns an instance of codec to use for the given filename, based on the 
+    # extension of the filename.
+    def self.new_for_filename(filename)
+      codec = for_filename(filename)
+      return codec.new()
+    end
+    
+    # Returns a new instance of a codec based on it's short name.
+    def self.new_for_name(name)
+      codec = for_name(name)
+      return nil unless codec
+      return codec.new()
+    end
+    
+    # Returns a codec based on it's short name or on the filename's extension.
+    def self.for_filename_name(filename, codecname = nil)
+      codec = nil      
+      return for_name(codecname) if codecname
+      return for_filename(codecname)
+    end
+    
+    # Returns a new instance of a codec based on it's short name or on 
+    # the filename's extension.
+    def self.new_for_filename_name(filename, codecname = nil)
+      codec = for_filename_name(filename, codecname)
+      return nil unless codec
+      return codec.new()
+    end
+  
+    # Stream should be an StringIO, or otherwise IO compatible object.
+    def decode(io)
+      raise "not implemented"
+    end
+    
+    def encode(image, io)
+      raise "not implemented"
+    end
+    
+    def can_decode?(io)
+      raise "not implemented"
+    end
+    
+    def can_encode?(image)
+      raise "not implemented"
+    end
+    
+    def encode_will_degrade?(image)
+      raise "not implemented"
+    end
+    
+    def text
+      return "A codec that does nothing."
+    end
+  end
+end

data/lib/pruim/color.rb

@@ -0,0 +1,34 @@
+module Pruim
+  class Color
+    def self.rgba(r, g, b, a)
+      (a | (b << 8) | (g << 16) | (r << 24))
+    end
+    
+    def self.rgb(r, g, b)
+      return rgba(r, g, b, 255)
+    end
+
+    # Cpolors are encoded in abgr
+    def self.to_rgba(color)
+      a = (color)       & 255
+      b = (color >> 8)  & 255
+      g = (color >> 16) & 255
+      r = (color >> 24) & 255
+      return r, g, b, a
+    end
+    
+    def self.to_rgb(color)
+      r, g, b, a = to_rgba(color)
+      return r, g, b
+    end
+    
+    BRIGHT_TRESHOLD = 382
+
+    # Returns true if the color is bright (above threshold)
+    # And false if black. Transparency is takeninto account as well.
+    def to_bool(treshold = BRIGHT_TRESHOLD)
+      
+    end
+    
+  end
+end  

data/lib/pruim/image.rb

@@ -0,0 +1,160 @@
+module Pruim
+  # An image consists of one or more pages.
+  # Whether a page is a layer, a frame in an animation
+  # or both, is determined by the properties of the page. 
+    
+  class Image
+    
+    attr_reader :w
+    attr_reader :h
+    attr_reader :palette
+    attr_reader :pages
+    # Currently "active" page.
+    attr_reader :active
+    # image mode, may be one of :monochrome, :palette, :grayscale, :rgba
+    attr_reader :mode
+    # Color depth, may be one of 1, 2, 4, 8, 16, 24, 32
+    attr_reader :depth
+    
+    # Extra information data hash table.
+    attr_reader :info
+    
+    def self.depth_for_colors(ncolors)
+      (Math.log(ncolors) / Math.log(2)).to_i
+    end
+
+    # Sets the comment for this image
+    def comment=(comm)
+      @info[:comment] = comm
+    end
+    
+    # gets the comment for this image
+    def comment
+      @info[:comment]
+    end
+    
+    def initialize(w, h, extra = {})
+      @w        = w
+      @h        = h
+      @info     = {}
+      @palette  = extra[:palette]
+      @mode     = extra[:mode]      
+      @mode   ||= (@palette ? :palette : :rgba)
+      @palette  = Palette.new if !@palette && @mode == :palette
+      @depth    = extra[:depth]
+      @depth  ||= (@palette ? 8 : 32)
+      @pages    = [] 
+      @ordered  = {} 
+      @active   = nil
+      # Construct many pages.
+      if extra[:pages]
+        data = extra[:data] || []
+        extra[:pages].times { |i| self.new_page(@w, @h, :data => data[i]) }
+      # Construct a single page if data is given nevertheless
+      elsif extra[:data]
+        self.new_page(@w, @h, :data => extra[:data])
+      end
+      # Set comments if any
+      self.comment = extra[:comment]
+    end
+    
+    def palette?
+      return !(@palette.nil?)
+    end      
+    
+    # Sets the page with the given index as active if it exists.
+    def activate(index)
+      @active = @pages[index]
+    end
+    
+    # Create a new a page and adds it to this image.
+    # The page is also set as the active page.
+    def new_page(w = nil, h = nil, extra = {})
+      w       ||= self.w
+      h       ||= self.h
+      page      = Page.new(self, w, h, extra)
+      return self.add_page(page)
+    end
+    
+    # Adds a page to this image. The page is also set as the active page. 
+    def add_page(page)
+      @pages << page
+      @ordered[page.frame]             = {} unless @ordered[page.frame]
+      @ordered[page.frame][page.layer] = [] unless @ordered[page.frame][page.layer] 
+      @ordered[page.frame][page.layer] << page
+      @active = page
+      return page
+    end
+    
+    # Returns an array of all pages at the given frame and layer 
+    def pages_at(frame = 0, layer = 0)
+      @ordered[frame, layer]
+    end
+    
+    # Gets a pixel from the current active page, if any.
+    def getpixel(x, y)
+      @active.getpixel!(x, y)
+    end
+    
+    # Sets a pixel to the current active page, if any.
+    def putpixel(x, y, color)
+      @active.putpixel!(x, y, color)
+    end
+
+    # Fills the current active page, if any.
+    def fill(color)
+      @active.fill(color)
+    end
+    
+    # Saves the image to the given filename using the given codec 
+    # If codec is missig, it's determined from the filename's extension.
+    def save_as(filename, codecname = nil)
+      codec = Codec.new_for_filename_name(filename, codecname)
+      return false unless codec
+      io    = File.open(filename, 'wb+')
+      res   = codec.encode(self, io)
+      io.close
+      return res
+    end
+    
+    # Loads the image from the given filename using the given codec 
+    # If codec is missig, it's determined from the filename's extension.
+    def self.load_from(filename, codecname = nil)
+      codec = Codec.new_for_filename_name(filename, codecname)
+      return false unless codec
+      io    = File.open(filename, 'rb+')
+      res   = nil
+      if codec.can_decode?(io)
+        res   = codec.decode(io)
+      else
+        raise "Malformed file #{filename} cannot be decoded as a #{codec} file."
+      end
+      io.close
+      return res
+    end
+
+    # Creates a new rgb color for use with this image.
+    # If the image is palleted, the color is added to the palette and the index
+    # is returned, otherwise the color is returned
+    def new_rgb(r, g, b)
+      if palette?
+        return @palette.new_rgb
+      else
+        return Color.rgb(r, g, b)
+      end     
+    end
+
+    # Creates a new rgba color for use with this image.
+    # If the image is palleted, the color is added to the palette and the index
+    # is returned, otherwise the color is returned
+    def new_rgba(r, g, b, a)
+      if palette?
+        return @palette.new_rgba
+      else
+        return Color.rgba(r, g, b, a)
+      end
+    end
+
+     
+  end
+end

data/lib/pruim/movie.rb

@@ -0,0 +1,15 @@
+ module Pruim
+  class Movie
+    attr_reader :w
+    attr_reader :h
+    attr_reader :frames
+
+    def initialize(w, h, index = 0, nframes = 1, nlayers = 1, data = nil)
+      @w      = w
+      @h      = h
+      @frames = Array.new(nframes) do | index |
+        Movie.new(self, w, h, index, nlayers, data)
+      end 
+    end
+  end
+end

data/lib/pruim/page.rb

@@ -0,0 +1,82 @@
+ module Pruim
+  # A Page can represents both a layer and a frame of animation, for 
+  # multi-page image formats.
+  # Inside a Page, bitmap data is stored in an array as follows:
+  # For a monochrome image, true and false are stored, where true is "black"
+  # meaning pixel activated, on, say, an LCD screen, and false means white
+  # or pixel not activated.
+  # For :palette mode images, what is stored are palette indexes.
+  # for an RBGA , integers are stored that encode the color in an 8888 bits
+  # ABGR way
+  class Page
+    attr_reader :image
+    attr_reader :w
+    attr_reader :h
+    attr_reader :layer
+    attr_reader :frame
+    attr_reader :x
+    attr_reader :y
+ 
+    # Extra information data hash table.
+    attr_reader :info
+    
+    # Returns a row of pixels with the given y coordinates as an array
+    def row(y)
+      return @data.slice(y * self.w, self.w)
+    end
+    
+    
+    def pixels
+      return @data
+    end
+
+    def initialize(image, w, h, extra = {})
+      @image  = image
+      @info   = {}
+      @w      = w
+      @h      = h
+      @frame  = extra[:frame] || 0
+      @layer  = extra[:layer] || 0
+      @x      = extra[:x] || 0
+      @y      = extra[:y] || 0
+      @data   = extra[:data]
+      if !@data
+        @data = Array.new(@h * @w, 0)
+      end
+    end
+
+    # Returns true if the coordinates are outside of the limits of this page.
+    def outside?(x, y)
+      return true   if (x  < 0 ) || (y  < 0 ) 
+      return true   if (x >= @w) || (y >= @h)
+      return false
+    end
+
+    # Gets the pixel at coordinates x,y.  Returns nil if out of bounds. 
+    def getpixel!(x, y)
+      @data[y * @w + x]
+    end
+
+    # Gets the pixel at coordinates x,y. Returns nil if out of bounds. 
+    def getpixel(x, y)      
+      return getpixel!(x, y)    
+    end    
+    
+    def putpixel!(x, y, color)
+      @data[y * @w + x] = color
+    end
+    
+    def putpixel(x, y, color)
+      return nil if outside?(x, y)
+      putpixel!(x, y, color)
+    end
+    
+    def fill(color)
+      for i in (0..(@h*@w))
+        @data[i] = color
+      end
+    end
+    
+    
+  end
+end

data/lib/pruim/palette.rb

@@ -0,0 +1,17 @@
+module Pruim
+  class Palette < Array
+
+    # Adds a new RGB color to this palette. Returns the palette index.
+    def new_rgb(r, g, b)
+      self << Pruim::Color.rgb(r, g, b)
+      return self.size - 1
+    end
+
+    # Adds a new RGBA color to this palette. Returns the palette index.
+    def new_rgba(r, g, b, a)
+      self << Pruim::Color.rgba(r, g, b, a)
+      return self.size - 1
+    end    
+    
+  end
+end

data/lib/pruim/pbm.rb

@@ -0,0 +1,70 @@
+# Tiny PBM parser, only works for 2 color (monochrome) pbm's
+# 
+module Pruim
+  # Tiny PBM parser integrated with Prium codecs.
+  class PBM
+    include Codec
+    Codec.register('pbm', self)
+    
+    # Read in a pbm file from an io object.
+    def decode(stream)
+      header    = stream.gets
+      lines     = []
+      until stream.eof?
+        lines << stream.gets
+      end
+      data      = []
+      image   = nil
+      page    = nil
+      w, h    = nil, nil
+      y       = 0
+      comment = ''
+      lines.each do |line|
+        if line[0] == '#'
+          comment << line.chomp.sub(/\A#/, '')
+          next
+        end
+        if !w
+          w , h = line.chomp.split(' ').map { |v| v.to_i }
+          next
+        end
+        # Converts 1 to true, rest to false.
+        bits = line.chomp.split('').map { |v| (v == '1') }
+        data += bits
+      end
+      image = Image.new(w, h, :mode => :monochrome, :data => data)
+      image.comment = comment
+      return image
+    end
+
+    def encode(image, stream)
+      stream.puts("P1")
+      stream.puts("##{image.comment}") if image.comment
+      stream.puts("#{image.w} #{image.h}")
+      page = image.pages.first
+      for y in (0...page.h) do
+        for x in (0...page.w) do
+          white   = page.getpixel!(x, y)
+          stream.write(white ? '1' : '0')
+        end
+        stream.puts()
+      end
+    end
+
+    def can_decode?(stream)
+      header = stream.gets
+      stream.rewind
+      return header == "P1\n"
+    end
+    
+    # Can only encode monocrome images.
+    def can_encode?(image)      
+      return image.mode == :monochrome
+    end
+
+    # Will only save first page of image.
+    def encode_will_degrade?(image)
+      return (image.pages.size > 1)
+    end
+  end # class PBM
+end # module Pruim

data/lib/pruim/ppm.rb

@@ -0,0 +1,76 @@
+module Pruim
+  class PPM 
+    include Codec
+    Codec.register('ppm', self) 
+    
+    def decode(stream)
+      header = stream.gets
+      lines  = []
+      until stream.eof?
+        lines << stream.gets
+      end
+      image   = nil
+      page    = nil
+      w, h, d = nil, nil
+      y       = 0
+      comment = ''
+      lines.each do |line| 
+        if line[0] == '#'
+          comment << line.chomp.sub(/\A#/, '') 
+          next
+        end
+        if !image
+          w , h = line.chomp.split(' ').map { |v| v.to_i }
+          image = Image.new(w, h)
+          page  = image.new_page(w, h)
+          next
+        end
+        if !d
+          d = line.chomp.to_i
+          next
+        end
+        triplets = line.chomp.split(' ').map { |v| v.to_i }
+        for x in (0...page.w) do
+          r, g, b = triplets.shift(3)
+          color   = Color.rgb(r, g, b)
+          page.putpixel(x, y, color)
+        end
+        y += 1 
+      end
+      image.comment = comment
+      return image
+    end
+    
+    
+    def encode(image, stream)
+      stream.puts("P3")
+      stream.puts("##{image.comment}") if image.comment
+      stream.puts("#{image.w} #{image.h}")
+      stream.puts("255")
+      page = image.pages.first
+      for y in (0...page.h) do
+        for x in (0...page.w) do
+          color = page.getpixel!(x, y)
+          r, g, b = Color.to_rgb(color)
+          stream.write(" ") if x > 0
+          stream.write("#{r} #{g} #{b}")
+        end
+        stream.write("\n")
+      end
+    end
+    
+    def can_decode?(stream)
+      header = stream.gets
+      stream.rewind
+      return header == "P3\n"
+    end
+    
+    def can_encode?(image)
+      return true
+    end
+    
+    def encode_will_degrade?(image)
+      return (image.pages.size > 1)
+    end
+  end
+end

data/lib/pruim.rb

@@ -0,0 +1,10 @@
+module Pruim
+  autoload :Color   , 'pruim/color'
+  autoload :Codec   , 'pruim/codec'
+  autoload :Palette , 'pruim/palette'
+  autoload :Image   , 'pruim/image'
+  autoload :Page    , 'pruim/page'
+  autoload :PBM     , 'pruim/pbm'
+  autoload :PPM     , 'pruim/ppm'  
+  autoload :BMP     , 'pruim/bmp'
+end

data/test/atto.rb

@@ -0,0 +1,9 @@
+# Atto is a tiny KISS library full of useful functionality for TDD and BDD. 
+module Atto
+  # Ansi colors for red/green display after testing.
+  autoload :Ansi, 'atto/ansi'
+  # TDD
+  autoload :Test, 'atto/test'
+  # BDD
+  autoload :Spec, 'atto/spec'
+end 

data/test/pruim/test_bmp.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+require 'pruim'
+
+test_w, test_h = 64, 32
+bitmap1_w, bitmap1_h = 64, 64
+
+assert { Pruim }
+assert { Pruim::BMP } 
+inname  = test_file('data', 'bitmap1.bmp')
+inname2 = test_file('data', 'bitmap_alpha.bmp')
+outname = test_file('data', 'out1.bmp')
+outname2= test_file('data', 'out2.bmp')
+
+codec   = Pruim::Codec.for_name('bmp')
+assert { codec } 
+
+image = Pruim::Image.load_from(inname, :bmp)
+
+# 
+# fin    = File.open(inname, 'r+')
+# assert { codec.can_decode?(fin) }
+# image  = nil
+# assert { image = codec.decode(fin) }
+# fin.close
+assert { image.w == bitmap1_w }
+assert { image.h == bitmap1_h }
+
+image.save_as(outname, :bmp)
+
+# 
+# fout   = File.open(outname, 'w+')
+# assert { codec.encode(image, fout) }
+# fout.close
+
+# system("display #{outname} &")
+
+
+image2 = Pruim::Image.new(test_w, test_h, :mode => :palette, :pages => 1)
+assert { image2 } 
+assert { image2.w == test_w }
+assert { image2.h == test_h }
+gray  = image2.palette.new_rgb(127, 128, 129)
+red   = image2.palette.new_rgb(255,   0,   0)
+green = image2.palette.new_rgb(0  , 255, 255)
+blue  = image2.palette.new_rgb(0  ,   0, 255)
+p red
+image2.fill(gray)
+image2.putpixel(4, 5, red)
+image2.putpixel(5, 6, green)
+image2.putpixel(6, 7, blue)
+assert { image2.getpixel(4, 5) == red   }
+assert { image2.getpixel(5, 6) == green }
+assert { image2.getpixel(6, 7) == blue  }
+
+image2.save_as(outname2, :bmp)
+# 
+# fout2   = File.open(outname2, 'w+')
+# assert { codec.encode(image2, fout2) }
+# fout2.close
+assert { system("display #{outname2} &") }
+
+
+ 
+# 
+# assert { codec } 
+# assert { codec.encode(image, fout) }
+# fout.close
+# # system("eog #{outname} &")
+# fin = File.open(outname, 'r+')
+# image2 = nil
+# assert { image2 = codec.decode(fin) }
+# fin.close
+# page2  = image2.active
+# assert { page2 }
+# assert { image2.w == test_w }
+# assert { image2.h == test_h }
+# assert { page2.w  == test_w }
+# assert { page2.h  == test_h }
+# 
+# assert { page2.getpixel!(1, 1)   == green }
+# assert { page2.getpixel!(10, 10) == blue  }
+# assert { page2.getpixel!(0, 0)   == red   }
+# 
+# assert { image2.getpixel(1, 1)   == green }
+# assert { image2.getpixel(10, 10) == blue  }
+# assert { image2.getpixel(0, 0)   == red   }
+# 
+
+
+

data/test/pruim/test_image.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'pruim'
+
+test_w, test_h = 64, 32
+
+assert { Pruim }
+assert { Pruim::Image } 
+image = Pruim::Image.new(test_w, test_h, :pages => 1)
+assert { image } 
+assert { image.w == test_w }
+assert { image.h == test_h }
+red   = Pruim::Color.rgb(255,  0,  0)
+green = Pruim::Color.rgb(0  ,255, 255)
+blue  = Pruim::Color.rgb(0  ,  0, 255)
+page  = image.active
+assert { page } 
+assert { page.w == test_w }
+assert { page.h == test_h }
+page.fill(red)
+page.putpixel(1, 1, green)
+page.putpixel(10, 10, blue)
+assert { image.getpixel(1, 1)   == green }
+assert { image.getpixel(10, 10) == blue  }
+assert { image.getpixel(0, 0)   == red   }
+
+image2 = Pruim::Image.new(2, 3, :data => [ 1, 2, 3, 4, 5, 6])
+assert { image2 }
+assert { image2.getpixel(0, 0) == 1     }
+assert { image2.getpixel(1, 1) == 4     }
+assert { image2.getpixel(1, 2) == 6     }
+
+
+
+

data/test/pruim/test_page.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+require 'pruim'
+
+test_w = 2
+test_h = 3
+assert { Pruim                   }
+assert { Pruim::Page             }
+page  = Pruim::Page.new(nil, test_w, test_h, :data => [1, 2, 3, 4, 5, 6] )
+assert { page                    }
+assert { page.w == test_w        }
+assert { page.h == test_h        }
+assert { page.getpixel(0,0) == 1 } 
+assert { page.getpixel(1,2) == 6 }
+
+

data/test/pruim/test_pbm.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require 'pruim'
+
+test_w, test_h = 16, 16
+test_comment = "Test PBM file for Pruim."
+assert { Pruim }
+assert { Pruim::Image }
+image = Pruim::Image.new(test_w, test_h, :mode => :monochrome, :pages => 1)
+page  = image.active
+page.fill(false)
+page.putpixel(1, 1, true)
+page.putpixel(10, 10, true)
+image.comment = test_comment
+
+outname = test_file("out.pbm")
+assert { image.save_as(outname, "pbm") }
+
+image2 = Pruim::Image.load_from(outname, "pbm")
+#
+# fin = File.open(outname, 'r+')
+# image2 = nil
+# assert { image2 = codec.decode(fin) }
+# fin.close
+page2  = image2.active
+assert { page2 }
+assert { image2.w == test_w }
+assert { image2.h == test_h }
+assert { page2.w  == test_w }
+assert { page2.h  == test_h }
+assert { page2.getpixel!(1, 1)     }
+assert { page2.getpixel!(10, 10)   }
+assert { !(page2.getpixel!(0, 0))  }
+assert { image2.getpixel(1, 1)     }
+assert { image2.getpixel(10, 10)   }
+assert { !(image2.getpixel(0, 0))  }
+assert { image2.comment          == test_comment }

data/test/pruim/test_ppm.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+require 'pruim'
+
+test_w, test_h = 64, 32
+test_comment = "Test PPM file for Pruim."
+assert { Pruim }
+assert { Pruim::Image } 
+image = Pruim::Image.new(test_w, test_h, :pages => 1)
+red   = Pruim::Color.rgb(255,  0,  0)
+green = Pruim::Color.rgb(0  ,255, 255)
+blue  = Pruim::Color.rgb(0  ,  0, 255)
+page  = image.active
+page.fill(red)
+page.putpixel(1, 1, green)
+page.putpixel(10, 10, blue)
+image.comment = test_comment
+
+outname = test_file("out.ppm")
+assert { image.save_as(outname, "ppm") }
+
+image2 = Pruim::Image.load_from(outname, "ppm")
+# 
+# fin = File.open(outname, 'r+')
+# image2 = nil
+# assert { image2 = codec.decode(fin) }
+# fin.close
+page2  = image2.active
+assert { page2 }
+assert { image2.w == test_w }
+assert { image2.h == test_h }
+assert { page2.w  == test_w }
+assert { page2.h  == test_h }
+
+assert { page2.getpixel!(1, 1)   == green }
+assert { page2.getpixel!(10, 10) == blue  }
+assert { page2.getpixel!(0, 0)   == red   }
+
+assert { image2.getpixel(1, 1)   == green }
+assert { image2.getpixel(10, 10) == blue  }
+assert { image2.getpixel(0, 0)   == red   }
+assert { image2.comment          == test_comment }
+
+
+

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+# require 'nanotest'
+# require 'redgreen'
+
+require 'pathname'
+require 'timeout'
+
+$: << '.'
+
+require 'atto'
+include Atto::Test
+
+
+def test_file(*fname)
+  return File.join('test', *fname)
+end
+
+
+$: << '../lib'
+
+

data/test/test_image.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+require 'pruim'
+
+test_w, test_h = 64, 32
+
+assert { Pruim }
+assert { Pruim::Image } 
+image = Pruim::Image.new(test_w, test_h)
+assert { image } 
+assert { image.w == test_w }
+assert { image.h == test_h }
+red   = Pruim::Color.rgb(255,  0,  0)
+green = Pruim::Color.rgb(0  ,255, 255)
+blue  = Pruim::Color.rgb(0  ,  0, 255)
+page  = image.new_page(test_w, test_h)
+assert { page } 
+assert { page.w == test_w }
+assert { page.h == test_h }
+page.fill(red)
+page.putpixel(1, 1, green)
+page.putpixel(10, 10, blue)
+outname = test_file("out.ppm")
+fout = File.open(outname, 'w+') 
+codec = Pruim::Codec.new_codec_for('ppm')
+assert { codec } 
+assert { codec.encode(image, fout) }
+fout.close
+# system("eog #{outname} &")
+fin = File.open(outname, 'r+')
+image2 = nil
+assert { image2 = codec.decode(fin) }
+fin.close
+page2  = image2.pages.first
+assert { page2 }
+assert { image2.w == test_w }
+assert { image2.h == test_h }
+assert { page2.w  == test_w }
+assert { page2.h  == test_h }
+
+assert { page2.getpixel!(1, 1)   == green }
+assert { page2.getpixel!(10, 10) == blue  }
+assert { page2.getpixel!(0, 0)   == red   }
+
+
+
+
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: pruim
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- beoran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bindata
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: atto
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+  type: :development
+  version_requirements: *id002
+description: "  Pruim is a Pure Ruby Image Library. Currently only supports BMP, PPM and PBM\n  formats, but preserves palette ordering on reading and writing.\n"
+email: beoran@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- lib/pruim.rb
+- lib/pruim/pbm.rb
+- lib/pruim/bmp.rb
+- lib/pruim/ppm.rb
+- lib/pruim/page.rb
+- lib/pruim/image.rb
+- lib/pruim/palette.rb
+- lib/pruim/codec.rb
+- lib/pruim/color.rb
+- lib/pruim/movie.rb
+- test/test_helper.rb
+- test/test_image.rb
+- test/atto.rb
+- test/pruim/test_bmp.rb
+- test/pruim/test_image.rb
+- test/pruim/test_pbm.rb
+- test/pruim/test_ppm.rb
+- test/pruim/test_page.rb
+homepage: http://github.com/beoran/pruim
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Pure Ruby Image Library.
+test_files: []
+