bribera-rubyvor 0.0.5 → 0.0.6

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.0.6 / 2008-12-11
+
+* Implementation of cluster_by_size to partition points into N clusters.
+
 === 0.0.5 / 2008-12-10
 
 * Beginnings of clustering and useful graph algorithms.

data/ext/ruby_vor.c

@@ -94,3 +94,6 @@ VALUE RubyVor_heapify(VALUE);
  * Compute the Euclidean distance between two points.
  */
 VALUE RubyVor_distance_from(VALUE, VALUE);
+
+
+// keep comment so RDOC will find the last method definition

data/lib/ruby_vor/computation.rb

@@ -3,6 +3,8 @@ module RubyVor
     class Computation
       attr_reader :points, :voronoi_diagram_raw, :delaunay_triangulation_raw
 
+      DIST_PROC = lambda{|a,b| a.distance_from(b)}
+      
       # Create a computation from an existing set of raw data.
       def initialize(points=[], vd_raw=[], dt_raw=[])
         @points = points
@@ -16,8 +18,7 @@ module RubyVor
       #
       # 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)})
-
+      def cluster_by_distance(max_distance, dist_proc=DIST_PROC)
         clusters = []
         nodes    = (0..points.length-1).to_a
         visited  = [false] * points.length
@@ -58,7 +59,7 @@ module RubyVor
       # 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)})
+      def minimum_spanning_tree(dist_proc=DIST_PROC)
         nodes = []
         q = RubyVor::PriorityQueue.new
         (0..points.length-1).to_a.map do |n|
@@ -112,16 +113,16 @@ module RubyVor
 
         end
 
-
-        nodes.map! do |n|
-          n.data[3].inject({}) do |h,v|
-            h[v.data[0]] = v.priority
-            h
+        nodes.inject({}) do |h,adjacency_list|
+          v = adjacency_list.data[0]
+          adjacency_list.data[3].each do |node|
+            h[ (v < node.data[0]) ? [v,node.data[0]] : [node.data[0],v] ] ||= node.priority
           end
+          h
         end
       end
 
-      def cluster_by_size(sizes=[])
+      def cluster_by_size(sizes=[], dist_proc=DIST_PROC)
         # TODO
         # *    (DONE) Create a minimum_spanning_tree routine to:
         #   1. (DONE) compute weights (should be done for us in C?)
@@ -133,22 +134,60 @@ module RubyVor
         #   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
+        
+        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)
+          
+          visited  = [nil] * points.length
 
-      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)
+        
+          for edge in mst
+            i, j = edge.first
+            
+            next if !visited[i].nil? && visited[i] == visited[j]
+            
+            if visited[i] && visited[j]
+              visited[i].concat(visited[j])
+              visited[i].uniq!
+              visited[j].each{|v| visited[v] = visited[i]}
+              visited[j] = visited[i]
+            else
+              cluster = visited[i] || visited[j] || []  
+              cluster.push(i) unless visited[i]
+              cluster.push(j) unless visited[j]
+              visited[i] = visited[j] = cluster
+            end
+          end
+
+        
+          visited.each_with_index do |visits, v|
+            if visits.nil?
+              visited[v] = [v]
+            end
           end
-          v += 1
-          eh
-        end.to_a
+          
+          sized_clusters[current_size + 1] = visited.uniq
+          
+          last_size = current_size
+        end
+        
+        sized_clusters
       end
 
+
     end
   end
 end

data/lib/ruby_vor/priority_queue.rb

@@ -2,8 +2,33 @@ 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()
+    def initialize
       @data = []
       @size = 0
       heapify()

data/lib/ruby_vor/version.rb

@@ -1,3 +1,3 @@
 module RubyVor
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/rubyvor.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyvor}
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendan Ribera"]

data/test/test_computation.rb

@@ -47,17 +47,15 @@ class TestComputation < MiniTest::Unit::TestCase
              ]
 
     comp = RubyVor::VDDT::Computation.from_points(points)
-
     expected_mst = [
-                    [1],
-                    [0,2],
-                    [1]
+                    [0,1],
+                    [1,2]
                    ]
     computed_mst = comp.minimum_spanning_tree
 
     # Assert nodes are correct
-    assert_equal expected_mst.map{|v| v.sort}.sort, \
-                 computed_mst.map{|v| v.keys.sort}.sort
+    assert_equal expected_mst.sort, \
+                 computed_mst.keys.sort
   end
   
   def test_advanced_mst
