imogen 0.1.6 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1910c699380fcfbe8d180baf1c7ef25bbf521eba
-  data.tar.gz: 0ff96a7186b1265d68cfe02fded732efe37daa14
+SHA256:
+  metadata.gz: 92c92a32465d8ae59f5e40a31c0ffd3cc2de271a3593db0dac7da1bd2954dd31
+  data.tar.gz: 044b86d16c8c028d36864e3aa550b6aa871d9075c5d4223b198ca1ac59b511f2
 SHA512:
-  metadata.gz: 89d7cccae25fe76829cee9e1a73877fe8637963723ec6c4b48659956bfb61b655e383daefa23e1b2e930ee88e60af80adf52068d6d281e2e845ccf31d0dbcc10
-  data.tar.gz: be16bfdbd8fe83c64c0a6dabfc759e1af3a986aed72428f50cf62bb8c622a06b69db1bcbd49857fea375228f616b5d7d6e8f019083ac515ac1dcda3f7f2284eb
+  metadata.gz: dc4ae61808bb12ad97f4f3a279aa81fd048b20626422358ccfc64ed1c5706d221a97195a0807dcd882c32dbfbd8ced6fba06bfe9e361ae61abfd6a1a38aed5a2
+  data.tar.gz: d416dd8390d144135bf5d1e4d9dc5445d0f137a6e64ce097aef8fe2e5f895214a18a4f5fd064f874ead2928db969b5dbc92fbe5a86ac20c244e199c6bca93757

data/lib/imogen.rb

@@ -1,107 +1,35 @@
 # encoding: UTF-8
-require 'ffi'
-require 'rbconfig'
-require 'free-image'
+require 'vips'
 module Imogen
 
   def self.from(src_path)
-    FreeImage::Bitmap.open(src_path) do |img|
-      yield img
-    end
+    yield Vips::Image.matload(src_path)
   end
   module Scaled
     def self.convert(img, dest_path, scale=1500, format = :jpeg)
       w = img.width
       h = img.height
       dims = (w > h) ? [scale, scale*h/w] : [scale*w/h, scale]
-      img.rescale(dims[0], dims[1]) do |scaled|
-        scaled = (scaled.color_type == :rgb) ?  scaled.convert_to_24bits : scaled.convert_to_8bits
-        dst = FreeImage::File.new(dest_path)
-        dst.save(scaled, format)
-        scaled.free
-      end
+      img.thumbnail_image(dims[0], height: dims[1]).write_to_file(dest_path)
     end
   end
   module Cropped
     def self.convert(img, dest_path, edges, scale=nil, format=:jpeg)
+      img.crop(*edges).write_to_file(dest_path)
     end
   end
   require 'imogen/auto_crop'
   require 'imogen/zoomable'
   require 'imogen/iiif'
 
-  def self.search_paths
-    @search_paths ||= begin
-      if ENV['FREE_IMAGE_LIBRARY_PATH']
-        [ ENV['FREE_IMAGE_LIBRARY_PATH'] ]
-      elsif FFI::Platform::IS_WINDOWS
-        ENV['PATH'].split(File::PATH_SEPARATOR)
-      else
-        [ '/usr/local/{lib64,lib32,lib}', '/opt/local/{lib64,lib32,lib}', '/usr/{lib64,lib32,lib}' ]
-      end
-    end
-  end
-
-  def self.find_lib(lib)
-    files = search_paths.inject(Array.new) do |array, path|
-      file_name = File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}"))
-      array << Dir.glob(file_name)
-      array
-    end
-    files.flatten.compact.first
-  end
-
-  def self.free_image_library_paths
-    @free_image_library_paths ||= begin
-      libs = %w{libfreeimage libfreeimage.3 FreeImage}
-
-      libs.map do |lib|
-        find_lib(lib)
-      end.compact
-    end
-  end
-
-  extend ::FFI::Library
-
-  if free_image_library_paths.any?
-    ffi_lib(*free_image_library_paths)
-  elsif FFI::Platform.windows?
-    ffi_lib("FreeImaged")
-  else
-    ffi_lib("freeimage")
-  end
-
-  ffi_convention :stdcall if FFI::Platform.windows?
-
   def self.format_from(image_path)
