riiif 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9f72b481aa0760baf9a47f06e01a62f1e76ec2e
-  data.tar.gz: 4f903b470600ac688a2f0636f59c40898f7e22e2
+  metadata.gz: 2267ef01c3a2abbf3991710ef5c4c9f6ac55500c
+  data.tar.gz: 13fc80e6e72c789bac048f66fc020d8a0cb2e314
 SHA512:
-  metadata.gz: 870c2da826793ec753971ae9c677a57d57577d1eb65c7aa69a5f98acea2a3601f8f1e2290c8f7e4553fd99fcc1043a2d4e449d4c884c3def264695de313c7849
-  data.tar.gz: d998c2468c0779170a188a6bbd47ef843c86c7df45203fbd115fbe28346a64dc765064dcb682b22eb114d3ff732b373cfd795e26dda4fde66638820fdffab474
+  metadata.gz: 0d45589ca6d5e13de6d7a40a61b09c48e9d062118c1845d9fd786e7d8f5066980d9e1adb8d1a4b1df7b419a6729248fec8bc8ea6338d0e9216324a94d9cec7eb
+  data.tar.gz: 64600eb8e05f1f613b7a039ed6c25b36f5f87d75f1993b9dad667ae3eea9e47e5fe9b66200ef4a03f3fc96862e307cdc2adf936e69609206e02cd4014562553b

data/README.md

@@ -15,7 +15,32 @@ And then execute:
 Or install it yourself as:
 
     $ gem install riiif
+    
+## Configure
 
+### Images on the servers file system.
+
+By default Riiif is set to load images from the filesystem using the Riiif::FileSystemFileResolver. 
+You can configure how this resolver finds the files by setting this property:
+```
+    Riiif::FileSystemFileResolver.base_path = '/opt/repository/images/'
+```
+When the Id passed in is "foo_image", then it will look for an image file using this glob: 
+```
+/opt/repository/images/foo_image.{png,jpg,tiff,jp,jp2}
+```
+
+### Images retrieved over HTTP
+To source the images from the network instead of the file system, we first configure Riiif to use an alternative resolver:
+```
+      Riiif::Image.file_resolver = Riiif::HTTPFileResolver
+```
+Then we configure the resolver with a mechanism for mapping the provided id to a url:
+```
+      Riiif::HTTPFileResolver.id_to_uri = lambda do |id| 
+        "http://upload.wikimedia.org/wikipedia/commons/thumb/a/a4/#{id}.jpg/600px-#{id}.jpg"
+      end
+```
 ## Usage
 
 Mount the gem as an engine:

data/app/controllers/riiif/images_controller.rb

@@ -1,9 +1,35 @@
 module Riiif
   class ImagesController < ::ApplicationController
+    before_filter :link_header, only: [:show, :info]
     def show
       image = Image.new(params[:id])
       data = image.render(params.permit(:region, :size, :rotation, :quality, :format))
       send_data data, type: Mime::Type.lookup_by_extension(params[:format]), :disposition => 'inline'
     end
+
+    def info
+      image = Image.new(params[:id])
+      render json: image.info.merge(server_info)
+    end
+
+    def view
+      @image = Image.new(params[:id])
+    end
+
+    protected
+
+    def link_header
+      response.headers["Link"] = '<http://library.stanford.edu/iiif/image-api/1.1/compliance.html#level2>;rel="profile"'
+    end
+
+    def server_info
+      {
+        "@context" => "http://library.stanford.edu/iiif/image-api/1.1/context.json",
+        "@id" => request.original_url.sub('/info.json', ''), 
+        "formats" => Image::OUTPUT_FORMATS,
+        "profile" => "http://library.stanford.edu/iiif/image-api/1.1/compliance.html#level0"
+        
+      }
+    end
   end
 end

data/app/models/riiif/file.rb

