imogen 0.1.9 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f78baebd0825df57e7ddeea7a7ca02c95a9c2c064c264532a911b12e72d289ad
-  data.tar.gz: c2d64e9187fa67bf65c6be9eb256cd430155609b4e5c8a0f2d5a48742fc87ceb
+  metadata.gz: 4b23125bf531a9a524f745c2ff9ffed4e3bd2e1aedf26dbdcd07434c0df9bbc0
+  data.tar.gz: 70b706da9db53e41b691eda24c70b8211cce3073cd99eae77a4045dad7dd0bab
 SHA512:
-  metadata.gz: 72f13fe92f9dc14fb61131218d84eb6516dab1a3737839e7377f717d0badee2ffe0bd8b57bb0c6fb6ba056bf2ad151c910296d09f1943e20bcaf96621c1db20d
-  data.tar.gz: 9eb6bd80a0dfa8d797a39267d805acde74e7ac33fe9395556db2d143396fe7aef0dd2603b9fd8df58b4b2d519adf24019b82113cf7506fca867a53eeb43404c4
+  metadata.gz: fa4d10b1e6aa9a00b72d73daa4796b2ffcd72bde1bfcb8dc36443bfc3f8d82d72a86abff0e1a4f8e6150d17b959c5670bc6868e83a6a40906b40b56fa1e24786
+  data.tar.gz: f5e43a5c25d37b0b99b0578216169d0cb0deabc5598c46bd21f50cbc546ac38250f3b658609d34751006696c10652399453a2537c12d72e710a515cafa7c5145

data/lib/imogen/auto_crop.rb

@@ -1,18 +1,8 @@
 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
     end
   end

data/lib/imogen/iiif/region.rb

@@ -1,5 +1,4 @@
 #!ruby
-
 module Imogen
 module Iiif
 class Region < Transform
@@ -45,10 +44,55 @@ class Region < Transform
       yield img
     else
       if edges == :featured
-        frame = Imogen::AutoCrop::Edges.new(img)
-        edges = frame.get([img.width, img.height,768].min)
+        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
+    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
-      img.copy(*edges) {|crop| yield crop}
     end
   end
 end

data/lib/imogen/iiif/rotation.rb

@@ -1,24 +1,27 @@
 module Imogen
-module Iiif
-class Rotation < Transform
-  RIGHT_ANGLES = [0,90,180,270]
-  def get(rotate)
-    return nil if [nil, 0, '0'].include?(rotate)
-    raise BadRequest.new("bad rotate #{rotate}") unless rotate.to_s =~ /^-?\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
+  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
   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/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)); yield result if block_given?}
-              else
-                quality.convert_to_8bits {|result| dst.save(result, format, (format == :jp2 ? 8 : 0)); yield result if block_given?}
-              end
+              quality.write_to_file(dest_path)
+              yield quality if block_given?
             end
           end
         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/lib/imogen.rb

@@ -1,108 +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
-require 'imogencv'

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_rotate_spec.rb

@@ -1,35 +1,41 @@
 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 '0' or nil" do
