abscondment-rubyvor 0.1.2

data/lib/ruby_vor.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '..', 'ext')
+
+require 'ruby_vor/version'
+require 'ruby_vor/point'
+require 'ruby_vor/priority_queue'
+require 'ruby_vor/computation'
+require 'ruby_vor/geo_ruby_extensions'
+require 'ruby_vor/visualizer'
+
+# Require ruby_vor.so last to clobber old from_points
+require 'ruby_vor_c.so'
+
+# DOC HERE
+module RubyVor
+end

data/lib/ruby_vor/computation.rb

@@ -0,0 +1,137 @@
+module RubyVor
+  module VDDT
+    class Computation
+      attr_reader :points, :voronoi_diagram_raw, :delaunay_triangulation_raw, :no_neighbor_response
+
+      DIST_PROC = lambda{|a,b| a.distance_from(b)}
+      NO_NEIGHBOR_RESPONSES = [:raise, :use_all, :ignore]
+      
+      # Create a computation from an existing set of raw data.
+      def initialize
+        @points = []
+        
+        @voronoi_diagram_raw = []
+        @delaunay_triangulation_raw = []
+        
+        @nn_graph = nil
+        @mst = nil
+
+        @no_neighbor_response = :use_all
+      end
+
+      # Decided what action to take if we find a point with no neighbors
+      # while computing the nn_graph.
+      #
+      # Choices are:
+      #  * :use_all - include all other nodes as potential neighbors. This choice is the default, and can lead to higher big-O lower bounds when clustering.
+      #  * :raise - raise an error
+      #  * :ignore - leave this node disconnected from the rest of the graph.
+      def no_neighbor_response=(v)
+        @no_neighbor_response = v if NO_NEIGHBOR_RESPONSES.include?(v)
+      end
+
+      # Uses the nearest-neighbors information encapsulated by the Delaunay triangulation as a seed for clustering:
+      # We take the edges (there are O(n) of them, because  defined by the triangulation and delete any edge above a certain distance.
+      #
+      # This method allows the caller to pass in a lambda for customizing distance calculations. For instance, to use a GeoRuby::SimpleFeatures::Point, one would:
+      #  > cluster_by_distance(50 lambda{|a,b| a.spherical_distance(b, 3958.754)}) # this rejects edges greater than 50 miles, using spherical distance as a measure
+      def cluster_by_distance(max_distance, dist_proc=DIST_PROC)
+        clusters = []
+        nodes    = (0..points.length-1).to_a
+        visited  = [false] * points.length
+        graph    = []
+        v = 0
+        
+        nn_graph.each_with_index do |neighbors,v|
+          graph[v] = neighbors.select do |neighbor|
+            dist_proc[points[v], points[neighbor]] < max_distance
+          end
+        end
+
+        
+        until nodes.empty?
+          v = nodes.pop
+          
+          next if visited[v]
+
+          cluster = []
+          visited[v] = true
+          cluster.push(v)
+
+          children = graph[v]
+          until children.nil? || children.empty?
+            cnode = children.pop
+            next if cnode.nil? || visited[cnode]
+
+            visited[cnode] = true
+            cluster.push(cnode)
+            children.concat(graph[cnode])
+          end
+
+          clusters.push(cluster)
+        end
+
+        clusters
+      end
+
+      def cluster_by_size(sizes=[], dist_proc=DIST_PROC)
+        # * Take MST, and
+        #   1. For n in sizes (taken in descending order), delete the n most expensive edges from MST
+        #     * TODO: use a MaxHeap?
+        #   2. Determine remaining connectivity using BFS as above?
+        #   3. Some other more efficient connectivity test?
+        #   4. Return {n1 => cluster, n2 => cluster} for all n.
+        
+        sized_clusters = sizes.inject({}) {|h,s| h[s] = []; h}
+        
+        
+        mst = minimum_spanning_tree(dist_proc).to_a
+        mst.sort!{|a,b|a.last <=> b.last}
+
+        sizes = sizes.sort
+        last_size = 0
+
+        while current_size = sizes.shift
+          current_size -= 1
+          
+          # Remove edge count delta
+          delta = current_size - last_size
+          mst.slice!(-delta,delta)
+
+          graph    = (1..points.length).to_a.map{|v| []}
+          visited  = [nil] * points.length
+          clusters = []
+
+          mst.each do |edge,weight|
+            graph[edge[1]].push(edge[0])
+            graph[edge[0]].push(edge[1])
+          end
+
+          for node in 0..points.length-1
+            next if visited[node]
+
+            cluster = [node]
+            visited[node] = true
+
+            neighbors = graph[node]
+            while v = neighbors.pop
+              next if visited[v]
+
+              cluster.push(v)
+              visited[v] = true
+              neighbors.concat(graph[v])
+            end
+
+            clusters.push(cluster)
+          end
+
+          sized_clusters[current_size + 1] = clusters
+          last_size = current_size
+        end
+        
+        sized_clusters
+      end
+
+    end
+  end
+end

data/lib/ruby_vor/geo_ruby_extensions.rb