-    result = FreeImage.FreeImage_GetFileType(image_path, 0)
-    FreeImage.check_last_error
-
-    if result == :unknown
-      # Try to guess the file format from the file extension
-      result = FreeImage.FreeImage_GetFIFFromFilename(image_path)
-      FreeImage.check_last_error
-    end
-    result
+    raise "format from path not implemented"
   end
 
   def self.image(src_path, flags=0)
-
-    fif = format_from(src_path)
-    if ((fif != :unknown) and FreeImage.FreeImage_FIFSupportsReading(fif))
-      ptr = FreeImage.FreeImage_Load(fif, src_path, flags)
-      FreeImage.check_last_error(ptr)
-      return FreeImage::Bitmap.new(ptr, nil)
-    end
-    return nil
+    Vips::Image.new_from_file(src_path)
   end
   def self.with_image(src_path, flags = 0, &block)
-
-    fif = format_from(src_path)
-    if ((fif != :unknown) and FreeImage.FreeImage_FIFSupportsReading(fif))
-      ptr = FreeImage.FreeImage_Load(fif, src_path, flags)
-      FreeImage.check_last_error(ptr)
-      FreeImage::Bitmap.new(ptr, nil, &block)
-    end
+    block.yield(image(src_path, flags))
   end
-end
+end

data/lib/imogen/auto_crop.rb

@@ -1,20 +1,9 @@
 module Imogen
   module AutoCrop
-    autoload :Edges, 'imogen/auto_crop/edges'
-    autoload :Box, 'imogen/auto_crop/box'
-    def self.convert(img, dest_path, scale=768, format=:jpeg)
-      frame = Edges.new(img)
-      edges = frame.get(scale)
-      img.copy(*edges) do |crop|
-        crop.rescale(scale, scale) do |thumb|
-          dst = FreeImage::File.new(dest_path)
-          t24 = (crop.color_type == :rgb) ?  thumb.convert_to_24bits : thumb.convert_to_8bits
-          dst.save(t24, format)
-          t24.free
-          thumb.free
-        end
+    def self.convert(img, dest_path, scale=768, opts = {})
+      Imogen::Iiif::Region::Featured.convert(img, scale, opts) do |smartcrop|
+        smartcrop.write_to_file(dest_path)
       end
-      frame.unlink
     end
   end
-end
+end

data/lib/imogen/iiif.rb

@@ -30,9 +30,9 @@ module Imogen
       def self.convert(img, quality)
         q = get(quality)
         if q == :grey
-          img.convert_to_greyscale {|c| yield c}
+          yield img.copy(interpretation: :b_w)
         elsif q == :bitonal
-          img.threshold(128) {|c| yield c}
+          yield img.copy(interpretation: :b_w) > 128
         else
           yield img
         end
@@ -53,13 +53,8 @@ module Imogen
         Size.convert(region, opts[:size]) do |size|
           Rotation.convert(size, opts[:rotation]) do |rotation|
             Quality.convert(rotation, opts[:quality]) do |quality|
-              dst = FreeImage::File.new(dest_path)
-              format = :jpeg if format == :jpg
-              if (img.color_type == :rgb)
-                quality.convert_to_24bits {|result| dst.save(result, format, (format == :jp2 ? 8 : 0))}
-              else
-                quality.convert_to_8bits {|result| dst.save(result, format, (format == :jp2 ? 8 : 0))}
-              end
+              quality.write_to_file(dest_path)
+              yield quality if block_given?
             end
           end
         end

data/lib/imogen/iiif/region.rb

@@ -1,5 +1,4 @@
 #!ruby
-
 module Imogen
 module Iiif
 class Region < Transform
@@ -36,9 +35,6 @@ class Region < Transform
     end
     if (e[0] > @width or e[1] > @height)
       raise BadRequest.new("Invalid region (disjoint): #{region}")
-    end      
-    if (e[2]) * (e[3]) < 100
-      raise BadRequest.new("Region too small: #{region}")
     end
     return e
   end
@@ -48,16 +44,57 @@ class Region < Transform
       yield img
     else
       if edges == :featured
