qttk 0.1.0

data/lib/quadtone/curve_set.rb

@@ -0,0 +1,196 @@
+module Quadtone
+
+  class CurveSet
+
+    attr_accessor :profile
+    attr_accessor :channels
+    attr_accessor :type
+    attr_accessor :curves
+
+    def initialize(params={})
+      @curves = []
+      params.each { |key, value| send("#{key}=", value) }
+      raise "Profile must be specified" unless @profile
+      raise "Channels must be specified" unless @channels
+      raise "Type must be specified" unless @type
+      @target = Target.new(name: @type.to_s, channels: @channels, base_dir: @profile.dir_path, type: @type, ink_limits: @profile.ink_limits)
+      generate_scale
+    end
+
+    def build_target
+      @target.build
+    end
+
+    def print_target
+      @profile.print_file(@target.image_file, calibrate: (@type == :characterization), print: true)
+    end
+
+    def measure_target(options={})
+      @target.measure(options)
+      process_target
+      chart_target
+    end
+
+    def process_target
+      case @type
+      when :characterization
+        import_from_target
+        verify_increasing_values
+        set_common_white
+        # trim_to_limits
+        # @profile.ink_limits = Hash[
+        #   @curves.map do |curve|
+        #     [
+        #       curve.channel,
+        #       curve.samples.last.input.value
+        #     ]
+        #   end
+        # ]
+        # normalize_curves
+        @profile.ink_partitions = partitions
+      when :linearization, :test
+        import_from_target
+        if @type == :linearization
+          @profile.linearization = grayscale(21)
+        elsif @type == :test
+          @profile.grayscale = grayscale(21)
+        end
+      end
+      @profile.save
+      @profile.install
+    end
+
+    def chart_target
+      import_from_target
+      out_file = (@profile.dir_path + @type.to_s).with_extname('.html')
+      out_file.open('w') { |io| io.write(to_html) }
+      ;;warn "Saved chart to #{out_file.to_s.inspect}"
+      system('qlmanage', '-p', out_file.to_s)
+    end
+
+    private
+
+    def import_from_target
+      @target.read
+      @curves.each do |curve|
+        curve.samples = @target.samples[curve.channel]
+      end
+    end
+
+    def generate_scale
+      @curves = @channels.map do |channel|
+        Curve.new(channel: channel, samples: [
+          Sample.new(input: Color::Gray.new(k: 0), output: Color::Lab.new(l: 100)),
+          Sample.new(input: Color::Gray.new(k: 1), output: Color::Lab.new(l: 0))
+        ])
+      end
+    end
+
+    def channels
+      @curves.map(&:channel)
+    end
+
+    def verify_increasing_values
+      @curves.each { |c| c.verify_increasing_values }
+    end
+
+    def trim_to_limits
+      @curves.each { |c| c.trim_to_limit }
+    end
+
+    def normalize_curves
+      @curves.each { |c| c.normalize_inputs }
+    end
+
+    # find average shade of paper, and update each curve to have that average as its first value
+
+    def set_common_white
+      samples = samples_with_value(0)
+      outputs = samples.map(&:output)
+      average, error = Color::Lab.average(outputs)
+      raise "too much variance in white samples: average = #{average}, error = #{error}" if error >= 1
+      samples.each { |s| s.output = average }
+    end
+
+    def samples_with_value(value)
+      @curves.map { |c| c.samples.find { |s| s.input_value == value } }.compact.flatten
+    end
+
+    def partitions
+      partitions = {}
+      previous_curve = nil
+      @curves.sort_by(&:dmax).reverse.each do |curve|
+        ;;warn "processing #{curve.channel}"
+        last_sample = curve.samples.last
+        if previous_curve
+          partitions[curve.channel] = previous_curve.input_for_output(last_sample.output.value) * partitions[previous_curve.channel]
+          ;;warn "\t" + "value on previous curve for dmax #{last_sample.output.value} = #{partitions[curve.channel]}"
+        else
+          partitions[curve.channel] = last_sample.input.value
+          ;;warn "\t" + "using absolute value of curve for dmax #{last_sample.output.value} = #{partitions[curve.channel]}"
+        end
+        previous_curve = curve
+      end
+      partitions
+    end
+
+    def grayscale(steps)
+      raise "Can't get gray scale of non-grayscale curveset" if @channels.length > 1
+      @curves.first.grayscale(steps)
+    end
+
+    def to_html
+      html = Builder::XmlMarkup.new(indent: 2)
+      html.div do
+        html.ul do
+          html.li("Channels: #{@channels.join(', ')}")
+        end
+        html.h3('Curve set:')
+        html.table(border: 1) do
+          html.tr do
+            [
+              'channel',
+              'ink limit',
+              'density: min',
+              'density: max',
+              'density: range',
+            ].each { |s| html.th(s) }
+          end
+          @curves.each do |curve|
+            html.tr do
+              dmin, dmax = curve.dynamic_range
+              [
+                curve.channel.to_s,
+                curve.ink_limit.input,
+                '%.2f' % dmin,
+                '%.2f' % dmax,
+                '%.2f' % (dmax - dmin),
+              ].each { |s| html.td(s) }
+            end
+          end
+        end
+        html << to_svg
+      end
+      html.target!
+    end
+
+    def to_svg(options={})
+      size = options[:size] || 500
+      svg = Builder::XmlMarkup.new(indent: 2)
+      svg.svg(xmlns: 'http://www.w3.org/2000/svg', version: '1.1') do
+        svg.g(width: size, height: size, transform: "translate(0,#{size}) scale(1,-1)") do
+          svg.g(stroke: 'blue') do
+            svg.rect(x: 0, y: 0, width: size, height: size, fill: 'none', :'stroke-width' => 1)
+            svg.line(x1: 0, y1: 0, x2: size, y2: size, :'stroke-width' => 0.5)
+          end
+          @curves.each do |curve|
+            curve.draw_svg(svg, options)
+          end
+        end
+      end
+      svg.target!
+    end
+
+  end
+
+end

