bribera-rubyvor 0.0.3 → 0.0.4

data/History.txt

@@ -1,3 +1,12 @@
+=== 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.

data/Manifest.txt

@@ -9,12 +9,19 @@ 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

data/Rakefile

@@ -20,7 +20,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'] 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')
+create_makefile('ruby_vor')

data/ext/output.c

@@ -237,12 +237,14 @@ debug_memory(void)
     FILE* pf;
 
     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;
 

data/ext/rb_cComputation.c

@@ -0,0 +1,281 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static Site * nextone(void);
+static int scomp(const void *, const void *);
+
+//
+// Class methods for RubyVor::VDDT::Computation
+//
+
+
+/*
+ * 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.
+ */
+VALUE
+from_points(VALUE self, VALUE pointsArray)
+{
+    //VALUE returnValue;
+    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");
+
+    // Load up point count & points pointer.
+    inSize = RARRAY(pointsArray)->len;
+    inPtr  = RARRAY(pointsArray)->ptr;
+
+    // Require nonzero size and x & y methods on each array object
+    if (inSize < 1)
+        rb_raise(rb_eRuntimeError, "points array have a nonzero length");
+    for (i = 0; i < inSize; i++) {
+        if(!rb_respond_to(inPtr[i], x) || !rb_respond_to(inPtr[i], y))
+            rb_raise(rb_eRuntimeError, "members of points array must respond to 'x' and 'y'");
+    }
+
+    
+    // Initialize rubyvorState
+    initialize_state(/* debug? */ 0);
+    debug_memory();
+    
+    // Create our return object.
+    newComp = rb_funcall(self, rb_intern("new"), 1, 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 4000 sites...
+        rubyvorState.sites = (Site *) myalloc(4000 * 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 4000 more if we just hit a multiple of 4000...
+            if (rubyvorState.nsites % 4000 == 0)
+            {
+                rubyvorState.sites = (Site *)myrealloc(rubyvorState.sites,(rubyvorState.nsites+4000)*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 (none)
+//
+
+VALUE
+minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
+{
+    VALUE dist_proc, nodes, nnGraph, points, queue, tmpHash, tmpArray, adjList, latestAddition;
+    long i, j;
+
+    /* 0 mandatory, 1 optional */
+    rb_scan_args(argc, argv, "01", &dist_proc);
+
+    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));
+    }
+
+    points  = rb_iv_get(self, "@points");
+    nodes   = rb_ary_new2(RARRAY(points)->len);
+    queue   = rb_eval_string("RubyVor::PriorityQueue.new(lambda{|a,b| a[:min_distance] < b[:min_distance]})");
+    nnGraph = nn_graph(self);
+
+    for (i=0; i < RARRAY(points)->len; i++) {
+        tmpHash = rb_hash_new();
+
+        // :node => n,
+        rb_hash_aset(tmpHash, ID2SYM(rb_intern("node")), INT2FIX(i));
+        // :min_distance => (n == 0) ? 0.0 : Float::MAX,
+        rb_hash_aset(tmpHash, ID2SYM(rb_intern("min_distance")), (i == 0) ? INT2FIX(0) : rb_const_get(rb_cFloat, rb_intern("MAX")));
+        // :parent => nil,
+        rb_hash_aset(tmpHash, ID2SYM(rb_intern("parent")), Qnil);
+        // :adjacency_list => nn_graph[n].clone,
+        rb_hash_aset(tmpHash, ID2SYM(rb_intern("adjacency_list")), rb_funcall(RARRAY(nnGraph)->ptr[i], rb_intern("clone"), 0));
+        // :min_adjacency_list => [],
+        rb_hash_aset(tmpHash, ID2SYM(rb_intern("min_adjacency_list")), rb_ary_new());
+        // :in_q => true
+        rb_hash_aset(tmpHash, ID2SYM(rb_intern("in_q")), Qtrue);
+        
+        rb_funcall(queue, rb_intern("push"), 1, tmpHash);
+    }
+
+    tmpArray = rb_funcall(queue, rb_intern("data"), 0);
+    for (i = 0; i < RARRAY(tmpArray)->len; i++) {
+        tmpHash = RARRAY(tmpArray)->ptr[i];
+        adjList = rb_hash_aref(tmpHash, ID2SYM(rb_intern("adjacency_list")));
+        
+        for (j = 0; j < RARRAY(adjList)->len; j++)
+            rb_ary_store(adjList, j, RARRAY(tmpArray)->ptr[ FIX2INT(RARRAY(adjList)->ptr[j]) ]);
+    }
+
+    latestAddition = rb_funcall(queue, rb_intern("pop"), 0);
+    while (RTEST(latestAddition)) {
+        rb_hash_aset(latestAddition, ID2SYM(rb_intern("in_q")), Qfalse);
+
+        if (RTEST(rb_hash_aref(latestAddition, ID2SYM(rb_intern("parent"))))) {
+        }
+        break;
+    }
+    
+    return tmpArray;
+}
+
+VALUE
+nn_graph(VALUE self)
+{
+    long i;
+    VALUE dtRaw, graph, points, * dtPtr, * tripletPtr, * graphPtr;
+    ID has_key;
+    graph = rb_iv_get(self, "@nn_graph");
+    
+    if (RTEST(graph))
+        return graph;
+
+    // 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++)
+        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) ;
+    }
+}

