qttk 0.1.0

data/lib/quadtone/color/lab.rb

@@ -0,0 +1,150 @@
+module Color
+
+  class Lab < Base
+
+    DeltaEMethods = [
+      :density,
+      :cie76,
+      :cie94,
+      :cmclc
+    ]
+
+    def self.component_names
+      [:l, :a, :b]
+    end
+
+    def self.cgats_fields
+      %w{LAB_L LAB_A LAB_B}
+    end
+
+    def l
+      @components[0]
+    end
+
+    def a
+      @components[1]
+    end
+
+    def b
+      @components[2]
+    end
+
+    def value
+      1 - (l / 100.0)
+    end
+
+    def chroma
+      # http://www.brucelindbloom.com/Eqn_Lab_to_LCH.html
+      sqrt((a * a) + (b * b))
+    end
+
+    def hue
+      # http://www.brucelindbloom.com/Eqn_Lab_to_LCH.html
+      if a == 0 && b == 0
+        0
+      else
+        rad2deg(atan2(b, a)) % 360
+      end
+    end
+
+    def delta_e(other, method=:cmclc)
+      # http://en.wikipedia.org/wiki/Color_difference
+      # http://www.brucelindbloom.com/iPhone/ColorDiff.html
+      l1, a1, b1 = self.l, self.a, self.b
+      l2, a2, b2 = other.l, other.a, other.b
+      dl = l2 - l1
+      da = a1 - a2
+      db = b1 - b2
+      if method == :cie94 || method == :cmclc
+        c1, c2 = self.chroma, other.chroma
+        h1, h2 = self.hue, other.hue
+        dc = c1 - c2
+        dh2 = da**2 + db**2 - dc**2
+        return Float::NAN if dh2 < 0
+        dh = sqrt(dh2)
+      end
+      case method
+      when :density
+        dl.abs
+      when :cie76
+        sqrt(dl**2 + da**2 + db**2)
+      when :cie94
+        kl, k1, k2 = 1, 0.045, 0.015
+        sqrt(
+          (dl / kl)**2 +
+          (dc / (1 + k1*c1))**2 +
+          (dh / (1 + k2*c2)**2)
+        )
+      when :cmclc
+        l, c = 2, 1
+        sl = (l1 < 16) ?
+          0.511 :
+          0.040975 * l1 / (1 + 0.01765 * l1)
+        sc = 0.0638 * c1 / (1 + 0.0131 * c1) + 0.638
+        f = sqrt(
+          (c1 ** 4) / ((c1 ** 4) + 1900)
+        )
+        t = (h1 >= 164 && h1 <= 345) ?
+          0.56 + (0.2 * cos(deg2rad(h1 + 168))).abs :
+          0.36 + (0.4 * cos(deg2rad(h1 + 35))).abs
+        sh = sc * ((f * t) + 1 - f)
+        sqrt(
+          (dl / (l * sl)) ** 2 +
+          (dc / (c * sc)) ** 2 +
+          (dh / sh) ** 2
+        )
+      else
+        raise "Unknown deltaE method: #{method.inspect}"
+      end
+    end
+
+    def to_xyz
+      # after http://www.easyrgb.com/index.php?X=MATH&H=08#text8
+
+      y = (l + 16) / 116.0
+      x = (a / 500.0) + y
+      z = y - (b / 200.0)
+
+      x, y, z = [x, y, z].map do |n|
+        if (n3 = n**3) > 0.008856
+          n3
+        else
+          (n - 16 / 116.0) / 7.787
+        end
+      end
+
+      ref = Color::XYZ.standard_reference
+      x *= ref.x
+      y *= ref.y
+      z *= ref.z
+
+      Color::XYZ.new([x, y, z])
+    end
+
+    def to_rgb
+      to_xyz.to_rgb
+    end
+
+  end
+
+end
+
+if $0 == __FILE__
+
+  pairs = [
+    [Color::Lab.from_lab(50,0,0), Color::Lab.from_lab(50,0,0)],
+    [Color::Lab.from_lab(50,0,0), Color::Lab.from_lab(51,0,0)],
+    [Color::Lab.from_lab(50,0,0), Color::Lab.from_lab(50,0,1)],
+    [Color::Lab.from_lab(50,0,0), Color::Lab.from_lab(50,1,0)],
+    [Color::Lab.from_lab(50,0,0), Color::Lab.from_lab(50,1,1)],
+  ]
+
+  pairs.each do |pair|
+    l1, l2 = *pair
+    puts "#{l1.inspect} ~ #{l2.inspect}"
+    [:density, :cie76, :cie94, :cmclc].each do |method|
+      puts "\t" + "#{method}: %.4f" % l1.delta_e(l2, method)
+    end
+  end
+
+end

data/lib/quadtone/color/qtr.rb

