geokdtree 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in geokdtree.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2013 Colin Surprenant <colin.surprenant@gmail.com>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,121 @@
+# Ruby/FFI Geokdtree v0.1.0
+
+Ruby & JRuby gem with a fast **k-d tree** C implementation using FFI bindings with support for latitude/longitude and **geo distance range search**.
+
+A [k-d tree](https://en.wikipedia.org/wiki/K-d_tree) is a space-partitioning data structure for organizing points in a k-dimensional space and are useful for very **fast range searches** and **nearest neighbor searches**. k-d trees are a special case of binary space partitioning trees.
+
+## Installation
+
+Tested on OSX 10.8.2 with
+- MRI Ruby 1.9.3 p362
+- MRI Ruby 1.9.3 p385
+- JRuby 1.7.2 (1.9.3 p327)
+
+Add this line to your application's Gemfile:
+
+    gem 'geokdtree'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geokdtree
+
+## JRuby Notes
+
+if the gem installation fails with the following error message, this is because JRuby disabled native extensions by default. 
+```
+Gem::Installer::ExtensionBuildError: ERROR: Failed to build gem native extension
+```
+
+To fix this simply set the following JRuby runtime option
+``` sh
+$ export JRUBY_OPTS=-Xcext.enabled=true
+```
+
+## Usage
+
+``` ruby
+  # simplest 2d tree
+  tree = Geokdtree::Tree.new(2)
+  tree.insert([1, 0])
+  tree.insert([2, 0])
+  tree.insert([3, 0])
+
+  result = tree.nearest([0, 0])
+  puts(result.point.inspect) # => [1.0, 0.0]
+  puts(result.data.inspect) # => nil
+
+  # simple 2d tree with point payload. 
+  # abritary objects can be attached to each inserted point
+  tree = Geokdtree::Tree.new(2)
+  tree.insert([1, 0], "point 1")
+  tree.insert([2, 0], "point 2")
+  tree.insert([3, 0], "point 3")
+
+  # single nearest using standard/Euclidean relative distance
+  result = tree.nearest([0, 0])
+  puts(result.point.inspect) # => [1.0, 0.0]
+  puts(result.data.inspect) # => "point 1"
+
+  # nearests within range using standard/Euclidean relative distance
+  results = tree.nearest_range([0, 0], 2)
+  puts(results.size) # => 2
+  puts(results[0].point.inspect) # => [2.0, 0.0]
+  puts(results[0].data.inspect) # => "point 2"
+  puts(results[1].point.inspect) # => [1.0, 0.0]
+  puts(results[1].data.inspect) # => "point 1"
+
+  # 2d tree with lat/lng points
+  tree = Geokdtree::Tree.new(2)
+  tree.insert([40.7, -74.0], "New York")
+  tree.insert([37.77, -122.41], "San Francisco")
+  tree.insert([45.50, -73.55], "Montreal")
+
+  # single nearest using standard/Euclidean relative distance
+  result = tree.nearest([34.1, -118.2]) # Los Angeles
+  puts(result.point.inspect) # => [37.77, -122.41]
+  puts(result.data.inspect) # => "San Francisco"
+
+
+  # nearests within range using miles relative geo distance
+  results = tree.nearest_geo_range([47.6, -122.3], 800) # Seattle, within 800 mi
+  puts(results.size) # => 1
+  puts(results[0].point.inspect) # => [37.77, -122.41]
+  puts(results[0].data.inspect) # => "San Francisco"
+
+  # nearests within range using kilometer relative geo distance
+  results = tree.nearest_geo_range([42.35, -71.06], 500, :km) # Boston, within 500 km
+  puts(results.size) # => 2
+  puts(results[0].point.inspect) # => [45.5, -73.55]
+  puts(results[0].data.inspect) # => "Montreal"
+  puts(results[1].point.inspect) # => [40.7, -74.0]
+  puts(results[1].data.inspect) # => "New York"
+
+  # compute standard/Euclidean distance between two points
+  d = Geokdtree::Tree.distance([-1, 1], [1, 1])
+  puts(d) # => 2
+
+  # compute geo distance between two points (Montreal, Boston)
+  d = Geokdtree::Tree.geo_distance([45.5, -73.55], [42.35, -71.06], :km).round(0)
+  puts(d.inspect) # => 403
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Credits
+- [John Tsiombikas](http://nuclear.mutantstargoat.com/) for writing the [original C kdtree](https://code.google.com/p/kdtree/).
+
+## Author
+Colin Surprenant, [@colinsurprenant](http://twitter.com/colinsurprenant), [http://github.com/colinsurprenant](http://github.com/colinsurprenant), colin.surprenant@gmail.com
+
+## License
+Ruby/FFI Geokdtree is distributed under the Apache License, Version 2.0. 

data/Rakefile

@@ -0,0 +1,30 @@
+require 'bundler/setup'
+require 'rake'
+require 'rake/clean'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+desc "clean, make and run specsrkae"
+task :spec do
+  RSpec::Core::RakeTask.new
+end
+
+desc "compile C ext and FFI ext and copy objects into lib"
+task :make => [:clean] do
+  Dir.chdir("ext/geokdtree") do
+    ruby jruby? ? "-Xcext.enabled=true extconf.rb" : "extconf.rb"
+    sh "make"
+  end
+  cp "ext/geokdtree/geokdtree.bundle", "lib/"
+end
+
+CLEAN.include('ext/**/*{.o,.log,.so,.bundle}')
+CLEAN.include('lib/**/*{.o,.log,.so,.bundle}')
+CLEAN.include('ext/**/Makefile')
+
+def jruby?
+  !!(defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby')
+end
+

data/example/usage.rb

@@ -0,0 +1,65 @@
+require 'bundler/setup'
+require 'geokdtree'
+
+# simplest 2d tree
+tree = Geokdtree::Tree.new(2)
+tree.insert([1, 0])
+tree.insert([2, 0])
+tree.insert([3, 0])
+
+result = tree.nearest([0, 0])
+puts(result.point.inspect) # => [1.0, 0.0]
+puts(result.data.inspect) # => nil
+
+# simple 2d tree with point payload. abritary objects can be attached to each inserted point
+tree = Geokdtree::Tree.new(2)
+tree.insert([1, 0], "point 1")
+tree.insert([2, 0], "point 2")
+tree.insert([3, 0], "point 3")
+
+# single nearest using standard/Euclidean relative distance
+result = tree.nearest([0, 0])
+puts(result.point.inspect) # => [1.0, 0.0]
+puts(result.data.inspect) # => "point 1"
+
+# nearests within range using standard/Euclidean relative distance
+results = tree.nearest_range([0, 0], 2)
+puts(results.size) # => 2
+puts(results[0].point.inspect) # => [2.0, 0.0]
+puts(results[0].data.inspect) # => "point 2"
+puts(results[1].point.inspect) # => [1.0, 0.0]
+puts(results[1].data.inspect) # => "point 1"
+
+# 2d tree with lat/lng points
+tree = Geokdtree::Tree.new(2)
+tree.insert([40.7, -74.0], "New York")
+tree.insert([37.77, -122.41], "San Francisco")
+tree.insert([45.50, -73.55], "Montreal")
+
+# single nearest using standard/Euclidean relative distance
+result = tree.nearest([34.1, -118.2]) # Los Angeles
+puts(result.point.inspect) # => [37.77, -122.41]
+puts(result.data.inspect) # => "San Francisco"
+
+
+# nearests within range using miles relative geo distance
+results = tree.nearest_geo_range([47.6, -122.3], 800) # Seattle, within 800 miles
+puts(results.size) # => 1
+puts(results[0].point.inspect) # => [37.77, -122.41]
+puts(results[0].data.inspect) # => "San Francisco"
+
+# nearests within range using kilometer relative geo distance
+results = tree.nearest_geo_range([42.35, -71.06], 500, :km) # Boston, within 500 kilometer
+puts(results.size) # => 2
+puts(results[0].point.inspect) # => [45.5, -73.55]
+puts(results[0].data.inspect) # => "Montreal"
+puts(results[1].point.inspect) # => [40.7, -74.0]
+puts(results[1].data.inspect) # => "New York"
+
+# compute standard/Euclidean distance between two points
+d = Geokdtree::Tree.distance([-1, 1], [1, 1])
+puts(d) # => 2
+
+# compute geo distance between two points
+d = Geokdtree::Tree.geo_distance([45.5, -73.55], [42.35, -71.06], :km).round(0) # Montreal, Boston
+puts(d.inspect) # => 403

data/ext/geokdtree/distance.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "distance.h"
+
+static double RADIAN_PER_DEGREE = M_PI / 180.0;
+
+/* return the square Euclidean distance from two points in k dimensions */
+double square_euclidean_distance(const double *a, const double *b, int k) {
+  double d = 0, diff;
+  while (--k >= 0) {
+    diff = (a[k] - b[k]);
+    d += diff * diff;
+  }
+  return d;
+}
+
+/* return the Euclidean distance from two points in k dimensions */
+double euclidean_distance(const double *a, const double *b, int k) {
+  return sqrt(square_euclidean_distance(a, b, k));
+}
+
+/* return the Euclidean distance from two points in two dimensions */
+double euclidean_distance2(double ax, double ay, double bx, double by) {
+  double a[2];
+  double b[2];
+  a[0] = ax;
+  a[1] = ay;
+  b[0] = bx;
+  b[1] = by;
+  return sqrt(square_euclidean_distance(a, b, 2));
+}
+
+/* return the geo distance from two lat/lng points using the spherical law of cosines */
+double slc_distance(const double *a, const double *b, double radius) {
+  double rlat1 = RADIAN_PER_DEGREE * a[0];
+  double rlng1 = RADIAN_PER_DEGREE * a[1];
+  double rlat2 = RADIAN_PER_DEGREE * b[0];
+  double rlng2 = RADIAN_PER_DEGREE * b[1];
+  return acos(sin(rlat1) * sin(rlat2) + cos(rlat1) * cos(rlat2) * cos(rlng2 - rlng1)) * radius;
+}
+
+/* return the geo distance from two lat/lng points using the spherical law of cosines */
+double slc_distance2(double lat1, double lng1, double lat2, double lng2, double radius) {
+  double a[2];
+  double b[2];
+  a[0] = lat1, a[1] = lng1;
+  b[0] = lat2, b[1] = lng2;
+  return slc_distance(a, b, radius);
+}
+
+/* return the geo distance from two lat/lng points using the haversine formula */
+double haversine_distance2(double lat1, double lng1, double lat2, double lng2, double radius) {
+  double rlat1 = RADIAN_PER_DEGREE * lat1;
+  double rlat2 = RADIAN_PER_DEGREE * lat2;
+  double rdistlat = RADIAN_PER_DEGREE * (lat2 - lat1);
+  double rdistlng = RADIAN_PER_DEGREE * (lng2 - lng1);
+  double a =  SQ(sin(rdistlat / 2.0)) + cos(rlat1) * cos(rlat2) * SQ(sin(rdistlng / 2.0));
+  double c = 2.0 * atan2(sqrt(a), sqrt(1 - a));
+  return c * radius;
+}
+
+int bsq_compare(double a, double b) {
+  return (a > SQ(b)) - (a < SQ(b));
+}
+
+int std_compare(double a, double b) {
+  return (a > b) - (a < b);
+}

data/ext/geokdtree/distance.h

@@ -0,0 +1,38 @@
+#ifndef _DISTANCE_H_
+#define _DISTANCE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RADIUS_MI 3958.760
+#define RADIUS_KM 6371.0
+#define KM_PER_MI 1.609
+#define SQ(x) ((x) * (x))
+
+/* return the square Euclidean distance from two points in k dimensions */
+double square_euclidean_distance(const double *a, const double *b, int k);
+
+/* return the Euclidean distance from two points in k dimensions */
+double euclidean_distance(const double *a, const double *b, int k);
+
+/* return the Euclidean distance from two points in two dimensions */
+double euclidean_distance2(double ax, double ay, double bx, double by);
+
+/* return the geo distance from two lat/lng points using the spherical law of cosines */
+double slc_distance(const double *a, const double *b, double radius);
+
+/* return the geo distance from two lat/lng points using the spherical law of cosines */
+double slc_distance2(double lat1, double lng1, double lat2, double lng2, double radius);
+
+/* return the geo distance from two lat/lng points using the haversine formula */
+double haversine_distance2(double lat1, double lng1, double lat2, double lng2, double radius);
+
+int bsq_compare(double a, double b);
+int std_compare(double a, double b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _DISTANCE_H_ */

data/ext/geokdtree/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+$CFLAGS = "-pedantic -Wall -g -O3 -fPIC -g -DUSE_LIST_NODE_ALLOCATOR"
+
+have_library("pthread")
+
+create_makefile 'geokdtree'

data/ext/geokdtree/kdtree.c

@@ -0,0 +1,782 @@
+/*
+This file is part of ``kdtree'', a library for working with kd-trees.
+Copyright (C) 2007-2011 John Tsiombikas <nuclear@member.fsf.org>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.
+*/
+
+/* single nearest neighbor search written by Tamas Nepusz <tamas@cs.rhul.ac.uk> */
+
+/*
+Feb 2013 - Colin Surprenant <colin.surprenant@gmail.com> 
+- inclusion in the ruby-ffi-kdtree gem
+- added kd_nearest2
+- added kd_nearest_range2
+- added kd_insert2
+- refactored find_nearest to externalize the distance computation and distance comparison
+- refactored kd_nearest_range into kd_generic_nearest_range to externalize the distance computation and distance comparison
+- added kd_nearest_geo_range
+- added distance.[ch]
+- removed all float functions
+
+original source code from https://code.google.com/p/kdtree/ 
+using version 0.5.6 dated Nov 2011
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "kdtree.h"
+#include "distance.h"
+
+#if defined(WIN32) || defined(__WIN32__)
+#include <malloc.h>
+#endif
+
+#ifdef USE_LIST_NODE_ALLOCATOR
+
+#ifndef NO_PTHREADS
+#include <pthread.h>
+#else
+
+#ifndef I_WANT_THREAD_BUGS
+#error "You are compiling with the fast list node allocator, with pthreads disabled! This WILL break if used from multiple threads."
+#endif	/* I want thread bugs */
+
+#endif	/* pthread support */
+#endif	/* use list node allocator */
+
+struct kdhyperrect {
+	int dim;
+	double *min, *max;              /* minimum/maximum coords */
+};
+
+struct kdnode {
+	double *pos;
+	int dir;
+	void *data;
+
+	struct kdnode *left, *right;	/* negative/positive side */
+};
+
+struct res_node {
+	struct kdnode *item;
+	double dist_sq;
+	struct res_node *next;
+};
+
+struct kdtree {
+	int dim;
+	struct kdnode *root;
+	struct kdhyperrect *rect;
+	void (*destr)(void*);
+};
+
+struct kdres {
+	struct kdtree *tree;
+	struct res_node *rlist, *riter;
+	int size;
+};
+
+#define SQ(x) ((x) * (x))
+
+
+static int find_nearest(struct kdnode *node, const double *pos, double range, struct res_node *list, int ordered, int dim, double (*distance_function)(const double *, const double *, int k), int (*compare_function)(double, double));
+static void kd_nearest_i(struct kdnode *node, const double *pos, struct kdnode **result, double *result_dist_sq, struct kdhyperrect* rect);
+static double geo_distance_mi(const double *a, const double *b, int k);
+static double geo_distance_km(const double *a, const double *b, int k);
+
+static void clear_rec(struct kdnode *node, void (*destr)(void*));
+static int insert_rec(struct kdnode **node, const double *pos, void *data, int dir, int dim);
+static int rlist_insert(struct res_node *list, struct kdnode *item, double dist_sq);
+static void clear_results(struct kdres *set);
+
+static struct kdhyperrect* hyperrect_create(int dim, const double *min, const double *max);
+static void hyperrect_free(struct kdhyperrect *rect);
+static struct kdhyperrect* hyperrect_duplicate(const struct kdhyperrect *rect);
+static void hyperrect_extend(struct kdhyperrect *rect, const double *pos);
+static double hyperrect_dist_sq(struct kdhyperrect *rect, const double *pos);
+
+#ifdef USE_LIST_NODE_ALLOCATOR
+static struct res_node *alloc_resnode(void);
+static void free_resnode(struct res_node*);
+#else
+#define alloc_resnode()		malloc(sizeof(struct res_node))
+#define free_resnode(n)		free(n)
+#endif
+
+
+struct kdtree *kd_create(int k)
+{
+	struct kdtree *tree;
+
+	if(!(tree = malloc(sizeof *tree))) {
+		return 0;
+	}
+
+	tree->dim = k;
+	tree->root = 0;
+	tree->destr = 0;
+	tree->rect = 0;
+
+	return tree;
+}
+
+void kd_free(struct kdtree *tree)
+{
+	if(tree) {
+		kd_clear(tree);
+		free(tree);
+	}
+}
+
+static void clear_rec(struct kdnode *node, void (*destr)(void*))
+{
+	if(!node) return;
+
+	clear_rec(node->left, destr);
+	clear_rec(node->right, destr);
+	
+	if(destr) {
+		destr(node->data);
+	}
+	free(node->pos);
+	free(node);
+}
+
+void kd_clear(struct kdtree *tree)
+{
+	clear_rec(tree->root, tree->destr);
+	tree->root = 0;
+
+	if (tree->rect) {
+		hyperrect_free(tree->rect);
+		tree->rect = 0;
+	}
+}
+
+void kd_data_destructor(struct kdtree *tree, void (*destr)(void*))
+{
+	tree->destr = destr;
+}
+
+
+static int insert_rec(struct kdnode **nptr, const double *pos, void *data, int dir, int dim)
+{
+	int new_dir;
+	struct kdnode *node;
+
+	if(!*nptr) {
+		if(!(node = malloc(sizeof *node))) {
+			return -1;
+		}
+		if(!(node->pos = malloc(dim * sizeof *node->pos))) {
+			free(node);
+			return -1;
+		}
+		memcpy(node->pos, pos, dim * sizeof *node->pos);
+		node->data = data;
+		node->dir = dir;
+		node->left = node->right = 0;
+		*nptr = node;
+		return 0;
+	}
+
+	node = *nptr;
+	new_dir = (node->dir + 1) % dim;
+	if(pos[node->dir] < node->pos[node->dir]) {
+		return insert_rec(&(*nptr)->left, pos, data, new_dir, dim);
+	}
+	return insert_rec(&(*nptr)->right, pos, data, new_dir, dim);
+}
+
+int kd_insert(struct kdtree *tree, const double *pos, void *data)
+{
+	if (insert_rec(&tree->root, pos, data, 0, tree->dim)) {
+		return -1;
+	}
+
+	if (tree->rect == 0) {
+		tree->rect = hyperrect_create(tree->dim, pos, pos);
+	} else {
+		hyperrect_extend(tree->rect, pos);
+	}
+
+	return 0;
+}
+
+int kd_insert2(struct kdtree *tree, double x, double y, void *data)
+{
+	double pos[2];
+	pos[0] = x;
+	pos[1] = y;
+	return kd_insert(tree, pos, data);
+}
+
+int kd_insert3(struct kdtree *tree, double x, double y, double z, void *data)
+{
+	double pos[3];
+	pos[0] = x;
+	pos[1] = y;
+	pos[2] = z;
+	return kd_insert(tree, pos, data);
+}
+
+/* TODO: add > 16 dimensions handling */
+static int find_nearest(
+	struct kdnode *node, 
+    const double *pos, 
+    double range, 
+    struct res_node *list, 
+    int ordered, 
+    int dim, 
+    double (*distance_function)(const double *, const double *, int k), 
+    int (*compare_function)(double, double)
+)
+{
+	double dist, one_dim_dist, one_dim_relative_dist;
+	int i, ret, added_res = 0;
+	double one_dim_pos[16];
+
+	if(!node) return 0;
+	if(dim > 16) return -1;
+
+	dist = (*distance_function)(node->pos, pos, dim);
+	if((*compare_function)(dist, range) <= 0) {
+		if(rlist_insert(list, node, ordered ? dist : -1.0) == -1) {
+			return -1;
+		}
+		added_res = 1;
+	}
+
+	/* isolate single dimension position from node->pos into one_dim_pos for single dimension distance computation */
+	for(i = 0; i < dim; i++) {
+		one_dim_pos[i] = pos[i];
+	}
+	one_dim_pos[node->dir] = node->pos[node->dir];
+
+	one_dim_dist = (*distance_function)(pos, one_dim_pos, dim);
+	one_dim_relative_dist = pos[node->dir] - node->pos[node->dir];
+
+	ret = find_nearest(one_dim_relative_dist <= 0.0 ? node->left : node->right, pos, range, list, ordered, dim, distance_function, compare_function);
+	if(ret >= 0 && (*compare_function)(one_dim_dist, range) < 0) {
+		added_res += ret;
+		ret = find_nearest(one_dim_relative_dist <= 0.0 ? node->right : node->left, pos, range, list, ordered, dim, distance_function, compare_function);
+	}
+	if(ret == -1) {
+		return -1;
+	}
+	added_res += ret;
+
+	return added_res;
+}
+
+#if 0
+static int find_nearest_n(struct kdnode *node, const double *pos, double range, int num, struct rheap *heap, int dim)
+{
+	double dist_sq, dx;
+	int i, ret, added_res = 0;
+
+	if(!node) return 0;
+	
+	/* if the photon is close enough, add it to the result heap */
+	dist_sq = 0;
+	for(i=0; i<dim; i++) {
+		dist_sq += SQ(node->pos[i] - pos[i]);
+	}
+	if(dist_sq <= range_sq) {
+		if(heap->size >= num) {
+			/* get furthest element */
+			struct res_node *maxelem = rheap_get_max(heap);
+
+			/* and check if the new one is closer than that */
+			if(maxelem->dist_sq > dist_sq) {
+				rheap_remove_max(heap);
+
+				if(rheap_insert(heap, node, dist_sq) == -1) {
+					return -1;
+				}
+				added_res = 1;
+
+				range_sq = dist_sq;
+			}
+		} else {
+			if(rheap_insert(heap, node, dist_sq) == -1) {
+				return =1;
+			}
+			added_res = 1;
+		}
+	}
+
+
+	/* find signed distance from the splitting plane */
+	dx = pos[node->dir] - node->pos[node->dir];
+
+	ret = find_nearest_n(dx <= 0.0 ? node->left : node->right, pos, range, num, heap, dim);
+	if(ret >= 0 && fabs(dx) < range) {
+		added_res += ret;
+		ret = find_nearest_n(dx <= 0.0 ? node->right : node->left, pos, range, num, heap, dim);
+	}
+
+}
+#endif
+
+static void kd_nearest_i(struct kdnode *node, const double *pos, struct kdnode **result, double *result_dist_sq, struct kdhyperrect* rect)
+{
+	int dir = node->dir;
+	int i;
+	double dummy, dist_sq;
+	struct kdnode *nearer_subtree, *farther_subtree;
+	double *nearer_hyperrect_coord, *farther_hyperrect_coord;
+
+	/* Decide whether to go left or right in the tree */
+	dummy = pos[dir] - node->pos[dir];
+	if (dummy <= 0) {
+		nearer_subtree = node->left;
+		farther_subtree = node->right;
+		nearer_hyperrect_coord = rect->max + dir;
+		farther_hyperrect_coord = rect->min + dir;
+	} else {
+		nearer_subtree = node->right;
+		farther_subtree = node->left;
+		nearer_hyperrect_coord = rect->min + dir;
+		farther_hyperrect_coord = rect->max + dir;
+	}
+
+	if (nearer_subtree) {
+		/* Slice the hyperrect to get the hyperrect of the nearer subtree */
+		dummy = *nearer_hyperrect_coord;
+		*nearer_hyperrect_coord = node->pos[dir];
+		/* Recurse down into nearer subtree */
+		kd_nearest_i(nearer_subtree, pos, result, result_dist_sq, rect);
+		/* Undo the slice */
+		*nearer_hyperrect_coord = dummy;
+	}
+
+	/* Check the distance of the point at the current node, compare it
+	 * with our best so far */
+	dist_sq = 0;
+	for(i=0; i < rect->dim; i++) {
+		dist_sq += SQ(node->pos[i] - pos[i]);
+	}
+	if (dist_sq < *result_dist_sq) {
+		*result = node;
+		*result_dist_sq = dist_sq;
+	}
+
+	if (farther_subtree) {
+		/* Get the hyperrect of the farther subtree */
+		dummy = *farther_hyperrect_coord;
+		*farther_hyperrect_coord = node->pos[dir];
+		/* Check if we have to recurse down by calculating the closest
+		 * point of the hyperrect and see if it's closer than our
+		 * minimum distance in result_dist_sq. */
+		if (hyperrect_dist_sq(rect, pos) < *result_dist_sq) {
+			/* Recurse down into farther subtree */
+			kd_nearest_i(farther_subtree, pos, result, result_dist_sq, rect);
+		}
+		/* Undo the slice on the hyperrect */
+		*farther_hyperrect_coord = dummy;
+	}
+}
+
+struct kdres *kd_nearest(struct kdtree *kd, const double *pos)
+{
+	struct kdhyperrect *rect;
+	struct kdnode *result;
+	struct kdres *rset;
+	double dist_sq;
+	int i;
+
+	if (!kd) return 0;
+	if (!kd->rect) return 0;
+
+	/* Allocate result set */
+	if(!(rset = malloc(sizeof *rset))) {
+		return 0;
+	}
+	if(!(rset->rlist = alloc_resnode())) {
+		free(rset);
+		return 0;
+	}
+	rset->rlist->next = 0;
+	rset->tree = kd;
+
+	/* Duplicate the bounding hyperrectangle, we will work on the copy */
+	if (!(rect = hyperrect_duplicate(kd->rect))) {
+		kd_res_free(rset);
+		return 0;
+	}
+
+	/* Our first guesstimate is the root node */
+	result = kd->root;
+	dist_sq = 0;
+	for (i = 0; i < kd->dim; i++)
+		dist_sq += SQ(result->pos[i] - pos[i]);
+
+	/* Search for the nearest neighbour recursively */
+	kd_nearest_i(kd->root, pos, &result, &dist_sq, rect);
+
+	/* Free the copy of the hyperrect */
+	hyperrect_free(rect);
+
+	/* Store the result */
+	if (result) {
+		if (rlist_insert(rset->rlist, result, -1.0) == -1) {
+			kd_res_free(rset);
+			return 0;
+		}
+		rset->size = 1;
+		kd_res_rewind(rset);
+		return rset;
+	} else {
+		kd_res_free(rset);
+		return 0;
+	}
+}
+
+
+struct kdres *kd_nearest2(struct kdtree *tree, double x, double y)
+{
+	double pos[2];
+	pos[0] = x;
+	pos[1] = y;
+	return kd_nearest(tree, pos);
+}
+
+struct kdres *kd_nearest3(struct kdtree *tree, double x, double y, double z)
+{
+	double pos[3];
+	pos[0] = x;
+	pos[1] = y;
+	pos[2] = z;
+	return kd_nearest(tree, pos);
+}
+
+/* ---- nearest N search ---- */
+/*
+static kdres *kd_nearest_n(struct kdtree *kd, const double *pos, int num)
+{
+	int ret;
+	struct kdres *rset;
+
+	if(!(rset = malloc(sizeof *rset))) {
+		return 0;
+	}
+	if(!(rset->rlist = alloc_resnode())) {
+		free(rset);
+		return 0;
+	}
+	rset->rlist->next = 0;
+	rset->tree = kd;
+
+	if((ret = find_nearest_n(kd->root, pos, range, num, rset->rlist, kd->dim)) == -1) {
+		kd_res_free(rset);
+		return 0;
+	}
+	rset->size = ret;
+	kd_res_rewind(rset);
+	return rset;
+}*/
+
+struct kdres *kd_generic_nearest_range(
+	struct kdtree *kd, 
+	const double *pos, 
+	double range, 
+	double (*distance_function)(const double *, const double *, int k), 
+	int (*compare_function)(double, double)
+)
+{
+	int ret;
+	struct kdres *rset;
+
+	if(!(rset = malloc(sizeof *rset))) {
+		return 0;
+	}
+	if(!(rset->rlist = alloc_resnode())) {
+		free(rset);
+		return 0;
+	}
+	rset->rlist->next = 0;
+	rset->tree = kd;
+
+	if((ret = find_nearest(kd->root, pos, range, rset->rlist, 0, kd->dim, distance_function, compare_function)) == -1) {
+		kd_res_free(rset);
+		return 0;
+	}
+	rset->size = ret;
+	kd_res_rewind(rset);
+	return rset;
+}
+
+struct kdres *kd_nearest_range(struct kdtree *kd, const double *pos, double range)
+{
+	return kd_generic_nearest_range(kd, pos, range, square_euclidean_distance, bsq_compare);
+}
+
+struct kdres *kd_nearest_range2(struct kdtree *tree, double x, double y, double range)
+{
+	double pos[2];
+	pos[0] = x;
+	pos[1] = y;
+	return kd_nearest_range(tree, pos, range);
+}
+
+struct kdres *kd_nearest_range3(struct kdtree *tree, double x, double y, double z, double range)
+{
+	double pos[3];
+	pos[0] = x;
+	pos[1] = y;
+	pos[2] = z;
+	return kd_nearest_range(tree, pos, range);
+}
+
+static double geo_distance_mi(const double *a, const double *b, int k)
+{
+	/* just ignore k, we know its 2d but k is required per distance function signature */
+	return slc_distance(a, b, RADIUS_MI);
+}
+
+static double geo_distance_km(const double *a, const double *b, int k)
+{
+	/* just ignore k, we know its 2d but k is required per distance function signature */
+	return slc_distance(a, b, RADIUS_KM);
+}
+
+struct kdres *kd_nearest_geo_range(struct kdtree *kd, double lat, double lng, double range, int units)
+{
+	double pos[2];
+	pos[0] = lat;
+	pos[1] = lng;
+	if(units != GEO_UNITS_MI) {
+		return kd_generic_nearest_range(kd, pos, range, geo_distance_km, std_compare);		
+	}
+	return kd_generic_nearest_range(kd, pos, range, geo_distance_mi, std_compare);		
+}
+
+void kd_res_free(struct kdres *rset)
+{
+	clear_results(rset);
+	free_resnode(rset->rlist);
+	free(rset);
+}
+
+int kd_res_size(struct kdres *set)
+{
+	return (set->size);
+}
+
+void kd_res_rewind(struct kdres *rset)
+{
+	rset->riter = rset->rlist->next;
+}
+
+int kd_res_end(struct kdres *rset)
+{
+	return rset->riter == 0;
+}
+
+int kd_res_next(struct kdres *rset)
+{
+	rset->riter = rset->riter->next;
+	return rset->riter != 0;
+}
+
+void *kd_res_item(struct kdres *rset, double *pos)
+{
+	if(rset->riter) {
+		if(pos) {
+			memcpy(pos, rset->riter->item->pos, rset->tree->dim * sizeof *pos);
+		}
+		return rset->riter->item->data;
+	}
+	return 0;
+}
+
+void *kd_res_item3(struct kdres *rset, double *x, double *y, double *z)
+{
+	if(rset->riter) {
+		if(*x) *x = rset->riter->item->pos[0];
+		if(*y) *y = rset->riter->item->pos[1];
+		if(*z) *z = rset->riter->item->pos[2];
+	}
+	return 0;
+}
+
+void *kd_res_item_data(struct kdres *set)
+{
+	return kd_res_item(set, 0);
+}
+
+/* ---- hyperrectangle helpers ---- */
+static struct kdhyperrect* hyperrect_create(int dim, const double *min, const double *max)
+{
+	size_t size = dim * sizeof(double);
+	struct kdhyperrect* rect = 0;
+
+	if (!(rect = malloc(sizeof(struct kdhyperrect)))) {
+		return 0;
+	}
+
+	rect->dim = dim;
+	if (!(rect->min = malloc(size))) {
+		free(rect);
+		return 0;
+	}
+	if (!(rect->max = malloc(size))) {
+		free(rect->min);
+		free(rect);
+		return 0;
+	}
+	memcpy(rect->min, min, size);
+	memcpy(rect->max, max, size);
+
+	return rect;
+}
+
+static void hyperrect_free(struct kdhyperrect *rect)
+{
+	free(rect->min);
+	free(rect->max);
+	free(rect);
+}
+
+static struct kdhyperrect* hyperrect_duplicate(const struct kdhyperrect *rect)
+{
+	return hyperrect_create(rect->dim, rect->min, rect->max);
+}
+
+static void hyperrect_extend(struct kdhyperrect *rect, const double *pos)
+{
+	int i;
+
+	for (i=0; i < rect->dim; i++) {
+		if (pos[i] < rect->min[i]) {
+			rect->min[i] = pos[i];
+		}
+		if (pos[i] > rect->max[i]) {
+			rect->max[i] = pos[i];
+		}
+	}
+}
+
+static double hyperrect_dist_sq(struct kdhyperrect *rect, const double *pos)
+{
+	int i;
+	double result = 0;
+
+	for (i=0; i < rect->dim; i++) {
+		if (pos[i] < rect->min[i]) {
+			result += SQ(rect->min[i] - pos[i]);
+		} else if (pos[i] > rect->max[i]) {
+			result += SQ(rect->max[i] - pos[i]);
+		}
+	}
+
+	return result;
+}
+
+/* ---- static helpers ---- */
+
+#ifdef USE_LIST_NODE_ALLOCATOR
+/* special list node allocators. */
+static struct res_node *free_nodes;
+
+#ifndef NO_PTHREADS
+static pthread_mutex_t alloc_mutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+static struct res_node *alloc_resnode(void)
+{
+	struct res_node *node;
+
+#ifndef NO_PTHREADS
+	pthread_mutex_lock(&alloc_mutex);
+#endif
+
+	if(!free_nodes) {
+		node = malloc(sizeof *node);
+	} else {
+		node = free_nodes;
+		free_nodes = free_nodes->next;
+		node->next = 0;
+	}
+
+#ifndef NO_PTHREADS
+	pthread_mutex_unlock(&alloc_mutex);
+#endif
+
+	return node;
+}
+
+static void free_resnode(struct res_node *node)
+{
+#ifndef NO_PTHREADS
+	pthread_mutex_lock(&alloc_mutex);
+#endif
+
+	node->next = free_nodes;
+	free_nodes = node;
+
+#ifndef NO_PTHREADS
+	pthread_mutex_unlock(&alloc_mutex);
+#endif
+}
+#endif	/* list node allocator or not */
+
+
+/* inserts the item. if dist_sq is >= 0, then do an ordered insert */
+/* TODO make the ordering code use heapsort */
+static int rlist_insert(struct res_node *list, struct kdnode *item, double dist_sq)
+{
+	struct res_node *rnode;
+
+	if(!(rnode = alloc_resnode())) {
+		return -1;
+	}
+	rnode->item = item;
+	rnode->dist_sq = dist_sq;
+
+	if(dist_sq >= 0.0) {
+		while(list->next && list->next->dist_sq < dist_sq) {
+			list = list->next;
+		}
+	}
+	rnode->next = list->next;
+	list->next = rnode;
+	return 0;
+}
+
+static void clear_results(struct kdres *rset)
+{
+	struct res_node *tmp, *node = rset->rlist->next;
+
+	while(node) {
+		tmp = node;
+		node = node->next;
+		free_resnode(tmp);
+	}
+
+	rset->rlist->next = 0;
+}