iconofthestoneage-doodl 0.0.2 → 0.0.4

data/lib/app/simple_model.rb

@@ -0,0 +1,292 @@
+require "observer"
+
+require "graph"
+require "layout/morph_layout"
+require "layout/collapse_layout"
+require "layout/fr_layout"
+require "layout/kk_layout"
+require "layout/isom_layout"
+require "layout/layout"
+require "shortest_path/dijkstra"
+
+class SimpleModel
+  include Observable
+
+  attr_reader :layout, :graph
+
+  def initialize
+    @graph_type = DirectedGraph
+  end
+
+  def view=(view)
+    @view = view
+  end
+
+  #Graph
+  def new_graph
+    @graph = @graph_type.new
+    @graph.add_observer(self)
+    @graph.attach_node_data(:is_clicked?, Hash.new(false))
+    @graph.attach_edge_data(:is_clicked?, Hash.new(false))
+    @layout.graph = @graph
+  end
+
+  def new_empty_graph
+    new_graph
+    @graph.notify_observers(nil)
+  end
+
+  def new_connected_graph(size)
+    $LOG.debug("new_connected_graph called on #{self}")
+    self.new_graph
+    @graph.gen_connected_graph(size)
+  end
+
+  def new_random_graph(node_number)
+    $LOG.debug("new_random_graph called on #{self}")
+    self.new_graph
+    @graph.gen_random_graph(node_number)
+  end
+
+  def new_ring_graph(node_number)
+    $LOG.debug("new_ring_graph called on #{self}")
+    self.new_graph
+    @graph.gen_ring_graph(node_number)
+  end
+
+  def new_binary_tree(height)
+    $LOG.debug("new_bintree_graph called on #{self}")
+    self.new_graph
+    @graph.gen_binary_tree(height)
+  end
+
+  def new_mesh_graph(rows)
+    $LOG.debug("new_mesh_graph called on #{self}")
+    self.new_graph
+    @graph.gen_mesh_graph(rows)
+  end
+
+  def new_linear_graph(size)
+    $LOG.debug("new_linear_graph called on #{self}")
+    self.new_graph
+    @graph.gen_linear_graph(size)
+  end
+
+
+  def add_node_at(x, y)
+    $LOG.debug("add_node_at #{x}, #{y} called on #{self}")
+    node = @graph.add_node(false)
+    @layout.set_location(node, x, y, true)
+    return node
+  end
+
+  def get_nearest_node(x, y)
+    $LOG.debug("get_nearest_node #{x}, #{y} called on #{self}")
+    @layout.get_nearest_node(x, y)
+  end
+
+  def set_location(node, x, y)
+    @layout.set_location(node, x, y, true)
+  end
+
+  def del_node(node)
+    @layout.delete(node)
+    @graph.del_node(node, true)
+  end
+
+  def add_edge(source, target)
+    @graph.add_edge(source, target, true)
+  end
+
+  def get_edge(source, target)
+    edge = nil
+    @graph.each_adjacent_edge(source) do |e|
+      if e.target == target
+        edge = e
+      elsif (not e.directed?) and e.source == target and e.target == source
+        edge = e
+      end
+    end
+    return edge
+  end
+
+  def del_edge(edge)
+    @graph.del_edge(edge, true)
+  end
+
+  def select_node(node)
+  end
+
+  def deselect_node(node)
+  end
+
+  def select(edge)
+  end
+
+  def deselect(edge)
+  end
+
+  #Layout
+  def new_layout(layout)
+    @layout = layout
+    @layout.add_observer(self)
+    if @graph
+      @layout.graph = @graph
+    end
+  end
+
+  def set_random_layout
+    self.new_layout(RandomLayout.new(@view.canvas))
+  end
+
+  def set_circle_layout
+    self.new_layout(CircleLayout.new(@view.canvas))
+  end
+
+  def set_fr_layout
+   self.new_layout(FRLayout.new(@view.canvas))
+  end
+
+  def set_kk_layout
+    self.new_layout(KKLayout.new(@view.canvas))
+  end
+
+  def set_morph_layout(target_layout)
+    if target_layout
+      self.new_layout(MorphLayout.new(@view.canvas, Kernel.const_get(target_layout)))
+    else
+      self.new_layout(MorphLayout.new(@view.canvas))
+    end
+  end
+
+  def set_collapse_layout
+    new_layout(CollapseLayout.new(@view.canvas))
+  end
+
+  def set_directed
+    @graph_type = DirectedGraph
+  end
+
+  def set_undirected
+    @graph_type = UndirectedGraph
+  end
+
+  def set_isom_layout
+    self.new_layout(ISOMLayout.new(@view.canvas))
+  end
+
+  def click(node)
+    @graph.node_data(:is_clicked?)[node] = true
+    changed
+    notify_observers(nil)
+  end
+
+  def unclick(node)
+    @graph.node_data(:is_clicked?)[node] = false
+    changed
+    notify_observers(nil)
+  end
+
+  def click_edge(edge)
+    @graph.edge_data(:is_clicked?)[edge] = true
+    changed
+    notify_observers(nil)
+  end
+
+  def unclick_edge(edge)
+    @graph.edge_data(:is_clicked?)[edge] = false
+    changed
+    notify_observers(nil)
+  end
+
+  def dsp(source, target)
+    stdata = @graph.attach_node_data(:start)
+    stdata[source] = true
+    endata = @graph.attach_node_data(:end)
+    endata[target] = true
+
+    dsp = DijkstraShortestPath.new(@graph, source)
+    npath = dsp.node_path_to(target)
+    epath = dsp.edge_path_to(target)
+
+    edata = @graph.attach_edge_data(:path)
+    epath.each do |edge|
+      edata[edge] = true
+    end
+    ndata = @graph.attach_node_data(:path)
+    npath.each do |node|
+      ndata[node] = true
+    end
+  end
+
+  def dspt(source)
+    @graph.attach_node_data(:start)[source] = true
+    path = []
+    edata = @graph.attach_edge_data(:path)
+    ndata = @graph.attach_node_data(:end)
+    dijk = DijkstraShortestPath.new(@graph, source)
+    @graph.each_node do |node|
+      if (node != source)
+        dijk.edge_path_to(node).each { |edge| edata[edge] = true }
+        dijk.node_path_to(node).each { |node| ndata[node] = true }
+      end
+    end
+  end
+
+  def count_nodes
+    index = 0
+    data = @graph.attach_node_data(:text)
+    @graph.each_node do |node|
+      data[node] = index.to_s
+      index += 1
+    end
+    index = 0
+    data = @graph.attach_edge_data(:text)
+    @graph.each_edge do |edge|
+      data[edge] = index.to_s
+      index += 1
+    end
+    changed
+    notify_observers(nil)
+  end
+
+  def rotate_layout(theta)
+    @layout.rotate(theta)
+    changed
+    notify_observers(nil)
+  end
+
+  def move_layout(x, y)
+    @layout.move(x, y)
+    changed
+    notify_observers(nil)
+  end
+
+  def center_x
+    @layout.center_x
+    changed
+    notify_observers(nil)
+  end
+
+  def center_y
+    @layout.center_y
+    changed
+    notify_observers(nil)
+  end
+
+  def center_xy
+    @layout.center_x
+    @layout.center_y
+    changed
+    notify_observers(nil)
+  end
+
+  #being a listener
+  def update(observable)
+    $LOG.debug("Observer #{self} being updated by #{observable}")
+    observable = nil if observable.is_a?(Graph)
+    changed
+    notify_observers(observable)
+  end
+
+end

