rubyplb 0.2.4

data/README.rdoc

@@ -0,0 +1,45 @@
+= RubyPLB
+
+RubyPLB generates pattern lattice graphics from lists of patterns.
+
+== Features
+
+* Accept a text file with any number of patterns and generate a Graphviz DOT file, or a PNG/JPG/EPS image file.
+* Calculate z-scores of pattern nodes and create lattice graphs with temperature colorng applied. 
+
+== Installation
+
+Install the gem:
+
+  $sudo gem install rubyplb --source http://gemcutter.org
+
+== How to Use
+
+  Usage:
+         rubyplb [options] <source file> <output file>
+  
+  where:
+  <source file>
+         ".plb", ".txt"
+  <output file>
+         ."dot", ".png", ".jpg", or ".eps"
+  [options]:
+      --simple, -s:   Use simple labels for pattern nodes
+        --full, -f:   Generate a full pattern lattice without contracting nodes
+    --vertical, -v:   Draw the graph from top to bottom instead of left to right)
+    --coloring, -c:   Color pattern nodes
+    --straight, -t:   Straighten edges (available when output format is either png, jpg, or eps)
+        --help, -h:   Show this message
+
+== ToDo
+
+* Multiple input formats
+* Database connection capability
+
+== Links
+
+under construction
+
+== Copyright
+
+Copyright (c) 2009 Kow Kuroda and Yoichiro Hasebe. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rubyplb"
+    gem.summary = %Q{TODO: one-line summary of your gem}
+    gem.description = %Q{TODO: longer description of your gem}
+    gem.email = "yohasebe@gmail.com"
+    gem.homepage = "http://github.com/yohasebe/rubyplb"
+    gem.authors = ["Yoichiro Hasebe"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubyplb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.4

data/bin/rubyplb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'trollop'
+require 'rubyplb'
+require 'ruby_graphviz'
+
+########## parse options ##########
+
+opts = Trollop::options do
+  version = File.read(File.dirname(__FILE__) + "/../VERSION")
+  banner <<-EOS
+  
+RubyPLB generates pattern lattice graphics from lists of patterns.
+
+Usage:
+       rubyplb [options] <source file> <output file>
+
+where:
+<source file>
+       ".plb", ".txt"
+<output file>
+       ."dot", ".png", ".jpg", or ".eps"
+[options]:
+EOS
+
+  opt :simple,  "Use simple labels for pattern nodes", :default=> false
+  opt :full, "Generate a full pattern lattice without contracting nodes", :default=> false
+  opt :vertical, "Draw the graph from top to bottom instead of left to right)", :default => false
+  opt :coloring, "Color pattern nodes", :default => false
+  opt :straight, "Straighten edges (available when output format is either png, jpg, or eps)", :default => false
+end
+
+############### main program ############### 
+
+if ARGV.size != 2
+  showerror("Input and output files are not set properly", 1) 
+end
+
+filename1 = ARGV[0]  #input  filename
+filename2 = ARGV[1]  #output filename
+
+#
+# extract input and output file types
+#
+input_type  = filename1.slice(/\.[^\.]+\z/).split(//)[1..-1].join("")
+output_type = filename2.slice(/\.[^\.]+\z/).split(//)[1..-1].join("")
+
+if (input_type !~ /\A(plb|txt)\z/ || output_type !~ /\A(dot|png|jpg|eps)\z/)
+  showerror("These file extensions are not (yet) supported.", 1)
+end
+
+#
+# input cxt data is kept as plain text
+#
+f = File.open(filename1, "r")
+inputdata = f.read
+f.close
+
+#
+# ask for confirmation of overwriting an exisiting file
+#
+if (File.exist?(filename2) && !opts[:sil])
+  print "#{filename2} exists and will be overwritten, OK? [y/n]"
+  var1 = STDIN.gets;
+  if /y/i !~ var1
+    exit;
+  end
+end
+
+begin
+  f = File.open(filename1, "r")
+  sentences = f.readlines.delete_if{ |s| /^\s*$/ =~ s }
+  f.close
+  if sentences.empty?
+    showerror("Input file does not contain data.", 1)
+  end
+rescue => e
+  showerror("Input file does not exist.", 1)  
+end
+
+begin
+  pl = PatLattice.new(opts)
+  sentences.each do |sentence|
+    pl.insert(sentence,  !opts[:full])
+  end
+# rescue => e
+#   showerror("Source data may have problems. Process aborted.", 1)
+end
+
+#
+# create the output file
+#
+case output_type
+when "dot"
+  File.open(filename2, "w") do |f|
+    f.write(pl.generate_dot)
+  end
+when "png"
+  pl.generate_img(filename2, "png", opts[:straight])
+when "jpg"
+  pl.generate_img(filename2, "jpg", opts[:straight])
+when "eps"
+  pl.generate_img(filename2, "eps", opts[:straight])
+end

data/lib/ruby_graphviz.rb

@@ -0,0 +1,167 @@
+## lib/ruby_graphviz.rb -- graphviz dot generator library
+## Author::    Yoichiro Hasebe (mailto: yohasebe@gmail.com)
+## Copyright:: Copyright 2009 Yoichiro Hasebe
+## License::   GNU GPL version 3
+
+class RubyGraphviz
+  
+  ## Example: 
+  ##
+  ##   g = RubyGraphviz.new("newgraph", {:rankdir => "LR", :nodesep => "0.4", :ranksep => "0.2"})
+  ##
+  def initialize(name, graph_hash = nil)
+    @name = name
+    @graph_data = graph_hash
+    @nodes = []
+    @edges = []
+    @dot   = ""
+    create_graph
+  end
+
+  protected
+
+  def create_graph
+    @dot << "graph #{@name} {\n  graph"
+    index = 0
+    if @graph_data
+      @dot << " ["
+      @graph_data.each do |k, v|
+        k = k.to_s
+        @dot << "#{k} = \"#{v}\""
+        index += 1
+        @dot << ", " unless index == @graph_data.size
+      end
+      @dot << "]"
+    end
+    @dot << ";\n"    
+  end
+  
+  def finish_graph
+    @dot << "}\n"
+  end
+
+  def create_edge(edgetype, nid1, nid2, edge_hash = nil)
+    temp = "  #{nid1.to_s} #{edgetype} #{nid2.to_s}"
+    index = 0
+    if edge_hash
+      temp << " ["      
+      edge_hash.each do |k, v|
+        k = k.to_s
+        temp << "#{k} = \"#{v}\""
+        index += 1
+        temp << ", " unless index == edge_hash.size
+      end
+      temp << "]"      
+    end
+    return temp
+  end
+  
+  public
+  
+  ## Add a subgraph to a graph (recursively)
+  ##
+  ## Example:
+  ##
+  ##   graph1.subgraph(graph2)
+  ##
+  def subgraph(graph)
+    @dot << graph.to_dot.sub(/\Agraph/, "subgraph")
+  end
+  
+  ## Set default options for nodes
+  ##
+  ## Example:
+  ##
+  ##   graph.node_default(:shape => "record", :color => "gray60")
+  ##
+  def node_default(node_hash = nil)
+    @dot << "  node["
+    index = 0
+    node_hash.each do |k, v|
+      k = k.to_s
+      @dot << "#{k} = \"#{v}\""
+      index += 1
+      @dot << ", " unless index == node_hash.size
+    end
+    @dot << "];\n"
+    self
+  end
+
+  ## Set default options for edges
+  ##
+  ## Example:
+  ##
+  ##   graph.edge_default(:color => "gray60")
+  ##
+  def edge_default(edge_hash = nil)
+    @dot << "  edge["
+    index = 0
+    edge_hash.each do |k, v|
+      k = k.to_s
+      @dot << "#{k} = \"#{v}\""
+      index += 1
+      @dot << ", " unless index == edge_hash.size
+    end
+    @dot << "];\n"
+    self
+  end
+  
+  ## Create a node with its options
+  ##
+  ## Example:
+  ##
+  ##   graph.node("node-01", :label => "Node 01", :fillcolor => "pink")
+  ##
+  def node(node_id, node_hash = nil)
+    @dot << "  #{node_id.to_s}"
+    index = 0
+    if node_hash
+      @dot << " ["
+      node_hash.each do |k, v|
+        k = k.to_s
+        @dot << "#{k} = \"#{v}\""
+        index += 1
+        @dot << ", " unless index == node_hash.size
+      end
+      @dot << "]"
+    end
+    @dot << ";\n"
+    self
+  end
+
+  ## Create a non-directional edge (connection line between nodes) with its options 
+  ##
+  ## Example:
+  ##
+  ##   graph.edge("node-01", "node-02", :label => "connecting 1 and 2", :color => "lightblue")
+  ## 
+  def edge(nid1, nid2, edge_hash = nil)
+    @dot << create_edge("--", nid1, nid2, edge_hash) + ";\n"
+    self
+  end
+
+  ## Create a directional edge (arrow from node to node) with its options 
+  ##
+  ## Example:
+  ##   graph.arrow_edge("node-01", "node-02", :label => "from 1 to 2", :color => "lightblue")
+  ##  
+  def arrow_edge(nid1, nid2, edge_hash = nil)
+    @dot << create_edge("->", nid1, nid2, edge_hash) + ";\n"
+    self
+  end
+
+  ## Align nodes on the same rank connecting them with non-directional edges
+  ##
+  def rank(nid1, nid2, edge_hash = nil)
+    @dot << "{rank=same " + create_edge("--", nid1, nid2, edge_hash) + "}\n"
+    self
+  end
+  
+  ## Convert graph into dot formatted data
+  ##
+  def to_dot
+    finish_graph
+    @dot = @dot.gsub(/\"\</m, "<").gsub(/\>\"/m, ">")
+    return @dot
+  end
+end

data/lib/rubyplb.rb

@@ -0,0 +1,336 @@
+## lib/rubyplb.rb -- Patten Lattice Builder written in Ruby
+## Design::    Kow Kuroda (mailto: kuroda@nict.go.jp)   
+## Program::   Yoichiro Hasebe (mailto: yohasebe@gmail.com)
+## Copyright:: Copyright 2009 Kow Kuroda and Yoichiro Hasebe
+## License::   GNU GPL version 3
+
+$KCODE = 'utf8'
+
+require 'ruby_graphviz'
+
+def showerror(sentence, severity)
+  if severity == 0
+    puts "Warning: #{sentence} The output may not be meaningful."
+  elsif severity == 1
+    puts "Error: #{sentence} No output generated."
+    exit
+  end
+end
+
+class Array
+  def subset
+    (0..self.length).inject([]) do |ret, n|
+      ret.push(*self.combination(n))
+    end
+  end
+end
+
+class Node
+  attr_accessor :data, :children, :parents, :leaf, :level, :num_instances
+  def initialize(data)
+    @data = data
+    @level = data.select{|b| b != "_"}.size
+    if @level == 0 
+      @leaf = true
+    else
+      @leaf = false
+    end
+    @children = []
+    @parents = []
+    @num_instances = 1
+  end
+  
+  def children_instances
+    @children.inject(0) { |sum, child| sum += child.num_instances }
+  end
+end  
+
+class PatLattice
+  attr_accessor :levels, :root_level, :root, :leaves, :nodes
+  
+  def initialize(opts)
+    @opts = opts
+    @levels = []
+    @root_level = 0
+    @root = nil
+    @leaves = []
+    @nodes = {}
+    @level_data = {}
+    @coloring = {}
+  end
+  
+  def ary_compact(ary, target = nil)
+    prev = nil
+    result = []
+    ary.each do |n|
+      next if (prev == n and n == target)
+      prev = n
+      result << n
+    end
+    return result      
+  end
+  
+  def create_patterns(sentence, compact)
+    words = sentence.split(/\s+/)
+
+    if /\((\d+)\)/ =~ words[-1]
+      words.pop 
+      times = $1.to_i
+    else
+      times = 1
+    end
+    
+    if /\[(.+)\]/ =~ words[-1]
+      words.pop
+      color = $1
+    end
+    
+    words.each do |w|
+      if /\[\]\(\)/ =~ w
+        raise "Data contains an invalid string."
+      end
+    end
+    
+    idx = (0...words.size).to_a
+    words_with_idx = words.zip(idx).collect{|a| a.join("-")}
+    masks = words_with_idx.subset
+    ptns = []
+    masks.each do |mask|
+      ptn1 = []
+      words_with_idx.each do |t|
+        if mask.index(t)
+          /\A(.*?)\-\d+\z/ =~ t
+          ptn1 << $1
+        else
+          ptn1 << "_"
+        end
+      end
+      if compact
+        ptns << ary_compact(ptn1, "_") 
+      else
+        ptns << ptn1
+      end
+    end
+
+    color = color ? color : "gray60"
+
+    if @coloring[color]
+      @coloring[color] += ptns
+    else
+      @coloring[color] = ptns
+    end
+    
+    
+    return ptns * times
+  end
+  
+  def search(pattern)
+    node = nodes[pattern.join("+").intern]
+  end
+  
+  def insert(sentence, compact)
+    ptns = create_patterns(sentence, compact)
+    
+    new_nodes = []    
+    ptns.each do |ptn|
+      if existing = search(ptn)
+        existing.num_instances += 1
+      else
+        node = Node.new(ptn)
+        nodes[node.data.join("+").intern] = node
+        new_nodes << node
+      end
+    end
+        
+    new_nodes.each do |node|
+      level = node.level
+      if levels[level]
+        levels[level] << node
+      else
+        levels[level] = [node]
+      end
+      
+
+      uplevel   = levels[level - 1]
+      if level != 0 and uplevel
+        uplevel.each do |sup_node|
+          rgx = Regexp.new("\\A" + sup_node.data.join(" ").gsub(/(\b_)+/, ".+?") + "\\z")
+          if rgx.match(node.data.join(" "))
+            sup_node.children << node
+            node.parents << sup_node
+          end
+        end
+      end
+
+      downlevel = levels[level + 1]
+      if downlevel
+        break unless downlevel
+        downlevel.each do |sub_node|
+          rgx = Regexp.new("\\A" + node.data.join(" ").gsub(/\_/, ".*") + "\\z")
+          if rgx.match(sub_node.data.join(" "))
+            node.children << sub_node
+            sub_node.parents << node  
+          end
+        end
+      end
+      @leaves << node if node.leaf
+    end
+
+    @root_level = levels.size - 1
+    @root = levels[root_level].first
+  end
+  
+  def traverse(&block)
+    levels.each do |level|
+      level.each do |node|
+        yield node
+      end
+    end
+  end
+  
+  def setup_data
+    levels.each_with_index do |level, l_index|
+      num_nodes_non_terminal = 0
+      sum_node_non_terminal = 0
+      avg_num_children = 0
+      valid_elements = []
+      level.each do |node|
+        next if node.children_instances == 0
+        valid_elements << node
+        num_nodes_non_terminal += 1 
+        sum_node_non_terminal += node.children_instances
+      end
+      if valid_elements.size > 0
+        avg_num_children = sum_node_non_terminal.to_f / num_nodes_non_terminal
+        x = valid_elements.inject(0){|sum, node| (node.children_instances - avg_num_children) ** 2 + sum}
+        std_dev = Math.sqrt( x / num_nodes_non_terminal)
+        @level_data[l_index] = {:num_nodes_non_terminal => num_nodes_non_terminal, 
+                                :avg_num_children => avg_num_children, 
+                                :std_dev_num_children => std_dev
+                                }
+      else
+        @level_data[l_index] = {:num_nodes_non_terminal => 0, 
+                                :avg_num_children => 0, 
+                                :std_dev_num_children => 0.0
+                                }
+      end
+    end
+  end
+  
+  def create_nodelabel(node)
+    if (@opts[:coloring] || !@opts[:simple])
+      if node.level != 0 and node.children_instances > 0
+        ldata = @level_data[node.level]
+        dev = node.children_instances - ldata[:avg_num_children]
+        zscore = dev / ldata[:std_dev_num_children]
+        zscore = zscore.nan? ? 0.0 : zscore
+      else
+        zscore = 0.0
+      end
+    end
+
+    color = "#ffffff"
+    if @opts[:coloring]
+      if !zscore.nan? and zscore != 0.0
+        if zscore >= 3.0
+          color = "2"
+        elsif zscore >= 2.0
+          color = "3"
+        elsif zscore >= 1.5
+          color = "4"
+        elsif zscore >= 1.0
+          color = "5"
+        elsif zscore > 0.5
+          color = "6"
+        elsif zscore >= 0.0
+          color = "7"
+        elsif zscore >= -0.5
+          color = "8"
+        elsif zscore >= -1.0
+          color = "9"
+        elsif zscore >= -1.5
+          color = "10"
+        else
+          color = "11"
+        end
+      end
+    end
+    zscore = ((zscore * 100).round / 100.0)      
+    border = "0"
+    pat_str = node.data.collect{|td|"<td color='black'>#{td}</td>"}.join
+    pat_str = "&nbsp;" * 5 if pat_str == ""        
+    label = "<<table bgcolor='#{color}' border='#{border}' cellborder='1' cellspacing='0' cellpadding='5'>" +
+            "<tr>#{pat_str}</tr>"
+    if !@opts[:simple]
+      label += "<tr><td color='black' colspan='#{node.data.size.to_s}'> "
+      if node.level != 0 and node.children_instances > 0
+        label += node.children_instances.to_s + " (" + zscore.to_s + ")"
+      end
+      label += "</td></tr>"
+    end        
+    label += "</table>>"
+    return label
+  end
+  
+  def create_node(graph, node_id, node_label)
+    graph.node(node_id, :label => node_label, :shape => "plaintext", 
+                        :height => "0.0", :width => "0.0",
+                        :margin => "0.0", :colorscheme => "rdylbu11", :URL => node_id)
+  end
+  
+  def generate_dot
+   setup_data if (@opts[:coloring] || !@opts[:simple])
+   nodes_drawn = []
+   rankdir = @opts[:vertical] ? "" : "LR" 
+   plb = RubyGraphviz.new("plb", :rankdir => rankdir, :nodesep => "0.8", :ranksep => "0.8")
+   levels.each do |level|
+     level.each do |node|
+       node_id = node.object_id     
+       unless nodes_drawn.index node_id
+         node_label = create_nodelabel(node)
+         create_node(plb, node_id, node_label) 
+         nodes_drawn << node_id
+       end
+       node.children.each do |cnode|
+         cnode_id = cnode.object_id
+         unless nodes_drawn.index cnode_id
+           cnode_label = create_nodelabel(cnode)
+           create_node(plb, cnode_id, cnode_label) 
+           nodes_drawn << node_id
+         end
+         if @opts[:coloring]
+           colors = []
+           @coloring.each do |color, val|
+             if val.index(node.data) and val.index(cnode.data)
+               colors << color
+             end
+           end
+         else
+           colors = ["black"]
+         end
+         plb.edge(node_id, cnode_id, :color => colors.join(":"))
+       end
+     end
+   end
+   result = plb.to_dot.gsub(/\"\</m, "<").gsub(/\>\"/m, ">")
+   return result
+  end
+  
+  def generate_img(outfile, image_type, straight_line = false)
+    dot = generate_dot
+    isthere_dot = `dot -V 2>&1`
+    if isthere_dot !~ /dot.*version/i
+      showerror("Graphviz's dot program cannot be found.", 1)
+    else
+      if straight_line
+        cmd = "dot | neato -n -T#{image_type} -o#{outfile} 2>rubyplb.log"
+      else
+        cmd = "dot -T#{image_type} -o#{outfile} 2>rubyplb.log"
+      end
+      IO.popen(cmd, 'r+') do |io|
+        io.puts dot
+      end
+    end
+  end  
+  
+end