iconofthestoneage-doodl 0.0.2 → 0.0.4

data/lib/layout/collapse_layout.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'layout/layout'
+
+module Doodl
+  class CollapseLayout < Layout
+
+    def initialize(view)
+      super(view)
+      @steps = 45
+    end
+
+    def dolayout(graph)
+      graph.each_node do |node|
+        @locations[node] = Location.new(@view.width / 2, @view.height / 2)
+      end
+      changed
+      notify_observers(self)
+    end
+
+  end
+
+end

data/lib/layout/fr_layout.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require "layout/layout"
+
+module Doodl
+
+  class FRLayout < Layout
+
+    def initialize(view)
+      super(view)
+      @max_iterations = 500
+      @max_dimension = [view.width, view.height].max
+    end
+
+    def dolayout(graph)
+      setup(graph)
+      while  (@iterations < @max_iterations and @temperature > 1.0/@max_dimension )
+        step(graph)
+        changed
+        notify_observers(self)
+      end
+    end
+
+    def setup(graph)
+      @temperature = @max_dimension / 10.0
+      @force_constant = Math.sqrt(@view.width * @view.height / graph.num_nodes) * 0.75
+      @disp = Hash.new
+      graph.each_node { |n| @disp[n] = Location.new(0, 0) }
+
+      randomize_locations(graph)
+    end
+
+    private
+
+    def randomize_locations(graph)
+      random = RandomLayout.new(@view)
+      random.graph = graph
+      random.layout
+      @locations = random.locations
+      changed
+      notify_observers(self)
+    end
+
+    def step(graph)
+      @iterations += 1
+      calc_repulsive_forces(graph)
+      calc_attractive_forces(graph)
+      calc_positions(graph)
+      cool
+    end
+
+    def calc_repulsive_forces(graph)
+      graph.each_node do |n|
+        graph.each_node do |m|
+          if (n != m)
+            delta = @locations[n] - @locations[m]
+            distance = delta.safedistance
+            force = (@force_constant ** 2) / distance
+            @disp[n] += delta * force / distance
+          end
+        end
+      end
+    end
+
+    def calc_attractive_forces(graph)
+      graph.each_edge do |edge|
+        if (edge.source != edge.target)
+          delta = @locations[edge.source] - @locations[edge.target]
+          distance = delta.safedistance
+          force = distance ** 2 / @force_constant
+          @disp[edge.source] -= delta * force / distance
+          @disp[edge.target] += delta * force / distance
+        end
+      end
+    end
+
+    def calc_positions(graph)
+      graph.each_node do |n|
+        nl = @locations[n]
+        distance = @disp[n].safedistance
+        x = nl.x + (@disp[n].x / distance) * [@temperature, @disp[n].x.abs].min
+        y = nl.y + (@disp[n].y / distance) * [@temperature, @disp[n].y.abs].min
+        @locations[n] = wall_bounce(Location.new(x, y))
+      end
+    end
+
+    def wall_bounce(location)
+      location.x = [[@view.width  * 0.1, location.x].max, @view.width  * 0.9].min
+      location.y = [[@view.height * 0.1, location.y].max, @view.height * 0.9].min
+      return location
+    end
+
+    def cool
+      @temperature = @temperature * (1 - @iterations.to_f / @max_iterations)
+    end
+
+  end
+
+  class Location
+    def safedistance
+      [self.length, Float::EPSILON].max
+    end
+  end
+
+end

data/lib/layout/isom_layout.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'layout/layout'
+
+require 'depth_first_search'
+
+module Doodl
+
+  class ISOMLayout < Layout
+  def initialize(view)
+    super(view)
+    @interval = 0
+    @finished = false
+    @max_epoch = 700
+    @initial_adaption = 0.9
+    @min_adaption = 0
+    @cooling_factor = 2.0
+    @finished = false
+
+    @epoch = 1
+    @interval = 100
+    @radius = 5
+    @minimal_radius = 1
+    @adaption = @initial_adaption
+  end
+
+  def dolayout(graph)
+    $LOG.info "Started ISOMLayout" if $LOG
+    setup(graph)
+    changed
+    notify_observers(self)
+    while (@epoch <= @max_epoch)
+      step(graph)
+      @epoch += 1
+      changed
+      notify_observers(self)
+    end
+    $LOG.info "Finished ISOMLayout" if $LOG
+  end
+
+  def setup(graph)
+    random = RandomLayout.new(@view)
+    random.graph=(graph)
+    random.layout
+    @locations = random.locations
+  end
+
+  def step(graph)
+    adjust(graph)
+    calc_adaption(graph)
+    @iterations += 1
+    @radius -= 1 if (@epoch % @interval == 0)
+  end
+
+  def calc_adaption(graph)
+    @adaption = [@min_adaption, @initial_adaption* Math.exp(-1 * @cooling_factor.to_f*(@epoch.to_f/@max_epoch))].max
+  end
+
+  def adjust(graph)
+    rloc = Location.new(rand(@view.width), rand(@view.height))
+    winner = graph.nodes.min { |a, b|  @locations[a].dist(rloc) <=> @locations[b].dist(rloc) }
+    dfs = DepthFirstSearch.new(graph, winner)
+    graph.each_node do |node|
+      nloc = @locations[node]
+      distance = dfs.dist[node]
+      if (distance < @radius)
+        delta_x = 2 ** (-distance) * @adaption*(nloc.x-rloc.x)
+        delta_y = 2 ** (-distance) * @adaption*(nloc.y-rloc.y)
+        delta = Location.new(delta_x, delta_y)
+        @locations[node] -= delta
+      end
+    end
+  end
+
+end
+
+end

