coloryze 2.0.0

data/lib/color/palette.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'color/hsb'
+require 'color/rgb'
+require 'color/util'
+
+# shows a set of colors, in text and html
+
+module Color
+
+  class Palette
+
+    attr_reader :background
+    attr_reader :saturation_start
+    attr_reader :saturation_end
+    attr_reader :saturation_step
+    attr_reader :brightness_start
+    attr_reader :brightness_end
+    attr_reader :brightness_step
+
+    def initialize(args = Hash.new)
+      @background       = args[:background]
+
+      @saturation_start = args[:saturation_start] || 0
+      @saturation_end   = args[:saturation_end]   || 100
+      @saturation_step  = args[:saturation_step]  || 25
+
+      @brightness_start = args[:brightness_start] || 0
+      @brightness_end   = args[:brightness_end]   || 100
+      @brightness_step  = args[:brightness_step]  || 25
+    end
+
+    # Returns nested hashes: hue => saturation => brightness => rgb
+    def colors_by_hue
+      by_hue = Hash.new
+      
+      colors.each do |color|
+        by_hue[color.hue] ||= Hash.new
+        by_hue[color.hue][color.saturation] ||= Hash.new
+        by_hue[color.hue][color.saturation][color.brightness] = color
+      end
+
+      by_hue
+    end
+
+    def print_as_text(io = $stdout)
+      colors.sort.each do |hsb|
+        io.printf "%4.1f %3d %3d %06x\n", hsb.hue, hsb.saturation, hsb.brightness, hsb.to_rgb
+      end
+    end
+
+    def print_as_html(io = $stdout)
+      puts "@background: #{@background}"
+      
+      bg = @background || "FFFFFF"
+      io.puts "<div style=\"background-color: " + bg + ";\">"
+      
+      print_html_tables(io)
+      
+      io.puts "</div>"
+    end
+    
+    def print_html_hue_line(io, hue, colspan)
+      # if no background or is A+ (dark), then 
+      textcolor = @background.nil? || @background.index(%r{[A-Z]\w}) ? "000000" : "FFFFFF"
+      io.puts "        <td colspan=\"" + colspan.to_s + "\" style=\"color: #" + textcolor + ";\">hue " + hue.to_s + "&deg;</td>"
+    end
+
+    def print_html_color(io, saturation, brightness, rgb, cellwidth)
+      rgbstr = sprintf("%06x", rgb)
+      io.puts "        <td style=\"width: " + cellwidth.to_s + "%; vertical-align: bottom; border:2px outset; border-collapse:collapse;\">"
+      io.puts "            <table width=\"100%\" border=\"0\" border-width=\"4px\">"
+      io.print "                <tr><td"
+      if @background
+        print "style=\"color: " + rgbstr + ";\""
+      end
+      io.printf ">#%s; s: %3.2f; b: %3.2f\n</td></tr>", rgbstr, saturation, brightness
+      io.puts "                <tr><td style=\"background-color: " + rgbstr + "; vertical-align: bottom;\"><br>&nbsp;</td></tr>"
+      io.puts "            </table>"
+      io.puts  "        </td>"
+    end
+
+    #$$$ todo: change to return hsbs
+
+    def colors
+      raise "abstract method: colors"
+    end
+
+  end
+
+end

data/lib/color/rgb.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'color/util'
+require 'color/hsb'
+require 'rubygems'
+require 'riel'
+
+module Color
+
+  class RGB
+    include Loggable
+    
+    attr_accessor :red, :green, :blue
+
+    RGB_VALUES    = '([0-9a-f]{2})'
+    # not supported, although in CSS: RGB_REGEXP    = Regexp.new '(' + RGB_VALUES + '){3}', Regexp::IGNORECASE
+    RRGGBB_REGEXP = Regexp.new '^\#?' + (RGB_VALUES * 3) + '$', Regexp::IGNORECASE  # '$
+    
+    class << self
+      alias_method :new_orig, :new
+      def new(*args)
+        if args
+          if args.size == 3
+            new_orig(*args)
+          elsif args.size == 1 and args[0].kind_of? String
+            str = args[0].sub(%r{^\#}, '') # optional
+            # str.hex does not validate, so we do here:
+            if md = matches_rgb_string?(str)
+              r, g, b = (1 .. 3).collect { |idx| md[idx].hex }
+              new_orig r, g, b
+            else
+              raise RuntimeError.new("invalid RGB string '#{str}: does not match #{RRGGBB_REGEXP.source}")
+            end
+          else
+            raise RuntimeError.new("invalid arguments '#{args.inspect}': expecting 0, 1, or 3")
+          end
+        else
+          new_orig 0, 0, 0
+        end
+      end
+
+      def matches_rgb_string?(val)
+        val.kind_of?(String) && RRGGBB_REGEXP.match(val)
+      end
+    end
+
+    def initialize(red, green, blue)
+      [ [ red, "red" ], [ green, "green" ], [ blue, "blue" ] ].each do |val, str|
+        Color::check_constraint(val, str, 0, 255)
+      end
+
+      @red   = red.to_i
+      @green = green.to_i
+      @blue  = blue.to_i
+    end
+
+    def to_s
+      "#{red},#{green},#{blue}"
+    end
+
+    def to_i
+      (red << 16) | (green << 8) | blue
+    end
+
+    def <=>(other)
+      to_i <=> other.to_i
+    end
+
+    def ==(other)
+      to_i == other.to_i
+    end
+
+    # Converts RGB to an HSB object.
+    def to_hsb
+      # this is not the only implementation of RGB to HSB, but it works.
+
+      # scale from 0..255 to 0..1
+      r, g, b = [ red, green, blue ].collect { |v| v / 255.0 }
+
+      log "r", r
+      log "g", g
+      log "b", b
+      
+      minrgb = [ r, g, b ].min
+      log "minrgb", minrgb
+      maxrgb = [ r, g, b ].max
+      log "maxrgb", maxrgb
+      delta  = maxrgb - minrgb
+      log "delta", delta
+      
+      hue = nil
+      saturation = nil
+      brightness = maxrgb
+      
+      if delta == 0
+        # this is a gray, no chroma...
+        hue = 0
+        saturation = 0
+      else                        # chromatic data...
+        saturation = delta / maxrgb
+
+        del_red, del_green, del_blue = [ r, g, b ].collect do |v|
+          (((maxrgb - v) / 6.0) + (delta / 2.0)) / delta
+        end
+        
+        if r == maxrgb
+          hue = del_blue - del_green
+        elsif g == maxrgb
+          hue = (1.0 / 3) + del_red - del_blue
+        elsif b == maxrgb
+          hue = (2.0 / 3) + del_green - del_red
+        end
+        
+        if hue < 0
+          hue += 1
+        end
+        
+        if hue > 1
+          hue -= 1
+        end
+      end
+
+      log "hue", hue
+      log "saturation", saturation
+      log "brightness", brightness
+      
+      # hue is to one decimal place; saturation and brightness to three
+      Color::HSB.new Color::round(hue * 360, 1), Color::round(saturation, 3), Color::round(brightness, 3)
+    end
+  end
+
+end

data/lib/color/sample_palette.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'color/hsb'
+require 'color/rgb'
+require 'color/util'
+require 'color/palette'
+require 'rubygems'
+require 'riel'
+
+# shows a set of colors, in text and html
+
+module Color
+
+  class SamplePalette < Palette
+    include Loggable
+
+    def initialize(hues, args = Hash.new)
+      super(args)
+
+      n_samples        = args[:samples]
+      n_total_samples  = args[:total_samples]
+      n_per_hue        = if n_samples
+                           hues.collect { n_samples }
+                         else
+                           Color::distribution(n_total_samples, hues.length)
+                         end
+
+      info "n_per_hue: #{n_per_hue}"
+      
+      @colors = Array.new
+
+      hues.each_with_index do |hue, idx|
+        n_per_hue[idx].times do
+          # don't keep trying ...
+          10.times do
+            sat = Color::random_in_range(saturation_start, saturation_end, saturation_step)
+            brt = Color::random_in_range(brightness_start, brightness_end, brightness_step)
+
+            hsb = HSB.new hue, sat / 100.0, brt / 100.0
+
+            if @colors.include?(hsb)
+              # try, try again
+            else
+              @colors << hsb
+              break
+            end
+          end
+        end
+      end
+    end
+
+    def colors
+      @colors
+    end
+
+    def print_html_tables(io = $stdout)
+      n_columns = 1 + (@brightness_end - @brightness_start) / @brightness_step
+      
+      colors_by_hue.sort.each do |hue, by_sat|
+        io.puts "<table width=\"100%\">"
+        io.puts "    <tr>"
+        print_html_hue_line(io, hue, 1)
+        io.puts "    </tr>"
+        
+        by_sat.sort.each do |sat, by_brt|
+          by_brt.sort.reverse.each do |brt, hsb|
+            io.puts "    <tr>"
+            print_html_color(io, sat, brt, hsb.to_rgb, 100)
+            io.puts "    </tr>"
+          end
+        end
+        io.puts "</table>"
+        io.puts "<br/>"
+      end
+    end
+  end
+end

data/lib/color/scheme.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+# creates schemes
+
+require 'color/rgb'
+
+module Color
+
+  # classes or methods, or factory?
+
+  class Scheme
+    include Loggable
+
+    # creates a hue from the value, processing it as a hue (0-360) or as
+    # RRGGBB, or generating a random one, if nil or an empty string.
+    
+    def self.create_hue(value)
+      if value.nil?
+        (rand * 360).round
+      elsif value.kind_of? Numeric
+        value.round % 360
+      elsif value.kind_of? String
+        if %r{^\d{3}$}.match(value)
+          value.to_i.round % 360
+        elsif md = Color::RGB::RRGGBB_REGEXP.match(value)
+          Color::RGB.new(value).to_hsb.hue
+        else
+          raise RuntimeError.new("invalid hue value '#{value}")
+        end
+      else
+        raise RuntimeError.new("invalid hue value '#{value}")
+      end
+    end
+
+    attr_reader :hues
+      
+    def initialize
+      @hues = Array.new
+    end
+
+    def add_hue(val)
+      hue = self.class.create_hue(val)
+      @hues << hue
+      hue
+    end
+  end
+
+  class Monochromatic < Scheme
+    def initialize(val)
+      super()
+
+      add_hue(val)
+    end
+  end
+
+  class Complementary < Scheme
+    def initialize(val)
+      super()
+
+      hue = add_hue(val)
+      add_hue(hue + 180)
+    end
+  end
+
+  class Triadic < Scheme
+    def initialize(val)
+      super()
+      
+      hue = add_hue(val)
+      add_hue(hue + 120)
+      add_hue(hue + 240)
+    end
+  end
+
+  class SplitComplementary < Scheme
+    def initialize(val, deg)
+      super()
+      
+      hue = add_hue(val)
+      add_hue(hue + 180 + deg)
+      add_hue(hue + 180 - deg)
+    end
+  end
+
+  class DoubleComplementary < Scheme
+    def initialize(val0, val1)
+      super()
+
+      hue0 = add_hue(val0)
+      hue1 = add_hue(val1)
+      
+      add_hue(hue0 + 180)
+      add_hue(hue1 + 180)
+    end
+  end  
+
+  class Analogous < Scheme
+    def initialize(val, deg)
+      super()
+
+      hue = add_hue(val)
+      
+      add_hue(hue - deg)
+      add_hue(hue + deg)
+    end
+  end
+
+  class Hues < Scheme
+    def initialize(startval, endval, interval)
+      super()
+
+      starthue = self.class.create_hue(startval)
+      info "starthue: #{starthue}"
+      endhue   = self.class.create_hue(endval)
+      info "endhue: #{endhue}"
+      
+      (starthue .. endhue).step(interval) do |hue|
+        add_hue(hue)
+      end
+    end
+  end
+
+end

data/lib/color/util.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Color                    # should be riel
+
+  def self.check_constraint(val, str, minimum, maximum)
+    if val < minimum || val > maximum
+      raise RuntimeError.new("#{str} must be (#{minimum} .. #{maximum}), not: #{val}")
+    end
+  end
+
+  def self.round(num, places)
+    (num * 10 ** places).round / (10 ** places).to_f
+  end
+
+  # returns an array, of length len, of numbers, equally (or near-equally)
+  # distributed for the total
+
+  def self.distribution(total, len)
+    base_per = total.to_f / len
+    pivot    = total - (base_per.floor * len)
+    
+    (0 ... len).collect { |idx| base_per.floor + (idx < pivot ? 1 : 0) }
+  end
+    
+  def self.random_in_range(from, to, interval)
+    from + rand((to.to_f - from) / interval).round * interval
+  end
+
+end