data/lib/app/simple_view.rb

@@ -0,0 +1,148 @@
+require "logger"
+
+require "../lib/jruby/renderer"
+
+include_class 'java.awt.geom.Rectangle2D'
+include_class 'java.awt.BasicStroke'
+include_class 'java.awt.Color'
+
+class SimpleView
+
+  attr_writer :frame
+  attr_reader :canvas
+
+  def initialize
+
+  end
+
+  def canvas=(canvas)
+    @canvas = canvas
+#    @canvas.node_shape_function { |g, l, n| Rectangle2D::Double.new(l[n].x-10, l[n].y-10, 20, 20) }
+    @canvas.edge_stroke_function do |g, l, e|
+        if (g.has_edge_data_key?(:path) and g.edge_data(:path)[e])
+          BasicStroke.new(3)
+        else
+          BasicStroke.new(2)
+        end
+    end
+    @canvas.node_stroke_function do |g, l, n|
+      if (g.has_node_data_key?(:path) and g.node_data(:path)[n])
+        BasicStroke.new(3)
+      else
+        BasicStroke.new(2)
+      end
+    end
+    @canvas.node_stroke_color_function  do |g, l, n|
+      if g.node_data(:is_clicked?) and g.node_data(:is_clicked?)[n]
+        Color::BLUE
+      elsif g.node_data(:start) and g.node_data(:start)[n]
+        Color::GREEN
+      elsif g.node_data(:end) and g.node_data(:end)[n]
+        Color::YELLOW
+      else
+        Color::WHITE
+      end
+    end
+    @canvas.edge_stroke_color_function do |g, l, e|
+      if g.edge_data(:is_clicked?) and g.edge_data(:is_clicked?)[e]
+        Color::BLUE
+      else
+        Color::WHITE
+      end
+    end
+    @canvas.instance_variable_set(:@arrow_head_stroke_color_function, @canvas.instance_variable_get(:@edge_stroke_color_function))
+    @canvas.instance_variable_set(:@arrow_head_fill_color_function, @canvas.instance_variable_get(:@edge_stroke_color_function))
+    @canvas.instance_variable_set(:@edge_stroke_function, @canvas.instance_variable_get(:@arrow_head_stroke_function))
+    @canvas.instance_variable_set(:@node_label_color_function, @canvas.instance_variable_get(:@node_stroke_color_function))
+    @canvas.requestFocusInWindow
+  end
+
+  def add_key_listener(key_listener)
+    $LOG.debug("adding key_listener #{key_listener} on #{self}")
+    @canvas.addKeyListener(key_listener)
+  end
+
+  def add_mouse_listener(mouse_listener)
+    $LOG.debug("adding mouse_listener #{mouse_listener} on #{self}")
+    @canvas.addMouseListener(mouse_listener)
+  end
+
+  def add_mouse_motion_listener(mouse_motion_listener)
+    $LOG.debug("adding mouse_motion_listener #{mouse_motion_listener} on #{self}")
+    @canvas.addMouseMotionListener(mouse_motion_listener)
+  end
+
+  def remove_mouse_listener(mouse_listener)
+    $LOG.debug("removing mouse_listener #{mouse_listener} on #{self}")
+    @canvas.removeMouseListener(mouse_listener)
+  end
+
+  def remove_mouse_motion_listener(mouse_motion_listener)
+    $LOG.debug("removing mouse_motion_listener #{mouse_motion_listener} on #{self}")
+    @canvas.removeMouseMotionListener(mouse_motion_listener)
+  end
+
+  def add_info_panel(info_text)
+    $LOG.debug("adding info panel with text: #{info_text}")
+    if (@frame.isAncestorOf(@infopanel))
+      @frame.getContentPane.remove(@infopanel)
+    end
+    @infopanel = javax.swing.JLabel.new(info_text)
+    @infopanel.setBorder(javax.swing.BorderFactory.createEmptyBorder(2, 4, 2, 2))
+    @frame.getContentPane().add(@infopanel, java.awt.BorderLayout::NORTH)
+    @frame.validate
+  end
+
+  def remove_info_panel
+    @frame.getContentPane().remove(@infopanel)
+    @infopanel = nil
+    @frame.validate
+  end
+
+  def add_text_field(action_listener)
+    $LOG.debug("adding text field with action listener: #{action_listener}")
+    @textfield = javax.swing.JTextField.new
+    @textfield.addActionListener(action_listener)
+    @frame.getContentPane().add(@textfield, java.awt.BorderLayout::SOUTH)
+    @frame.validate
+    @textfield.requestFocusInWindow
+  end
+
+  def remove_text_field
+    $LOG.debug("removing text field")
+    @frame.remove(@textfield)
+    @textfield = nil
+    @frame.validate
+    @canvas.requestFocusInWindow
+  end
+
+  def toggle_paint_iterations
+    if @canvas.paint_iterations?
+      @canvas.paint_iterations = false
+    else
+      @canvas.paint_iterations = true
+    end
+  end
+
+  def width
+    @canvas.width
+  end
+
+  def height
+    @canvas.height
+  end
+
+  def update(layout)
+    $LOG.debug("Observer #{self} being updated with #{layout}")
+    if (layout)
+      @canvas.update_layout(layout)
+    else
+      @canvas.repaint
+    end
+  end
+
+  def repaint
+    @canvas.repaint
+  end
+
+end