data/lib/layout/kk_layout.rb

@@ -0,0 +1,203 @@
+# encoding: utf-8
+
+require "layout/layout"
+
+require "facets/array/combination"
+require "shortest_path/johnson_all_pair"
+
+module Doodl
+
+  class KKLayout < Layout
+    attr_reader :dm
+
+    K = 1.0
+    EPSILON = 0.1
+    LENGHT_FACTOR = 0.9
+    MAXITERATIONS = 2000
+    DISCONNECTED_MULTIPLIER = 0.5
+
+    def initialize(view)
+      super(view)
+      @adjust_for_gravity = true
+    	@exchange_vertices = true
+    end
+
+    def dolayout(graph)
+      $LOG.info "Started KKLayout" if $LOG
+      setup(graph)
+      while  (not @stabilized and @iterations < MAXITERATIONS)
+        step(graph)
+        @iterations += 1
+        changed
+        notify_observers(self)
+      end
+      $LOG.info "Finished KKLayout" if $LOG
+    end
+
+    def setup(graph)
+      initial = CircleLayout.new(@view)
+      initial.graph = graph
+      initial.layout
+      @locations = initial.locations
+      changed
+      notify_observers(self)
+      $LOG.info "Finished Randomizing"
+
+      @stabilized = false
+      @nodes = graph.nodes
+      japsp = JohnsonAllPairShortestPaths.new(graph)
+      distance = japsp.dist
+      diameter = japsp.diameter
+      @L0 = [@view.width, @view.height].min
+      @L = @L0 / diameter * LENGHT_FACTOR
+      @dm = {}
+      walk do |i, j|
+        d_ij = distance[[i, j]]
+        d_ji = distance[[j, i]]
+        d = [diameter * DISCONNECTED_MULTIPLIER, d_ij, d_ji].min
+        @dm[[i, j]] = d
+        @dm[[j, i]] = d
+      end
+
+    end
+
+
+    def step(graph)
+      energy = calculate_energy
+      old_locations = @locations.clone
+      pm = @nodes.max { |x, y| calculate_delta_m(x) <=> calculate_delta_m(y) }
+      i = 0
+      100.times do |i|
+        @locations[pm] =  @locations[pm] + calculate_delta_xy(pm)
+        deltam = calculate_delta_m(pm)
+        break if (deltam < EPSILON)
+      end
+
+      adjust_for_gravity if @adjust_for_gravity
+
+      if (@exchange_vertices and calculate_delta_m(pm) < EPSILON)
+        energy = calculate_energy
+        walk do |i, j|
+          xenergy = calculate_energy_if_exchanged(i, j)
+          if (energy > xenergy)
+            li = locations[i]
+            lj = locations[j]
+            temp = li
+            li = lj
+            lj = temp
+            break
+          end
+        end
+      end
+      diff = 0
+      @locations.each_key { |key| diff += (@locations[key] - old_locations[key]).length }
+      @stabilized = true if (diff < graph.num_nodes)
+    end
+
+    def calculate_energy
+      energy = 0
+      walk do |i, j|
+        dist = dm[[i, j]];
+				l_ij = @L * dist;
+				k_ij = K / (dist * dist)
+				delta = locations[i] - locations[j]
+				d = delta.length
+
+				energy += k_ij / 2 * (delta.x * delta.x + delta.y * delta.y + l_ij * l_ij -
+									  2 * l_ij * d)
+      end
+
+      return energy
+    end
+
+    def calculate_delta_m(m)
+  		dEdm = Location.new(0, 0)
+  		@nodes.each do |i|
+  			if (i != m)
+          dist = dm[[m,i]]
+  				l_mi = @L * dist
+  				k_mi = K / (dist * dist)
+
+  				delta = locations[m] - locations[i]
+  				d = delta.length
+  				common = k_mi * (1 - l_mi / d)
+  				dEdm += delta * common
+  			end
+  		end
+  		return dEdm.length
+    end
+
+    def calculate_delta_xy(m)
+      dE_dxm = 0
+  		dE_dym = 0
+  		d2E_d2xm = 0
+  		d2E_dxmdym = 0
+  		d2E_dymdxm = 0
+  		d2E_d2ym = 0
+
+      @nodes.each  do |i|
+        if (i != m)
+          dist = dm[[m, i]]
+  				l_mi = @L * dist
+  				k_mi = K / (dist * dist)
+  				d = locations[m] - locations[i]
+  				dist = d.length
+  				ddd = dist * dist * dist
+
+  				dE_dxm += k_mi * (1 - l_mi / dist) * d.x
+  				dE_dym += k_mi * (1 - l_mi / dist) * d.y
+  				d2E_d2xm += k_mi * (1 - l_mi * d.y * d.y / ddd)
+  				d2E_dxmdym += k_mi * l_mi * d.x * d.y / ddd
+  				d2E_d2ym += k_mi * (1 - l_mi * d.x * d.x / ddd)
+        end
+
+      end
+      d2E_dymdxm = d2E_dxmdym
+
+      denomi = d2E_d2xm * d2E_d2ym - d2E_dxmdym * d2E_dymdxm
+      delta_x = (d2E_dxmdym * dE_dym - d2E_d2ym * dE_dxm) / denomi
+      delta_y = (d2E_dymdxm * dE_dxm - d2E_d2xm * dE_dym) / denomi
+      Location.new(delta_x, delta_y)
+    end
+
+  	def calculate_energy_if_exchanged(p, q)
+  		energy = 0
+      walk do |i, j|
+				ii = i;
+				jj = j;
+				ii = q if (i == p)
+				jj = p if (j == q)
+
+        dist = dm[[i,j]]
+				l_ij = @L * dist
+				k_ij = K / (dist * dist)
+				delta = locations[ii] - locations[jj]
+				d = Math.sqrt(delta.x * delta.x + delta.y * delta.y)
+
+				energy += k_ij / 2 * (delta.x * delta.x + delta.y * delta.y + l_ij * l_ij -
+									  2 * l_ij * d)
+      end
+  		return energy
+    end
+
+    def adjust_for_gravity
+  		gcenter = Location.new(0, 0)
+  		@locations.each_value do |loc|
+  			gcenter += loc
+  		end
+      gcenter /= @locations.size
+  		@locations.each_pair do |key, value|
+  		  @locations[key] = value + (@view.center - gcenter)
+  		end
+  	end
+
+    private
+
+    def walk
+      @nodes.combination(2).to_a.each do |tupel|
+        yield(tupel[0], tupel[1])
+      end
+    end
+
+  end #end class
+end #end modulse

