bribera-rubyvor 0.0.2 → 0.1.1

data/History.txt

@@ -1,3 +1,48 @@
+=== 0.1.1 / 2009-01-15
+
+* LibXML require conflict fix.
+
+=== 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)
+* Moved minimum_spanning_tree computation into C, yielding large speed gain.
+* Basic SVG visualization.
+
+=== 0.0.7 / 2008-12-12
+
+* Bugfix: there are cases where performing a Delaunay triangulation on a set of points will not yield a complete nearest neighbor graph. This causes computation of the minimum spanning tree and clustering to fail for these nodes (they always appear as disconnected from the main graph).
+
+* To fix this, the nn_graph function now treats any point that is excluded from Delaunay triangulation as having *all* other points as nearest neighbors. This is a naive approach, but is a good fix while a more efficient solution is considered.
+
+=== 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.
+* Some refactoring of C methods.
+
+=== 0.0.4 / 2008-12-04
+
+* Fixed 64-bit segfaults due to improper definition of the myrealloc() function.
+
+=== 0.0.3 / 2008-12-03
+
+* Fixed a segfault by using rb_ary_push instead of direct pointer manipulation. Much simpler.
+
 === 0.0.2 / 2008-12-03
 
 * Computations succeed on a naive Point class, returning raw values for the associated Voronoi Diagram and Delaunay triangulation.

data/Manifest.txt

@@ -9,12 +9,22 @@ 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
-ext/voronoi_interface.c
 lib/ruby_vor.rb
-lib/ruby_vor/decomposition.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_point.rb
+test/test_priority_queue.rb
 test/test_voronoi_interface.rb

data/README.txt

@@ -12,7 +12,38 @@ in turn be used for proximity-based clustering of the input points.
 
 == Usage:
 
-TODO
+require 'lib/ruby_vor'
+require 'pp'
+
+points = [
+  RubyVor::Point.new(120, 290),
+  RubyVor::Point.new(110, 120),
+  RubyVor::Point.new(160, 90.2),
+  RubyVor::Point.new(3.14159265, 3.14159265)
+]
+
+# Compute the diagram & triangulation
+comp = RubyVor::VDDT::Computation.from_points(points)
+
+puts "The nearest-neighbor graph:"
+pp comp.nn_graph
+
+puts "\nThe minimum-spanning tree:"
+pp comp.minimum_spanning_tree
+
+#
+# Visualize these things as SVGs
+#
+
+# Just the triangulation
+RubyVor::Visualizer.make_svg(comp, :name => 'tri.svg')
+
+# Just the MST
+RubyVor::Visualizer.make_svg(comp, :name => 'mst.svg', :triangulation => false, :mst => true)
+
+# Voronoi diagram and the triangulation
+RubyVor::Visualizer.make_svg(comp, :name => 'dia.svg', :voronoi_diagram => true)
+
 
 == LICENSE:
 

data/Rakefile

@@ -7,8 +7,7 @@ require './lib/ruby_vor/version.rb'
 EXT = "ext/voronoi_interface.#{Hoe::DLEXT}"
 
 Hoe.new('rubyvor', RubyVor::VERSION) do |p|
-  p.developer('Brendan Ribera', 'brendan.ribera+rubyvor@gmail.com')
-  
+  p.developer('Brendan Ribera', 'brendan.ribera+rubyvor@gmail.com')  
   p.url = 'http://github.com/bribera/rubyvor'
 
   # C extension goodness
@@ -20,7 +19,7 @@ desc "Compile extensions"
 task :compile => EXT
 task :test => :compile
 
-file EXT => ['ext/extconf.rb', 'ext/voronoi_interface.c'] do
+file EXT => ['ext/extconf.rb', 'ext/ruby_vor_c.c'] do
   Dir.chdir 'ext' do
     ruby 'extconf.rb'
     sh 'make'

data/ext/extconf.rb

@@ -1,3 +1,3 @@
 require 'mkmf'
-dir_config('voronoi_interface')
-create_makefile('voronoi_interface')
+dir_config('ruby_vor_c')
+create_makefile('ruby_vor_c')