-        frame = Imogen::AutoCrop::Edges.new(img)
-        begin
-          edges = frame.get([img.width, img.height,768].min)
-        ensure
-          frame.unlink
-        end
+        side = [img.width, img.height,768].min
+        Featured.convert(img, side) { |x| yield x }
+      else
+        # edges are leftX, topY, rightX, bottomY
+        # Vips wants left, top, width, height
+        yield img.extract_area(edges[0], edges[1], edges[2] - edges[0], edges[3] - edges[1])
       end
-      img.copy(*edges) {|crop| yield crop}
     end
   end
+  class Featured < Transform
+    SQUARISH = 5.to_f / 6
+    ONE_THIRD = 1.to_f / 3
+    def self.convert(img, scale = 768, opts = {})
+      middle_dims = [(img.width * 2 * ONE_THIRD).floor, (img.height * 2 * ONE_THIRD).floor]
+      x_offset = (img.width * ONE_THIRD/2).floor
+      y_offset = (img.height * ONE_THIRD/2).floor
+      crop_scale = middle_dims.min
+      smart_crop_opts = {interesting: (squarish?(img) ? :centre : :entropy)}.merge(opts)
+      window = img.extract_area(x_offset, y_offset, middle_dims[0], middle_dims[1])
+      smartcrop = window.smartcrop(crop_scale, crop_scale, smart_crop_opts)
+      # Vips counts with negative offsets from left and top
+      yield smartcrop.thumbnail_image(scale, height: scale)
+    end
+
+    # returns leftX, topY, rightX, bottomY
+    def self.get(img, scale = 768, opts = {})
+      middle_dims = [(img.width * 2 * ONE_THIRD).floor, (img.height * 2 * ONE_THIRD).floor]
+      x_offset = (img.width * ONE_THIRD/2).floor
+      y_offset = (img.height * ONE_THIRD/2).floor
+      crop_scale = middle_dims.min
+      smart_crop_opts = {interesting: (squarish?(img) ? :centre : :entropy)}.merge(opts)
+      window = img.extract_area(x_offset, y_offset, middle_dims[0], middle_dims[1])
+      smartcrop = window.smartcrop(crop_scale, crop_scale, smart_crop_opts)
+      # Vips counts with negative offsets from left and top
+      left = (window.xoffset + smartcrop.xoffset)*-1
+      top = (window.yoffset + smartcrop.yoffset)*-1
+      right = left + smartcrop.width
+      bottom = top + smartcrop.height
+      return [left, top, right, bottom]
+    end
+
+    def self.squarish?(img)
+      if img.is_a? Vips::Image
+        dims = [img.width, img.height]
+        ratio = dims.min.to_f / dims.max
+        return ratio >= Featured::SQUARISH
+      else
+        raise "#{img.class.name} is not a Vips::Image"
+      end
+    end
+  end
+end
 end
 end
-end

data/lib/imogen/iiif/rotation.rb

@@ -1,26 +1,27 @@
 module Imogen
-module Iiif
-class Rotation < Transform
-  RIGHT_ANGLES = [0,90,180,270]
-  def get(rotate)
-    if rotate.nil? or rotate.eql? '0'
-      return nil
+  module Iiif
+    class Rotation < Transform
+      RIGHT_ANGLES = [0,90,180,270]
+      def get(rotate)
+        return [0, false] if rotate.nil?
+        original_rotate_value = rotate
+        rotate = rotate.to_s
+        raise BadRequest.new("bad rotate #{original_rotate_value}") unless rotate =~ /^!?-?\d+$/
+        flip = rotate.to_s.start_with?('!')
+        # libvips and IIIF spec counts clockwise
+        angle = rotate.sub(/^!/, '').to_i % 360
+        raise BadRequest.new("bad rotate #{original_rotate_value}") unless RIGHT_ANGLES.include?(angle)
+        return angle, flip
+      end
+
+      def self.convert(img, rotate)
+        angle, flip = Rotation.new(img).get(rotate)
+        # IIIF spec applies horizontal flip ("mirrored by reflection on the vertical axis") before rotation
+        img = img.fliphor if flip
+        # No need to rotate if angle is zero
+        img = img.rot("d#{angle}") unless angle.zero?
+        yield img
+      end
     end
