assembly-image 1.6.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b213d29d1bbd1206e9268adeff0d7eba4f9e8b26
+  data.tar.gz: 04d757adec2931a7ca42ac9f1cf7f29d6b7dbbc0
+SHA512:
+  metadata.gz: 84120410f44ab8fdbf8fe2f7e9943d6209058e6bc4ffc707e149ba134c65b3165e1839ec869bf40b33a823ab395ed7ddfbbb22582f8aee53c2a5befaf8d31b62
+  data.tar.gz: fb93f15796aacf0500337b0afe7997cec9d832edb39f23f6078cacaef061c36efb5e85b48b4f40607f2b7d86bd3d58afdd569f33f3babfe1c980de90179b89d6

data/.gitignore

@@ -0,0 +1,13 @@
+.rvmrc
+*.gem
+.DS_Store
+.bundle
+Gemfile.lock
+config/certs/*
+config/environments/*
+doc/*
+log/*
+pkg/*
+tags
+tmp
+.yardoc/*

data/.rvmrc.example

@@ -0,0 +1 @@
+rvm use 1.9.3@assembly-image --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in assembly-image.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,14 @@
+#############################################################################################################
+# Copyright (c) 2012-2014 by The Board of Trustees of the Leland Stanford Junior University.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.rdoc

@@ -0,0 +1,139 @@
+= Assembly Image Gem
+
+==Overview 
+This gem contains classes used by the Stanford University Digital Library to perform
+image operations necessary for accessioning of content.
+
+==Releases
+
+- 0.0.1 initial release
+- 0.0.2 small bug fixes
+- 0.0.3 more bug fixes
+- 0.0.4 update jp2 creation method to restrict allowed input types and improve color profile handling
+- 0.0.5 updated documentation to yard format
+- 0.0.6 updated dependency declarations
+- 0.1.0 move color profile extraction to tmp folder instead of gem profiles folder
+- 0.1.1 fix problem with digest require statement
+- 0.1.2 move check for file existence to when an action occurs instead of object initialization; more error checking and messages on command execution
+- 0.1.3 added a filesize attribute to the file object to allow easy access to filesize in bytes
+- 0.1.4 added a new images class that allows you batch create jp2s from an input TIFF directory
+- 0.2.0 added a new method to the image class to handle TIFF "sanity-check" -- can be used to ensure TIFFs are valid before JP2 generation
+- 1.0.0 bump the version number up to an official production level release
+- 1.1.0 remove common object file behaviors to a separate gem and use that gem as a dependency
+- 1.1.1 minor changes to spec tests
+- 1.1.2 remove the addition of 'format' node to file types in content metadata generation
+- 1.1.3 changes to content metadata generation method: change md5 and sha1 computations so that they come from the assembly-objectfile gem, and set preserve/publish/shelve attributes using mimetype defaults
+- 1.2.0 support tiffs that have embedded thumbnails when creating jp2
+- 1.2.1 raise a SecurityError if the user attempts to overwrite an existing jp2 when creating it, to make it easier to catch in assembly
+- 1.2.2 add height and width methods for an image that gets it from exif
+- 1.2.4 prepare for release listing on DLSS release board
+- 1.2.5 small change to use the jp2able method instead of the valid? method when creating jp2s
+- 1.2.6 update how version number is set to make it easier to show
+- 1.3.0 added a new method to the Assembly::Images class to allow for batch adding of color profiles to all tiffs in a directory; allow batch methods to run recursively
+- 1.3.1 remove content metadata generation method and add to assembly-objectfile gem instead
+- 1.3.3 update gemspec to force use of latest assembly-objectfile gem to allow gem to work in Ruby 1.9 projects
+- 1.3.4 update to latest version of lyberteam gems
+- 1.3.5 fix a problem that could occur if there were spaces in input filenames
+- 1.3.6 add new attribute to give you default jp2 filename that will be used
+- 1.3.7 add new attribute to give you default dpg jp2 filename 
+- 1.3.8 allow for batch processing of image extensions other than tif
+- 1.3.9 create new methods for getting a color profile from exif and for force adding color profile to a single image
+- 1.4.0 and 1.4.1 set the imagemagick tmp folder location environment variable when creating jp2
+- 1.5.0 allow images with a color profile to have jp2 derivatives generated
+- 1.5.1 relax nokogiri version requirement
+- 1.6.1 bump version number of assembly-objectfile required to fix UTF-8 errors during JP2-create
+- 1.6.2-1.6.3 small change to jp2 generation to try and fix bug with tiffs that have multiple input profile layers 
+- 1.6.4 added in some additional checks to try and create jp2s with mismatching exif data
+- 1.6.5 fix problem with lack of extension in incoming tif causing a problem when creating jp2
+- 1.6.7 release to github/rubygems
+==Notes
+
+1. The gem assumes that the user context in which it is executed has write access to the 'tmp' folder.
+This is because color profiles can be extracted from images during the JP2 creation process, and these profiles need to
+be stored as local files, and it is beneficial to cache them for later usage by images with the same color profile.  
+If you know there are color profiles which are commonly used, it is better to capture them in the gem itself in the profile
+folder so they can be re-used and do not need to be extracted.
+
+2. If any errors occur during JP2 generation for any reason, a runtime exception will be thrown with a description of the error.
+
+3. If an image is passed in with a color profile that cannot be determined by examining the exif header data, an exception will be thrown.
+This can commonally occur in basic test TIFs that are black/white and have no profile, so beware during testing.
+
+==Usage
+
+To use the JP2 creation method, you first instantiate the image object with an input image and then operate on it.
+
+	require 'assembly-image'
+	input=Assembly::Image.new('/full/path/to/file.tif')
+	puts input.exif  # this will show you exif header information for the TIF
+	output=input.create_jp2(:output=>'/full/path/to/output.jp2') # this will generate a new JP2 in the output location specified
+	puts output.exif # this will show you exif header information for the JP2
+
+==Running tests
+
+	bundle exec rspec spec
+
+==Generate documentation
+To generate documentation into the "doc" folder:
+
+	yard
+
+To keep a local server running with up to date code documentation that you can view in your browser:
+
+	yard server --reload
+
+==Prerequisites
+
+1. Perl 
+
+2. Kakadu Software Binaries - for JP2 generation
+
+   Download and install demonstration binaries from Kakadu:
+   http://www.kakadusoftware.com/index.php?option=com_content&task=view&id=26&Itemid=22
+
+   Note: The binaries will not work with RHEL 5.x; an RPM for RHEL 5 with
+   compatible binaries coming soon.
+
+3. Imagemagick 6.5.4 or higher
+            	   		
+   RHEL 6
+   
+   The version of ImageMagick included with RHEL 6 has all of the dependency libraries included: 
+
+       yum install ImageMagick
+           
+   RHEL 5: (RPM to install with included binaries comming soon)
+
+   The version of ImageMagic included with RHEL 5 is too old and does not have all the proper binaries included/built
+
+   Required libraries are:
+
+       yum install lcms lcms-devel libjpeg \
+                   libjpeg-devel libpng libpng-devel
+
+   Required libraries from source:
+   * libtiff (version 3.9.4 or higher)
+				
+   Build Imagemagick from source:
+   http://www.imagemagick.org/download/ImageMagick.tar.gz
+
+   Mac users:
+
+		brew install jasper
+		brew install libtiff
+		brew install imagemagick --use-tiff --use-jpeg2000
+
+4. Exiftool
+            
+   RHEL: (RPM to install comming soon)
+   Download latest version from:  http://www.sno.phy.queensu.ca/~phil/exiftool
+
+       tar -xf Image-ExifTool-#.##.tar.gz
+       cd Image-ExifTool-#.##
+       perl Makefile.PL
+       make test
+       sudo make install
+
+   Mac users:
+
+       brew install exiftool

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/assembly-image.gemspec

@@ -0,0 +1,30 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require 'assembly-image/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'assembly-image'
+  s.version     = Assembly::Image::VERSION
+  s.authors     = ["Peter Mangiafico", "Renzo Sanchez-Silva","Monty Hindman","Tony Calavano"]
+  s.email       = ["pmangiafico@stanford.edu"]
+  s.homepage    = ""
+  s.summary     = %q{Ruby immplementation of image services needed to prepare objects to be accessioned in SULAIR digital library}
+  s.description = %q{Contains classes to create derivative image files and perform other image operations}
+
+  s.rubyforge_project = 'assembly-image'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'uuidtools'
+  s.add_dependency 'assembly-objectfile', ">= 1.6.4"
+  s.add_dependency 'mini_exiftool', "~> 1.6"
+  s.add_dependency 'activesupport'
+  s.add_dependency 'nokogiri'
+
+  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "rake"
+  
+end

data/bin/console

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+
+require 'rubygems'
+require 'irb'
+
+require File.expand_path(File.dirname(__FILE__) + '/../config/boot')
+
+IRB.start

data/bin/run_all_tests

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+bundle exec rspec spec

data/config/boot.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+
+environment  = ENV['ENVIRONMENT'] ||= 'development'
+project_root = File.expand_path(File.dirname(__FILE__) + '/..')
+
+# Load config for current environment.
+$LOAD_PATH.unshift(project_root + '/lib')
+
+require 'assembly-image'

data/lib/assembly-image/image.rb

@@ -0,0 +1,216 @@
+require 'uuidtools'
+require 'assembly-objectfile'
+
+module Assembly
+  
+  # The Image class contains methods to operate on an image.
+  class Image
+
+    # include common behaviors from assembly-objectfile gem
+    include Assembly::ObjectFileable
+
+    # stores the path to the tmp file generated during the JP2 creation process
+    attr_accessor :tmp_path
+
+    # Examines the input image for validity.  Used to determine if image is correct and if JP2 generation is likely to succeed.
+    #  This method is automatically called before you create a jp2 but it can be called separately earlier as a sanity check.
+    #
+    # @return [boolean] true if image is valid, false if not.
+    #
+    # Example:
+    #   source_img=Assembly::ObjectFile.new('/input/path_to_file.tif')
+    #   puts source_img.valid? # gives true
+    def valid?
+      valid_image? # behavior is defined in assembly-objectfile gem
+    end
+    
+    # Get the image color profile
+    #
+    # @return [string] image color profile
+    # Example:
+    #   source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #   puts source_img.profile # gives 'Adobe RGB 1998'
+    def profile
+      exif.nil? ? nil : exif['profiledescription']
+    end
+    
+    # Get the image height from exif data
+    #
+    # @return [integer] image height in pixels
+    # Example:
+    #   source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #   puts source_img.height # gives 100
+    def height
+      exif.imageheight
+    end
+
+    # Get the image width from exif data
+    #
+    # @return [integer] image height in pixels
+    # Example:
+    #   source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #   puts source_img.width # gives 100    
+    def width
+      exif.imagewidth
+    end
+
+    # Add an exif color profile descriptions to the image.
+    # This is useful if your source TIFFs do not have color profile descriptions in the EXIF data, but you know what it should be.
+    # This will allow the images to pass the validaty check and have JP2s created successfully.
+    #
+    # Note you will need full read/write access to the source path so that new EXIF data can be saved.
+    #
+    # @param [String] profile_name profile name to be added, current options are 'Adobe RBG 1998','Dot Gain 20%','sRGB IEC61966-2.1'
+    #
+    # @param [String] force if set to true, force overwrite a color profile description even if it already exists (default: false)
+    #
+    # Example:
+    #  source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #  source_img.add_exif_profile_description('Adobe RGB 1998')
+    def add_exif_profile_description(profile_name,force=false)
+      begin
+        if profile.nil? || force
+          input_profile = profile_name.gsub(/[^[:alnum:]]/, '')   # remove all non alpha-numeric characters, so we can get to a filename
+          path_to_profiles    = File.join(Assembly::PATH_TO_IMAGE_GEM,'profiles')
+          input_profile_file = File.join(path_to_profiles,"#{input_profile}.icc")
+          command="exiftool '-icc_profile<=#{input_profile_file}' #{path}"
+          result=`#{command} 2>&1`
+          raise "profile addition command failed: #{command} with result #{result}" unless $?.success?
+        end
+      rescue Exception => e
+        puts "** Error for #{filename}: #{e.message}"
+      end
+    end
+    
+    # Returns the full default jp2 path and filename that will be created from the given image
+    #
+    # @return [string] full default jp2 path and filename that will be created from the given image
+    # Example:
+    #   source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #   puts source_img.jp2_filename # gives /input/path_to_file.jp2
+    def jp2_filename
+      File.extname(@path).empty? ? "#{@path}.jp2" : @path.gsub(File.extname(@path),'.jp2')
+    end
+
+    # Returns the full DPG equivalent jp2 path and filename that would match with the given image
+    #
+    # @return [string] full DPG equivalent jp2 path and filename
+    # Example:
+    #   source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #   puts source_img.jp2_filename # gives /input/path_to_file.jp2
+    def dpg_jp2_filename
+      jp2_filename.gsub('_00_','_05_')
+    end
+        
+    # Create a JP2 file for the current image.
+    # Important note: this will not work for multipage TIFFs.
+    #
+    # @return [Assembly::Image] object containing the generated JP2 file
+    #
+    # @param [Hash] params Optional parameters specified as a hash, using symbols for options:
+    #   * :output => path to the output JP2 file (default: mirrors the source file name and path, but with a .jp2 extension)
+    #   * :overwrite => if set to false, an existing JP2 file with the same name won't be overwritten (default: false)
+    #   * :tmp_folder =>  the temporary folder to use when creating the jp2 (default: '/tmp'); also used by imagemagick
+    #   * :preserve_tmp_source => if set to true, preserve the temporary file generated during the creation process and store path in 'tmp_path' attribute (default: false)
+    #
+    # Example:
+    #   source_img=Assembly::Image.new('/input/path_to_file.tif')
+    #   derivative_img=source_img.create_jp2(:overwrite=>true)
+    #   puts derivative_img.mimetype # 'image/jp2'
+    #   puts derivative_image.path # '/input/path_to_file.jp2'
+    def create_jp2(params = {})
+
+      check_for_file
+
+      raise "input file is not a valid image, or is the wrong mimetype" if !self.jp2able?
+      
+      output    = params[:output] || jp2_filename
+      overwrite = params[:overwrite] || false
+
+      raise SecurityError,"output #{output} exists, cannot overwrite" if !overwrite && File.exists?(output)
+
+      raise SecurityError,"cannot recreate jp2 over itself" if overwrite && mimetype=='image/jp2' && output == @path
+
+      tmp_folder = params[:tmp_folder] || '/tmp'
+      raise "tmp_folder #{tmp_folder} does not exists" unless File.exists?(tmp_folder)
+      
+      output_profile      = 'sRGBIEC6196621' # params[:output_profile] || 'sRGBIEC6196621'  # eventually we may allow the user to specify the output_profile...when we do, you can just uncomment this code and update the tests that check for this
+      preserve_tmp_source = params[:preserve_tmp_source] || false
+      path_to_profiles    = File.join(Assembly::PATH_TO_IMAGE_GEM,'profiles')
+      output_profile_file = File.join(path_to_profiles,"#{output_profile}.icc")
+
+      raise "output profile #{output_profile} invalid" if !File.exists?(output_profile_file)
+
+      samples_per_pixel=exif['samplesperpixel'].to_s || ""
+      bits_per_sample=exif['bitspersample'] || ""
+      
+      path_to_profiles   = File.join(Assembly::PATH_TO_IMAGE_GEM,'profiles')
+    
+      if !profile.nil? # if the input color profile exists, contract paths to the profile and setup the command
+      
+        input_profile = profile.gsub(/[^[:alnum:]]/, '')   # remove all non alpha-numeric characters, so we can get to a filename
+      
+        # construct a path to the input profile, which might exist either in the gem itself or in the tmp folder
+        input_profile_file_gem = File.join(path_to_profiles,"#{input_profile}.icc")
+        input_profile_file_tmp = File.join(tmp_folder,"#{input_profile}.icc")
+        input_profile_file = File.exists?(input_profile_file_gem) ? input_profile_file_gem : input_profile_file_tmp
+       
+        # if input profile was extracted and does not matches an existing known profile either in the gem or in the tmp folder,
+        # we'll issue an imagicmagick command to extract the profile to the tmp folder
+        unless File.exists?(input_profile_file)
+          input_profile_extraction_command = "MAGICK_TEMPORARY_PATH=#{tmp_folder} convert '#{@path}'[0] #{input_profile_file}" # extract profile from input image
+          result=`#{input_profile_extraction_command} 2>&1`
+          raise "input profile extraction command failed: #{input_profile_extraction_command} with result #{result}" unless $?.success?
+          raise "input profile is not a known profile and could not be extracted from input file" unless File.exists?(input_profile_file) # if extraction failed or we cannot write the file, throw exception
+        end
+
+        profile_conversion_switch = "-profile #{input_profile_file} -profile #{output_profile_file}"
+      
+      else
+        
+        profile_conversion_switch = "" # no conversion needed if input color profile does not exist
+
+      end
+      
+      # make temp tiff filename
+      @tmp_path      = "#{tmp_folder}/#{UUIDTools::UUID.random_create.to_s}.tif"
+      
+      options    =  ""
+      case samples_per_pixel
+        when "3"
+          options += "-type TrueColor"
+        when "1"
+          if bits_per_sample.to_i == 1
+            options += "-type Bilevel" 
+          elsif bits_per_sample.to_i > 1
+            options += "-type Grayscale" 
+          end
+      end
+      tiff_command       = "MAGICK_TEMPORARY_PATH=#{tmp_folder} convert -quiet -compress none #{profile_conversion_switch} #{options} '#{@path}[0]' '#{@tmp_path}'"
+      result=`#{tiff_command} 2>&1`
+      raise "tiff convert command failed: #{tiff_command} with result #{result}" unless $?.success?
+      
+      pixdem = width > height ? width : height
+      layers = (( Math.log(pixdem) / Math.log(2) ) - ( Math.log(96) / Math.log(2) )).ceil + 1
+      
+      # jp2 creation command
+      kdu_bin     = "kdu_compress "
+      options     = ""
+      options    += " -jp2_space sRGB " if samples_per_pixel == "3"
+      options    += " -precise -no_weights -quiet Creversible=no Cmodes=BYPASS Corder=RPCL " + 
+                    "Cblk=\\{64,64\\} Cprecincts=\\{256,256\\},\\{256,256\\},\\{128,128\\} " + 
+                    "ORGgen_plt=yes -rate 1.5 Clevels=5 "
+      jp2_command = "#{kdu_bin} #{options} Clayers=#{layers.to_s} -i '#{@tmp_path}' -o '#{output}'"
+      result=`#{jp2_command} 2>&1`
+      raise "JP2 creation command failed: #{jp2_command} with result #{result}" unless $?.success?
+      
+      File.delete(@tmp_path) unless preserve_tmp_source
+
+      # create output response object, which is an Assembly::Image type object
+      return Assembly::Image.new(output)
+      
+    end
+
+  end
+  
+end

data/lib/assembly-image/images.rb

@@ -0,0 +1,97 @@
+require 'logger'
+module Assembly
+  
+  # The Images class contains methods to operate on multiple images in batch.
+  class Images
+    
+    def self.logger
+      @logger ||= Logger.new(STDERR)
+    end
+    
+    def self.logger= logger
+      @logger = logger
+    end
+
+    # Pass in a source path and have exif color profile descriptions added to all images contained.
+    # This is useful if your source TIFFs do not have color profile descriptions in the EXIF data, but you know what it should be.
+    # This will allow the images to pass the validty check and have JP2s created successfully.
+    #
+    # Note you will need full read/write access to the source path so that new EXIF data can be saved.
+    #
+    # @param [String] source path full path to the directory containing TIFFs
+    # @param [String] profile_name profile name to be added, current options are 'Adobe RBG 1998','Dot Gain 20%','sRGB IEC61966-2.1'
+    #
+    # @param [Hash] params Optional parameters specified as a hash, using symbols for options:
+    #   * :force => if set to true, force overwrite a color profile description even if it already exists (default: false)
+    #   * :recusrive => if set to true, directories will be searched recursively for TIFFs from the source specified, false searches the top level only (default: false)
+    #   * :extension => defines the types of files that will be processed (default '.tif')
+    #
+    # Example:
+    #  Assembly::Images.batch_add_exif_profile_description('/full_path_to_tifs','Adobe RGB 1998')    
+    def self.batch_add_exif_profile_description(source,profile_name,params={})
+
+      extension = params[:extension] || 'tif'
+      recursive = params[:recursive] || false
+      force = params[:force] || false
+      
+      raise "Input path does not exist" unless File.directory?(source)
+      
+      logger.debug "Source: #{source}"
+
+      # iterate over input directory looking for tifs
+      pattern = recursive ? "**/*.#{extension}" : "*.#{extension}*" 
+      Dir.glob(File.join(source,pattern)).each do |file|
+        img=Assembly::Image.new(file)
+        logger.debug "Processing #{file}"
+        img.add_exif_profile_description(profile_name,force)
+      end
+      return "Complete"
+    end
+        
+    # Pass in a source path and get JP2s generate for each tiff that is in the source path
+    #
+    # If not passed in, the destination will be a "jp2" subfolder within the source folder.
+    # Note you will need read access to the source path, and write access to the destination path.
+    #
+    # @param [String] source path full path to the directory containing TIFFs to be converted to JP2
+    #
+    # @param [Hash] params Optional parameters specified as a hash, using symbols for options:
+    #   * :output=>'/full/path_to_jp2' # specifies full path to folder where jp2s will be created (default: jp2 subdirectory from source path)
+    #   * :overwrite => if set to false, an existing JP2 file with the same name won't be overwritten (default: false)
+    #   * :recursive => if set to true, directories will be searched recursively for TIFFs from the source specified, false searches the top level only (default: false)
+    #   * :extension => defines the types of files that will be processed (default '.tif')
+    #
+    # Example:
+    #  Assembly::Images.batch_generate_jp2('/full_path_to_tifs')
+    def self.batch_generate_jp2(source,params={})
+      
+        raise "Input path does not exist" unless File.directory?(source)
+        output = params[:output] || File.join(source,'jp2') # default output directgory is jp2 sub-directory from source
+        extension = params[:extension] || 'tif'
+        overwrite = params[:overwrite] || false
+        recursive = params[:recursive] || false
+                
+        Dir.mkdir(output) unless File.directory?(output) # attemp to make output directory
+        raise "Output path does not exist or could not be created" unless File.directory?(output) 
+
+        logger.debug "Source: #{source}"
+        logger.debug "Destination: #{output}"
+  
+        pattern = recursive ? "**/*.#{extension}" : "*.#{extension}*" 
+
+        # iterate over input directory looking for tifs
+        Dir.glob(File.join(source,pattern)).each do |file|
+          source_img=Assembly::Image.new(file)
+          output_img=File.join(output,File.basename(file,File.extname(file))+'.jp2') # output image gets same file name as source, but with a jp2 extension and in the correct output directory
+          begin
+            derivative_img=source_img.create_jp2(:overwrite=>overwrite,:output=>output_img)
+            logger.debug "Generated jp2 for #{File.basename(file)}"
+          rescue Exception => e
+            logger.debug "** Error for #{File.basename(file)}: #{e.message}"
+          end
+        end
+        return 'Complete'
+        
+    end
+  end
+end

