bribera-rubyvor 0.0.2 → 0.1.1

data/ext/rb_cPoint.c

@@ -0,0 +1,35 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor_c.h>
+#include <math.h>
+
+/*
+ * Euclidean distance between two Points
+ */
+VALUE
+RubyVor_distance_from(VALUE self, VALUE other)
+{
+    return rb_float_new(sqrt(pow(NUM2DBL(rb_iv_get(self, "@x")) - NUM2DBL(rb_iv_get(other, "@x")), 2.0) +
+                             pow(NUM2DBL(rb_iv_get(self, "@y")) - NUM2DBL(rb_iv_get(other, "@y")), 2.0)));
+}
+
+VALUE
+RubyVor_point_hash(VALUE self)
+{
+    double x, y;
+    char *c;
+    long i, xHash, yHash;
+
+    x = NUM2DBL(rb_iv_get(self, "@x"));
+    y = NUM2DBL(rb_iv_get(self, "@y"));
+
+    /* Bastardized from Ruby's numeric.c */
+    
+    for (c = (char*)&x, xHash = 0, i = 0; i < sizeof(double); i++) xHash += c[i] * 971;
+    for (c = (char*)&y, yHash = 0, i = 0; i < sizeof(double); i++) yHash += c[i] * 971;
+
+    xHash = xHash & RB_HASH_FILTER;
+    yHash = yHash & RB_HASH_FILTER;
+    
+    return LONG2FIX((xHash << (RB_LONG_BITS / 2)) | yHash);
+}

data/ext/rb_cPriorityQueue.c

@@ -0,0 +1,120 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor_c.h>
+
+/*
+ * Instance methods for RubyVor::VDDT::PriorityQueue
+ */
+
+
+static VALUE
+compare(VALUE a, VALUE b)
+{
+    double aD, bD;
+    ID minDistance;
+    minDistance = ID2SYM(rb_intern("min_distance"));
+
+    if (rb_class_of(a) == RubyVor_rb_cQueueItem)
+        aD = NUM2DBL(rb_funcall(a, rb_intern("priority"), 0));
+    else
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(a), rb_class2name(RubyVor_rb_cQueueItem));
+    
+    if (rb_class_of(b) == RubyVor_rb_cQueueItem)
+        bD = NUM2DBL(rb_funcall(b, rb_intern("priority"), 0));
+    else
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(b), rb_class2name(RubyVor_rb_cQueueItem));
+    
+    return RTEST(aD < bD);
+}
+
+VALUE
+RubyVor_percolate_up(VALUE self, VALUE index)
+{
+    VALUE item, data;
+    long i, j, size;
+
+    Check_Type(index, T_FIXNUM);
+    
+    data = rb_iv_get(self, "@data");
+    Check_Type(data, T_ARRAY);
+    
+    size = FIX2INT(rb_iv_get(self, "@size"));
+    i = FIX2INT(index) + 1;
+
+    if (i < 1 || i > size)
+        rb_raise(rb_eIndexError, "index %i out of range", i-1);
+    
+    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-1));
+        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-1));
+    
+    return Qnil;
+}
+
+
+VALUE
+RubyVor_percolate_down(VALUE self, VALUE index)
+{
+    VALUE item, data;
+    long i, j, k, size;
+
+    Check_Type(index, T_FIXNUM);
+
+    data = rb_iv_get(self, "@data");
+    Check_Type(data, T_ARRAY);
+    
+    size = FIX2INT(rb_iv_get(self, "@size"));
+    i = FIX2INT(index) + 1;
+    
+    if (i < 1 || i > size)
+        rb_raise(rb_eIndexError, "index %i out of range", i-1);
+    
+    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-1));
+            i = k;
+        }
+    }
+
+    rb_ary_store(data, i-1, item);
+    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i-1));
+    
+    return Qnil;
+}
+
+
+VALUE
+RubyVor_heapify(VALUE self)
+{
+    long i, size;
+    size = FIX2INT(rb_iv_get(self, "@size"));
+
+    for(i = size / 2; i >= 1; i--)
+        RubyVor_percolate_down(self, INT2FIX(i-1));
+
+    return Qnil;
+}

data/ext/ruby_vor_c.c

