iconofthestoneage-doodl 0.0.2 → 0.0.4

data/lib/graph_canvas.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+require 'layout'
+
+require 'java'
+
+
+include_class 'java.awt.Color'
+include_class 'java.awt.Font'
+include_class 'java.awt.geom.Ellipse2D'
+include_class 'java.awt.geom.Line2D'
+include_class 'java.awt.RenderingHints'
+include_class 'java.awt.BasicStroke'
+include_class 'java.awt.Polygon'
+include_class 'java.awt.font.TextLayout'
+
+include_class 'java.util.concurrent.ConcurrentLinkedQueue'
+
+
+class GraphCanvas < java.awt.Canvas
+  include java.awt.event.MouseListener
+
+  attr_accessor :graph, :layout
+  attr_accessor :iterative
+
+  def initialize
+    super
+    @iterative = true
+
+    @frame = 0
+    @queue = ConcurrentLinkedQueue.new
+
+    @d = 25
+    @poly = Polygon.new
+    @poly.addPoint(0, 0)
+    @poly.addPoint(6, 14)
+    @poly.addPoint(0, 11)
+    @poly.addPoint(-6, 14)
+    @poly.addPoint(0, 0)
+    setBackground(Color::black)
+  end
+
+  def update_layout(layout)
+    if @iterative
+      if @layout != layout
+        @layout = layout
+        @queue.clear
+      end
+      @queue.add(layout.deep_copy)
+      repaint unless @painting
+    end
+  end
+
+  def paint(g)
+    if @queue.size > 0
+      @painting = true
+      @queued_layout = @queue.poll
+      paint_graph(g)
+      java.lang.Thread.sleep(20)
+      repaint
+    elsif @layout
+      @queued_layout = @layout
+      paint_graph(g)
+      @painting = false
+    end
+  end
+
+  def paint_graph(g)
+    if (@queued_layout.graph)
+      paint_info(g)
+      paint_edges(g)
+      paint_nodes(g)
+    end
+  end
+
+  def paint_info(g)
+    rh =  RenderingHints.new(RenderingHints.new(RenderingHints::KEY_ANTIALIASING, RenderingHints::VALUE_ANTIALIAS_ON))
+    g.setRenderingHints(rh);
+    g.setStroke(BasicStroke.new(2))
+
+    finished = ""
+    finished = "finished" if @queued_layout.finished?
+    g.setColor(Color::white)
+    g.drawString("Iteration: #{@queued_layout.iterations}", 10, 20)
+    g.drawString("Layout: #{@queued_layout.class.name} #{finished}", 10, self.height - 20)
+  end
+
+  def paint_node(g, node, location)
+    shape = Ellipse2D::Double.new(location.x-@d/2.0, location.y-@d/2.0, @d, @d)
+    g.setColor(Color::black)
+    g.fill(shape)
+    if @queued_layout.graph.node_data(:is_clicked?) and @queued_layout.graph.node_data(:is_clicked?)[node]
+      g.setColor(Color::blue)
+    elsif @queued_layout.graph.node_data(:path) and @queued_layout.graph.node_data(:path)[node]
+      g.setColor(Color::red)
+    else
+      g.setColor(Color::white)
+    end
+    g.draw(shape)
+  end
+
+  def paint_nodes(g)
+    @queued_layout.each_node_location do |node, location|
+      paint_node(g, node, location)
+    end
+  end
+
+  def paint_edge(g, edge)
+    s = @queued_layout[edge.source]
+    t = @queued_layout[edge.target]
+    line = Line2D::Double.new(s.x, s.y, t.x, t.y)
+    if (@queued_layout.graph.has_edge_data_key?(:path) and @queued_layout.graph.edge_data(:path)[edge])
+      g.setColor(Color::ORANGE)
+      g.setStroke(BasicStroke.new(6))
+      g.draw(line)
+    end
+    if (@queued_layout.graph.edge_data(:is_clicked?) and @queued_layout.graph.edge_data(:is_clicked?)[edge])
+      g.setColor(Color::blue)
+    else
+      g.setColor(Color::white)
+    end
+    if (edge.directed?)
+      paint_arrowhead(g, edge)
+    end
+    g.setStroke(BasicStroke.new(2))
+    g.draw(line)
+  end
+
+  def paint_arrowhead(g, edge)
+    a = @queued_layout[edge.source]
+    b = @queued_layout[edge.target]
+    g.setStroke(BasicStroke.new(2))
+    line = Line2D::Double.new(a.x, a.y, b.x, b.y)
+    g.draw(line)
+    teta = Math::atan2((a.x - b.x), a.y - b.y)
+    dist = Math.sqrt((a.x - b.x)**2 + (a.y - b.y)**2)
+    frac = @d/2.0 / dist
+    px = b.x - frac * (b.x - a.x)
+    py = b.y - frac * (b.y - a.y)
+
+    at = g.getTransform
+    g.translate(px, py)
+    g.rotate(-teta)
+
+    if (@queued_layout.graph.has_edge_data_key?(:path) and @queued_layout.graph.edge_data(:path)[edge])
+      color = g.getColor
+      stroke = g.getStroke
+      g.setColor(Color::ORANGE)
+      g.setStroke(BasicStroke.new(6))
+      g.draw(@poly)
+      g.setStroke(stroke)
+      g.setColor(color)
+    end
+    g.draw(@poly)
+    g.fill(@poly)
+
+
+    g.setTransform(at)
+  end
+
+  def paint_edges(g)
+    g.setColor(Color::white)
+    @queued_layout.graph.each_edge do |edge|
+      if edge.source == edge.target
+        paint_ref_edge(g, edge)
+      else
+        paint_edge(g, edge)
+      end
+    end
+  end
+
+  def paint_ref_edges(g, node)
+    loc = @layout[node]
+    shape = Ellipse2D::Double.new(loc.x, loc.y, 40, 40)
+    g.setColor(Color::white)
+    g.draw(shape)
+  end
+
+  def width
+    return self.getWidth
+  end
+
+  def height
+    return self.getHeight
+  end
+
+end

