rubyvor 0.1.3

data/ext/output.c

@@ -0,0 +1,251 @@
+
+/*** OUTPUT.C ***/
+
+#include <vdefs.h>
+#include <stdio.h>
+#include <unistd.h>
+
+static float pxmin, pxmax, pymin, pymax, cradius;
+
+void openpl(void) {}
+void line(float ax, float ay, float bx, float by) {}
+void circle(float ax, float ay, float radius) {}
+void range(float pxmin, float pxmax, float pymin, float pymax) {}
+
+void
+out_bisector(Edge * e)
+{
+    /* 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); */
+    
+    if (rubyvorState.plot)
+        line(e->reg[0]->coord.x, e->reg[0]->coord.y, e->reg[1]->coord.x, e->reg[1]->coord.y);
+    
+    if (rubyvorState.debug)
+        printf("line(%d) %gx+%gy=%g, bisecting %d %d\n", e->edgenbr, e->a, e->b, e->c, e->reg[le]->sitenbr, e->reg[re]->sitenbr);
+}
+
+void
+out_ep(Edge * e)
+{
+    /* 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);
+    
+    /*
+        printf("e %d", e->edgenbr);
+        printf(" %d ", e->ep[le] != (Site *)NULL ? e->ep[le]->sitenbr : -1) ;
+        printf("%d\n", e->ep[re] != (Site *)NULL ? e->ep[re]->sitenbr : -1) ;
+    */
+
+    if (rubyvorState.plot)
+        clip_line(e) ;
+}
+
+void
+out_vertex(Site * v)
+{
+    /* 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) ; */
+    
+    if (rubyvorState.debug)
+        printf("vertex(%d) at %f %f\n", v->sitenbr, v->coord.x, v->coord.y);
+}
+
+void
+out_site(Site * s)
+{
+    /* 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) ; */
+
+    if (rubyvorState.plot)
+        circle (s->coord.x, s->coord.y, cradius);
+    
+    if (rubyvorState.debug)
+        printf("site (%d) at %f %f\n", s->sitenbr, s->coord.x, s->coord.y);
+}
+
+void
+out_triple(Site * s1, Site * s2, Site * s3)
+{
+    /* Save triplet to our ruby object */
+    (*rubyvorState.storeT)(s1->sitenbr, s2->sitenbr, s3->sitenbr);
+    
+    if (rubyvorState.debug)
+    {
+        printf("%d %d %d\n", s1->sitenbr, s2->sitenbr, s3->sitenbr);
+        printf("circle through left=%d right=%d bottom=%d\n",
+               s1->sitenbr, s2->sitenbr, s3->sitenbr) ;
+    }
+}
+
+void
+plotinit(void)
+{
+    float dx, dy, d ;
+
+    dy = rubyvorState.ymax - rubyvorState.ymin ;
+    dx = rubyvorState.xmax - rubyvorState.xmin ;
+    d = ( dx > dy ? dx : dy) * 1.1 ;
+    pxmin = rubyvorState.xmin - (d-dx) / 2.0 ;
+    pxmax = rubyvorState.xmax + (d-dx) / 2.0 ;
+    pymin = rubyvorState.ymin - (d-dy) / 2.0 ;
+    pymax = rubyvorState.ymax + (d-dy) / 2.0 ;
+    cradius = (pxmax - pxmin) / 350.0 ;
+    openpl() ;
+    range(pxmin, pymin, pxmax, pymax) ;
+}
+
+void
+clip_line(Edge * e)
+{
+    Site * s1, * s2 ;
+    float x1, x2, y1, y2 ;
+
+    if (e->a == 1.0 && e->b >= 0.0)
+    {
+        s1 = e->ep[1] ;
+        s2 = e->ep[0] ;
+    }
+    else
+    {
+        s1 = e->ep[0] ;
+        s2 = e->ep[1] ;
+    }
+    if (e->a == 1.0)
+    {
+        y1 = pymin ;
+        if (s1 != (Site *)NULL && s1->coord.y > pymin)
+        {
+             y1 = s1->coord.y ;
+        }
+        if (y1 > pymax)
+        {
+            return ;
+        }
+        x1 = e->c - e->b * y1 ;
+        y2 = pymax ;
+        if (s2 != (Site *)NULL && s2->coord.y < pymax)
+        {
+            y2 = s2->coord.y ;
+        }
+        if (y2 < pymin)
+        {
+            return ;
+        }
+        x2 = e->c - e->b * y2 ;
+        if (((x1 > pxmax) && (x2 > pxmax)) || ((x1 < pxmin) && (x2 < pxmin)))
+        {
+            return ;
+        }
+        if (x1 > pxmax)
+        {
+            x1 = pxmax ;
+            y1 = (e->c - x1) / e->b ;
+        }
+        if (x1 < pxmin)
+        {
+            x1 = pxmin ;
+            y1 = (e->c - x1) / e->b ;
+        }
+        if (x2 > pxmax)
+        {
+            x2 = pxmax ;
+            y2 = (e->c - x2) / e->b ;
+        }
+        if (x2 < pxmin)
+        {
+            x2 = pxmin ;
+            y2 = (e->c - x2) / e->b ;
+        }
+    }
+    else
+    {
+        x1 = pxmin ;
+        if (s1 != (Site *)NULL && s1->coord.x > pxmin)
+        {
+            x1 = s1->coord.x ;
+        }
+        if (x1 > pxmax)
+        {
+            return ;
+        }
+        y1 = e->c - e->a * x1 ;
+        x2 = pxmax ;
+        if (s2 != (Site *)NULL && s2->coord.x < pxmax)
+        {
+            x2 = s2->coord.x ;
+        }
+        if (x2 < pxmin)
+        {
+            return ;
+        }
+        y2 = e->c - e->a * x2 ;
+        if (((y1 > pymax) && (y2 > pymax)) || ((y1 < pymin) && (y2 <pymin)))
+        {
+            return ;
+        }
+        if (y1> pymax)
+        {
+            y1 = pymax ;
+            x1 = (e->c - y1) / e->a ;
+        }
+        if (y1 < pymin)
+        {
+            y1 = pymin ;
+            x1 = (e->c - y1) / e->a ;
+        }
+        if (y2 > pymax)
+        {
+            y2 = pymax ;
+            x2 = (e->c - y2) / e->a ;
+        }
+        if (y2 < pymin)
+        {
+            y2 = pymin ;
+            x2 = (e->c - y2) / e->a ;
+        }
+    }
+    line(x1,y1,x2,y2);
+}
+
+/* Linux-specific. */
+void
+debug_memory(void)
+{    
+    char buf[30];
+    FILE* pf;
+    int tmp;
+    float totalSize;
+    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)
+    */
+
+    if (!rubyvorState.debug)
+        return;
+    
+    snprintf(buf, 30, "/proc/%u/statm", (unsigned)getpid());
+    pf = fopen(buf, "r");
+    if (NULL != pf)
+    {
+        tmp = fscanf(pf, "%u", &size); /*, %u, %u ... etc &resident, &share, &text, &lib, &data); */
+        totalSize = (float)size / 1024.0;
+        fprintf(stderr, "%f ", totalSize);
+    }
+    fclose(pf);
+}

