bribera-rubyvor 0.0.7 → 0.0.8

data/ext/ruby_vor_c.h

@@ -1,6 +1,14 @@
 #ifndef __RUBY_VOR_H
 #define __RUBY_VOR_H
 
+#ifndef RB_LONG_BITS
+#define RB_LONG_BITS sizeof(long)*8
+#endif
+
+#ifndef RB_HASH_FILTER
+#define RB_HASH_FILTER ((2 << (RB_LONG_BITS / 2 - 1)) - 1)
+#endif
+
 extern VoronoiState rubyvorState;
 
 /* Base modules */
@@ -11,7 +19,7 @@ VALUE RubyVor_rb_mVDDT;
 VALUE RubyVor_rb_cComputation;
 VALUE RubyVor_from_points(VALUE, VALUE);
 VALUE RubyVor_nn_graph(VALUE);
-// VALUE minimum_spanning_tree(int, VALUE*, VALUE);
+VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
 
 /* PriorityQueue */
 VALUE RubyVor_rb_cPriorityQueue;
@@ -23,5 +31,6 @@ VALUE RubyVor_heapify(VALUE);
 /* Point */
 VALUE RubyVor_rb_cPoint;
 VALUE RubyVor_distance_from(VALUE, VALUE);
+VALUE RubyVor_point_hash(VALUE);
 
 #endif

data/ext/voronoi.c

@@ -5,7 +5,7 @@
 #include <vdefs.h>
 #include <stdio.h>
 
-// Static method definitions: C -> Ruby storage methods.
+/* Static method definitions: C -> Ruby storage methods. */
 static void storeTriangulationTriplet(const int, const int, const int);
 static void storeLine(const float, const float, const float);
 static void storeEndpoint(const int, const int, const int);
@@ -20,7 +20,7 @@ static void storeSite(const float, const float);
 
 void initialize_state(int debug)
 {
-    // Set up our initial state
+    /* Set up our initial state */
     rubyvorState.debug = debug;
     rubyvorState.plot = 0;
     rubyvorState.nsites = 0;
@@ -32,13 +32,13 @@ void initialize_state(int debug)
     rubyvorState.storeV = storeVertex;
     rubyvorState.storeS = storeSite;
     
-    // Initialize the Site Freelist
+    /* Initialize the Site Freelist */
     freeinit(&(rubyvorState.sfl), sizeof(Site)) ;
 
-    // Initialize the geometry module
+    /* Initialize the geometry module */
     geominit() ;
 
-    // TODO: remove C plot references
+    /* TODO: remove C plot references */
     if (rubyvorState.plot)
         plotinit();
 }
@@ -52,7 +52,7 @@ voronoi(Site *(*nextsite)(void))
     Halfedge * lbnd, * rbnd, * llbnd, * rrbnd, * bisector ;
     Edge * e ;
 
-    c = 0;
+    newintstar.x = newintstar.y = c = 0;
     
     PQinitialize() ;
     rubyvorState.bottomsite = (*nextsite)() ;
@@ -155,9 +155,9 @@ voronoi(Site *(*nextsite)(void))
 
 
 
-//
-// Static storage methods
-//
+/*
+ * Static storage methods
+ */
 
 /*** stores a triplet of point indices that comprise a Delaunay triangle ***/
 static void
@@ -165,17 +165,17 @@ storeTriangulationTriplet(const int a, const int b, const int c)
 {
     VALUE trArray, triplet;
     
-    // Create a new triplet from the three incoming points
+    /* Create a new triplet from the three incoming points */
     triplet = rb_ary_new2(3);
     
     rb_ary_push(triplet, INT2FIX(a));
     rb_ary_push(triplet, INT2FIX(b));
     rb_ary_push(triplet, INT2FIX(c));
 
-    // Get the existing raw triangulation
+    /* Get the existing raw triangulation */
     trArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("delaunay_triangulation_raw"), 0);
 
-    // Add the new triplet to it
+    /* Add the new triplet to it */
     rb_ary_push(trArray, triplet);
 }
 
