axon 0.0.2 → 0.1.0

data/test/scaler_tests.rb

@@ -0,0 +1,102 @@
+module Axon
+  module ScalerTests
+    def test_dimensions
+      [
+        [7, 8],
+        [71, 82],
+        [@image.width, @image.height],
+        [1, 1]
+      ].each do |dims|
+        im = Solid.new(100, 200)
+
+        w, h = dims[0], dims[1]
+
+        s = @scalerclass.new(im, w, h)
+        assert_image_dimensions(s, w, h)
+      end
+    end
+
+    def test_bad_dimensions
+      [ [0, 0], [0, 1], [1, 0], [-1, -3] ].each do |dims|
+        w, h = dims[0], dims[1]
+
+        assert_raises ArgumentError do
+          @scalerclass.new(@image, w, h).gets
+        end
+      end
+    end
+
+    def test_scalar
+      [1, 2, 3, 1.1, 2.1, 0.9, 0.1].each do |scale|
+        im = Solid.new(100, 200)
+        width = (im.width * scale).to_i
+        height = (im.height * scale).to_i
+
+        s = @scalerclass.new(im, width, height)
+        assert_image_dimensions(s, width, height)
+      end
+    end
+
+    def test_bad_scalar
+      [0, 0.0, -1, -0.1].each do |scale|
+        assert_raises ArgumentError do
+          @scalerclass.new(@image, scale).gets
+        end
+      end
+    end
+
+    def scale_test(*coords)
+      cache = Repeater.new(Noise.new 100, 200)
+
+      [1.0, 5.0, 0.3, 2.8].each do |scale|
+        width = (cache.width * scale).to_i
+        height = (cache.height * scale).to_i
+
+        cache.rewind
+        test_scaler = @scalertestclass.new(cache, width, height)
+        cache.rewind
+        s = @scalerclass.new(cache, width, height)
+        resized = []
+        s.height.times{ resized << s.gets }
+
+        right = width - 1
+        bottom = height - 1
+
+        coords.each do |coord|
+          x = coord[0]
+          y = coord[1]
+
+          x = right if x < 0
+          y = bottom if y < 0
+
+          result = resized[y][x * 3, 3].chars.map do |c|
+            c.respond_to?(:ord) ? c.ord : c[0]
+          end
+
+          expected = test_scaler.calc(x, y)
+          3.times do |i|
+            assert_in_delta expected[i], result[i], 1
+          end
+        end
+      end
+    end
+
+    def test_pixel_values
+      scale_test [10, 10], [29, 20], [9, 15]
+    end
+
+    def test_edge_pixel_values
+      scale_test [0, 10], [29, 0], [-1, 15], [17, -1]
+    end
+
+    def test_corner_pixel_values
+      scale_test [0, 0], [-1, 0], [0, -1], [-1, -1]
+    end
+
+    def test_small_scaling
+      im = Solid.new(10, 20)
+      sc = @scalerclass.new(im, 2, 5)
+      assert_image_dimensions(sc, 2, 5)
+    end
+  end
+end

data/test/stress_helper.rb

@@ -0,0 +1,58 @@
+
+class MiniTest::Unit::TestCase
+  WARMUP_TESTS = 10
+  MAX_TEST_TIME = 3
+  MAX_TESTS = 3000
+
+  def vmsize
+    GC.start
+    GC.disable
+    vms = IO.read("/proc/#{$$}/status")[/^VmSize:\s+(\d+)/, 1].to_i
+    GC.enable
+    vms
+  end
+
+  def vmdelta
+    start_vmsize = vmsize
+    yield
+    vmsize - start_vmsize
+  end
+
+  def limited_loop
+    start_time = Time.now
+    test_counter = 0
+
+    until Time.now - start_time > MAX_TEST_TIME || test_counter > MAX_TESTS do
+      yield
+      test_counter += 1
+    end
+
+    return test_counter
+  end
+
+  def mem_loop
+    result = yield
+    WARMUP_TESTS.times{ yield }
+    num_tests = 0
+
+    delta = vmdelta do
+      num_tests = limited_loop do
+        yield
+      end
+    end
+
+    # The idea here is that a legitimate memory leak will leak at least one
+    # byte per iteration.
+    if delta >= num_tests
+      puts "\n#{self.class} #{__name__}: #{delta}"
+    end
+
+    result
+  end
+
+  alias_method :old_run, :run
+
+  def run(*args)
+    mem_loop{ old_run(*args) }
+  end
+end