data/lib/breadth_first_search.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require "graph"
+
+require "facets/infinity"
+
+module Doodl
+
+  class BreadthFirstSearch
+
+  attr_reader :dist, :prev, :list
+
+  def initialize(graph, source, visitor = nil)
+    raise ArgumentError unless (graph.is_a?(Graph) and graph.contains_node?(source))
+    @graph, @visitor = graph, visitor
+    @dist, @prev, @color = {}, {}, {}
+    @queue, @list = [], []
+    init_maps
+    main_algorithm(source)
+  end
+
+private
+
+  def init_maps
+    @graph.each_node do |node|
+      visit(:init, @graph, node)
+      @color[node] = :white
+      @dist[node] = INFINITY
+      @prev[node] = node
+    end
+  end
+
+  def visit_edge(edge)
+    visit(:examine_edge, @graph, edge)
+    if (@color[edge.target] == :white)
+      @color[edge.target] = :gray
+      @dist[edge.target] = @dist[edge.source] + 1
+      @prev[edge.target] = edge.source
+      @queue.push(edge.target)
+      visit(:discover, @graph, edge.target)
+      @list.push(edge.target)
+    end
+  end
+
+  def main_algorithm(source)
+    @color[source] = :gray
+    @dist[source] = 0
+    @queue.push(source)
+    visit(:discover, @graph, source)
+    @list.push(source)
+    until (@queue.empty?)
+      node = @queue.shift
+      visit(:examine_node, @graph, node)
+      @graph.each_adjacent_edge(node) do |edge|
+        visit_edge(edge)
+      end
+      @color[node] = :black
+    end
+  end
+
+  def visit(position, *arg)
+    if @visitor.respond_to?(position)
+      @visitor.send(position, *arg)
+    end
+  end
+
+end
+
+end