data/ext/memory.c

@@ -1,8 +1,9 @@
 
 /*** MEMORY.C ***/
 
+#include <ruby.h>
 #include <stdio.h>
-#include <stdlib.h>  /* malloc(), exit() */
+#include <stdlib.h>  /* malloc() */
 
 #include "vdefs.h"
 
@@ -61,17 +62,15 @@ update_memory_map(char * newp)
 char *
 myalloc(unsigned n)
 {
-    char * t ;
+    char * t;
+    
     if ((t=(char*)malloc(n)) == (char *) 0)
-    {
-        fprintf(stderr,"Insufficient memory processing site %d (%d bytes in use)\n",
-                rubyvorState.siteidx, total_alloc) ;
-        exit(0) ;
-    }
-    total_alloc += n ;
+        rb_raise(rb_eNoMemError, "Insufficient memory processing site %d (%d bytes in use)\n", rubyvorState.siteidx, total_alloc);
+
+    total_alloc += n;
     
     update_memory_map(t);
-    return (t) ;
+    return (t);
 }
 
 char *
@@ -81,24 +80,27 @@ myrealloc(void * oldp, unsigned n, unsigned oldn)
     int i;
     
     if ((newp=(char*)realloc(oldp, n)) == (char *) 0)
-    {
-        fprintf(stderr,"Insufficient memory processing site %d (%d bytes in use)\n",
-                rubyvorState.siteidx, total_alloc) ;
-        exit(0) ;
-    }
+        rb_raise(rb_eNoMemError, "Insufficient memory processing site %d (%d bytes in use)\n", rubyvorState.siteidx, total_alloc);
 
-    total_alloc += (n - oldn) ;
+    total_alloc += (n - oldn);
 
     update_memory_map(newp);
 
-    // Mark oldp as freed, since free() was called by realloc.
-    for (i=0; i<nallocs; i++) {
-        if (memory_map[i] != (char*)0 && memory_map[i] == oldp) {
+    /*
+     * Mark oldp as freed, since free() was called by realloc.
+     *
+     * TODO: this seems naive; measure if this is a bottleneck & use a hash table or some other scheme if it is.
+     */
+    for (i=0; i<nallocs; i++)
+    {
+        if (memory_map[i] != (char*)0 && memory_map[i] == oldp)
+        {
             memory_map[i] = (char*)0;
             break;
         }
     }
-    return (newp) ;
+    
+    return (newp);
 }
     
 
@@ -115,6 +117,4 @@ void free_all(void)
 	}
 	free(memory_map);
 	nallocs = 0;
-
-    debug_memory();
 }

data/ext/output.c

@@ -1,34 +1,27 @@
 
 /*** OUTPUT.C ***/
 
-
+#include <vdefs.h>
 #include <stdio.h>
-
-#include "vdefs.h"
+#include <unistd.h>
 
 VoronoiState rubyvorState;
 
 static float pxmin, pxmax, pymin, pymax, cradius;
 
 void openpl(void) {}
-
-#pragma argsused
 void line(float ax, float ay, float bx, float by) {}
-
-#pragma argsused
 void circle(float ax, float ay, float radius) {}
