bribera-rubyvor 0.0.3 → 0.0.4

data/lib/ruby_vor/computation.rb

@@ -1,28 +1,139 @@
 module RubyVor
-  
-  # Voronoi Digram and Delaunay Triangulation namespace.
   module VDDT
-    
-    # Represents a computation from a set of 2-dimensional points
     class Computation
       attr_reader :points, :voronoi_diagram_raw, :delaunay_triangulation_raw
-      
+
+      # Create a computation from an existing set of raw data.
       def initialize(points=[], vd_raw=[], dt_raw=[])
+        @points = points
         @voronoi_diagram_raw = vd_raw
-        @delaunay_triangulation_raw   = dt_raw
+        @delaunay_triangulation_raw = dt_raw
+        @nn_graph = nil
       end
 
-      class << self
+      # 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=lambda{|a,b| a.distance_from(b)})
+
+        clusters = []
+        nodes    = (0..points.length-1).to_a
+        visited  = []
+        
+        v = 0
+        graph = nn_graph.map do |neighbors|
+          neighbors = neighbors.reject do |neighbor|
+            dist_proc[points[v], points[neighbor]] > max_distance            
+          end
+          v += 1
+          neighbors
+        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
 
-        # Compute the voronoi diagram and delaunay triangulation from a set of points.
-        #
-        # This implementation uses Steven Fortune's sweepline algorithm, which runs in O(n log n) time and O(n) space.
-        # It is limited to 2-dimensional space, therefore it expects to receive an array of objects that respond to 'x' and 'y' methods.
-        def from_points(p)
-          # Stub; implemented as C function in voronoi_interface.so
-        end        
+        clusters
       end
-      
+
+      # Computes the minimum spanning tree for given points, using the Delaunay triangulation as a seed.
+      #
+      # For points on a Euclidean plane, the MST is always comprised of a subset of the edges in a Delaunay triangulation. This makes computation of the tree very efficient: simply compute the Delaunay triangulation, and then run Prim's algorithm on the resulting edges.
+      def minimum_spanning_tree(dist_proc=lambda{|a,b| a.distance_from(b)})
+        nodes = []
+        q = RubyVor::PriorityQueue.new
+        (0..points.length-1).to_a.map do |n|
+          q.push({
+            :node => n,
+            :parent => nil,
+            :adjacency_list => nn_graph[n].clone,
+            :min_adjacency_list => [],
+            :in_q => true
+          }, (n == 0) ? 0.0 : Float::MAX)
+        end
+        
+        q.data.each do |n|
+          n.data[:adjacency_list].map!{|v| q.data[v]}
+          nodes.push(n)
+        end
+
+        while latest_addition = q.pop          
+          latest_addition.data[:in_q] = false
+
+          if latest_addition.data[:parent]
+            latest_addition.data[:parent].data[:min_adjacency_list].push(latest_addition)
+            latest_addition.data[:min_adjacency_list].push(latest_addition.data[:parent])
+          end
+
+          latest_addition.data[:adjacency_list].each do |adjacent|
+            
+            if adjacent.data[:in_q]
+
+              adjacent_distance = dist_proc[ points[latest_addition.data[:node]], points[adjacent.data[:node]] ]
+              
+              if adjacent_distance < adjacent.priority
+                adjacent.data[:parent] = latest_addition
+                adjacent.priority = adjacent_distance
+                q.percolate_up(adjacent.index)
+              end
+            end
+          end
+
+        end
+
+
+        nodes.map! do |n|
+          n.data[:min_adjacency_list].map!{|v| v.data[:node]}
+        end
+      end
+
+      def cluster_by_size(sizes=[])
+        # TODO
+        # * Create a minimum_spanning_tree routine to:
+        #   1. compute weights (should be done for us in C?)
+        #   2. Use Prim's algorithm for computation
+        # * Take MST, and
+        #   1. For n in sizes (taken in descending order), delete the n most expensive edges from MST
+        #     * 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.
+      end
+
+      protected
+
+      def weighted_edges(dist_proc)
+        v = 0
+        edges = nn_graph.inject({}) do |eh, neighbors|
+          neighbors.each do |neighbor|
+            k = [v,neighbor].sort
+            eh[k] = dist_proc.call(points[v],points[neighbor]) unless eh.has_key?(k)
+          end
+          v += 1
+          eh
+        end.to_a
+      end
+
     end
   end
 end

data/lib/ruby_vor/point.rb

@@ -5,5 +5,9 @@ module RubyVor
     def initialize(x=0.0,y=0.0)
       @x = x; @y = y
     end
+
+    def distance_from(p)
+      ((self.x - p.x) ** 2 + (self.y - p.y) ** 2) ** 0.5
+    end
   end
 end

