assembly-image 1.8.0 → 2.1.0

data/spec/assembly/image/jp2_creator_spec.rb

@@ -3,56 +3,345 @@
 require 'spec_helper'
 
 RSpec.describe Assembly::Image::Jp2Creator do
-  subject(:result) { creator.create }
+  let(:jp2creator) { described_class.new(assembly_image, output: jp2_output_file) }
+  let(:assembly_image) { Assembly::Image.new(input_path) }
+  let(:jp2_output_file) { File.join(TEST_OUTPUT_DIR, 'test.jp2') }
 
-  let(:ai) { Assembly::Image.new(input_path) }
-  let(:input_path) { TEST_TIF_INPUT_FILE }
-  let(:creator) { described_class.new(ai, output: TEST_JP2_OUTPUT_FILE) }
+  describe '.create' do
+    subject(:result) { jp2creator.create }
 
-  after do
-    # after each test, empty out the input and output test directories
-    remove_files(TEST_INPUT_DIR)
-    remove_files(TEST_OUTPUT_DIR)
-  end
+    let(:input_path) { TEST_TIF_INPUT_FILE }
+
+    before { cleanup }
+
+    context 'when input path is blank' do
+      let(:input_path) { '' }
 
-  context 'when given an LZW compressed RGB tif' do
-    before do
-      generate_test_image(TEST_TIF_INPUT_FILE, compress: 'lzw')
+      it 'raises error' do
+        expect { assembly_image.create_jp2 }.to raise_error(RuntimeError, 'input file  does not exist or is a directory')
+      end
     end
 
-    it 'creates the jp2 with a temp file' do
-      expect(File).to exist TEST_TIF_INPUT_FILE
-      expect(File).not_to exist 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
+    context 'when tmp folder does not exist' do
+      before do
+        generate_test_image(input_path)
+      end
 
-      # Indicates a temp tiff was not created.
-      expect(creator.tmp_path).not_to be_nil
-      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
+      it 'raises error' do
+        bogus_folder = '/nonexisting'
+        expect(File).not_to exist bogus_folder
+        expect { assembly_image.create_jp2(tmp_folder: bogus_folder) }.to raise_error(RuntimeError, 'tmp_folder /nonexisting does not exist')
+      end
     end
-  end
 
-  context 'when the input file is a JPEG' do
-    before do
-      generate_test_image(TEST_JPEG_INPUT_FILE)
+    context 'when no output file is specified' do
+      let(:jp2creator) { described_class.new(assembly_image) }
+      let(:jp2_output_file) { File.join(TEST_INPUT_DIR, File.basename(input_path).gsub('.tif', '.jp2')) }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'creates a jp2 of the same filename and in the same location as the input' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result).to be_a_kind_of Assembly::Image
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+      end
+    end
+
+    context 'when the output file exists and no 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 'raises error' do
+        expect(File).to exist input_path # test image was generated
+        expect { assembly_image.create_jp2(output: jp2_output_file) }.to raise_error(SecurityError, %r{spec/test_data/output/test.jp2 exists, cannot overwrite})
+      end
+    end
+
+    context 'when the output file exists and overwriting allowed' 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 # test image was generated
+        expect(File).to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        result = assembly_image.create_jp2(output: jp2_output_file, overwrite: true)
+        expect(result).to be_a_kind_of Assembly::Image
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+      end
+    end
+
+    context 'when the input file is a jp2' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'for_jp2.tif') }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'raises error' do
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        expect { described_class.new(Assembly::Image.new(jp2_output_file)).create }.to raise_error(RuntimeError, 'input file is not a valid image, or is the wrong mimetype')
+      end
+    end
+
+    context 'when given a tiff' do
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'gets the correct image, creates and cleans up the temporary tiff' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+
+        expect(result).to be_a_kind_of Assembly::Image
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check height and width on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.height).to eq 36
+        expect(tmp_tiff_image.width).to eq 43
+
+        expect(jp2creator.tmp_tiff_path).not_to be_nil # temporary tiff was created
+        expect(File).not_to exist jp2creator.tmp_tiff_path # the temporary tiff path is cleaned up
+      end
+    end
+
+    context 'when given an LZW compressed RGB tif' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'lzw.tif') }
+
+      before do
+        generate_test_image(input_path, compress: 'lzw')
+      end
+
+      it 'creates the jp2' do
+        expect(File).to exist input_path
+        expect(File).not_to exist jp2_output_file
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check height and width on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.height).to eq 36
+        expect(tmp_tiff_image.width).to eq 43
+      end
     end
 