@@ -186,17 +186,17 @@ storeLine(const float a, const float b, const float c)
 {
     VALUE lArray, line;
     
-    // Create a new line from the three values
+    /* Create a new line from the three values */
     line = rb_ary_new2(4);
     rb_ary_push(line, ID2SYM(rb_intern("l")));
     rb_ary_push(line, rb_float_new(a));
     rb_ary_push(line, rb_float_new(b));
     rb_ary_push(line, rb_float_new(c));
 
-    // Get the existing raw voronoi diagram
+    /* Get the existing raw voronoi diagram */
     lArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new line to it
+    /* Add the new line to it */
     rb_ary_push(lArray, line);
 }
 
@@ -211,17 +211,17 @@ storeEndpoint(const int l, const int v1, const int v2)
 {
     VALUE eArray, endpoint;
     
-    // Create a new endpoint from the three values
+    /* Create a new endpoint from the three values */
     endpoint = rb_ary_new2(4);
     rb_ary_push(endpoint, ID2SYM(rb_intern("e")));
     rb_ary_push(endpoint, INT2FIX(l));
     rb_ary_push(endpoint, INT2FIX(v1));
     rb_ary_push(endpoint, INT2FIX(v2));
 
-    // Get the existing raw voronoi diagram
+    /* Get the existing raw voronoi diagram */
     eArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new endpoint to it
+    /* Add the new endpoint to it */
     rb_ary_push(eArray, endpoint);
 }
 
@@ -232,16 +232,16 @@ storeVertex(const float a, const float b)
 {
     VALUE vArray, vertex;
     
-    // Create a new vertex from the coordinates
+    /* Create a new vertex from the coordinates */
     vertex = rb_ary_new2(3);
     rb_ary_push(vertex, ID2SYM(rb_intern("v")));
     rb_ary_push(vertex, rb_float_new(a));
     rb_ary_push(vertex, rb_float_new(b));
 
-    // Get the existing raw voronoi diagram
+    /* Get the existing raw voronoi diagram */
     vArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new vertex to it
+    /* Add the new vertex to it */
     rb_ary_push(vArray, vertex);
 }
 
@@ -255,15 +255,15 @@ storeSite(const float x, const float y)
 {
     VALUE sArray, site;
     
-    // Create a new site from the coordinates
+    /* Create a new site from the coordinates */
     site = rb_ary_new2(3);
     rb_ary_push(site, ID2SYM(rb_intern("s")));
     rb_ary_push(site, rb_float_new(x));
     rb_ary_push(site, rb_float_new(y));
 
-    // Get the existing raw voronoi diagram
+    /* Get the existing raw voronoi diagram */
     sArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new site to it
+    /* Add the new site to it */
     rb_ary_push(sArray, site);
 }

data/lib/ruby_vor/computation.rb

@@ -6,11 +6,14 @@ module RubyVor
       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
-        @voronoi_diagram_raw = vd_raw
-        @delaunay_triangulation_raw = dt_raw
+      def initialize
+        @points = []
+        @unique_points = []
+        @point_map = {}
+        @voronoi_diagram_raw = []
+        @delaunay_triangulation_raw = []
         @nn_graph = nil
+        @mst = nil
       end
 
       # Uses the nearest-neighbors information encapsulated by the Delaunay triangulation as a seed for clustering:
@@ -30,6 +33,7 @@ module RubyVor
             dist_proc[points[v], points[neighbor]] < max_distance
           end
         end
+
         
         until nodes.empty?
           v = nodes.pop
@@ -56,81 +60,10 @@ module RubyVor
         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=DIST_PROC)
