bribera-rubyvor 0.0.2

data/ext/vdefs.h

@@ -0,0 +1,149 @@
+#ifndef __VDEFS_H
+#define __VDEFS_H
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define DELETED -2
+
+typedef struct tagFreenode
+{
+    struct tagFreenode * nextfree;
+} Freenode ;
+
+
+typedef struct tagFreelist
+{
+    Freenode * head;
+    int nodesize;
+} Freelist ;
+
+typedef struct tagPoint
+{
+    float x ;
+    float y ;
+} Point ;
+
+/* structure used both for sites and for vertices */
+
+typedef struct tagSite
+{
+    Point coord ;
+    int sitenbr ;
+    int refcnt ;
+} Site ;
+
+
+typedef struct tagEdge
+{
+    float a, b, c ;
+    Site * ep[2] ;
+    Site * reg[2] ;
+    int edgenbr ;
+} Edge ;
+
+#define le 0
+#define re 1
+
+typedef struct tagHalfedge
+{
+    struct tagHalfedge * ELleft ;
+    struct tagHalfedge * ELright ;
+    Edge * ELedge ;
+    int ELrefcnt ;
+    char ELpm ;
+    Site * vertex ;
+    float ystar ;
+    struct tagHalfedge * PQnext ;
+} Halfedge ;
+
+typedef struct tagVoronoiState
+{
+    /* voronoi.c */
+    int sorted, plot, debug, siteidx;
+    float xmin, xmax, ymin, ymax;
+    Site * sites;
+    void * decomp;
+    void (* storeT)(int, int, int);
+    void (* storeL)(float, float, float);
+    void (* storeE)(int, int, int);
+    void (* storeV)(float, float);
+    void (* storeS)(float, float);
+    
+    /* geometry.c */
+    float deltax, deltay;
+    int nsites, nedges, sqrt_nsites, nvertices;
+    Freelist sfl;
+
+    /* edgelist.c */
+    int ELhashsize;
+    Site * bottomsite;
+} VoronoiState;
+
+extern VoronoiState rubyvorState;
+
+/* edgelist.c */
+void ELinitialize(void) ;
+Halfedge * HEcreate(Edge *, int) ;
+void ELinsert(Halfedge *, Halfedge *) ;
+Halfedge * ELgethash(int) ;
+Halfedge * ELleftbnd(Point *) ;
+void ELdelete(Halfedge *) ;
+Halfedge * ELright(Halfedge *) ;
+Halfedge * ELleft(Halfedge *) ;
+Site * leftreg(Halfedge *) ;
+Site * rightreg(Halfedge *) ;
+Halfedge * getELleftend(void) ;
+Halfedge * getELrightend(void) ;
+
+/* geometry.c */
+void geominit(void) ;
+Edge * bisect(Site *, Site *) ;
+Site * intersect(Halfedge *, Halfedge *) ;
+int right_of(Halfedge *, Point *) ;
+void endpoint(Edge *, int, Site *) ;
+float dist(Site *, Site *) ;
+void makevertex(Site *) ;
+void deref(Site *) ;
+void ref(Site *) ;
+
+/* heap.c */
+void PQinsert(Halfedge *, Site *, float) ;
+void PQdelete(Halfedge *) ;
+int PQbucket(Halfedge *) ;
+int PQempty(void) ;
+Point PQ_min(void) ;
+Halfedge * PQextractmin(void) ;
+void PQinitialize(void) ;
+
+/* getopt.c */
+extern int getopt(int, char *const *, const char *);
+
+/* memory.c */
+void freeinit(Freelist *, int) ;
+char *getfree(Freelist *) ;
+void makefree(Freenode *, Freelist *) ;
+char *myalloc(unsigned) ;
+void free_all(void);
+
+/* output.c */
+void openpl(void) ;
+void line(float, float, float, float) ;
+void circle(float, float, float) ;
+void range(float, float, float, float) ;
+void out_bisector(Edge *) ;
+void out_ep(Edge *) ;
+void out_vertex(Site *) ;
+void out_site(Site *) ;
+void out_triple(Site *, Site *, Site *) ;
+void plotinit(void) ;
+void clip_line(Edge *) ;
+void debug_memory(void);
+
+/* voronoi.c */
+void voronoi(Site *(*)()) ;
+void initialize_state(int);
+#endif  
+
+

data/ext/voronoi.c

