axon 0.0.1

data/lib/axon/cropper.rb

@@ -0,0 +1,35 @@
+module Axon
+  class Cropper
+    include Enumerable
+    include Image
+
+    attr_reader :image, :width, :height, :components, :color_model
+
+    def initialize(image, width, height, x_offset=nil, y_offset=nil)
+      @image = image
+      @width = width
+      @height = height
+      @x_offset = x_offset || 0
+      @y_offset = y_offset || 0
+      @components = image.components
+      @color_model = image.color_model
+    end
+
+    def each
+      sl_width = @width * @components
+      sl_offset = @x_offset * @components
+
+      @image.each_with_index do |orig_sl, i|
+        next if i < @y_offset
+        yield orig_sl[sl_offset, sl_width]
+        break if i == @height - 1
+      end
+    end
+  end
+
+  module Image
+    def crop(*args)
+      Cropper.new(self, *args)
+    end
+  end
+end

data/lib/axon/fit.rb

@@ -0,0 +1,67 @@
+module Axon
+  class Fit
+    include Image
+    include Enumerable
+
+    def initialize(source, width, height)
+      @source, @fit_width, @fit_height = source, width, height
+    end
+
+    def components
+      @source.components
+    end
+
+    def color_model
+      @source.color_model
+    end
+
+    def width
+      @source.width * calc_fit_ratio
+    end
+
+    def height
+      @source.height * calc_fit_ratio
+    end
+
+    def each
+      r = calc_fit_ratio
+
+      if r > 1
+        scaler = NearestNeighborScaler.new(@source, r)
+        scaler.each{ |*a| yield(*a) }
+      elsif r < 1
+        if r <= 0.5 && @source.kind_of?(JPEGReader)
+          @source.scale_denom = calc_jpeg_pre_shrink(r)
+          r = calc_fit_ratio
+        end
+        scaler = BilinearScaler.new(@source, r)
+        scaler.each{ |*a| yield(*a) }
+      else
+        @source.each{ |*a| yield(*a) }
+      end
+    end
+
+    private
+
+    def calc_fit_ratio
+      width_ratio = @fit_width.to_f / @source.width
+      height_ratio = @fit_height.to_f / @source.height
+      [width_ratio, height_ratio].min
+    end
+
+    def calc_jpeg_pre_shrink(r)
+      case (1/r)
+      when (0...2) then nil
+      when (2...4) then 2
+      when (4...8) then 4
+      else 8
+      end
+    end
+  end
+
+  module Image
+    def fit(*args)
+      Fit.new(self, *args)
+    end
+  end
+end

data/lib/axon/jpeg_writer.rb

@@ -0,0 +1,41 @@
+require 'stringio'
+
+module Axon
+  class JPEGWriter
+    include JPEGNativeWriter
+
+    attr_accessor :quality, :icc_profile, :exif
+    attr_reader :io, :bufsize, :image
+
+    def initialize(image)
+      @image = image
+      @quality = nil
+      @icc_profile = nil
+      @exif = nil
+    end
+    
+    def write(io, bufsize = nil)
+      @bufsize = bufsize || 512
+      @io = io
+      jpeg_native_write
+    end
+
+    def data
+      s = StringIO.new
+      s.set_encoding 'BINARY' if s.respond_to?(:set_encoding)
+
+      write(s)
+      s.string
+    end
+  end
+
+  module Image
+    def to_jpeg(*args)
+      JPEGWriter.new self, *args
+    end
+
+    def write_jpeg(io)
+      JPEGWriter.new(self).write(io)
+    end
+  end
+end

data/lib/axon/nearest_neighbor_scaler.rb

@@ -0,0 +1,39 @@
+module Axon
+  class NearestNeighborScaler < Scaler
+    include NearestNeighborScaling
+    include Image
+    include Enumerable
+
+    def each
+      dest_y = 0
+      sample_y = 0
+
+      @image.each_with_index do |scanline, orig_y|
+        while sample_y == orig_y
+          yield interpolate_scanline(scanline)
+          dest_y += 1
+          sample_y = (dest_y / @height_ratio).to_i
+        end
+      end
+    end
+    
+    private
+    
+    def _interpolate_scanline(scanline)
+      dest_sl = ''
+
+      scanline.size.times do |dest_x|
+        sample_x = (dest_x / @width_ratio).to_i
+        dest_sl << scanline[sample_x * components, components]
+      end
+
+      return dest_sl      
+    end
+  end
+
+  module Image
+    def scale_nearest_neighbor(*args)
+      NearestNeighborScaler.new(self, *args)
+    end
+  end
+end

data/lib/axon/png_writer.rb

@@ -0,0 +1,35 @@
+require 'stringio'
+
+module Axon
+  class PNGWriter
+    include PNGNativeWriter
+
+    attr_reader :image
+
+    def initialize(image)
+      @image = image
+    end
+
+    def write(io)
+      png_native_write(io)
+    end
+
+    def data
+      s = StringIO.new
+      s.set_encoding 'BINARY' if s.respond_to?(:set_encoding)
+
+      write(s)
+      s.string
+    end
+  end
+
+  module Image
+    def to_png
+      PNGWriter.new self
+    end
+
+    def write_png(io)
+      PNGWriter.new(self).write(io)
+    end
+  end
+end