@@ -0,0 +1,87 @@
+require 'open3'
+module Riiif
+  class File
+    include Open3
+    attr_reader :path
+    # @param input_path [String] The location of an image file
+    def initialize(input_path, tempfile = nil)
+      raise "HUH" if input_path.is_a? Riiif::File
+      @path = input_path
+      @tempfile = tempfile # ensures that the tempfile will stick around until this file is garbage collected.
+    end
+
+    def self.open(file_or_url, ext = nil)
+      file_or_url = file_or_url.to_s # Force it to be a String... hell or highwater
+      if file_or_url.include?("://")
+        require 'open-uri'
+        ext ||= ::File.extname(URI.parse(file_or_url).path)
+        Kernel::open(file_or_url) do |f|
+          self.read(f, ext)
+        end
+      else
+        self.new(file_or_url)
+      end
+    end
+
+    def self.read(stream, ext)
+      create(ext) do |f|
+        while chunk = stream.read(8192)
+          f.write(chunk)
+        end
+      end
+    end
+
+    def self.create(ext = nil, validate = true, &block)
+      begin
+        tempfile = Tempfile.new(['mini_magick', ext.to_s.downcase])
+        tempfile.binmode
+        block.call(tempfile)
+        tempfile.close
+        image = self.new(tempfile.path, tempfile)
+      ensure
+        tempfile.close if tempfile
+      end
+    end
+
+    def extract(options)
+
+      command = 'convert'
+      command << " -crop #{options[:crop]}" if options[:crop]
+      command << " -resize #{options[:size]}" if options[:size]
+      if options[:rotation]
+        command << " -virtual-pixel white +distort srt #{options[:rotation]}"
+      end
+
+      case options[:quality]
+      when 'grey'
+        command << ' -colorspace Gray'
+      when 'bitonal'
+        command << ' -colorspace Gray'
+        command << ' -type Bilevel'
+      end
+      command << " #{path} #{options[:format]}:-"
+      Rails.logger.debug "RIIIF executed: #{command}"
+      execute(command)
+    end
+
+    def info
+      return @info if @info
+      height, width = execute("identify -format %hx%w #{path}").split('x')
+      @info = {height: Integer(height), width: Integer(width)}
+    end
+
+    private
+      def execute(command)
+          stdin, stdout, stderr, wait_thr = popen3(command)
+          stdin.close
+          stdout.binmode
+          out = stdout.read
+          stdout.close
+          err = stderr.read
+          stderr.close
+          raise "Unable to execute command \"#{command}\"\n#{err}" unless wait_thr.value.success?
+          out
+      end
+
+  end
+end

data/app/models/riiif/image.rb

@@ -1,37 +1,30 @@
-require 'mini_magick'
 module Riiif
   class Image
+    
     class_attribute :file_resolver
     self.file_resolver = FileSystemFileResolver
 
-    attr_reader :path_name
+    OUTPUT_FORMATS = %W{jpg png}
+
+    attr_reader :path_name, :id
 
     # @param [String] id The identifier of the file
     def initialize(id)
+      @id = id
       @path_name = file_resolver.find(id)
     end
 
     def render(args)
       options = decode_options!(args)
+      Rails.cache.fetch(options.merge(id: id), compress: true, expires_in: 3.days) do
+        image.extract(options)
+      end
+    end
 
-      image.combine_options do |c|
-        c.crop options[:crop] if options[:crop]
-        c.resize options[:size] if options[:size]
-        if options[:rotation]
-          c.virtual_pixel 'white'
-          c.distort.+ 'srt', options[:rotation]
-        end
+    delegate :info, to: :image
 
-        case options[:quality]
-        when 'grey'
-          c.colorspace "Gray"
-        when 'bitonal'
-          c.colorspace "Gray"
-          c.type 'Bilevel'
-        end
-      end
-      image.format(options[:format])
-      image.to_blob
+    def image
+      @image ||= Riiif::File.open(path_name)
     end
 
     private
@@ -63,7 +56,7 @@ module Riiif
       end
 
       def validate_format!(format)
-        raise InvalidAttributeError, "Unsupported format: #{format}" unless ['jpg', 'png'].include?(format)
+        raise InvalidAttributeError, "Unsupported format: #{format}" unless OUTPUT_FORMATS.include?(format)
 
       end
 
@@ -72,8 +65,8 @@ module Riiif
           nil 
         elsif md = /^pct:(\d+),(\d+),(\d+),(\d+)$/.match(region)
           # Image magic can't do percentage offsets, so we have to calculate it
-          offset_x = (image[:width] * Integer(md[1]).to_f / 100).round
-          offset_y = (image[:height] * Integer(md[2]).to_f / 100).round
+          offset_x = (info[:width] * Integer(md[1]).to_f / 100).round
+          offset_y = (info[:height] * Integer(md[2]).to_f / 100).round
           "#{md[3]}%x#{md[4]}+#{offset_x}+#{offset_y}"
         elsif md = /^(\d+),(\d+),(\d+),(\d+)$/.match(region)
           "#{md[3]}x#{md[4]}+#{md[1]}+#{md[2]}"