@@ -0,0 +1,71 @@
+# "Color" in QTR calibration mode.
+
+module Color
+
+  class QTR < Base
+
+=begin
+
+    QTR channel map (in calibration mode):
+
+      R: inverse bitmask for channels
+
+        7: K	 = 127 (01111111)
+        6: C	 = 191 (10111111)
+        5: M	 = 223 (11011111)
+        4: Y	 = 239 (11101111)
+        3: LC	 = 247 (11110111)
+        2: LM	 = 251 (11111011)
+        1: LK	 = 253 (11111101)
+        0: LLK = 254 (11111110)
+
+      G: value (0-255)
+
+      B: unused -- should always be 255
+
+      For background, use R=127 / G=255 / B=255
+=end
+
+    Channels = [:llk, :lk, :lm, :lc, :y, :m, :c, :k]
+
+    def self.component_names
+      [:channel, :value]
+    end
+
+    def self.cgats_fields
+      %w{QTR_CHANNEL QTR_VALUE}
+    end
+
+    def channel
+      @components[0]
+    end
+
+    def channel_num
+      Channels.index(channel)
+    end
+
+    def value
+      @components[1]
+    end
+
+    def to_rgb
+      Color::RGB.new(
+        r: (255 - (1 << channel_num)) / 255.0,
+        g: (1 - value) / 100,
+        b: 1)
+    end
+
+    def to_gray
+      Color::Gray.new(k: value)
+    end
+
+    def to_cgats
+      {
+        'QTR_CHANNEL' => channel,
+        'QTR_VALUE' => value,
+      }
+    end
+
+  end
+
+end

data/lib/quadtone/color/rgb.rb

@@ -0,0 +1,71 @@
+module Color
+
+  class RGB < Base
+
+    def self.component_names
+      [:r, :g, :b]
+    end
+
+    def self.cgats_fields
+      %w{RGB_R RGB_G RGB_B}
+    end
+
+    def self.from_cgats(set)
+      new(*set.values_at(*cgats_fields).map { |n| n / 100.0 })
+    end
+
+    def r
+      @components[0]
+    end
+
+    def g
+      @components[1]
+    end
+
+    def b
+      @components[2]
+    end
+
+    def to_cgats
+      {
+        'RGB_R' => r * 100,
+        'RGB_G' => g * 100,
+        'RGB_B' => b * 100,
+      }
+    end
+
+    def to_xyz
+      # after http://www.easyrgb.com/index.php?X=MATH&H=02#text2
+
+      r0, g0, b0 = [r, g, b].map do |n|
+        if n > 0.04045
+          ((n + 0.055) / 1.055) ** 2.4
+        else
+          n / 12.92
+        end
+      end
+
+      r0 *= 100
+      g0 *= 100
+      b0 *= 100
+
+      # Observer. = 2°, Illuminant = D65
+
+      x = (r0 * 0.4124) + (g0 * 0.3576) + (b0 * 0.1805)
+      y = (r0 * 0.2126) + (g0 * 0.7152) + (b0 * 0.0722)
+      z = (r0 * 0.0193) + (g0 * 0.1192) + (b0 * 0.9505)
+
+      Color::XYZ.new([x, y, z])
+    end
+
+    def to_a
+      [r, g, b]
+    end
+
+    def to_pixel
+      Magick::Pixel.new(*to_a.map { |n| n * Magick::QuantumRange })
+    end
+
+  end
+
+end

data/lib/quadtone/color/xyz.rb

@@ -0,0 +1,80 @@
+module Color
+
+  class XYZ < Base
+
+    # Observer= 2°, Illuminant= D65
+    def self.standard_reference
+      @@reference ||= new([95.047, 100.000, 108.883])
+    end
+
+    def self.component_names
+      [:x, :y, :z]
+    end
+
+    def self.cgats_fields
+      %w{XYZ_X XYZ_Y XYZ_Z}
+    end
+
+    def x
+      @components[0]
+    end
+
+    def y
+      @components[1]
+    end
+
+    def z
+      @components[2]
+    end
+
+    def to_lab
+      # http://www.easyrgb.com/index.php?X=MATH&H=07#text7
+
+      ref = self.class.standard_reference
+
+      x = self.x / ref.x
+      y = self.y / ref.y
+      z = self.z / ref.z
+
+      x, y, z = [x, y, z].map do |n|
+        if n > 0.008856
+          n ** (1.0 / 3)
+        else
+          (7.787 * n) + (16 / 116)
+        end
+      end
+
+      l = (116 * y) - 16
+      a = 500 * (x - y)
+      b = 200 * (y - z)
+
+      Color::Lab.new([l, a, b])
+    end
+
+    def to_rgb
+      rgb = [
+        (x *  3.2406) + (y * -1.5372) + (z * -0.4986),
+        (x * -0.9689) + (y *  1.8758) + (z *  0.0415),
+        (x *  0.0557) + (y * -0.2040) + (z *  1.0570),
+      ]
+      rgb = rgb.map do |n|
+        if n > 0.0031308
+          1.055 * (n ** (1 / 2.4)) - 0.055
+        else
+          12.92 * rgb[0]
+        end
+      end
+      Color::RGB.new(rgb)
+    end
+
+    def to_cgats
+      {
+        'XYZ_X' => x,
+        'XYZ_Y' => y,
+        'XYZ_Z' => z,
+      }
+    end
+
+  end
+
+end