data/lib/axon/scaler.rb

@@ -0,0 +1,41 @@
+module Axon
+  class Scaler
+    attr_reader :width, :height
+
+    def initialize(image, *args)
+      @image = image
+
+      if args.size == 1
+        init_ratio(args[0])
+      elsif args.size == 2
+        init_dims(args[0], args[1])
+      else
+        raise ArgumentError, "Must give one or two arguments"
+      end
+    end
+
+    def components
+      @image.components
+    end
+
+    def color_model
+      @image.color_model
+    end
+
+    private
+
+    def init_ratio(ratio)
+      @width_ratio = @height_ratio = ratio.to_f
+      @width = (@image.width * ratio).floor
+      @height = (@image.height * ratio).floor
+    end
+
+    def init_dims(width, height)
+      @width_ratio = width.to_f / @image.width
+      @width = width
+
+      @height_ratio = height.to_f / @image.height
+      @height = height
+    end
+  end
+end

data/lib/axon/solid.rb

@@ -0,0 +1,23 @@
+module Axon
+  class Solid
+    include Image
+    include Enumerable
+    attr_reader :width, :height, :color_model, :components
+
+    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
+    end
+
+    def each
+      sl = @color * width
+      height.times { yield sl }
+    end
+  end
+
+  module Image
+    # empty
+  end
+end

data/lib/axon.rb

@@ -0,0 +1,45 @@
+require 'axon/axon'
+
+require 'axon/solid'
+require 'axon/cropper'
+require 'axon/scaler'
+require 'axon/nearest_neighbor_scaler'
+require 'axon/bilinear_scaler'
+require 'axon/fit'
+
+require 'axon/jpeg_writer'
+require 'axon/png_writer'
+
+module Axon
+  VERSION = '0.0.1'
+
+  def self.JPEG(thing, markers=nil)
+    if thing.respond_to? :read
+      io = thing
+      rewind_after_scanlines = false
+    elsif thing[0, 1] == "\xFF"
+      io = StringIO.new(thing)
+      rewind_after_scanlines = true
+    else
+      io = File.open(thing)
+      rewind_after_scanlines = true
+    end
+
+    JPEGReader.new(io, markers, rewind_after_scanlines)
+  end
+
+  def self.PNG(thing)
+    if thing.respond_to? :read
+      io = thing
+      rewind_after_scanlines = false
+    elsif thing[0, 1] == "\x89"
+      io = StringIO.new(thing)
+      rewind_after_scanlines = true
+    else
+      io = File.open(thing)
+      rewind_after_scanlines = true
+    end
+
+    PNGReader.new(io)
+  end
+end

data/test/_test_readme.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+module Axon
+  class TestReader < AxonTestCase
+    def setup
+      data = Solid.new(100, 200, "\x0A\x14\x69").to_jpeg.data
+      @io_in = StringIO.new(data)
+      @io_out = StringIO.new
+    end
+
+    def test_short_chained_example
+
+      # Short, chained example. Reads a JPEG from io_in and writes scaled png to
+      # io_out.
+      Axon.JPEG(@io_in).fit(100, 100).write_png(@io_out)
+    end
+
+    def test_longer_example
+      # Even longer example, reads the JPEG header, looks at properties and header
+      # values, sets decompression options, scales the image, sets compression
+      # options, and writes a JPEG.
+      image = Axon.JPEG(@io_in, [:APP2])
+
+      puts image.width
+      puts image.height
+      puts image[:APP2]
+      image.scale_denom = 4
+
+      jpeg = image.fit(100, 100).to_jpeg
+      jpeg.quality = 88
+      jpeg.write(@io_out)
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+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
+    def setup
+      @velvet = "\x0A\x14\x69"
+      @image = Solid.new 10, 15, @velvet
+      @io_out = StringIO.new
+    end
+  end
+end

data/test/reader_tests.rb

@@ -0,0 +1,115 @@
+module Axon
+  module ReaderTests
+    def test_read_image_from_io
+      assert_equal 10, @reader.width
+      assert_equal 15, @reader.height
+    end
+    
+    def test_read_image_from_string
+      assert_equal 10, @reader.width
+      assert_equal 15, @reader.height
+    end
+    
+    def test_num_components
+      assert_equal 3, @reader.components
+    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
+    end
+    
+    def test_io_returns_nil
+      assert_raises(RuntimeError) { @readerclass.new NilIO.new }
+    end
+    
+    class RaiseIO
+      def read(*args)
+        raise 'heck'
+      end
+    end
+    
+    def test_io_raises_exception
+      assert_raises(RuntimeError) { @readerclass.new RaiseIO.new }
+    end
+
+    class EmptyStringIO
+      def read(*args)
+        ""
+      end
+    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
+    end
+    
+    def test_not_a_string_io
+      assert_raises(TypeError) { @readerclass.new ThatsNotAStringIO.new }
+    end
+    
+    def test_each
+      size = @reader.width * @reader.components
+
+      @reader.each do |scan_line|
+        assert_equal size, scan_line.size
+      end
+    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
+      end
+    end
+    
+    def test_recovers_from_initial_io_exception
+      io = OneExceptionIO.new @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{ }
+    end
+  end
+end