-        expect(subject.get(0)).to be_nil
-        expect(subject.get(360)).to be_nil
-        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("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("-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
@@ -41,4 +47,31 @@ describe Imogen::Iiif::Rotation, type: :unit do
       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

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: imogen
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.2
 platform: ruby
 authors:
 - Ben Armintor
-autorequire: 
+- Eric O'Hanlon
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 2022-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rice
+  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:
     - - ">="
@@ -39,32 +40,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: 
+        version: '3.9'
+description:
 email: armintor@gmail.com
 executables: []
-extensions:
-- ext/imogencv/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
-- ext/imogencv/extconf.rb
-- ext/imogencv/imogencv.cpp
 - 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
@@ -73,6 +69,9 @@ files:
 - 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
@@ -82,7 +81,7 @@ files:
 homepage: https://github.com/cul/imogen
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,8 +96,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.32
+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: []

data/ext/imogencv/extconf.rb

@@ -1,99 +0,0 @@
-require 'mkmf-rice'
-
-osx = RbConfig::CONFIG['target_os'] =~ /darwin/
-
-if osx
-	$CFLAGS << " -x c++ -std=c++14"# damn the torpedoes!
-else
-	$CFLAGS << " -x c++"
-end
-
-def real_inc_dir(src)
-	 File.symlink?(src) ? File.realdirpath(src) : src
-end
-
-def add_flags_if_header(header, header_dir, lib_dir)
-	a_file = File.join(header_dir, header)
-	exists = File.exist?(a_file)
-	puts "#{a_file} exists ... #{exists}"
-	if exists
-		inc_opt = "-I#{header_dir}".quote
-		lib_opt = "-L#{lib_dir}".quote
-		puts "adding compiler flags:\n#{inc_opt}\n#{lib_opt}"
-		$INCFLAGS << " " << inc_opt
-		$LIBPATH = $LIBPATH | [lib_dir]
-	end
-	exists
-end
-
-incdir_default = "/usr/local/include"
-libdir_default = "/usr/local/lib"
-
-have_library('stdc++')
-# MakeMakefile::CONFTEST_C = "#{CONFTEST}.cc"
-
-required_headers = {}
-required_libs = {}
-
-required_headers['opencv4'] = [ 'opencv2/features2d.hpp' ]
-required_libs['opencv4'] = [
-	'opencv_core',
-	'opencv_imgcodecs',
-	'opencv_imgproc',
-	'opencv_features2d'
-]
-
-required_libs['zlib'] = ['z']
-required_libs['libwebp'] = ['webp']
-required_libs['libjpeg'] = ['jpeg']
-required_libs['libtiff-4'] = ['tiff']
-required_libs['libpng'] = ['png16']
-required_libs['jasper'] = [] # just run pkg-config if you can
-required_libs['OpenEXR'] = ['IlmImf']
-
-all_deps = (required_libs.keys | required_headers.keys).sort.uniq
-all_deps.each do |dep_key|
-	has_pkg_config = (pkg_config(dep_key) || []).detect { |c| c =~ /\-L\/\w+/ }
-
-	# expect to call with --with-opencv4-include=DIR and --with-opencv4-lib=DIR or --withopencv4-dir=DIR
-	incdir, libdir = dir_config(dep_key, incdir_default, libdir_default) unless has_pkg_config
-
-	unless !has_pkg_config && incdir && incdir != incdir_default
-		puts "using default #{dep_key} include path: #{incdir_default}"
-	end
-
-	unless !has_pkg_config && libdir && libdir != libdir_default
-		puts "using default #{dep_key} library path: #{libdir_default}"
-	end
-
-	include_paths = [incdir_default, "/usr/local"]
-	include_paths = ([incdir, File.join(incdir, dep_key)] | include_paths) if incdir
-
-	required_headers.fetch(dep_key, []).each do |hdr|
-		unless find_header(hdr, *include_paths.compact.uniq)
-			open(MakeMakefile::Logging.instance_variable_get(:@logfile), 'r') do |logblob|
-				logblob.each { |logline| puts logline.strip }
-			end
-			puts "Cannot find required header: #{hdr}"
-			puts "if this output is from rake compile, consider adding:"
-			puts "rake compile -- --with#{dep_key}-include=DIR"
-			exit 1
-		end
-	end
-
-	lib_paths = [libdir_default, "/usr/local"]
-	lib_paths.unshift(libdir) if libdir
-
-	required_libs.fetch(dep_key, []).each do |lib|
-		unless find_library(lib, nil, *lib_paths.compact.uniq)
-			puts "Cannot find required lib: #{lib}"
-			exit 1
-		end
-	end
-	append_cflags(lib_paths.compact.uniq.map {|x| "-L#{x}"}.join(' '))
-end
-
-append_cflags('-stdlib=libc++')
-@libdir_basename ||= 'lib'
-$LIBRUBYARG.prepend(' ') # there's some weird spacing issue in rice's lib linking routine
-create_makefile('imogencv')

data/ext/imogencv/imogencv.cpp

@@ -1,87 +0,0 @@
-#include "rice/Class.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/Enum.hpp"
-#include "opencv2/features2d.hpp"
-#include "opencv2/imgproc.hpp"
-#include "opencv2/imgcodecs.hpp"
-
-using namespace Rice;
-
-Object process_kaze_features(Object r_image)
-{
-	cv::Mat image = from_ruby<cv::Mat>(r_image);
-	std::vector<cv::KeyPoint> keyPoints;
-	cv::Ptr<cv::KAZE> alg = cv::KAZE::create();
-	cv::Mat features;
-	alg->detectAndCompute(image, cv::noArray(), keyPoints, features);
-	Array a;
-	for(cv::KeyPoint keyPoint : keyPoints)
-	{
-		a.push(to_ruby<cv::Point2f>(keyPoint.pt));
-	}
-	keyPoints.clear();
-	return a;
-}
-
-Object load_grayscale(Object filename)
-{
-	Check_Type(filename, T_STRING);
-	cv::String const c_path = cv::String(String(filename).str());
-	cv::Mat image = imread(c_path, cv::IMREAD_GRAYSCALE);
-	return to_ruby<cv::Mat>(image);
-}
-
-Object point2f_x(Object self)
-{
-	cv::Point2f point = from_ruby<cv::Point2f>(self);
-	return to_ruby<int>(point.x);
-}
-
-Object point2f_y(Object self)
-{
-	cv::Point2f point = from_ruby<cv::Point2f>(self);
-	return to_ruby<int>(point.y);
-}
-
-Object mat_cols(Object self)
-{
-	cv::Mat image = from_ruby<cv::Mat>(self);
-	return to_ruby<int>(image.cols);
-}
-
-Object mat_rows(Object self)
-{
-	cv::Mat image = from_ruby<cv::Mat>(self);
-	return to_ruby<int>(image.rows);
-}
-
-Object mat_good_features_to_track(Object self, int maxCorners, double qualityLevel, double minDistance, int blockSize, bool useHarrisDetector, double k)
-{
-	cv::Mat image = from_ruby<cv::Mat>(self);
-	cv::Mat mask;
-	std::vector<cv::Point2f> corners;
-	cv::goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance, mask, blockSize, useHarrisDetector, k);
-	Array a;
-	for(cv::Point2f corner : corners)
-	{
-		a.push(to_ruby<cv::Point2f>(corner));
-	}
-	corners.clear();
-	return a;
-}
-
-extern "C"
-void Init_imogencv()
-{
-	Module rb_mOpenCV = define_module("ImogenCV");
-	Class rb_cKazeFeatures = rb_mOpenCV.define_class("KazeFeatures");
-	rb_cKazeFeatures.define_singleton_method("process", &process_kaze_features);
-	Data_Type<cv::Mat> rb_cMat = rb_mOpenCV.define_class<cv::Mat>("Mat")
-		.define_method(Identifier("cols"), &mat_cols)
-		.define_method(Identifier("rows"), &mat_rows)
-		.define_method("good_features_to_track", &mat_good_features_to_track)
-		.define_singleton_method("load_grayscale", &load_grayscale);
-	Data_Type<cv::Point2f> rb_cPoint2f = rb_mOpenCV.define_class<cv::Point2f>("Point2f")
-		.define_method(Identifier("x"), &point2f_x)
-		.define_method(Identifier("y"), &point2f_y);
-}

data/lib/imogen/auto_crop/box.rb

@@ -1,93 +0,0 @@
-#!ruby
-require 'imogencv'
-module Imogen::AutoCrop::Box
-  include ImogenCV
-  class Best
-    def initialize(grayscale)
-      # mat_good_features_to_track(std::int maxCorners, std::double qualityLevel, std:double minDistance, std::int blockSize, std::bool useHarrisDetector, std::double k)
-      @corners = grayscale.good_features_to_track(20, 0.3, 1.0, 3, false, 0.04)
-      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? ImogenCV::Mat
-      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 'imogencv'
-require 'free-image'
-require 'tempfile'
-
-module Imogen::AutoCrop
-  class Edges
-    include ImogenCV
-    def initialize(src)
-      @xoffset = 0
-      @yoffset = 0
-      tempfile = nil
-      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 = ImogenCV::Mat.load_grayscale(tempfile.path)
-      @xrange = (0..@grayscale.cols)
-      @yrange = (0..@grayscale.rows)
-    ensure
-      tempfile.unlink if tempfile
-    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
-  end
-end