axon 0.0.2 → 0.1.0

data/lib/axon/generators.rb

@@ -0,0 +1,109 @@
+module Axon
+  # == A Noise Image Generator
+  #
+  # Axon::Noise will generate images with random pixel color values.
+  #
+  # == Example
+  #
+  #   Axon::Noise.new(100, 200, :components => 1)
+  #
+  class Noise
+    # The width of the generated image.
+    attr_reader :width
+
+    # The height of the generated image.
+    attr_reader :height
+
+    # The color model of the generated image.
+    attr_reader :color_model
+
+    # The components in the generated image.
+    attr_reader :components
+
+    # The index of the next line that will be fetched by gets, starting at 0.
+    attr_reader :lineno
+
+    # :call-seq:
+    #   Noise.new(width, height, options = {})
+    #
+    # Creates a new noise image object with dimensions +width+ x +height+.
+    #
+    # +options+ may contain the following optional hash key values:
+    #
+    # * :color_model -- The color model of the generated image.
+    # * :components -- The number of components in the generated image.
+    #
+    def initialize(width, height, options=nil)
+      options ||= {}
+
+      @width = width
+      @height = height
+      @color_model = options[:color_model] || :RGB
+      @components = options[:components] || 3
+      @lineno = 0
+      @empty_string = String.new
+      if @empty_string.respond_to? :force_encoding
+        @empty_string.force_encoding('BINARY')
+      end
+    end
+
+    # Gets the next scanline from the generated image.
+    #
+    def gets
+      return nil if @lineno >= @height
+      sl = @empty_string.dup
+      (@width * @components).times{ sl << rand(2**8) }
+      @lineno += 1
+      sl
+    end
+  end
+
+  # == A Solid Color Image Generator
+  #
+  # Axon::Solid will generate images with a solid color value.
+  #
+  # == Example
+  #
+  #   Axon::Solid.new(100, 200, "\x0A\x14\x69")
+  #
+  class Solid
+    # The width of the generated image.
+    attr_reader :width
+
+    # The height of the generated image.
+    attr_reader :height
+
+    # The color model of the generated image.
+    attr_reader :color_model
+
+    # The components in the generated image.
+    attr_reader :components
+
+    # The index of the next line that will be fetched by gets, starting at 0.
+    attr_reader :lineno
+
+    # :call-seq:
+    #   Solid.new(width, height, color = "\x00\x00\x00", color_model = :RGB)
+    #
+    # Creates a new solid color image object with dimensions +width+ x +height+.
+    #
+    # The optional argument +color+ is the binary value that will be assigned
+    # to each pixel.
+    #
+    def initialize(width, height, color=nil, color_model=nil)
+      @width, @height = width, height
+      @color = color || "\x00\x00\x00"
+      @color_model = color_model || :RGB
+      @components = @color.size
+      @lineno = 0
+    end
+
+    # Gets the next scanline from the generated image.
+    #
+    def gets
+      return nil if @lineno >= @height
+      @lineno += 1
+      @color * width
+    end
+  end
+end

data/lib/axon/scalers.rb

