ruby-graphviz_c 1.1.0

data/lib/graphviz/nothugly.rb

@@ -0,0 +1,63 @@
+# This file use notugly.xsl: An XSL transform to pretty up the SVG output from Graphviz
+#
+# See: http://www.hokstad.com/making-graphviz-output-pretty-with-xsl.html
+# And: http://www.hokstad.com/making-graphviz-output-pretty-with-xsl-updated.html
+#
+# By Vidar Hokstad and Ryan Shea; Contributions by Jonas Tingborn,
+# Earl Cummings, Michael Kennedy (Graphviz 2.20.2 compatibility, bug fixes,
+# testing, lots of gradients)
+
+require 'rubygems'
+begin
+   require 'xml/xslt'
+   XSLT_METHOD = :xml_xslt_transform
+rescue LoadError => e
+   require 'libxml'
+   require 'libxslt'
+   XSLT_METHOD = :libxslt_transform
+end
+
+class GraphViz
+  # Transform to pretty up the SVG output
+  #
+  # For more information, see http://www.hokstad.com/making-graphviz-output-pretty-with-xsl.html
+  # and http://www.hokstad.com/making-graphviz-output-pretty-with-xsl-updated.html
+  #
+  # You can use the :nothugly option to GraphViz#output :
+  #
+  #   graph.output( :svg => "myGraph.svg", :nothugly => true )
+  #
+  # Or directly on an SVG output graph :
+  #
+  #   GraphViz.nothugly( "myGraph.svg" )
+  def self.nothugly( file, save = true )
+    xsl = File.join( File.dirname(File.expand_path(__FILE__)), "nothugly", "nothugly.xsl" )
+    out = self.send(XSLT_METHOD, file, xsl)
+
+    if save
+      fname = File.join( File.dirname(File.expand_path(file)), File.basename(file))
+      File.open( fname, "w" ) { |io|
+        io.print out
+      }
+    else
+      return out
+    end
+  end
+
+  def self.xml_xslt_transform(xml, xsl)
+    xslt = XML::XSLT.new()
+    xslt.xml = xml
+    xslt.xsl = xsl
+    xslt.serve()
+  end
+
+  def self.libxslt_transform(xml, xsl)
+     LibXML::XML.default_load_external_dtd = false
+     LibXML::XML.default_substitute_entities = false
+
+     stylesheet_doc = LibXML::XML::Document.file(xsl)
+     stylesheet = LibXSLT::XSLT::Stylesheet.new(stylesheet_doc)
+     xml_doc = LibXML::XML::Document.file(xml)
+     stylesheet.apply(xml_doc).to_s
+  end
+end

data/lib/graphviz/theory.rb

@@ -0,0 +1,321 @@
+require 'graphviz/math/matrix'
+
+class GraphViz
+   class Theory
+      def initialize( graph )
+         @graph = graph
+      end
+
+      # Return the adjancy matrix of the graph
+      def adjancy_matrix
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count )
+
+         @graph.each_edge { |e|
+            x = @graph.get_node(e.node_one( false )).index
+            y = @graph.get_node(e.node_two( false )).index
+            matrix[x+1, y+1] = 1
+            matrix[y+1, x+1] = 1 if @graph.type == "graph"
+         }
+
+         return matrix
+      end
+
+      # Return the incidence matrix of the graph
+      def incidence_matrix
+         tail = (@graph.type == "digraph") ? -1 : 1
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.edge_count )
+
+         @graph.each_edge { |e|
+            x = e.index
+
+            nstart = @graph.get_node(e.node_one( false )).index
+            nend = @graph.get_node(e.node_two( false )).index
+
+            matrix[nstart+1, x+1] = 1
+            matrix[nend+1, x+1] = tail
+            matrix[nend+1, x+1] = 2 if nstart == nend
+         }
+
+         return matrix
+      end
+
+      # Return the degree of the given node
+      def degree( node )
+         degree = 0
+         name = node
+         if node.kind_of?(GraphViz::Node)
+            name = node.id
+         end
+
+         @graph.each_edge do |e|
+            degree += 1 if e.node_one(false) == name or e.node_two(false) == name
+         end
+
+         return degree
+      end
+
+      # Return the laplacian matrix of the graph
+      def laplacian_matrix
+         return degree_matrix - adjancy_matrix
+      end
+
+      # Return <tt>true</tt> if the graph if symmetric, <tt>false</tt> otherwise
+      def symmetric?
+         adjancy_matrix == adjancy_matrix.transpose
+      end
+
+      # moore_dijkstra(source, destination)
+      def moore_dijkstra( dep, arv )
+         dep = @graph.get_node(dep) unless dep.kind_of?(GraphViz::Node)
+         arv = @graph.get_node(arv) unless arv.kind_of?(GraphViz::Node)
+
+         m = distance_matrix
+         n = @graph.node_count
+         # Table des sommets à choisir
+         c = [dep.index]
+         # Table des distances
+         d = []
+         d[dep.index] = 0
+
+         # Table des predecesseurs
+         pred = []
+
+         @graph.each_node do |name, k|
+            if k != dep
+               d[k.index] = m[dep.index+1,k.index+1]
+               pred[k.index] = dep
+            end
+         end
+
+         while c.size < n
+            # trouver y tel que d[y] = min{d[k];  k sommet tel que k n'appartient pas à c}
+            mini = 1.0/0.0
+            y = nil
+            @graph.each_node do |name, k|
+               next if c.include?(k.index)
+               if d[k.index] < mini
+                  mini = d[k.index]
+                  y = k
+               end
+            end
+
+            # si ce minimum est ∞ alors sortir de la boucle fin si
+            break unless mini.to_f.infinite?.nil?
+
+            c << y.index
+            @graph.each_node do |name, k|
+               next if c.include?(k.index)
+               if d[k.index] > d[y.index] + m[y.index+1,k.index+1]
+                  d[k.index] = d[y.index] + m[y.index+1,k.index+1]
+                  pred[k.index] = y
+               end
+            end
+         end
+
+         # Construction du chemin le plus court
+         ch = []
+         k = arv
+         while k.index != dep.index
+            ch.unshift(k)
+            k = pred[k.index]
+         end
+         ch.unshift(dep)
+
+         if d[arv.index].to_f.infinite?
+            return nil
+         else
+            return( {
+               :path => ch,
+               :distance => d[arv.index]
+            } )
+         end
+      end
+
+      # Return a liste of range
+      #
+      # If the returned array include nil values, there is one or more circuits in the graph
+      def range
+         matrix = adjancy_matrix
+         unseen = (1..matrix.columns).to_a
+         result = Array.new(matrix.columns)
+         r = 0
+
+         range_recursion( matrix, unseen, result, r )
+      end
+
+      # Return the critical path for a PERT network
+      #
+      # If the given graph is not a PERT network, return nul
+      def critical_path
+         return nil if range.include?(nil) or @graph.type != "digraph"
+         r = [ [0, [1]] ]
+
+         critical_path_recursion( distance_matrix, adjancy_matrix, r, [], 0 ).inject( {:distance => 0, :path => []} ) { |_r, item|
+            (_r[:distance] < item[0]) ? { :distance => item[0], :path => item[1] } : _r
+         }
+      end
+
+      # Return the PageRank in an directed graph.
+      #
+      # * damping_factor: PageRank dumping factor.
+      # * max_iterations: Maximum number of iterations.
+      # * min_delta: Smallest variation required to have a new iteration.
+      def pagerank(damping_factor = 0.85, max_iterations = 100, min_delta = 0.00001)
+         return nil unless @graph.directed?
+
+         min_value = (1.0-damping_factor)/@graph.node_count
+
+         pagerank = {}
+         @graph.each_node { |_, node|
+            pagerank[node] = 1.0/@graph.node_count
+         }
+
+         max_iterations.times { |_|
+            diff = 0
+            @graph.each_node { |_, node|
+               rank = min_value
+               incidents(node).each { |referent|
+                  rank += damping_factor * pagerank[referent] / neighbors(referent).size
+               }
+
+               diff += (pagerank[node] - rank).abs
+               pagerank[node] = rank
+            }
+            break if diff < min_delta
+         }
+
+         return pagerank
+      end
+
+      # Return the list of nodes that are directly accessible from given node
+      def neighbors(node)
+         if node.class == String
+            @graph.get_node(node).neighbors
+         else
+            node.neighbors
+         end
+      end
+
+      # Return the list of nodes that are incident to the given node (in a directed graph neighbors == incidents)
+      def incidents(node)
+         if node.class == String
+            @graph.get_node(node).incidents
+         else
+            node.incidents
+         end
+      end
+
+      # Breadth First Search
+      def bfs(node, &b)
+         queue = []
+         visited_nodes = []
+         node = @graph.get_node(node) if node.kind_of? String
+         queue << node
+         visited_nodes << node
+
+         while not queue.empty?
+            node = queue.shift
+            b.call(node)
+            neighbors(node).each do |n|
+               unless visited_nodes.include?(n)
+                  visited_nodes << n
+                  queue << n
+               end
+            end
+         end
+      end
+
+      # Depth First Search
+      def dfs(node, &b)
+         visited_nodes = []
+         recursive_dfs(node, visited_nodes, &b)
+      end
+
+      private
+      def recursive_dfs(node, visited_nodes, &b)
+         node = @graph.get_node(node) if node.kind_of? String
+         b.call(node)
+         visited_nodes << node
+         neighbors(node).each do |n|
+            recursive_dfs(n, visited_nodes, &b) unless visited_nodes.include?(n)
+         end
+      end
+
+      def distance_matrix
+         type = @graph.type
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count, (1.0/0.0) )
+
+         @graph.each_edge { |e|
+            x = @graph.get_node(e.node_one( false )).index
+            y = @graph.get_node(e.node_two( false )).index
+            unless x == y
+               weight = ((e[:weight].nil?) ? 1 : e[:weight].to_f)
+               matrix[x+1, y+1] = weight
+               matrix[y+1, x+1] = weight if type == "graph"
+            end
+         }
+
+         return matrix
+      end
+
+      def degree_matrix
+         matrix = GraphViz::Math::Matrix.new( @graph.node_count, @graph.node_count )
+         @graph.each_node do |name, node|
+            i = node.index
+            matrix[i+1, i+1] = degree(node)
+         end
+         return matrix
+      end
+
+      def range_recursion(matrix, unseen, result, r)
+         remove = []
+         matrix.columns.times do |c|
+            if matrix.sum_of_column(c+1) == 0
+               result[unseen[c]-1] = r
+               remove.unshift( c + 1 )
+            end
+         end
+
+         remove.each do |rem|
+            matrix = matrix.remove_line(rem).remove_column(rem)
+            unseen.delete_at(rem-1)
+         end
+
+         if matrix.columns == 1 and matrix.lines == 1
+            if matrix.sum_of_column(1) == 0
+               result[unseen[0]-1] = r+1
+            end
+         elsif remove.size > 0
+            range_recursion( matrix, unseen, result, r+1 )
+         end
+
+         return result
+      end
+
+      def index_of_item( array, item )
+         array.inject( [0,[]] ){|a,i|
+            a[1] << a[0] if i == item
+            a[0] += 1
+            a
+         }[1]
+      end
+
+      def critical_path_recursion( d, a, r, result, level )
+         r.each do |p|
+            node = p[1][-1]
+            index_of_item( a.line(node), 1 ).each do |c|
+               succ = c+1
+
+               cpath = [ (p[0] + d[node,succ]), (p[1].clone << succ) ]
+
+               if index_of_item( a.line(succ), 1 ).size > 0
+                  critical_path_recursion( d, a, [cpath], result, level+1 )
+               else
+                  result << cpath
+               end
+            end
+         end
+         return result
+      end
+   end
+end

data/lib/graphviz/types/arrow_type.rb

@@ -0,0 +1,32 @@
+# >> x = "hello\n\t\\l\"world\""
+# => "hello\n\t\\l\"world\""
+# >> puts x.inspect.gsub( "\\\\", "\\" )
+# "hello\n\t\l\"world\""
+#
+# OR
+#
+# >> x = 'hello\n\t\l"world"'
+# => "hello\\n\\t\\l\"world\""
+# >> puts x.inspect.gsub( "\\\\", "\\" )
+# "hello\n\t\l\"world\""
+
+class GraphViz
+  class Types
+    class ArrowType < Common
+      def check(data)
+        return data
+      end
+
+      def output
+        return @data.to_s.inspect.gsub( "\\\\", "\\" )
+      end
+
+      alias :to_gv :output
+      alias :to_s :output
+
+      def to_ruby
+         @data
+      end
+    end
+  end
+end

data/lib/graphviz/types/color.rb

@@ -0,0 +1,58 @@
+require 'graphviz/utils/colors'
+
+class ColorException < RuntimeError
+end
+
+class GraphViz
+  class Types
+    class Color < Common
+      HEX_FOR_COLOR = /[0-9a-fA-F]{2}/
+      RGBA = /^#(#{HEX_FOR_COLOR})(#{HEX_FOR_COLOR})(#{HEX_FOR_COLOR})(#{HEX_FOR_COLOR})?$/
+
+      def check(data)
+        data = data.to_s if data.is_a?(Symbol)
+        return nil if data.empty?
+
+        if data[0].chr == "#"
+          m = RGBA.match(data)
+          if m.nil?
+            raise ColorException, "Wrong color definition RGBA #{data}"
+          end
+          @to_ruby = GraphViz::Utils::Colors.rgb(m[1], m[2], m[3], m[4])
+          return data
+        elsif data.include?(",") or data.include?(" ")
+          m = data.split(/(?:\s*,\s*|\s+)/).map { |x| x.to_f }
+          if m.size != 3
+            raise ColorException, "Wrong color definition HSV #{data}"
+          end
+          @to_ruby = GraphViz::Utils::Colors.hsv(m[0], m[1], m[2])
+          return data
+        elsif data.is_a?(Array)
+          if data.all? { |x| x.is_a?(String) and x =~ /^#{HEX_FOR_COLOR}$/ } and [3,4].include?(data.size)
+            @to_ruby = GraphViz::Utils::Colors.rgb(data[0], data[1], data[2], data[3])
+            return data
+          elsif data.all? { |x| x.kind_of?(Numeric) } and data.size == 3
+            @to_ruby = GraphViz::Utils::Colors.hsv(data[0], data[1], data[2])
+            return data
+          end
+
+          raise ColorException, "Wrong color definition Array #{data}"
+        else
+          @to_ruby = GraphViz::Utils::Colors.name(data)
+          return data
+        end
+      end
+
+      def output
+        return @data.to_s.inspect.gsub( "\\\\", "\\" )
+      end
+
+      alias :to_gv :output
+      alias :to_s :output
+
+      def to_ruby
+         @to_ruby
+      end
+    end
+  end
+end