data/lib/ruby_vor/priority_queue.rb

@@ -0,0 +1,60 @@
+module RubyVor
+  class PriorityQueue
+
+    attr_reader :data, :size
+    
+    def initialize(d=[])
+      @data = d || []
+      @size = d.length
+
+      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 = 1
+      @data.delete_at(@size-1)
+
+      @size -= 1
+      
+      percolate_down(1) if @size > 0
+
+      return r
+    end
+
+    def push(data, priority=Float::MAX)
+      @size += 1
+      @data[@size - 1] = QueueItem.new(priority, @size - 1, data)
+      percolate_up(@size)
+    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

@@ -1,3 +1,3 @@
 module RubyVor
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/ruby_vor.rb

@@ -3,10 +3,11 @@ $:.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 voronoi_interface.so last to clobber old from_points
-require 'voronoi_interface.so'
+# Require ruby_vor.so last to clobber old from_points
+require 'ruby_vor.so'
 
 # DOC HERE
 module RubyVor

data/rubyvor.gemspec

@@ -1,29 +1,31 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{rubyvor}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendan Ribera"]
-  s.date = %q{2008-12-03}
+  s.date = %q{2008-12-10}
   s.description = %q{RubyVor provides efficient computation of Voronoi diagrams and Delaunay triangulation for a set of Ruby points. It is intended to function as a complemenet to GeoRuby. These structures can be used to compute a nearest-neighbor graph for a set of points. This graph can in turn be used for proximity-based clustering of the input points.}
   s.email = ["brendan.ribera+rubyvor@gmail.com"]
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
-  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "ext/Doc", "ext/edgelist.c", "ext/extconf.rb", "ext/geometry.c", "ext/heap.c", "ext/memory.c", "ext/output.c", "ext/vdefs.h", "ext/voronoi.c", "ext/voronoi_interface.c", "lib/ruby_vor.rb", "lib/ruby_vor/computation.rb", "lib/ruby_vor/point.rb", "lib/ruby_vor/version.rb", "rubyvor.gemspec", "test/test_voronoi_interface.rb"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "ext/Doc", "ext/edgelist.c", "ext/extconf.rb", "ext/geometry.c", "ext/heap.c", "ext/memory.c", "ext/output.c", "ext/rb_cComputation.c", "ext/rb_cPriorityQueue.c", "ext/ruby_vor.c", "ext/ruby_vor.h", "ext/vdefs.h", "ext/voronoi.c", "ext/voronoi_interface.c", "lib/ruby_vor.rb", "lib/ruby_vor/computation.rb", "lib/ruby_vor/point.rb", "lib/ruby_vor/priority_queue.rb", "lib/ruby_vor/version.rb", "rubyvor.gemspec", "test/test_computation.rb", "test/test_priority_queue.rb", "test/test_voronoi_interface.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/bribera/rubyvor}
   s.rdoc_options = ["--main", "README.txt"]
   s.require_paths = ["lib", "ext"]
   s.rubyforge_project = %q{rubyvor}
-  s.rubygems_version = %q{1.2.0}
+  s.rubygems_version = %q{1.3.1}
   s.summary = %q{RubyVor provides efficient computation of Voronoi diagrams and Delaunay triangulation for a set of Ruby points}
-  s.test_files = ["test/test_voronoi_interface.rb"]
+  s.test_files = ["test/test_voronoi_interface.rb", "test/test_computation.rb", "test/test_priority_queue.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 2
 
-    if current_version >= 3 then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<hoe>, [">= 1.8.2"])
     else
       s.add_dependency(%q<hoe>, [">= 1.8.2"])

data/test/test_computation.rb