-
-#pragma argsused
 void range(float pxmin, float pxmax, float pymin, float pymax) {}
 
 void
 out_bisector(Edge * e)
 {
-    // Save line to our ruby object
+    /* Save line to our ruby object */
     (*rubyvorState.storeL)(e->a, e->b, e->c);
 
     
-    // printf("l %f %f %f\n", e->a, e->b, e->c);
+    /* printf("l %f %f %f\n", e->a, e->b, e->c); */
     
     if (rubyvorState.plot)
         line(e->reg[0]->coord.x, e->reg[0]->coord.y, e->reg[1]->coord.x, e->reg[1]->coord.y);
@@ -40,7 +33,7 @@ out_bisector(Edge * e)
 void
 out_ep(Edge * e)
 {
-    // Save endpoint to our ruby object
+    /* Save endpoint to our ruby object */
     (*rubyvorState.storeE)(e->edgenbr,
                            e->ep[le] != (Site *)NULL ? e->ep[le]->sitenbr : -1,
                            e->ep[re] != (Site *)NULL ? e->ep[re]->sitenbr : -1);
@@ -58,10 +51,10 @@ out_ep(Edge * e)
 void
 out_vertex(Site * v)
 {
-    // Save vertex to our ruby object
+    /* Save vertex to our ruby object */
     (*rubyvorState.storeV)(v->coord.x, v->coord.y);
     
-    // printf ("v %f %f\n", v->coord.x, v->coord.y) ;
+    /* printf ("v %f %f\n", v->coord.x, v->coord.y) ; */
     
     if (rubyvorState.debug)
         printf("vertex(%d) at %f %f\n", v->sitenbr, v->coord.x, v->coord.y);
@@ -70,10 +63,10 @@ out_vertex(Site * v)
 void
 out_site(Site * s)
 {
-    // Save site to our ruby object
+    /* Save site to our ruby object */
     (*rubyvorState.storeS)(s->coord.x, s->coord.y);
 
-    //printf("s %f %f\n", s->coord.x, s->coord.y) ;
+    /* printf("s %f %f\n", s->coord.x, s->coord.y) ; */
 
     if (rubyvorState.plot)
         circle (s->coord.x, s->coord.y, cradius);
@@ -85,7 +78,7 @@ out_site(Site * s)
 void
 out_triple(Site * s1, Site * s2, Site * s3)
 {
-    // Save triplet to our ruby object
+    /* Save triplet to our ruby object */
     (*rubyvorState.storeT)(s1->sitenbr, s2->sitenbr, s3->sitenbr);
     
     if (rubyvorState.debug)
@@ -229,32 +222,30 @@ clip_line(Edge * e)
 /* Linux-specific. */
 void
 debug_memory(void)
-{
-    if (!rubyvorState.debug)
-        return;
-    
+{    
     char buf[30];
     FILE* pf;
+    int tmp;
+    float totalSize;
+    unsigned size;/*       total program size */
 
-    unsigned size;//       total program size
+    /*
     unsigned resident;//   resident set size
     unsigned share;//      shared pages
     unsigned text;//       text (code)
     unsigned lib;//        library
     unsigned data;//       data/stack
     unsigned dt;//         dirty pages (unused in Linux 2.6)
-    
-    int retVal;
+    */
 
-    float totalSize;
+    if (!rubyvorState.debug)
+        return;
     
     snprintf(buf, 30, "/proc/%u/statm", (unsigned)getpid());
     pf = fopen(buf, "r");
     if (NULL != pf)
     {
-        retVal = fscanf(pf, "%u", &size);
-        //, %u, %u ... etc &resident, &share, &text, &lib, &data);
-        
+        tmp = fscanf(pf, "%u", &size); /*, %u, %u ... etc &resident, &share, &text, &lib, &data); */
         totalSize = (float)size / 1024.0;
         fprintf(stderr, "%f ", totalSize);
     }

data/ext/rb_cComputation.c

@@ -0,0 +1,370 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor_c.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static Site * nextone(void);
+static int scomp(const void *, const void *);
+
+/*
+ * See ruby_vor.c for RDOC
+ */
+
+
+/*
+ * Class methods for RubyVor::VDDT::Computation
+ */
+
+VALUE
+RubyVor_from_points(VALUE self, VALUE pointsArray)
+{
+    VALUE * inPtr, newComp;
+    ID x, y;
+
+    long i, inSize;
+
+    /* Require T_ARRAY */
+    Check_Type(pointsArray, T_ARRAY);
+
+    /* Intern our point access methods */
+    x = rb_intern("x");
+    y = rb_intern("y");
+
+
+    /* Require nonzero size and x & y methods on each array object */
+    if (RARRAY(pointsArray)->len < 1)
+        rb_raise(rb_eRuntimeError, "points array have a nonzero length");
+    for (i = 0; i < RARRAY(pointsArray)->len; i++) {
+        if(!rb_respond_to(RARRAY(pointsArray)->ptr[i], x) || !rb_respond_to(RARRAY(pointsArray)->ptr[i], y))
+            rb_raise(rb_eRuntimeError, "members of points array must respond to 'x' and 'y'");
+    }
+
+    /* Load up point count & points pointer. */
+    pointsArray = rb_funcall(pointsArray, rb_intern("uniq"), 0);
+    inSize = RARRAY(pointsArray)->len;
+    inPtr  = RARRAY(pointsArray)->ptr;
+
+    
+    /* Initialize rubyvorState */
+    initialize_state(0 /* debug? */);
+    debug_memory();
+    
+    /* Create our return object. */
+    newComp = rb_funcall(self, rb_intern("new"), 0);
+    rb_iv_set(newComp, "@points", pointsArray);
+    
+    /* Store it in rubyvorState so we can populate its values. */
+    rubyvorState.comp = (void *) &newComp;
+    
+    /*
+     * Read in the sites, sort, and compute xmin, xmax, ymin, ymax
+     *
+     * TODO: refactor this block into a separate method for clarity?
+     */
+    {
+        /* Allocate memory for N sites... */
+        rubyvorState.sites = (Site *) myalloc(inSize * sizeof(Site));
+    
+    
+        /* Iterate over the arrays, doubling the incoming values. */
+        for (i=0; i<inSize; i++)
+        {
+            rubyvorState.sites[rubyvorState.nsites].coord.x = NUM2DBL(rb_funcall(inPtr[i], x, 0));
+            rubyvorState.sites[rubyvorState.nsites].coord.y = NUM2DBL(rb_funcall(inPtr[i], y, 0));
+             
+            rubyvorState.sites[rubyvorState.nsites].sitenbr = rubyvorState.nsites;
+            rubyvorState.sites[rubyvorState.nsites++].refcnt = 0;
+            
+            /* Allocate for N more if we just hit a multiple of N... */
+            if (rubyvorState.nsites % inSize == 0)
+            {
+                rubyvorState.sites = (Site *)myrealloc(rubyvorState.sites,(rubyvorState.nsites+inSize)*sizeof(Site),rubyvorState.nsites*sizeof(Site));
+            }
+        }
+        
+        /* Sort the Sites */
+        qsort((void *)rubyvorState.sites, rubyvorState.nsites, sizeof(Site), scomp) ;
+        
+        /* Pull the minimum values. */
+        rubyvorState.xmin = rubyvorState.sites[0].coord.x;
+        rubyvorState.xmax = rubyvorState.sites[0].coord.x;
+        for (i=1; i < rubyvorState.nsites; ++i)
+        {
+            if (rubyvorState.sites[i].coord.x < rubyvorState.xmin)
+            {
+                rubyvorState.xmin = rubyvorState.sites[i].coord.x;
+            }
+            if (rubyvorState.sites[i].coord.x > rubyvorState.xmax)
+            {
+                rubyvorState.xmax = rubyvorState.sites[i].coord.x;
+            }
+        }
+        rubyvorState.ymin = rubyvorState.sites[0].coord.y;
+        rubyvorState.ymax = rubyvorState.sites[rubyvorState.nsites-1].coord.y;
+        
+    }
+
+    
+    /* Perform the computation */
+    voronoi(nextone);
+    debug_memory();
+    
+    /* Get rid of our comp reference */
+    rubyvorState.comp = (void *)NULL;
+    
+    /* Free our allocated objects */
+    free_all();    
+    debug_memory();
+
+    return newComp;
+}
+
+
+/*
+ * Instance methods
+ */
+
+VALUE
+RubyVor_minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
+{
+    VALUE mst, dist_proc, nodes, nnGraph, points, queue, tmp, adjacent, adjacentData, adjacentDistance, current, currentData, floatMax;
+    ID i_call, i_push, i_pop, i_has_key;
+    long i;
+
+    /* 0 mandatory, 1 optional */
+    rb_scan_args(argc, argv, "01", &dist_proc);
+
+    mst = rb_iv_get(self, "@mst");
+    
+    if (RTEST(mst))
+        return mst;
+
+
+    if (NIL_P(dist_proc)) {
+        /* Use our default Proc */
+        dist_proc = rb_eval_string("lambda{|a,b| a.distance_from(b)}");
+    } else if (rb_class_of(dist_proc) != rb_cProc) {
+        /* Blow up if we have a non-nil, non-Proc */
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(dist_proc), rb_class2name(rb_cProc));
+    }
+
+    // Set up interned values
+    i_call     = rb_intern("call");
+    i_push     = rb_intern("push");
+    i_pop      = rb_intern("pop");
+    i_has_key  = rb_intern("has_key?");
+    
+    points  = rb_iv_get(self, "@points");
+    queue   = rb_eval_string("RubyVor::PriorityQueue.new");
+    nnGraph = RubyVor_nn_graph(self);
+    floatMax= rb_iv_get(rb_cFloat, "MAX");
+
+    for (i = 0; i < RARRAY(points)->len; i++) {
+        tmp = rb_ary_new2(5);
+        /* 0: node index */
+        rb_ary_push(tmp, LONG2FIX(i));
+        /* 1: parent */
+        rb_ary_push(tmp, Qnil);
+        /* 2: adjacency_list */
+        rb_ary_push(tmp, rb_obj_clone(RARRAY(nnGraph)->ptr[i]));
+        /* 3: min_adjacency_list */
+        rb_ary_push(tmp, rb_ary_new());
+        /* 4: in_q */
+        rb_ary_push(tmp, Qtrue);
+
+        rb_funcall(queue, i_push, 2, tmp, (i == 0) ? rb_float_new(0.0) : floatMax);
+    }
+    nodes = rb_obj_clone(rb_iv_get(queue, "@data"));
+    
+    while(RTEST(current = rb_funcall(queue, i_pop, 0))) {
+        currentData = rb_iv_get(current, "@data");
+        
+        /* mark in_q */
+        rb_ary_store(currentData, 4, Qfalse);
+
+        /* check for presence of parent */
+        if (RTEST(RARRAY(currentData)->ptr[1])) {
+            /* push this node into adjacency_list of parent */
+            rb_ary_push(RARRAY(rb_iv_get(RARRAY(currentData)->ptr[1], "@data"))->ptr[3], current);
+            /* push parent into adjacency_list of this node */
+            rb_ary_push(RARRAY(currentData)->ptr[3], RARRAY(currentData)->ptr[1]);
+        }
+
+        for (i = 0; i < RARRAY(RARRAY(currentData)->ptr[2])->len; i++) {
+            /* grab indexed node */
+            adjacent = RARRAY(nodes)->ptr[FIX2LONG(RARRAY(RARRAY(currentData)->ptr[2])->ptr[i])];
+            adjacentData = rb_iv_get(adjacent, "@data");
+        
+            /* check in_q -- only look at new nodes */
+            if (Qtrue == RARRAY(adjacentData)->ptr[4]) {
+
+                /* compare points by node -- adjacent against current */
+                adjacentDistance = rb_funcall(dist_proc, i_call, 2,
+                                              RARRAY(points)->ptr[FIX2LONG(RARRAY(currentData)->ptr[0])],
+                                              RARRAY(points)->ptr[FIX2LONG(RARRAY(adjacentData)->ptr[0])]);
+
+                /* If the new distance is better than our current priority, exchange them. */
+                if (RFLOAT(adjacentDistance)->value < RFLOAT(rb_iv_get(adjacent, "@priority"))->value) {
+                    /* set new :parent */
+                    rb_ary_store(adjacentData, 1, current);
+                    /* update priority */
+                    rb_iv_set(adjacent, "@priority", adjacentDistance);
+                    /* percolate up into correctn position */
+                    RubyVor_percolate_up(queue, rb_iv_get(adjacent, "@index"));
+                }
+            }
+        }
+    }
+
+    mst = rb_hash_new();
+    for (i = 0; i < RARRAY(nodes)->len; i++) {
+        current = RARRAY(nodes)->ptr[i];
+        currentData = rb_iv_get(current, "@data");
+        if (!NIL_P(RARRAY(currentData)->ptr[1])) {
+            adjacentData = rb_iv_get(RARRAY(currentData)->ptr[1], "@data");
+            tmp = rb_ary_new2(2);
+            if (FIX2LONG(RARRAY(currentData)->ptr[0]) < FIX2LONG(RARRAY(adjacentData)->ptr[0])) {
+                rb_ary_push(tmp, RARRAY(currentData)->ptr[0]);
+                rb_ary_push(tmp, RARRAY(adjacentData)->ptr[0]);
+            } else {
+                rb_ary_push(tmp, RARRAY(adjacentData)->ptr[0]);                
+                rb_ary_push(tmp, RARRAY(currentData)->ptr[0]);
+            }
+            
+            /* if (!st_lookup(RHASH(mst)->tbl, tmp, 0)) { */
+            rb_hash_aset(mst, tmp, rb_iv_get(current, "@priority"));
+            /* } */
+        }
+    }
+
+    rb_iv_set(self, "@mst", mst);
+    
+    return mst;
+}
+
+
+VALUE
+RubyVor_nn_graph(VALUE self)
+{
+    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");
+    
+    graph = rb_ary_new2(RARRAY(points)->len);
+    for (i = 0; i < RARRAY(points)->len; i++)
+        rb_ary_push(graph, rb_ary_new());
+    
+    /* Get our pointer into this array. */
+    graphPtr = RARRAY(graph)->ptr;
+
+    /* Iterate over the triangulation */
+    dtRaw = rb_iv_get(self, "@delaunay_triangulation_raw");
+    dtPtr = RARRAY(dtRaw)->ptr;
+    for (i = 0; i < RARRAY(dtRaw)->len; i++) {
+        tripletPtr = RARRAY(dtPtr[i])->ptr;
+
+        rb_ary_push(graphPtr[FIX2INT(tripletPtr[0])], tripletPtr[1]);
+        rb_ary_push(graphPtr[FIX2INT(tripletPtr[1])], tripletPtr[0]);
+
+        rb_ary_push(graphPtr[FIX2INT(tripletPtr[0])], tripletPtr[2]);
+        rb_ary_push(graphPtr[FIX2INT(tripletPtr[2])], tripletPtr[0]);
+
+        rb_ary_push(graphPtr[FIX2INT(tripletPtr[1])], tripletPtr[2]);
+        rb_ary_push(graphPtr[FIX2INT(tripletPtr[2])], tripletPtr[1]);
+        
+    }
+    for (i = 0; i < RARRAY(graph)->len; i++) {
+        if (RARRAY(graphPtr[i])->len < 1) {
+            /* 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);
+        }
+    }
+
+    rb_iv_set(self, "@nn_graph", graph);
+    
+    return graph;
+}
+
+
+
+/*
+ * Static C helper methods
+ */
+
+
+/*** sort sites on y, then x, coord ***/
+static int
+scomp(const void * vs1, const void * vs2)
+{
+    Point * s1 = (Point *)vs1 ;
+    Point * s2 = (Point *)vs2 ;
+
+    if (s1->y < s2->y)
+    {
+        return (-1) ;
+    }
+    if (s1->y > s2->y)
+    {
+        return (1) ;
+    }
+    if (s1->x < s2->x)
+    {
+        return (-1) ;
+    }
+    if (s1->x > s2->x)
+    {
+        return (1) ;
+    }
+    return (0) ;
+}
+
+/*** return a single in-storage site ***/
+static Site *
+nextone(void)
+{
+    Site * s ;
+
+    if (rubyvorState.siteidx < rubyvorState.nsites)
+    {
+        s = &rubyvorState.sites[rubyvorState.siteidx++];
+        return (s) ;
+    }
+    else
+    {
+        return ((Site *)NULL) ;
+    }
+}