rgraphum 0.0.1.alpha

data/lib/rgraphum/graph.rb

@@ -0,0 +1,267 @@
+# -*- coding: utf-8 -*-
+
+# FIXME some 'edge.source's are edge.source.id
+# FIXME some 'edge.target's are edge.target.id
+
+class Rgraphum::Graph
+  RGRAPHUM = Rgraphum
+
+  include Rgraphum::Graph::Math
+  include Rgraphum::Graph::Gremlin
+  include Rgraphum::Marshal
+  include Rgraphum::Simulator
+  include Rgraphum::Importer
+  include Rgraphum::Parsers
+
+  attr_accessor :aspect
+  attr_accessor :label
+
+  class << self
+
+    def build_from_adjacency_matrix( matrix, vertex_labels = [], options={} )
+      options = { loop: false, limit: 0.65 }.merge(options)
+
+      graph = new
+      if vertex_labels.size == matrix.size
+        vertex_labels.each do |label|
+          v = graph.vertices.build(label:label)
+        end
+      else
+        matrix.size.times do 
+          graph.vertices.build
+        end
+      end
+
+      matrix.each_with_index do | row,row_index|
+        row.each_with_index do |weight,col_index|
+          next if col_index == row_index and !options[:loop]
+          
+          if weight and weight >= options[:limit]
+            graph.edges.build( {source:graph.vertices[row_index], target:graph.vertices[col_index],weight:weight} )
+          end
+        end
+      end
+      graph
+    end
+
+  end
+ 
+  # @param [Hash] options
+  # @option options [Rgraphum::Vertices] :vertices   
+  # @option options [Rgraphum::Edges]    :edges
+  #
+  def initialize(options={})
+    @vertices = Rgraphum::Vertices.new
+    if options[:vertices]
+      self.vertices = options[:vertices]
+    else
+      @vertices.graph = self
+    end
+
+    @edges = Rgraphum::Edges.new
+    if options[:edges]
+      @edges.graph = self
+      self.edges = options[:edges]
+    else
+      @edges.graph = self
+    end
+
+    @aspect = "real"
+  end
+
+
+  # 再計算が必要な物にnilをセットする。
+  def clear_cache
+    @m = nil
+    @m_with_weight = nil
+  end
+
+  # m is size of edges
+  def m
+    @m ||= @edges.size
+  end
+
+  # degree
+  def degree
+    self.m * 2
+  end
+
+  # m with weight
+  def m_with_weight
+    @m_with_weight ||= @edges.inject(0.0) { |sum, edge| sum + edge.weight }
+  end
+
+  # average degree
+  def average_degree
+    @average_degree ||= (2 * @m / @vertices.size)
+  end
+
+  def average_path_length
+    raise NotImplementedError
+  end
+
+  # basic method
+  def vertices
+    @vertices
+  end
+
+  def vertices=(vertex_array)
+    @vertices = @vertices.substitute(vertex_array) do |vertex|
+      Rgraphum::Vertex(vertex)
+    end
+  end
+
+  def edges
+    @edges
+  end
+
+  def edges=(edge_array)
+    @edges = @edges.substitute(edge_array) do |edge|
+      Rgraphum::Edge(edge)
+    end
+  end
+
+  # to_real mean edge has vertex pointer
+  def real_aspect!
+    return self if @aspect == "real"
+
+    edges.each do |edge|
+      edge.source = @vertices.find_by_id(edge.source) # FIXME
+      edge.target = @vertices.find_by_id(edge.target) # FIXME
+    end
+
+    @aspect = "real"
+    self
+  end
+
+  # to_id mean edge has vertex id
+  def id_aspect!
+    return self if @aspect == "id"
+
+    edges.each do |edge|
+      edge.source = edge.source.id
+      edge.target = edge.target.id
+    end
+
+    @aspect = "id"
+    self
+  end
+
+  # pickup start vertices
+  # it mean pick vertices having no in degree
+  def start_root_vertices
+    vertices.select do |vertex|
+      vertex.inE.empty?
+    end
+  end
+
+  # pickup end vertices
+  # it mean pick vertices having no out degree
+  def end_root_vertices
+    vertices.select do |vertex|
+      vertex.outE.empty?
+    end
+  end
+
+  def dup
+    new_graph = Rgraphum::Graph.new
+
+    @vertices.each do |vertex|
+      new_vertex = vertex.dup
+      new_vertex.edges = Rgraphum::Edges.new
+      new_graph.vertices << new_vertex
+    end
+
+    @edges.each do |edge|
+      new_graph.edges << edge.dup
+    end
+
+    new_graph
+  end
+
+  def +(other)
+    new_graph = Rgraphum::Graph.new
+    start_vertex_id = @vertices.id.max
+    start_edge_id = @edges.id.max
+
+    other_dup = other.dup
+    other_dup.vertices.each do | vertex |
+      vertex.id = vertex.id + start_vertex_id
+    end
+    other_dup.edges.each do |edge|
+      edge.id = edge.id + start_edge_id
+    end
+
+    new_graph.vertices = self.dup.vertices + other_dup.vertices
+    new_graph.edges = self.dup.edges + other_dup.edges
+
+    new_graph
+  end
+
+  def compact_with_label(options={})
+    compact_with(:label, self, options)
+  end
+
+  def marge_with_label(target)
+    new_graph = self + target
+    new_graph.compact_with_label
+  end
+
+  def divide_by_time(interval=20)
+    @vertices.divide_by_time(interval)
+    @edges.divide_by_time(interval)
+
+    new_edges = Rgraphum::Edges.new
+    new_edges.graph = self
+    @edges.each do |edge|
+      conditions = { source: edge.source, target: edge.target, start: edge.start }
+      same_edge = new_edges.where(conditions).first
+      if same_edge
+        same_edge.weight += edge.weight
+      else
+        new_edges << edge
+      end
+    end
+    self.edges = new_edges
+  end
+
+  def compact_with(method_name, graph=self, options ={})
+    new_vertices = Rgraphum::Vertices.new
+    new_vertices.graph = graph
+    graph.vertices.each do |vertex|
+      same_vertex = new_vertices.find{ |v| v.send(method_name) == vertex.send(method_name) }
+      unless same_vertex
+        new_vertex = vertex.dup
+        new_vertex.edges = Rgraphum::Edges.new
+        new_vertices << new_vertex
+      end
+    end
+
+    new_edges = Rgraphum::Edges.new
+    graph.edges.each do |edge|
+      source_label = edge.source.send(method_name)
+      target_label = edge.target.send(method_name)
+      edge.source = new_vertices.find{ |vertex| vertex.send(method_name) == source_label }
+      edge.target = new_vertices.find{ |vertex| vertex.send(method_name) == target_label }
+
+      same_edge = new_edges.find{ |e| e.source.equal?(edge.source) and e.source.equal?(edge.source) }
+      if same_edge
+        same_edge.weight += edge.weight
+      else
+        new_edges << edge
+      end
+    end
+
+    graph.vertices = new_vertices
+    graph.edges = new_edges
+    graph
+  end
+
+  def ==(other)
+    return false unless aspect   == other.aspect
+    return false unless label    == other.label
+    return false unless vertices == other.vertices
+    return false unless edges    == other.edges
+    true
+  end
+end

data/lib/rgraphum/importer.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+module Rgraphum
+  module Importer
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Load graph from files
+      #
+      #
+      def load(options={})
+        parse_options = options.dup
+        parse_options[:vertices] &&= open(parse_options[:vertices])
+        parse_options[:edges]    &&= open(parse_options[:edges])
+        parse_options[:path]     &&= open(parse_options[:path])
+        parse_options[:options]  = options[:options]
+        parse parse_options
+      end
+
+      # Parse str and load graph
+      #
+      #
+      def parse(options={})
+        graph = Rgraphum::Graph.new
+
+        case options[:format]
+        when :idg_json
+          build_graph_from_idg_json graph, options[:vertices], options[:edges], (options[:options] || {})
+        when :dump
+          graph = load_from(options[:path])
+        else
+          raise ArgumentError, "Rgraphum::Importer::ClassMethods.parse: Unknown format: '#{options[:format]}'"
+        end
+
+        graph
+      end
+
+      private
+
+      def build_graph_from_idg_json(graph, vertices_json_str_or_stream, edges_json_str_or_stream, options={})
+        vertex_id_hash = {}
+        community_hash = {}
+        verbose = options[:verbose]
+
+        puts "Loading vertices ... #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}" if verbose
+        $stdout.flush if verbose
+        if vertices_json_str_or_stream
+          puts "JSON.load start  ... #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}" if verbose
+          json = JSON.load(vertices_json_str_or_stream)
+          puts "JSON.load end    ... #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}" if verbose
+          json["result"].each_with_index do |vertex_hash, i|
+            vertex_id_hash[vertex_hash["rid"]]  ||= vertex_id_hash.size
+            community_hash[vertex_hash["c_id"]] ||= graph.communities.build
+            params = {
+              id:           vertex_id_hash[vertex_hash["rid"]],
+              label:        vertex_hash["screen_name"],
+              community_id: community_hash[vertex_hash["c_id"]].id,
+            }
+            graph.vertices.build(params)
+            if verbose
+              puts ".................... #{Time.now.strftime('%Y-%m-%d %H:%M:%S')} #{i}" if (i % 10000) == 0
+            end
+          end
+        end
+
+        puts "Loading edges ...... #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}" if verbose
+        $stdout.flush if verbose
+        start_edge_number = (options[:start_edge_number].to_i rescue 1) || 1
+        end_edge_number   = (options[:end_edge_number].to_i   rescue nil)
+        end_edge_number   = nil if end_edge_number == 0
+        if edges_json_str_or_stream
+          json = JSON.load(edges_json_str_or_stream)
+          json["result"].each_with_index do |edge_hash, i|
+            next  if i < start_edge_number
+            break if end_edge_number && end_edge_number < i
+            params = {
+              weight: edge_hash["weight"].to_f,
+              source: vertex_id_hash[edge_hash["in"]],
+              target: vertex_id_hash[edge_hash["out"]],
+            }
+            if graph.class::RGRAPHUM::Edge.has_field?(:created_at)
+              params[:created_at] = Time.at(edge_hash["created_at"].to_i)
+            end
+            graph.edges.build(params)
+          end
+        end
+
+        puts "Loaded!              #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}" if verbose
+        $stdout.flush if verbose
+
+        graph
+      end
+    end
+  end
+end

