bribera-rubyvor 0.0.9 → 0.1.0

data/History.txt

@@ -1,3 +1,15 @@
+=== 0.1.0 / 2009-01-13
+
+* Configurable handling of "no neighbors" case.
+* Tests for "no neighbors" case.
+
+=== 0.0.9 / 2009-01-01
+
+Happy New Year!
+* New speed improvements.
+* Additional visualization tweaks.
+* More tests.
+
 === 0.0.8 / 2008-12-23
 
 * Several C warning fixes (more ISO C compliance unused variables, etc)

data/ext/rb_cComputation.c

@@ -247,14 +247,23 @@ RubyVor_minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
 VALUE
 RubyVor_nn_graph(VALUE self)
 {
-    long i;
     VALUE dtRaw, graph, points, * dtPtr, * tripletPtr, * graphPtr;
+    long i, j, noNeighborResponse;
 
     graph = rb_iv_get(self, "@nn_graph");
     
     if (RTEST(graph))
         return graph;
 
+    /* Figure out our "no neighbor" response value */
+    if (SYM2ID(rb_iv_get(self, "@no_neighbor_response")) == rb_intern("raise")) {
+        noNeighborResponse = 1;
+    } else if (SYM2ID(rb_iv_get(self, "@no_neighbor_response")) == rb_intern("use_all")) {
+        noNeighborResponse = 2;
+    } else {
+        noNeighborResponse = 0;
+    }
+
     /* Create an array of same size as points for the graph */
     points = rb_iv_get(self, "@points");
     
@@ -283,16 +292,23 @@ RubyVor_nn_graph(VALUE self)
     }
     for (i = 0; i < RARRAY(graph)->len; i++) {
         if (RARRAY(graphPtr[i])->len < 1) {
-            rb_raise(rb_eIndexError, "index of 0 (no neighbors) at %i", i);
-            /* No valid triangles touched this node -- include *all* possible neighbors
-            for(j = 0; j < RARRAY(points)->len; j++) {
-                if (j != i) {
-                    rb_ary_push(graphPtr[i], INT2FIX(j));
-                    if (RARRAY(graphPtr[j])->len > 0 && !rb_ary_includes(graphPtr[j], INT2FIX(i)))
-                        rb_ary_push(graphPtr[j], INT2FIX(i));
+            /* Evaluate noNeighborResponse and respond accordingly */
+            if (noNeighborResponse == 1) {
+                rb_raise(rb_eIndexError, "index of 0 (no neighbors) at %i", i);
+            } else if (noNeighborResponse == 2) {
+                /* No valid triangles touched this node -- include *all* possible neighbors
+                 *
+                 * Note that this can make for exceptionally slow (ie O(n^2) time) clustering,
+                 * but should only happen in rare cases.
+                 */
+                for(j = 0; j < RARRAY(points)->len; j++) {
+                    if (j != i) {
+                        rb_ary_push(graphPtr[i], INT2FIX(j));
+                        if (RARRAY(graphPtr[j])->len > 0 && !rb_ary_includes(graphPtr[j], INT2FIX(i)))
+                            rb_ary_push(graphPtr[j], INT2FIX(i));
+                    }
                 }
             }
-            */
         } else {
             rb_funcall(graphPtr[i], rb_intern("uniq!"), 0);
         }

data/lib/ruby_vor/computation.rb

@@ -1,19 +1,33 @@
 module RubyVor
   module VDDT
     class Computation
-      attr_reader :points, :voronoi_diagram_raw, :delaunay_triangulation_raw
+      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 = []
-        @unique_points = []
-        @point_map = {}
+        
         @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:

data/lib/ruby_vor/version.rb

@@ -1,3 +1,3 @@
 module RubyVor
-  VERSION = '0.0.9'
+  VERSION = '0.1.0'
 end

data/lib/ruby_vor/visualizer.rb

@@ -3,8 +3,9 @@ module RubyVor
   class Visualizer
 
     COLORS = %w{black red blue lime gray yellow purple orange pink}
-    
-    include LibXML
+
+    # Support various versions of LibXML
+    include LibXML if defined?(LibXML)
       
     def self.make_svg(computation, opts={})
       @opts = opts = {

data/rubyvor.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyvor}
-  s.version = "0.0.9"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendan Ribera"]
-  s.date = %q{2009-01-01}
+  s.date = %q{2009-01-13}
   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"]

data/test/test_computation.rb

@@ -233,6 +233,44 @@ class TestComputation < MiniTest::Unit::TestCase
     end
   end
 
+
+  def test_no_neighbors
+    nn_graph = nil
+
+    # Test :raise
+    comp = RubyVor::VDDT::Computation.from_points([1,2,3,4,5].map{|xy| RubyVor::Point.new(xy,xy)})
+    comp.no_neighbor_response = :raise
+
+    assert_equal comp.no_neighbor_response, :raise    
+    assert_raises(IndexError) { nn_graph = comp.nn_graph }
+    assert_raises(IndexError) { comp.cluster_by_distance(5) }
+    assert_equal nn_graph, nil
+
+    
+    # Test :use_all (default)
+    comp = RubyVor::VDDT::Computation.from_points([1,2,3,4,5].map{|xy| RubyVor::Point.new(xy,xy)})
+    comp.no_neighbor_response = :use_all
+
+    assert_equal comp.no_neighbor_response, :use_all
+    assert_nothing_raised { nn_graph = comp.nn_graph }
+    assert_nothing_raised do
+      assert_equal comp.cluster_by_distance(5).map{|a| a.sort}.sort, [[0,1,2,3,4]]
+    end
+    refute_equal nn_graph, nil
+
+    
+    # Test :ignore
+    comp = RubyVor::VDDT::Computation.from_points([1,2,3,4,5].map{|xy| RubyVor::Point.new(xy,xy)})
+    comp.no_neighbor_response = :ignore
+
+    assert_equal comp.no_neighbor_response, :ignore
+    assert_nothing_raised { nn_graph = comp.nn_graph }
+    assert_nothing_raised do
+      assert_equal comp.cluster_by_distance(5).map{|a| a.sort}.sort, [[0],[1],[2],[3],[4]]
+    end
+    refute_equal nn_graph, nil
+  end
+
   
   def test_cluster_by_size
     comp = RubyVor::VDDT::Computation.from_points([
@@ -291,6 +329,16 @@ class TestComputation < MiniTest::Unit::TestCase
     end
     @points
   end
+  
+  def assert_nothing_raised(&b)
+    begin
+      yield
+    rescue Exception => e
+      flunk "#{mu_pp(e)} exception encountered, expected no exceptions"
+      return
+    end
+    pass()
+  end
 end
 
 MiniTest::Unit.autorun

data/test/test_point.rb

@@ -29,7 +29,7 @@ class TestPoint < MiniTest::Unit::TestCase
 
     assert a > b
     assert b < a
-    assert_equal -1, b <=> a
+    assert_equal(-1, (b <=> a))
   end
 
   def test_equality

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bribera-rubyvor
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Brendan Ribera
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-01 00:00:00 -08:00
+date: 2009-01-13 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency