yohasebe-rubyfca 0.2.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Yoichiro Hasebe
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,45 @@
+= RubyFCA
+
+Command line tool for Formal Concept Analysis (FCA) written in Ruby.
+
+== Features
+
+* Convert a Conexp's CXT file and generate a Graphviz DOT file, or a PNG/JPG/EPS image file.
+* Adopt the Ganter algorithm (through its Perl implementation of Fcastone by Uta Priss).
+
+== Installation
+
+Install the gem:
+
+  $sudo gem install rubyfca --source http://gems.github.com
+
+== How to Use
+
+  rubyfca [options] <source file> <output file>
+
+  where:
+  <source file>
+         "foo.cxt"
+  <output file>
+         "bar.dot", "bar.png", "bar.jpg", or "bar.eps"
+  [options]:
+         --box, -b:   Use box shaped concept nodes
+        --full, -f:   Do not contract concept labels
+      --legend, -l:   Print the legend of concept nodes (disabled when using circle node shape) (default: true)
+    --coloring, -c:   Color concept nodes (default: true)
+    --straight, -s:   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 Yoichiro Hasebe and Kow Kuroda. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rubyfca"
+    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/rubyfca"
+    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 = "rubyfca #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.3

data/bin/rubyfca

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'trollop'
+require 'rubyfca'
+require 'ruby_graphviz'
+
+################ parse options ##########
+
+opts = Trollop::options do
+  version = File.read(File.dirname(__FILE__) + "/../VERSION")
+  banner <<-EOS
+  
+RubuFCA converts Conexp CXT data to Graphviz dot format.
+
+Usage:
+       rubyfca [options] <source file> <output file>
+
+where:
+<source file>
+       ".cxt"
+<output file>
+       ."dot", ".png", ".jpg", or ".eps"
+[options]:
+EOS
+
+  opt :circle,  "Use circle shaped concept nodes", :default=> false
+  opt :full, "Do not contract concept labels", :default=> false
+  opt :legend, "Print the legend of concept nodes (available only when using circle node shape)", :default => false
+  opt :coloring, "Color concept 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(cxt|csv)\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
+
+#
+# context data is converted to a hash table
+#
+begin
+  ctxt = FormalContext.new(inputdata, opts[:full])
+  ctxt.calcurate
+# rescue => e
+#   puts 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(ctxt.generate_dot(opts))
+  end
+when "png"
+  ctxt.generate_img(filename2, "png", opts)
+when "jpg"
+  ctxt.generate_img(filename2, "jpg", opts)
+when "eps"
+  ctxt.generate_img(filename2, "eps", opts)
+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/rubyfca.rb

