djatoka 0.0.2

data/generators/djatoka/templates/OpenURL.js

@@ -0,0 +1,256 @@
+/* Copyright (c) UNC Chapel Hill University Library, created by Hugh A. Cayless
+ * and revised by J. Clifford Dyer.  Published under the Clear BSD licence.
+ * See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
+ * text of the license.
+ */
+
+
+/**
+ * @requires OpenLayers/Layer/Grid.js
+ * @requires OpenLayers/Tile/Image.js
+ */
+
+/**
+ * Class: OpenLayers.Layer.OpenURL
+ *
+ * Inherits from:
+ *  - <OpenLayers.Layer.Grid>
+ */
+OpenLayers.Layer.OpenURL = OpenLayers.Class(OpenLayers.Layer.Grid, {
+
+    /**
+     * APIProperty: isBaseLayer
+     * {Boolean}
+     */
+    isBaseLayer: true,
+
+    /**
+     * APIProperty: tileOrigin
+     * {<OpenLayers.Pixel>}
+     */
+    tileOrigin: null,
+
+    url_ver: 'Z39.88-2004',
+    rft_id: null,
+    svc_id: "info:lanl-repo/svc/getRegion",
+    svc_val_fmt: "info:ofi/fmt:kev:mtx:jpeg2000",
+    format: null,
+    tileHeight: null,
+
+    /**
+     * Constructor: OpenLayers.Layer.OpenURL
+     *
+     * Parameters:
+     * name - {String}
+     * url - {String}
+     * options - {Object} Hashtable of extra options to tag onto the layer
+     */
+    initialize: function(name, url, options) {
+        var newArguments = [];
+        newArguments.push(name, url, {}, options);
+        OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
+        this.rft_id = options.rft_id;
+        this.format = options.format;
+        // Get image metadata if it hasn't been set
+        if (!options.imgMetadata) {
+          var request = OpenLayers.Request.issue({url: options.metadataUrl, async: false});
+          this.imgMetadata = eval('(' + request.responseText + ')');
+        } else {
+          this.imgMetadata = options.imgMetadata;
+        }
+
+        var minLevel = this.getMinLevel();
+
+        // viewerLevel is the smallest useful zoom level: i.e., it is the largest level that fits entirely
+        // within the bounds of the viewer div.
+        var viewerLevel = Math.ceil(Math.min(minLevel, Math.max(
+            (Math.log(this.imgMetadata.width) - Math.log(OpenLayers.Layer.OpenURL.viewerWidth)),
+            (Math.log(this.imgMetadata.height) - Math.log(OpenLayers.Layer.OpenURL.viewerHeight)))/
+               Math.log(2)));
+        this.zoomOffset = minLevel - viewerLevel;
+
+        // width at level viewerLevel
+        var w = this.imgMetadata.width / Math.pow(2, viewerLevel);
+
+        // height at level viewerLevel
+        var h = this.imgMetadata.height / Math.pow(2, viewerLevel);
+
+        this.resolutions = new Array();
+        for (i = viewerLevel; i >= 0; i--) {
+          this.resolutions.push(Math.pow(2, i));
+        }
+
+        this.tileSize = new OpenLayers.Size(Math.ceil(w), Math.ceil(h));
+    },
+
+    /**
+     * APIMethod:destroy
+     */
+    destroy: function() {
+        // for now, nothing special to do here.
+        OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments);
+    },
+
+
+    /**
+     * APIMethod: clone
+     *
+     * Parameters:
+     * obj - {Object}
+     *
+     * Returns:
+     * {<OpenLayers.Layer.OpenURL>} An exact clone of this <OpenLayers.Layer.OpenURL>
+     */
+    clone: function (obj) {
+
+        if (obj == null) {
+            obj = new OpenLayers.Layer.OpenURL(this.name,
+                                           this.url,
+                                           this.options);
+        }
+
+        //get all additions from superclasses
+        obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
+
+        // copy/set any non-init, non-simple values here
+
+        return obj;
+    },
+
+    /**
+     * Method: getURL
+     *
+     * Parameters:
+     * bounds - {<OpenLayers.Bounds>}
+     *
+     * Returns:
+     * {String} A string with the layer's url and parameters and also the
+     *          passed-in bounds and appropriate tile size specified as
+     *          parameters
+     */
+    getURL: function (bounds) {
+        bounds = this.adjustBounds(bounds);
+        this.calculatePositionAndSize(bounds);
+        var z = this.map.getZoom() + this.zoomOffset;
+        var path = OpenLayers.Layer.OpenURL.djatokaURL + "?url_ver=" + this.url_ver + "&rft_id=" + this.rft_id +
+            "&svc_id=" + this.svc_id + "&svc_val_fmt=" + this.svc_val_fmt + "&svc.format=" +
+            this.format + "&svc.level=" + z + "&svc.rotate=0&svc.region=" + this.tilePos.lat + "," +
+            this.tilePos.lon + "," + this.imageSize.h + "," + this.imageSize.w;
+
+        var url = this.url;
+        if (url instanceof Array) {
+            url = this.selectUrl(path, url);
+        }
+        return url + path;
+    },
+
+    /**
+     * Method: addTile
+     * addTile creates a tile, initializes it, and adds it to the layer div.
+     *
+     * Parameters:
+     * bounds - {<OpenLayers.Bounds>}
+     * position - {<OpenLayers.Pixel>}
+     *
+     * Returns:
+     * {<OpenLayers.Tile.Image>} The added OpenLayers.Tile.Image
+     */
+    addTile:function(bounds,position) {
+      this.calculatePositionAndSize(bounds);
+      var size = this.size;
+      return new OpenLayers.Tile.Image(this, position, bounds,
+                                         null, this.imageSize);
+    },
+
+    /**
+     * APIMethod: setMap
+     * When the layer is added to a map, then we can fetch our origin
+     *    (if we don't have one.)
+     *
+     * Parameters:
+     * map - {<OpenLayers.Map>}
+     */
+    setMap: function(map) {
+        OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments);
+        if (!this.tileOrigin) {
+            this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left,
+                                                this.map.maxExtent.bottom);
+        }
+    },
+
+    calculatePositionAndSize: function(bounds) {
+      // Have to recalculate x and y (instead of using bounds and resolution), because resolution will be off.
+      // Get number of tiles in image
+      var max = this.map.getMaxExtent();
+      var xtiles = Math.round( 1 / (this.tileSize.w / max.getWidth()));
+      // Find out which tile we're on
+      var xpos = Math.round((bounds.left / max.getWidth()) * xtiles);
+      // Set x
+      var x = xpos * (this.tileSize.w + 1);
+      var w,h;
+      var xExtent = max.getWidth() / this.map.getResolution();
+      if (xpos == xtiles - 1) {
+        w = xExtent % (this.tileSize.w + 1);
+      } else {
+        w = this.tileSize.w;
+      }
+      // Do the same for y
+      var ytiles = Math.round( 1 / (this.tileSize.h / max.getHeight()));
+      // Djatoka's coordinate system is top-down, not bottom-up, so invert for y
+      var y = max.getHeight() - bounds.top;
+      y = y < 0? 0 : y;
+      var ypos = Math.round((y / max.getHeight()) * ytiles);
+      var y = ypos * (this.tileSize.h + 1);
+      var yExtent = max.getHeight() / this.map.getResolution();
+      if (ypos == ytiles - 1) {
+        h = yExtent % (this.tileSize.h + 1);
+      } else {
+        h = this.tileSize.h;
+      }
+      this.tilePos = new OpenLayers.LonLat(x,y);
+      this.imageSize = new OpenLayers.Size(w,h);
+    },
+
+    getImageMetadata: function() {
+      return this.imgMetadata;
+    },
+
+    getResolutions: function() {
+      return this.resolutions;
+    },
+
+    getTileSize: function() {
+      return this.tileSize;
+    },
+
+    getMinLevel: function() {
+        // Versions of djatoka from before 4/17/09 have levels set to the
+        // number of levels encoded in the image.  After this date, that
+        // number is assigned to the new dwtLevels, and levels contains the
+        // number of levels between the full image size and the minimum
+        // size djatoka could return.  We want the lesser of these two numbers.
+
+        var levelsInImg;
+        var levelsToDjatokaMin;
+        if (this.imgMetadata.dwtLevels === undefined) {
+            var maxImgDimension = Math.max(this.imgMetadata.width,
+                                         this.imgMetadata.height);
+            levelsInImg = this.imgMetadata.levels;
+            levelsToDjatokaMin = Math.floor((Math.log(maxImgDimension) -
+                Math.log(OpenLayers.Layer.OpenURL.minDjatokaLevelDimension)) /
+                Math.log(2));
+        } else {
+            var levelsInImg = this.imgMetadata.dwtLevels;
+            var levelsToDjatokaMin = this.imgMetadata.levels;
+        }
+        return Math.min(levelsInImg, levelsToDjatokaMin);
+    },
+
+    CLASS_NAME: "OpenLayers.Layer.OpenURL"
+});
+
+OpenLayers.Layer.OpenURL.viewerWidth = 512;
+OpenLayers.Layer.OpenURL.viewerHeight = 512;
+OpenLayers.Layer.OpenURL.minDjatokaLevelDimension = 48;
+OpenLayers.Layer.OpenURL.djatokaURL = '/adore-djatoka/resolver';
+