@@ -95,36 +93,35 @@ class TestComputation < MiniTest::Unit::TestCase
     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
+                    [0,1],
+                    [0,13],
+                    [1,2],
+                    [1,5],
+                    [2,3],
+                    [3,4],
+                    [5,6],
+                    [5,10],
+                    [6,7],
+                    [7,8],
+                    [8,9],
+                    [10,11],
+                    [11,12],
+                    [13,14],
+                    [13,16],
+                    [14,15],
+                    [16,17],
+                    [17,18],
+                    [18,19],
+                    [19,20],
+                    [20,21],
+                    [21,22],
+                    [22,23],
+                    [23,24]
                    ]
     computed_mst = comp.minimum_spanning_tree
     
-    assert_equal expected_mst.map{|v| v.sort}.sort, \
-                 computed_mst.map{|v| v.keys.sort}.sort
+    assert_equal expected_mst.sort, \
+                 computed_mst.keys.sort
   end
   
   def test_cluster_by_distance
@@ -150,6 +147,16 @@ class TestComputation < MiniTest::Unit::TestCase
 
   end
 
+  
+  def test_duplicate_points
+    comp = RubyVor::VDDT::Computation.from_points([RubyVor::Point.new(1,1), RubyVor::Point.new(1,1), RubyVor::Point.new(2,3), RubyVor::Point.new(1,1), RubyVor::Point.new(4,0)])
+    refute_equal comp.nn_graph,               nil
+    refute_equal comp.minimum_spanning_tree,  nil
+    refute_equal comp.cluster_by_distance(3), nil
+    refute_equal comp.cluster_by_size([2]),   nil
+  end
+
+  
   def test_bad_data
     assert_raises TypeError do
       comp = RubyVor::VDDT::Computation.from_points([RubyVor::Point.new(1,1), RubyVor::Point.new(21,3), RubyVor::Point.new(2,:s)])
@@ -173,6 +180,39 @@ class TestComputation < MiniTest::Unit::TestCase
     end
   end
 
+  
+  def test_cluster_by_size
+    comp = RubyVor::VDDT::Computation.from_points([
+                                                   RubyVor::Point.new(0.25, 0.25),
+                                                   RubyVor::Point.new(1, 0.25),
+                                                   RubyVor::Point.new(0.5, 1),
+                                                   RubyVor::Point.new(5, 5),
+                                                   RubyVor::Point.new(10.25, 10.25),
+                                                   RubyVor::Point.new(13, 9),
+                                                   RubyVor::Point.new(9, 9)
+                                                  ])
+
+    sizes = [1, 3, 5, 7]
+    
+    computed_sized_clusters = comp.cluster_by_size(sizes)
+
+    # Check that we got clusters for each size requested
+    assert_equal sizes, \
+                 computed_sized_clusters.keys.sort                 
+
+    assert_equal [[0,1,2,3,4,5,6]], \
+                 computed_sized_clusters[1].map{|cl| cl.sort}.sort
+    
+    assert_equal [[0,1,2], [3], [4,5,6]], \
+                 computed_sized_clusters[3].map{|cl| cl.sort}.sort
+
+    assert_equal [[0,1,2], [3], [4], [5], [6]], \
+                 computed_sized_clusters[5].map{|cl| cl.sort}.sort
+
+    assert_equal [[0], [1], [2], [3], [4], [5], [6]], \
+                 computed_sized_clusters[7].sort
+  end
+
   #
   # A few helper methods
   #

data/test/test_priority_queue.rb

@@ -44,7 +44,7 @@ class TestPriorityQueue < MiniTest::Unit::TestCase
 
     old_n = -1.0 * Float::MAX
     while n = q.pop
-      assert n.priority >= old_n
+      assert n.priority >= old_n, 'Heap-order property violated'
       old_n = n.priority
     end
   end
@@ -96,6 +96,22 @@ class TestPriorityQueue < MiniTest::Unit::TestCase
     end
   end
 
+  def test_build_queue
+    n = 100
+    
+    q = RubyVor::PriorityQueue.build_queue(n) do |queue_item|
+      queue_item.priority = rand * 10000.0 - 5000.0
+    end
+
+    assert_equal n, q.data.length
+    assert_equal n, q.size
+    
+    old_n = -1.0 * Float::MAX
+    while n = q.pop
+      assert n.priority >= old_n, 'Heap-order property violated'
+      old_n = n.priority
+    end
+  end
   
   private
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bribera-rubyvor
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Brendan Ribera