@@ -0,0 +1,160 @@
+module Axon
+  # == A Nearest-neighbor Image Scaler
+  #
+  # Axon::NearestNeighborScaler scales images quickly using the nearest-neighbor
+  # interpolation method.
+  #
+  # Nearest-neighbor interpolation selects the value of the nearest pixel when
+  # calculating colors in the scaled image.
+  #
+  # == Example
+  #
+  #   n = Axon::NearestNeighborScaler.new(image_in, 50, 75)
+  #   n.width  # => 50
+  #   n.height # => 75
+  #   n.gets   # => String
+  #
+  class NearestNeighborScaler
+    # The width of the generated image.
+    attr_reader :width
+
+    # The height of the generated image.
+    attr_reader :height
+
+    # The index of the next line that will be fetched by gets, starting at 0.
+    attr_reader :lineno
+
+    # :call-seq:
+    #   NearestNeighborScaler.new(image_in, width, height)
+    #
+    # Scales +image_in+ to the size +width+ x +height+ using the
+    # nearest-neighbor interpolation method.
+    #
+    def initialize(source, width, height)
+      raise ArgumentError if width < 1 || height < 1
+      @width = width
+      @height = height
+      @source = source
+      @lineno = 0
+      @buf = nil
+    end
+
+    # Gets the components in the scaled image. Same as the components of the
+    # source image.
+    #
+    def components
+      @source.components
+    end
+
+    # Gets the color model of the scaled image. Same as the color model of the
+    # source image.
+    #
+    def color_model
+      @source.color_model
+    end
+
+    # Gets the next scanline from the cropped image.
+    #
+    def gets
+      return nil if @lineno >= @height
+      sample = (@lineno * @source.height / @height.to_f).floor
+      @lineno += 1
+      Interpolation.nearest(get_buf(sample), @width, components)
+    end
+
+    private
+
+    def get_buf(line)
+      @buf ||= @source.gets
+      (line + 1 - @source.lineno).times{ @buf = @source.gets }
+      @buf
+    end
+  end
+
+  # == A Bilinear Image Scaler
+  #
+  # Axon::BilinearScaler scales images using the bilinear interpolation method.
+  #
+  # Bilinear interpolation calculates the color values in the resulting image by
+  # looking at the four nearest pixels for each pixel in the resulting image.
+  #
+  # This gives a more accurate representation than nearest-neighbor
+  # interpolation, at the expense of slightly blurring the resulting image.
+  #
+  # == Example
+  #
+  #   n = Axon::BilinearScaler.new(image_in, 50, 75)
+  #   n.width  # => 50
+  #   n.height # => 75
+  #   n.gets   # => String
+  #
+  class BilinearScaler
+    # The width of the generated image.
+    attr_reader :width
+
+    # The height of the generated image.
+    attr_reader :height
+
+    # The index of the next line that will be fetched by gets, starting at 0.
+    attr_reader :lineno
+
+    # :call-seq:
+    #   BilinearScaler.new(image_in, width, height)
+    #
+    # Scales +image_in+ to the size +width+ x +height+ using the bilinear
+    # interpolation method.
+    #
+    def initialize(source, width, height)
+      raise ArgumentError if width < 1 || height < 1
+      @width = width
+      @height = height
+      @source = source
+      @lineno = 0
+      @buf1 = nil
+      @buf2 = nil
+    end
+
+    # Gets the components in the scaled image. Same as the components of the
+    # source image.
+    #
+    def components
+      @source.components
+    end
+
+    # Gets the color model of the scaled image. Same as the color model of the
+    # source image.
+    #
+    def color_model
+      @source.color_model
+    end
+
+    # Gets the next scanline from the cropped image.
+    #
+    def gets
+      return nil if @lineno >= @height
+      sample = @lineno * @source.height / @height.to_f
+      sample_i = sample.to_i
+      ty = sample - sample_i
+      @lineno += 1
+      get_buf(sample_i)
+
+      Interpolation.bilinear(@buf1, @buf2, @width, ty, components)
+    end
+
+    private
+
+    def get_buf(line)
+      @buf1 = @buf2 = read_with_padding unless @buf2
+      (line + 2 - @source.lineno).times do
+        @buf1 = @buf2
+        @buf2 = read_with_padding if @source.lineno < @source.height
+      end
+    end
+
+    def read_with_padding
+      line = @source.gets
+      line << line[-@source.components, @source.components]
+      line
+    end
+  end
+end

data/test/helper.rb

@@ -1,17 +1,162 @@
+require 'rubygems'
 require 'minitest/autorun'
 require 'axon'
 require 'stringio'
-require 'reader_tests'
-require 'writer_tests'
 
 module Axon
   class AxonTestCase < MiniTest::Unit::TestCase
-    
-    # Generate a solid velvet JPEG
+    # Generate a solid velvet image
     def setup
-      @velvet = "\x0A\x14\x69"
-      @image = Solid.new 10, 15, @velvet
+      super
+      @image = Solid.new 10, 15, "\x0A\x14\x69"
       @io_out = StringIO.new