-    raise BadRequest.new("bad rotate #{rotate}") unless rotate =~ /^-?\d+$/
-    # negate offset because IIIF spec counts clockwise, FreeImage counterclockwise
-    r = (rotate.to_i * -1) % 360
-    r = r + 360 if r < 0
-    raise BadRequest.new("bad rotate #{rotate}") unless RIGHT_ANGLES.include? r
-    return r > 0 ? r : nil
   end
-  def self.convert(img, rotate)
-    rotation = Rotation.new(img).get(rotate)
-    if rotation
-      img.rotate(rotation) {|crop| yield crop}
-    else
-      yield img
-    end
-  end
-end
 end
-end

data/lib/imogen/iiif/size.rb

@@ -35,7 +35,7 @@ class Size < Transform
   def self.convert(img, size)
     dims = Size.new(img).get(size)
     if dims
-      img.rescale(*dims) {|crop| yield crop}
+      yield img.thumbnail_image(dims[0], height: dims[1])
     else
       yield img
     end

data/lib/imogen/zoomable.rb

@@ -12,8 +12,7 @@ module Imogen
       return Math.log2(dims[0..1].max.to_f / tile_size).ceil
     end
     def self.convert(img, dest_path)
-      dst = FreeImage::File.new(dest_path)
-			dst.save(img, :jp2, 8)
+      raise "jp2 output conversion not implemented"
     end
   end
 end

data/spec/integration/imogen_autocrop_spec.rb

@@ -0,0 +1,17 @@
+require 'imogen'
+require 'tmpdir'
+
+describe Imogen::AutoCrop, vips: true do
+  describe "#convert" do
+    let(:output_file) { Dir.tmpdir + '/test-imogen-crop.jpg' }
+    it "should successfully convert the image" do
+      Imogen.with_image(fixture('sample.jpg').path) do |img|
+        Imogen::AutoCrop.convert(img, output_file, 150)
+      end
+      expect(File.exist?(output_file)).to be true
+      expect(File.size?(output_file)).to be > 0
+    ensure
+      File.delete(output_file) if File.exist?(output_file)
+    end
+  end
+end

data/spec/integration/imogen_iiif_spec.rb

@@ -0,0 +1,17 @@
+require 'imogen'
+require 'tmpdir'
+
+describe Imogen::AutoCrop, vips: true do
+  describe "#convert" do
+    let(:output_file) { Dir.tmpdir + '/test-imogen-convert.jpg' }
+    it "should successfully convert the image" do
+      Imogen.with_image(fixture('sample.jpg').path) do |img|
+        Imogen::Iiif.convert(img, output_file, 'jpg', region: '50,60,500,800', size: '!100,100', quality: 'color', rotation: '!90')
+      end
+      expect(File.exist?(output_file)).to be true
+      expect(File.size?(output_file)).to be > 0
+    ensure
+      File.delete(output_file) if File.exist?(output_file)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,104 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+end
+
 class ImageStub
   attr_reader :width, :height
   def initialize(width,height)
@@ -5,3 +106,13 @@ class ImageStub
     @height = height
   end
 end
+
+def absolute_fixture_path(file)
+  File.realpath(File.join(File.dirname(__FILE__), '..','spec','fixtures', 'files', file))
+end
+
+def fixture(file)
+  path = absolute_fixture_path(file)
+  raise "No fixture file at #{path}" unless File.exist? path
+  File.new(path)
+end

data/spec/unit/imogen_iiif_region_spec.rb

@@ -18,6 +18,8 @@ describe Imogen::Iiif::Region, type: :unit do
     describe "with an absolute region" do
       it "should calculate a contained region" do
         expect(subject.get("80,15,60,75")).to eql([80,15,140,90])
+        # small regions are the application's concern
+        expect(subject.get("1,2,3,4")).to eql([1,2,4,6])
       end
       it "should reject zero-dimension boxes" do
         expect{subject.get("101,15,0,15")}.to raise_error Imogen::Iiif::BadRequest

data/spec/unit/imogen_iiif_rotate_spec.rb