data/generators/djatoka/templates/djatoka-initializer.rb

@@ -0,0 +1,4 @@
+if Djatoka.respond_to? :resolver
+  Djatoka.resolver="http://localhost/adore-djatoka/resolver"
+end
+

data/generators/djatoka/templates/djatoka.js

@@ -0,0 +1,48 @@
+//////////////////////
+//$.extend({
+//  getUrlVars: function(){
+//    var vars = [], hash;
+//    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
+//    for(var i = 0; i < hashes.length; i++)
+//    {
+//      hash = hashes[i].split('=');
+//      vars.push(hash[0]);
+//      vars[hash[0]] = hash[1];
+//    }
+//    return vars;
+//  },
+//  getUrlVar: function(name){
+//    return $.getUrlVars()[name];
+//  }
+//});
+//////////////////////////////
+
+   function openlayersInit(base_url,metadataUrl, rft_id, div_identifier){
+
+	//alert(params);
+        //var metadataUrl = "http://localhost/adore-djatoka/resolver?url_ver=Z39.88-2004&rft_id=http://memory.loc.gov/gmd/gmd433/g4330/g4330/np000066.jp2&svc_id=info:lanl-repo/svc/getMetadata";
+
+        var OUlayer = new OpenLayers.Layer.OpenURL( "OpenURL",
+          base_url, {layername: 'basic',
+format:'image/jpeg',
+rft_id: rft_id,
+metadataUrl: metadataUrl} );
+        var metadata = OUlayer.getImageMetadata();
+        var resolutions = OUlayer.getResolutions();
+        var maxExtent = new OpenLayers.Bounds(0, 0, metadata.width,
+metadata.height);
+        var tileSize = OUlayer.getTileSize();
+        var options = {resolutions: resolutions, maxExtent: maxExtent,
+tileSize: tileSize};
+        var map = new OpenLayers.Map( div_identifier, options);
+        map.addLayer(OUlayer);
+        var lon = metadata.width / 2;
+        var lat = metadata.height / 2;
+        map.setCenter(new OpenLayers.LonLat(lon, lat), 0);
+      }
+///////////////////////////////////////
+//     $(document).ready(function() {
+//   openlayersInit('http://localhost',"http://localhost/adore-djatoka/resolver?url_ver=Z39.88-2004&rft_id=http://memory.loc.gov/gmd/gmd433/g4330/g4330/np000066.jp2&svc_id=info:lanl-repo/svc/getMetadata",
+//   'http://memory.loc.gov/gmd/gmd433/g4330/g4330/np000066.jp2');
+// });
+

