griffordson-georuby-extras 0.6.0

data/History.txt

@@ -0,0 +1,7 @@
+=== 0.6.0 / 2010-06-30
+
+  * Added LinearRing#fast_contains?
+  
+=== 0.5.0 / 2008-12-03
+
+  * Released by David Troy (C) Under the MIT License

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+README
+ext/extconf.rb
+ext/vincenty.c
+ext/pnpoly.c
+ext/pnpoly.h
+lib/georuby-extras.rb
+test/test_vincenty.rb
+test/test_pnpoly.rb
+test/extras-benchmark.rb
+

data/README

@@ -0,0 +1,77 @@
+= georuby-extras
+
+* http://github.com/davetroy/georuby-extras
+
+== DESCRIPTION:
+
+GeoRuby-Extras Gem for Ruby (c) 2008 David Troy
+dave@roundhousetech.com
+
+GeoRuby-Extras offers some native C enhancements and extras to the popular GeoRuby gem.
+
+GeoRuby offers OGC-compliant simple features for Ruby as well as the ability to
+process SHP files and do other cool GIS hacks.  GeoRuby is often used in conjunction
+with GIS extensions for popular databases including Postgres and MySQL.
+
+== FEATURES/PROBLEMS:
+
+* Provides native C implementation of Vincenty distance and direct algorithms.
+* 25 times faster than GeoRuby 'ellipsoidal_distance' function.
+* Adds the Vincenty 'direct' algorithm (point_at_bearing_and_distance).
+* Provides native C implementation of a ray casting algorithm to detect if a point is contained in a polygon.
+* No known problems; won't work with JRuby or non-MRI Ruby implementations.
+
+== SYNOPSIS:
+
+require 'rubygems'
+require 'georuby-extras'
+
+include GeoRuby::SimpleFeatures
+  
+@home = Point.from_lon_lat(-76.511,39.024)
+@nyc = Point.from_lon_lat(-74,40.6)
+
+>> @home.ellipsoidal_distance(@nyc)
+=> 277195.510448391
+
+>> @home.point_at_bearing_and_distance(91.0, 130000.0).kml_representation
+=> "<Point>\n<coordinates>-75.0105920700835,38.9939120193168</coordinates>\n</Point>\n"
+
+== REQUIREMENTS:
+
+* GCC and a Gnu-ish build environment (for native extensions)
+
+== INSTALLATION
+
+1) Update to the latest RubyGems version
+    > gem update --system
+
+2) Install gem
+    > gem install griffordson-georuby-extras
+
+3) Profit!
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 David Troy, Roundhouse Technologies LLC
+
+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/ext/extconf.rb

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

data/ext/pnpoly.c

@@ -0,0 +1,105 @@
+// pnpoly.c
+// (c) 2010 Matt Griffith
+// 
+// A native Ruby extension for determining if a point is in a polygon. 
+// 
+// (The MIT License)
+// 
+// Copyright (c) 2010 Matt Griffith, AgriSmart Information Systems, LLC
+// 
+// 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.
+//
+// --------------------------------------------------------
+// The pnpoly function is covered by the following license. 
+// For more inforation see: 
+// http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
+//
+// Copyright (c) 1970-2003, Wm. Randolph Franklin
+// 
+// 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:
+// 
+// Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimers.
+// Redistributions in binary form must reproduce the above copyright
+// notice in the documentation and/or other materials provided with the
+// distribution. The name of W. Randolph Franklin may not be used to
+// endorse or promote products derived from this Software without
+// specific prior written permission. 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.
+
+#include "ruby.h"
+#include "pnpoly.h"
+
+static int pnpoly(int nvert, float *vertx, float *verty, float testx, float testy)
+{
+  int i, j, c = 0;
+  for (i = 0, j = nvert-1; i < nvert; j = i++) {
+    if (  ((verty[i]>testy) != (verty[j]>testy)) && 
+          (testx < (vertx[j]-vertx[i]) * (testy-verty[i]) / (verty[j]-verty[i]) + vertx[i]) )
+       c = !c;
+  }
+  return c;
+}
+
+VALUE point_in_poly(VALUE self, VALUE rb_x, VALUE rb_y, VALUE rb_points) {
+  Check_Type(rb_x, T_FLOAT);
+  Check_Type(rb_y, T_FLOAT);
+  Check_Type(rb_points, T_ARRAY);
+  
+  int i = 0;
+  int s = RARRAY(rb_points)->len;
+  float *vertx;
+  float *verty;
+  
+  vertx = calloc(s, sizeof(float));
+  verty = calloc(s, sizeof(float));
+  
+  float test_x = RFLOAT(rb_x)->value;
+  float test_y = RFLOAT(rb_y)->value;
+  
+  ID i_x = rb_intern("x");
+  ID i_y = rb_intern("y");
+  
+  for(i = 0; i < s; i++) {
+    VALUE point = RARRAY_PTR(rb_points)[i];
+    VALUE x = rb_funcall(point, i_x, 0);
+    VALUE y = rb_funcall(point, i_y, 0);
+    Check_Type(x, T_FLOAT);
+    Check_Type(y, T_FLOAT);
+    vertx[i] = RFLOAT(x)->value;
+    verty[i] = RFLOAT(y)->value;
+  }
+  
+  return pnpoly(s, vertx, verty, test_x, test_y);
+}
+
+// end