data/lib/rgraphum/marshal.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+module Rgraphum::Marshal
+  def self.included(base)
+    base.__send__ :include, InstanceMethods
+    base.__send__ :extend,  ClassMethods
+  end
+
+  module InstanceMethods
+    def dump_to(path)
+      data = Marshal.dump(self)
+      File.write(path, data)
+    end
+  end
+
+  module ClassMethods
+    def load_from(path)
+      data = File.read(path)
+      graph = Marshal.load(data)
+      unless graph.is_a?(self)
+        raise TypeError, "No #{self} instance in: #{path} (#{graph.class})"
+      end
+      graph
+    end
+  end
+end

data/lib/rgraphum/motifs.rb

@@ -0,0 +1,8 @@
+
+
+class Rgraphum::Motifs
+
+  # def
+  # end
+
+end

data/lib/rgraphum/parsers/flare.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+require 'json'
+
+module Rgraphum::Parsers
+  class FlareParser
+    class << self
+      #
+      def builder(graph)
+        stream = "var flare = { \"#{graph.label}\" : "
+
+        vertices_hash = {}
+        graph.vertices.each do |vertex|
+          vertices_hash[vertex.label] = vertex.amount
+        end
+        stream += vertices_hash.to_json
+        stream += "};"
+        stream
+      end
+    end
+
+    # Options:
+    #
+    def initialize(options={})
+      default_options = {
+      }
+      @options = default_options.merge(options)
+      builder(@options[:graph]) if @options.key?(:graph)
+    end
+
+    def builder(graph)
+      @stream = self.class.builder(graph)
+    end
+
+    def to_s
+      unless @stream
+        raise ArgumentError, "Didn't build stream with builder(graph)"
+      end
+      @stream
+    end
+  end
+end

