qttk 0.1.0

data/lib/quadtone/cgats.rb

@@ -0,0 +1,137 @@
+module Quadtone
+
+  class CGATS
+
+    attr_accessor :sections
+
+    def self.new_from_file(file)
+      cgats = new
+      section_index = 0
+      state = :header
+      Pathname.new(file).readlines.each do |line|
+        line.chomp!
+        line.sub!(/#.*/, '')
+        line.strip!
+        next if line.empty?
+        section = cgats.sections[section_index] || cgats.add_section
+        case state
+        when :header
+          case line
+          when 'BEGIN_DATA_FORMAT'
+            state = :data_format
+          when 'BEGIN_DATA'
+            state = :data
+          else
+            key, value = line.split(/\s+/, 2)
+            if section.header[key]
+              if !section.header[key].kind_of?(Array)
+                section.header[key] = [section.header[key]]
+              end
+              section.header[key] << value
+            else
+              section.header[key] = value
+            end
+          end
+        when :data_format
+          case line
+          when 'END_DATA_FORMAT'
+            state = :header
+          else
+            line.split(/\s+/).each { |f| section.data_fields << f }
+          end
+        when :data
+          case line
+          when 'END_DATA'
+            # Emission data (BEGIN_DATA_EMISSION) may come after here, but we don't handle it.
+            section_index += 1
+            state = :header
+          else
+            values = line.split(/\s+/).map do |v|
+              case v
+              when /^-?\d+$/
+                v.to_i
+              when /^-?\d+\.\d+$/
+                v.to_f
+              else
+                v.to_s
+              end
+            end
+            set = {}
+            values.each_with_index do |value, i|
+              set[section.data_fields[i]] = value
+            end
+            section.data << set
+          end
+        end
+      end
+      cgats
+    end
+
+    def initialize
+      @sections = []
+    end
+
+    def add_section
+      @sections << Section.new
+      @sections[-1]
+    end
+
+    def write(io)
+      @sections.each do |section|
+        section.write(io)
+        io.puts
+      end
+      nil
+    end
+
+    class Section
+
+      attr_accessor :header
+      attr_accessor :data
+      attr_accessor :data_fields
+
+      def initialize
+        @header = {}
+        @data = []
+        @data_fields = []
+      end
+
+      def <<(set)
+        @data << set
+      end
+
+      def write(io)
+        # header
+        @header.each { |k, v| io.puts k.to_s + (v ? " \"#{v}\"" : '') }
+        # data format
+        io.puts
+        io.puts "NUMBER_OF_FIELDS #{@data_fields.length}"
+        io.puts 'BEGIN_DATA_FORMAT'
+        io.puts @data_fields.join(' ')
+        io.puts 'END_DATA_FORMAT'
+        # data
+        io.puts
+        io.puts "NUMBER_OF_SETS #{@data.length}"
+        io.puts 'BEGIN_DATA'
+        @data.each do |set|
+          fields = @data_fields.map do |f|
+            case (d = set[f])
+            when Float
+              '%.05f' % d
+            when String
+              '"' + d + '"'
+            else
+              d
+            end
+          end
+          io.puts fields.join(' ')
+        end
+        io.puts 'END_DATA'
+        nil
+      end
+
+    end
+
+  end
+
+end

data/lib/quadtone/cluster_calculator.rb

@@ -0,0 +1,81 @@
+# after:
+#   http://colinfdrake.com/2011/05/28/clustering-in-ruby.html
+#   http://m635j520.blogspot.com/2013/02/implementing-k-means-clustering-in-ruby.html
+
+class ClusterCalculator
+
+  class Cluster
+
+    attr_accessor :center
+    attr_accessor :samples
+    attr_accessor :moved
+
+    def initialize(center)
+      @center = center
+      @samples = []
+      @moved = true
+    end
+
+    def add_sample(sample)
+      @samples << sample
+    end
+
+    def clear_samples
+      @samples = []
+    end
+
+    def distance_to(sample)
+      @center.delta_e(sample.output)
+    end
+
+    def update_center(delta=0.001)
+      @moved = false
+      average, error = Color::Lab.average(@samples.map(&:output))
+      unless average.delta_e(@center) < delta
+        @center = average
+        @moved = true
+      end
+    end
+
+    def size
+      @samples.length
+    end
+
+  end
+
+  attr_accessor :samples
+  attr_accessor :max_clusters
+  attr_accessor :delta
+  attr_accessor :clusters
+
+  def initialize(params={})
+    @delta = 0.001
+    params.each { |k, v| send("#{k}=", v) }
+    raise "Must specify samples" unless @samples
+    raise "Must specify max_clusters" unless @max_clusters
+    @max_clusters = @samples.length if @max_clusters > @samples.length
+  end
+
+  def cluster!
+    @clusters = @max_clusters.times.map { Cluster.new(@samples.sample.output) }
+    while @clusters.any?(&:moved)
+      @clusters.each(&:clear_samples)
+      @samples.each do |sample|
+        shortest = Float::INFINITY
+        cluster_found = nil
+        @clusters.each do |cluster|
+          distance = cluster.distance_to(sample)
+          if distance < shortest
+            cluster_found = cluster
+            shortest = distance
+          end
+        end
+        cluster_found.add_sample(sample) if cluster_found
+      end
+      @clusters.delete_if { |c| c.size == 0 }
+      @clusters.each { |c| c.update_center(@delta) }
+    end
+
+  end
+
+end

data/lib/quadtone/color.rb

@@ -0,0 +1,83 @@
+module Color
+
+  class Base
+
+    include Math
+
+    attr_accessor :components
+
+    def self.component_names
+      raise NotImplementedError, "\#component_names not implemented in #{self}"
+    end
+
+    def self.cgats_fields
+      raise NotImplementedError, "\#cgats_fields not implemented in #{self}"
+    end
+
+    def self.num_components
+      component_names.length
+    end
+
+    def self.colorspace_name
+      self.to_s.split('::').last.downcase
+    end
+
+    def self.from_cgats(set)
+      new(set.values_at(*cgats_fields))
+    end
+
+    def self.average(colors)
+      avg_components = []
+      errors = []
+      component_names.each_with_index do |comp, i|
+        avg_components << colors.map { |c| c.components[i] }.mean
+        errors << colors.map { |c| c.components[i] }.standard_deviation
+      end
+      [new(avg_components), errors.max]
+    end
+
+    def initialize(arg)
+      components = case arg
+      when String
+        arg =~ /^(\w+)\((.+)\)$/ or raise "Can't initialize #{self.class}: bad color string: #{arg.inspect}"
+        raise "Expected #{self.class.colorspace_name.inspect} but got #{$1.inspect}" if $1.downcase != self.class.colorspace_name
+        $2.split(/,\s+/).map(&:to_f)
+      when Hash
+        self.class.component_names.map { |n| arg[n] }
+      when Array
+        arg.map(&:to_f)
+      else
+        raise "Can't initialize #{self.class}: unknown object: #{arg.inspect}"
+      end
+      raise "Can't initialize #{self.class}: too many components specified: #{components.inspect}" if components.length > self.class.num_components
+      @components = [0] * self.class.num_components
+      components.each_with_index { |n, i| @components[i] = n if n }
+    end
+
+    def to_s
+      "#{self.class.colorspace_name}(#{@components.map { |n| '%3.1f' % n }.join(', ')})"
+    end
+
+    def to_str
+      to_s
+    end
+
+    def to_cgats
+      @components
+    end
+
+    def hash
+      @components.hash
+    end
+
+    def eql?(other)
+      @components == other.components
+    end
+
+    def <=>(other)
+      @components <=> other.components
+    end
+
+  end
+
+end

data/lib/quadtone/color/cmyk.rb

@@ -0,0 +1,112 @@
+module Color
+
+  class CMYK < Base
+
+    def self.component_names
+      [:c, :m, :y, :k, :lc, :lm, :lk, :llk]
+    end
+
+    def self.cgats_fields
+      %w{CMYKcmk1k_C CMYKcmk1k_M CMYKcmk1k_Y CMYKcmk1k_K
+         CMYKcmk1k_c CMYKcmk1k_m CMYKcmk1k_k CMYKcmk1k_1k}
+    end
+
+    def self.cgats_color_rep
+      'CMYKcmk1k'
+    end
+
+    def c
+      @components[0]
+    end
+
+    def m
+      @components[1]
+    end
+
+    def y
+      @components[2]
+    end
+
+    def k
+      @components[3]
+    end
+
+    def lc
+      @components[4]
+    end
+
+    def lm
+      @components[5]
+    end
+
+    def lk
+      @components[6]
+    end
+
+    def llk
+      @components[7]
+    end
+
+    def to_cgats
+      {
+        'CMYKcmk1k_C'  => c,
+        'CMYKcmk1k_M'  => m,
+        'CMYKcmk1k_Y'  => y,
+        'CMYKcmk1k_K'  => k,
+        'CMYKcmk1k_c'  => lc,
+        'CMYKcmk1k_m'  => lm,
+        'CMYKcmk1k_k'  => lk,
+        'CMYKcmk1k_1k' => llk,
+      }
+    end
+
+    def to_cmyk
+      # estimates for light & light-light inks
+      l_factor = 0.5
+      ll_factor = 0.25
+
+      # first adjust for light inks
+      c0 = c + (lc * l_factor)
+      m0 = m + (lm * l_factor)
+      y0 = y
+      k0 = k + (lk * l_factor) + (llk * ll_factor)
+
+      Color::CMYK.new([c0, m0, y0, k0])
+    end
+
+    def to_cmy
+      # after http://www.easyrgb.com/index.php?X=MATH&H=14#text14
+
+      c0, m0, y0, k0 = *to_cmyk
+      c0 /= 100.0
+      m0 /= 100.0
+      y0 /= 100.0
+      k0 /= 100.0
+
+      c0 = (c0 * (1 - k0)) + k0
+      m0 = (m0 * (1 - k0)) + k0
+      y0 = (y0 * (1 - k0)) + k0
+
+      Color::CMYK.new([c0 * 100, m0 * 100, y0 * 100])
+    end
+
+    def to_rgb
+      cmy = to_cmy
+      Color::RGB.new([1 - (cmy.c / 100), 1 - (cmy.m / 100), 1 - (cmy.y / 100)])
+    end
+
+    def to_lab
+      to_xyz.to_lab
+    end
+
+    def to_xyz
+      to_rgb.to_xyz
+    end
+
+    def to_a
+      @components
+    end
+
+  end
+
+end

data/lib/quadtone/color/device_n.rb

@@ -0,0 +1,23 @@
+module Color
+
+  class DeviceN < Base
+
+    Components = (0..7).to_a
+
+    def self.component_names
+      Components
+    end
+
+    def self.cgats_fields
+      Components.map do |i|
+        "DEVICE_#{i}"
+      end
+    end
+
+    def to_gray
+      Color::Gray.new(@components.find { |c| c != 0 } || 0)
+    end
+
+  end
+
+end

data/lib/quadtone/color/gray.rb

@@ -0,0 +1,46 @@
+module Color
+
+  class Gray < Base
+
+    def self.component_names
+      [:k]
+    end
+
+    def self.cgats_fields
+      %w{GRAY_K}
+    end
+
+    def self.cgats_color_rep
+      'K'
+    end
+
+    def k
+      @components[0]
+    end
+
+    def value
+      k / 100.0
+    end
+
+    def to_cgats
+      {
+        'GRAY_K' => k,
+      }
+    end
+
+    def to_rgb
+      n = 1 - value
+      Color::RGB.new([n, n, n])
+    end
+
+    def to_lab
+      Color::Lab.new(l: 100 - k, a: 0, b: 0)
+    end
+
+    def to_xyz
+      to_lab.to_xyz
+    end
+
+  end
+
+end