-    let(:input_path) { TEST_JPEG_INPUT_FILE }
+    context 'when given a cmyk tif' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'test-cmyk.tif') }
+
+      before do
+        generate_test_image(input_path, color: 'cmyk', cg_type: 'cmyk', profile: 'cmyk', bands: 4)
+      end
+
+      it 'creates an srgb jp2' do
+        expect(File).to exist input_path
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be false
+        expect(assembly_image.vips_image.interpretation).to eq :cmyk
+        expect(assembly_image.has_profile?).to be true
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # NOTE: we verify the CMYK has been converted to an SRGB JP2 correctly by using ruby-vips;
+        #   we have to verify this on the *temporary tiff because lipvips pkg available for circleci does not speak JP2
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be true
+      end
+    end
+
+    context 'when the input file is a JPEG' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'test.jpg') }
+
+      before do
+        generate_test_image(input_path)
+      end
+
+      it 'creates jp2 when given a JPEG' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+        # check height and width on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.height).to eq 36
+        expect(tmp_tiff_image.width).to eq 43
+      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 color jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+      end
+    end
+
+    context 'when given a bitonal tif with bitonal image data' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'bitonal.tif') }
+
+      before do
+        # depth of 1 says 1 bit per pixel.
+        generate_test_image(input_path, color: 'bin', bands: 1, depth: 1)
+      end
+
+      it 'creates bitonal jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be false
+        expect(assembly_image.vips_image.interpretation).to eq :'b-w'
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be false
+        expect(tmp_tiff_image.has_profile?).to be false
+        vips_for_tmp_tiff = tmp_tiff_image.vips_image
+        expect(vips_for_tmp_tiff.bands).to eq 1
+        expect(vips_for_tmp_tiff.interpretation).to eq :'b-w'
+      end
+    end
+
+    context 'when given a color tif but bitonal image data' do
+      # NOTE: this spec was created due to ImageMagick weirdness processing this wrinkle
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'color.tif') }
+
+      before do
+        # from Tony Calavano:
+        #  color: bin should threshold the pixel data to 0 or 255, bands: 3 forces it to be rgb.
+        #  It should then create a 8 bits per pixel image
+        generate_test_image(input_path, color: 'bin', bands: 3)
+      end
+
+      it 'creates color jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+        expect(tmp_tiff_image.vips_image.bands).to eq 3
+      end
+    end
+
+    context 'when given a grayscale tif but with bitonal image data' do
+      # NOTE: this spec was created due to ImageMagick weirdness processing this wrinkle
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'gray.tif') }
+
+      before do
+        # from Tony Calavano:  color: grey, bands: 1 would be a normal grayscale image with 8 bits per pixel
+        generate_test_image(input_path, color: 'bin', bands: 1)
+      end
+
+      it 'creates grayscale jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be false
+        expect(assembly_image.has_profile?).to be false
+        expect(assembly_image.vips_image.interpretation).to eq :'b-w'
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be false
+        expect(tmp_tiff_image.has_profile?).to be false
+        vips_for_tmp_tiff = tmp_tiff_image.vips_image
+        expect(vips_for_tmp_tiff.bands).to eq 1
+        expect(vips_for_tmp_tiff.interpretation).to eq :'b-w'
+      end
+    end
+
+    context 'when given a color tif but with grayscale image data (3 channels and 8 bits per pixel)' do
+      let(:input_path) { File.join(TEST_INPUT_DIR, 'color_gray.tif') }
+
+      before do
+        # this is bands: 3 with 8 bits per pixel
+        generate_test_image(input_path, color: 'grey')
+      end
+
+      it 'creates color jp2 without ICC profile' do
+        expect(File).to exist input_path # test image was generated
+        expect(File).not_to exist jp2_output_file
+        expect(assembly_image.srgb?).to be true
+        expect(assembly_image.has_profile?).to be false
+
+        expect(result.path).to eq jp2_output_file
+        expect(result.mimetype).to eq 'image/jp2'
+
+        # check srgb on temporary tiff (due to CI libvips not speaking jp2)
+        tmp_tiff_image = Assembly::Image.new(jp2creator.send(:make_tmp_tiff))
+        expect(tmp_tiff_image.srgb?).to be true
+        expect(tmp_tiff_image.has_profile?).to be false
+        vips_for_tmp_tiff = tmp_tiff_image.vips_image
+        expect(vips_for_tmp_tiff.bands).to eq 3
+      end
+    end
+  end
+
+  describe '#make_tmp_tiff' do
+    subject(:tiff_file) { jp2creator.send(:make_tmp_tiff) }
 
