rubyvor 0.1.3

data/History.rdoc

@@ -0,0 +1,60 @@
+=== 0.1.3 / 2010-01-26
+
+* Ruby 1.9 compatibility update; update for newer Hoe syntax.
+
+=== 0.1.2 / 2009-04-24
+
+* Compilation fixes for OSX. Thanks to jpemberthy and febuiles!
+
+=== 0.1.1 / 2009-01-15
+
+* LibXML require conflict fix.
+
+=== 0.1.0 / 2009-01-13
+
+* Configurable handling of "no neighbors" case.
+* Tests for "no neighbors" case.
+
+=== 0.0.9 / 2009-01-01
+
+Happy New Year!
+* New speed improvements.
+* Additional visualization tweaks.
+* More tests.
+
+=== 0.0.8 / 2008-12-23
+
+* Several C warning fixes (more ISO C compliance unused variables, etc)
+* Moved minimum_spanning_tree computation into C, yielding large speed gain.
+* Basic SVG visualization.
+
+=== 0.0.7 / 2008-12-12
+
+* Bugfix: there are cases where performing a Delaunay triangulation on a set of points will not yield a complete nearest neighbor graph. This causes computation of the minimum spanning tree and clustering to fail for these nodes (they always appear as disconnected from the main graph).
+
+* To fix this, the nn_graph function now treats any point that is excluded from Delaunay triangulation as having *all* other points as nearest neighbors. This is a naive approach, but is a good fix while a more efficient solution is considered.
+
+=== 0.0.6 / 2008-12-11
+
+* Implementation of cluster_by_size to partition points into N clusters.
+
+=== 0.0.5 / 2008-12-10
+
+* Beginnings of clustering and useful graph algorithms.
+* Some refactoring of C methods.
+
+=== 0.0.4 / 2008-12-04
+
+* Fixed 64-bit segfaults due to improper definition of the myrealloc() function.
+
+=== 0.0.3 / 2008-12-03
+
+* Fixed a segfault by using rb_ary_push instead of direct pointer manipulation. Much simpler.
+
+=== 0.0.2 / 2008-12-03
+
+* Computations succeed on a naive Point class, returning raw values for the associated Voronoi Diagram and Delaunay triangulation.
+
+=== 0.0.1 / 2008-12-01
+
+* Initial release. Nothing works.

data/Manifest.txt

@@ -0,0 +1,30 @@
+History.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+ext/Doc
+ext/edgelist.c
+ext/extconf.rb
+ext/geometry.c
+ext/heap.c
+ext/memory.c
+ext/output.c
+ext/rb_cComputation.c
+ext/rb_cPoint.c
+ext/rb_cPriorityQueue.c
+ext/ruby_vor_c.c
+ext/ruby_vor_c.h
+ext/vdefs.h
+ext/voronoi.c
+lib/ruby_vor.rb
+lib/ruby_vor/computation.rb
+lib/ruby_vor/geo_ruby_extensions.rb
+lib/ruby_vor/point.rb
+lib/ruby_vor/priority_queue.rb
+lib/ruby_vor/version.rb
+lib/ruby_vor/visualizer.rb
+rubyvor.gemspec
+test/test_computation.rb
+test/test_point.rb
+test/test_priority_queue.rb
+test/test_voronoi_interface.rb

data/README.rdoc

