rubyvor 0.1.3

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 (CLASS_OF(a) == rb_path2class("RubyVor::PriorityQueue::QueueItem"))
+        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_obj_classname(rb_path2class("RubyVor::PriorityQueue::QueueItem")));
+
+    if (CLASS_OF(a) == rb_path2class("RubyVor::PriorityQueue::QueueItem"))
+        bD = NUM2DBL(rb_funcall(b, rb_intern("priority"), 0));
+    else
+      rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(a), rb_obj_classname(rb_path2class("RubyVor::PriorityQueue::QueueItem")));
+
+    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 %li out of range", i-1);
+    
+    j = i / 2;
+    
+    item = RARRAY_PTR(data)[i - 1];
+
+    while(j > 0 && compare(item, RARRAY_PTR(data)[j - 1]))
+    {
+        rb_ary_store(data, i-1, RARRAY_PTR(data)[j - 1]);
+        rb_funcall(RARRAY_PTR(data)[i-1], rb_intern("index="), 1, INT2FIX(i-1));
+        i = j;
+        j = j / 2;
+    }
+
+    rb_ary_store(data, i-1, item);
+    rb_funcall(RARRAY_PTR(data)[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 %li out of range", i-1);
+    
+    j = size / 2;
+
+    item = RARRAY_PTR(data)[i - 1];
+
+    while (!(i > j))
+    {
+        k = i * 2;
+        if (k < size && compare(RARRAY_PTR(data)[k], RARRAY_PTR(data)[k - 1]))
+            k++;
+
+        if (compare(item, RARRAY_PTR(data)[k - 1]))
+            j = -1;
+        else
+        {
+            rb_ary_store(data, i-1, RARRAY_PTR(data)[k - 1]);
+            rb_funcall(RARRAY_PTR(data)[i-1], rb_intern("index="), 1, INT2FIX(i-1));
+            i = k;
+        }
+    }
+
+    rb_ary_store(data, i-1, item);
+    rb_funcall(RARRAY_PTR(data)[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,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,40 @@
+#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
+
+#ifndef RUBY_19
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(v) (RARRAY(v)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(v) (RARRAY(v)->ptr)
+#endif
+#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
+
+