rbpip 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a5bd34943439cd36bd33032bdddf348e7f65fa9f
+  data.tar.gz: ea9b875eea013c1bfb2482daa54acbd50d4c11b5
+SHA512:
+  metadata.gz: 593d81c1ae7a50e7d07c7e07238655016a27257ed5bc4f9fef2c6e3dc4b02e4641e5cbae0a13c27e3e5ae982fa0debfb9e0acdd80698a7ac20a05f6b407bd1dc
+  data.tar.gz: 9605f5f9399676cd9a4523b56dc387bee8ee91c4903a4aa95f926f7fdde767e3f260e00d3f44f28bdcd7969ad0b04a55367c8646b4d84bab57d24ed9a2fa9215

data/ext/rbpip/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+extension_name = 'rbpip'
+dir_config(extension_name)
+
+create_makefile(extension_name)

data/ext/rbpip/rbpip.c

@@ -0,0 +1,125 @@
+#include "ruby.h"
+
+int pip(double poly[][2], int npoints, double xt, double yt) {
+    double xnew, ynew;
+    double xold, yold;
+    double x1, y1;
+    double x2, y2;
+    int i;
+    int inside = 0;
+
+    if (npoints < 3) return 0;
+
+    xold = poly[npoints-1][0];
+    yold = poly[npoints-1][1];
+
+    for (i = 0; i < npoints; i++) {
+        xnew = poly[i][0];
+        ynew = poly[i][1];
+
+        if (xnew > xold) {
+            x1 = xold;
+            x2 = xnew;
+            y1 = yold;
+            y2 = ynew;
+        } else {
+            x1 = xnew;
+            x2 = xold;
+            y1 = ynew;
+            y2 = yold;
+        }
+
+        if ((xnew < xt) == (xt <= xold) && /* edge "open" at left end */
+            (yt - y1) * (x2 - x1) <
+            (y2 - y1) * (xt - x1))
+        {
+            inside = !inside;
+        }
+
+        xold = xnew;
+        yold = ynew;
+    }
+
+    return inside;
+}
+
+static VALUE c_contains_point(VALUE self, VALUE args) {
+    VALUE respond_to = rb_intern("respond_to?");
+    
+    VALUE p_x;
+    VALUE p_y;
+    
+    switch (RARRAY_LEN(args)) {
+        case 1: {
+            VALUE arg = rb_ary_entry(args, 0);
+            VALUE responds_x = rb_funcall(arg, respond_to, 1, ID2SYM(rb_intern("x")));
+            VALUE responds_y = rb_funcall(arg, respond_to, 1, ID2SYM(rb_intern("y")));
+            
+            if (responds_x == Qtrue && responds_y == Qtrue) {
+                p_x = rb_funcall(arg, rb_intern("x"), 0);
+                p_y = rb_funcall(arg, rb_intern("y"), 0);
+            } else {
+                rb_raise(rb_eArgError, "Argument must respond to :x and :y.");
+            }
+            
+            break;
+        }
+        case 2: {
+            p_x = rb_ary_entry(args, 0);
+            p_y = rb_ary_entry(args, 1);
+            break;
+        }
+        default:
+            break;
+    }
+    
+    Check_Type(p_x, T_FLOAT);
+    Check_Type(p_y, T_FLOAT);
+    
+    VALUE polygon = Qnil;
+    
+    switch (TYPE(self)) {
+        case T_ARRAY: {
+            polygon = self;
+            break;
+        }
+        case T_OBJECT: {
+            VALUE points_id = rb_intern("points");
+            VALUE responds = rb_funcall(self, respond_to, 1, ID2SYM(points_id));
+            if (responds == Qtrue) polygon = rb_funcall(self, points_id, 0);
+            else rb_raise(rb_eTypeError, "Receiver does not respond to :points.");
+            break;
+        }
+        default:
+            rb_raise(rb_eTypeError, "Receiver is not a valid polygon.");
+            break;
+    }
+    
+    VALUE *poly_arr = RARRAY_PTR(polygon);
+    int poly_len = RARRAY_LEN(polygon);
+    if (poly_len < 3) rb_raise(rb_eTypeError, "Polygon must have at least 3 points");
+    
+    double x = NUM2DBL(p_x);
+    double y = NUM2DBL(p_y);
+    
+    //double *p_polygon = ALLOCA_N(double, 2 * poly_len);
+    double *p_polygon = (double *)malloc(sizeof(double)*2*poly_len);
+    
+    for (int i = 0; i < poly_len; i++) {
+        Check_Type(poly_arr[i], T_ARRAY);
+        VALUE *p = RARRAY_PTR(poly_arr[i]);
+        int p_len = RARRAY_LEN(poly_arr[i]);
+        if (p_len != 2) rb_raise(rb_eTypeError, "A polygon's points must contain only two values.");
+        Check_Type(p[0], T_FLOAT);
+        Check_Type(p[1], T_FLOAT);
+        p_polygon[i*2] = NUM2DBL(p[0]);
+        p_polygon[(i*2)+1] = NUM2DBL(p[1]);
+    }
+    
+    int res = pip((double (*)[2]) p_polygon, poly_len, x, y);
+    return res == 1 ? Qtrue : Qfalse;
+}
+
+void Init_rbpip() {
+    rb_define_method(rb_cObject, "contains_point?", RUBY_METHOD_FUNC(c_contains_point), -2);
+}

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: rbpip
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathaniel Symer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-06 00:00:00.000000000 Z
+dependencies: []
+description: Point-in-poly calcs for ruby. Extends Object.
+email: nate@natesymer.com
+executables: []
+extensions:
+- ext/rbpip/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/rbpip/extconf.rb
+- ext/rbpip/rbpip.c
+homepage: https://github.com/fhsjaagshs/rbpip
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Point-in-poly calcs for ruby.
+test_files: []