@@ -89,7 +82,7 @@ module Riiif
           "x#{md[1]}"
         elsif md = /^(\d+),$/.match(size)
           "#{md[1]}"
-        elsif md = /^pct:(\d+)$/.match(size)
+        elsif md = /^pct:(\d+(.\d+)?)$/.match(size)
           "#{md[1]}%"
         elsif md = /^(\d+),(\d+)$/.match(size)
           "#{md[1]}x#{md[2]}!"
@@ -100,18 +93,5 @@ module Riiif
         end
       end
 
-      def image
-        begin
-          @image ||= MiniMagick::Image.open(path_name)
-        rescue Errno::ENOENT => e
-          Rails.logger.error "Unable to find #{path_name}"
-          Rails.logger.error e.backtrace
-          raise Riiif::Error, "Unable to find #{path_name}"
-        rescue MiniMagick::Error => e
-          Rails.logger.error "Error trying to open #{path_name}"
-          Rails.logger.error e.backtrace
-          raise Riiif::Error, "Unable to open the image #{path_name}"
-        end
-      end
   end
 end

data/app/views/riiif/images/view.html.erb

@@ -0,0 +1,21 @@
+    <div id="openseadragon1" style="width: 800px; height: 600px;"></div>
+    <%=javascript_include_tag "openseadragon.js" %>
+    <script type="text/javascript">
+        var viewer = OpenSeadragon({
+            id: "openseadragon1",
+            prefixUrl: "/assets/openseadragon/",
+            tileSources:   [{
+            "image_host":     "http://localhost:8080/image-service",
+            "identifier":   "irises",   
+            "width":        4264,   
+            "height":       3282,   
+            "scale_factors": [1, 2, 3, 4, 5],   
+            "tile_width":   1024,   
+            "tile_height":  1024,   
+            "formats":      [ "jpg", "png" ],   
+            "qualities":    ["native", "bitonal", "grey", "color"],   
+            "profile":      "http://library.stanford.edu/iiif/image-api/compliance.html#level1"
+          }]
+        });
+    </script>
+DOOD

data/config/routes.rb

@@ -1,4 +1,8 @@
 Riiif::Engine.routes.draw do
   ALLOW_DOTS ||= /[\w.]+/
-  get "/:id/:region/:size/:rotation/:quality(.:format)" => "images#show", :constraints => { :rotation => ALLOW_DOTS}
+  PERCENTAGE ||= /(pct:)?[\w.]+/
+  get "/:id/:region/:size/:rotation/:quality(.:format)" => "images#show", 
+    constraints: { rotation: ALLOW_DOTS, size: PERCENTAGE}
+  get "/:id/info(.:format)" => "images#info", :constraints => { :format => /json/}
+  get "/:id/view(.:format)" => "images#view"
 end

data/lib/riiif.rb

@@ -5,6 +5,7 @@ module Riiif
   extend ActiveSupport::Autoload
   autoload :Image
   autoload :FileSystemFileResolver
+  autoload :HTTPFileResolver
 
   class Error < RuntimeError; end
   class InvalidAttributeError < Error; end

data/lib/riiif/file_system_file_resolver.rb

@@ -13,7 +13,7 @@ module Riiif
 
     def self.pattern(id)
       raise ArgumentException, "Invalid characters in id `#{id}`" unless /^\w+$/.match(id)
-      File.join(base_path, "#{id}.{#{input_types.join(',')}}")
+      ::File.join(base_path, "#{id}.{#{input_types.join(',')}}")
     end
 
   end

data/lib/riiif/http_file_resolver.rb

@@ -0,0 +1,24 @@
+module Riiif
+  module HTTPFileResolver
+
+    # Set a lambda that maps the first parameter (id) to a URL
+    # Example:
+    #
+    # Riiif::HTTPFileResolver.id_to_uri = lambda do |id| 
+    #  "http://upload.wikimedia.org/wikipedia/commons/thumb/a/a4/#{id}.jpg/600px-#{id}.jpg"
+    # end
+    #
+    mattr_accessor :id_to_uri
+
+    def self.find(id)
+      uri(id)
+    end
+
+    protected
+
+    def self.uri(id)
+      raise "Must set the id_to_uri lambda" if id_to_uri.nil?
+      id_to_uri.call(id)
+    end
+  end
+end

