rgeo 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65bbadb93580fd02234007e3ddfb888b4a38b4a7dfaa2d2b0d072d313b98adfb
-  data.tar.gz: b45a6f33bba7543ee86e0211a8b9d976cfef470222ab2adb9107f98b06818fff
+  metadata.gz: 0f0ded4953c3ad02eb5512ae8a9e8dd204e2008360678807a4ecea567c39533c
+  data.tar.gz: 577998a9cc566eba2146fb5a5e02e26db330e38f2b8518551b50c86fa8a7a027
 SHA512:
-  metadata.gz: 33d2c278eb28f697047c98091676fae7161f3b410375ba8b5042f51cb5e10158c69617d044a19d1c68b86c399439fc6a22e3bf39d8767b303194f1d64b191d41
-  data.tar.gz: 5e77a71cc569f9826fbac6d97ccd2aac46d2b7e37284cba950b6d8621ae04b52ed60c9a63bec7c5d227b3656e2015b1d3062eb1eaf15438de383209f1d6b291e
+  metadata.gz: 01f855c7553814054b662dbc9e84629f878ee71f642901cfb32f09386737cba9e0a86a2e91cbbe660515095d24cb09fb45d4b0ed680eac2f8194e0399eafe7c7
+  data.tar.gz: 810f5ef0b1b0f7c20d1a2b8845cdd443b9646aa564965d98d2b0d9b4bb25211e810cc73b780ff14e405dd824f5d7305a8a473a952e89e0f397406672f8fceab1

data/README.md

