rgeo 1.1.2 → 2.2.0

data/ext/geos_c_impl/geometry_collection.c

@@ -559,22 +559,6 @@ static VALUE method_multi_polygon_centroid(VALUE self)
 }
 
 
-static VALUE method_multi_polygon_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;
-}
-
-
 static VALUE cmethod_geometry_collection_create(VALUE module, VALUE factory, VALUE array)
 {
   return create_geometry_collection(module, GEOS_GEOMETRYCOLLECTION, factory, array);
@@ -648,7 +632,6 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   rb_define_method(geos_multi_polygon_methods, "geometry_type", method_multi_polygon_geometry_type, 0);
   rb_define_method(geos_multi_polygon_methods, "area", method_multi_polygon_area, 0);
   rb_define_method(geos_multi_polygon_methods, "centroid", method_multi_polygon_centroid, 0);
-  rb_define_method(geos_multi_polygon_methods, "point_on_surface", method_multi_polygon_point_on_surface, 0);
   rb_define_method(geos_multi_polygon_methods, "hash", method_multi_polygon_hash, 0);
   rb_define_method(geos_multi_polygon_methods, "coordinates", method_multi_polygon_coordinates, 0);
 }

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # RGeo is a spatial data library for Ruby. It focuses on the storage and
 # manipulation of spatial data types such as points, lines, and polygons.
 #
@@ -73,16 +75,12 @@
 #   database, and based on the postgresql adapter. Available as the
 #   activerecord-postgis-adapter gem.
 
-module RGeo
-end
-
-# Core modules
-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

@@ -1,25 +1,15 @@
-# -----------------------------------------------------------------------------
-#
-# Cartesian features for RGeo
-#
-# -----------------------------------------------------------------------------
+# frozen_string_literal: true
 
-module RGeo
-  # The Cartesian module is a gateway to implementations that use the
-  # Cartesian (i.e. flat) coordinate system. It provides convenient
-  # access to Cartesian factories such as the Geos implementation and
-  # the simple Cartesian implementation. It also provides a namespace
-  # for Cartesian-specific analysis tools.
+# The Cartesian module is a gateway to implementations that use the
+# Cartesian (i.e. flat) coordinate system. It provides convenient
+# access to Cartesian factories such as the Geos implementation and
+# the simple Cartesian implementation. It also provides a namespace
+# for Cartesian-specific analysis tools.
 
-  module Cartesian
-  end
-end
-
-# Implementation files.
-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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian geometric analysis utilities
@@ -11,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.
@@ -19,33 +43,33 @@ module RGeo
         # The return value is undefined if the object is not a ring, or
         # is not in a Cartesian coordinate system.
 
-        def ring_direction(ring_)
-          size_ = ring_.num_points - 1
-          return 0 if size_ == 0
+        def ring_direction(ring)
+          size = ring.num_points - 1
+          return 0 if size == 0
 
           # Extract unit-length segments from the ring.
-          segs_ = []
-          size_.times do |i_|
-            p0_ = ring_.point_n(i_)
-            p1_ = ring_.point_n(i_ + 1)
-            x_ = p1_.x - p0_.x
-            y_ = p1_.y - p0_.y
-            r_ = ::Math.sqrt(x_ * x_ + y_ * y_)
-            if r_ > 0.0
-              segs_ << x_ / r_ << y_ / r_
+          segs = []
+          size.times do |i|
+            p0 = ring.point_n(i)
+            p1 = ring.point_n(i + 1)
+            x = p1.x - p0.x
+            y = p1.y - p0.y
+            r = Math.sqrt(x * x + y * y)
+            if r > 0.0
+              segs << x / r << y / r
             else
-              size_ -= 1
+              size -= 1
             end
           end
-          segs_ << segs_[0] << segs_[1]
+          segs << segs[0] << segs[1]
 
           # Extract angles from the segments by subtracting the segments.
           # Note angles are represented as cos/sin pairs so we don't
           # have to calculate any trig functions.