@@ -0,0 +1,106 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor_c.h>
+
+/*
+ * Extension initialization
+ */
+void
+Init_ruby_vor_c(void)
+{
+    /*
+     * Set up our Modules and Class.
+     */
+
+    /*
+     * Main RubyVor namespace.
+     */
+    RubyVor_rb_mRubyVor       = rb_define_module("RubyVor");
+
+    
+    /*
+     * Voronoi Digram and Delaunay Triangulation namespace.
+     */
+    RubyVor_rb_mVDDT          = rb_define_module_under(RubyVor_rb_mRubyVor, "VDDT");
+
+    
+    /*
+     * Class representing a VD/DT computation based on a set of 2-dimensional points
+     */
+    RubyVor_rb_cComputation   = rb_define_class_under(RubyVor_rb_mVDDT, "Computation", rb_cObject);
+    rb_define_singleton_method(RubyVor_rb_cComputation, "from_points", RubyVor_from_points, 1);
+    rb_define_method(RubyVor_rb_cComputation, "nn_graph", RubyVor_nn_graph, 0);
+    rb_define_method(RubyVor_rb_cComputation, "minimum_spanning_tree", RubyVor_minimum_spanning_tree, -1);
+
+    
+    /*
+     * A priority queue with a customizable heap-order property.
+     */
+    RubyVor_rb_cPriorityQueue = rb_define_class_under(RubyVor_rb_mRubyVor, "PriorityQueue", rb_cObject);
+    RubyVor_rb_cQueueItem = rb_define_class_under(RubyVor_rb_cPriorityQueue, "QueueItem", rb_cObject);
+    rb_define_method(RubyVor_rb_cPriorityQueue, "percolate_up", RubyVor_percolate_up, 1);
+    rb_define_method(RubyVor_rb_cPriorityQueue, "percolate_down", RubyVor_percolate_down, 1);
+    rb_define_method(RubyVor_rb_cPriorityQueue, "heapify", RubyVor_heapify, 0);
+
+
+    /*
+     * A simple Point class
+     */
+    RubyVor_rb_cPoint = rb_define_class_under(RubyVor_rb_mRubyVor, "Point", rb_cObject);
+    rb_define_method(RubyVor_rb_cPoint, "distance_from", RubyVor_distance_from, 1);
+    rb_define_method(RubyVor_rb_cPoint, "hash", RubyVor_point_hash, 0);
+}
+
+
+
+
+/*
+ * Method declarations duplicated here for RDOC
+ */
+
+/*
+ * 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 RubyVor_from_points(VALUE, VALUE);
+
+/*
+ * Compute the nearest-neighbor graph using the existing Delaunay triangulation.
+ */
+VALUE RubyVor_nn_graph(VALUE);
+
+/*
+ * 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.
+ */
+VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
+
+/*
+ * Move from the given index up, restoring the heap-order property.
+ */
+VALUE RubyVor_percolate_up(VALUE, VALUE);
+
+/*
+ * Move from the index down, restoring the heap-order property.
+ */
+VALUE RubyVor_percolate_down(VALUE, VALUE);
+
+/*
+ * Restore the heap-order property for a randomly ordered array of entries.
+ */
+VALUE RubyVor_heapify(VALUE);
+
+/*
+ * Compute the Euclidean distance between two points.
+ */
+VALUE RubyVor_distance_from(VALUE, VALUE);
+
+/*
+ * Hash value for a point.
+ */
+VALUE RubyVor_point_hash(VALUE);
+
+/* keep comment so RDOC will find the last method definition */

data/ext/ruby_vor_c.h

@@ -0,0 +1,36 @@
+#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 */
+VALUE RubyVor_rb_mRubyVor;
+VALUE RubyVor_rb_mVDDT;
+
+/* Computation */
+VALUE RubyVor_rb_cComputation;
+VALUE RubyVor_from_points(VALUE, VALUE);
+VALUE RubyVor_nn_graph(VALUE);
+VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
+
+/* PriorityQueue */
+VALUE RubyVor_rb_cPriorityQueue;
+VALUE RubyVor_rb_cQueueItem;
+VALUE RubyVor_percolate_up(VALUE, VALUE);
+VALUE RubyVor_percolate_down(VALUE, VALUE);
+VALUE RubyVor_heapify(VALUE);
+
+/* Point */
+VALUE RubyVor_rb_cPoint;
+VALUE RubyVor_distance_from(VALUE, VALUE);
+VALUE RubyVor_point_hash(VALUE);
+
+#endif

data/ext/vdefs.h

@@ -64,7 +64,7 @@ typedef struct tagVoronoiState
     int sorted, plot, debug, siteidx;
     float xmin, xmax, ymin, ymax;
     Site * sites;
-    void * decomp;
+    void * comp;
     void (* storeT)(int, int, int);
     void (* storeL)(float, float, float);
     void (* storeE)(int, int, int);
@@ -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

@@ -3,9 +3,9 @@
 
 #include <ruby.h>
 #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,17 +32,15 @@ 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();