+      @io_out.set_encoding 'ASCII-8BIT' if @io_out.respond_to?(:set_encoding)
+    end
+
+    def assert_image_dimensions(image, width, height)
+      cmp = image.components
+
+      assert_equal width, image.width
+      assert_equal height, image.height
+
+      height.times do |i|
+        assert_equal i, image.lineno
+        assert_equal width * cmp, image.gets.size, 'image.gets should return scanlines with length width'
+      end
+
+      assert_equal height, image.lineno
+      assert_nil image.gets, 'image.gets should be nil after reading height lines'
+      assert_equal height, image.lineno
+    end
+  end
+
+  class CustomError < RuntimeError; end
+
+  module CallOrReturnValue
+    def call_or_return(*args)
+      @custom.respond_to?(:call) ? @custom.call(@parent, *args) : @custom
+    end
+  end
+
+  class CustomImage
+    include CallOrReturnValue
+
+    def initialize(custom)
+      @parent = Solid.new 100, 200
+      @custom = custom
+    end
+
+    def height; @parent.height; end
+    def width; @parent.width; end
+    def color_model; @parent.color_model; end
+    def components; @parent.components; end
+    def gets; @parent.gets; end
+    def lineno; @parent.lineno; end
+  end
+
+  class CustomHeightImage < CustomImage
+    def height; call_or_return; end
+  end
+
+  class CustomWidthImage < CustomImage
+    def width; call_or_return; end
+  end
+
+  class CustomColorModelImage < CustomImage
+    def color_model; call_or_return; end
+  end
+
+  class CustomComponentsImage < CustomImage
+    def components; call_or_return; end
+  end
+
+  class CustomLinenoImage < CustomImage
+    def lineno; call_or_return; end
+  end
+
+  class CustomGetsImage < CustomImage
+    def gets; call_or_return; end
+  end
+  
+  class CustomIO
+    include CallOrReturnValue
+
+    attr_accessor :custom
+
+    def initialize(custom, *args)
+      @parent = StringIO.new(*args)
+      @custom = custom
+    end
+
+    def write(*args); call_or_return(*args); end
+    def read(*args); call_or_return(*args); end
+    def string; @parent.string; end
+  end
+
+  class ArrayWrapper
+    attr_reader :lineno, :components, :color_model
+
+    def initialize(ary, components=nil, color_model=nil)
+      @ary = ary
+      @components = components || 3
+      @color_model = color_model || :RGB
+      @lineno = 0
+    end
+
+    def width
+      @ary[0].size
+    end
+
+    def height
+      @ary.size
+    end
+
+    def gets
+      return nil if @lineno > @ary.size
+      res = @ary[@lineno]
+      @lineno += 1
+      res
+    end
+  end
+
+  class Repeater
+    attr_reader :lineno
+
+    def initialize(source)
+      @source = source
+      @data = []
+      @lineno = 0
+    end
+
+    def components
+      @source.components
+    end
+
+    def color_model
+      @source.color_model
+    end
+
+    def height
+      @source.height
+    end
+
+    def width
+      @source.width
+    end
+
+    def gets
+      if @data.size <= @lineno
+        res = @source.gets.dup
+        return nil unless res
+        @data << res
+      end
+
+      @lineno += 1
+      @data[@lineno - 1].dup
+    end
+
+    def rewind
+      @lineno = 0
     end
   end
 end

data/test/reader_tests.rb

@@ -1,115 +1,70 @@
 module Axon
   module ReaderTests
-    def test_read_image_from_io
-      assert_equal 10, @reader.width
-      assert_equal 15, @reader.height
+    def test_header_dimensions
+      assert_equal @image.width, @reader.width
+      assert_equal @image.height, @reader.height
     end
     
-    def test_read_image_from_string
-      assert_equal 10, @reader.width
-      assert_equal 15, @reader.height
+    def test_header_components
+      assert_equal @image.components, @reader.components
     end
     