-        nodes = []
-        q = RubyVor::PriorityQueue.new
-        (0..points.length-1).to_a.map do |n|
-          q.push([
-                  n,                 #               :node == 0
-                  nil,               #             :parent == 1
-                  nn_graph[n].clone, #     :adjacency_list == 2
-                  [],                # :min_adjacency_list == 3
-                  true               #               :in_q == 4
-                 ],
-                 # Set min_distance of first node to 0, all others (effectively) to Infinity.
-                 (n == 0) ? 0.0 : Float::MAX)
-        end
-
-        # Adjacency list accces
-        nodes = q.data.clone
-
-        # We have now prepped to run through Prim's algorithm.
-        while latest_addition = q.pop
-          # check :in_q
-          latest_addition.data[4] = false
-
-          # check :parent
-          if latest_addition.data[1]
-            # push this node into :adjacency_list of :parent
-            latest_addition.data[1].data[3].push(latest_addition)
-            # push :parent into :adjacency_list of this node
-            latest_addition.data[3].push(latest_addition.data[1])
-          end
-
-          latest_addition.data[2].each do |adjacent|
-            # grab indexed node
-            adjacent = nodes[adjacent]
-
-            # check :in_q -- only look at new nodes
-            if adjacent.data[4]
-              # compare points by :node -- adjacent against current
-              adjacent_distance = dist_proc[ points[latest_addition.data[0]], points[adjacent.data[0]] ]
-
-              # if the new distance is better than our current priorty, exchange them
-              if adjacent_distance < adjacent.priority
-                # set new :parent
-                adjacent.data[1] = latest_addition
-                # update priority
-                adjacent.priority = adjacent_distance
-                # percolate up into correct position
-                q.percolate_up(adjacent.index)
-              end
-            end
-          end
-
-        end
-
-        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=[], dist_proc=DIST_PROC)
-        # TODO
-        # *    (DONE) Create a minimum_spanning_tree routine to:
-        #   1. (DONE) compute weights (should be done for us in C?)
-        #   2. (DONE) 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?
+        #     * 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.
@@ -140,54 +73,51 @@ module RubyVor
         
         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
 
+          graph    = (1..points.length).to_a.map{|v| []}
+          visited  = [nil] * points.length
+          clusters = []
 
-        
-          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
+          mst.each do |edge,weight|
+            graph[edge[1]].push(edge[0])
+            graph[edge[0]].push(edge[1])
           end
 
-        
-          visited.each_with_index do |visits, v|
-            if visits.nil?
-              visited[v] = [v]
+          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] = visited.uniq
-          
+
+          sized_clusters[current_size + 1] = clusters
           last_size = current_size
         end
         
         sized_clusters
       end
 
-
     end
   end
 end

data/lib/ruby_vor/point.rb

@@ -2,16 +2,31 @@ module RubyVor
   class Point
     attr_reader :x, :y
     def initialize(x=0.0,y=0.0)
-      @x = x; @y = y
+      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 hash
-      [x.to_f, y.to_f].hash
-    end
+
+    def to_s
+      "(#{@x},#{@y})"
+    end    
 
   end
 end

data/lib/ruby_vor/version.rb

@@ -1,3 +1,3 @@
 module RubyVor
-  VERSION = '0.0.7'
+  VERSION = '0.0.8'
 end

data/lib/ruby_vor/visualizer.rb

@@ -0,0 +1,217 @@
+require 'libxml'
+module RubyVor
+  class Visualizer
+
+    COLORS = %w{black blue red purple gray lime yellow orange pink}
+    
+    include 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)# ^ (a | b)
+      
+      "rgb(#{[a,b,c].sort{|k,l| rand(3)-1}.join(',')})"
+    end
+  end
+end

data/lib/ruby_vor.rb

@@ -6,6 +6,7 @@ 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'

data/rubyvor.gemspec

@@ -2,16 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyvor}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendan Ribera"]
-  s.date = %q{2008-12-12}
+  s.date = %q{2008-12-23}
   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/rb_cComputation.c", "ext/rb_cPoint.c", "ext/rb_cPriorityQueue.c", "ext/ruby_vor_c.c", "ext/ruby_vor_c.h", "ext/vdefs.h", "ext/voronoi.c", "lib/ruby_vor.rb", "lib/ruby_vor/computation.rb", "lib/ruby_vor/geo_ruby_extensions.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.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_cPoint.c", "ext/rb_cPriorityQueue.c", "ext/ruby_vor_c.c", "ext/ruby_vor_c.h", "ext/vdefs.h", "ext/voronoi.c", "lib/ruby_vor.rb", "lib/ruby_vor/computation.rb", "lib/ruby_vor/geo_ruby_extensions.rb", "lib/ruby_vor/point.rb", "lib/ruby_vor/priority_queue.rb", "lib/ruby_vor/version.rb", "lib/ruby_vor/visualizer.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"]
@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{rubyvor}
   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", "test/test_computation.rb", "test/test_priority_queue.rb"]
+  s.test_files = ["test/test_computation.rb", "test/test_priority_queue.rb", "test/test_voronoi_interface.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION