rubyvor 0.1.3

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);
+}

data/lib/ruby_vor.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '..', 'ext')
+
+require 'ruby_vor/version'
+require 'ruby_vor/point'
+require 'ruby_vor/priority_queue'
+require 'ruby_vor/computation'
+require 'ruby_vor/geo_ruby_extensions'
+require 'ruby_vor/visualizer'
+
+# Require ruby_vor.so last to clobber old from_points
+require 'ruby_vor_c.so'
+
+# DOC HERE
+module RubyVor
+end

data/lib/ruby_vor/computation.rb

@@ -0,0 +1,136 @@
+module RubyVor
+  module VDDT
+    class Computation
+      attr_reader :points, :voronoi_diagram_raw, :delaunay_triangulation_raw, :no_neighbor_response
+
+      DIST_PROC = lambda{|a,b| a.distance_from(b)}
+      NO_NEIGHBOR_RESPONSES = [:raise, :use_all, :ignore]
+      
+      # Create a computation from an existing set of raw data.
+      def initialize
+        @points = []
+        
+        @voronoi_diagram_raw = []
+        @delaunay_triangulation_raw = []
+        
+        @nn_graph = nil
+        @mst = nil
+
+        @no_neighbor_response = :use_all
+      end
+
+      # Decided what action to take if we find a point with no neighbors
+      # while computing the nn_graph.
+      #
+      # Choices are:
+      #  * :use_all - include all other nodes as potential neighbors. This choice is the default, and can lead to higher big-O lower bounds when clustering.
+      #  * :raise - raise an error
+      #  * :ignore - leave this node disconnected from the rest of the graph.
+      def no_neighbor_response=(v)
+        @no_neighbor_response = v if NO_NEIGHBOR_RESPONSES.include?(v)
+      end
+
+      # Uses the nearest-neighbors information encapsulated by the Delaunay triangulation as a seed for clustering:
+      # We take the edges (there are O(n) of them, because  defined by the triangulation and delete any edge above a certain distance.
+      #
+      # This method allows the caller to pass in a lambda for customizing distance calculations. For instance, to use a GeoRuby::SimpleFeatures::Point, one would:
+      #  > cluster_by_distance(50 lambda{|a,b| a.spherical_distance(b, 3958.754)}) # this rejects edges greater than 50 miles, using spherical distance as a measure
+      def cluster_by_distance(max_distance, dist_proc=DIST_PROC)
+        clusters = []
+        nodes    = (0..points.length-1).to_a
+        visited  = [false] * points.length
+        graph    = []
+        v = 0
+        
+        nn_graph.each_with_index do |neighbors,nv|
+          graph[nv] = neighbors.select do |neighbor|
+            dist_proc[points[nv], points[neighbor]] < max_distance
+          end
+        end
+        
+        until nodes.empty?
+          v = nodes.pop
+          
+          next if visited[v]
+
+          cluster = []
+          visited[v] = true
+          cluster.push(v)
+
+          children = graph[v]
+          until children.nil? || children.empty?
+            cnode = children.pop
+            next if cnode.nil? || visited[cnode]
+
+            visited[cnode] = true
+            cluster.push(cnode)
+            children.concat(graph[cnode])
+          end
+
+          clusters.push(cluster)
+        end
+
+        clusters
+      end
+
+      def cluster_by_size(sizes=[], dist_proc=DIST_PROC)
+        # * Take MST, and
+        #   1. For n in sizes (taken in descending order), delete the n most expensive edges from MST
+        #     * TODO: use a MaxHeap?
+        #   2. Determine remaining connectivity using BFS as above?
+        #   3. Some other more efficient connectivity test?
+        #   4. Return {n1 => cluster, n2 => cluster} for all n.
+        
+        sized_clusters = sizes.inject({}) {|h,s| h[s] = []; h}
+        
+        
+        mst = minimum_spanning_tree(dist_proc).to_a
+        mst.sort!{|a,b|a.last <=> b.last}
+
+        sizes = sizes.sort
+        last_size = 0
+
+        while current_size = sizes.shift
+          current_size -= 1
+          
+          # Remove edge count delta
+          delta = current_size - last_size
+          mst.slice!(-delta,delta)
+
+          graph    = (1..points.length).to_a.map{|v| []}
+          visited  = [nil] * points.length
+          clusters = []
+
+          mst.each do |edge,weight|
+            graph[edge[1]].push(edge[0])
+            graph[edge[0]].push(edge[1])
+          end
+
+          for node in 0..points.length-1
+            next if visited[node]
+
+            cluster = [node]
+            visited[node] = true
+
+            neighbors = graph[node]
+            while v = neighbors.pop
+              next if visited[v]
+
+              cluster.push(v)
+              visited[v] = true
+              neighbors.concat(graph[v])
+            end
+
+            clusters.push(cluster)
+          end
+
+          sized_clusters[current_size + 1] = clusters
+          last_size = current_size
+        end
+        
+        sized_clusters
+      end
+
+    end
+  end
+end

data/lib/ruby_vor/geo_ruby_extensions.rb

@@ -0,0 +1,15 @@
+if require 'geo_ruby'
+  # Let us call uniq on a set of Points or use one as a Hash key.
+  module GeoRuby
+    module SimpleFeatures
+      class Point < Geometry
+        def eql?(other)
+          self == other
+        end
+        def hash
+          [x,y,z,m].hash
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vor/point.rb

@@ -0,0 +1,32 @@
+module RubyVor
+  class Point
+    attr_reader :x, :y
+    def initialize(x=0.0,y=0.0)
+      raise TypeError, 'Must be able to convert point values into floats' unless x.respond_to?(:to_f) && y.respond_to?(:to_f)
+      @x = x.to_f
+      @y = y.to_f
+    end
+
+    def <=>(p)
+      (@x != p.x) ? @x <=> p.x : @y <=> p.y
+    end
+
+    def <(p)
+      (self <=> p) == -1
+    end
+
+    def >(p)
+      (self <=> p) == 1
+    end
+    
+    def ==(p)
+      @x == p.x && @y == p.y
+    end
+    alias :eql? :==
+
+    def to_s
+      "(#{@x},#{@y})"
+    end    
+
+  end
+end