@@ -1,39 +1,77 @@
 require 'imogen/iiif'
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Imogen::Iiif::Rotation, type: :unit do
-  before(:all) do
-    @test_image = ImageStub.new(175,131)
-  end
-  subject {Imogen::Iiif::Rotation.new(@test_image)}
+  let(:image) { double("image", width: 175, height: 131) }
   describe "#get" do
+    subject { Imogen::Iiif::Rotation.new(image) }
     describe "with values mod 360 in 90 degree rotations" do
-      it "should nil for 0 or nil" do
-        expect(subject.get("360")).to be_nil
-        expect(subject.get("-360")).to be_nil
-        expect(subject.get("0")).to be_nil
-        expect(subject.get(nil)).to be_nil
+      it "should return [0, false] angle and flip for 0 or '0' or nil" do
+        expect(subject.get(0)).to eq([0, false])
+        expect(subject.get(360)).to eq([0, false])
+        expect(subject.get("360")).to eq([0, false])
+        expect(subject.get("-360")).to eq([0, false])
+        expect(subject.get("0")).to eq([0, false])
+        expect(subject.get(nil)).to eq([0, false])
+      end
+      it "should return the expected angle and flip for positive values" do
+        expect(subject.get(90)).to eql([90, false])
+        expect(subject.get("90")).to eql([90, false])
+        expect(subject.get("180")).to eql([180, false])
+        expect(subject.get("270")).to eql([270, false])
+        expect(subject.get("450")).to eql([90, false])
       end
-      # IIIF rotation is opposite FreeImage
-      it "should calculate for positive values" do
-        expect(subject.get("90")).to eql(270)
-        expect(subject.get("180")).to eql(180)
-        expect(subject.get("270")).to eql(90)
-        expect(subject.get("450")).to eql(270)
+      it "should return the expected angle and flip for negative values" do
+        expect(subject.get(-90)).to eql([270, false])
+        expect(subject.get("-90")).to eql([270, false])
+        expect(subject.get("-180")).to eql([180, false])
+        expect(subject.get("-270")).to eql([90, false])
+        expect(subject.get("-450")).to eql([270, false])
       end
-      # IIIF rotation is opposite FreeImage
-      it "should calculate for negative values" do
-        expect(subject.get("-90")).to eql(90)
-        expect(subject.get("-180")).to eql(180)
-        expect(subject.get("-270")).to eql(270)
-        expect(subject.get("-450")).to eql(90)
+      it "should return the expected angle and flip for string values that start with an exclamation point" do
+        expect(subject.get("!0")).to eql([0, true])
+        expect(subject.get("!90")).to eql([90, true])
+        expect(subject.get("!180")).to eql([180, true])
+        expect(subject.get("!270")).to eql([270, true])
+        expect(subject.get("!-90")).to eql([270, true])
+        expect(subject.get("!-180")).to eql([180, true])
+        expect(subject.get("!-270")).to eql([90, true])
+        expect(subject.get("!-450")).to eql([270, true])
       end
     end
     it "should reject arbitrary integer and float values" do
-        expect{subject.get("2")}.to raise_error Imogen::Iiif::BadRequest
-        expect{subject.get("90.0")}.to raise_error Imogen::Iiif::BadRequest
+      expect{subject.get(2)}.to raise_error Imogen::Iiif::BadRequest
+      expect{subject.get("2")}.to raise_error Imogen::Iiif::BadRequest
+      expect{subject.get("90.0")}.to raise_error Imogen::Iiif::BadRequest
     end
     it "should reject bad values" do