@@ -0,0 +1,15 @@
+if require 'geo_ruby'
+  # Let us call uniq on a set of Points or use one as a Hash key.
+  module GeoRuby
+    module SimpleFeatures
+      class Point < Geometry
+        def eql?(other)
+          self == other
+        end
+        def hash
+          [x,y,z,m].hash
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vor/point.rb

@@ -0,0 +1,32 @@
+module RubyVor
+  class Point
+    attr_reader :x, :y
+    def initialize(x=0.0,y=0.0)
+      raise TypeError, 'Must be able to convert point values into floats' unless x.respond_to?(:to_f) && y.respond_to?(:to_f)
+      @x = x.to_f
+      @y = y.to_f
+    end
+
+    def <=>(p)
+      (@x != p.x) ? @x <=> p.x : @y <=> p.y
+    end
+
+    def <(p)
+      (self <=> p) == -1
+    end
+
+    def >(p)
+      (self <=> p) == 1
+    end
+    
+    def ==(p)
+      @x == p.x && @y == p.y
+    end
+    alias :eql? :==
+
+    def to_s
+      "(#{@x},#{@y})"
+    end    
+
+  end
+end

data/lib/ruby_vor/priority_queue.rb

@@ -0,0 +1,84 @@
+module RubyVor
+  class PriorityQueue
+
+    attr_reader :data, :size
+
+    class << self
+      def build_queue(max_index=-1,&block)
+        data = []
+
+        index = 0
+        loop do
+          x = QueueItem.new(nil, nil, nil)
+
+          yield(x)
+          break if !(max_index < 0 || index < max_index) || x.priority.nil?
+          
+          x.index = index
+          data.push(x)
+          index += 1
+        end
+
+        q = new
+        q.instance_variable_set(:@data, data)
+        q.instance_variable_set(:@size, data.length)
+        q.heapify()
+
+        return q
+      end
+    end
+    
+    def initialize
+      @data = []
+      @size = 0
+      heapify()
+    end
+
+    def peek
+      @data[0]
+    end
+
+    def pop
+      return nil if @size < 1
+      
+      r = @data[0]
+
+      @data[0] = @data[@size-1]
+      @data[0].index = 0
+      @data.delete_at(@size-1)
+
+      @size -= 1
+      
+      percolate_down(0) if @size > 0
+
+      return r
+    end
+
+    def push(data, priority=data)
+      @size += 1
+      @data[@size - 1] = QueueItem.new(priority, @size - 1, data)
+      percolate_up(@size - 1)
+    end
+
+    # Implemented in C
+    def reorder_queue;end
+
+    protected
+
+    # Implemented in C
+    def percolate_up(i);end
+
+    # Implemented in C
+    def percolate_down(i);end
+
+    class QueueItem
+      attr_accessor :priority, :index, :data
+      def initialize(p, i, d)
+        @priority = p
+        @index    = i
+        @data     = d
+      end
+    end
+    
+  end
+end

data/lib/ruby_vor/version.rb

@@ -0,0 +1,3 @@
+module RubyVor
+  VERSION = '0.1.2'
+end

data/lib/ruby_vor/visualizer.rb