@@ -0,0 +1,397 @@
+## lib/rubyfca.rb -- Formal Concept Analysis tool in Ruby
+## Author::    Yoichiro Hasebe (mailto: yohasebe@gmail.com)
+##             Kow Kuroda (mailto: kuroda@nict.go.jp)   
+## Copyright:: Copyright 2009 Yoichiro Hasebe and Kow Kuroda
+## License::   GNU GPL version 3
+
+$KCODE ='utf-8'
+require 'ruby_graphviz'
+
+private
+
+## Take two arrays each consisting of 0s and 1s and create their logical disjunction 
+def create_and_ary(a, b)
+  return false if (s = a.size) != b.size
+  result = (0..(s-1)).to_a.map{|i| a[i].to_i & b[i].to_i}
+  return result
+end
+
+## Take two arrays each consisting of 0s and 1s and create their logical conjunction
+def create_or_ary(a, b)
+  return false if (s = a.size) != b.size
+  result = (0..(s-1)).to_a.map{|i| a[i].to_i | b[i].to_i}
+  return result
+end
+
+public
+
+## Take care of errors
+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
+
+## Basic structure of the code is the same as Fcastone written in Perl by Uta Priss
+class FormalContext
+
+  ## Converte cxt data to three basic structures of objects, attributes, and matrix
+  def initialize(input, label_contraction = true)
+    if input.size == 0
+      showerror("File is empty", 1)
+    end
+    lines = input.split
+    t1 = 3
+    if (lines[0] !~ /B/i || (2 * lines[1].to_i + lines[2].to_i + t1) != lines.size)
+      showerror("Wrong cxt format!", 1)
+    end
+    
+    @label_contraction = label_contraction
+    
+    @objects    = lines[t1..(lines[1].to_i + t1 - 1)]
+    @attributes = lines[(lines[1].to_i + t1) .. (lines[1].to_i + lines[2].to_i + t1 - 1)]
+    lines      = lines[(lines[1].to_i + lines[2].to_i + t1) .. lines.size]
+    @matrix     = changecrosssymbol("X", "\\.", lines)
+  end
+  
+  ## Apply a formal concept analysis on the matrix
+  def calcurate 
+    @concepts, @extM, @intM = ganter_alg(@matrix)
+    @relM, @reltrans, @rank = create_rel(@intM)
+    @gammaM, @muM = gammaMu(@extM, @intM, @matrix)
+  end
+
+  ## This is an implementation of an algorithm described by Bernhard Ganter 
+  ## in "Two basic algorithms in concept analysis." Technische Hochschule
+  ## Darmstadt, FB4-Preprint, 831, 1984.
+  def ganter_alg(matrix)
+
+    m = matrix
+
+    ## all arrays except @idx are arrays of arrays of 0's and 1's
+    idx = []
+    extension = []
+    intension = []
+    ext_A = []
+    int_B = []
+    endkey = []
+    temp = []
+    
+    ## the level in the lattice from the top
+    lvl = 0 
+    ## is lower than the index of leftmost attr
+    idx[lvl] = -1     
+    ## number of attr. and objs
+    anzM = m.size   
+    ## only needed for initialization  
+    anzG = m[0].size
+    ## initialize extA[0] = [1,...,1]
+    anzG.times do |i|
+      if !ext_A[0]
+        ext_A[0] = []
+      end
+      ext_A[0] << 1
+    end
+    ## initialize extB[0] = [0,...,0]
+    anzM.times do |i| 
+      if !int_B[0]
+        int_B[0] = []
+      end
+      int_B[0] << 0
+    end
+    anzCpt = 0
+    extension[0] = ext_A[0]
+    intension[0] = int_B[0]
+    anzM.times do |i|
+      endkey << 1
+    end
+
+    ## start of algorithm
+    while int_B[lvl] != endkey
+      (anzM - 1).downto(0) do |i|
+        breakkey = false
+        if (int_B[lvl][i] != 1)
+          while (i < idx[lvl])
+            lvl -= 1
+          end
+          idx[lvl + 1] = i
+          ext_A[lvl + 1] = create_and_ary(ext_A[lvl], m[i])
+          0.upto(i - 1) do |j|
+            if(!breakkey && int_B[lvl][j] != 1)
+              temp = create_and_ary(ext_A[lvl + 1], m[j])
+              if temp == ext_A[lvl + 1]
+                breakkey = true
+              end
+            end
+          end
+          unless breakkey
+            int_B[lvl + 1] = int_B[lvl].dup
+            int_B[lvl + 1][i] = 1
+            (i+1).upto(anzM - 1) do |k|
+              if int_B[lvl + 1][k] != 1
+                temp = create_and_ary(ext_A[lvl + 1], m[k])
+                if temp == ext_A[lvl + 1]
+                  int_B[lvl + 1][k] = 1
+                end
+              end
+            end
+            lvl += 1
+            anzCpt += 1
+            extension[anzCpt] = ext_A[lvl]
+            intension[anzCpt] = int_B[lvl]
+            break
+          end
+        end      
+      end
+    end
+
+    a1 = extension[0].join("")
+    a2 = extension[1].join("")
+    if a1 == a2
+      shift extension
+      shift intension
+      anzCpt -= 1
+    end
+
+    c = []
+    0.upto(anzCpt) do |i|
+      c[i] = i
+    end
+
+    [c, intension, extension]
+  end
+
+  ## Output arrayconsists of the following: 
+  ## r (subconcept superconcept relation)
+  ## rt (trans. closure of r)
+  ## s (ranked concepts)
+  def create_rel(intensions)
+    anzCpt = intensions.size
+    rank = []
+    sup_con = []
+    r = []
+    rt = []
+    s = []
+
+    0.upto(anzCpt - 1) do |i|
+      0.upto(anzCpt - 1) do |j|
+        unless r[i]
+          r[i] = []
+        end
+        r[i][j] = 0;
+        unless rt[i]
+          rt[i] = []
+        end
+        rt[i][j] = 0;
+      end
+    end
+
+    1.upto(anzCpt - 1) do |i|
+      rank[i] = 1
+      (i - 1).downto(0) do |j|
+        temp = create_and_ary(intensions[j], intensions[i])
+        if temp == intensions[i]
+          unless sup_con[i]
+            sup_con[i] = []
+          end
+          sup_con[i] << j
+          r[i][j] = 1
+          rt[i][j] = 1
+          sup_con[i].each do |elem|
+            if r[elem][j] == 1
+              r[i][j] = 0
+              if rank[elem] >= rank [i]
+                rank[i] = rank[elem] + 1
+              end
+              break
+            end
+          end
+        end
+      end
+      unless s[rank[i]]
+        s[rank[i]] = []
+      end
+      s[rank[i]] << i
+    end  
+    s = s.collect do |i|
+      i ? i : [0]
+    end
+
+    [r, rt, s]
+  end 
+
+  def gammaMu(extent, intent, cxt)
+    
+    gamma = []
+    mu = []
+    invcxt = []
+    0.upto(cxt[0].size - 1) do |i|
+      0.upto(cxt.size - 1) do |k|
+        invcxt[i] = [] unless invcxt[i]
+        invcxt[i][k] = cxt[k][i]
+      end
+    end
+
+    0.upto(intent.size - 1) do |j|
+      0.upto(cxt.size - 1) do |i|
+        gamma[i] = [] unless gamma[i]
+        if cxt[i] == intent[j]
+          gamma[i][j] = 2
+        elsif (!@label_contraction && create_or_ary(cxt[i], intent[j]) == cxt[i])
+          gamma[i][j] = 1
+        else
+          gamma[i][j] = 0
+        end
+      end
+      
+      0.upto(invcxt.size - 1) do |i|
+        # next unless invcxt[i]
+        mu[i] = [] unless mu[i]
+        if invcxt[i] == extent[j]
+          mu[i][j] = 2
+        elsif (!@label_contraction && create_or_ary(invcxt[i], extent[j]) == invcxt[i])
+          mu[i][j] = 1
+        else
+          mu[i][j] = 0
+        end        
+      end
+    end
+    
+    [gamma, mu]
+  end
+  
+  def changecrosssymbol(char1, char2, lns)
+    rel = []
+    lns.each do |ln|
+      ary = []
+      elems = ln.split(//)
+      elems.each do |elem|
+        if /#{char1}/i =~ elem
+          ary << 1
+        elsif /#{char2}/i =~ elem
+          ary << 0
+        end
+      end
+      rel << ary
+    end
+    rel
+  end
+
+  ## Generate Graphviz dot data (not creating a file)
+  ## For options, see 'rubyfca'
+  def generate_dot(opts)
+    index_max_width = @concepts.size.to_s.split(//).size
+
+    clattice = RubyGraphviz.new("clattice", :rankdir => "", :nodesep => "0.4", :ranksep => "0.2")
+
+    if opts[:circle] and opts[:legend]
+      legend   = RubyGraphviz.new("legend", :rankdir => "TB", :lebelloc => "t", :centered => "false")
+      legend.node_default(:shape => "plaintext")
+      legend.edge_default(:color => "gray60") if opts[:coloring]
+      legends = []
+    end
+
+    if opts[:circle]
+      clattice.node_default(:shape => "circle", :style => "filled") 
+      clattice.edge_default(:dir => "none", :minlen => "2")
+      clattice.edge_default(:color => "gray60") if opts[:coloring]
+    else
+      clattice.node_default(:shape => "record", :margin => "0.2,0.055") 
+      clattice.edge_default(:dir => "none")
+      clattice.edge_default(:color => "gray60") if opts[:coloring]
+    end
+    
+    0.upto(@concepts.size - 1) do |i|
+      objfull = []
+      attrfull = []  
+      0.upto(@gammaM.size - 1) do |j|
+        if @gammaM[j][i] == 2
+          obj = opts[:full] ? @objects[j] + " " + [0x261C].pack("U") : @objects[j] 
+          objfull << obj
+        elsif @gammaM[j][i] == 1
+          objfull << @objects[j]
+        end
+      end
+      0.upto(@muM.size - 1) do |k|
+        if @muM[k][i] == 2
+          att = opts[:full] ? @attributes[k] + " " + [0x261C].pack("U") : @attributes[k] 
+          attrfull << att
+        elsif @muM[k][i] == 1
+          attrfull << @attributes[k]
+        end
+      end
+
+      concept_id = i + 1
+
+      attr_str = attrfull.join('<br />')
+      attr_str = attr_str == "" ? "     " : attr_str
+      attr_color = (!opts[:coloring] || /\A\s+\z/ =~ attr_str) ? "white" : "lightblue"
+      obj_str = objfull.join('<br />')
+      obj_str = obj_str == "" ? "     " : obj_str
+      obj_color = (!opts[:coloring] || /\A\s+\z/ =~ obj_str) ? "white" : "pink"
+
+      label = "<<table border=\"0\" cellborder=\"1\" cellspacing=\"0\">" + 
+      "<tr><td balign=\"left\" align=\"left\" bgcolor=\"#{attr_color}\">#{attr_str}</td></tr>" +
+      "<tr><td balign=\"left\" align=\"left\"  bgcolor=\"#{obj_color}\">#{obj_str}</td></tr>" +
+      "</table>>"
+
+      if opts[:circle] and opts[:legend]
+
+        leg = "<<table border=\"0\" cellborder=\"1\" cellspacing=\"0\">" + 
+        "<tr><td rowspan=\"2\">#{concept_id}</td><td balign=\"left\" align=\"left\" bgcolor=\"#{attr_color}\">#{attr_str}</td></tr>" + 
+        "<tr><td balign=\"left\" align=\"left\" bgcolor=\"#{obj_color}\">#{obj_str}</td></tr>" +
+        "</table>>"
+
+        if !attrfull.empty? and !objfull.empty?
+          legend.node("cl#{concept_id}k", :label => concept_id, :style => "invis")
+          legend.node("cl#{concept_id}v", :label => leg, :fillcolor => "white")
+          legend.rank("cl#{concept_id}k", "cl#{concept_id}v", :style => "invis", :length => "0.0")
+          if legends[-1]
+            legend.edge("cl#{legends[-1]}k", "cl#{concept_id}k", :style => "invis", :length => "0.0")
+          end
+          legends << concept_id
+        end
+      end
+      
+      if opts[:circle]
+        clattice.node("c#{i}", :width => "0.5", :fontsize => "14.0", :label => concept_id)
+      else
+        clattice.node("c#{i}", :label => label, :shape => "plaintext", 
+                               :height => "0.0", :width => "0.0", :margin => "0.0")
+      end
+    end
+    
+    0.upto(@relM.size - 1) do |i|
+      0.upto(@relM.size - 1) do |j|
+        if @relM[i][j] == 1
+          clattice.edge("c#{i}", "c#{j}")
+        end
+      end
+    end
+    
+    clattice.subgraph(legend) if opts[:circle] and opts[:legend]
+    clattice.to_dot
+  end
+  
+  ## Generate an actual graphic file (Graphviz dot needs to be installed properly)
+  def generate_img(outfile, image_type, opts)
+    dot = generate_dot(opts)
+    isthere_dot = `dot -V 2>&1`
+    if isthere_dot !~ /dot.*version/i
+      showerror("Graphviz's dot program cannot be found.", 1)
+    else
+      if opts[:straight]
+        cmd = "dot | neato -n -T#{image_type} -o#{outfile} 2>rubyfca.log"
+      else
+        cmd = "dot -T#{image_type} -o#{outfile} 2>rubyfca.log"
+      end
+      IO.popen(cmd, 'r+') do |io|
+        io.puts dot
+      end
+    end
+  end  
+end
+