assembly-image 2.0.0 → 2.1.0

data/lib/assembly-image/image.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby-vips'
-require 'assembly-objectfile'
-require_relative 'jp2_creator'
-
-module Assembly
-  # The Image class contains methods to operate on an image.
-  class Image < Assembly::ObjectFile
-    # 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
-
-    # Examines the input image to determine if it is compressed.
-    #
-    # @return [boolean] true if image is compressed, false if not.
-    #
-    # Example:
-    #   source_img=Assembly::ObjectFile.new('/input/path_to_file.tif')
-    #   puts source_img.compressed? # gives true
-    # def compressed?
-    #   exif.compression != 'Uncompressed'
-    # 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)
-      if profile.nil? || force
-        input_profile = profile_name.gsub(/[^[:alnum:]]/, '') # remove all non alpha-numeric characters, so we can get to a filename
-        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 $CHILD_STATUS.success?
-      end
-    rescue StandardError => e
-      puts "** Error for #{filename}: #{e.message}"
-    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
-
-    # 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
-    #
-    # 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'
-    # rubocop:disable Metrics/CyclomaticComplexity:
-    def create_jp2(params = {})
-      Jp2Creator.create(self, params)
-    end
-
-    def samples_per_pixel
-      if exif['samplesperpixel']
-        exif['samplesperpixel'].to_i
-      else
-        case mimetype
-        when 'image/tiff'
-          1
-        when 'image/jpeg'
-          3
-        end
-      end
-    end
-
-    # Get size of image data in bytes
-    def image_data_size
-      (samples_per_pixel * height * width * bits_per_sample) / 8
-    end
-
-    private
-
-    # rubocop:enable Metrics/CyclomaticComplexity
-    def bits_per_sample
-      if exif['bitspersample']
-        exif['bitspersample'].to_i
-      else
-        case mimetype
-        when 'image/tiff'
-          1
-        end
-      end
-    end
-  end
-end

data/lib/assembly-image/images.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-    class << self
-      attr_writer :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')
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/AbcSize
-    def self.batch_add_exif_profile_descr(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)
-
-      # 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
-      'Complete'
-    end
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/AbcSize
-
-    # 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')
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/AbcSize
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/PerceivedComplexity
-    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)
-
-      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
-          source_img.create_jp2(overwrite: overwrite, output: output_img)
-          logger.debug "Generated jp2 for #{File.basename(file)}"
-        rescue StandardError => e
-          logger.debug "** Error for #{File.basename(file)}: #{e.message}"
-        end
-      end
-      'Complete'
-    end
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/AbcSize
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
-  end
-end

data/spec/image_spec.rb