-          angs_ = []
-          size_.times do |i_|
-            x0_, y0_, x1_, y1_ = segs_[i_ * 2, 4]
-            angs_ << x0_ * x1_ + y0_ * y1_ << x0_ * y1_ - x1_ * y0_
+          angs = []
+          size.times do |i|
+            x0, y0, x1, y1 = segs[i * 2, 4]
+            angs << x0 * x1 + y0 * y1 << x0 * y1 - x1 * y0
           end
 
           # Now add the angles and count revolutions.
@@ -54,12 +78,12 @@ module RGeo
           direction = nil
           sin = 0.0
           cos = 1.0
-          angs_.each_slice(2) do |(x, y)|
+          angs.each_slice(2) do |(x, y)|
             ready = y > 0.0 && (sin > 0.0 || sin == 0.0 && direction == -1) || y < 0.0 && (sin < 0.0 || sin == 0.0 && direction == 1)
             if y != 0.0
               s = sin * x + cos * y
               c = cos * x - sin * y
-              r = ::Math.sqrt(s * s + c * c)
+              r = Math.sqrt(s * s + c * c)
               sin = s / r
               cos = c / r
             end

data/lib/rgeo/cartesian/bounding_box.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Cartesian bounding box
@@ -24,9 +26,9 @@ module RGeo
       # You may also provide the same options available to
       # BoundingBox.new.
 
-      def self.create_from_points(point1_, point2_, opts_ = {})
-        factory_ = point1_.factory
-        new(factory_, opts_)._add_geometry(point1_).add(point2_)
+      def self.create_from_points(point1, point2, opts = {})
+        factory = point1.factory
+        new(factory, opts).add_geometry(point1).add(point2)
       end
 
       # Create a bounding box given a geometry to surround.
@@ -34,9 +36,9 @@ module RGeo
       # You may also provide the same options available to
       # BoundingBox.new.
 
-      def self.create_from_geometry(geom_, opts_ = {})
-        factory_ = geom_.factory
-        new(factory_, opts_)._add_geometry(geom_)
+      def self.create_from_geometry(geom, opts = {})
+        factory = geom.factory
+        new(factory, opts).add_geometry(geom)
       end
 
       # Create a new empty bounding box with the given factory.
@@ -56,23 +58,23 @@ module RGeo
       #   If true, ignore m coordinates even if the factory supports them.
       #   Default is false.
 
-      def initialize(factory_, opts_ = {})
-        @factory = factory_
-        if (values_ = opts_[:raw])
-          @has_z, @has_m, @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m = values_
+      def initialize(factory, opts = {})
+        @factory = factory
+        if (values = opts[:raw])
+          @has_z, @has_m, @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m = values
         else
-          @has_z = !opts_[:ignore_z] && factory_.property(:has_z_coordinate) ? true : false
-          @has_m = !opts_[:ignore_m] && factory_.property(:has_m_coordinate) ? true : false
+          @has_z = !opts[:ignore_z] && factory.property(:has_z_coordinate) ? true : false
+          @has_m = !opts[:ignore_m] && factory.property(:has_m_coordinate) ? true : false
           @min_x = @max_x = @min_y = @max_y = @min_z = @max_z = @min_m = @max_m = nil
         end
       end
 
-      def eql?(rhs_) # :nodoc:
-        rhs_.is_a?(BoundingBox) && @factory == rhs_.factory &&
-          @min_x == rhs_.min_x && @max_x == rhs_.max_x &&
-          @min_y == rhs_.min_y && @max_y == rhs_.max_y &&
-          @min_z == rhs_.min_z && @max_z == rhs_.max_z &&
-          @min_m == rhs_.min_m && @max_m == rhs_.max_m
+      def eql?(rhs) # :nodoc:
+        rhs.is_a?(BoundingBox) && @factory == rhs.factory &&
+          @min_x == rhs.min_x && @max_x == rhs.max_x &&
+          @min_y == rhs.min_y && @max_y == rhs.max_y &&
+          @min_z == rhs.min_z && @max_z == rhs.max_z &&
+          @min_m == rhs.min_m && @max_m == rhs.max_m
       end
       alias == eql?
 