data/test/stress_tests.rb

@@ -4,9 +4,12 @@ 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
+      @image = Solid.new 1000, 1500, @velvet
+
+      io = StringIO.new
+      JPEG.write(@image, io)
+      @jpeg_data = io.string
+      @readerclass = JPEG::Reader
     end
 
     class RandomRaiseIO
@@ -15,7 +18,7 @@ module Axon
         @die_at = rand(source.size)
       end
 
-      def read
+      def read(*args)
         if @die_at < 2
           raise 'random death!'
         end
@@ -40,7 +43,7 @@ module Axon
         @sequence = sequence
       end
 
-      def read
+      def read(*args)
         if !@sequence || @sequence.empty?
           raise "random death!"
           @sequence = nil

data/test/test_bilinear_scaler.rb

@@ -1,9 +1,67 @@
 require 'helper'
+require 'scaler_tests'
 
 module Axon
   class TestBilinearScaler < AxonTestCase
-    def test_scaling
-      @image.scale_bilinear(0.7).write_jpeg(@io_out)
+    include ScalerTests
+
+    def setup
+      super
+      @scalerclass = BilinearScaler
+      @scalertestclass = TestBilinearScaler
+    end
+
+    class TestBilinearScaler
+      def initialize(original, width, height)
+        @original = original
+        @scale_x_inv = original.width / width.to_f
+        @scale_y_inv = original.height / height.to_f
+
+        # pad right and bottom with one pixel
+        @data = []
+        @original.height.times do
+          sl = @original.gets
+          @data << sl + sl[-@original.components, @original.components]
+        end
+        @data << @data.last
+      end
+
+      def calc(x, y)
+        sample_x = x * @scale_x_inv
+        sample_y = y * @scale_y_inv
+
+        sample_x_i = sample_x.floor
+        sample_y_i = sample_y.floor
+
+        tx = sample_x - sample_x_i
+        ty = sample_y - sample_y_i
+
+        ret = []
+
+        cmp = @original.components
+
+        cmp.times do |i|
+          smp_x = sample_x_i * @original.components + i
+
+          c00 = @data[sample_y_i][smp_x]
+          c10 = @data[sample_y_i][smp_x + cmp]
+          c01 = @data[sample_y_i + 1][smp_x]
+          c11 = @data[sample_y_i + 1][smp_x + cmp]
+
+          unless RUBY_VERSION == '1.8.7'
+            c00 = c00.ord
+            c10 = c10.ord
+            c01 = c01.ord
+            c11 = c11.ord
+          end
+
+          a = (1 - tx) * c00 + tx * c10
+          b = (1 - tx) * c01 + tx * c11
+          ret << ((1 - ty) * a + ty * b).floor
+        end
+
+        ret
+      end
     end
   end
 end

data/test/test_cropper.rb

@@ -3,7 +3,74 @@ require 'helper'
 module Axon
   class TestCropper < AxonTestCase
     def test_crop
-      @image.scale_nearest_neighbor(40).crop(320, 123).write_jpeg(@io_out)
+      i = Solid.new(200, 100)
+      c = Cropper.new(i, 4, 55)
+
+      assert_equal 4, c.width
+      assert_equal 55, c.height
+
+      55.times do |i|
+        assert_equal i, c.lineno
+        assert_equal 4 * c.components, c.gets.size
+      end
+
+      assert_equal nil, c.gets
+      assert_equal 55, c.lineno
+    end
+
+    def test_crop_too_tall
+      i = Solid.new(200, 100)
+      c = Cropper.new(i, 4, 133)
+      assert_image_dimensions(c, 4, 100)
+    end
+
+    def test_crop_too_wide
+      i = Solid.new(200, 100)
+      c = Cropper.new(i, 233, 33)
+      assert_image_dimensions(c, 200, 33)
+    end
+
+    def test_crop_negative_values
+      i = Solid.new(200, 100)
+
+      assert_raises(ArgumentError) do
+        Cropper.new(i, -233, 33)
+      end
+
+      assert_raises(ArgumentError) do
+        Cropper.new(i, 100, -33)
+      end
+
+      assert_raises(ArgumentError) do
+        Cropper.new(i, 0, 23)
+      end
+    end
+
+    def test_crop_with_offset
+      i = Noise.new(100, 200)
+
+      data = []
+      i.height.times{ data << i.gets }
+      c = Cropper.new(ArrayWrapper.new(data), 42, 51, 22, 31)
+
+      assert_equal 42, c.width
+      assert_equal 51, c.height
+
+      51.times do |i|
+        assert_equal i, c.lineno
+        sl = c.gets
+        assert_equal 42 * c.components, sl.size
+        assert_equal data[i + 31][22 * c.components], sl[0]
+      end
+
+      assert_equal nil, c.gets
+      assert_equal 51, c.lineno
+    end
+
+    def test_crop_with_offset_oob
+      i = Solid.new(200, 100)
+      c = Cropper.new(i, 30, 40, 220, 10)
+      assert_nil c.gets
     end
   end
 end