@@ -1,324 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'fileutils'
-
-RSpec.describe Assembly::Image do
-  let(:assembly_image) { described_class.new(input_path) }
-  let(:input_path) { TEST_TIF_INPUT_FILE }
-  let(:jp2_output_file) { File.join(TEST_OUTPUT_DIR, File.basename(input_path).gsub('.tif', '.jp2')) }
-
-  before { cleanup }
-
-  describe '#jp2_filename' do
-    it 'indicates the default jp2 filename' do
-      expect(assembly_image.jp2_filename).to eq input_path.gsub('.tif', '.jp2')
-    end
-
-    context 'with a file with no extension' do
-      let(:input_path) { '/path/to/a/file_with_no_extension' }
-
-      it 'indicates the default jp2 filename' do
-        expect(assembly_image.jp2_filename).to eq '/path/to/a/file_with_no_extension.jp2'
-      end
-    end
-  end
-
-  describe '#create_jp2' do
-    context 'when input path is blank' do
-      let(:input_path) { '' }
-
-      it 'does not run if no input file is passed in' do
-        expect { assembly_image.create_jp2 }.to raise_error(RuntimeError)
-      end
-    end
-
-    context 'when given an uncompressed compressed RGB tif with more than 4GB of image data', skip: 'This test will create a 4GB test image and a 4GB temporary image, so skipping by default.' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'rgb.tif') }
-
-      before do
-        generate_test_image(input_path, compress: 'none', width: '37838', height: '37838')
-      end
-
-      it 'creates the jp2 with a temp file' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(assembly_image.tmp_path).not_to be_nil
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        expect(result.exif.colorspace).to eq 'sRGB'
-        expect(result.height).to eq 37_838
-        expect(result.width).to eq 37_838
-      end
-    end
-
-    context 'when given an LZW compressed RGB tif with more than 4GB of image data', skip: 'This test will create a 4GB temporary image, so skipping by default.' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'lzw.tif') }
-
-      before do
-        generate_test_image(input_path, compress: 'lzw', width: '37838', height: '37838')
-      end
-
-      it 'creates the jp2 with a temp file' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image.exif.samplesperpixel).to be 3
-        expect(assembly_image.exif.bitspersample).to eql '8 8 8'
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2abl
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(assembly_image.tmp_path).not_to be_nil
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        expect(result.exif.colorspace).to eq 'sRGB'
-        expect(result.height).to eq 37_838
-        expect(result.width).to eq 37_838
-      end
-    end
-
-    context 'when given a bitonal tif' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'bitonal.tif') }
-
-      before do
-        generate_test_image(input_path, color: 'bin', bands: 1, depth: 1)
-      end
-
-      it 'creates valid jp2' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image.exif.samplesperpixel).to be 1
-        expect(assembly_image.exif.bitspersample).to be 1
-        expect(assembly_image).not_to have_color_profile
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        expect(result.exif.colorspace).to eq 'Grayscale'
-      end
-    end
-
-    context 'when given a color tif but bitonal image data (1 channels and 1 bits per pixel)' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'color.tif') }
-
-      before do
-        generate_test_image(input_path, color: 'bin', bands: 3)
-      end
-
-      it 'creates color jp2' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image).not_to have_color_profile
-        expect(assembly_image.exif.samplesperpixel).to be 3
-        expect(assembly_image.exif.bitspersample).to eql '8 8 8'
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2able
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        expect(result.exif.colorspace).to eq 'sRGB'
-      end
-    end
-
-    context 'when given a graycale tif but with bitonal image data (1 channel and 1 bits per pixel)' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'gray.tif') }
-
-      before do
-        generate_test_image(input_path, color: 'grey', bands: 1)
-      end
-
-      it 'creates grayscale jp2' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image).not_to have_color_profile
-        expect(assembly_image.exif.samplesperpixel).to be 1
-        expect(assembly_image.exif.bitspersample).to be 8
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2able
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(jp2_output_file).to be_a_jp2
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(result.exif.colorspace).to eq 'Grayscale'
-      end
-    end
-
-    context 'when given a color tif but with greyscale image data (1 channel and 8 bits per pixel)' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'color_gray.tif') }
-
-      before do
-        generate_test_image(input_path, color: 'grey')
-      end
-
-      it 'creates color jp2' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image.exif.samplesperpixel).to be 3
-        expect(assembly_image.exif.bitspersample).to eql '8 8 8'
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2able
-        expect(assembly_image).not_to have_color_profile
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        expect(result.exif.colorspace).to eq 'sRGB'
-      end
-    end
-
-    context 'when given a cmyk tif' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'cmky.tif') }
-
-      before do
-        generate_test_image(input_path, color: 'cmyk', cg_type: 'cmyk', profile: 'cmyk', bands: 4)
-      end
-
-      it 'creates an srgb jp2', skip: 'Need to verify the color space is correct in jp2' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image.exif.samplesperpixel).to be 4
-        expect(assembly_image.exif.bitspersample).to eql '8 8 8 8'
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2able
-        expect(assembly_image).to have_color_profile
-        result = assembly_image.create_jp2(output: jp2_output_file)
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        # note, we verify the CMYK has been converted to an SRGB JP2 correctly by using ruby-vips instead of exif, since exif does not correctly
-        #  identify the color space...note: this line current does not work in circleci, potentially due to libvips version differences
-        expect(Vips::Image.new_from_file(jp2_output_file).get_value('interpretation')).to eq :srgb
-      end
-    end
-
-    context 'when the source image has no profile' do
-      let(:input_path) { File.join(TEST_INPUT_DIR, 'no_profile.tif') }
-
-      before do
-        generate_test_image(input_path)
-      end
-
-      it 'creates a jp2' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image.exif.samplesperpixel).to be 3
-        expect(assembly_image.exif.bitspersample).to eql '8 8 8'
-        expect(assembly_image).not_to have_color_profile
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2able
-        assembly_image.create_jp2(output: jp2_output_file)
-        expect(jp2_output_file).to be_a_jp2
-      end
-    end
-
-    context "when the output file exists and you don't allow overwriting" do
-      before do
-        generate_test_image(input_path)
-        FileUtils.touch(jp2_output_file) # just need a file with this name, don't care what
-      end
-
-      it 'does not run' do
-        expect(File).to exist input_path
-        expect(File).to exist jp2_output_file
-        expect { assembly_image.create_jp2(output: jp2_output_file) }.to raise_error(SecurityError)
-      end
-    end
-
-    context 'when given a test tiff' do
-      before do
-        generate_test_image(input_path)
-      end
-
-      it 'gets the correct image height and width' do
-        expect(assembly_image.height).to eq 36
-        expect(assembly_image.width).to eq 43
-      end
-    end
-
-    context 'when the input file is a jp2' do
-      before do
-        generate_test_image(input_path)
-      end
-
-      it 'does not run' do
-        expect(File).to exist input_path
-        expect(File).not_to exist jp2_output_file
-        expect(assembly_image).not_to have_color_profile
-        expect(assembly_image).to be_a_valid_image
-        expect(assembly_image).to be_jp2able
-        assembly_image.create_jp2(output: jp2_output_file)
-        expect(jp2_output_file).to be_a_jp2
-        jp2_file = described_class.new(jp2_output_file)
-        expect(jp2_file).to be_valid_image
-        expect(jp2_file).not_to be_jp2able
-        expect { jp2_file.create_jp2 }.to raise_error(RuntimeError)
-      end
-    end
-
-    context 'when you specify a bogus output profile' do
-      before do
-        generate_test_image(input_path)
-      end
-
-      it 'runs, because this is not currently an option' do
-        expect(File).to exist input_path
-        result = assembly_image.create_jp2(output_profile: 'bogusness')
-        expect(result).to be_a_kind_of described_class
-        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
-    end
-
-    context 'when an invalid tmp folder' do
-      before do
-        generate_test_image(TEST_JPEG_INPUT_FILE)
-      end
-
-      let(:input_path) { TEST_JPEG_INPUT_FILE }
-
-      it 'does not run' do
-        bogus_folder = '/crapsticks'
-        expect(File).to exist TEST_JPEG_INPUT_FILE
-        expect(File).not_to exist bogus_folder
-        expect { assembly_image.create_jp2(tmp_folder: bogus_folder) }.to raise_error(RuntimeError)
-      end
-    end
-
-    context 'when no output file is specified' do
-      before do
-        generate_test_image(input_path)
-      end
-
-      it 'creates a jp2 of the same filename and in the same location as the input and cleans up the tmp file' do
-        expect(File).to exist input_path
-        expect(File.exist?(TEST_JP2_INPUT_FILE)).to be false
-        result = assembly_image.create_jp2
-        expect(result).to be_a_kind_of described_class
-        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
-    end
-
-    context 'when the output file exists and you allow overwriting' do
-      before do
-        generate_test_image(input_path)
-        FileUtils.touch(jp2_output_file) # just need a file with this name, don't care what
-      end
-
-      it 'recreates jp2' do
-        expect(File).to exist input_path
-        expect(File).to exist jp2_output_file
-        result = assembly_image.create_jp2(output: jp2_output_file, overwrite: true)
-        expect(result).to be_a_kind_of described_class
-        expect(result.path).to eq jp2_output_file
-        expect(jp2_output_file).to be_a_jp2
-        expect(result.exif.colorspace).to eq 'sRGB'
-      end
-    end
-  end
-end