data/lib/layout/layout.rb

@@ -0,0 +1,240 @@
+# encoding: utf-8
+
+require 'forwardable'
+require 'observer'
+
+module Doodl
+
+  class Layout
+  extend Forwardable
+  include Observable
+
+  attr_reader :iterations, :locations, :graph
+
+  def initialize(view)
+    @view = view
+    @locations = Hash.new
+  end
+
+  def graph=(g)
+    @graph = g
+    @locations.clear
+  end
+
+  def init(graph)
+  end
+
+  def finished?
+    @finished
+  end
+
+  def layout(g = nil)
+    if g
+      self.graph = g
+    end
+    if @graph
+      @finished = false
+      @iterations = 0
+      init(@graph)
+      dolayout(@graph)
+      @finished = true
+      changed
+      notify_observers(self)
+    end
+  end
+
+  def_delegators(:@locations, :each, :[], :[]=, :delete)
+
+  def_delegator(:@locations, :each_pair, :each_node_location)
+
+  def get_nearest_node(x, y)
+    origin = Location.new(x, y)
+    nearest = @locations.inject do |memo, cmp|
+      memo[1].dist(origin) < cmp[1].dist(origin) ? memo : cmp
+    end
+    return nearest[0]
+  end
+
+  def get_nearest_node_within(x, y, radius)
+    node = get_nearest_node(x, y)
+    if @locations[node].dist(Location.new(x, y)) < radius
+      return node
+    else
+      return nil
+    end
+  end
+
+  def set_location(node, x, y, notify = false)
+    @locations[node] = Location.new(x, y)
+    if notify
+      changed
+      notify_observers(nil)
+    end
+  end
+
+  def rotate(theta)
+    center = Location.new(@view.width/2, @view.height/2)
+    @graph.each_node do |node|
+      vector = @locations[node] - center
+      vector.rotate!(theta)
+      @locations[node] = vector.add!(center)
+    end
+  end
+
+  def move(pad_x, pad_y)
+    @locations.each_value { |location| location.add!(pad_x, pad_y ) }
+  end
+
+  def center_x
+    pad_l = @locations.values.min { |a, b| a.x <=> b.x }.x
+    pad_r = @view.width - @locations.values.max { |a, b| a.x <=> b.x }.x
+    pad = ((pad_l + pad_r) / 2.0) - pad_l
+    @locations.each_value { |location| location.add!(pad, 0)  }
+  end
+
+  def center_y
+    pad_t = @locations.values.min { |a, b| a.y <=> b.y }.y
+    pad_b = @view.height - @locations.values.max { |a, b| a.y <=> b.y }.y
+    pad = ((pad_t + pad_b) / 2.0) - pad_t
+    @locations.each_value { |location| location.add!(0, pad)  }
+  end
+
+  def deep_copy
+    clone = self.clone
+    clone.locations = self.locations.clone
+    return clone
+  end
+
+end
+
+  class RandomLayout < Layout
+
+    # def initialize(view)
+    #   super(view)
+    # end
+
+    def dolayout(graph)
+      $LOG.info "Started RandomLayout" if $LOG
+      width = @view.width * 0.9
+      height = @view.height * 0.9
+      graph.each_node do |node|
+        @locations[node] = Location.new(rand(width), rand(height))
+      end
+      $LOG.info "Finished RandomLayout" if $LOG
+    end
+
+end
+
+  class CircleLayout < Layout
+
+    def initialize(view)
+      super(view)
+    end
+
+    def dolayout(graph)
+      $LOG.info "Started CircleLayout" if $LOG
+      center = @view.center
+      r = [center.x, center.y].min * 0.75
+      main = 2 * Math::PI / graph.num_nodes
+      graph.each_node_with_index do |node, index|
+        x = center.x + r * Math.sin(index * main)
+        y = center.y + r * Math.cos(index * main)
+        @locations[node] = Location.new(x, y)
+      end
+      $LOG.info "Finished CircleLayout" if $LOG
+    end
+
+  end
+
+  class Location
+    attr_accessor :x, :y
+
+    def initialize(a, b)
+      if a.is_a?(Numeric) and b.is_a?(Numeric)
+        @x, @y = a, b
+      else
+        @x = b.x - a.x
+        @y = b.y - a.y
+      end
+    end
+
+    def dist(other)
+      Math.sqrt((@x - other.x) ** 2 + (@y - other.y) ** 2)
+    end
+
+    def -@
+      self * (-1)
+    end
+
+    def +(other)
+      Location.new(@x + other.x, @y + other.y)
+    end
+
+    def -(other)
+      Location.new(@x - other.x, @y - other.y)
+    end
+
+    def *(scalar)
+      Location.new(scalar * @x, scalar * @y)
+    end
+
+    def /(scalar)
+      Location.new(@x / scalar, @y / scalar)
+    end
+
+    def div!(scalar)
+      @x /= scalar
+      @y /= scalar
+      return self
+    end
+
+    def mul!(scalar)
+      @x *= scalar
+      @y *= scalar
+      return self
+    end
+
+    def add!(a, b = nil)
+      if b
+        @x += a
+        @y += b
+      else
+        @x += a.x
+        @y += a.y
+      end
+      return self
+    end
+
+    def sub!(a, b = nil)
+      if b
+        add!(-a, -b)
+      else
+        add!(-a)
+      end
+    end
+
+    def length
+      Math.sqrt(@x**2 + @y**2)
+    end
+
+    def normalize!
+      m = length
+      div!(length)
+      return self
+    end
+
+    def rotate_radians!(theta)
+      m = length
+      a = Math.cos(theta) * @x - Math.sin(theta) * @y
+      b = Math.sin(theta) * @x + Math.cos(theta) * @y
+      @x, @y = a, b
+      return self
+    end
+
+    def rotate!(theta)
+      self.rotate_radians!((Math::PI/180.0) * theta)
+    end
+
+  end
+
+end