-    def test_num_components
-      assert_equal 3, @reader.components
+    def test_header_color_model
+      assert_equal @image.color_model, @reader.color_model
     end
     
-    def test_color_model
-      assert_equal :RGB, @reader.color_model
-    end
-    
-    class DoubleIO < StringIO
-      def read(*args)
-        s = super
-        s[0..20] * 100
-      end
-    end
-    
-    def test_io_returns_too_much
-      f = DoubleIO.new @data
-      assert_raises(RuntimeError) { @readerclass.new f }
-    end
-    
-    class NilIO
-      def read(*args); end
+    def test_io_returns_too_much_data
+      io = CustomIO.new(Proc.new{ |io, *args| io.read(*args)[0..20] * 100 }, @data)
+      assert_raises(RuntimeError) { @readerclass.new io }
     end
     
     def test_io_returns_nil
-      assert_raises(RuntimeError) { @readerclass.new NilIO.new }
+      assert_raises(RuntimeError) { @readerclass.new(CustomIO.new(nil)) }
     end
-    
-    class RaiseIO
-      def read(*args)
-        raise 'heck'
-      end
-    end
-    
-    def test_io_raises_exception
-      assert_raises(RuntimeError) { @readerclass.new RaiseIO.new }
+
+    def test_io_returns_one_byte_at_a_time
+      io = CustomIO.new(Proc.new{ |io, len| io.read(len || 1) }, @data)
+      r = @readerclass.new(io)
+      r.gets
     end
 
-    class EmptyStringIO
-      def read(*args)
-        ""
-      end
+    def test_io_raises_exception
+      io = CustomIO.new(Proc.new{ raise CustomError }, @data)
+      assert_raises(CustomError) { @readerclass.new io }
     end
 
     def test_empty_string_io
-      assert_raises(RuntimeError) { @readerclass.new EmptyStringIO.new }
-    end
-    
-    class ThatsNotAStringIO
-      def read(*args)
-        :this_should_be_a_string
-      end
+      assert_raises(RuntimeError) { @readerclass.new(CustomIO.new("")) }
     end
     
     def test_not_a_string_io
-      assert_raises(TypeError) { @readerclass.new ThatsNotAStringIO.new }
+      assert_raises(TypeError) { @readerclass.new(CustomIO.new(:foo)) }
     end
-    
-    def test_each
-      size = @reader.width * @reader.components
 
-      @reader.each do |scan_line|
-        assert_equal size, scan_line.size
+    def test_lineno
+      assert_equal 0, @reader.lineno
+      @reader.height.times do |i|
+        assert_equal i, @reader.lineno
+        @reader.gets
       end
+      assert_equal nil, @reader.gets
+      assert_equal @reader.height, @reader.lineno
     end
     
-    def test_no_shenanigans_during_each
-      @reader.each do |sl|
-        assert_raises(RuntimeError) { @reader.each{} }
-        break
-      end
-    end
-    
-    class OneExceptionIO < StringIO
-      def initialize(*args)
-        @raised_exception = false
-        super
-      end
-      
-      def read(*args)
-        unless @raised_exception
-          @raised_exception = true
-          raise 'heck'
-        end
-        super
+    def test_gets
+      size = @reader.width * @reader.components
+      @reader.height.times do
+        assert_equal size, @reader.gets.size
       end
+      assert_equal nil, @reader.gets
     end
     
     def test_recovers_from_initial_io_exception
-      io = OneExceptionIO.new @data
+      ex_io = CustomIO.new(Proc.new{ raise CustomError }, @data)
       r = @readerclass.allocate
-      assert_raises(RuntimeError) { r.send(:initialize, io) }
-      r.send(:initialize, io)
-      r.each{ }
-    end
-
-    def test_multiple_each_calls
-      @reader.each{ }
-      @io_in.rewind
-      @reader.each{ }
+      assert_raises(CustomError) { r.send(:initialize, ex_io) }
+      r.send(:initialize, StringIO.new(@data))
+      r.gets
     end
   end
 end