-        expect{subject.get("-2,")}.to raise_error Imogen::Iiif::BadRequest
+      expect{subject.get("-2,")}.to raise_error Imogen::Iiif::BadRequest
+    end
+  end
+  describe '.convert' do
+    let(:no_op) { Proc.new {|x| x} }
+    context 'at multiple of 360' do
+      it "does not rotate" do
+        expect(image).not_to receive(:rot)
+        expect(image).not_to receive(:fliphor)
+        (-2..2).each { |x| described_class.convert(image, (x*360).to_s, &no_op) }
+      end
+    end
+    context 'at right angle rotations not multiple of 360' do
+      it "does rotate" do
+        expect(image).not_to receive(:fliphor)
+        [-3, -2, -1, 1, 2, 3].each do |x|
+          tuple = Imogen::Iiif::Rotation.new(image).get((90*x).to_s)
+          param = "d#{tuple[0]}"
+          expect(image).to receive(:rot).with(param)
+          described_class.convert(image, (x*90).to_s, &no_op)
+        end
+      end
+    end
+    context 'with a bang param' do
+      it "flips horizontal" do
+        expect(image).to receive(:fliphor)
+        described_class.convert(image, "!0", &no_op)
+      end
     end
   end
-end
+end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: imogen
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.1
 platform: ruby
 authors:
 - Ben Armintor
-autorequire: 
+- Eric O'Hanlon
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2021-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby-opencv
+  name: ruby-vips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +26,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,7 +39,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description:
 email: armintor@gmail.com
 executables: []
 extensions: []
@@ -46,8 +61,6 @@ extra_rdoc_files: []
 files:
 - lib/imogen.rb
 - lib/imogen/auto_crop.rb
-- lib/imogen/auto_crop/box.rb
-- lib/imogen/auto_crop/edges.rb
 - lib/imogen/dzi.rb
 - lib/imogen/iiif.rb
 - lib/imogen/iiif/region.rb
@@ -55,6 +68,10 @@ files:
 - lib/imogen/iiif/size.rb
 - lib/imogen/iiif/tiles.rb
 - lib/imogen/zoomable.rb
+- lib/imogencv.bundle
+- spec/fixtures/files/sample.jpg
+- spec/integration/imogen_autocrop_spec.rb
+- spec/integration/imogen_iiif_spec.rb
 - spec/spec_helper.rb
 - spec/unit/imogen_iiif_quality_spec.rb
 - spec/unit/imogen_iiif_region_spec.rb
@@ -64,7 +81,7 @@ files:
 homepage: https://github.com/cul/imogen
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -79,10 +96,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.3
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
-summary: derivative generation via FreeImage and smart square thumbnail via OpenCV
+summary: IIIF image derivative generation helpers for Vips
 test_files: []
-has_rdoc: 

data/lib/imogen/auto_crop/box.rb

@@ -1,92 +0,0 @@
-#!ruby
-require 'opencv'
-module Imogen::AutoCrop::Box
-  include OpenCV
-  class Best
-    def initialize(grayscale)
-      @corners = grayscale.good_features_to_track(0.3, 1.0, block_size: 3, max: 20)
-      if @corners.nil? or @corners.length == 0
-        @center = Center.new(grayscale)
-      else
-        @center = nil
-      end
-    end
-
-    def self.distance(p1, p2)
-      dx = p1.x.to_i - p2.x.to_i
-      dy = p1.y.to_i - p2.y.to_i
-      return Math.sqrt((dx * dx) + (dy * dy)) 
-    end
-
-    def box()
-      return @center.box unless @center.nil?
-      c = median()
-      cp = BoxInfo.new(c[0], c[1],0)
-      total_distance = 0;
-      features = @corners.collect {|corner| d = Best.distance(corner, cp); total_distance += d; {x: corner.x, y: corner.y, d: d}}
-      mean_distance = total_distance/features.length
-      sigma = features.inject(0) {|memo, feature| v = feature[:d] - mean_distance; memo += (v*v)}
-      sigma = Math.sqrt(sigma.to_f/features.length)
-      # 2 sigmas would capture > 95% of normally distributed features
-      cp.radius = 2*sigma
-      cp
-    end
-
-    def median()
-      @median ||= begin
-        xs = []
-        ys = []
-        @corners.each {|c| xs << c.x.to_i; ys << c.y.to_i}
-        xs.sort!
-        ys.sort!
-        ix = 0
-        if (@corners.length % 2 == 0)
-          l = (@corners.length == 2) ? 0 : (@corners.length/2)
-          x = ((xs[l] + xs[l+1]) /2).floor
-          y = ((ys[l] + ys[l+1]) /2).floor
-          [x,y]
-        else
-          r = (@corners.length/2).ceil
-          [xs[r], ys[r]]
-        end
-      end
-    end
-  end
-  class Center
-    def initialize(grayscale)
-      @center ||= [(grayscale.cols/2).floor, (grayscale.rows/2).floor]
-      @radius = @center.min
-      @ratio = @radius / @center.max
-    end
-    def box
-      return BoxInfo.new(@center[0],@center[1],@radius)
-    end
-  end
-  class BoxInfo
-    attr_reader :x, :y
-    attr_accessor :radius
-    SQUARISH = 5.to_f / 6
-    def initialize(x,y,r)
-      @x = x
-      @y = y
-      @radius = r
-    end
-  end
-  def self.squarish?(img)
-    if img.is_a? FreeImage::Bitmap
-      dims = [img.width, img.height]
-      ratio = dims.min.to_f / dims.max
-      return ratio >= BoxInfo::SQUARISH
-    elsif img.is_a? OpenCV::CvMat
-      dims = [img.cols, img.rows]
-      ratio = dims.min.to_f / dims.max
-      return ratio >= BoxInfo::SQUARISH
-    else
-      raise "#{img.class.name} is not a FreeImage::Bitmap"
-    end
-  end
-  def self.info(grayscale)
-    dims = [grayscale.cols, grayscale.rows]
-    squarish?(grayscale) ? Center.new(grayscale).box() : Best.new(grayscale).box()
-  end
-end