data/spec/images_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Assembly::Images do
-  before { cleanup }
-
-  describe '#batch_generate_jp2' do
-    it 'does not run if no input folder is passed in' do
-      expect{ described_class.batch_generate_jp2('') }.to raise_error(RuntimeError)
-    end
-
-    it 'does not run if a non-existent input folder is passed in' do
-      expect{ described_class.batch_generate_jp2('/junk/path') }.to raise_error(RuntimeError)
-    end
-
-    it 'runs and batch produces jp2s from input tiffs' do
-      ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif"), profile: 'AdobeRGB1998') }
-      described_class.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
-  end
-
-  describe '#batch_add_exif_profile_descr' do
-    it 'runs and batch adds color profile descriptions to input tiffs that had no 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 be_nil }
-      described_class.batch_add_exif_profile_descr(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 'runs and batch adds color profile descriptions to input tiffs, forcing over existing color profile descriptions' do
-      ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif"), profile: 'sRGBIEC6196621') }
-      ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'sRGB IEC61966-2.1' }
-      described_class.batch_add_exif_profile_descr(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 'runs and batch adds color profile descriptions to input tiffs, not overwriting existing color profile descriptions' do
-      ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif"), profile: 'sRGBIEC6196621') }
-      ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'sRGB IEC61966-2.1' }
-      described_class.batch_add_exif_profile_descr(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
-  end
-end