qttk 0.1.0

data/lib/quadtone/quad_file.rb

@@ -0,0 +1,59 @@
+module Quadtone
+
+  class QuadFile
+
+    attr_accessor :curve_set
+
+    ChannelAliases = {
+      'C' => 'c',
+      'M' => 'm',
+      'Y' => 'y',
+      'K' => 'k',
+      'c' => 'lc',
+      'm' => 'lm',
+      'k' => 'lk',
+    }
+
+    def initialize(profile)
+      @profile = profile
+      @curve_set = CurveSet.new(channels: [], profile: @profile, type: :separation)
+      load(@profile.quad_file_path)
+    end
+
+    # Read QTR quad (curve) file
+
+    def load(quad_file)
+      ;;warn "reading #{quad_file}"
+      lines = Pathname.new(quad_file).open.readlines.map { |line| line.chomp.force_encoding('ISO-8859-1') }
+      # process header
+      channels = parse_channel_list(lines.shift)
+      channels.each do |channel|
+        samples = (0..255).to_a.map do |input|
+          lines.shift while lines.first =~ /^#/
+          line = lines.shift
+          line =~ /^(\d+)$/ or raise "Unexpected value: #{line.inspect}"
+          output = $1.to_i
+          Sample.new(input: Color::Gray.new(k: 100 * (input / 255.0)), output: Color::Gray.new(k: 100 * (output / 65535.0)))
+        end
+        if @profile.inks.include?(channel)
+          @curve_set.curves << Curve.new(channel: channel, samples: samples)
+        end
+      end
+    end
+
+    def parse_channel_list(line)
+      # "## QuadToneRIP K,C,M,Y,LC,LM"
+      # "## QuadToneRIP KCMY"
+      line =~ /^##\s+QuadToneRIP\s+(.*)$/ or raise "Unexpected header line: #{line.inspect}"
+      channel_list = $1
+      case channel_list
+      when /,/
+        channel_list.split(',')
+      else
+        channel_list.chars.map { |c| ChannelAliases[c] }
+      end.map { |c| c.downcase.to_sym }
+    end
+
+  end
+
+end

data/lib/quadtone/renderer.rb