@@ -196,10 +198,10 @@ module RGeo
 
       def min_point
         if @min_x
-          extras_ = []
-          extras_ << @min_z if @has_z
-          extras_ << @min_m if @has_m
-          @factory.point(@min_x, @min_y, *extras_)
+          extras = []
+          extras << @min_z if @has_z
+          extras << @min_m if @has_m
+          @factory.point(@min_x, @min_y, *extras)
         end
       end
 
@@ -208,10 +210,10 @@ module RGeo
 
       def max_point
         if @min_x
-          extras_ = []
-          extras_ << @max_z if @has_z
-          extras_ << @max_m if @has_m
-          @factory.point(@max_x, @max_y, *extras_)
+          extras = []
+          extras << @max_z if @has_z
+          extras << @max_m if @has_m
+          @factory.point(@max_x, @max_y, *extras)
         end
       end
 
@@ -219,16 +221,16 @@ module RGeo
       # object, which may be a geometry or another bounding box.
       # Returns self.
 
-      def add(geometry_)
-        case geometry_
+      def add(geometry)
+        case geometry
         when BoundingBox
-          add(geometry_.min_point)
-          add(geometry_.max_point)
+          add(geometry.min_point)
+          add(geometry.max_point)
         when Feature::Geometry
-          if geometry_.factory == @factory
-            _add_geometry(geometry_)
+          if geometry.factory == @factory
+            add_geometry(geometry)
           else
-            _add_geometry(Feature.cast(geometry_, @factory))
+            add_geometry(Feature.cast(geometry, @factory))
           end
         end
         self
@@ -241,23 +243,23 @@ module RGeo
 
       def to_geometry
         if @min_x
-          extras_ = []
-          extras_ << @min_z if @has_z
-          extras_ << @min_m if @has_m
-          point_min_ = @factory.point(@min_x, @min_y, *extras_)
+          extras = []
+          extras << @min_z if @has_z
+          extras << @min_m if @has_m
+          point_min = @factory.point(@min_x, @min_y, *extras)
           if infinitesimal?
-            point_min_
+            point_min
           else
-            extras_ = []
-            extras_ << @max_z if @has_z
-            extras_ << @max_m if @has_m
-            point_max_ = @factory.point(@max_x, @max_y, *extras_)
+            extras = []
+            extras << @max_z if @has_z
+            extras << @max_m if @has_m
+            point_max = @factory.point(@max_x, @max_y, *extras)
             if degenerate?
-              @factory.line(point_min_, point_max_)
+              @factory.line(point_min, point_max)
             else
-              @factory.polygon(@factory.linear_ring([point_min_,
-                                                     @factory.point(@max_x, @min_y, *extras_), point_max_,
-                                                     @factory.point(@min_x, @max_y, *extras_), point_min_]))
+              @factory.polygon(@factory.linear_ring([point_min,
+                                                     @factory.point(@max_x, @min_y, *extras), point_max,
+                                                     @factory.point(@min_x, @max_y, *extras), point_min]))
             end
           end
         else
@@ -277,18 +279,18 @@ module RGeo
       #   Ignore the M coordinate when testing, even if both objects
       #   have M. Default is false.
 
-      def contains?(rhs_, opts_ = {})
-        if Feature::Geometry === rhs_
-          contains?(BoundingBox.new(@factory).add(rhs_))
-        elsif rhs_.empty?
+      def contains?(rhs, opts = {})
+        if Feature::Geometry === rhs
+          contains?(BoundingBox.new(@factory).add(rhs))
+        elsif rhs.empty?
           true
         elsif empty?
           false
-        elsif @min_x > rhs_.min_x || @max_x < rhs_.max_x || @min_y > rhs_.min_y || @max_y < rhs_.max_y
+        elsif @min_x > rhs.min_x || @max_x < rhs.max_x || @min_y > rhs.min_y || @max_y < rhs.max_y
           false