data/lib/djatoka.rb

@@ -0,0 +1,71 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# In the context of Djatoka a <tt>uri</tt> is an Addressable::URI and a
+# <tt>url</tt> is a String representation of that uri.
+module Djatoka
+  # for use with Rails to allow for configuration
+  def self.resolver=(url)
+    if url.is_a? Djatoka::Resolver
+      @resolver = url
+    elsif url.is_a? String
+      @resolver = Djatoka::Resolver.new(url)
+#      if resolver.valid?
+#        @resolver = resolver
+#      else
+#        @resolver = nil
+#      end
+    end
+  end
+  def self.resolver
+    @resolver
+  end
+
+  # Allows for using curb if available. Otherwise falls back on Net::HTTP. See Djatoka::Net
+  def self.use_curb=(curb)
+    @use_curb = curb
+  end
+  def self.use_curb?
+    @use_curb
+  end
+  class << self
+    # Calls enable_actionpack
+    def enable
+      enable_actionpack
+    end
+    # Requires the Djatoka Rails view helpers
+    def enable_actionpack
+      return if ActionView::Base.instance_methods.include? :djatoka_image_tag
+      require 'djatoka/view_helpers'
+      ActionView::Base.send :include, ViewHelpers
+    end
+  end
+end
+
+begin
+  require 'curb'
+  Djatoka.use_curb = true
+rescue LoadError
+  Djatoka.use_curb = false
+end
+
+require 'net/http'
+  require 'uri'
+
+require 'djatoka/net'
+require 'djatoka/resolver'
+require 'djatoka/metadata'
+require 'djatoka/common'
+require 'djatoka/region'
+
+require 'rubygems'
+require 'addressable/uri'
+require 'addressable/template'
+require 'json'
+require 'mash'
+
+
+if defined? Rails
+  Djatoka.enable_actionpack if defined? ActionController
+end
+