@@ -0,0 +1,277 @@
+
+/*** VORONOI.C ***/
+
+#include <ruby.h>
+#include <vdefs.h>
+
+
+// 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);
+static void storeVertex(const float, const float);
+static void storeSite(const float, const float);
+
+/*** implicit parameters: nsites, sqrt_nsites, xmin, xmax, ymin, ymax,
+ : deltax, deltay (can all be estimates).
+ : Performance suffers if they are wrong; better to make nsites,
+ : deltax, and deltay too big than too small.  (?)
+ ***/
+
+void initialize_state(int debug)
+{
+    // Set up our initial state
+    rubyvorState.debug = debug;
+    rubyvorState.plot = 0;
+    rubyvorState.nsites = 0;
+    rubyvorState.siteidx = 0;
+    
+    rubyvorState.storeT = storeTriangulationTriplet;
+    rubyvorState.storeL = storeLine;
+    rubyvorState.storeE = storeEndpoint;
+    rubyvorState.storeV = storeVertex;
+    rubyvorState.storeS = storeSite;
+    
+    // Initialize the Site Freelist
+    freeinit(&(rubyvorState.sfl), sizeof(Site)) ;
+
+    // Initialize the geometry module
+    geominit() ;
+
+    // TODO: remove C plot references
+    if (rubyvorState.plot)
+        plotinit();
+    
+    debug_memory();
+}
+
+void
+voronoi(Site *(*nextsite)(void))
+{
+    Site * newsite, * bot, * top, * temp, * p, * v ;
+    Point newintstar ;
+    int pm ;
+    Halfedge * lbnd, * rbnd, * llbnd, * rrbnd, * bisector ;
+    Edge * e ;
+
+    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
+            && newsite->coord.x < newintstar.x)))
+        {
+            /* new site is smallest */
+            {
+                out_site(newsite) ;
+            }
+            lbnd = ELleftbnd(&(newsite->coord)) ;
+            rbnd = ELright(lbnd) ;
+            bot = rightreg(lbnd) ;
+            e = bisect(bot, newsite) ;
+            bisector = HEcreate(e, le) ;
+            ELinsert(lbnd, bisector) ;
+            p = intersect(lbnd, bisector) ;
+            if (p != (Site *)NULL)
+            {
+                PQdelete(lbnd) ;
+                PQinsert(lbnd, p, dist(p,newsite)) ;
+            }
+            lbnd = bisector ;
+            bisector = HEcreate(e, re) ;
+            ELinsert(lbnd, bisector) ;
+            p = intersect(bisector, rbnd) ;
+            if (p != (Site *)NULL)
+            {
+                PQinsert(bisector, p, dist(p,newsite)) ;
+            }
+            newsite = (*nextsite)() ;
+        }
+        else if (!PQempty())   /* intersection is smallest */
+        {
+            lbnd = PQextractmin() ;
+            llbnd = ELleft(lbnd) ;
+            rbnd = ELright(lbnd) ;
+            rrbnd = ELright(rbnd) ;
+            bot = leftreg(lbnd) ;
+            top = rightreg(rbnd) ;
+            out_triple(bot, top, rightreg(lbnd)) ;
+            v = lbnd->vertex ;
+            makevertex(v) ;
+            endpoint(lbnd->ELedge, lbnd->ELpm, v);
+            endpoint(rbnd->ELedge, rbnd->ELpm, v) ;
+            ELdelete(lbnd) ;
+            PQdelete(rbnd) ;
+            ELdelete(rbnd) ;
+            pm = le ;
+            if (bot->coord.y > top->coord.y)
+            {
+                temp = bot ;
+                bot = top ;
+                top = temp ;
+                pm = re ;
+            }
+            e = bisect(bot, top) ;
+            bisector = HEcreate(e, pm) ;
+            ELinsert(llbnd, bisector) ;
+            endpoint(e, re-pm, v) ;
+            deref(v) ;
+            p = intersect(llbnd, bisector) ;
+            if (p  != (Site *) NULL)
+            {
+                PQdelete(llbnd) ;
+                PQinsert(llbnd, p, dist(p,bot)) ;
+            }
+            p = intersect(bisector, rrbnd) ;
+            if (p != (Site *) NULL)
+            {
+                PQinsert(bisector, p, dist(p,bot)) ;
+            }
+        }
+        else
+        {
+            break ;
+        }
+    }
+    
+    for( lbnd = ELright(getELleftend()) ;
+         lbnd != getELrightend() ;
+         lbnd = ELright(lbnd))
+    {
+        e = lbnd->ELedge ;
+        out_ep(e) ;
+    }
+
+    // After completing calculations
+    debug_memory();
+}
+
+
+
+
+//
+// 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);
+    RARRAY(triplet)->len = 3;
+    RARRAY(triplet)->ptr[0] = INT2FIX(a);
+    RARRAY(triplet)->ptr[1] = INT2FIX(b);
+    RARRAY(triplet)->ptr[2] = INT2FIX(c);
+
+    // Get the existing raw triangulation
+    trArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("delaunay_triangulation_raw"), 0);
+
+    // Add the new triplet to it
+    rb_ary_push(trArray, triplet);
+}
+
+
+/*** stores a line defined by ax + by = c ***/
+static void
+storeLine(const float a, const float b, const float c)
+{
+    VALUE lArray, line;
+    
+    // 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);
+
+    // Get the existing raw voronoi diagram
+    lArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+
+    // Add the new line to it
+    rb_ary_push(lArray, line);    
+}
+
+
+/***
+ * Stores a Voronoi segment which is a subsegment of line number l;
+ * with endpoints numbered v1 and v2.  If v1 or v2 is -1, the line
+ * extends to infinity.
+ ***/
+static void
+storeEndpoint(const int l, const int v1, const int v2)
+{
+    VALUE eArray, endpoint;
+    
+    // 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);
+
+    // Get the existing raw voronoi diagram
+    eArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+
+    // Add the new endpoint to it
+    rb_ary_push(eArray, endpoint);    
+}
+
+
+/*** stores a vertex at (a,b) ***/
+static void
+storeVertex(const float a, const float b)
+{
+    VALUE vArray, vertex;
+    
+    // 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);
+
+    // Get the existing raw voronoi diagram
+    vArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+
+    // Add the new vertex to it
+    rb_ary_push(vArray, vertex);    
+}
+
+
+/***
+ * stores an input site at (x,y)
+ * TODO: redundant?
+ ***/
+static void
+storeSite(const float x, const float y)
+{
+    VALUE sArray, site;
+    
+    // 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);
+
+    // Get the existing raw voronoi diagram
+    sArray = rb_funcall(*(VALUE *)rubyvorState.decomp, rb_intern("voronoi_diagram_raw"), 0);
+
+    // Add the new site to it
+    rb_ary_push(sArray, site);    
+}