@@ -0,0 +1,76 @@
+= rubyvor
+
+Efficient Voronoi diagrams and Delaunay trianglation for Ruby
+
+== Description
+
+RubyVor provides efficient computation of Voronoi diagrams and
+Delaunay triangulation for a set of Ruby points. It is intended to
+function as a complemenet to GeoRuby. These structures can be used to
+compute a nearest-neighbor graph for a set of points. This graph can
+in turn be used for proximity-based clustering of the input points.
+
+== Usage:
+
+require 'lib/ruby_vor'
+require 'pp'
+
+points = [
+  RubyVor::Point.new(120, 290),
+  RubyVor::Point.new(110, 120),
+  RubyVor::Point.new(160, 90.2),
+  RubyVor::Point.new(3.14159265, 3.14159265)
+]
+
+# Compute the diagram & triangulation
+comp = RubyVor::VDDT::Computation.from_points(points)
+
+puts "The nearest-neighbor graph:"
+pp comp.nn_graph
+
+puts "\nThe minimum-spanning tree:"
+pp comp.minimum_spanning_tree
+
+#
+# Visualize these things as SVGs
+#
+
+# Just the triangulation
+RubyVor::Visualizer.make_svg(comp, :name => 'tri.svg')
+
+# Just the MST
+RubyVor::Visualizer.make_svg(comp, :name => 'mst.svg', :triangulation => false, :mst => true)
+
+# Voronoi diagram and the triangulation
+RubyVor::Visualizer.make_svg(comp, :name => 'dia.svg', :voronoi_diagram => true)
+
+
+== LICENSE:
+
+Original public-domain C code (by Steven Fortune; http://ect.bell-labs.com/who/sjf/) and
+memory-management fixes for said C code (by Derek Bradley; http://www.derekbradley.ca)
+used (and released under the MIT-LICENSE) with permission.
+
+
+(The MIT License)
+
+Copyright (c) 2008 Brendan Ribera <brendan.ribera+rubyvor@gmail.com>
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,41 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'lib/ruby_vor/version.rb'
+
+EXT = "ext/voronoi_interface.#{Config::CONFIG['DLEXT']}"
+
+Hoe.spec 'rubyvor' do
+  developer 'Brendan Ribera', 'brendan.ribera+rubyvor@gmail.com'
+  
+  self.version      = RubyVor::VERSION
+  self.url          = 'http://github.com/bribera/rubyvor'
+  self.readme_file  = 'README.rdoc'
+  self.history_file = 'History.rdoc'
+  self.summary      = 'Efficient Voronoi diagrams and Delaunay trianglation for Ruby'
+  self.description  = 'RubyVor provides efficient computation of Voronoi diagrams and Delaunay triangulation for a set of Ruby points. It is intended to function as a complemenet to GeoRuby. These structures can be used to compute a nearest-neighbor graph for a set of points. This graph can in turn be used for proximity-based clustering of the input points.'
+
+  # C extension goodness
+  self.spec_extras[:extensions] = "ext/extconf.rb"
+  self.clean_globs << EXT << 'ext/*.o' << 'ext/Makefile'
+end
+
+desc "Compile extensions"
+task :compile => EXT
+task :test => :compile
+
+file EXT => ['ext/extconf.rb', 'ext/ruby_vor_c.c'] do
+  Dir.chdir 'ext' do
+    ruby 'extconf.rb'
+    sh 'make'
+  end    
+end
+
+desc "Prepare for github upload"
+task :github do
+  system "git ls-files | egrep -v \"\\.gitignore\" > Manifest.txt"
+  system "rake debug_gem | egrep -v \"^\\(in\" > rubyvor.gemspec"
+end
+
+task :gem => :github

data/ext/Doc

@@ -0,0 +1,30 @@
+voronoi - compute Voronoi diagram or Delaunay triangulation
+SYNOPSIS
+	voronoi [-s -t] <pointfile >outputfile
+
+Voronoi reads the standard input for a set of points in the plane and writes either
+the Voronoi diagram or the Delaunay triangulation to the standard output.
+Each input line should consist of two real numbers, separated by white space.
+
+If option
+	-t 
+is present, the Delaunay triangulation is produced. 
+Each output line is a triple
+	i j k
+which are the indices of the three points in a Delaunay triangle. Points are
+numbered starting at 0. If this option is not present, the
+Voronoi diagram is produced.  There are four output record types.
+	s a b
+indicates that an input point at coordinates 
+	l a b c
+indicates a line with equation ax + by = c.
+	v a b
+indicates a vertex at  a b.
+	e l v1 v2
+indicates 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.
+
+AUTHOR
+Steve J. Fortune (1987) A Sweepline Algorithm for Voronoi Diagrams,
+Algorithmica 2, 153-174.

data/ext/edgelist.c

@@ -0,0 +1,204 @@
+
+/*** EDGELIST.C ***/
+
+#include "vdefs.h"
+
+static int ELhashsize ;
+static Halfedge * ELleftend, * ELrightend, ** ELhash ;
+static Freelist hfl ;
+static int ntry, totalsearch ;
+
+void
+ELinitialize(void)
+{
+    int i ;
+
+    freeinit(&hfl, sizeof(Halfedge)) ;
+    ELhashsize = 2 * rubyvorState.sqrt_nsites ;
+    ELhash = (Halfedge **)myalloc( sizeof(*ELhash) * ELhashsize) ;
+    for (i = 0  ; i < ELhashsize  ; i++)
+    {
+        ELhash[i] = (Halfedge *)NULL ;
+    }
+    ELleftend = HEcreate((Edge *)NULL, 0) ;
+    ELrightend = HEcreate((Edge *)NULL, 0) ;
+    ELleftend->ELleft = (Halfedge *)NULL ;
+    ELleftend->ELright = ELrightend ;
+    ELrightend->ELleft = ELleftend ;
+    ELrightend->ELright = (Halfedge *)NULL ;
+    ELhash[0] = ELleftend ;
+    ELhash[ELhashsize-1] = ELrightend ;
+}
+
+Halfedge *
+HEcreate(Edge * e, int pm)
+{
+    Halfedge * answer ;
+
+    answer = (Halfedge *)getfree(&hfl) ;
+    answer->ELedge = e ;
+    answer->ELpm = pm ;
+    answer->PQnext = (Halfedge *)NULL ;
+    answer->vertex = (Site *)NULL ;
+    answer->ELrefcnt = 0 ;
+    return (answer) ;
+}
+
+void
+ELinsert(Halfedge * lb, Halfedge * new)
+{
+    new->ELleft = lb ;
+    new->ELright = lb->ELright ;
+    (lb->ELright)->ELleft = new ;
+    lb->ELright = new ;
+}
+
+/* Get entry from hash table, pruning any deleted nodes */
+
+Halfedge *
+ELgethash(int b)
+{
+    Halfedge * he ;
+
+    if ((b < 0) || (b >= ELhashsize))
+    {
+        return ((Halfedge *)NULL) ;
+    }
+    he = ELhash[b] ;
+    if ((he == (Halfedge *)NULL) || (he->ELedge != (Edge *)DELETED))
+    {
+        return (he) ;
+    }
+    /* Hash table points to deleted half edge.  Patch as necessary. */
+    ELhash[b] = (Halfedge *)NULL ;
+    if ((--(he->ELrefcnt)) == 0)
+    {
+        makefree((Freenode *)he, (Freelist *)&hfl) ;
+    }
+    return ((Halfedge *)NULL) ;
+}
+
+Halfedge *
+ELleftbnd(Point * p)
+{
+    int i, bucket ;
+    Halfedge * he ;
+
+    /* Use hash table to get close to desired halfedge */
+    bucket = (p->x - rubyvorState.xmin) / rubyvorState.deltax * ELhashsize ;
+    if (bucket < 0)
+    {
+        bucket = 0 ;
+    }
+    if (bucket >= ELhashsize)
+    {
+        bucket = ELhashsize - 1 ;
+    }
+    he = ELgethash(bucket) ;
+    if  (he == (Halfedge *)NULL)
+    {
+        for (i = 1 ; 1 ; i++)
+        {
+            if ((he = ELgethash(bucket-i)) != (Halfedge *)NULL)
+            {
+                break ;
+            }
+            if ((he = ELgethash(bucket+i)) != (Halfedge *)NULL)
+            {
+                break ;
+            }
+        }
+        totalsearch += i ;
+    }
+    ntry++ ;
+    /* Now search linear list of halfedges for the corect one */
+    if (he == ELleftend || (he != ELrightend && right_of(he,p)))
+    {
+        do  {
+            he = he->ELright ;
+        } while (he != ELrightend && right_of(he,p)) ;
+        he = he->ELleft ;
+    }
+    else
+    {
+        do  {
+            he = he->ELleft ;
+        } while (he != ELleftend && !right_of(he,p)) ;
+    }
+    /*** Update hash table and reference counts ***/
+    if ((bucket > 0) && (bucket < ELhashsize-1))
+    {
+        if (ELhash[bucket] != (Halfedge *)NULL)
+        {
+            (ELhash[bucket]->ELrefcnt)-- ;
+        }
+        ELhash[bucket] = he ;
+        (ELhash[bucket]->ELrefcnt)++ ;
+    }
+    return (he) ;
+}
+
+/*** This delete routine can't reclaim node, since pointers from hash
+ : table may be present.
+ ***/
+
+void
+ELdelete(Halfedge * he)
+{
+    (he->ELleft)->ELright = he->ELright ;
+    (he->ELright)->ELleft = he->ELleft ;
+    he->ELedge = (Edge *)DELETED ;
+}
+
+Halfedge *
+ELright(Halfedge * he)
+{
+    return (he->ELright) ;
+}
+
+Halfedge *
+ELleft(Halfedge * he)
+{
+    return (he->ELleft) ;
+}
+
+Site *
+leftreg(Halfedge * he)
+{
+    if (he->ELedge == (Edge *)NULL)
+    {
+        return(rubyvorState.bottomsite) ;
+    }
+    return (he->ELpm == le ? he->ELedge->reg[le] :
+            he->ELedge->reg[re]) ;
+}
+
+Site *
+rightreg(Halfedge * he)
+{
+    if (he->ELedge == (Edge *)NULL)
+    {
+        return(rubyvorState.bottomsite) ;
+    }
+    return (he->ELpm == le ? he->ELedge->reg[re] :
+            he->ELedge->reg[le]) ;
+}
+
+/*
+ * Semi-hacky way to access these static variables. Placing them inside rubyvorState
+ * causes pointer issues that I don't want to debug, and they're only accessed briefly
+ * inside of voronoi.c.  Since we're just doing pointer comparison there, this is an
+ * acceptable compromise.
+ */
+
+Halfedge *
+getELleftend(void)
+{
+    return(ELleftend);
+}
+
+Halfedge *
+getELrightend(void)
+{
+    return(ELrightend);
+}

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+dir_config('ruby_vor_c')
+create_makefile('ruby_vor_c')