data/lib/rgraphum/parsers/gephi.rb

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+
+require 'builder/xmlmarkup'
+
+module Rgraphum::Parsers
+  class GephiParser
+    class << self
+      def builder(graph)
+        new.builder(graph)
+      end
+    end
+
+    # Options:
+    #
+    def initialize(options={})
+      default_options = {
+      }
+      @options = default_options.merge(options)
+      builder(@options[:graph]) if @options.key?(:graph)
+    end
+
+    def builder(graph)
+      xml = ""
+      @xmlobj = Builder::XmlMarkup.new(target: xml , indent: 2)
+      set_header
+
+      options = {
+        "xmlns"              => "http://www.gexf.net/1.2draft",
+        "xmlns:viz"          => "http://www.gexf.net/1.1draft/viz",
+        "xmlns:xsi"          => "http://www.w3.org/2001/XMLSchema-instance",
+        "xsi:schemaLocation" => "http://www.gexf.net/1.2draft http://www.gexf.net/1.2draft/gexf.xsd",
+        "version"            => "1.2",
+      }
+      @xmlobj.gexf(options) do
+        @xmlobj.meta(lastmodifieddate: Time.now.strftime("%Y-%m-%d")) do
+          @xmlobj.creator("Gephi 0.8")
+        end
+        opts = {
+          defaultedgetype: "directed",
+          mode:       "dynamic",
+          idtype:     "string",
+          timeformat: "dateTime",
+        }
+        @xmlobj.graph(opts) do
+          vertices_to_xml(graph.vertices)
+          edges_to_xml(graph.edges)
+        end
+      end
+
+      @xml = xml
+      @xml
+    end
+
+    def to_s
+      unless @xml
+        raise ArgumentError, "Didn't build xml with builder(graph)"
+      end
+      @xml
+    end
+
+    private
+
+    def vertices_to_xml(vertices)
+      # Vertexの登録
+      @xmlobj.nodes() do
+        vertices.each do |vertex|
+          node_to_xml(vertex)
+        end
+      end
+    end
+    alias :nodes_to_xml :vertices_to_xml
+
+    def node_to_xml(vertex)
+      new_vertex = vertex.dup
+      new_vertex.start = time_format(vertex.start) if vertex.start
+      new_vertex.end   = time_format(vertex.end)   if vertex.end
+
+      @xmlobj.node(id: vertex.id, label: vertex.label) do
+        # if vertex.attvalues and vertex.attvalues !=[]
+        #   xmlobj.spells(){
+        #     vertex.attvalues.each do |attvalue|
+        #       opts = {
+        #         start:   time_format(attvalue.start),
+        #         endopen: time_format(attvalue.end),
+        #       }
+        #       @xmlobj.spell(opts)
+        #     end
+        #   }
+        # end
+      end
+    end
+    alias :vertex_to_xml :node_to_xml
+
+    def edges_to_xml(edges)
+      # @xmlobj.attributes(class: "edge", mode: "dynamic") do
+      #   @xmlobj.attribute(id: "weight", title: "Weight", type: "float")
+      # end
+      @xmlobj.edges() do
+        edges.each do |edge|
+          edge_to_xml(edge.dup)
+        end
+      end
+    end
+
+    def edge_to_xml(edge)
+      edge_opts = {
+        id:     edge.id,
+        source: edge.source.id,
+        target: edge.target.id,
+        label:  edge.label,
+        weight: (edge.weight || 0.0),
+      }
+      @xmlobj.edge(edge_opts) do
+        if edge.attvalues and !edge.attvalues.empty?
+          mlobj.spells() do
+            edge.attvalues.each do |attvalue|
+              opts = {
+                start:   time_format(attvalue.start),
+                endopen: time_format(attvalue.end),
+              }
+              xmlobj.spell(opts)
+            end
+          end
+
+          xmlobj.attvalues() do
+            edge.attvalues.each do |attvalue|
+              attrs = {
+                :for   => "weight",
+                :value => attvalue.weight.to_f,
+                :start => time_format(attvalue.start),
+                :end   => time_format(attvalue.end),
+              }
+              xmlobj.attvalue(attrs)
+            end
+          end
+        end
+      end
+    end
+
+    def make_spells_compact_with(field_name, graph, options={})
+      graph.divide_by_time(60 * 8)
+
+      new_vertices = Rgraphum::Vertices.new
+      new_vertices.graph = graph
+
+      graph.vertices.each do |vertex|
+        same_vertex = new_vertices.find { |v|
+          v.send(field_name) == vertex.send(field_name)
+        }
+        unless same_vertex
+          new_vertex = vertex.dup
+          new_vertex.edges = []
+          new_vertices << new_vertex
+        end
+      end
+
+      new_edges = Rgraphum::Edges.new
+
+      graph.edges.each do |edge|
+        source_label = edge.source.send(field_name)
+        target_label = edge.target.send(field_name)
+
+        edge.source = new_vertices.find { |vertex| vertex.send(field_name) == source_label }
+        edge.target = new_vertices.find { |vertex| vertex.send(field_name) == target_label }
+
+        new_edge = new_edges.find { |e|
+          e.source == edge.source and e.source == edge.source
+        }
+        if new_edge
+          new_edge.weight += edge.weight
+        else
+          new_edges << edge
+        end
+      end
+
+      graph.vertices = new_vertices
+      graph.edges = new_edges
+      graph
+    end
+
+    def set_header
+      @xmlobj.instruct! :xml, encoding: 'UTF-8'
+    end
+
+    def add_spells(vertex_a, vertex_b)
+      raise NotImplementedError
+    end
+
+    def time_format(t)
+      t.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+  end
+end

data/lib/rgraphum/parsers/graphviz.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+require "open3"
+
+module Rgraphum::Parsers
+  # Graphviz is Graph drowing application.
+  # Using dot formatted file, it drow picture.
+  # This class make dot formatted file from graph and write file
+  # if you want to know details, please see graphviz manual
+  class GraphvizParser
+    class << self
+      # build graphviz file(.dot) content as string
+      # @param [Rgraphum::Graph] graph target graph .
+      # @param [String] layout type of layout, "dot", "neato", "fdp", "sfdp", "twopi", "circo". please see graphviz manual.
+      def builder(graph, layout="dot")
+        dot = "digraph #{graph.label || "sample"} { \n"
+        dot += "  graph [ layout = \"#{layout}\", overlap = false ] \n\n"
+
+        graph.edges.each do |edge|
+          s = edge[:source][:label] || edge[:source][:id]
+          t = edge[:target][:label] || edge[:target][:id]
+          label = "[label = \"#{edge[:label]}\"]" if edge[:label]
+          dot += "  \"#{s}\" -> \"#{t}\" #{label}; \n"
+        end
+
+        dot += "}"
+
+        dot
+      end
+
+      # save graph as .dot and image files
+      #
+      # @param [Rgraphum::Graph] graph
+      # @param [String]          path_prefix  Will create path_prefix.{dot,*} files
+      # @param [String]          type         picture type, "jpeg", "jpg", "png" and etc..
+      #
+      def export(graph, path_prefix, type)
+        dot = builder(graph)
+        open("#{path_prefix}.dot", "w") do |file|
+          file.write(dot)
+        end
+        cmd = "dot -T#{type} #{path_prefix}.dot -o #{path_prefix}.#{type}"
+        o, e, s = Open3.capture3(cmd)
+      end
+    end
+
+    def initialize(options={})
+      default_options = {
+        layout: "dot",
+      }
+      @options = default_options.merge(options)
+      builder(@options[:graph]) if @options.key?(:graph)
+    end
+
+    # dot output builder
+    # it call only class.method
+    # @see GraphvizParser::builder
+    def builder(graph)
+      @dot = self.class.builder(graph, @options[:layout])
+    end
+
+    # save dot file and image
+    # @param [String]          path_prefix  Will create path_prefix.{dot,*} files
+    # @param [String]          type         picture type, "jpeg", "jpg", "png" and etc..
+    def export(path_prefix, type=nil)
+      graph = @options[:graph]
+      builder(graph) unless @dot
+      self.class.export(graph, path_prefix, type)
+    end
+
+    def to_s
+      unless @dot
+        raise ArgumentError, "Didn't build dot with builder(graph)"
+      end
+      @dot
+    end
+  end
+end