data/ext/rb_cComputation.c

@@ -0,0 +1,369 @@
+#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_LEN(pointsArray) < 1)
+        rb_raise(rb_eRuntimeError, "input points array must have a nonzero length");
+    for (i = 0; i < RARRAY_LEN(pointsArray); i++) {
+        if(!rb_respond_to(RARRAY_PTR(pointsArray)[i], x) || !rb_respond_to(RARRAY_PTR(pointsArray)[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_LEN(pointsArray);
+    inPtr  = RARRAY_PTR(pointsArray);
+
+    
+    /* 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_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_LEN(points));
+    for (i = 0; i < RARRAY_LEN(points); i++)
+        rb_ary_push(graph, rb_ary_new());
+    
+    /* Get our pointer into this array. */
+    graphPtr = RARRAY_PTR(graph);
+
+    /* Iterate over the triangulation */
+    dtRaw = rb_iv_get(self, "@delaunay_triangulation_raw");
+    dtPtr = RARRAY_PTR(dtRaw);
+    for (i = 0; i < RARRAY_LEN(dtRaw); i++) {
+        tripletPtr = RARRAY_PTR(dtPtr[i]);
+
+        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_LEN(graph); i++) {
+        if (RARRAY_LEN(graphPtr[i]) < 1) {
+            /* Evaluate noNeighborResponse and respond accordingly */
+            if (noNeighborResponse == 1) {
+                rb_raise(rb_eIndexError, "index of 0 (no neighbors) at %li", 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_LEN(points); j++) {
+                    if (j != i) {
+                        rb_ary_push(graphPtr[i], INT2FIX(j));
+                        if (RARRAY_LEN(graphPtr[j]) > 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;
+}
+
+
+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_LEN(points); 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_PTR(nnGraph)[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_PTR(currentData)[1])) {
+            /* push this node into adjacency_list of parent */
+            rb_ary_push(RARRAY_PTR(rb_iv_get(RARRAY_PTR(currentData)[1], "@data"))[3], current);
+            /* push parent into adjacency_list of this node */
+            rb_ary_push(RARRAY_PTR(currentData)[3], RARRAY_PTR(currentData)[1]);
+        }
+
+        for (i = 0; i < RARRAY_LEN(RARRAY_PTR(currentData)[2]); i++) {
+            /* grab indexed node */
+            adjacent = RARRAY_PTR(nodes)[FIX2LONG(RARRAY_PTR(RARRAY_PTR(currentData)[2])[i])];
+            adjacentData = rb_iv_get(adjacent, "@data");
+        
+            /* check in_q -- only look at new nodes */
+            if (Qtrue == RARRAY_PTR(adjacentData)[4]) {
+
+                /* compare points by node -- adjacent against current */
+                adjacentDistance = rb_funcall(dist_proc, i_call, 2,
+                                              RARRAY_PTR(points)[FIX2LONG(RARRAY_PTR(currentData)[0])],
+                                              RARRAY_PTR(points)[FIX2LONG(RARRAY_PTR(adjacentData)[0])]);
+
+                /* If the new distance is better than our current priority, exchange them. */
+                if (RFLOAT_VALUE(adjacentDistance) < RFLOAT_VALUE(rb_iv_get(adjacent, "@priority"))) {
+                    /* 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_LEN(nodes); i++) {
+        current = RARRAY_PTR(nodes)[i];
+        currentData = rb_iv_get(current, "@data");
+        if (!NIL_P(RARRAY_PTR(currentData)[1])) {
+            adjacentData = rb_iv_get(RARRAY_PTR(currentData)[1], "@data");
+            tmp = rb_ary_new2(2);
+            if (FIX2LONG(RARRAY_PTR(currentData)[0]) < FIX2LONG(RARRAY_PTR(adjacentData)[0])) {
+                rb_ary_push(tmp, RARRAY_PTR(currentData)[0]);
+                rb_ary_push(tmp, RARRAY_PTR(adjacentData)[0]);
+            } else {
+                rb_ary_push(tmp, RARRAY_PTR(adjacentData)[0]);                
+                rb_ary_push(tmp, RARRAY_PTR(currentData)[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;
+}
+
+
+/*
+ * 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) ;
+    }
+}