@@ -0,0 +1,144 @@
+## RGeo
+
+[![Gem Version](https://badge.fury.io/rb/rgeo.svg)](http://badge.fury.io/rb/rgeo)
+[![Build Status](https://travis-ci.org/rgeo/rgeo.svg?branch=master)](https://travis-ci.org/rgeo/rgeo)
+
+RGeo is a geospatial data library for Ruby.
+
+:warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning:
+
+This organization is looking for maintainers, see [this issue](https://github.com/rgeo/rgeo/issues/216) for more information.
+
+:warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning:
+
+### Summary
+
+RGeo is a key component for writing location-aware applications in the Ruby
+programming language. At its core is an implementation of the industry
+standard OGC Simple Features Specification, which provides data
+representations of geometric objects such as points, lines, and polygons,
+along with a set of geometric analysis operations. This makes it ideal for
+modeling geolocation data. It also supports a suite of optional add-on modules
+that provide various geolocation-related services.
+
+Use the core **rgeo** gem to:
+
+*   Represent spatial and geolocation data objects such as points, lines, and
+    polygons in your Ruby application.
+*   Perform standard spatial analysis operations such as finding
+    intersections, creating buffers, and computing lengths and areas.
+*   Correctly handle spherical geometry, and compute geographic projections
+    for map display and data analysis.
+*   Read and write location data in the WKT and WKB representations used by
+    spatial databases.
+
+
+### Dependencies
+
+RGeo works with the following Ruby implementations:
+
+*   MRI Ruby 2.3.0 or later.
+*   Partial support for JRuby 9.0 or later. The FFI implementation of GEOS
+    is available (ffi-geos gem required) but CAPI is not.
+*   See earlier versions for support for older ruby versions.
+
+Some features also require the following:
+
+*   GEOS 3.2 or later is highly recommended. (3.3.3 or later preferred.) Some
+    functions will not be available without it. This C/C++ library may be
+    available via your operating system's package manager (`sudo aptitude
+    install libgeos-dev` for debian based Linux distributions, `yum install geos geos-devel` for redhat based Linux distributions), or you can
+    download it from http://trac.osgeo.org/geos
+*   On some platforms, you should install the ffi-geos gem (version 1.2.0 or
+    later recommended.) JRuby requires this gem to link properly with Geos,
+    and Windows builds probably do as well.
+
+### Installation
+
+Install the RGeo gem:
+
+```sh
+gem install rgeo
+```
+
+or include it in your Gemfile:
+
+```ruby
+gem "rgeo"
+```
+
+If you are using proj.4 extensions, include  
+[`rgeo-proj4`](https://github.com/rgeo/rgeo-proj4):
+
+```ruby
+gem "rgeo-proj4"
+```
+
+
+### Extensions
+
+The [RGeo organization](https://github.com/rgeo) provides several gems that extend RGeo:
+
+#### [`rgeo-proj4`](https://github.com/rgeo/rgeo-proj4)
+
+Proj4 extensions
+
+#### [`rgeo-geojson`](https://github.com/rgeo/rgeo-geojson)
+
+Read and write GeoJSON
+
+#### [`rgeo-shapefile`](https://github.com/rgeo/rgeo-shapefile)
+
+Read ESRI shapefiles
+
+#### [`activerecord-postgis-adapter`](https://github.com/rgeo/activerecord-postgis-adapter)
+
+ActiveRecord connection adapter for PostGIS, based on postgresql (pg gem)
+
+#### [`activerecord-mysql2spatial-adapter`](https://github.com/rgeo/activerecord-mysql2spatial-adapter)
+
+ActiveRecord connection adapter for MySQL Spatial Extensions, based on mysql2
+
+#### [`activerecord-spatialite-adapter`](https://github.com/rgeo/activerecord-spatialite-adapter)
+
+ActiveRecord connection adapter for SpatiaLite, based on sqlite3 (*not maintained)
+
+
+### Development and support
+
+RDoc Documentation is available at https://www.rubydoc.info/gems/rgeo
+
+Contributions are welcome. Please read the 
+[Contributing guidelines](https://github.com/rgeo/rgeo/blob/master/CONTRIBUTING.md).
+
+Support may be available on the 
+[rgeo-users google group](https://groups.google.com/forum/#!forum/rgeo-users)
+or on [Stack Overflow](https://stackoverflow.com/questions/tagged/rgeo).
+
+
+### Acknowledgments
+
+RGeo was created by [Daniel Azuma](http://www.daniel-azuma.com).
+[Tee Parham](https://github.com/teeparham) is the current maintainer.
+
+Thanks to [Pirq](http://www.pirq.com) and [Neighborland](https://neighborland.com)
+for development support.
+
+Thanks to [Travis-CI](https://travis-ci.org) for CI testing.
+
+Thanks to [JetBrains](https://www.jetbrains.com/?from=rgeo) for RubyMine license.
+
+RGeo calls the GEOS library to handle most Cartesian geometric calculations,
+and the Proj4 library to handle projections and coordinate transformations.
+These libraries are maintained by the Open Source Geospatial Foundation; more
+information is available on [OSGeo's web site](http://www.osgeo.org).
+
+JRuby support is made possible by the ffi-geos (and upcoming ffi-proj4) gems,
+by [J Smith](https://github.com/dark-panda).
+
+
+### License
+
+Copyright (c) Daniel Azuma, Tee Parham
+
+[License](https://github.com/rgeo/rgeo/blob/master/LICENSE.txt)

data/ext/geos_c_impl/analysis.c

@@ -0,0 +1,78 @@
+/*
+  Analysis methos for GEOS wrapper
+*/
+
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include <ruby.h>
+#include <geos_c.h>
+
+#include "analysis.h"
+#include "factory.h"
+#include "errors.h"
+
+RGEO_BEGIN_C
+
+/*
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw? -> true or false
+ *
+ * Checks direction for a ring, returns +true+ if counter-clockwise, +false+
+ * otherwise.
+ */
+#ifdef RGEO_GEOS_SUPPORTS_ISCCW
+VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
+{
+
+  const RGeo_GeometryData* ring_data;
+  const GEOSCoordSequence* coord_seq;
+  char is_ccw;
+
+  rgeo_check_geos_object(ring);
+
+  ring_data = RGEO_GEOMETRY_DATA_PTR(ring);
+
+  coord_seq = GEOSGeom_getCoordSeq_r(ring_data->geos_context, ring_data->geom);
+  if (!coord_seq) { rb_raise(geos_error, "Could not retrieve CoordSeq from given ring."); }
+  if (!GEOSCoordSeq_isCCW_r(ring_data->geos_context, coord_seq, &is_ccw)) {
+    rb_raise(geos_error, "Could not determine if the CoordSeq is CCW.");
+  }
+
+  return is_ccw ? Qtrue : Qfalse;
+};
+#endif // RGEO_GEOS_SUPPORTS_ISCCW
+
+
+/**
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw_supported? -> true or false 
+ * 
+ * Checks if the RGEO_GEOS_SUPPORTS_ISCCW macro is defined, returns +true+
+ * if it is, +false+ otherwise
+ */
+VALUE rgeo_geos_analysis_supports_ccw(VALUE self)
+{
+  #ifdef RGEO_GEOS_SUPPORTS_ISCCW
+    return Qtrue;
+  #else
+    return Qfalse;
+  #endif
+}
+
+
+void rgeo_init_geos_analysis(RGeo_Globals* globals)
+{
+  VALUE geos_analysis_module;
+
+  geos_analysis_module = rb_define_module_under(globals->geos_module, "Analysis");
+  rb_define_singleton_method(geos_analysis_module, "ccw_supported?", rgeo_geos_analysis_supports_ccw, 0);
+  #ifdef RGEO_GEOS_SUPPORTS_ISCCW
+  rb_define_singleton_method(geos_analysis_module, "ccw?", rgeo_geos_analysis_ccw_p, 1);
+  #endif // RGEO_GEOS_SUPPORTS_ISCCW
+}
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/analysis.h

@@ -0,0 +1,42 @@
+/*
+  Analysis methos for GEOS wrapper
+*/
+
+#ifndef RGEO_GEOS_ANALYSIS_INCLUDED
+#define RGEO_GEOS_ANALYSIS_INCLUDED
+
+#include <ruby.h>
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include "factory.h"
+
+RGEO_BEGIN_C
+
+/*
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw? -> true or false
+ *
+ * Checks direction for a ring, returns +true+ if counter-clockwise, +false+
+ * otherwise.
+ */
+#ifdef RGEO_GEOS_SUPPORTS_CCW
+VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring);
+#endif // RGEO_GEOS_SUPPORTS_CCW
+
+/**
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw_supported? -> true or false 
+ * 
+ * Checks if the RGEO_GEOS_SUPPORTS_ISCCW macro is defined, returns +true+
+ * if it is, +false+ otherwise
+ */
+VALUE rgeo_geos_analysis_supports_ccw(VALUE self);
+
+void rgeo_init_geos_analysis(RGeo_Globals* globals);
+
+RGEO_END_C
+
+#endif // RGEO_GEOS_SUPPORTED
+
+#endif // RGEO_GEOS_ANALYSIS_INCLUDED

data/ext/geos_c_impl/errors.c

@@ -0,0 +1,35 @@
+
+#ifndef RGEO_GEOS_ERROS_INCLUDED
+#define RGEO_GEOS_ERROS_INCLUDED
+
+#include <ruby.h>
+
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include "errors.h"
+
+RGEO_BEGIN_C
+
+// Any error relative to RGeo.
+VALUE rgeo_error;
+// RGeo error specific to the GEOS implementation.
+VALUE geos_error;
+
+
+void rgeo_init_geos_errors() {
+  VALUE rgeo_module;
+  VALUE error_module;
+
+  rgeo_module = rb_define_module("RGeo");
+  error_module = rb_define_module_under(rgeo_module, "Error");
+  rgeo_error = rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
+  geos_error = rb_define_class_under(error_module, "GeosError", rgeo_error);
+}
+
+RGEO_END_C
+
+#endif // RGEO_GEOS_SUPPORTED
+
+#endif // RGEO_GEOS_ERROS_INCLUDED

data/ext/geos_c_impl/errors.h

@@ -0,0 +1,22 @@
+
+#ifndef RGEO_GEOS_ERROS_INCLUDED
+#define RGEO_GEOS_ERROS_INCLUDED
+
+#include <ruby.h>
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+RGEO_BEGIN_C
+
+// Any error relative to RGeo.
+extern VALUE rgeo_error;
+// RGeo error specific to the GEOS implementation.
+extern VALUE geos_error;
+
+void rgeo_init_geos_errors();
+
+RGEO_END_C
+
+#endif // RGEO_GEOS_SUPPORTED
+
+#endif // RGEO_GEOS_ERROS_INCLUDED

data/ext/geos_c_impl/extconf.rb

@@ -31,6 +31,7 @@ else
     have_func("GEOSPreparedContains_r", "geos_c.h")
     have_func("GEOSPreparedDisjoint_r", "geos_c.h")
     have_func("GEOSUnaryUnion_r", "geos_c.h")
+    have_func("GEOSCoordSeq_isCCW_r", "geos_c.h")
     have_func("rb_memhash", "ruby.h")
   end
 

data/ext/geos_c_impl/factory.c

@@ -16,6 +16,7 @@
 #include "line_string.h"
 #include "polygon.h"
 #include "geometry_collection.h"
+#include "errors.h"
 
 RGEO_BEGIN_C
 
@@ -576,10 +577,11 @@ RGeo_Globals* rgeo_init_geos_factory()
   VALUE wrapped_globals;
   VALUE feature_module;
 
+  rgeo_module = rb_define_module("RGeo");
+
   globals = ALLOC(RGeo_Globals);
 
   // Cache some modules so we don't have to look them up by name every time
-  rgeo_module = rb_define_module("RGeo");
   feature_module = rb_define_module_under(rgeo_module, "Feature");
   globals->feature_module = feature_module;
   globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
@@ -831,6 +833,13 @@ char rgeo_is_geos_object(VALUE obj)
   return (TYPE(obj) == T_DATA && RDATA(obj)->dfree == (RUBY_DATA_FUNC)destroy_geometry_func) ? 1 : 0;
 }
 
+void rgeo_check_geos_object(VALUE obj)
+{
+  if (!rgeo_is_geos_object(obj)) {
+    rb_raise(rgeo_error, "Not a GEOS Geometry object.");
+  }
+}
+
 
 const GEOSGeometry* rgeo_get_geos_geometry_safe(VALUE obj)
 {

data/ext/geos_c_impl/factory.h

@@ -10,7 +10,6 @@
 
 RGEO_BEGIN_C
 
-
 /*
   Per-interpreter globals.
   Most of these are cached references to commonly used classes, modules,
@@ -187,6 +186,11 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, V
 */
 char rgeo_is_geos_object(VALUE obj);
 
+/*
+  Raises a rgeo error if the object is not a GEOS Geometry implementation.
+*/
+void rgeo_check_geos_object(VALUE obj);
+
 /*
   Gets the underlying GEOS geometry for a given ruby object. Returns NULL
   if the given ruby object is not a GEOS geometry wrapper.

data/ext/geos_c_impl/main.c

@@ -2,7 +2,6 @@
   Main initializer for GEOS wrapper
 */
 
-
 #include "preface.h"
 
 #ifdef RGEO_GEOS_SUPPORTED
@@ -10,18 +9,20 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "errors.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
 #include "line_string.h"
 #include "polygon.h"
 #include "geometry_collection.h"
+#include "analysis.h"
 
 #endif
 
 RGEO_BEGIN_C
 
-
 void Init_geos_c_impl()
 {
 #ifdef RGEO_GEOS_SUPPORTED
@@ -33,6 +34,8 @@ void Init_geos_c_impl()
   rgeo_init_geos_line_string(globals);
   rgeo_init_geos_polygon(globals);
   rgeo_init_geos_geometry_collection(globals);
+  rgeo_init_geos_analysis(globals);
+  rgeo_init_geos_errors();
 #endif
 }
 

data/ext/geos_c_impl/preface.h

@@ -21,6 +21,9 @@
 #ifdef HAVE_GEOSUNARYUNION_R
 #define RGEO_GEOS_SUPPORTS_UNARYUNION
 #endif
+#ifdef HAVE_GEOSCOORDSEQ_ISCCW_R
+#define RGEO_GEOS_SUPPORTS_ISCCW
+#endif
 #ifdef HAVE_RB_MEMHASH
 #define RGEO_SUPPORTS_NEW_HASHING
 #endif

data/lib/rgeo.rb

@@ -75,12 +75,12 @@
 #   database, and based on the postgresql adapter. Available as the
 #   activerecord-postgis-adapter gem.
 
-require "rgeo/version"
-require "rgeo/error"
-require "rgeo/feature"
-require "rgeo/coord_sys"
-require "rgeo/impl_helper"
-require "rgeo/wkrep"
-require "rgeo/geos"
-require "rgeo/cartesian"
-require "rgeo/geographic"
+require_relative "rgeo/version"
+require_relative "rgeo/error"
+require_relative "rgeo/feature"
+require_relative "rgeo/coord_sys"
+require_relative "rgeo/impl_helper"
+require_relative "rgeo/wkrep"
+require_relative "rgeo/geos"
+require_relative "rgeo/cartesian"
+require_relative "rgeo/geographic"

data/lib/rgeo/cartesian.rb

@@ -6,10 +6,10 @@
 # the simple Cartesian implementation. It also provides a namespace
 # for Cartesian-specific analysis tools.
 
-require "rgeo/cartesian/calculations"
-require "rgeo/cartesian/feature_methods"
-require "rgeo/cartesian/feature_classes"
-require "rgeo/cartesian/factory"
-require "rgeo/cartesian/interface"
-require "rgeo/cartesian/bounding_box"
-require "rgeo/cartesian/analysis"
+require_relative "cartesian/calculations"
+require_relative "cartesian/feature_methods"
+require_relative "cartesian/feature_classes"
+require_relative "cartesian/factory"
+require_relative "cartesian/interface"
+require_relative "cartesian/bounding_box"
+require_relative "cartesian/analysis"

data/lib/rgeo/cartesian/analysis.rb

@@ -13,6 +13,28 @@ module RGeo
 
     module Analysis
       class << self
+        # Check orientation of a ring, returns `true` if it is counter-clockwise
+        # and false otherwise.
+        #
+        # If the factory used is GEOS based, use the GEOS implementation to
+        # check that. Otherwise, this methods falls back to `ring_direction`.
+        #
+        # == Note
+        #
+        # This method does not ensure a correct result for an invalid geometry.
+        # You should make sure your ring is valid beforehand using `is_ring?`
+        # if you are using a LineString, or directly `valid?` for a
+        # `linear_ring?`.
+        # This will be subject to changes in v3.
+        def ccw?(ring)
+          if RGeo::Geos.is_capi_geos?(ring) && RGeo::Geos::Analysis.ccw_supported?
+            RGeo::Geos::Analysis.ccw?(ring)
+          else
+            RGeo::Cartesian::Analysis.ring_direction(ring) == 1
+          end
+        end
+        alias counter_clockwise? ccw?
+
         # Given a LineString, which must be a ring, determine whether the
         # ring proceeds clockwise or counterclockwise.
         # Returns 1 for counterclockwise, or -1 for clockwise.

data/lib/rgeo/coord_sys.rb

@@ -6,12 +6,12 @@
 #
 # -----------------------------------------------------------------------------
 
-require "rgeo/coord_sys/cs/factories"
-require "rgeo/coord_sys/cs/entities"
-require "rgeo/coord_sys/cs/wkt_parser"
-require "rgeo/coord_sys/srs_database/entry"
-require "rgeo/coord_sys/srs_database/url_reader"
-require "rgeo/coord_sys/srs_database/sr_org"
+require_relative "coord_sys/cs/factories"
+require_relative "coord_sys/cs/entities"
+require_relative "coord_sys/cs/wkt_parser"
+require_relative "coord_sys/srs_database/entry"
+require_relative "coord_sys/srs_database/url_reader"
+require_relative "coord_sys/srs_database/sr_org"
 
 module RGeo
   # This module provides data structures and tools related to coordinate

data/lib/rgeo/error.rb

@@ -14,6 +14,10 @@ module RGeo
     class RGeoError < RuntimeError
     end
 
+    # RGeo error specific to the GEOS implementation.
+    class GeosError < RGeoError
+    end
+
     # The specified geometry is invalid
     class InvalidGeometry < RGeoError
     end

data/lib/rgeo/feature.rb

@@ -24,20 +24,20 @@
 # itself. The implementation should separately document any such
 # extensions that it may provide.
 
-require "rgeo/feature/factory"
-require "rgeo/feature/types"
-require "rgeo/feature/geometry"
-require "rgeo/feature/point"
-require "rgeo/feature/curve"
-require "rgeo/feature/line_string"
-require "rgeo/feature/linear_ring"
-require "rgeo/feature/line"
-require "rgeo/feature/surface"
-require "rgeo/feature/polygon"
-require "rgeo/feature/geometry_collection"
-require "rgeo/feature/multi_point"
-require "rgeo/feature/multi_curve"
-require "rgeo/feature/multi_line_string"
-require "rgeo/feature/multi_surface"
-require "rgeo/feature/multi_polygon"
-require "rgeo/feature/factory_generator"
+require_relative "feature/factory"
+require_relative "feature/types"
+require_relative "feature/geometry"
+require_relative "feature/point"
+require_relative "feature/curve"
+require_relative "feature/line_string"
+require_relative "feature/linear_ring"
+require_relative "feature/line"
+require_relative "feature/surface"
+require_relative "feature/polygon"
+require_relative "feature/geometry_collection"
+require_relative "feature/multi_point"
+require_relative "feature/multi_curve"
+require_relative "feature/multi_line_string"
+require_relative "feature/multi_surface"
+require_relative "feature/multi_polygon"
+require_relative "feature/factory_generator"

data/lib/rgeo/feature/linear_ring.rb

@@ -23,6 +23,16 @@ module RGeo
     module LinearRing
       include LineString
       extend Type
+
+      # Returns +true+ if the ring is oriented in a counter clockwise direction
+      # otherwise returns +false+.
+      #
+      # == Notes
+      #
+      # Not a standard SFS method for linear rings, but added for convenience.
+      def ccw?
+        raise Error::UnsupportedOperation, "Method LinearRing#ccw? not defined."
+      end
     end
   end
 end

data/lib/rgeo/geographic.rb

@@ -18,13 +18,13 @@
 # See the various class methods of Geographic for more information on
 # the behaviors of the factories they generate.
 
-require "rgeo/geographic/factory"
-require "rgeo/geographic/projected_window"
-require "rgeo/geographic/interface"
-require "rgeo/geographic/spherical_math"
-require "rgeo/geographic/spherical_feature_methods"
-require "rgeo/geographic/spherical_feature_classes"
-require "rgeo/geographic/proj4_projector"
-require "rgeo/geographic/simple_mercator_projector"
-require "rgeo/geographic/projected_feature_methods"
-require "rgeo/geographic/projected_feature_classes"
+require_relative "geographic/factory"
+require_relative "geographic/projected_window"
+require_relative "geographic/interface"
+require_relative "geographic/spherical_math"
+require_relative "geographic/spherical_feature_methods"
+require_relative "geographic/spherical_feature_classes"
+require_relative "geographic/proj4_projector"
+require_relative "geographic/simple_mercator_projector"
+require_relative "geographic/projected_feature_methods"
+require_relative "geographic/projected_feature_classes"

data/lib/rgeo/geographic/spherical_feature_classes.rb

@@ -47,6 +47,7 @@ module RGeo
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPolygonMethods
       include SphericalGeometryMethods
+      include SphericalPolygonMethods
     end
 
     class SphericalGeometryCollectionImpl # :nodoc:

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -130,5 +130,28 @@ module RGeo
         inject(0.0) { |sum, geom| sum + geom.length }
       end
     end
+
+    module SphericalPolygonMethods # :nodoc:
+      def centroid
+        return super unless num_interior_rings == 0
+
+        centroid_lat = 0.0
+        centroid_lng = 0.0
+        signed_area = 0.0
+
+        exterior_ring.points.each_cons(2) do |p0, p1|
+          area = (p0.x * p1.y) - (p1.x * p0.y)
+          signed_area += area
+          centroid_lat += (p0.x + p1.x) * area
+          centroid_lng += (p0.y + p1.y) * area
+        end
+
+        signed_area *= 0.5
+        centroid_lat /= (6.0 * signed_area)
+        centroid_lng /= (6.0 * signed_area)
+
+        RGeo::Geographic.spherical_factory.point(centroid_lat, centroid_lng)
+      end
+    end
   end
 end

data/lib/rgeo/geos.rb

@@ -21,24 +21,24 @@
 
 module RGeo
   module Geos
-    require "rgeo/geos/utils"
-    require "rgeo/geos/interface"
+    require_relative "geos/utils"
+    require_relative "geos/interface"
     begin
-      require "rgeo/geos/geos_c_impl"
+      require_relative "geos/geos_c_impl"
     rescue LoadError
       # continue
     end
     CAPI_SUPPORTED = RGeo::Geos.const_defined?(:CAPIGeometryMethods)
     if CAPI_SUPPORTED
-      require "rgeo/geos/capi_feature_classes"
-      require "rgeo/geos/capi_factory"
+      require_relative "geos/capi_feature_classes"
+      require_relative "geos/capi_factory"
     end
-    require "rgeo/geos/ffi_feature_methods"
-    require "rgeo/geos/ffi_feature_classes"
-    require "rgeo/geos/ffi_factory"
-    require "rgeo/geos/zm_feature_methods"
-    require "rgeo/geos/zm_feature_classes"
-    require "rgeo/geos/zm_factory"
+    require_relative "geos/ffi_feature_methods"
+    require_relative "geos/ffi_feature_classes"
+    require_relative "geos/ffi_factory"
+    require_relative "geos/zm_feature_methods"
+    require_relative "geos/zm_feature_classes"
+    require_relative "geos/zm_factory"
 
     # Determine ffi support.
     begin

data/lib/rgeo/geos/capi_factory.rb

@@ -297,10 +297,10 @@ module RGeo
         if (wkb_parser_ = _wkb_parser)
           wkb_parser_.parse(str_)
         else
-          if str_[0] =~ /[0-oa-fA-F]/
-            _parse_wkb_impl([str_].pack('H*'))
-          else
+          if str_[0] == "\x00" || str_[0] == "\x01"
             _parse_wkb_impl(str_)
+          else
+            _parse_wkb_impl([str_].pack('H*'))
           end
         end
       end

data/lib/rgeo/geos/capi_feature_classes.rb

@@ -72,6 +72,10 @@ module RGeo
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILinearRingMethods
+
+      def ccw?
+        RGeo::Cartesian::Analysis.ccw?(self)
+      end
     end
 
     class CAPILineImpl # :nodoc:

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -393,6 +393,10 @@ module RGeo
       def geometry_type
         Feature::LinearRing
       end
+
+      def ccw?
+        RGeo::Cartesian::Analysis.ccw?(self)
+      end
     end
 
     module FFILineMethods # :nodoc:

data/lib/rgeo/impl_helper.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "rgeo/impl_helper/utils"
-require "rgeo/impl_helper/math"
-require "rgeo/impl_helper/basic_geometry_methods"
-require "rgeo/impl_helper/basic_geometry_collection_methods"
-require "rgeo/impl_helper/basic_point_methods"
-require "rgeo/impl_helper/basic_line_string_methods"
-require "rgeo/impl_helper/basic_polygon_methods"
+require_relative "impl_helper/utils"
+require_relative "impl_helper/math"
+require_relative "impl_helper/basic_geometry_methods"
+require_relative "impl_helper/basic_geometry_collection_methods"
+require_relative "impl_helper/basic_point_methods"
+require_relative "impl_helper/basic_line_string_methods"
+require_relative "impl_helper/basic_polygon_methods"

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -114,6 +114,12 @@ module RGeo
         @elements.map(&:coordinates)
       end
 
+      def contains?(rhs)
+        return super unless Feature::Point === rhs
+
+        @elements.any? { |line| line.contains?(rhs) }
+      end
+
       private
 
       def add_boundary(hash, point)
@@ -171,12 +177,18 @@ module RGeo
           array << poly.exterior_ring unless poly.is_empty?
           array.concat(poly.interior_rings)
         end
-        factory.multilinestring(array)
+        factory.multi_line_string(array)
       end
 
       def coordinates
         @elements.map(&:coordinates)
       end
+
+      def contains?(rhs)
+        return super unless Feature::Point === rhs
+
+        @elements.any? { |poly| poly.contains?(rhs) }
+      end
     end
   end
 end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -87,8 +87,43 @@ module RGeo
         @points.map(&:coordinates)
       end
 
+      def contains?(rhs)
+        if Feature::Point === rhs
+          contains_point?(rhs)
+        else
+          raise(Error::UnsupportedOperation,
+                "Method LineString#contains? is only defined for Point")
+        end
+      end
+
       private
 
+      def contains_point?(point)
+        @points.each_cons(2) do |start_point, end_point|
+          return true if point_intersect_segment?(point, start_point, end_point)
+        end
+        false
+      end
+
+      def point_intersect_segment?(point, start_point, end_point)
+        return false unless point_collinear?(point, start_point, end_point)
+
+        if start_point.x != end_point.x
+          between_coordinate?(point.x, start_point.x, end_point.x)
+        else
+          between_coordinate?(point.y, start_point.y, end_point.y)
+        end
+      end
+
+      def point_collinear?(a, b, c)
+        (b.x - a.x) * (c.y - a.y) == (c.x - a.x) * (b.y - a.y)
+      end
+
+      def between_coordinate?(coord, start_coord, end_coord)
+        end_coord >= coord && coord >= start_coord ||
+          start_coord >= coord && coord >= end_coord
+      end
+
       def copy_state_from(obj)
         super
         @points = obj.points
@@ -137,6 +172,10 @@ module RGeo
         Feature::LinearRing
       end
 
+      def ccw?
+        RGeo::Cartesian::Analysis.ccw?(self)
+      end
+
       private
 
       def validate_geometry

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -79,8 +79,45 @@ module RGeo
         ([@exterior_ring] + @interior_rings).map(&:coordinates)
       end
 
+      def contains?(rhs)
+        if Feature::Point === rhs
+          contains_point?(rhs)
+        else
+          raise(Error::UnsupportedOperation,
+            "Method Polygon#contains? is only defined for Point"
+          )
+        end
+      end
+
       private
 
+      def contains_point?(point)
+        ring_encloses_point?(@exterior_ring, point) &&
+          !@interior_rings.any? do |exclusion|
+            ring_encloses_point?(exclusion, point, on_border_return: true)
+          end
+      end
+
+      def ring_encloses_point?(ring, point, on_border_return: false)
+        # This is an implementation of the ray casting algorithm, greatly inspired
+        # by https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html
+        # Since this algorithm does not handle point on edge, we check first if
+        # the ring is on the border.
+        # on_border_return is used for exclusion ring
+        return on_border_return if ring.contains?(point)
+        encloses_point = false
+        ring.points.each_cons(2) do |start_point, end_point|
+          next unless (point.y < end_point.y) != (point.y < start_point.y)
+
+          if point.x < (end_point.x - start_point.x) * (point.y - start_point.y) /
+                       (end_point.y - start_point.y) + start_point.x
+            encloses_point = !encloses_point
+          end
+        end
+        encloses_point
+      end
+
+
       def copy_state_from(obj)
         super
         @exterior_ring = obj.exterior_ring

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/lib/rgeo/wkrep.rb

@@ -21,7 +21,7 @@
 # To parse a byte string in WKB (well-known binary) format back into a
 # geometry object, use the WKRep::WKBParser class.
 
-require "rgeo/wkrep/wkt_parser"
-require "rgeo/wkrep/wkt_generator"
-require "rgeo/wkrep/wkb_parser"
-require "rgeo/wkrep/wkb_generator"
+require_relative "wkrep/wkt_parser"
+require_relative "wkrep/wkt_generator"
+require_relative "wkrep/wkb_parser"
+require_relative "wkrep/wkb_generator"

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
-- Daniel Azuma, Tee Parham
+- Daniel Azuma
+- Tee Parham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2020-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-geos
@@ -85,15 +86,23 @@ description: RGeo is a geospatial data library for Ruby. It provides an implemen
   standard spatial/geographic data storage systems such as PostGIS. A number of add-on
   modules are also available to help with writing location-based applications using
   Ruby-based frameworks such as Ruby On Rails.
-email: dazuma@gmail.com, parhameter@gmail.com
+email:
+- dazuma@gmail.com
+- parhameter@gmail.com
+- kfdoggett@gmail.com
 executables: []
 extensions:
 - ext/geos_c_impl/extconf.rb
 extra_rdoc_files: []
 files:
 - LICENSE.txt
+- README.md
+- ext/geos_c_impl/analysis.c
+- ext/geos_c_impl/analysis.h
 - ext/geos_c_impl/coordinates.c
 - ext/geos_c_impl/coordinates.h
+- ext/geos_c_impl/errors.c
+- ext/geos_c_impl/errors.h
 - ext/geos_c_impl/extconf.rb
 - ext/geos_c_impl/factory.c
 - ext/geos_c_impl/factory.h
@@ -181,7 +190,8 @@ files:
 - lib/rgeo/wkrep/wkt_generator.rb
 - lib/rgeo/wkrep/wkt_parser.rb
 homepage: https://github.com/rgeo/rgeo
-licenses: []
+licenses:
+- BSD-3-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -191,14 +201,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: RGeo is a geospatial data library for Ruby.