data/lib/assembly-image/version.rb

@@ -0,0 +1,8 @@
+# Main Assembly namespace
+module Assembly
+  # Main Image class
+  class Image
+    # Project version number    
+    VERSION = "1.6.7"
+  end
+end

data/lib/assembly-image.rb

@@ -0,0 +1,9 @@
+module Assembly
+  
+  # the path to the gem, used to access profiles stored with the gem
+  PATH_TO_IMAGE_GEM = File.expand_path(File.dirname(__FILE__) + '/..')
+  
+end
+
+# auto-include all files in the lib sub-directory directory
+Dir[File.dirname(__FILE__) + '/assembly-image/*.rb'].each {|file| require file unless file=='version.rb'}

data/spec/image_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe Assembly::Image do
+
+  it "should not run if no input file is passed in" do
+    @ai=Assembly::Image.new('')
+    expect{@ai.create_jp2}.to raise_error
+  end
+  
+  it "should indicate the default jp2 filename" do
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai.jp2_filename).to eq TEST_TIF_INPUT_FILE.gsub('.tif','.jp2')
+  end
+
+  it "should indicate the default jp2 filename" do
+    @ai = Assembly::Image.new("/path/to/a/file_with_no_extension")
+    expect(@ai.jp2_filename).to eq "/path/to/a/file_with_no_extension.jp2"
+  end
+  
+  it "should indicate the default DPG jp2 filename" do
+    @ai = Assembly::Image.new(TEST_DPG_TIF_INPUT_FILE)
+    expect(@ai.dpg_jp2_filename).to eq TEST_DPG_TIF_INPUT_FILE.gsub('.tif','.jp2').gsub('_00_','_05_')
+  end
+
+  it "should indicate the default jp2 filename" do
+    @ai = Assembly::Image.new("/path/to/a/file_with_no_00_extension")
+    expect(@ai.dpg_jp2_filename).to eq "/path/to/a/file_with_no_05_extension.jp2"
+  end
+  
+  it "should create jp2 when given an RGB tif" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)
+    expect(result).to be_a_kind_of Assembly::Image
+    expect(result.path).to eq TEST_JP2_OUTPUT_FILE        
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"
+    @jp2=Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
+    expect(@jp2.height).to eq 100
+    expect(@jp2.width).to eq 100
+  end
+
+  it "should create grayscale jp2 when given a bitonal tif" do
+    generate_test_image(TEST_TIF_INPUT_FILE,:color=>'white',:image_type=>"Bilevel")
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai).to have_color_profile
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "Grayscale"    
+  end
+
+  it "should create color jp2 when given a color tif but bitonal image data (1 channels and 1 bits per pixel)" do
+    generate_test_image(TEST_TIF_INPUT_FILE,:color=>'white',:image_type=>"TrueColor",:profile=>'')
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai).to_not have_color_profile
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"    
+  end
+
+  it "should create grayscale jp2 when given a graycale tif but with bitonal image data (1 channel and 1 bits per pixel)" do
+    generate_test_image(TEST_TIF_INPUT_FILE,:color=>'white',:image_type=>"Grayscale",:profile=>'')
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai).to_not have_color_profile
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "Grayscale"    
+  end
+
+  it "should create color jp2 when given a color tif but with greyscale image data (1 channel and 8 bits per pixel)" do
+    generate_test_image(TEST_TIF_INPUT_FILE,:color=>'gray',:image_type=>"TrueColor",:profile=>'')
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai).to_not have_color_profile
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"    
+  end
+  
+  it "should create a jp2 when the source image has no profile" do
+    generate_test_image(TEST_TIF_INPUT_FILE,:profile=>'') # generate a test input with no profile
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai).to_not have_color_profile
+    expect(@ai).to be_a_valid_image
+    expect(@ai).to be_jp2able
+    @ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+  end
+
+  it "should not run if the output file exists and you don't allow overwriting" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    generate_test_image(TEST_JP2_OUTPUT_FILE)
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect{@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE)}.to raise_error(SecurityError)
+  end
+
+  it "should get the correct image height and width" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect(@ai.height).to eq 100
+    expect(@ai.width).to eq 100
+  end
+  
+  it "should not run if the input file is a jp2" do
+    generate_test_image(TEST_JP2_OUTPUT_FILE)
+    expect(File).to exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
+    expect(@ai).to be_valid_image
+    expect(@ai).to_not be_jp2able
+    expect { @ai.create_jp2 }.to raise_error
+  end
+
+  it "should run if you specify a bogus output profile, because this is not currently an option" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    result=@ai.create_jp2(:output_profile=>'bogusness')
+    expect(result).to be_a_kind_of Assembly::Image
+    expect(result.path).to eq TEST_JP2_INPUT_FILE    
+    expect(TEST_JP2_INPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"     
+  end
+
+  it "should not run if you specify a bogus tmp folder" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    bogus_folder='/crapsticks'
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to_not exist bogus_folder
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    expect { @ai.create_jp2(:tmp_folder=>bogus_folder) }.to raise_error
+  end
+
+  it "should create a jp2 and preserve the temporary file if specified" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE, :preserve_tmp_source=>true)
+    expect(result).to be_a_kind_of Assembly::Image
+    expect(result.path).to eq TEST_JP2_OUTPUT_FILE    
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"    
+    expect(File.exists?(@ai.tmp_path)).to be true
+  end
+
+  it "should create jp2 of the same filename and in the same location as the input if no output file is specified, and should cleanup tmp file" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File.exists?(TEST_JP2_INPUT_FILE)).to be false
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    result=@ai.create_jp2
+    expect(result).to be_a_kind_of Assembly::Image
+    expect(result.path).to eq TEST_JP2_INPUT_FILE
+    expect(TEST_JP2_INPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"
+    expect(File.exists?(@ai.tmp_path)).to be false    
+  end
+
+  it "should create jp2 from input JPEG of the same filename and in the same location as the input if no output file is specified, and should cleanup tmp file" do
+    generate_test_image(TEST_JPEG_INPUT_FILE)
+    expect(File).to exist TEST_JPEG_INPUT_FILE
+    expect(File).to_not exist TEST_JP2_INPUT_FILE
+    @ai = Assembly::Image.new(TEST_JPEG_INPUT_FILE)
+    result=@ai.create_jp2
+    expect(result).to be_a_kind_of Assembly::Image
+    expect(result.path).to eq TEST_JP2_INPUT_FILE
+    expect(TEST_JP2_INPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"    
+    expect(File.exists?(@ai.tmp_path)).to be false    
+  end
+
+  it "should recreate jp2 if the output file exists and if you allow overwriting" do
+    generate_test_image(TEST_TIF_INPUT_FILE)
+    generate_test_image(TEST_JP2_OUTPUT_FILE)
+    expect(File).to exist TEST_TIF_INPUT_FILE
+    expect(File).to exist TEST_JP2_OUTPUT_FILE
+    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
+    result=@ai.create_jp2(:output => TEST_JP2_OUTPUT_FILE,:overwrite => true)
+    expect(result).to be_a_kind_of Assembly::Image
+    expect(result.path).to eq TEST_JP2_OUTPUT_FILE 
+    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+    expect(result.exif.colorspace).to eq "sRGB"           
+  end
+
+  after(:each) do
+    # after each test, empty out the input and output test directories
+    remove_files(TEST_INPUT_DIR)
+    remove_files(TEST_OUTPUT_DIR)
+  end
+
+end

data/spec/images_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Assembly::Images do
+
+  it "should not run if no input folder is passed in" do
+    expect{Assembly::Images.batch_generate_jp2('')}.to raise_error
+  end
+
+  it "should not run if a non-existent input folder is passed in" do
+    expect{Assembly::Images.batch_generate_jp2('/junk/path')}.to raise_error
+  end
+
+  it "should run and batch produe jp2s from input tiffs" do
+    ['test1','test2','test3'].each {|image| generate_test_image(File.join(TEST_INPUT_DIR,"#{image}.tif")) }
+    Assembly::Images.batch_generate_jp2(TEST_INPUT_DIR,:output=>TEST_OUTPUT_DIR)
+    expect(File.directory?(TEST_OUTPUT_DIR)).to be true
+    ['test1','test2','test3'].each {|image| expect(File.join(TEST_OUTPUT_DIR,"#{image}.jp2")).to be_a_jp2 }
+  end
+
+  it "should run and batch add color profile descriptions input tiffs with no color profile descriptions" do
+    ['test1','test2','test3'].each {|image| generate_test_image(File.join(TEST_INPUT_DIR,"#{image}.tif"),:profile=>'') }
+    ['test1','test2','test3'].each {|image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR,"#{image}.tif")).exif.profiledescription).to be nil}    
+    Assembly::Images.batch_add_exif_profile_description(TEST_INPUT_DIR,'Adobe RGB 1998')
+    ['test1','test2','test3'].each {|image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR,"#{image}.tif")).exif.profiledescription).to eq 'Adobe RGB (1998)'}    
+  end
+  
+  it "should run and batch add color profile descriptions input tiffs, forcing over existing color profile descriptions" do
+    ['test1','test2','test3'].each {|image| generate_test_image(File.join(TEST_INPUT_DIR,"#{image}.tif")) }
+    ['test1','test2','test3'].each {|image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR,"#{image}.tif")).exif.profiledescription).to eq  'sRGB IEC61966-2.1'}    
+    Assembly::Images.batch_add_exif_profile_description(TEST_INPUT_DIR,'Adobe RGB 1998',:force=>true) # force overwrite
+    ['test1','test2','test3'].each {|image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR,"#{image}.tif")).exif.profiledescription).to eq  'Adobe RGB (1998)'}    
+  end
+
+  it "should run and batch add color profile descriptions input tiffs, not overwriting existing color profile descriptions" do
+    ['test1','test2','test3'].each {|image| generate_test_image(File.join(TEST_INPUT_DIR,"#{image}.tif")) }
+    ['test1','test2','test3'].each {|image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR,"#{image}.tif")).exif.profiledescription).to eq  'sRGB IEC61966-2.1'}    
+    Assembly::Images.batch_add_exif_profile_description(TEST_INPUT_DIR,'Adobe RGB 1998') # do not force overwrite
+    ['test1','test2','test3'].each {|image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR,"#{image}.tif")).exif.profiledescription).to eq  'sRGB IEC61966-2.1'}    
+  end
+
+
+  after(:each) do
+    # after each test, empty out the input and output test directories
+    remove_files(TEST_INPUT_DIR)
+    remove_files(TEST_OUTPUT_DIR)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+bootfile = File.expand_path(File.dirname(__FILE__) + '/../config/boot')
+require bootfile
+
+TEST_INPUT_DIR       = File.join(Assembly::PATH_TO_IMAGE_GEM,'spec','test_data','input')
+TEST_OUTPUT_DIR      = File.join(Assembly::PATH_TO_IMAGE_GEM,'spec','test_data','output')
+TEST_TIF_INPUT_FILE  = File.join(TEST_INPUT_DIR,'test.tif')
+TEST_DPG_TIF_INPUT_FILE  = File.join(TEST_INPUT_DIR,'oo000oo0001_00_01.tif')
+TEST_JPEG_INPUT_FILE  = File.join(TEST_INPUT_DIR,'test.jpg')
+TEST_JP2_INPUT_FILE  = File.join(TEST_INPUT_DIR,'test.jp2')
+TEST_JP2_OUTPUT_FILE = File.join(TEST_OUTPUT_DIR,'test.jp2')
+TEST_DRUID           = "nx288wh8889"
+
+# generate a sample image file with a specified profile
+def generate_test_image(file,params={})
+  color=params[:color] || 'red'
+  profile=params[:profile] || 'sRGBIEC6196621'
+  image_type=params[:image_type]
+  create_command="convert -size 100x100 xc:#{color} "
+  create_command += " -profile " + File.join(Assembly::PATH_TO_IMAGE_GEM,'profiles',profile+'.icc') + " " unless profile == ''
+  create_command += " -type #{image_type} " if image_type
+  create_command += file
+  create_command += " 2>&1"
+  output = `#{create_command}`
+  unless $?.success?
+    raise "Failed to create test image #{file} (#{params}): \n#{output}"
+  end
+end
+
+def remove_files(dir)
+  Dir.foreach(dir) {|f| fn = File.join(dir, f); File.delete(fn) if !File.directory?(fn) && File.basename(fn) != '.empty'}
+end
+
+RSpec::Matchers.define :be_a_jp2 do
+  match do |actual|
+    if File.exists?(actual)
+      exif = MiniExiftool.new actual
+      exif['mimetype'] == 'image/jp2'
+    else
+      false
+    end
+  end
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: assembly-image
+version: !ruby/object:Gem::Version
+  version: 1.6.7
+platform: ruby
+authors:
+- Peter Mangiafico
+- Renzo Sanchez-Silva
+- Monty Hindman
+- Tony Calavano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: assembly-objectfile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+- !ruby/object:Gem::Dependency
+  name: mini_exiftool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Contains classes to create derivative image files and perform other image
+  operations
+email:
+- pmangiafico@stanford.edu
+executables:
+- console
+- run_all_tests
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rvmrc.example"
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- assembly-image.gemspec
+- bin/console
+- bin/run_all_tests
+- config/boot.rb
+- lib/assembly-image.rb
+- lib/assembly-image/image.rb
+- lib/assembly-image/images.rb
+- lib/assembly-image/version.rb
+- profiles/AdobeRGB1998.icc
+- profiles/DotGain20.icc
+- profiles/sRGBIEC6196621.icc
+- spec/image_spec.rb
+- spec/images_spec.rb
+- spec/spec_helper.rb
+- spec/test_data/input/.empty
+- spec/test_data/output/.empty
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: assembly-image
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby immplementation of image services needed to prepare objects to be accessioned
+  in SULAIR digital library
+test_files:
+- spec/image_spec.rb
+- spec/images_spec.rb
+- spec/spec_helper.rb
+- spec/test_data/input/.empty
+- spec/test_data/output/.empty
+has_rdoc: