coloryze 2.0.0

data/bin/coloryze

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# exec ruby -w -x $0 ${1+"$@"} # -*- ruby -*-
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+dir = File.dirname(File.dirname(File.expand_path(__FILE__)))
+
+libpath = dir + "/lib"
+$:.unshift libpath
+
+require 'color/coloryze'
+
+Log.output = $stderr
+
+col = Coloryze.new(ARGV, $stdout)
+exit(col.exit_status)

data/lib/color.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Color
+  VERSION = '0.0.1'
+end
+
+rbfiles = Dir[File.dirname(__FILE__) + "/color/**/*.rb"]
+
+rbfiles.sort.each do |rbfile|
+  rootname = rbfile.match(%r{.*/(\w+)\.rb})[1]
+  require "color/" + rootname
+end

data/lib/color/coloryze.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'color/rgb'
+require 'color/hsb'
+require 'color/full_palette'
+require 'color/sample_palette'
+require 'color/scheme'
+
+require 'rubygems'
+require 'riel'
+
+Log.level = Log::WARN
+
+class SchemeOption
+
+  attr_accessor :stype, :desc, :cls, :option, :re, :args, :params
+  
+  def initialize(stype, desc, cls, *params)
+    @stype  = stype
+    @desc   = desc
+    @cls    = cls
+    @params = params
+    @option = '--' + stype + "=" + params.collect { |arg| arg.to_s.upcase                          }.join(',')
+    restr   = '^' + '--' + stype + "=" + params.collect { |arg| arg == :hue ? '(\#?\w+)' : '(\d+)' }.join(',') + '$'  # '$
+    @re     = Regexp.new(restr)
+    @args   = Array.new
+  end
+
+  def set_args(args)
+    (0 ... args.length).each do |idx|
+      if @params[idx] == :hue
+        @args << create_hue(args[idx])
+      else
+        @args << args[idx].to_i
+      end
+    end
+  end
+
+  def create_hue(val)
+    if Color::RGB.matches_rgb_string?(val)
+      Color::RGB.new(val).to_hsb.hue
+    elsif md = %r{^\d+$}.match(val)
+      val.to_i
+    else
+      raise RuntimeErro.new("invalid value for hue: #{val}")
+    end
+  end
+
+  def to_s
+    [ @stype, @desc, @cls, @re ].join(" ")
+  end
+end
+
+class Coloryze
+  include Loggable
+
+  VERSION = "2.0.0"
+
+  attr_reader :exit_status
+
+  def initialize(args, outio = $stdout, errio = $stderr)
+    info "args: #{args}"
+
+    @exit_status = 0
+    @scheme_options = Array.new
+
+    _add_option("monochromatic",        "display one hue",                                           Color::Monochromatic,       :hue)
+    _add_option("split-complementary",  "display hue and two complements near 180 degrees",          Color::SplitComplementary,  :hue, :deg)
+    _add_option("double-complementary", "display two hues and their two complements",                Color::DoubleComplementary, :hue, :hue)
+    _add_option("complementary",        "display hues at 180 degrees from each other",               Color::Complementary,       :hue)
+    _add_option("analogous",            "display three hues near each other",                        Color::Analogous,           :hue, :deg)
+    _add_option("triadic",              "display three equidistant hues",                            Color::Triadic,             :hue)
+    _add_option("hues",                 "display colors for the generated hues (no scheme applied)", Color::Hues,                :start, :end, :int)
+
+    output_type = :html
+    sample = nil
+    total_sample = nil
+    
+    @scheme_options.each do |sopt|
+      # info "sopt: #{sopt}"
+    end
+    
+    sopt = nil
+    scheme_args = Array.new
+
+    params = {
+      :background       => nil,
+      :saturation_start => nil,
+      :saturation_end   => nil,
+      :saturation_step  => nil,
+      :brightness_start => nil,
+      :brightness_end   => nil,
+      :brightness_step  => nil,
+    }
+
+    args.each do |arg|
+      info "arg: #{arg}"
+
+      case arg
+      when %r{--(saturation|brightness)=(\d+),(\d+),(\d+)}
+        md = Regexp.last_match
+        fieldname = md[1]
+        %w{ _start _end _step }.each_with_index do |fieldsuffix, idx|
+          field = (fieldname + fieldsuffix).intern
+          params[field] = md[idx + 2].to_i
+        end
+        # not supported
+        #       when %r{--background}
+        #         args[:background] = md[1]
+      when %r{--output=(\w+)}
+        md = Regexp.last_match
+        output_type = md[1].intern
+      when "--version"
+        show_version(outio)
+        @exit_status = 0
+        return
+      when "--verbose"
+        Log.level = Log::DEBUG
+      when %r{--sample=(\d+)}
+        md = Regexp.last_match
+        sample = md[1].to_i
+      when %r{--total-sample=(\d+)}
+        md = Regexp.last_match
+        total_sample = md[1].to_i
+      when "--help", "--usage"
+        show_usage(outio)
+        @exit_status = 0
+        return
+      else
+        md = nil
+        if sopt
+          $stderr.puts "error: invalid argument: #{arg}"
+          @sxit_status = 1
+        elsif sopt = @scheme_options.detect { |so| md = so.re.match(arg) }
+          sopt.set_args(md[1 .. -1])
+          scheme_args.concat(md[1 .. -1])
+
+          # add process for scheme without the right parameters
+        end
+      end
+    end
+
+    unless sopt
+      # check for invalid scheme parameters
+
+      args.each do |arg|
+        @scheme_options.each do |so|
+          if arg.index("--" + so.stype)
+            info "matched #{so}"
+            errio.puts "error: scheme '#{so.stype}' requires " + so.params.collect { |p| p.to_s }.join(",")
+            @exit_status = 1
+            return
+          end
+        end
+      end
+    end
+
+    unless sopt
+      show_usage(outio)
+      @exit_status = 1
+      return
+    end
+
+    info "sopt: #{sopt}"
+    info "scheme_args: #{scheme_args}"
+
+    hues = sopt.cls.new(*sopt.args).hues
+
+    info "hues: #{hues}"
+    info "params: #{params}"
+
+    info "sample: #{sample}"
+    info "total_sample: #{total_sample}"
+
+    palette_cls = if sample || total_sample
+                    # yes, a mismatch between *sample and *samples ... legacy option.
+                    params[:samples] = sample
+                    params[:total_samples] = total_sample
+                    Color::SamplePalette
+                  else
+                    Color::FullPalette
+                  end
+    
+    palette = palette_cls.new(hues, params)
+    info "palette: #{palette}"
+    if output_type == :html
+      palette.print_as_html(outio)
+    else
+      palette.print_as_text(outio)
+    end
+  end
+
+  def show_version(io)
+    io.puts "coloryze, version #{VERSION}"
+    io.puts "Written by Jeff Pace (jpace@incava.org)"
+    io.puts "Released under the GNU Public License."
+  end
+
+  def show_usage(io)
+    io.puts "usage: coloryze [options]"
+    io.puts "options:"
+    options = Array.new
+    options << [ "--help, --usage",                "display this help message" ]
+    @scheme_options.each do |sopt|
+      options << [ sopt.option, sopt.desc ]
+    end
+    options << [ "--sample=NUM",                   "select only NUM colors per hue, chosen randomly" ]
+    options << [ "--total-sample=NUM",             "select only NUM total colors, chosen randomly" ]
+    options << [ "--saturation=START,END,INT",     "set the saturation start, end, and interval" ]
+    options << [ "--brightness=START,END,INT",     "set the brightness start, end, and interval" ]
+    options << [ "--output=TYPE",                  "set the output type, \"text\" (the default) or \"html\"" ]
+    options << [ "--verbose",                      "produce debugging output" ]
+    options << [ "--version",                      "display the version and exit"]
+
+    options.each do |opt|
+      io.printf "    %-30s  %s\n", *opt
+    end
+  end
+
+  def _add_option(stype, desc, cls, *params)
+    @scheme_options << SchemeOption.new(stype, desc, cls, *params)
+  end
+
+end

data/lib/color/full_palette.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'color/hsb'
+require 'color/rgb'
+require 'color/util'
+require 'color/palette'
+
+# shows a set of colors, in text and html
+
+module Color
+
+  class FullPalette < Palette
+
+    def initialize(hues, args = Hash.new)
+      super(args)
+
+      # hue => saturation => brightness => rgb
+      @colors = Array.new
+      
+      hues.each do |hue|
+        (saturation_start .. saturation_end).step(saturation_step) do |sat|
+          (brightness_start .. brightness_end).step(brightness_step) do |brt|
+            hsb = HSB.new hue, sat / 100.0, brt / 100.0
+            @colors << hsb
+          end
+        end
+      end
+    end
+    
+    def colors
+      @colors
+    end
+
+    def puts_indented(io, level, msg)
+      io.puts((' ' * (4 * level)) + msg)
+    end
+
+    def print_html_tables(io = $stdout)
+      n_columns = 1 + (@brightness_end - @brightness_start) / @brightness_step
+
+      # want the output to be:
+
+      # +-------------------------------------------------------+
+      # + hue[0]                                                +
+      # + +-----------------------------------------------------+
+      # + + sat[0]                                              +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ 
+      # + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b +
+      # + +     + +     + +     + +     + +     + +     + +     +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+
+      # + + sat[1]                                              +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ 
+      # + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b +
+      # + +     + +     + +     + +     + +     + +     + +     +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+
+      # +-------------------------------------------------------+
+      # + hue[1]                                                +
+      # + +-----------------------------------------------------+
+      # + + sat[0]                                              +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ 
+      # + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b +
+      # + +     + +     + +     + +     + +     + +     + +     +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+
+      # + + sat[1]                                              +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ 
+      # + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b + + r/b +
+      # + +     + +     + +     + +     + +     + +     + +     +
+      # + +-----+ +-----+ +-----+ +-----+ +-----+ +-----+ +-----+
+      # +-------------------------------------------------------+
+
+      cellwidth = 100 / n_columns
+
+      level = 1
+      
+      colors_by_hue.sort.each do |hue, by_saturation|
+        puts_indented io, 1, '<table width="100%">'
+
+        puts_indented io, 2, '<tr>'
+        
+        textcolor = @background.nil? || @background.index(%r{[A-Z]\w}) ? "000000" : "FFFFFF"
+        puts_indented io, 3, "<td style=\"color: \##{textcolor};\">hue #{hue} &deg;</td>"
+        
+        puts_indented io, 2, '</tr>'
+
+        by_saturation.sort.each do |sat, by_brightness|
+          puts_indented io, 2, '<tr>'
+          puts_indented io, 3, '<td>'
+
+          puts_indented io, 4, '<table width="100%">'
+          puts_indented io, 5, '<tr>'
+          puts_indented io, 6, "<td colspan=#{n_columns}>"
+
+          puts_indented io, 7, "saturation: #{sat}"
+
+          puts_indented io, 6, '</td>'
+          puts_indented io, 5, '</tr>'
+
+          puts_indented io, 5, '<tr>'
+
+          by_brightness.sort.reverse.each do |brt, hsb|
+            rgbstr = sprintf("%06x", hsb.to_rgb)
+            
+            puts_indented io, 6, "<td style=\"width: #{cellwidth}%; vertical-align: bottom; border:2px outset; border-collapse:collapse;\">"
+            
+            puts_indented io, 7, "<table width=\"100%\" border=\"0\" border-width=\"4px\">"
+            
+            stylestr = @background ? " style=\"color: \##{rgbstr};\"" : ""
+            
+            text = sprintf "\#%s; b: %3.2f", rgbstr, brt
+              
+            puts_indented io, 8, '<tr><td' + stylestr + '>' + text + '</td></tr'
+
+            puts_indented io, 8, "<tr><td style=\"background-color: \##{rgbstr}; vertical-align: bottom;\"><br>&nbsp;</td></tr>"
+
+            puts_indented io, 7, "</table>"
+            puts_indented io, 6, "</td>"
+          end
+
+          puts_indented io, 5, '</tr>'
+
+          puts_indented io, 4, '</table>'
+
+          puts_indented io, 3, '</td>'
+          puts_indented io, 2, '</tr>'
+
+        end
+
+        puts_indented io, 1, '</table>'
+      end
+      
+      return nil if true
+        
+
+      colors_by_hue.sort.each do |hue, by_saturation|
+        print_html_hue_line(io, hue, n_columns)
+
+        io.puts "<table width=\"100%\">"
+        io.puts "    <tr>"
+      
+        by_saturation.sort.each do |sat, by_brightness|
+          by_brightness.sort.reverse.each do |brt, hsb|
+            io.puts "    <tr>"
+
+            # this is one color per row, for now
+            print_html_color(io, sat, brt, hsb.to_rgb, 100 / n_columns)
+
+            io.puts "    </tr>"
+          end
+        end
+        io.puts "</table>"
+        io.puts "<br/>"
+      end
+    end
+
+  end
+
+end

data/lib/color/hsb.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'color/rgb'
+require 'color/util'
+
+module Color
+
+  class HSB
+    attr_accessor :hue, :saturation, :brightness
+
+    def initialize(hue, saturation, brightness)
+      Color::check_constraint(hue,        "hue",        0, 360)
+      Color::check_constraint(saturation, "saturation", 0, 1)
+      Color::check_constraint(brightness, "brightness", 0, 1)
+
+      @hue        = hue
+      @saturation = saturation
+      @brightness = brightness
+    end
+
+    def to_s
+      "hue: #{hue}; saturation: #{saturation}; brightness: #{brightness}"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def equal?(other)
+      $stderr.puts "*******"
+
+      hue.equal?(other.hue) && 
+      if cmp == 0
+        cmp = saturation <=> other.saturation
+        if cmp == 0
+          cmp = brightness <=> other.brightness
+        end
+      end
+      
+      puts "returning: #{cmp}"
+      cmp
+    end
+
+    def <=>(other)
+      cmp = hue <=> other.hue
+      if cmp == 0
+        cmp = saturation <=> other.saturation
+        if cmp == 0
+          cmp = brightness <=> other.brightness
+        end
+      end
+      
+      cmp
+    end
+
+    def floats_equal?(a, b, threshold)
+      (a - b).abs < 0.0001
+    end
+
+    def ==(other)
+      threshold = 0.0001
+      floats_equal?(hue, other.hue, threshold) && floats_equal?(saturation, other.saturation, threshold) && floats_equal?(brightness, other.brightness, threshold)
+    end
+    
+    # Converts HSB (HSV) to RGB. Hue is expected as 0-360; saturation
+    # and brightness (value) as 0.0-1.0. Returns an RGB object.
+    def to_rgb
+      red = green = blue = nil
+      
+      if saturation == 0
+        red = green = blue = brightness * 255
+      else
+        hi = (hue / 60.0).to_i
+        f  = (hue / 60.0) - hi
+        p = brightness * (1 - saturation)
+        q = brightness * (1 - saturation * f)
+        t = brightness * (1 - saturation * (1 - f))
+        
+        red, green, blue = case hi
+                           when 0
+                             [ brightness, t, p ]
+                           when 1
+                             [ q, brightness, p ]
+                           when 2
+                             [ p, brightness, t ]
+                           when 3
+                             [ p, q, brightness ]
+                           when 4
+                             [ t, p, brightness ]
+                           when 5
+                             [ brightness, p, q ]
+                           else
+                             raise "error: hue: #{hue}; hi: #{hi}"
+                           end
+        
+        red   *= 255
+        green *= 255
+        blue  *= 255
+      end
+      
+      RGB.new red, green, blue
+    end
+
+  end
+
+end