@@ -0,0 +1,139 @@
+module Quadtone
+
+  class Renderer
+
+    attr_accessor :gamma
+    attr_accessor :rotate
+    attr_accessor :compress
+    attr_accessor :page_size
+    attr_accessor :resolution
+    attr_accessor :desired_size
+
+    def initialize(params={})
+      @compress = true
+      @resolution = 720
+      params.each { |k, v| send("#{k}=", v) }
+    end
+
+    def render(input_path)
+      @input_path = input_path
+
+      raise "Page size required" unless @page_size
+
+      # Scale measurements to specified resolution
+
+      @page_size.width = (@page_size.width / 72.0 * @resolution).to_i
+      @page_size.height = (@page_size.height / 72.0 * @resolution).to_i
+      @page_size.imageable_width = (@page_size.imageable_width / 72.0 * @resolution).to_i
+      @page_size.imageable_height = (@page_size.imageable_height / 72.0 * @resolution).to_i
+      @page_size.margin.left = (@page_size.margin.left / 72.0 * @resolution).to_i
+      @page_size.margin.right = (@page_size.margin.right / 72.0 * @resolution).to_i
+      @page_size.margin.top = (@page_size.margin.top / 72.0 * @resolution).to_i
+      @page_size.margin.bottom = (@page_size.margin.bottom / 72.0 * @resolution).to_i
+
+      if @desired_size
+        @desired_size.width = (@desired_size.width * @resolution).to_i
+        @desired_size.height = (@desired_size.height * @resolution).to_i
+        if @desired_size.width > @page_size.imageable_width || @desired_size.height > @page_size.imageable_height
+          raise "Image too large for page size (#{@page_size.name})"
+        end
+      else
+        @desired_size = HashStruct.new(width: @page_size.imageable_width, height: @page_size.imageable_height)
+      end
+
+      ;;warn "Reading #{@input_path} @ #{@resolution}dpi"
+      r = @resolution  # have to alias to avoid referring to ImageList object
+      image_list = Magick::ImageList.new(@input_path) {
+        self.density = r
+      }
+      output_paths = []
+      image_list.each_with_index do |image, image_index|
+        @current_image = image
+        @current_image_index = image_index
+        ;;warn "\t" + "Processing sub-image \##{@current_image_index}"
+        show_info
+        delete_profiles
+        convert_to_16bit
+        apply_gamma
+        rotate
+        resize
+        extend_to_page
+        crop_to_imageable_area
+        show_info
+        output_paths << write_to_file
+      end
+      output_paths
+    end
+
+    def output_path
+      params = []
+      params << "#{@desired_size.width}x#{@desired_size.height}"
+      params << @page_size.name
+      params << "@#{@resolution}"
+      params << "g#{@gamma}" if @gamma
+      @input_path.with_extname(".out-#{params.join('-')}.#{@current_image_index}.png")
+    end
+
+    def show_info
+      ;;warn "\t\t" + @current_image.inspect
+    end
+
+    def delete_profiles
+      ;;warn "\t\t" + "Deleting profiles"
+      @current_image.delete_profile('*')
+    end
+
+    def convert_to_16bit
+      ;;warn "\t\t" + "Changing to grayscale"
+      @current_image = @current_image.quantize(2 ** 16, Magick::GRAYColorspace)
+    end
+
+    def apply_gamma
+      if @gamma
+        ;;warn "\t\t" + "Applying gamma #{@gamma}"
+        @current_image = @current_image.gamma_correct(@gamma)
+      end
+    end
+
+    def rotate
+      if @rotate
+        ;;warn "\t\t" + "Rotating #{@rotate}°"
+        @current_image.rotate!(@rotate)
+      elsif (@current_image.columns.to_f / @current_image.rows) > (@page_size.width.to_f / @page_size.height)
+        ;;warn "\t\t" + "Auto-rotating 90°"
+        @current_image.rotate!(90)
+      end
+    end
+
+    def resize
+      ;;warn "\t\t" + "Resizing to desired size"
+      @current_image.resize_to_fit!(@desired_size.width, @desired_size.height)
+    end
+
+    def extend_to_page
+      ;;warn "\t\t" + "Extending canvas to page area"
+      @current_image = @current_image.extent(
+        @page_size.width,
+        @page_size.height,
+        -(@page_size.width - @current_image.columns) / 2,
+        -(@page_size.height - @current_image.rows) / 2)
+    end
+
+    def crop_to_imageable_area
+      x, y, w, h = @page_size.margin.left, @page_size.height - @page_size.margin.top, @page_size.imageable_width, @page_size.imageable_height
+      ;;warn "\t\t" + "Cropping to imageable area (x,y = #{x},#{y}, w,h = #{w},#{h})"
+      @current_image.crop!(x, y, w, h)
+    end
+
+    def write_to_file
+      path = output_path
+      ;;warn "\t\t" + "Writing image to #{path}"
+      @current_image.write(path) do
+        self.compression = @compress ? Magick::ZipCompression : Magick::NoCompression
+      end
+      path
+    end
+
+  end
+
+end

data/lib/quadtone/run.rb

@@ -0,0 +1,10 @@
+module Quadtone
+
+  def self.run(*args)
+    args = args.flatten.compact.map { |a| a.to_s }
+    warn "\t* #{args.join(' ')}"
+    system(*args)
+    raise "Error: #{$?}" unless $? == 0
+  end
+
+end

data/lib/quadtone/sample.rb

@@ -0,0 +1,32 @@
+module Quadtone
+
+  class Sample
+
+    attr_accessor :input
+    attr_accessor :output
+    attr_accessor :error
+    attr_accessor :label
+
+    def initialize(params={})
+      params.each { |key, value| send("#{key}=", value) }
+    end
+
+    def input_value
+      @input.value
+    end
+
+    def output_value
+      @output.value
+    end
+
+    def to_s
+      "%s / %s%s" % [
+        input,
+        output,
+        label ? " [#{label}]" : '',
+      ]
+    end
+
+  end
+
+end