data/lib/quadtone/descendants.rb

@@ -0,0 +1,9 @@
+# from http://stackoverflow.com/a/2393878
+
+class Class
+
+  def descendants
+    ObjectSpace.each_object(::Class).select { |c| c < self }
+  end
+
+end

data/lib/quadtone/environment.rb

@@ -0,0 +1,5 @@
+module Quadtone
+
+  BaseDir = Pathname.new(ENV['HOME']) + '.qttk'
+
+end

data/lib/quadtone/extensions/math.rb

@@ -0,0 +1,11 @@
+module Math
+  
+  def deg2rad(deg)
+    deg * (PI / 180)
+  end
+  
+  def rad2deg(rad)
+    rad * (180 / PI)
+  end
+  
+end

data/lib/quadtone/extensions/pathname3.rb

@@ -0,0 +1,11 @@
+class Pathname
+  
+  def with_extname(extname)
+    Pathname.new(without_extname.to_s + extname)
+  end
+  
+  def without_extname
+    Pathname.new(to_s.sub(/#{Regexp.quote(self.extname)}$/, ''))
+  end
+  
+end

data/lib/quadtone/printer.rb

@@ -0,0 +1,106 @@
+module Quadtone
+
+  class Printer
+
+    ImportantOptions = %i{
+      MediaType
+      Resolution
+      ripBlack
+      ripSpeed
+      stpDither
+    }
+
+    attr_accessor :name
+    attr_accessor :options
+    attr_accessor :attributes
+    attr_accessor :inks
+
+    def initialize(name)
+      @name = name
+      @cups_ppd = CupsPPD.new(@name, nil)
+      @options = Hash[
+        @cups_ppd.options.map { |o| [o.delete(:keyword).to_sym, HashStruct.new(o)] }
+      ]
+      @attributes = Hash[
+        @cups_ppd.attributes.map { |a| [a.delete(:name).to_sym, HashStruct.new(a)] }
+      ]
+      @cups_printer = CupsPrinter.new(@name)
+      get_inks
+    end
+
+    def quadtone?
+      @attributes[:Manufacturer].value == 'QuadToneRIP'
+    end
+
+    def get_inks
+      # FIXME: It would be nice to get this path programmatically.
+      ppd_file = Pathname.new("/etc/cups/ppd/#{@name}.ppd")
+      ppd_file.readlines.each do |line|
+        if line =~ /^\*%Inks\s*(.*?)\s*$/
+          @inks = $1.split(/,/).map(&:downcase).map(&:to_sym)
+          break
+        end
+      end
+    end
+
+    def page_size(name=nil)
+      name ||= @cups_ppd.attribute('DefaultPageSize').first[:value]
+      page_size = @cups_ppd.page_size(name) or raise "Can't determine page size #{name.inspect}"
+      size = HashStruct.new(page_size)
+      # change 'length' to 'height', or else there are problems with Hash#length
+      size[:height] = size.delete(:length)
+      size = HashStruct.new(size)
+      size.imageable_width = size.margin.right - size.margin.left
+      size.imageable_height = size.margin.top - size.margin.bottom
+      size
+    end
+
+    def default_options
+      Hash[
+        @options.map do |name, option|
+          [name, option.default_choice]
+        end
+      ]
+    end
+
+    def show_attributes
+      puts "Attributes:"
+      max_field_length = @attributes.keys.map(&:length).max
+      @attributes.sort_by { |name, info| name }.each do |name, attribute|
+        puts "\t" + "%#{max_field_length}s: %s%s" % [
+          name,
+          attribute.value.inspect,
+          attribute.spec.empty? ? '' : " [#{attribute.spec.inspect}]"
+        ]
+      end
+    end
+
+    def show_options
+      puts "Options:"
+      max_field_length = @options.keys.map(&:length).max
+      @options.sort_by { |name, option| name }.each do |name, option|
+        puts "\t" + "%#{max_field_length}s: %s [%s]" % [
+          name,
+          option.default_choice.inspect,
+          (option.choices.map { |o| o.choice } - [option.default_choice]).map { |o| o.inspect }.join(', ')
+        ]
+      end
+    end
+
+    def show_inks
+      puts "Inks:"
+      puts "\t" + @inks.map { |ink| ink.to_s.upcase }.join(', ')
+    end
+
+    def print_file(path, options)
+      warn "Printing #{path}"
+      warn "Options:"
+      options.each do |key, value|
+        warn "\t" + "%10s: %s" % [key, value]
+      end
+      @cups_printer.print_file(path, options)
+    end
+
+  end
+
+end

data/lib/quadtone/profile.rb

@@ -0,0 +1,217 @@
+module Quadtone
+
+  class Profile
+
+    attr_accessor :printer
+    attr_accessor :printer_options
+    attr_accessor :medium
+    attr_accessor :inks
+    attr_accessor :ink_partitions
+    attr_accessor :ink_limits
+    attr_accessor :linearization
+    attr_accessor :default_ink_limit
+    attr_accessor :gray_highlight
+    attr_accessor :gray_shadow
+    attr_accessor :gray_overlap
+    attr_accessor :gray_gamma
+    attr_accessor :characterization_curveset
+    attr_accessor :linearization_curveset
+    attr_accessor :test_curveset
+
+    ProfilesDir = BaseDir + 'profiles'
+    ProfileName = 'profile.txt'
+
+    def self.profile_names
+      Pathname.glob(ProfilesDir + '*').select { |p| p.directory? && p[0] != '.' }.map(&:basename)
+    end
+
+    def self.load(name)
+      profile = Profile.new
+      profile.load(name)
+      profile
+    end
+
+    def initialize(params={})
+      @printer_options = nil
+      @default_ink_limit = 1.0
+      @ink_limits = {}
+      @ink_partitions = {}
+      @gray_highlight = 0.06
+      @gray_shadow = 0.06
+      @gray_overlap = 0.10
+      @gray_gamma = 1.0
+      params.each { |key, value| send("#{key}=", value) }
+    end
+
+    def name
+      [
+        @printer.name.gsub(/[^-A-Z0-9]/i, ''),
+        @medium.gsub(/[^-A-Z0-9]/i, ''),
+      ].flatten.join('-')
+    end
+
+    def load(name)
+      inks_by_num = []
+      (ProfilesDir + name + ProfileName).readlines.each do |line|
+        line.chomp!
+        line.sub!(/#.*/, '')
+        line.strip!
+        next if line.empty?
+        key, value = line.split('=', 2)
+        case key
+        when 'PRINTER'
+          @printer = Printer.new(value)
+        when 'PRINTER_OPTIONS'
+          @printer_options = Hash[ value.split(',').map { |o| o.split('=') } ]
+        when 'MEDIUM'
+          @medium = value
+        when 'GRAPH_CURVE'
+          # ignore
+        when 'N_OF_INKS'
+          # ignore
+        when 'INKS'
+          @inks = value.split(',').map(&:downcase).map(&:to_sym)
+        when 'DEFAULT_INK_LIMIT'
+          @default_ink_limit = value.to_f / 100
+        when /^LIMIT_(.+)$/
+          @ink_limits[$1.downcase.to_sym] = value.to_f / 100
+        when 'N_OF_GRAY_PARTS'
+          # ignore
+        when /^GRAY_INK_(\d+)$/
+          i = $1.to_i - 1
+          inks_by_num[i] = value.downcase.to_sym
+        when /^GRAY_VAL_(\d+)$/
+          i = $1.to_i - 1
+          ink = inks_by_num[i]
+          @ink_partitions[ink] = value.to_f / 100
+        when 'GRAY_HIGHLIGHT'
+          @gray_highlight = value.to_f / 100
+        when 'GRAY_SHADOW'
+          @gray_shadow = value.to_f / 100
+        when 'GRAY_OVERLAP'
+          @gray_overlap = value.to_f / 100
+        when 'GRAY_GAMMA'
+          @gray_gamma = value.to_f
+        when 'LINEARIZE'
+          @linearization = value.gsub('"', '').split(/\s+/).map { |v| Color::Lab.new([v.to_f]) }
+        else
+          warn "Unknown key in QTR profile: #{key.inspect}"
+        end
+      end
+      @characterization_curveset = CurveSet.new(channels: @inks, profile: self, type: :characterization)
+      @linearization_curveset = CurveSet.new(channels: [:k], profile: self, type: :linearization)
+    end
+
+    def save
+      qtr_profile_path.dirname.mkpath
+      qtr_profile_path.open('w') do |io|
+        io.puts "PRINTER=#{@printer.name}"
+        io.puts "PRINTER_OPTIONS=#{@printer_options.map { |k, v| [k, v].join('=') }.join(',')}" if @printer_options
+        io.puts "MEDIUM=#{@medium}"
+        io.puts "GRAPH_CURVE=YES"
+        io.puts "INKS=#{@inks.join(',')}"
+        io.puts "N_OF_INKS=#{@inks.length}"
+        io.puts "DEFAULT_INK_LIMIT=#{@default_ink_limit * 100}"
+        @ink_limits.each do |ink, limit|
+          io.puts "LIMIT_#{ink.upcase}=#{limit * 100}"
+        end
+        io.puts "N_OF_GRAY_PARTS=#{@ink_partitions.length}"
+        @ink_partitions.each_with_index do |partition, i|
+          ink, value = *partition
+          io.puts "GRAY_INK_#{i+1}=#{ink.upcase}"
+          io.puts "GRAY_VAL_#{i+1}=#{value * 100}"
+        end
+        io.puts "GRAY_HIGHLIGHT=#{@gray_highlight * 100}"
+        io.puts "GRAY_SHADOW=#{@gray_shadow * 100}"
+        io.puts "GRAY_OVERLAP=#{@gray_overlap * 100}"
+        io.puts "GRAY_GAMMA=#{@gray_gamma}"
+        io.puts "LINEARIZE=\"#{@linearization.map(&:l).join(' ')}\"" if @linearization
+      end
+    end
+
+    def dir_path
+      ProfilesDir + name
+    end
+
+    def qtr_profile_path
+      dir_path + ProfileName
+    end
+
+    def quad_file_path
+      Pathname.new('/Library/Printers/QTR/quadtone') + @printer.name + "#{name}.quad"
+    end
+
+    def ink_limit(ink)
+      @ink_limits[ink] || @default_ink_limit
+    end
+
+    def install
+      # filename needs to match name of profile for quadprofile to install it properly,
+      # so temporarily make a symlink
+      tmp_file = Pathname.new('/tmp') + "#{name}.txt"
+      qtr_profile_path.symlink(tmp_file)
+      system('/Library/Printers/QTR/bin/quadprofile', tmp_file)
+      tmp_file.unlink
+    end
+
+    def print_file(input_path, options={})
+      options = HashStruct.new(options)
+      printer_options = @printer_options.dup
+      if options.printer_options
+        options.printer_options.each do |key, value|
+          printer_options[key.to_s] = value
+        end
+      end
+      if options.calibrate
+        printer_options['ColorModel'] = 'QTCAL'
+      else
+        printer_options['ripCurve1'] = name
+      end
+      @printer.print_file(input_path, printer_options)
+    end
+
+    def show
+      puts "Profile: #{name}"
+      puts "Printer: #{@printer.name}"
+      puts "Printer options:"
+      @printer_options.each do |key, value|
+        puts "\t" + "#{key}: #{value}"
+      end
+      puts "Medium: #{@medium}"
+      puts "Inks: #{@inks.join(', ')}"
+      puts "Default ink limit: #{@default_ink_limit}"
+      puts "Ink limits:"
+      @ink_limits.each do |ink, limit|
+        puts "\t" + "#{ink.upcase}: #{limit}"
+      end
+      puts "Gray settings:"
+      puts "\t" + "Highlight: #{@gray_highlight}"
+      puts "\t" + "Shadow: #{@gray_shadow}"
+      puts "\t" + "Overlap: #{@gray_overlap}"
+      puts "Gray gamma: #{@gray_gamma}"
+      puts "Ink partitions:"
+      @ink_partitions.each do |ink, value|
+        puts "\t" + "#{ink.upcase}: #{value}"
+      end
+      puts "Linearization: #{@linearization.join(', ')}" if @linearization
+    end
+
+    def to_html
+      html = Builder::XmlMarkup.new(indent: 2)
+      html.html do
+        html.head do
+        end
+        html.body do
+          html.h1("Profile: #{name}")
+        end
+      end
+      html.target!
+    end
+
+    def check
+      #FIXME: check values
+    end
+
+  end
+
+end