-        elsif @has_m && rhs_.has_m && !opts_[:ignore_m] && (@min_m > rhs_.min_m || @max_m < rhs_.max_m)
+        elsif @has_m && rhs.has_m && !opts[:ignore_m] && (@min_m > rhs.min_m || @max_m < rhs.max_m)
           false
-        elsif @has_z && rhs_.has_z && !opts_[:ignore_z] && (@min_z > rhs_.min_z || @max_z < rhs_.max_z)
+        elsif @has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z)
           false
         else
           true
@@ -309,7 +311,7 @@ module RGeo
       #   greater than this factor, the bounding box is divided only in
       #   half instead of fourths.
 
-      def subdivide(opts_ = {})
+      def subdivide(opts = {})
         return [] if empty?
         if infinitesimal?
           return [
@@ -317,17 +319,17 @@ module RGeo
                                             @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
           ]
         end
-        factor_ = opts_[:bisect_factor]
-        factor_ ||= 1 if degenerate?
-        if factor_
-          if x_span > y_span * factor_
+        factor = opts[:bisect_factor]
+        factor ||= 1 if degenerate?
+        if factor
+          if x_span > y_span * factor
             return [
               BoundingBox.new(@factory, raw: [@has_z, @has_m,
                                               @min_x, center_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
               BoundingBox.new(@factory, raw: [@has_z, @has_m,
                                               center_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
             ]
-          elsif y_span > x_span * factor_
+          elsif y_span > x_span * factor
             return [
               BoundingBox.new(@factory, raw: [@has_z, @has_m,
                                               @min_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
@@ -348,49 +350,51 @@ module RGeo
         ]
       end
 
-      def _add_geometry(geometry_) # :nodoc:
-        case geometry_
+      def add_geometry(geometry)
+        case geometry
         when Feature::Point
-          _add_point(geometry_)
+          add_point(geometry)
         when Feature::LineString
-          geometry_.points.each { |p_| _add_point(p_) }
+          geometry.points.each { |p| add_point(p) }
         when Feature::Polygon
-          geometry_.exterior_ring.points.each { |p_| _add_point(p_) }
+          geometry.exterior_ring.points.each { |p| add_point(p) }
         when Feature::MultiPoint
-          geometry_.each { |p_| _add_point(p_) }
+          geometry.each { |p| add_point(p) }
         when Feature::MultiLineString
-          geometry_.each { |line_| line_.points.each { |p_| _add_point(p_) } }
+          geometry.each { |line| line.points.each { |p| add_point(p) } }
         when Feature::MultiPolygon
-          geometry_.each { |poly_| poly_.exterior_ring.points.each { |p_| _add_point(p_) } }
+          geometry.each { |poly| poly.exterior_ring.points.each { |p| add_point(p) } }
         when Feature::GeometryCollection
-          geometry_.each { |g_| _add_geometry(g_) }
+          geometry.each { |g| add_geometry(g) }
         end
         self
       end
 
-      def _add_point(point_) # :nodoc:
+      private
+
+      def add_point(point)
         if @min_x
-          x_ = point_.x
-          @min_x = x_ if x_ < @min_x
-          @max_x = x_ if x_ > @max_x
-          y_ = point_.y
+          x = point.x
+          @min_x = x if x < @min_x
+          @max_x = x if x > @max_x
+          y_ = point.y
           @min_y = y_ if y_ < @min_y
           @max_y = y_ if y_ > @max_y
           if @has_z
-            z_ = point_.z
+            z_ = point.z
             @min_z = z_ if z_ < @min_z
             @max_z = z_ if z_ > @max_z
           end
           if @has_m
-            m_ = point_.m
+            m_ = point.m
             @min_m = m_ if m_ < @min_m
             @max_m = m_ if m_ > @max_m
           end
         else
-          @min_x = @max_x = point_.x
-          @min_y = @max_y = point_.y
-          @min_z = @max_z = point_.z if @has_z
-          @min_m = @max_m = point_.m if @has_m
+          @min_x = @max_x = point.x
+          @min_y = @max_y = point.y
+          @min_z = @max_z = point.z if @has_z
+          @min_m = @max_m = point.m if @has_m
         end
       end
     end