data/lib/quadtone/separator.rb

@@ -0,0 +1,36 @@
+module Quadtone
+
+  class Separator
+
+    attr_accessor :luts
+
+    def initialize(curve_set)
+  	  @luts = {}
+  	  curve_set.curves.each do |curve|
+    		color_map = Magick::Image.new(curve.num_samples, 1) do
+          self.colorspace = Magick::GRAYColorspace
+  		  end
+        color_map.pixel_interpolation_method = Magick::IntegerInterpolatePixel
+  		  color_map.view(0, 0, curve.num_samples, 1) do |view|
+          curve.samples.each_with_index do |sample, i|
+            value = ((1 - sample.output.value) * 65535).to_i
+            view[0][curve.num_samples - 1 - i] = Magick::Pixel.new(value, value, value)
+      		end
+    		end
+        @luts[curve.channel] = color_map
+  		end
+  	end
+
+    def separate(image)
+      images = {}
+      @luts.each do |channel, lut|
+        image2 = image.copy.clut_channel(lut)
+        image2['Label'] = channel.to_s.upcase
+        images[channel] = image2
+      end
+      images
+    end
+
+  end
+
+end

data/lib/quadtone/target.rb

@@ -0,0 +1,277 @@
+module Quadtone
+
+  class Target
+
+    attr_accessor :base_dir
+    attr_accessor :channels
+    attr_accessor :type
+    attr_accessor :name
+    attr_accessor :ink_limits
+    attr_accessor :samples
+
+    def initialize(params={})
+      params.each { |k, v| send("#{k}=", v) }
+      raise "Base directory must be specified" unless @base_dir
+      raise "Channels must be specified" unless @channels
+      raise "Type must be specified" unless @type
+      raise "Name must be specified" unless @name
+    end
+
+    def build
+      ;;warn "Making target for channels #{@channels.inspect}"
+      cleanup_files(:all)
+
+      resolution = 360
+      page_size = HashStruct.new(width: 8, height: 10.5)
+      # total_patches = 42
+      ;;total_patches = 14
+      patches_per_row = 14
+      total_rows = total_patches / patches_per_row
+      row_height = 165
+      target_size = [
+        ((total_rows + 1) * row_height).to_f / resolution,
+        page_size.height,
+      ].map { |n| (n * 25.4).to_i }.join('x')
+
+      image_list = Magick::ImageList.new
+      @channels.each do |channel|
+        sub_path = base_file(channel)
+        sub_image_path = image_file(channel)
+        ;;warn "Making target #{sub_path.inspect} at #{sub_image_path}"
+        Quadtone.run('targen',
+          # '-v',                 # Verbose mode [optional level 1..N]
+          '-d', 0,              # generate grayscale target
+          '-e', 0,              # White test patches (default 4)
+          '-B', 0,              # Black test patches (default 4 Grey/RGB, else 0)
+          '-s', total_patches,  # Single channel steps (default grey 50, color 0)
+          sub_path)
+        Quadtone.run('printtarg',
+          # '-v',                 # Verbose mode [optional level 1..N]
+          '-a', 1.45,           # Scale patch size and spacers by factor (e.g. 0.857 or 1.5 etc.)
+          '-r',                 # Don't randomize patch location
+          '-i', 'i1',           # set instrument to EyeOne (FIXME: make configurable)
+          '-t', resolution,     # generate 16-bit TIFF @ 360 ppi
+          '-m', 0,              # Set a page margin in mm (default 6.0 mm)
+          '-L',                 # Suppress any left paper clip border
+          '-p', target_size,    # Select page size
+          sub_path)
+        image = Magick::Image.read(sub_image_path).first
+        # image.background_color = 'transparent'
+        # image = image.transparent('white')
+        case @type
+        when :characterization
+          if @ink_limits && (limit = @ink_limits[channel]) && limit != 1
+            ;;warn "\t" + "#{channel.to_s.upcase}: Applying limit of #{limit}"
+            levels = [1.0 - limit, 1.0].map { |n| n * Magick::QuantumRange }
+            image = image.levelize_channel(*levels)
+          end
+          # calculate a black RGB pixel for this channel in QTR calibration mode
+          black_qtr = Color::QTR.new(channel: channel, value: 0)
+          black_rgb = black_qtr.to_rgb
+          ;;warn "\t" + "#{channel.to_s.upcase}: Colorizing to #{black_rgb}"
+          image = image.colorize(1, 0, 1, black_rgb.to_pixel)
+        end
+        image_list << image
+      end
+
+      if @type == :linearization || @type == :test
+
+        width = (page_size.width * resolution).to_i - image_list.first.columns
+        height = page_size.height * resolution
+
+        ;;width = (page_size.width / 2) * resolution
+
+        linear_scale_height = 1 * resolution
+        radial_scale_height = (height - linear_scale_height) / 2
+        sample_image_height = (height - linear_scale_height) / 2
+
+        test_images = Magick::ImageList.new
+        test_images << linear_gradation_scale_image([width, linear_scale_height])
+        test_images << radial_gradation_scale_image([width, radial_scale_height])
+        test_images << sample_image([width, sample_image_height])
+        image_list << test_images.append(true)
+      end
+
+      # ;;warn "montaging images"
+      # image_list = image_list.montage do
+      #   self.geometry = Magick::Geometry.new(page_size.width * resolution, page_size.height * resolution)
+      #   self.tile = Magick::Geometry.new(image_list.length, 1)
+      # end
+
+      # ;;warn "writing target image"
+      # image_list.write(image_file) do
+      #   self.depth = (@type == :characterization) ? 8 : 16
+      #   self.compression = Magick::ZipCompression
+      # end
+
+      ;;warn "writing target image"
+      image_list.append(false).write(image_file) do
+        self.depth = (@type == :characterization) ? 8 : 16
+        self.compression = Magick::ZipCompression
+      end
+
+    end
+
+    def linear_gradation_scale_image(size)
+      ;;warn "\t" + "generating linear gradation scale of size #{size.inspect}"
+      bounds = Magick::Rectangle.new(*size, 0, 0)
+      image1 = Magick::Image.new(bounds.width, bounds.height/2, Magick::GradientFill.new(0, 0, 0, bounds.height/2, 'white', 'black'))
+      image2 = image1.posterize(21)
+      image3 = image1.posterize(256)
+      ilist = Magick::ImageList.new
+      ilist << image1
+      ilist << image2
+      ilist << image3
+      ilist.append(true)
+    end
+
+    def radial_gradation_scale_image(size)
+      ;;warn "\t" + "generating radial gradation scale of size #{size.inspect}"
+      bounds = Magick::Rectangle.new(*size, 0, 0)
+      image1 = Magick::Image.new(bounds.width, bounds.height/2, Magick::GradientFill.new(bounds.width/2, bounds.height/2, bounds.width/2, bounds.height/2, 'black', 'white'))
+      image2 = image1.posterize(21).flip
+      ilist = Magick::ImageList.new
+      ilist << image1
+      ilist << image2
+      ilist.append(true)
+    end
+
+    def sample_image(size)
+      ;;warn "\t" + "generating sample image of size #{size.inspect}"
+      bounds = Magick::Rectangle.new(*size, 0, 0)
+      ilist = Magick::ImageList.new(Pathname.new(ENV['HOME']) + 'Desktop' + '121213b.01.tif')
+      ilist.first.resize_to_fill(*size)
+    end
+
+    def measure(options={})
+      options = HashStruct.new(options)
+      channels_to_measure = options.channels || @channels
+      channels_to_measure.each_with_index do |channel, i|
+        measure_channel(channel, options.merge(disable_calibration: i > 0))
+      end
+    end
+
+    def measure_channel(channel, options=HashStruct.new)
+      options = HashStruct.new(options)
+      if options.remeasure
+        pass = options.remeasure
+      else
+        pass = ti2_files(channel).length
+      end
+      base = base_file(channel, pass)
+      FileUtils.cp(ti2_file(channel), base.with_extname('.ti2')) unless options.remeasure
+      ;;warn "Measuring target #{base.inspect}"
+      Quadtone.run('chartread',
+        # '-v',                             # Verbose mode [optional level 1..N]
+        '-p',                             # Measure patch by patch rather than strip
+        '-n',                             # Don't save spectral information (default saves spectral)
+        '-l',                             # Save CIE as D50 L*a*b* rather than XYZ
+        options.disable_calibration ? '-N' : nil, # Disable initial calibration of instrument if possible
+        options.remeasure ? '-r' : nil,   # Resume reading partly read chart
+        base)
+    end
+
+    def read
+      ;;warn "reading samples for #{@channels.join(', ')} from CGATS files"
+      @samples = {}
+      @channels.each do |channel|
+        samples = {}
+        ti3_files(channel).map do |file|
+          ;;warn "reading #{file}"
+          cgats = CGATS.new_from_file(file)
+          cgats.sections.first.data.each do |set|
+            id = set['SAMPLE_LOC'].gsub(/"/, '')
+            samples[id] ||= []
+            samples[id] << Sample.new(input: Color::Gray.from_cgats(set), output: Color::Lab.from_cgats(set))
+          end
+        end
+        @samples[channel] = samples.map do |id, samples|
+          cc = ClusterCalculator.new(samples: samples, max_clusters: samples.length > 2 ? 2 : 1)
+          cc.cluster!
+          clusters = cc.clusters.sort_by(&:size).reverse
+          # ;;warn "Clusters:"
+          # clusters.each do |cluster|
+          #   warn "\t" + cluster.center.to_s
+          #   cluster.samples.each do |sample|
+          #     warn "\t\t" + "#{sample.to_s}"
+          #   end
+          # end
+          # ;;
+          cluster = clusters.shift
+          raise "Too much spread" if cluster.samples.length < 2 && samples.length > 2
+          unless clusters.empty?
+            warn "Dropped #{clusters.length} out of range sample(s) at patch #{channel}-#{id}"
+          end
+          output = cluster.center
+          Sample.new(input: samples.first.input, output: output, label: "#{channel}-#{id}")
+        end
+      end
+    end
+
+    # private
+
+    def base_file(channel=nil, n=nil)
+      @base_dir + (@name.to_s + (channel ? "-#{channel}" : '') + (n ? "-#{n}" : ''))
+    end
+
+    def ti1_file(channel)
+      base_file(channel).with_extname('.ti1')
+    end
+
+    def ti2_file(channel, n=nil)
+      base_file(channel, n).with_extname('.ti2')
+    end
+
+    def ti3_file(channel, n=nil)
+      base_file(channel, n).with_extname('.ti3')
+    end
+
+    def image_file(channel=nil)
+      base_file(channel).with_extname('.tif')
+    end
+
+    def values_file(channel=nil)
+      base_file(channel).with_extname('.txt')
+    end
+
+    def ti_files
+      Pathname.glob(base_file.with_extname('*.ti[123]'))
+    end
+
+    def ti2_files(channel)
+      Pathname.glob(base_file(channel).with_extname('*.ti2'))
+    end
+
+    def ti3_files(channel)
+      Pathname.glob(base_file(channel).with_extname('*.ti3'))
+    end
+
+    def image_files
+      Pathname.glob(base_file.with_extname('*.tif'))
+    end
+
+    def cleanup_files(files)
+      ;;warn "deleting files: #{files.inspect}"
+      files = [files].flatten
+      until files.empty?
+        file = files.shift
+        case file
+        when :all
+          files << :ti
+          files += image_files
+        when :ti
+          files += ti_files
+        when Pathname
+          if file.exist?
+            # ;;warn "\t" + file
+            file.unlink
+          end
+        else
+          raise "Unknown file to cleanup: #{file}"
+        end
+      end
+    end
+
+  end
+
+end