data/ext/voronoi_interface.c

@@ -0,0 +1,213 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+
+VoronoiState rubyvorState;
+
+static VALUE rb_mRubyVor;
+static VALUE rb_mVDDT;
+static VALUE rb_cDecomposition;
+static int repeat, rit;
+
+// Static method definitions
+static VALUE from_points(VALUE, VALUE);
+
+static Site * readone(void), * nextone(void);
+static int scomp(const void *, const void *);
+
+
+
+void
+Init_voronoi_interface(void)
+{
+    // Set up our Modules and Class.
+    rb_mRubyVor       = rb_define_module("RubyVor");
+    rb_mVDDT          = rb_define_module_under(rb_mRubyVor, "VDDT");
+    rb_cDecomposition = rb_define_class_under(rb_mVDDT, "Decomposition", rb_cObject);
+
+    // Add methods.
+    rb_define_singleton_method(rb_cDecomposition, "from_points", from_points, 1);
+}
+
+
+//
+// Class methods
+//
+static VALUE
+from_points(VALUE self, VALUE pointsArray)
+{
+    //VALUE returnValue;
+    VALUE * inPtr, newDecomp;
+    ID x, y;
+
+    long i, inSize;
+
+    // TODO: remove
+    repeat = 1;
+    
+    for (rit = 0; rit < repeat; rit++) {
+
+    // 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(0/* debug? */);
+    
+    // Create our return object.
+    newDecomp = rb_funcall(self, rb_intern("new"), 0);
+    // Store it in rubyvorState so we can populate its values.
+    rubyvorState.decomp = (void *) &newDecomp;
+
+
+    //
+    // 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);
+    
+    // Free our allocated objects
+    free_all();
+
+    if (rubyvorState.debug)
+        fprintf(stderr,"FINISHED ITERATION %i\n", repeat + 1);
+
+    
+    }
+    
+    return newDecomp;
+}
+
+
+
+
+//
+// Static C 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) ;
+    }
+}
+
+
+/*** read one site ***/
+static Site *
+readone(void)
+{
+    Site * s ;
+
+    s = (Site *)getfree(&(rubyvorState.sfl)) ;
+    s->refcnt = 0 ;
+    s->sitenbr = rubyvorState.siteidx++ ;
+    if (scanf("%f %f", &(s->coord.x), &(s->coord.y)) == EOF)
+    {
+        return ((Site *)NULL ) ;
+    }
+    return (s) ;
+}