data/lib/graph_generator.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+require "facets/array/combination"
+
+module Doodl
+
+  module GraphGenerator
+
+    def gen_random_graph(number_of_nodes, number_of_links = nil)
+      if number_of_links
+        raise ArgumentError if directed? and number_of_links > (number_of_nodes*(number_of_nodes-1))
+        raise ArgumentError if (not directed? and number_of_links > (number_of_nodes*(number_of_nodes-1)/2))
+      else
+        if directed?
+          number_of_links = rand(number_of_nodes*(number_of_nodes-1)+1)
+        else
+          number_of_links = rand(number_of_nodes*(number_of_nodes-1)/2+1)
+        end
+      end
+      @nodes = []
+      number_of_nodes.times { self.add_node }
+      combinations = combinations(@nodes)
+      number_of_links.times do
+        tupel = combinations.delete_at(rand(combinations.size))
+        self.add_edge(tupel[0], tupel[1])
+      end
+      self.changed
+      self.notify_observers(self)
+    end
+
+    def gen_connected_graph(number_of_nodes)
+      @nodes = []
+      number_of_nodes.times { self.add_node }
+
+      combinations(@nodes).each { |tupel| add_edge(tupel[0], tupel[1]) }
+      self.changed
+      self.notify_observers(self)
+    end
+
+    def gen_binary_tree(depth)
+      @nodes = []
+      ancestors = [self.add_node]
+      depth.times do |index|
+        children = []
+         ancestors.each do |node|
+          a = self.add_node
+          b = self.add_node
+          children << a << b
+          self.add_edge(node, a, false)
+          self.add_edge(node, b, false)
+        end
+        ancestors = children
+      end
+      self.changed
+      self.notify_observers(self)
+    end
+
+    def gen_ring_graph(size=3)
+      @nodes = []
+      link_linear(size)
+      if (@nodes.first != @nodes.last and not get_edge(@nodes.last, @nodes.first))
+        self.add_edge(@nodes.last, @nodes.first, false)
+      end
+      self.changed
+      self.notify_observers(self)
+    end
+
+    def gen_linear_graph(size)
+      @nodes = []
+      link_linear(size)
+      self.changed
+      self.notify_observers(self)
+    end
+
+    def gen_mesh_graph(num_rows, num_columns = nil)
+      num_columns = num_rows unless num_columns
+      @nodes = []
+      rows = []
+      num_rows.times { rows << link_linear(num_columns) }
+      index = 0
+      while index < rows.size - 1
+        link_rows(rows[index], rows[index+1])
+        index += 1
+      end
+      self.changed
+      self.notify_observers(self)
+    end
+
+    private
+
+    def combinations(array)
+      combinations = []
+      array.combination(2).each do |tupel|
+        combinations << tupel
+        if directed?
+          combinations << [tupel.last, tupel.first]
+        end
+      end
+      return combinations
+    end
+
+    def link_linear(num_nodes)
+      n = []
+      num_nodes.times { n << add_node }
+      index = 0
+      while index < (n.size - 1)
+        add_edge(n[index], n[index+1], false)
+        index += 1
+      end
+      return n
+    end
+
+    def link_rows(one, two)
+      one.each_with_index do |node, index|
+          add_edge(node, two[index])
+      end
+    end
+
+  end
+
+end

