rgeo 1.1.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0760bb96d9e6654cf7cb09bd88b4a799f5ba249f573fd4c0484df2269ba50a0
-  data.tar.gz: 73928442258c96603367a340aac3cd1f93bed12471854e17cf14a712d58bb711
+  metadata.gz: 0f0ded4953c3ad02eb5512ae8a9e8dd204e2008360678807a4ecea567c39533c
+  data.tar.gz: 577998a9cc566eba2146fb5a5e02e26db330e38f2b8518551b50c86fa8a7a027
 SHA512:
-  metadata.gz: 961f639e7a8985cbcdff0b166cdf2923a6a8a4c4143e55b66a2769d5897abdacb42a6abceaa2b92c870f648e867154df996e55d5ab9a50bbbe70a6c4eef5c7bd
-  data.tar.gz: ff8f393c6c5ef195c790836a4ba844867d54c7cf4e8a7266d86c4bd0f44025a58a90debad8a77521288ef1ffe8db0906575e52de9a5dc49d5507fb03aee43765
+  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

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Makefile builder for GEOS wrapper
 #
 # -----------------------------------------------------------------------------
 def create_dummy_makefile
-  ::File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
+  File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
 end
 
-if ::RUBY_DESCRIPTION =~ /^jruby\s/
+if RUBY_DESCRIPTION =~ /^jruby\s/
   create_dummy_makefile
 else
   require "mkmf"
@@ -15,7 +17,7 @@ else
   geosconfig = with_config("geos-config") || find_executable("geos-config")
 
   if geosconfig
-    puts "Using GEOS compile configuration from %s" [geosconfig]
+    puts "Using GEOS compile configuration from #{geosconfig}"
     $INCFLAGS << " " << `#{geosconfig} --cflags`.strip
     geos_libs = `#{geosconfig} --clibs`.tr("\n", " ")
     geos_libs.split(/\s+/).each do |flag|
@@ -29,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");
@@ -623,10 +625,10 @@ RGeo_Globals* rgeo_init_geos_factory()
   rb_define_method(geos_factory_class, "_wkb_generator", method_get_wkb_generator, 0);
   rb_define_method(geos_factory_class, "_wkt_parser", method_get_wkt_parser, 0);
   rb_define_method(geos_factory_class, "_wkb_parser", method_get_wkb_parser, 0);
-  rb_define_method(geos_factory_class, "_read_for_marshal", method_factory_read_for_marshal, 1);
-  rb_define_method(geos_factory_class, "_write_for_marshal", method_factory_write_for_marshal, 1);
-  rb_define_method(geos_factory_class, "_read_for_psych", method_factory_read_for_psych, 1);
-  rb_define_method(geos_factory_class, "_write_for_psych", method_factory_write_for_psych, 1);
+  rb_define_method(geos_factory_class, "read_for_marshal", method_factory_read_for_marshal, 1);
+  rb_define_method(geos_factory_class, "write_for_marshal", method_factory_write_for_marshal, 1);
+  rb_define_method(geos_factory_class, "read_for_psych", method_factory_read_for_psych, 1);
+  rb_define_method(geos_factory_class, "write_for_psych", method_factory_write_for_psych, 1);
   rb_define_module_function(geos_factory_class, "_create", cmethod_factory_create, 7);
   rb_define_module_function(geos_factory_class, "_geos_version", cmethod_factory_geos_version, 0);
   rb_define_module_function(geos_factory_class, "_supports_unary_union?", cmethod_factory_supports_unary_union, 0);
@@ -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/geometry.c

@@ -756,7 +756,9 @@ static VALUE method_geometry_buffer_with_style(VALUE self, VALUE distance, VALUE
                                      GEOSBufferWithStyle_r(self_data->geos_context, self_geom,
                                                            rb_num2dbl(distance),
                                                            RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution,
-                                                           endCapStyle, joinStyle, mitreLimit),
+                                                           rb_num2int(endCapStyle),
+                                                           rb_num2int(joinStyle),
+                                                           rb_num2dbl(mitreLimit)),
                                      Qnil);
   }
   return result;
@@ -1053,6 +1055,21 @@ static VALUE method_geometry_invalid_reason(VALUE self)
   return result;
 }
 
+static VALUE method_geometry_point_on_surface(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), Qnil);
+  }
+  return result;
+}
+
 
 /**** INITIALIZATION FUNCTION ****/
 
@@ -1063,7 +1080,7 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
 
   geos_geometry_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryMethods");
 
-  rb_define_method(geos_geometry_methods, "_set_factory", method_geometry_set_factory, 1);
+  rb_define_method(geos_geometry_methods, "factory=", method_geometry_set_factory, 1);
   rb_define_method(geos_geometry_methods, "initialize_copy", method_geometry_initialize_copy, 1);
   rb_define_method(geos_geometry_methods, "_steal", method_geometry_steal, 1);
   rb_define_method(geos_geometry_methods, "initialized?", method_geometry_initialized_p, 0);
@@ -1107,6 +1124,7 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_methods, "sym_difference", method_geometry_sym_difference, 1);
   rb_define_method(geos_geometry_methods, "valid?", method_geometry_is_valid, 0);
   rb_define_method(geos_geometry_methods, "invalid_reason", method_geometry_invalid_reason, 0);
+  rb_define_method(geos_geometry_methods, "point_on_surface", method_geometry_point_on_surface, 0);
 }