-    it 'creates jp2 when given a JPEG' do
-      expect(File).to exist TEST_JPEG_INPUT_FILE
-      expect(File).not_to exist 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
+    let(:input_path) { 'spec/test_data/color_rgb_srgb_rot90cw.tif' }
+    let(:vips_output) { Vips::Image.new_from_file(tiff_file) }
+    let(:plum) { [94.0, 58.0, 101.0] }
 
-      # Indicates a temp tiff was created.
-      expect(creator.tmp_path).not_to be_nil
-      expect(File).not_to exist creator.tmp_path
+    context 'when given a tiff with a rotation hint' do
+      it 'rotates it' do
+        expect(Vips::Image.new_from_file(input_path).getpoint(3, 3)).not_to eq plum
+        expect(vips_output.getpoint(3, 3)).to eq plum
+      end
     end
   end
 end

data/spec/assembly/image_spec.rb

@@ -0,0 +1,25 @@
+# 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 }
+
+  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
+end

data/spec/spec_helper.rb

@@ -5,17 +5,14 @@ SimpleCov.start do
   add_filter 'spec'
 end
 
-bootfile = File.expand_path(File.dirname(__FILE__) + '/../config/boot')
+bootfile = File.expand_path("#{File.dirname(__FILE__)}/../config/boot")
 require bootfile
+require 'pry-byebug'
 
 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'
 
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate
@@ -101,45 +98,134 @@ RSpec.configure do |config|
   Kernel.srand config.seed
 end
 
+# rubocop:disable Metrics/MethodLength
+# Color values for 30-patch ColorGauge color target.
+def color_gauge_values(type = 'adobeRGB')
+  # rubocop:disable Layout/SpaceInsideArrayLiteralBrackets
+  # rubocop:disable Layout/ExtraSpacing
+  adobe_rgb = [
+    [109,  83,  71],  [187, 146, 129], [101, 120, 151], [ 97, 108,  68], [130, 128, 172],
+    [130, 187, 171],  [ 64, 134, 165], [241, 242, 237], [231, 232, 229], [216, 217, 215],
+    [203, 204, 203],  [202, 125,  55], [172,  87, 147], [174, 176, 175], [148, 150, 149],
+    [116, 119, 118],  [ 91,  91,  92], [ 78,  92, 165], [227, 198,  55], [ 68,  70,  69],
+    [ 48,  48,  48],  [ 32,  32,  32], [ 23,  23,  23], [175,  85,  97], [157,  60,  61],
+    [100, 148,  80],  [ 53,  67, 141], [213, 160,  56], [167, 187,  77], [ 86,  61, 100]
+  ]
+
+  srgb = [
+    [118,  82,  69], [202, 147, 129], [ 92, 121, 154], [ 92, 109,  64], [132, 129, 175],
+    [ 96, 188, 172], [  0, 135, 168], [241, 242, 237], [231, 232, 229], [217, 218, 216],
+    [204, 205, 204], [225, 126,  46], [196,  86, 150], [175, 178, 177], [148, 151, 150],
+    [116, 120, 119], [ 91,  91,  92], [ 70,  92, 169], [238, 199,  27], [ 65,  68,  67],
+    [ 44,  44,  44], [ 26,  26,  26], [ 16,  16,  16], [200,  84,  97], [181,  57,  58],
+    [ 68, 149,  74], [ 42,  65, 145], [231, 161,  41], [160, 188,  65], [ 94,  58, 101]
+  ]
+
+  cmyk = [
+    [120, 154, 169,  84], [ 69, 110, 120,   5], [169, 125,  64,   8], [154, 105, 207,  64],
+    [138, 125,  31,   0], [128,  26,  95,   0], [195,  95,  61,   3], [ 10,   5, 13,    0],
+    [ 20,  13,  18,   0], [ 36,  26,  31,   0], [ 51,  38,  41,   0], [ 46, 143, 236,   8],
+    [ 90, 202,  31,   0], [ 84,  64,  69,   0], [115,  90,  95,   0], [143, 115, 120,  28],
+    [161, 141, 136,  69], [205, 182,   8,   0], [ 33,  46, 238,   0], [172, 151, 151, 110],
+    [179, 164, 161, 156], [184, 169, 166, 189], [187, 172, 166, 205], [ 69, 197, 131,  20],
+    [ 69, 220, 189,  51], [161,  59, 223,  15], [241, 223,  28,   5], [ 44,  95, 238,   3],
+    [100,  31, 228,   0], [184, 210,  90,  56]
+  ]
+  # rubocop:enable Layout/SpaceInsideArrayLiteralBrackets
+  # rubocop:enable Layout/ExtraSpacing
+  case type
+  when 'adobe_rgb'
+    adobe_rgb
+  when 'srgb'
+    srgb
+  when 'cmyk'
+    cmyk
+  else
+    raise 'Unknown color_gauge_values type.'
+  end
+end
+# rubocop:enable Metrics/MethodLength
+
 # generate a sample image file with a specified profile
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/CyclomaticComplexity
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/PerceivedComplexity
 def generate_test_image(file, params = {})