data/ext/pnpoly.h

@@ -0,0 +1,6 @@
+#if !defined(_pnpoly_h_)
+#define _pnpoly_h_
+
+VALUE point_in_poly(VALUE self, VALUE rb_lat, VALUE rb_lon, VALUE rb_points);
+
+#endif // _pnpoly_h_

data/ext/vincenty.c

@@ -0,0 +1,166 @@
+// geohash-native.c
+// (c) 2008 David Troy
+// dave@roundhousetech.com
+//
+// Based on Javascript code (c) by Chris Veness
+// http://www.movable-type.co.uk/scripts/latlong-vincenty.html
+// http://www.movable-type.co.uk/scripts/latlong-vincenty-direct.html
+// 
+// Derived from algorithms by T. Vincenty, 1975
+//
+// (The MIT License)
+// 
+// Copyright (c) 2008 David Troy, Roundhouse Technologies LLC
+// 
+// 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.
+
+#include "ruby.h"
+#include <math.h>
+#include <ctype.h>
+#include "pnpoly.h"
+
+#define DEG_TO_RAD	0.0174532925199433
+#define PI					3.14159265358979
+
+static VALUE rb_mVincenty;
+static VALUE rb_mPointInPoly;
+
+static VALUE distance(VALUE self, VALUE rb_lon1, VALUE rb_lat1, VALUE rb_lon2, VALUE rb_lat2, VALUE rb_a, VALUE rb_b) {
+
+	Check_Type(rb_lon1, T_FLOAT);
+	Check_Type(rb_lat1, T_FLOAT);
+	Check_Type(rb_lon2, T_FLOAT);
+	Check_Type(rb_lat2, T_FLOAT);
+	Check_Type(rb_a, T_FLOAT);
+	Check_Type(rb_b, T_FLOAT);
+
+	double lon1 = RFLOAT(rb_lon1)->value;
+	double lat1 = RFLOAT(rb_lat1)->value;
+	double lon2 = RFLOAT(rb_lon2)->value;
+	double lat2 = RFLOAT(rb_lat2)->value;
+	double a = RFLOAT(rb_a)->value;
+	double b = RFLOAT(rb_b)->value;
+
+	double sinLambda, cosLambda, sinSigma, cosSigma, sigma, sinAlpha, cosSqAlpha, cos2SigmaM, C;
+	
+	double f = (a-b) / a;
+  double L = (lon2-lon1) * DEG_TO_RAD;
+  double U1 = atan((1-f) * tan(lat1 * DEG_TO_RAD));
+  double U2 = atan((1-f) * tan(lat2 * DEG_TO_RAD));
+	double sinU1 = sin(U1), cosU1 = cos(U1);
+  double sinU2 = sin(U2), cosU2 = cos(U2);
+
+	int iterLimit = 20;
+  double lambda = L, lambdaP=2*PI;
+  while ((fabs(lambda-lambdaP) > 1e-12 && --iterLimit>0)) {
+		sinLambda = sin(lambda); cosLambda = cos(lambda);
+    sinSigma = sqrt((cosU2*sinLambda) * (cosU2*sinLambda) + (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda));
+    if (sinSigma==0) return rb_float_new(0);  // co-incident points
+    cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda;
+    sigma = atan2(sinSigma, cosSigma);
+    sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
+    cosSqAlpha = 1 - sinAlpha*sinAlpha;
+    cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha;
+    if (isnan(cos2SigmaM)) cos2SigmaM = 0;  // equatorial line: cosSqAlpha=0 (§6)
+    C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
+    lambdaP = lambda;
+    lambda = L + (1-C) * f * sinAlpha * (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
+  }
+
+	if (iterLimit==0) return Qnil;  // formula failed to converge
+
+  double uSq = cosSqAlpha * (a*a - b*b) / (b*b);
+  double A = 1 + uSq/16384.0*(4096+uSq*(-768+uSq*(320-175*uSq)));
+  double B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
+  double deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM) -
+    B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
+
+	double s = b*A*(sigma-deltaSigma);
+	
+	return rb_float_new(s);
+}
+
+static VALUE point_from_lon_lat(VALUE self, VALUE rb_lon1, VALUE rb_lat1, VALUE rb_bearing, VALUE rb_distance, VALUE rb_a, VALUE rb_b) {
+	Check_Type(rb_lon1, T_FLOAT);
+	Check_Type(rb_lat1, T_FLOAT);
+	Check_Type(rb_bearing, T_FLOAT);
+	Check_Type(rb_distance, T_FLOAT);
+	Check_Type(rb_a, T_FLOAT);
+	Check_Type(rb_b, T_FLOAT);
+	
+	VALUE ret;
+
+	double lon1 = RFLOAT(rb_lon1)->value;
+	double lat1 = RFLOAT(rb_lat1)->value;
+	double brng = RFLOAT(rb_bearing)->value;
+	double s = RFLOAT(rb_distance)->value;
+	double a = RFLOAT(rb_a)->value;
+	double b = RFLOAT(rb_b)->value;
+	
+	double f = (a-b) / a;
+  double alpha1 = brng * DEG_TO_RAD;
+  double sinAlpha1 = sin(alpha1), cosAlpha1 = cos(alpha1);
+  
+  double tanU1 = (1-f) * tan(lat1 * DEG_TO_RAD);
+  double cosU1 = 1 / sqrt((1 + tanU1*tanU1)), sinU1 = tanU1*cosU1;
+  double sigma1 = atan2(tanU1, cosAlpha1);
+  double sinAlpha = cosU1 * sinAlpha1;
+  double cosSqAlpha = 1 - sinAlpha*sinAlpha;
+  double uSq = cosSqAlpha * (a*a - b*b) / (b*b);
+  double A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
+  double B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
+  
+  double sigma = s / (b*A), sigmaP = 2*PI;
+	double cos2SigmaM, sinSigma, deltaSigma, cosSigma;
+  while (fabs(sigma-sigmaP) > 1e-12) {
+    cos2SigmaM = cos(2*sigma1 + sigma);
+    sinSigma = sin(sigma), cosSigma = cos(sigma);
+    deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-
+      B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
+    sigmaP = sigma;
+    sigma = s / (b*A) + deltaSigma;
+  }
+
+  double tmp = sinU1*sinSigma - cosU1*cosSigma*cosAlpha1;
+  double lat2 = atan2(sinU1*cosSigma + cosU1*sinSigma*cosAlpha1, (1-f)*sqrt(sinAlpha*sinAlpha + tmp*tmp));
+  double lambda = atan2(sinSigma*sinAlpha1, cosU1*cosSigma - sinU1*sinSigma*cosAlpha1);
+  double C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
+  double L = lambda - (1-C) * f * sinAlpha * (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
+
+  double revAz = atan2(sinAlpha, -tmp);  // final bearing
+
+	ret = rb_ary_new2(2); /* [lon, lat] */
+	rb_ary_store(ret, 0, rb_float_new(lon1+L/DEG_TO_RAD));
+	rb_ary_store(ret, 1, rb_float_new(lat2/DEG_TO_RAD));
+
+	return ret;
+}
+
+void Init_grextras()
+{
+	rb_mVincenty = rb_define_module("Vincenty");
+	rb_define_module_function(rb_mVincenty, "distance", distance, 6);
+	rb_define_module_function(rb_mVincenty, "point_from_lon_lat", point_from_lon_lat, 6);
+	
+	rb_mPointInPoly = rb_define_module("PointInPoly");
+	rb_define_module_function(rb_mPointInPoly, "point_in_poly", point_in_poly, 3);
+}
+
+// end

data/lib/georuby-extras.rb

@@ -0,0 +1,46 @@
+require 'geo_ruby'
+require "#{File.dirname(__FILE__)}/../ext/grextras"
+
+module GeoRuby
+  module SimpleFeatures
+    class Point < Geometry
+    
+      alias_method :orig_ellipsoidal_distance, :ellipsoidal_distance
+
+      # Implementation of the Vincenty 'distance' formula to find the ellipsoidal distance between points
+      # As per implementation by Chris Veness (http://www.movable-type.co.uk/scripts/latlong-vincenty.html)
+      # Default a/b values are for the WGS84 ellipsoid - other values may be specified
+      def ellipsoidal_distance(point, a = 6378137.0, b = 6356752.3142)
+        Vincenty.distance(x.to_f, y.to_f, point.x.to_f, point.y.to_f, a.to_f, b.to_f)
+      end
+
+      # Implementation of the Vincenty 'direct' formula to find a point based on a bearing and distance
+      # As per implementation by Chris Veness (http://www.movable-type.co.uk/scripts/latlong-vincenty-direct.html)
+      # Default a/b values are for the WGS84 ellipsoid - other values may be specified
+      def point_at_bearing_and_distance(bearing=0.0, distance=0.0, a = 6378137.0, b = 6356752.3142)
+        Point.from_coordinates(Vincenty.point_from_lon_lat(lon.to_f,lat.to_f,bearing.to_f,distance.to_f,a.to_f,b.to_f))
+      end
+      
+    end
+    
+  
+    class LinearRing < LineString
+      def fast_contains?(point)
+        !!PointInPoly.point_in_poly(point.x.to_f, point.y.to_f, points)
+      end
+      
+      def slow_contains?(point_to_check)
+        c = 0
+        last = points[points.length - 1]
+
+        points.each do |point|
+          if (point.y > point_to_check.y) != (last.y > point_to_check.y)
+            c += 1 if point_to_check.x < (last.x - point.x) * (point_to_check.y - point.y) / (last.y / point.y) + point.x
+          end
+          last = point
+        end
+        ((c % 2) == 1) 
+      end
+    end
+  end
+end

data/test/test_pnpoly.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'test/unit'
+require 'geo_ruby'
+require "#{File.dirname(__FILE__)}/../lib/georuby-extras"
+
+class PointInPolyTest < Test::Unit::TestCase
+  
+  include GeoRuby::SimpleFeatures
+
+  def setup
+    @poly_points = [[-95.81394, 41.008889], [-95.8103490000001, 41.0089209999999], [-95.8109810000001, 41.0072869999999], [-95.8113760000001, 41.00503], [-95.812187, 41.0017499999999], [-95.818804, 41.0017539999999], [-95.8187930000001, 41.0031709999998], [-95.8186090000002, 41.0038159999999], [-95.8186070000002, 41.008026], [-95.8185370000001, 41.008341], [-95.8183790000001, 41.008529], [-95.8181140000002, 41.008707], [-95.8178770000002, 41.0088039999998], [-95.817137, 41.00881], [-95.8158390000001, 41.0088089999999], [-95.815024, 41.0088289999999], [-95.8146770000001, 41.008836], [-95.8141700000001, 41.0089859999998], [-95.81394, 41.008889]]
+
+    @in_points = [[-95.8169174194336, 41.0077548921441], [-95.8169174194336, 41.0065242578572], [-95.8161449432373, 41.0053259865994], [-95.8147716522217, 41.0043543993136], [-95.8134412765503, 41.0042248532598], [-95.8128833770752, 41.0051316702882], [-95.812668800354, 41.0062327884756], [-95.8130550384521, 41.0073015032386], [-95.8149433135986, 41.0080787394523], [-95.8169174194336, 41.0077548921441], [-95.8176898956299, 41.0056498458448], [-95.8179044723511, 41.0042572397971], [-95.8179044723511, 41.0032856367545], [-95.817174911499, 41.0025731187526], [-95.8152008056641, 41.0024111817688], [-95.8140420913696, 41.0028322170991], [-95.81627368927, 41.0046134906571], [-95.8176898956299, 41.0056498458448], [-95.8176898956299, 41.0056498458448], [-95.8179044723511, 41.0042572397971], [-95.8179044723511, 41.0032856367545], [-95.817174911499, 41.0025731187526], [-95.8152008056641, 41.0024111817688], [-95.8140420913696, 41.0028322170991], [-95.81627368927, 41.0046134906571], [-95.8176898956299, 41.0056498458448], [-95.8176898956299, 41.0056498458448], [-95.8179044723511, 41.0042572397971], [-95.8179044723511, 41.0032856367545], [-95.817174911499, 41.0025731187526], [-95.8152008056641, 41.0024111817688], [-95.8140420913696, 41.0028322170991], [-95.81627368927, 41.0046134906571], [-95.8176898956299, 41.0056498458448]]
+
+    @out_points = [[-95.8193635940552, 41.0129038758068], [-95.8218097686768, 41.0130657870063], [-95.8228826522827, 41.0119000174887], [-95.8237838745117, 41.0105399269802], [-95.8245992660522, 41.0094388807662], [-95.8248996734619, 41.0079168159972], [-95.8250713348389, 41.0057793890973], [-95.8250713348389, 41.0039009870114], [-95.8233976364136, 41.0047430359468], [-95.8213806152344, 41.0071071927528], [-95.8201789855957, 41.0094388807662], [-95.8179903030396, 41.0117057205636], [-95.8126258850098, 41.0110256768135], [-95.808162689209, 41.0107666106814], [-95.8079051971436, 41.0123209921941], [-95.8193635940552, 41.0129038758068], [-95.8236122131348, 41.003091314427], [-95.8249855041504, 41.0019253684299], [-95.8249855041504, 40.9997877471958], [-95.8235263824463, 40.9977796156103], [-95.8193635940552, 40.9971642082001], [-95.8149433135986, 40.9953179514964], [-95.8091926574707, 40.9967431366616], [-95.8089351654053, 41.0000468564923], [-95.8184623718262, 41.0002087992855], [-95.8212089538574, 41.0019253684299], [-95.8236122131348, 41.003091314427], [-95.8074331283569, 41.0099894061731], [-95.8079051971436, 41.0069776521105], [-95.8079051971436, 41.0044839451126], [-95.8078193664551, 41.0022168568629], [-95.8072185516357, 40.9995286368806], [-95.8069610595703, 40.9978120053149], [-95.8051586151123, 40.9979415639739], [-95.8033990859985, 40.9988808566362], [-95.8033990859985, 41.0025731187526], [-95.8074331283569, 41.0099894061731]]
+
+    @ring = LinearRing.from_coordinates(@poly_points)
+    # @polygon = Polygon.from_linear_rings([@ring])
+  end
+  
+  def test_in_points
+    @in_points.each_with_index do |coord, i|
+      point = Point.from_coordinates(coord)
+      assert_equal true, @ring.fast_contains?(point), "point with index #{i} should be in the ring"
+    end
+  end
+  
+  def test_out_points
+    @out_points.each_with_index do |coord, i|
+      point = Point.from_coordinates(coord)
+      assert_equal false, @ring.fast_contains?(point), "point with index #{i} should not be in the ring"
+    end
+  end
+end

data/test/test_vincenty.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'test/unit'
+require 'geo_ruby'
+require "#{File.dirname(__FILE__)}/../lib/georuby-extras"
+
+class GeoHashNativeTest < Test::Unit::TestCase
+  
+  include GeoRuby::SimpleFeatures
+
+  def setup
+    @home = Point.from_lon_lat(-76.511,39.024)
+    @nyc = Point.from_lon_lat(-74,40.6)
+  end
+  
+  def test_distance
+    assert_in_delta 277195.5104, @home.ellipsoidal_distance(@nyc), 0.001
+  end
+  
+  def test_orig_distance
+    assert_in_delta 277195.5104, @home.orig_ellipsoidal_distance(@nyc), 0.001
+  end
+
+  def test_bearing_from_point
+    dest = @home.point_at_bearing_and_distance(91.0, 130000.0)
+    assert_in_delta -75.0106, dest.x, 0.0001
+    assert_in_delta 38.9939, dest.y, 0.0001
+  end
+  
+  # This test is basically identical to those in georuby; to confirm compatibility
+  def test_point_distance
+    point1 = Point.from_x_y(0,0)
+    point2 = Point.from_x_y(3,4)
+    assert_equal(5,point1.euclidian_distance(point2))
+    
+    assert_in_delta(554058.924,point1.ellipsoidal_distance(point2),0.001)
+    assert_in_delta(554058.924,point1.orig_ellipsoidal_distance(point2),0.001)
+         
+    assert_in_delta(555811.68,point1.spherical_distance(point2),0.01)
+  end
+  
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: griffordson-georuby-extras
+version: !ruby/object:Gem::Version 
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- David Troy
+- Matt Griffith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-30 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: GeoRuby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id001
+description: Provides native implementations of Vincenty ellipsoidal functions and a native implementation of a ray casting algorithm to detect if a point is contained in a polygon.
+email: matt@griffith.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- Manifest.txt
+- README
+- History.txt
+files: 
+- ext/extconf.rb
+- ext/vincenty.c
+- lib/georuby-extras.rb
+- ext/pnpoly.c
+- ext/pnpoly.h
+- Manifest.txt
+- README
+- History.txt
+- test/test_vincenty.rb
+- test/test_pnpoly.rb
+has_rdoc: true
+homepage: http://github.com/griffordson/georuby-extras
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Native extensions and extra functions for the GeoRuby library.
+test_files: 
+- test/test_vincenty.rb
+- test/test_pnpoly.rb