@@ -0,0 +1,175 @@
+require 'rubygems'
+require 'minitest/unit'
+require File.dirname(__FILE__) + '/../lib/ruby_vor'
+
+class TestComputation < MiniTest::Unit::TestCase
+
+  def initialize(*args)
+    @points = @trianglulation_raw = @diagram_raw = nil
+    super(*args)
+  end
+
+  def test_nn_graph
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
+
+    # based on this expected delaunay trianglulation:
+    #    3 2 1
+    #    3 0 2
+    #    8 2 0
+    #    3 8 0
+    #    5 6 8
+    #    7 6 5
+    #    7 4 6
+    #    6 2 8
+    #    8 7 5
+    
+    expected_graph = [
+                      [2, 3, 8],          # 0
+                      [2, 3],             # 1
+                      [0, 1, 3, 6, 8],    # 2
+                      [0, 1, 2, 8],       # 3
+                      [6, 7],             # 4
+                      [6, 7, 8],          # 5
+                      [2, 4, 5, 7, 8],    # 6
+                      [4, 5, 6, 8],       # 7
+                      [0, 2, 3, 5, 6, 7], # 8
+                     ]
+
+    assert_equal comp.nn_graph.map{|v| v.sort}.sort, \
+                 expected_graph.map{|v| v.sort}.sort
+  end
+
+  def test_simple_mst
+    points = [
+              RubyVor::Point.new(0,0),
+              RubyVor::Point.new(1.0,1.1),
+              RubyVor::Point.new(4.9,3.1),
+             ]
+
+    comp = RubyVor::VDDT::Computation.from_points(points)
+
+    expected_mst = [
+                    [1],
+                    [0,2],
+                    [1]
+                   ]
+
+    assert_equal expected_mst.map{|v| v.sort}.sort, \
+                 comp.minimum_spanning_tree.map{|v| v.sort}.sort
+  end
+  
+  def test_advanced_mst
+    # Test tree taken from an example SVG included in the Wikipedia article on Euclidean minimum spanning trees:
+    # http://en.wikipedia.org/wiki/Image:Euclidean_minimum_spanning_tree.svg
+    
+    points = [
+              RubyVor::Point.new(155.692, 99.783),  # 0
+              RubyVor::Point.new(162.285, 120.245), # 1
+              RubyVor::Point.new(143.692, 129.893), # 2
+              RubyVor::Point.new(150.128, 167.924), # 3
+              RubyVor::Point.new(137.617, 188.953), # 4
+              RubyVor::Point.new(193.467, 119.345), # 5
+              RubyVor::Point.new(196.754, 88.47),   # 6
+              RubyVor::Point.new(241.629, 70.845),  # 7
+              RubyVor::Point.new(262.692, 59.97),   # 8
+              RubyVor::Point.new(269.629, 63.158),  # 9
+              RubyVor::Point.new(247.257, 200.669), # 10
+              RubyVor::Point.new(231.28, 245.974),  # 11
+              RubyVor::Point.new(268.002, 264.693), # 12
+              RubyVor::Point.new(155.442, 64.473),  # 13
+              RubyVor::Point.new(198.598, 31.804),  # 14
+              RubyVor::Point.new(216.816, 3.513),   # 15
+              RubyVor::Point.new(89.624, 27.344),   # 16
+              RubyVor::Point.new(67.925, 56.999),   # 17
+              RubyVor::Point.new(77.328, 93.404),   # 18
+              RubyVor::Point.new(65.525, 158.783),  # 19
+              RubyVor::Point.new(63.525,170.783),   # 20
+              RubyVor::Point.new(15.192, 192.783),  # 21
+              RubyVor::Point.new(7.025, 236.949),   # 22
+              RubyVor::Point.new(40.525, 262.949),  # 23
+              RubyVor::Point.new(61.692, 225.95)    # 24
+             ]
+    
+    comp = RubyVor::VDDT::Computation.from_points(points)
+
+    expected_mst = [
+                    [1,13],    # 0
+                    [0,2,5],   # 1
+                    [1,3],     # 2
+                    [2,4],     # 3
+                    [3],       # 4
+                    [1,6,10],  # 5
+                    [5,7],     # 6
+                    [6,8],     # 7
+                    [7,9],     # 8
+                    [8],       # 9
+                    [5,11],    # 10
+                    [10,12],   # 11
+                    [11],      # 12
+                    [0,14,16], # 13
+                    [13,15],   # 14
+                    [14],      # 15
+                    [13,17],   # 16
+                    [16,18],   # 17
+                    [17,19],   # 18
+                    [18,20],   # 19
+                    [19,21],   # 20
+                    [20,22],   # 21
+                    [21,23],   # 22
+                    [22,24],   # 23
+                    [23]       # 24
+                   ]
+    assert_equal expected_mst.map{|v| v.sort}.sort, \
+                 comp.minimum_spanning_tree.map{|v| v.sort}.sort
+  end
+  
+  def test_cluster_by_distance
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
+    
+    expected_clusters = [
+                         [0,1,2,3],
+                         [8],
+                         [4,5,6,7]
+                        ]
+
+    # We want to ensure that the nn_graph isn't modified by this call
+    original_nn_graph = comp.nn_graph.map{|v| v.clone}
+
+    # Compute clusters within a distance of 10
+    computed_clusters = comp.cluster_by_distance(10)
+    
+    assert_equal expected_clusters.map{|cl| cl.sort}.sort, \
+                 computed_clusters.map{|cl| cl.sort}.sort
+
+    assert_equal original_nn_graph, \
+                 comp.nn_graph
+
+  end
+
+  #
+  # A few helper methods
+  #
+
+  private
+
+  def sample_points
+    if @points.nil?
+      @points = [
+                 [1.1,1],
+                 [0,0],
+                 [1,0],
+                 [0,1.1],
+                 
+                 [101.1,101],
+                 [100,100],
+                 [101,100],
+                 [100,101.1],
+
+                 [43, 55]
+                ].map{|x,y| RubyVor::Point.new(x,y)}
+    end
+    @points
+  end
+end
+
+MiniTest::Unit.autorun