-  width = params[:width] || '100'
-  height = params[:height] || '100'
-  color = params[:color] || 'TrueColor'
-  profile = params[:profile] || 'sRGBIEC6196621'
-  image_type = params[:image_type]
-  create_command = "convert rose: -scale #{width}x#{height}\! -type #{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 += ' -compress lzw ' if params[:compress]
-  create_command += file
-  create_command += ' 2>&1'
-  output = `#{create_command}`
-  raise "Failed to create test image #{file} (#{params}): \n#{output}" unless $CHILD_STATUS.success?
+  # Set default size for sample test image.
+  line_size = 1
+  box_size = 6
+  width = (box_size * 6) + (line_size * 7)
+  height = (box_size * 5) + (line_size * 6)
+
+  # Set parameters for image creation options.
+  image_type  = params[:image_type] || File.extname(file)
+  bands       = params[:bands] || 3
+  color       = params[:color] || 'rgb'
+  depth       = params[:depth] || 8
+  cg_type     = params[:cg_type] || 'adobe_rgb'
+  compression = params[:compression]
+  profile     = params[:profile]
+
+  temp_array = color_gauge_values(cg_type)
+  temp_image = Vips::Image.black(width, height, bands: temp_array.first.size)
+  (0..4).each do |i|
+    b = (box_size * i) + (line_size * (i + 1))
+    # d = b + box_size - line_size
+    (0...6).each do |j|
+      a = (box_size * j) + (line_size * (j + 1))
+      # c = a + box_size - line_size
+      colors = temp_array.shift
+      temp_image = temp_image.draw_rect(colors, a, b, box_size, box_size, fill: true)
+    end
+  end
+
+  temp_image = color.eql?('cmyk') ? temp_image.copy(interpretation: :cmyk) : temp_image.copy(interpretation: :srgb)
+
+  temp_image = if color.eql?('grey') && bands == 3
+                 mean = temp_image.bandmean
+                 Vips::Image.bandjoin([mean, mean, mean])
+               elsif color.eql?('grey') && bands == 1
+                 temp_image.bandmean
+               elsif color.eql?('bin') && bands == 3
+                 mean = temp_image.bandmean < 128
+                 Vips::Image.bandjoin([mean, mean, mean])
+               elsif color.eql?('bin') && bands == 1
+                 temp_image.bandmean < 128
+               else
+                 temp_image
+               end
+
+  options = {}
+  unless profile.nil?
+    profile_file = File.join(Assembly::PATH_TO_IMAGE_GEM, 'profiles', "#{profile}.icc")
+    options.merge!(profile: profile_file)
+  end
+
+  case image_type
+  when '.tiff', '.tif'
+    options.merge!(compression: compression) unless compression.nil?
+    options.merge!(squash: true) if depth.eql?(1)
+    temp_image.tiffsave(file, **options)
+  when '.jpeg', '.jpg'
+    temp_image.jpegsave(file, **options)
+  else
+    raise "unknown type: #{image_type}"
+  end
 end
 # rubocop:enable Metrics/AbcSize
 # rubocop:enable Metrics/CyclomaticComplexity
 # rubocop:enable Metrics/MethodLength
 # rubocop:enable Metrics/PerceivedComplexity
 
+def cleanup
+  remove_files(TEST_INPUT_DIR)
+  remove_files(TEST_OUTPUT_DIR)
+end
+
 def remove_files(dir)
   Dir.foreach(dir) do |f|
     fn = File.join(dir, f)
     File.delete(fn) if !File.directory?(fn) && File.basename(fn) != '.empty'
   end
 end
-
-RSpec::Matchers.define :be_a_jp2 do
-  match do |actual|
-    if File.exist?(actual)
-      exif = MiniExiftool.new actual
-      exif['mimetype'] == 'image/jp2'
-    else
-      false
-    end
-  end
-end