abscondment-rubyvor 0.1.2

data/ext/ruby_vor_c.c

@@ -0,0 +1,115 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor_c.h>
+
+/* Classes & Modules */
+static VALUE RubyVor_rb_mRubyVor;
+static VALUE RubyVor_rb_mVDDT;
+
+static VALUE RubyVor_rb_cComputation;
+static VALUE RubyVor_rb_cPriorityQueue;
+static VALUE RubyVor_rb_cQueueItem;
+static VALUE RubyVor_rb_cPoint;
+
+/*
+ * 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,28 @@
+#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;
+
+/* Computation */
+VALUE RubyVor_from_points(VALUE, VALUE);
+VALUE RubyVor_nn_graph(VALUE);
+VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
+
+/* PriorityQueue */
+VALUE RubyVor_percolate_up(VALUE, VALUE);
+VALUE RubyVor_percolate_down(VALUE, VALUE);
+VALUE RubyVor_heapify(VALUE);
+
+/* Point */
+VALUE RubyVor_distance_from(VALUE, VALUE);
+VALUE RubyVor_point_hash(VALUE);
+
+#endif

data/ext/vdefs.h

@@ -0,0 +1,150 @@
+#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 * comp;
+    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) ;
+char *myrealloc(void *, unsigned, 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,271 @@
+
+/*** VORONOI.C ***/
+
+#include <ruby.h>
+#include <vdefs.h>
+#include <stdio.h>
+
+VoronoiState rubyvorState;
+
+/* 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();
+}
+
+void
+voronoi(Site *(*nextsite)(void))
+{
+    Site * newsite, * bot, * top, * temp, * p, * v ;
+    Point newintstar ;
+    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
+            && 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) ;
+    }
+}
+
+
+
+
+/*
+ * 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));
+
+    /* Get the existing raw triangulation */
+    trArray = rb_funcall(*(VALUE *)rubyvorState.comp, 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);
+    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.comp, 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);
+    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.comp, 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);
+    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.comp, 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);
+    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.comp, rb_intern("voronoi_diagram_raw"), 0);
+
+    /* Add the new site to it */
+    rb_ary_push(sArray, site);
+}