data/lib/quadtone/curve.rb

@@ -0,0 +1,138 @@
+module Quadtone
+
+  class Curve
+
+    DeltaETolerance = 1.0
+    DeltaEMethod = :density
+
+    attr_accessor :channel
+    attr_accessor :samples
+
+    def initialize(params={})
+      params.each { |key, value| send("#{key}=", value) }
+    end
+
+    def samples=(samples)
+      @samples = samples.sort_by(&:input_value)
+    end
+
+    def output_for_input(input)
+      @output_spliner ||= Spliner::Spliner.new(@samples.map(&:input_value), @samples.map(&:output_value))
+      @output_spliner[input]
+    end
+
+    def input_for_output(output)
+      @input_spliner ||= Spliner::Spliner.new(@samples.map(&:output_value), @samples.map(&:input_value))
+      @input_spliner[output]
+    end
+
+    def num_samples
+      @samples.length
+    end
+
+    def grayscale(steps)
+      spliner = Spliner::Spliner.new(Hash[ @samples.map { |s| [s.input.value, s.output.l] } ])
+      scale = (0 .. 1).step(1.0 / (steps - 1))
+      spliner[scale].map { |l| Color::Lab.new([l]) }
+    end
+
+    def ink_limit(method=DeltaEMethod)
+      # ;;@samples.each { |s| warn "%s-%s: %.2f => %.2f" % [@channel, s.id, s.input.value, s.output.value] }
+      @samples.each_with_index do |sample, i|
+        if i > 0
+          previous_sample = @samples[i - 1]
+          return previous_sample if sample.output_value < previous_sample.output_value
+          return previous_sample if previous_sample.output.delta_e(sample.output, method) < DeltaETolerance
+        end
+      end
+      @samples.last
+    end
+
+    def trim_to_limit
+      limit = ink_limit
+      i = @samples.index(limit)
+      ;;warn "trimming curve #{@channel} to sample \##{i}: #{limit}"
+      @samples.slice!(i + 1 .. -1)
+      @input_spliner = @output_spliner = nil
+    end
+
+    def normalize_inputs
+      scale = 1 / @samples.last.input.value
+      @samples.each do |sample|
+        sample.input = Color::Gray.new(k: sample.input.k * scale)
+      end
+      @input_spliner = @output_spliner = nil
+    end
+
+    def verify_increasing_values
+      @samples.each_with_index do |sample, i|
+        if i > 0
+          previous_sample = @samples[i - 1]
+          if sample.output_value < previous_sample.output_value
+            raise "Samples not in increasing order (#{sample.label} [#{i}]: #{sample.output_value} < #{previous_sample.output_value})"
+          end
+        end
+      end
+    end
+
+    def dmin
+      @samples.first.output_value
+    end
+
+    def dmax
+      @samples.last.output_value
+    end
+
+    def dynamic_range
+      [dmin, dmax]
+    end
+
+    def draw_svg(svg, options={})
+      size = options[:size] || 500
+
+      # draw interpolated curve
+      svg.g(fill: 'none', stroke: 'green', :'stroke-width' => 1) do
+        samples = (0..1).step(1.0 / size).map do |n|
+          [size * n, size * output_for_input(n)]
+        end
+        svg.polyline(points: samples.map { |pt| pt.join(',') }.join(' '))
+      end
+
+      # draw markers for ink limits
+      {
+        density: 'gray',
+        # cie76: 'red',
+        # cie94: 'green',
+        # cmclc: 'blue',
+      }.each do |method, color|
+        limit = ink_limit(method)
+        x, y = size * limit.input_value, size * limit.output_value
+        svg.g(stroke: color, :'stroke-width' => 3) do
+          svg.line(x1: x, y1: y + 8, x2: x, y2: y - 8)
+        end
+      end
+
+      # if (limit = ink_limit)
+      #   x, y = size * limit.input_value, size * limit.output_value
+      #   svg.g(stroke: 'black', :'stroke-width' => 3) do
+      #     svg.line(x1: x, y1: y + 15, x2: x, y2: y - 15)
+      #   end
+      # end
+
+      # draw individual samples
+      @samples.each_with_index do |sample, i|
+        svg.circle(
+          cx: size * sample.input_value,
+          cy: size * sample.output_value,
+          r: 3,
+          stroke: 'none',
+          fill: "rgb(#{sample.output.to_rgb.to_a.join(',')})",
+          title: sample.label)
+      end
+
+      svg.target!
+    end
+
+  end
+
+end