data/test/test_priority_queue.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'minitest/unit'
+require File.dirname(__FILE__) + '/../lib/ruby_vor'
+
+class TestPriorityQueue < MiniTest::Unit::TestCase
+  
+  def test_heap_order_property
+    # min heap by default
+    q = RubyVor::PriorityQueue.new
+
+    items = [1,2,3,4,5,6,99,4,-20,101,5412,2,-1,-1,-1,33.0,0,55,7,12321,123.123,-123.123,0,0,0]
+    items.each{|i| q.push(i,i)}
+
+    items.sort!
+    idx = 0
+
+    # Test peek
+    assert_equal q.peek.data, items[0]
+    
+    while min = q.pop
+      # Test pop
+      assert_equal min.data, items[idx]
+
+      # Test peek
+      assert_equal q.peek.data, items[idx + 1] if idx + 1 < items.length
+      
+      idx += 1
+    end
+  end
+
+  def test_heapify
+    q = RubyVor::PriorityQueue.new
+
+    ([10] * 10).each{|x| q.push(x,x)}
+
+    q.data[3] = RubyVor::PriorityQueue::QueueItem.new(-34, 3, -34)
+    q.data[4] = RubyVor::PriorityQueue::QueueItem.new(1, 4, 1)
+    q.data[5] = RubyVor::PriorityQueue::QueueItem.new(100, 5, 100)
+    q.data[7] = RubyVor::PriorityQueue::QueueItem.new(0.9, 7, 0.9)
+    q.data.sort!{|a,b| rand(3)-1}
+    
+    q.heapify()
+
+    assert_equal(-34, q.pop.data)
+    assert_equal 0.9, q.pop.data
+    assert_equal 1,   q.pop.data
+    assert_equal 10,  q.pop.data
+    assert_equal 10,  q.pop.data
+    assert_equal 10,  q.pop.data
+    assert_equal 10,  q.pop.data
+    assert_equal 10,  q.pop.data
+    assert_equal 10,  q.pop.data
+    assert_equal 100, q.pop.data
+  end
+  
+end

data/test/test_voronoi_interface.rb

@@ -2,14 +2,16 @@ require 'rubygems'
 require 'minitest/unit'
 require File.dirname(__FILE__) + '/../lib/ruby_vor'
 
+
 class TestVoronoiInterface < MiniTest::Unit::TestCase
 
-  MAX_DELTA = 0.000001
-  
   def initialize(*args)
     @points = @trianglulation_raw = @diagram_raw = nil
     super(*args)
   end
+
+  
+  MAX_DELTA = 0.000001
   
   def test_diagram_correct
     # Perform the computation.
@@ -44,7 +46,7 @@ class TestVoronoiInterface < MiniTest::Unit::TestCase
     
     assert_equal example_triangulation_raw, comp.delaunay_triangulation_raw
   end
-  
+
 
   
   #
@@ -153,6 +155,7 @@ class TestVoronoiInterface < MiniTest::Unit::TestCase
     end
     @trianglulation_raw
   end
+  
 end
 
 MiniTest::Unit.autorun

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bribera-rubyvor
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Brendan Ribera
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-03 00:00:00 -08:00
+date: 2008-12-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,14 +44,21 @@ files:
 - ext/heap.c
 - ext/memory.c
 - ext/output.c
+- ext/rb_cComputation.c
+- ext/rb_cPriorityQueue.c
+- ext/ruby_vor.c
+- ext/ruby_vor.h
 - ext/vdefs.h
 - ext/voronoi.c
 - ext/voronoi_interface.c
 - lib/ruby_vor.rb
 - lib/ruby_vor/computation.rb
 - lib/ruby_vor/point.rb
+- lib/ruby_vor/priority_queue.rb
 - lib/ruby_vor/version.rb
 - rubyvor.gemspec
+- test/test_computation.rb
+- test/test_priority_queue.rb
 - test/test_voronoi_interface.rb
 has_rdoc: true
 homepage: http://github.com/bribera/rubyvor
@@ -83,3 +90,5 @@ specification_version: 2
 summary: RubyVor provides efficient computation of Voronoi diagrams and Delaunay triangulation for a set of Ruby points
 test_files: 
 - test/test_voronoi_interface.rb
+- test/test_computation.rb
+- test/test_priority_queue.rb