data/test/test_fit.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module Axon
+  class TestFit < AxonTestCase
+    def test_width_determines_downscaling
+      im = Solid.new(10, 20)
+      r = Fit.new(im, 5, 20)
+      assert_image_dimensions(r, 5, 10)
+    end
+
+    def test_height_determines_downscaling
+      im = Solid.new(10, 20)
+      r = Fit.new(im, 20, 5)
+      assert_image_dimensions(r, 2, 5)
+    end
+
+    def test_width_determines_upscaling
+      im = Solid.new(10, 20)
+      r = Fit.new(im, 100, 900)
+      assert_image_dimensions(r, 100, 200)
+    end
+
+    def test_height_determines_upscaling
+      im = Solid.new(10, 20)
+      r = Fit.new(im, 1000, 200)
+      assert_image_dimensions(r, 100, 200)
+    end
+
+    def test_dimensions_unchanged
+      im = Solid.new(10, 20)
+      r = Fit.new(im, 10, 20)
+      assert_image_dimensions(r, 10, 20)
+    end
+  end
+end

data/test/test_generators.rb

@@ -0,0 +1,21 @@
+require "helper"
+
+module Axon
+  class TestGenerators < AxonTestCase
+    def test_solid_color
+      g = Solid.new 10, 15, "\x0A\x14\x69"
+      sl = g.gets
+      assert_equal "\x0A\x14\x69", sl[9, 3]
+    end
+
+    def test_solid_dimensions
+      g = Solid.new(23, 33)
+      assert_image_dimensions(g, 23, 33)
+    end
+
+    def test_noise_dimensions
+      im = Noise.new(100, 200, :components => 1, :color_model => :GRAYSCALE)
+      assert_image_dimensions(im, 100, 200)
+    end
+  end
+end

data/test/test_image.rb

@@ -0,0 +1,61 @@
+require 'helper'
+require 'tempfile'
+
+module Axon
+  class TestImage < AxonTestCase
+    def setup
+      super
+      io = StringIO.new
+      JPEG.write(Solid.new(10, 20), io)
+      @jpeg_data = io.string
+
+      io = StringIO.new
+      PNG.write(Solid.new(10, 20), io)
+      @png_data = io.string
+    end
+
+    def test_jpeg_helper_io
+      image = Axon.jpeg(StringIO.new(@jpeg_data))
+      assert_image_dimensions(image, 10, 20)
+    end
+
+    def test_jpeg_helper_stringdata
+      image = Axon.jpeg(@jpeg_data)
+      assert_image_dimensions(image, 10, 20)
+    end
+
+    def test_png_helper_io
+      image = Axon.png(StringIO.new(@png_data))
+      assert_image_dimensions(image, 10, 20)
+    end
+
+    def test_jpeg_helper_stringdata
+      image = Axon.png(@png_data)
+      assert_image_dimensions(image, 10, 20)
+    end
+
+    def test_bilinear
+      image = Axon.jpeg(@jpeg_data)
+      image.scale_bilinear(50, 75)
+      assert_image_dimensions(image, 50, 75)
+    end
+
+    def test_nearest
+      image = Axon.jpeg(@jpeg_data)
+      image.scale_nearest(50, 75)
+      assert_image_dimensions(image, 50, 75)
+    end
+
+    def test_fit
+      image = Axon.jpeg(@jpeg_data)
+      image.fit(50, 80)
+      assert_image_dimensions(image, 40, 80)
+    end
+
+    def test_crop
+      image = Axon.jpeg(@jpeg_data)
+      image.crop(5, 10, 6, 2)
+      assert_image_dimensions(image, 4, 10)
+    end
+  end
+end