data/lib/djatoka/common.rb

@@ -0,0 +1,125 @@
+# In this module are some methods for some common operations to be done on images.
+# These features are more experimental and more likely to break for some images
+# at some resolutions.
+module Djatoka::Common
+
+  # svc.region - Y,X,H,W.
+  # Y is the down inset value (positive) from 0 on the y axis at the max image resolution.
+  # X is the right inset value (positive) from 0 on the x axis at the max image resolution.
+  # H is the height of the image provided as response.
+  # W is the width of the image provided as response.
+
+  # Sets the scale to a 75x75 pixel version of the image and crops any long side
+  # to square it. Returns self (a Djatoka::Region.)
+  def smallbox
+    scale('75')
+    square_params
+    self
+  end
+
+  # An Addressable::URI for a 75x75 version of the image.
+  def smallbox_uri
+    smallbox
+    uri
+  end
+
+  # String of #smallbox_uri
+  def smallbox_url
+    smallbox_uri.to_s
+  end
+
+  # public alias for #square_params. Returns self (a Djatoka::Region)
+  def square
+    square_params
+    self
+  end
+
+  # Sets any parameters needed to crop the image to a square and then returns
+  # an Addressable::URI.
+  def square_uri
+    square_params
+    uri
+  end
+
+  # String of the #square_uri
+  def square_url
+    square_uri.to_s
+  end
+
+  # So far we figure the best level to ask for based on any scale parameter and
+  # try to compensate for any difference between the dwtLevels and djatoka levels
+  # so that we get a decent image returned.
+  def pick_best_level(metadata)
+    best_level = '6'
+    metadata_levels = metadata.all_levels
+    metadata_levels.keys.sort.reverse.each do |k|
+       if metadata_levels[k].height.to_i > query.scale.to_i and
+         metadata_levels[k].width.to_i > query.scale.to_i
+         best_level = k
+       end
+    end
+    # Here we try to compensate for when the dwtLevels does not match the
+    # djatoka levels.
+    if metadata.dwt_levels.to_i > metadata.levels.to_i
+      best_level.to_i - 2
+    elsif metadata.dwt_levels.to_i == metadata.levels.to_i
+      best_level.to_i
+    end
+  end
+
+  private
+
+  # This is an experimental way to get a decent looking square image at any level.
+  # The complication seems to come in where the dwtLevels are different from the
+  # how djatoka determines levels. See the comments for the places where the code
+  # tries to reconcile this difference in a way that seems to work in the cases
+  # seen so far.
+  def square_params
+    metadata = Djatoka::Metadata.new(resolver, rft_id).perform
+    if metadata
+      orig_height = metadata.height.to_i
+      orig_width = metadata.width.to_i
+      if query.scale and query.scale.split.length == 1
+        # scaling an image without picking a good level results in poor image
+        # quality
+        level(pick_best_level(metadata))
+      end
+      if query.level
+        # we try to compensate for when there is a difference between the
+        # dwtLevels and the djatoka levels. So far the only case seen is where
+        # the dwtLevels are greater than the djatoka levels.
+        if metadata.dwt_levels.to_i > metadata.levels.to_i
+          good_query_level = query.level.to_i + 1
+        # dwtLevels in the cases seen so far almost always match the djatoka levels.
+        elsif metadata.dwt_levels.to_i == metadata.levels.to_i
+          good_query_level = query.level.to_i
+        end
+        height = metadata.all_levels[good_query_level].height
+        width = metadata.all_levels[good_query_level].width
+      else
+        height = orig_height
+        width = orig_width
+      end
+      # x & y are always the inset of the original image size
+      # height and width are relative to the level selected and one if not already
+      # a square then the longest side is cropped.
+      if height != width
+        if height > width
+          x = '0'
+          y = ((orig_height - orig_width)/2).to_s
+
+          h = width.to_s
+          w = width.to_s
+        elsif width > height
+          y = '0'
+          x = ((orig_width - orig_height)/2).to_s
+          h = height.to_s
+          w = height.to_s
+        end
+        region([y,x,h,w])
+      end
+    end
+  end #square_params
+
+end
+