-    
-    debug_memory();
 }
 
 void
@@ -50,21 +48,23 @@ voronoi(Site *(*nextsite)(void))
 {
     Site * newsite, * bot, * top, * temp, * p, * v ;
     Point newintstar ;
-    int pm ;
+    int pm , c;
     Halfedge * lbnd, * rbnd, * llbnd, * rrbnd, * bisector ;
     Edge * e ;
 
+    newintstar.x = newintstar.y = c = 0;
+    
     PQinitialize() ;
     rubyvorState.bottomsite = (*nextsite)() ;
     out_site(rubyvorState.bottomsite) ;
     ELinitialize() ;
     newsite = (*nextsite)() ;
+    
     while (1)
     {
         if(!PQempty())
-        {
             newintstar = PQ_min() ;
-        }
+        
         if (newsite != (Site *)NULL && (PQempty()
             || newsite -> coord.y < newintstar.y
             || (newsite->coord.y == newintstar.y
@@ -150,36 +150,32 @@ voronoi(Site *(*nextsite)(void))
         e = lbnd->ELedge ;
         out_ep(e) ;
     }
-
-    // After completing calculations
-    debug_memory();
 }
 
 
 
 
-//
-// Static storage methods
-//
-
+/*
+ * 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
+    
+    /* Create a new triplet from the three incoming points */
     triplet = rb_ary_new2(3);
-    RARRAY(triplet)->len = 3;
-    RARRAY(triplet)->ptr[0] = INT2FIX(a);
-    RARRAY(triplet)->ptr[1] = INT2FIX(b);
-    RARRAY(triplet)->ptr[2] = INT2FIX(c);
+    
+    rb_ary_push(triplet, INT2FIX(a));
+    rb_ary_push(triplet, INT2FIX(b));
+    rb_ary_push(triplet, INT2FIX(c));
 
-    // Get the existing raw triangulation
-    trArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("delaunay_triangulation_raw"), 0);
+    /* 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);
 }
 
@@ -190,19 +186,18 @@ 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);
-    RARRAY(line)->len = 4;
-    RARRAY(line)->ptr[0] = ID2SYM(rb_intern("l"));
-    RARRAY(line)->ptr[1] = rb_float_new(a);
-    RARRAY(line)->ptr[2] = rb_float_new(b);
-    RARRAY(line)->ptr[3] = rb_float_new(c);
+    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
-    lArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+    /* Get the existing raw voronoi diagram */
+    lArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new line to it
-    rb_ary_push(lArray, line);    
+    /* Add the new line to it */
+    rb_ary_push(lArray, line);
 }
 
 
@@ -216,19 +211,18 @@ 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);
-    RARRAY(endpoint)->len = 4;
-    RARRAY(endpoint)->ptr[0] = ID2SYM(rb_intern("e"));
-    RARRAY(endpoint)->ptr[1] = INT2FIX(l);
-    RARRAY(endpoint)->ptr[2] = INT2FIX(v1);
-    RARRAY(endpoint)->ptr[3] = INT2FIX(v2);
+    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
-    eArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+    /* Get the existing raw voronoi diagram */
+    eArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new endpoint to it
-    rb_ary_push(eArray, endpoint);    
+    /* Add the new endpoint to it */
+    rb_ary_push(eArray, endpoint);
 }
 
 
@@ -238,18 +232,17 @@ 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);
-    RARRAY(vertex)->len = 3;
-    RARRAY(vertex)->ptr[0] = ID2SYM(rb_intern("v"));
-    RARRAY(vertex)->ptr[1] = rb_float_new(a);
-    RARRAY(vertex)->ptr[2] = rb_float_new(b);
+    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
-    vArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+    /* Get the existing raw voronoi diagram */
+    vArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new vertex to it
-    rb_ary_push(vArray, vertex);    
+    /* Add the new vertex to it */
+    rb_ary_push(vArray, vertex);
 }
 
 
@@ -262,16 +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);
-    RARRAY(site)->len = 3;
-    RARRAY(site)->ptr[0] = ID2SYM(rb_intern("s"));
-    RARRAY(site)->ptr[1] = rb_float_new(x);
-    RARRAY(site)->ptr[2] = rb_float_new(y);
+    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
-    sArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+    /* Get the existing raw voronoi diagram */
+    sArray = rb_funcall(*(VALUE *)rubyvorState.comp, rb_intern("voronoi_diagram_raw"), 0);
 
-    // Add the new site to it
-    rb_ary_push(sArray, site);    
+    /* Add the new site to it */
+    rb_ary_push(sArray, site);
 }