data/ext/rb_cPriorityQueue.c

@@ -0,0 +1,106 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor.h>
+
+VALUE
+compare(VALUE a, VALUE b)
+{
+    double aD, bD;
+    ID minDistance;
+    minDistance = ID2SYM(rb_intern("min_distance"));
+
+    if (rb_class_of(a) == rb_cQueueItem)
+        aD = NUM2DBL(rb_funcall(a, rb_intern("priority"), 0));
+    else
+        aD = NUM2DBL(a);
+    
+    if (rb_class_of(b) == rb_cQueueItem)
+        bD = NUM2DBL(rb_funcall(b, rb_intern("priority"), 0));
+    else
+        bD = NUM2DBL(b);
+    
+    return RTEST(aD < bD);
+}
+
+VALUE
+percolate_up(VALUE self, VALUE index)
+{
+    VALUE item, data;
+    long i, j;
+    
+    data = rb_iv_get(self, "@data");
+    Check_Type(data, T_ARRAY);
+    
+    i = FIX2INT(index);
+
+    
+    j = i / 2;
+    
+    item = RARRAY(data)->ptr[i - 1];
+
+    while(j > 0 && compare(item, RARRAY(data)->ptr[j - 1]))
+    {
+        rb_ary_store(data, i-1, RARRAY(data)->ptr[j - 1]);
+        rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+        i = j;
+        j = j / 2;
+    }
+
+    rb_ary_store(data, i-1, item);
+    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+    
+    return Qnil;
+}
+
+
+VALUE
+percolate_down(VALUE self, VALUE index)
+{
+    VALUE item, data;
+    long i, j, k, size;
+
+    data = rb_iv_get(self, "@data");
+    Check_Type(data, T_ARRAY);
+    
+    size = FIX2INT(rb_iv_get(self, "@size"));
+    i = FIX2INT(index);
+    
+    
+    j = size / 2;
+
+    item = RARRAY(data)->ptr[i - 1];
+
+    while (!(i > j))
+    {
+        k = i * 2;
+        if (k < size && compare(RARRAY(data)->ptr[k], RARRAY(data)->ptr[k - 1]))
+            k++;
+
+        if (compare(item, RARRAY(data)->ptr[k - 1]))
+            j = -1;
+        else
+        {
+            rb_ary_store(data, i-1, RARRAY(data)->ptr[k - 1]);
+            rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+            i = k;
+        }
+    }
+
+    rb_ary_store(data, i-1, item);
+    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+    
+    return Qnil;
+}
+
+
+VALUE
+heapify(VALUE self)
+{
+    long i, size;
+    size = FIX2INT(rb_iv_get(self, "@size"));
+
+    for(i = size / 2; i >= 1; i--)
+        percolate_down(self, INT2FIX(i));
+
+    return Qnil;
+}

data/ext/ruby_vor.c

@@ -0,0 +1,41 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor.h>
+
+void
+Init_ruby_vor(void)
+{
+    //
+    // Set up our Modules and Class.
+    //
+
+    /*
+     * Main RubyVor namespace.
+     */
+    rb_mRubyVor       = rb_define_module("RubyVor");
+
+    
+    /*
+     * Voronoi Digram and Delaunay Triangulation namespace.
+     */
+    rb_mVDDT          = rb_define_module_under(rb_mRubyVor, "VDDT");
+
+    
+    /*
+     * Class representing a VD/DT computation based on a set of 2-dimensional points
+     */
+    rb_cComputation   = rb_define_class_under(rb_mVDDT, "Computation", rb_cObject);
+    rb_define_singleton_method(rb_cComputation, "from_points", from_points, 1);
+    rb_define_method(rb_cComputation, "nn_graph", nn_graph, 0);
+    //rb_define_method(rb_cComputation, "minimum_spanning_tree", minimum_spanning_tree, -1);
+
+    
+    /*
+     * A priority queue with a customizable heap-order property.
+     */
+    rb_cPriorityQueue = rb_define_class_under(rb_mRubyVor, "PriorityQueue", rb_cObject);
+    rb_cQueueItem = rb_define_class_under(rb_cPriorityQueue, "QueueItem", rb_cObject);
+    rb_define_method(rb_cPriorityQueue, "percolate_up", percolate_up, 1);
+    rb_define_method(rb_cPriorityQueue, "percolate_down", percolate_down, 1);
+    rb_define_method(rb_cPriorityQueue, "heapify", heapify, 0);
+}