data/test/stress_tests.rb

@@ -0,0 +1,71 @@
+require 'helper'
+
+module Axon
+  class TestStressCases < AxonTestCase
+    def setup
+      @velvet = "\x0A\x14\x69"
+      @image = Generator::Solid.new 1000, 1500, @velvet
+      @jpeg_data = @image.to_jpeg.data
+      @readerclass = JPEGReader
+    end
+
+    class RandomRaiseIO
+      def initialize(source)
+        @io = StringIO.new source
+        @die_at = rand(source.size)
+      end
+
+      def read
+        if @die_at < 2
+          raise 'random death!'
+        end
+
+        read_size = rand @die_at
+        @die_at -= read_size
+        @io.read(read_size)
+      end
+    end
+
+    def test_io_raises_after_random_sized_reads
+      loop do
+        f = RandomRaiseIO.new(@jpeg_data)
+        r = @readerclass.new(f) rescue puts("new failed")
+        r.each{} rescue puts('each_sl failed')
+      end
+    end
+
+    class CustomIO < StringIO
+      def initialize(str, sequence)
+        super str
+        @sequence = sequence
+      end
+
+      def read
+        if !@sequence || @sequence.empty?
+          raise "random death!"
+          @sequence = nil
+        end
+        super(@sequence.shift)
+      end
+    end
+
+    def test_custom_io_error
+      loop do
+        f = CustomIO.new(@jpeg_data, [114, 64, 8, 200, 200, 30, 350])
+
+        r = @readerclass.new(f)
+        r.each{  } rescue nil
+        f = CustomIO.new(@jpeg_data, [101, 0])
+        r = @readerclass.new(f) rescue nil
+      end
+    end
+
+    def test_io_returns_nil_after_random_sized_reads
+      loop do
+        f = SometimesNilIO.new(@data)
+        r = @readerclass.new(f)
+        r.each{}
+      end
+    end
+  end
+end

data/test/test_bilinear_scaler.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+module Axon
+  class TestBilinearScaler < AxonTestCase
+    def test_scaling
+      @image.scale_bilinear(0.7).write_jpeg(@io_out)
+    end
+  end
+end

data/test/test_cropper.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+module Axon
+  class TestCropper < AxonTestCase
+    def test_crop
+      @image.scale_nearest_neighbor(40).crop(320, 123).write_jpeg(@io_out)
+    end
+  end
+end

data/test/test_exif.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+module Axon
+  class TestExif < AxonTestCase
+    def test_exif_roundtrip
+      random_data = ""
+      (100).times do
+        random_data << [rand].pack('d') # 800 bytes random data
+      end
+
+      writer = @image.to_jpeg
+      writer.exif = random_data
+      
+      image_with_exif = Axon.JPEG(writer.data)
+      assert_equal random_data, image_with_exif.exif      
+    end
+    
+    def test_exif_with_icc_roundtrip
+      random_icc_data = ""
+      (2**16).times do                  # a little larger than one jpeg segment
+        random_icc_data << [rand].pack('d') # 8 bytes random data
+      end
+
+      random_exif_data = ""
+      (100).times do
+        random_exif_data << [rand].pack('d') # 800 bytes random data
+      end
+      
+      writer = @image.to_jpeg
+      writer.icc_profile = random_icc_data
+      writer.exif = random_exif_data
+
+      image_with_exif_and_icc = Axon.JPEG(writer.data)
+
+      assert_equal random_exif_data, image_with_exif_and_icc.exif
+      assert_equal random_icc_data, image_with_exif_and_icc.icc_profile
+    end
+  end
+end

data/test/test_generator.rb

@@ -0,0 +1,10 @@
+require "helper"
+
+module Axon
+  class TestGenerator < AxonTestCase
+    def test_new_solid
+      g = Solid.new 10, 15, "\x0A\x14\x69"
+      g.write_jpeg(@io_out)
+    end
+  end
+end

data/test/test_icc.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+module Axon
+  class TestICC < AxonTestCase
+    def test_large_icc_roundtrip
+      random_data = ""
+      (2**16).times do                  # a little larger than one jpeg segment
+        random_data << [rand].pack('d') # 8 bytes random data
+      end
+
+      writer = @image.to_jpeg
+      writer.icc_profile = random_data
+      
+      image_with_icc = Axon.JPEG(writer.data)
+      assert_equal random_data, image_with_icc.icc_profile
+    end
+  end
+end

data/test/test_jpeg.rb

@@ -0,0 +1,9 @@
+require "helper"
+
+module Axon
+  class TestJPEG < AxonTestCase
+    def test_version
+      assert JPEG_LIB_VERSION >= 62
+    end
+  end
+end