data/lib/imogen/auto_crop/edges.rb

@@ -1,67 +0,0 @@
-#!ruby
-require 'opencv'
-require 'free-image'
-require 'tempfile'
-
-module Imogen::AutoCrop
-class Edges
-  include OpenCV
-  def initialize(src)
-    @xoffset = 0
-    @yoffset = 0
-    if src.is_a? FreeImage::Bitmap
-      img = src
-      @xoffset = img.width.to_f/6
-      @yoffset = img.height.to_f/6
-      if Imogen::AutoCrop::Box.squarish? img
-        @xoffset = @xoffset/2
-        @yoffset = @yoffset/2
-      end
-      @tempfile = Tempfile.new(['crop','.png'])
-
-      img.copy(@xoffset,@yoffset,img.width-@xoffset,img.height-@yoffset) do |crop|
-        crop.save(@tempfile.path, :png)
-        crop.free
-      end
-    else
-      raise src.class.name 
-    end
-    # use bigger features on bigger images
-    @grayscale = CvMat.load(@tempfile.path, CV_LOAD_IMAGE_GRAYSCALE)
-    @xrange = (0..@grayscale.cols)
-    @yrange = (0..@grayscale.rows)
-  end
-
-  def bound_min(center)
-    [center.x - @xrange.min, @xrange.max - center.x, center.y - @yrange.min, @yrange.max - center.y].min
-  end
-
-  # returns leftX, topY, rightX, bottomY
-  def get(*args)
-    c = Imogen::AutoCrop::Box.info(@grayscale)
-    r = c.radius.floor
-    # adjust the box
-    coords = [c.x, c.y]
-    min_rad = args.max/2
-    unless r >= min_rad && r <= bound_min(c)
-      # first adjust to the lesser of max (half short dimension) and min (half requested length) radius
-      # this might require upscaling in rare situations to preserve bound safety
-      r = min_rad if r < min_rad
-      max_rad = [@xrange.max - @xrange.min, @yrange.max - @yrange.min].min / 2
-      r = max_rad if r > max_rad
-      # now move the center point minimally to accomodate the necessary radius
-      coords[0] = @xrange.max - r if (coords[0] + r) > @xrange.max  
-      coords[0] = @xrange.min + r if (coords[0] - r) < @xrange.min  
-      coords[1] = @yrange.max - r if (coords[1] + r) > @yrange.max  
-      coords[1] = @yrange.min + r if (coords[1] - r) < @yrange.min  
-    end
-    coords = [coords[0] + @xoffset, coords[1] + @yoffset].collect {|i| i.floor}
-    c = coords
-
-    return [c[0]-r, c[1]-r, c[0]+r, c[1] + r]
-  end
-  def unlink
-    @tempfile.unlink
-  end
-end
-end