data/ext/ruby_vor.h

@@ -0,0 +1,23 @@
+#ifndef __RUBY_VOR_H
+#define __RUBY_VOR_H
+
+extern VoronoiState rubyvorState;
+
+/* Base modules */
+VALUE rb_mRubyVor;
+VALUE rb_mVDDT;
+
+/* Computation */
+VALUE rb_cComputation;
+VALUE from_points(VALUE, VALUE);
+VALUE nn_graph(VALUE);
+VALUE minimum_spanning_tree(int, VALUE*, VALUE);
+
+/* PriorityQueue */
+VALUE rb_cPriorityQueue;
+VALUE rb_cQueueItem;
+VALUE percolate_up(VALUE, VALUE);
+VALUE percolate_down(VALUE, VALUE);
+VALUE heapify(VALUE);
+
+#endif

data/ext/vdefs.h

@@ -125,6 +125,7 @@ void freeinit(Freelist *, int) ;
 char *getfree(Freelist *) ;
 void makefree(Freenode *, Freelist *) ;
 char *myalloc(unsigned) ;
+char *myrealloc(void *, unsigned, unsigned);
 void free_all(void);
 
 /* output.c */
@@ -144,6 +145,6 @@ void debug_memory(void);
 /* voronoi.c */
 void voronoi(Site *(*)()) ;
 void initialize_state(int);
-#endif  
+#endif
 
 

data/ext/voronoi.c

@@ -56,16 +56,12 @@ voronoi(Site *(*nextsite)(void))
     
     PQinitialize() ;
     rubyvorState.bottomsite = (*nextsite)() ;
-    if (rubyvorState.debug) fprintf(stderr, "bnys ");
     out_site(rubyvorState.bottomsite) ;
     ELinitialize() ;
     newsite = (*nextsite)() ;
     
     while (1)
     {
-        
-        if (rubyvorState.debug) fprintf(stderr, "%d ", c++);
-        
         if(!PQempty())
             newintstar = PQ_min() ;
         
@@ -74,10 +70,8 @@ voronoi(Site *(*nextsite)(void))
             || (newsite->coord.y == newintstar.y
             && newsite->coord.x < newintstar.x)))
         {
-            if (rubyvorState.debug) fprintf(stderr, "nss ");
             /* new site is smallest */
             {
-                if (rubyvorState.debug) fprintf(stderr, "bnys ");
                 out_site(newsite) ;
             }
             lbnd = ELleftbnd(&(newsite->coord)) ;
@@ -104,14 +98,12 @@ voronoi(Site *(*nextsite)(void))
         }
         else if (!PQempty())   /* intersection is smallest */
         {
-            if (rubyvorState.debug) fprintf(stderr, "!pqe ");
             lbnd = PQextractmin() ;
             llbnd = ELleft(lbnd) ;
             rbnd = ELright(lbnd) ;
             rrbnd = ELright(rbnd) ;
             bot = leftreg(lbnd) ;
             top = rightreg(rbnd) ;
-            if (rubyvorState.debug) fprintf(stderr, "bnyt ");
             out_triple(bot, top, rightreg(lbnd)) ;
             v = lbnd->vertex ;
             makevertex(v) ;
@@ -156,7 +148,6 @@ voronoi(Site *(*nextsite)(void))
          lbnd = ELright(lbnd))
     {
         e = lbnd->ELedge ;
-        if (rubyvorState.debug) fprintf(stderr, "bnye ");
         out_ep(e) ;
     }
 }
@@ -168,15 +159,15 @@ voronoi(Site *(*nextsite)(void))
 // Static storage methods
 //
 
-
 /*** stores a triplet of point indices that comprise a Delaunay triangle ***/
 static void
 storeTriangulationTriplet(const int a, const int b, const int c)
 {
     VALUE trArray, triplet;
-
+    
     // 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));