data/lib/jruby/renderer.rb

@@ -0,0 +1,413 @@
+# encoding: utf-8
+
+require 'java'
+
+  include_class 'java.awt.event.MouseMotionAdapter'
+include_class 'java.awt.geom.Point2D'
+include_class 'java.awt.geom.AffineTransform'
+include_class 'java.awt.geom.PathIterator'
+include_class 'java.awt.Color'
+include_class 'java.awt.geom.Ellipse2D'
+include_class 'java.awt.geom.Rectangle2D'
+include_class 'java.awt.Polygon'
+include_class 'java.awt.geom.Point2D'
+include_class 'java.awt.geom.Line2D'
+include_class 'java.awt.BasicStroke'
+include_class 'java.awt.RenderingHints'
+include_class 'javax.swing.SwingUtilities'
+include_class 'java.awt.font.TextLayout'
+include_class 'java.awt.Font'
+
+require 'layout/layout'
+
+module Doodl
+
+  class PluggableRenderer < javax.swing.JPanel
+
+    attr_writer :paint_iterations
+    attr_reader :node_shapes, :edge_shapes
+
+    def initialize
+      super
+      @paint_iterations = true
+      @transform = AffineTransform.new
+      @node_shapes, @edge_shapes = [], []
+      set_defaults
+      setBackground(Color::black)
+      setDoubleBuffered(true)
+      @tooltip = TooltipMouseListener.new
+      addMouseMotionListener(@tooltip)
+    end
+
+    def update_layout(layout)
+      if (paint_iterations? or layout.finished?)
+        @layout, @graph = layout, layout.graph
+        @transform = AffineTransform.new
+        if SwingUtilities.isEventDispatchThread
+          repaint
+        else
+          SwingUtilities.invokeAndWait(java.lang.Runnable.impl do
+            repaint
+            java.lang.Thread.sleep(20)
+          end)
+        end
+      end
+    end
+
+    def paintComponent(g)
+      g.setColor(getBackground)
+      g.fill(Rectangle2D::Double.new(0, 0, width, height))
+      # g.setFont(Font.new("Gill Sans", Font::BOLD, 14))
+      rh =  RenderingHints.new(
+        RenderingHints.new(RenderingHints::KEY_ANTIALIASING, RenderingHints::VALUE_ANTIALIAS_ON))
+      g.setTransform(@transform)
+      g.setRenderingHints(rh)
+      paint_graph(g)
+    end
+
+    def paint_graph(g)
+      if @graph and @layout
+        @node_shapes.clear
+        @edge_shapes.clear
+        paint_edges(g)
+        paint_nodes(g)
+        paint_node_labels(g)
+        paint_edge_labels(g)
+        paint_tooltip(g)
+      end
+    end
+
+    def paint_node(g, node)
+      if node_predicate(node)
+        shape = node_shape(node)
+        @node_shapes << [node, shape]
+        g.setColor node_fill_color(node)
+        g.fill(shape)
+        g.setColor node_stroke_color(node)
+        g.setStroke node_stroke(node)
+        g.draw(shape)
+      end
+    end
+
+    def paint_edge(g, edge)
+      if edge_predicate(edge) and node_predicate(edge.source) and node_predicate(edge.target)
+        g.setColor edge_stroke_color(edge)
+        shape = edge_shape(edge)
+        @edge_shapes << [edge, shape]
+        g.setStroke edge_stroke(edge)
+        g.draw(shape)
+        paint_arrow_head(g, edge) if arrow_head_predicate(edge)
+      end
+    end
+
+    def paint_arrow_head(g, edge)
+      at = g.getTransform
+      loc_and_angle = arrow_head_properties(g, edge)
+      if loc_and_angle
+        g.translate(loc_and_angle[0].x, loc_and_angle[0].y)
+        g.rotate(loc_and_angle[1])
+        g.setColor arrow_head_fill_color(edge)
+        shape = arrow_head_shape(edge)
+        g.fill(shape)
+        g.setStroke arrow_head_stroke(edge)
+        g.setColor arrow_head_stroke_color(edge)
+        g.draw(shape)
+        g.setTransform(at)
+      end
+    end
+
+    def paint_node_label(g, node)
+      if node_label_predicate(node) and text = node_label_string(node)
+        g.setColor node_label_color(node)
+        layout = TextLayout.new(text, g.getFont, g.getFontRenderContext)
+        position = node_label_position(node, layout)
+        layout.draw(g, position.x, position.y)
+      end
+    end
+
+    def paint_edge_label(g, edge)
+      if edge_label_predicate(edge) and text = edge_label_string(edge)
+        g.setColor edge_label_color(edge)
+        layout = TextLayout.new(text, g.getFont, g.getFontRenderContext)
+        position = edge_label_position(edge, layout)
+        layout.draw(g, position.x, position.y)
+      end
+    end
+
+    def paint_tooltip(g)
+      element = @tooltip.element
+      if element and tooltip_predicate(element)
+        temp = g.getTransform
+        layout = TextLayout.new(tooltip_string(element), g.getFont, g.getFontRenderContext)
+        rect = layout.getBounds
+        rect.x -= 3
+        rect.y -= 3
+        rect.width += 5
+        rect.height += 5
+        g.translate(@tooltip.position.x + 15, @tooltip.position.y - 15)
+        g.setColor(tooltip_fill_color(element))
+        g.fill(rect)
+        g.setColor(tooltip_stroke_color(element))
+        g.setStroke(tooltip_stroke(element))
+        g.draw(rect)
+        layout.draw(g, 0, 0)
+        g.setTransform(temp)
+      end
+    end
+
+    def paint_nodes(g)
+      @graph.each_node { |node| paint_node(g, node) }
+    end
+
+    def paint_edges(g)
+      @graph.each_edge { |edge| paint_edge(g, edge) }
+    end
+
+    def paint_node_labels(g)
+      @graph.each_node { |node| paint_node_label(g, node) }
+    end
+
+    def paint_edge_labels(g)
+      @graph.each_edge { |edge| paint_edge_label(g, edge) }
+    end
+
+    def paint_iterations?
+      @paint_iterations
+    end
+
+    def move(x, y, smooth = true)
+      repaint
+    end
+
+    def center_on_node(node)
+      @transform.translate(-@transform.getTranslateX, -@transform.getTranslateY)
+      location = @layout[node]
+      @transform.translate(-location.x + center.x, -location.y + center.y)
+      repaint
+    end
+
+    def zoom(f)
+      @transform.translate(center.x, center.y)
+      @transform.scale(f, f)
+      @transform.translate(-center.x, -center.y)
+      repaint
+    end
+
+    def zoom_absolute(f)
+      @transform.translate(center.x, center.y)
+      @transform.scale(f/@transform.getScaleX, f/@transform.getScaleY)
+      @transform.translate(-center.x, -center.y)
+      repaint
+    end
+
+    def center
+      Location.new(width/2.0, height/2.0)
+    end
+
+    def width
+      return self.getWidth
+    end
+
+    def height
+      return self.getHeight
+    end
+
+    ["shape", "stroke", "stroke_color", "fill_color", "predicate", "label_predicate", "label_string", "label_color"].each do |name|
+      ["edge", "node", "arrow_head"].each do |object|
+
+        define_method("#{object}_#{name}") do |subject|
+          instance_variable_get("@#{object}_#{name}_function").call(@graph, @layout, subject)
+        end
+
+        define_method("#{object}_#{name}_function=") do |function|
+          instance_variable_set("@#{object}_#{name}_function", function)
+        end
+
+        eval "def #{object}_#{name}_function(&block)
+                raise ArgumentError unless block_given?
+                @#{object}_#{name}_function = block
+              end"
+      end
+    end
+
+    ["tooltip_string", "tooltip_stroke_color", "tooltip_fill_color", "tooltip_stroke", "tooltip_predicate"].each do |name|
+      define_method("#{name}") do |subject|
+        instance_variable_get("@#{name}_function").call(@graph, @layout, subject)
+      end
+
+      define_method("#{name}_function=") do |function|
+        instance_variable_set("@#{name}_function", function)
+      end
+
+      eval "def #{name}_function(&block)
+              raise ArgumentError unless block_given?
+              @#{name}_function = block
+            end"
+    end
+
+    def node_label_position_function=(function)
+      @node_label_position_function = function
+    end
+
+    def node_label_position_function(&block)
+      raise ArgumentError unless block_given?
+      @node_label_position_function = block
+    end
+
+    def node_label_position(node, label_layout)
+      @node_label_position_function.call(@graph, @layout, node, label_layout)
+    end
+
+    def edge_label_position_function=(function)
+      @edge_label_position_function = function
+    end
+
+    def edge_label_position_function(&block)
+      raise ArgumentError unless block_given?
+      @edge_label_position_function = block
+    end
+
+    def edge_label_position(edge, label_layout)
+      @edge_label_position_function.call(@graph, @layout, edge, label_layout)
+    end
+
+    def set_defaults
+      node_shape_function { |g, l, n| Ellipse2D::Double.new(l[n].x-10, l[n].y-10, 20, 20) }
+      node_stroke_function { BasicStroke.new(2) }
+      node_predicate_function { true }
+      node_stroke_color_function { Color::white }
+      node_fill_color_function { Color::black }
+      node_label_predicate_function { false }
+      node_label_string_function { |g, l, n| n.to_s }
+      node_label_position_function do |g, l, node, layout|
+        nb = node_shape(node).getBounds2D
+        lb = layout.getBounds
+        Point2D::Double.new(nb.getCenterX-lb.getCenterX, nb.getCenterY-lb.getCenterY)
+      end
+      node_label_color_function { Color::white }
+
+      edge_shape_function { |g, l, e| Line2D::Double.new(l[e.source].x, l[e.source].y, l[e.target].x, l[e.target].y) }
+      edge_predicate_function { true }
+      edge_stroke_function { |g, l, e| BasicStroke.new(2) }
+      edge_stroke_color_function { Color::white }
+      edge_fill_color_function { Color::white }
+
+      edge_label_predicate_function { true }
+      edge_label_string_function { |g, l, e| g.edge_data(:text)[e] if g.has_edge_data_key?(:text) }
+      edge_label_color_function { Color::white }
+      edge_label_position_function do |g, l, edge, layout|
+        shape = edge_shape(edge)
+        edge_bounds = shape.getBounds2D
+        label_bounds = layout.getBounds
+        ex = edge_bounds.getCenterX
+        ey = edge_bounds.getCenterY
+        lx = label_bounds.getCenterX
+        ly = label_bounds.getCenterY
+        v = Location.new(l[edge.source], l[edge.target])
+        v.normalize!
+        v.rotate!(90)
+        v.mul!(15)
+        v.add!(ex-lx, ey-ly)
+      end
+
+      arrow_head_shape_function { Polygon.new([0, 4, 0, -4, 0].to_java(:int), [0, 14, 11, 14, 0].to_java(:int), 5) }
+      arrow_head_predicate_function { |g, l, e| e.directed? }
+      arrow_head_stroke_function { BasicStroke.new(2) }
+      arrow_head_stroke_color_function { Color::white }
+      arrow_head_fill_color_function { Color::white }
+
+      tooltip_string_function { |g, l, element| element.to_s }
+      tooltip_stroke_function { |g, l, element| BasicStroke.new(1) }
+      tooltip_stroke_color_function { |g, l, element| Color::WHITE }
+      tooltip_fill_color_function { |g, l, element| Color::BLACK }
+      tooltip_predicate_function { true }
+    end
+
+    private
+
+    def arrow_head_properties(g, edge)
+      get_lines(node_shape(edge.target)).each do |node_line|
+        get_lines(edge_shape(edge)).each do |edge_line|
+          if node_line.intersectsLine(edge_line)
+            location = get_intersection(node_line, edge_line)
+            angle = get_angle(edge_line)
+            return [location, angle]
+          end
+        end
+      end
+      return nil
+    end
+
+    def get_lines(shape)
+      lines = []
+      p = shape.getPathIterator(nil, 2.0)
+      until p.isDone
+        a = Array.new(6).to_java(:double)
+        type = p.currentSegment(a)
+        case type
+        when PathIterator::SEG_MOVETO
+          prev = a
+        when PathIterator::SEG_LINETO
+          lines << Line2D::Double.new(prev[0], prev[1], a[0], a[1])
+          prev = a
+        end
+        p.next
+      end
+      return lines
+    end
+
+    def get_intersection(line_a, line_b)
+      y_a = line_a.getY1
+      y_b = line_b.getY1
+      x_a = line_a.getX1
+      x_b = line_b.getX1
+      if (line_a.getX1 == line_a.getX2)
+        m_b = (line_b.getY2 - line_b.getY1) / (line_b.getX2 - line_b.getX1)
+        x = line_a.getX1
+        y = m_b * (x - x_b) + y_b
+      elsif (line_b.getX1 == line_b.getX2)
+        m_a = (line_a.getY2 - line_a.getY1) / (line_a.getX2 - line_a.getX1)
+        x = line_b.getX1
+        y = m_a * (x - x_a) + y_a
+      else
+        m_a = (line_a.getY2 - line_a.getY1) / (line_a.getX2 - line_a.getX1)
+        m_b = (line_b.getY2 - line_b.getY1) / (line_b.getX2 - line_b.getX1)
+        x = (y_b - y_a + (m_a * x_a) - (m_b * x_b)) / (m_a - m_b)
+        y = m_a * (x - x_a) + y_a
+      end
+      return Point2D::Double.new(x, y)
+    end
+
+    def get_angle(line)
+      Math::atan2((line.getX2 - line.getX1), line.getY1 - line.getY2)
+    end
+
+  end
+
+  class TooltipMouseListener < MouseMotionAdapter
+
+    attr_reader :position, :element
+
+    def mouseMoved(event)
+      result = event.getSource.node_shapes.select { |tupel| tupel[1].contains(event.getPoint)}.first
+      if result == nil
+        result = event.getSource.edge_shapes.select { |tupel| tupel[1].ptLineDist(event.getPoint) < 5.0 }.first
+      end
+      if result
+        if @element != result[0]
+          @element = result[0]
+          @position = event.getPoint
+          event.getSource.repaint
+        end
+      else
+        if @element
+          @element = nil
+          @position = nil
+          event.getSource.repaint
+        end
+      end
+    end
+
+  end
+
+end