@@ -0,0 +1,218 @@
+require 'xml/libxml' unless defined?(LibXML)
+module RubyVor
+  class Visualizer
+
+    COLORS = %w{black red blue lime gray yellow purple orange pink}
+
+    # Support various versions of LibXML
+    include LibXML if defined?(LibXML)
+      
+    def self.make_svg(computation, opts={})
+      @opts = opts = {
+        :name            => 'vddt.svg',
+        :triangulation   => true,
+        :voronoi_diagram => false,
+        :mst             => false,
+        :cbd             => false,
+      }.merge(opts)
+
+      line_colors = COLORS.clone
+      
+      doc = XML::Document.new()
+      
+      doc.root = XML::Node.new('svg')
+      doc.root['xmlns'] = 'http://www.w3.org/2000/svg'
+      doc.root['xml:space'] = 'preserve'
+
+      max_x = 0
+      min_x = Float::MAX
+      max_y = 0
+      min_y = Float::MAX
+      pmax_x = 0
+      pmin_x = Float::MAX
+      pmax_y = 0
+      pmin_y = Float::MAX
+
+      computation.points.each do |point|
+        max_x = point.x if point.x > max_x
+        min_x = point.x if point.x < min_x
+        max_y = point.y if point.y > max_y
+        min_y = point.y if point.y < min_y
+        pmax_x = point.x if point.x > pmax_x
+        pmin_x = point.x if point.x < pmin_x
+        pmax_y = point.y if point.y > pmax_y
+        pmin_y = point.y if point.y < pmin_y
+      end
+
+      if opts[:voronoi_diagram]
+        computation.voronoi_diagram_raw.each do |item|
+          if item.first == :v
+            max_x = item[1] if item[1] > max_x
+            min_x = item[1] if item[1] < min_x
+            max_y = item[2] if item[2] > max_y
+            min_y = item[2] if item[2] < min_y
+          end
+        end
+      end
+      
+      opts[:offset_x] = -1.0 * min_x + 20
+      opts[:offset_y] = -1.0 * min_y + 20
+
+      if opts[:triangulation]
+        # Draw in the triangulation
+        color = line_colors.shift
+        computation.delaunay_triangulation_raw.each do |triplet|
+          for i in 0..2
+            line = line_from_points(computation.points[triplet[i % 2 + 1]], computation.points[triplet[i & 6]])
+            line['style'] = "stroke:#{color};stroke-width:1;"            
+            doc.root << line
+          end
+        end
+      end
+
+      if opts[:mst]
+        color = line_colors.shift
+        computation.minimum_spanning_tree.each do |edge, weight|
+          line = line_from_points(computation.points[edge[0]], computation.points[edge[1]])
+          line['style'] = "stroke:#{color};stroke-width:1;"
+          doc.root << line
+        end
+      end
+
+      if opts[:cbd]
+        mst = computation.minimum_spanning_tree
+        
+        computation.cluster_by_distance(opts[:cbd]).each do |cluster|
+          
+          color = new_color
+          min_dist = Float::MAX
+          set_min  = false
+          cluster.each do |a|
+            cluster.each do |b|
+              next if a == b
+              k = a < b ? [a,b] : [b,a]
+              next unless mst.has_key?(k)
+
+              if mst[k] < min_dist
+                min_dist = mst[k]
+                set_min = true
+              end
+            end
+          end
+
+          min_dist = 10 unless set_min
+
+
+          cluster.each do |v|
+            node = circle_from_point(computation.points[v])
+            node['r'] = (min_dist + 10).to_s
+            node['style'] = "fill:#{color};stroke:#{color};"
+            node['opacity'] = '0.4'
+
+            doc.root << node
+          end
+
+        end
+      end
+
+      if opts[:voronoi_diagram]
+        voronoi_vertices = []
+        draw_lines = []
+        draw_points = []
+        line_functions = []
+        
+        xcut = (pmax_x + pmin_x) / 2.0
+        ycut = (pmax_y + pmin_y) / 2.0
+
+        color = line_colors.shift
+
+        computation.voronoi_diagram_raw.each do |item|
+          case item.first
+          when :v
+            # Draw a voronoi vertex
+            v = RubyVor::Point.new(item[1], item[2])
+            voronoi_vertices.push(v)
+            node = circle_from_point(v)
+            node['fill'] = 'red'
+            node['r'] = '2'
+            node['stroke'] = 'black'
+            node['stroke-width'] = '1'
+
+            draw_points << node
+          when :l
+            # :l a b c  --> ax + by = c
+            a = item[1]
+            b = item[2]
+            c = item[3]
+            line_functions.push({ :y => lambda{|x| (c - a * x) / b},
+                                  :x => lambda{|y| (c - b * y) / a} })
+          when :e
+            if item[2] == -1 || item[3] == -1
+              from_vertex = voronoi_vertices[item[2] == -1 ? item[3] : item[2]]
+              
+              next if from_vertex < RubyVor::Point.new(0,0)              
+
+              if item[2] == -1
+                inf_vertex = RubyVor::Point.new(0, line_functions[item[1]][:y][0])
+              else
+                inf_vertex = RubyVor::Point.new(max_x, line_functions[item[1]][:y][max_x])
+              end
+
+              line = line_from_points(from_vertex, inf_vertex)
+            else
+              line = line_from_points(voronoi_vertices[item[2]], voronoi_vertices[item[3]])
+            end
+
+            line['style'] = "stroke:#{color};stroke-width:1;"
+            draw_lines << line
+
+          end
+        end
+
+        draw_lines.each {|l| doc.root << l}
+        draw_points.each {|p| doc.root << p}
+      end
+      
+      # Now draw in nodes
+      computation.points.each do |point|
+        node = circle_from_point(point)
+        node['fill'] = 'lime'
+
+        doc.root << node
+      end
+
+      doc.root['width']  = (max_x + opts[:offset_x] + 50).to_s
+      doc.root['height'] = (max_y + opts[:offset_y] + 50).to_s
+      
+      doc.save(opts[:name] || 'vddt.svg')
+    end
+    
+    private
+    def self.line_from_points(a, b)
+      line = XML::Node.new('line')
+      line['x1'] = (a.x + @opts[:offset_x] + 10).to_s
+      line['y1'] = (a.y + @opts[:offset_y] + 10).to_s
+      line['x2'] = (b.x + @opts[:offset_x] + 10).to_s
+      line['y2'] = (b.y + @opts[:offset_y] + 10).to_s
+      line
+    end
+    
+    def self.circle_from_point(point)
+      node = XML::Node.new('circle')
+      node['cx'] = (point.x + @opts[:offset_x] + 10).to_s
+      node['cy'] = (point.y + @opts[:offset_y] + 10).to_s
+      node['r'] = 5.to_s
+      node['stroke'] = 'black'
+      node['stroke-width'] = 2.to_s
+      node
+    end
+
+    def self.new_color
+      a = rand(256)
+      b = rand(256) | a
+      c = rand(256) ^ b
+      
+      "rgb(#{[a,b,c].sort{|k,l| rand(3)-1}.join(',')})"
+    end
+  end
+end