data/lib/riiif/version.rb

@@ -1,3 +1,3 @@
 module Riiif
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/riiif.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = ""
   spec.license       = "APACHE2"
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files|grep -v spec/samples`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
@@ -22,6 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "engine_cart"
   spec.add_development_dependency "rspec-rails"
-  spec.add_dependency 'mini_magick'
   spec.add_dependency 'rails', '> 3.2.0'
 end

data/spec/controllers/images_controller_spec.rb

@@ -12,5 +12,22 @@ describe Riiif::ImagesController do
                rotation: '0', quality: 'native', format: 'jpg'
     expect(response).to be_successful
     expect(response.body).to eq 'IMAGEDATA'
+    expect(response.headers['Link']).to eq '<http://library.stanford.edu/iiif/image-api/1.1/compliance.html#level2>;rel="profile"'
+  end
+
+  it "should return info" do
+    image = double
+    expect(Riiif::Image).to receive(:new).with('abcd1234').and_return(image)
+    expect(image).to receive(:info).and_return({width: 6000, height: 4000 })
+    get :info, id: 'abcd1234', format: 'json'
+    expect(response).to be_successful
+    json = JSON.parse(response.body)
+    expect(json).to eq "@context"=>"http://library.stanford.edu/iiif/image-api/1.1/context.json",
+      "@id" =>"http://test.host/image-service/abcd1234",
+      "width" =>6000,
+      "height" =>4000,
+      "formats" =>  [ "jpg", "png" ],
+      "profile" =>  "http://library.stanford.edu/iiif/image-api/1.1/compliance.html#level0" 
+    expect(response.headers['Link']).to eq '<http://library.stanford.edu/iiif/image-api/1.1/compliance.html#level2>;rel="profile"'
   end
 end

data/spec/models/image_spec.rb

@@ -1,15 +1,12 @@
 require 'spec_helper'
 
 describe Riiif::Image do
+  before { Rails.cache.clear }
+  let(:filename) { File.expand_path('spec/samples/world.jp2') }
   subject { Riiif::Image.new('world') }
   describe "happy path" do
-    let(:combinator) { double }
-    let(:inner) { double }
     before do
-      expect(inner).to receive(:format).with('jpg')
-      expect(inner).to receive(:to_blob).and_return('imagedata')
-      inner.stub(:combine_options).and_yield(combinator)
-      subject.stub(:image).and_return(inner)
+      expect(subject.image).to receive(:execute).with("convert #{filename} jpg:-").and_return('imagedata')
     end
     it "should render" do
       expect(subject.render('size' => 'full', format: 'jpg')).to eq 'imagedata'
@@ -22,27 +19,42 @@ describe Riiif::Image do
     end
   end
 
+  describe "info" do
+    it "should return the data" do
+      expect(subject.info).to eq height: 400, width:800
+    end
+  end
 
-  describe "mogrify" do
-    let(:combinator) { double }
-    let(:inner) { double(format: true, to_blob: 'imagedata') }
+  describe "get images from web" do
     before do
-      inner.stub(:combine_options).and_yield(combinator)
-      subject.stub(:image).and_return(inner)
+      Riiif::Image.file_resolver = Riiif::HTTPFileResolver
+      Riiif::HTTPFileResolver.id_to_uri = lambda do |id| 
+        "http://upload.wikimedia.org/wikipedia/commons/thumb/a/a4/#{id}.jpg/600px-#{id}.jpg"
+      end
+    end
+    after do
+      Riiif::Image.file_resolver = Riiif::FileSystemFileResolver
+    end
+    subject { Riiif::Image.new('Cave_26,_Ajanta') }
+    it "should be easy" do
+      expect(subject.info).to eq height: 390, width:600
     end
+  end
+
+
+  describe "mogrify" do
     describe "region" do
       it "should return the original when specifing full size" do
-        expect(combinator).to_not receive(:crop)
+        expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(region: 'full', format: 'png')
       end
       it "should handle absolute geometry" do
-        expect(combinator).to receive(:crop).with('60x75+80+15')
+        expect(subject.image).to receive(:execute).with("convert -crop 60x75+80+15 #{filename} png:-")
         subject.render(region: '80,15,60,75', format: 'png')
       end
       it "should handle percent geometry" do
-        expect(inner).to receive(:[]).with(:height).and_return(131)
-        expect(inner).to receive(:[]).with(:width).and_return(175)
-        expect(combinator).to receive(:crop).with('80%x70+18+13')
+        expect(subject.image).to receive(:execute).with("identify -format %hx%w #{filename}").and_return('131x175')
+        expect(subject.image).to receive(:execute).with("convert -crop 80%x70+18+13 #{filename} png:-")
         subject.render(region: 'pct:10,10,80,70', format: 'png')
       end
       it "should raise an error for invalid geometry" do
@@ -52,27 +64,31 @@ describe Riiif::Image do
 
     describe "resize" do
       it "should return the original when specifing full size" do
-        expect(combinator).to_not receive(:resize)
+        expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(size: 'full', format: 'png')
       end
-      it "should handle percent sizes" do
-        expect(combinator).to receive(:resize).with('50%')
+      it "should handle integer percent sizes" do
+        expect(subject.image).to receive(:execute).with("convert -resize 50% #{filename} png:-")
         subject.render(size: 'pct:50', format: 'png')
       end
+      it "should handle float percent sizes" do
+        expect(subject.image).to receive(:execute).with("convert -resize 12.5% #{filename} png:-")
+        subject.render(size: 'pct:12.5', format: 'png')
+      end
       it "should handle w," do
-        expect(combinator).to receive(:resize).with('50')
+        expect(subject.image).to receive(:execute).with("convert -resize 50 #{filename} png:-")
         subject.render(size: '50,', format: 'png')
       end
       it "should handle ,h" do
-        expect(combinator).to receive(:resize).with('x50')
+        expect(subject.image).to receive(:execute).with("convert -resize x50 #{filename} png:-")
         subject.render(size: ',50', format: 'png')
       end
       it "should handle w,h" do
-        expect(combinator).to receive(:resize).with('150x75!')
+        expect(subject.image).to receive(:execute).with("convert -resize 150x75! #{filename} png:-")
         subject.render(size: '150,75', format: 'png')
       end
       it "should handle bestfit (!w,h)" do
-        expect(combinator).to receive(:resize).with('150x75')
+        expect(subject.image).to receive(:execute).with("convert -resize 150x75 #{filename} png:-")
         subject.render(size: '!150,75', format: 'png')
       end
       it "should raise an error for invalid size" do
@@ -81,15 +97,12 @@ describe Riiif::Image do
     end
 
     describe "rotate" do
-      let(:distorter) { double }
       it "should return the original when specifing full size" do
-        expect(combinator).to_not receive(:distort)
+        expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(rotation: '0', format: 'png')
       end
       it "should handle floats" do
-        expect(combinator).to receive(:distort).and_return(distorter)
-        expect(combinator).to receive(:virtual_pixel).with('white')
-        expect(distorter).to receive(:+).with("srt", 22.5)
+        expect(subject.image).to receive(:execute).with("convert -virtual-pixel white +distort srt 22.5 #{filename} png:-")
         subject.render(rotation: '22.5', format: 'png')
       end
       it "should raise an error for invalid angle" do
@@ -99,20 +112,19 @@ describe Riiif::Image do
 
     describe "quality" do
       it "should return the original when specifing native" do
-        expect(combinator).to_not receive(:colorspace)
+        expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(quality: 'native', format: 'png')
       end
       it "should return the original when specifing color" do
-        expect(combinator).to_not receive(:colorspace)
+        expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(quality: 'color', format: 'png')
       end
       it "should convert to grayscale" do
-        expect(combinator).to receive(:colorspace).with('Gray')
+        expect(subject.image).to receive(:execute).with("convert -colorspace Gray #{filename} png:-")
         subject.render(quality: 'grey', format: 'png')
       end
       it "should convert to bitonal" do
-        expect(combinator).to receive(:colorspace).with('Gray')
-        expect(combinator).to receive(:type).with('Bilevel')
+        expect(subject.image).to receive(:execute).with("convert -colorspace Gray -type Bilevel #{filename} png:-")
         subject.render(quality: 'bitonal', format: 'png')
       end
       it "should raise an error for invalid angle" do