rgeo 3.0.0.pre.rc.3 → 3.0.0

data/ext/geos_c_impl/line_string.c

@@ -250,6 +250,7 @@ method_line_string_project_point(VALUE self, VALUE point)
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   const GEOSGeometry* geos_point;
+  int state = 0;
 
   double location;
 
@@ -258,8 +259,12 @@ method_line_string_project_point(VALUE self, VALUE point)
   self_geom = self_data->geom;
 
   if (self_geom && point) {
-    geos_point =
-      rgeo_convert_to_geos_geometry(factory, point, rgeo_geos_point_class);
+    geos_point = rgeo_convert_to_geos_geometry(
+      factory, point, rgeo_geos_point_class, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
+
     location = GEOSProject(self_geom, geos_point);
     result = DBL2NUM(location);
   }
@@ -392,7 +397,6 @@ method_line_hash(VALUE self)
 static GEOSCoordSequence*
 coord_seq_from_array(VALUE factory, VALUE array, char close)
 {
-  RGeo_FactoryData* factory_data;
   VALUE point_type;
   unsigned int len;
   char has_z;
@@ -404,9 +408,9 @@ coord_seq_from_array(VALUE factory, VALUE array, char close)
   const GEOSCoordSequence* entry_cs;
   double x;
   GEOSCoordSequence* coord_seq;
+  int state = 0;
 
   Check_Type(array, T_ARRAY);
-  factory_data = RGEO_FACTORY_DATA_PTR(factory);
   point_type = rgeo_feature_point_module;
   len = (unsigned int)RARRAY_LEN(array);
   has_z = (char)(RGEO_FACTORY_DATA_PTR(factory)->flags &
@@ -418,22 +422,26 @@ coord_seq_from_array(VALUE factory, VALUE array, char close)
   }
   for (i = 0; i < len; ++i) {
     good = 0;
+
     entry_geom = rgeo_convert_to_geos_geometry(
-      factory, rb_ary_entry(array, i), point_type);
-    if (entry_geom) {
-      entry_cs = GEOSGeom_getCoordSeq(entry_geom);
-      if (entry_cs) {
-        if (GEOSCoordSeq_getX(entry_cs, 0, &x)) {
-          coords[i * dims] = x;
-          if (GEOSCoordSeq_getY(entry_cs, 0, &x)) {
-            coords[i * dims + 1] = x;
-            good = 1;
-            if (has_z) {
-              if (GEOSCoordSeq_getZ(entry_cs, 0, &x)) {
-                coords[i * dims + 2] = x;
-              } else {
-                good = 0;
-              }
+      factory, rb_ary_entry(array, i), point_type, &state);
+    if (state) {
+      FREE(coords);
+      rb_jump_tag(state);
+    }
+
+    entry_cs = GEOSGeom_getCoordSeq(entry_geom);
+    if (entry_cs) {
+      if (GEOSCoordSeq_getX(entry_cs, 0, &x)) {
+        coords[i * dims] = x;
+        if (GEOSCoordSeq_getY(entry_cs, 0, &x)) {
+          coords[i * dims + 1] = x;
+          good = 1;
+          if (has_z) {
+            if (GEOSCoordSeq_getZ(entry_cs, 0, &x)) {
+              coords[i * dims + 2] = x;
+            } else {
+              good = 0;
             }
           }
         }
@@ -474,13 +482,11 @@ cmethod_create_line_string(VALUE module, VALUE factory, VALUE array)
 {
   VALUE result;
   GEOSCoordSequence* coord_seq;
-  RGeo_FactoryData* factory_data;
   GEOSGeometry* geom;
 
   result = Qnil;
   coord_seq = coord_seq_from_array(factory, array, 0);
   if (coord_seq) {
-    factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLineString(coord_seq);
     if (geom) {
       result =
@@ -495,13 +501,11 @@ cmethod_create_linear_ring(VALUE module, VALUE factory, VALUE array)
 {
   VALUE result;
   GEOSCoordSequence* coord_seq;
-  RGeo_FactoryData* factory_data;
   GEOSGeometry* geom;
 
   result = Qnil;
   coord_seq = coord_seq_from_array(factory, array, 1);
   if (coord_seq) {
-    factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLinearRing(coord_seq);
     if (geom) {
       result =
@@ -549,25 +553,31 @@ cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE end)
   const GEOSGeometry* end_geom;
   GEOSCoordSequence* coord_seq;
   GEOSGeometry* geom;
+  int state = 0;
 
   result = Qnil;
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
   has_z = (char)(factory_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   point_type = rgeo_feature_point_module;
 
-  start_geom = rgeo_convert_to_geos_geometry(factory, start, point_type);
-  if (start_geom) {
-    end_geom = rgeo_convert_to_geos_geometry(factory, end, point_type);
-    if (end_geom) {
-      coord_seq = GEOSCoordSeq_create(2, 3);
-      if (coord_seq) {
-        populate_geom_into_coord_seq(start_geom, coord_seq, 0, has_z);
-        populate_geom_into_coord_seq(end_geom, coord_seq, 1, has_z);
-        geom = GEOSGeom_createLineString(coord_seq);
-        if (geom) {
-          result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_class);
-        }
-      }
+  start_geom =
+    rgeo_convert_to_geos_geometry(factory, start, point_type, &state);
+  if (state) {
+    rb_jump_tag(state);
+  }
+
+  end_geom = rgeo_convert_to_geos_geometry(factory, end, point_type, &state);
+  if (state) {
+    rb_jump_tag(state);
+  }
+
+  coord_seq = GEOSCoordSeq_create(2, 3);
+  if (coord_seq) {
+    populate_geom_into_coord_seq(start_geom, coord_seq, 0, has_z);
+    populate_geom_into_coord_seq(end_geom, coord_seq, 1, has_z);
+    geom = GEOSGeom_createLineString(coord_seq);
+    if (geom) {
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_class);
     }
   }
 

data/ext/geos_c_impl/point.c

@@ -208,12 +208,10 @@ VALUE
 rgeo_create_geos_point(VALUE factory, double x, double y, double z)
 {
   VALUE result;
-  RGeo_FactoryData* factory_data;
   GEOSCoordSequence* coord_seq;
   GEOSGeometry* geom;
 
   result = Qnil;
-  factory_data = RGEO_FACTORY_DATA_PTR(factory);
   coord_seq = GEOSCoordSeq_create(1, 3);
   if (coord_seq) {
     if (GEOSCoordSeq_setX(coord_seq, 0, x)) {

data/ext/geos_c_impl/polygon.c

@@ -237,27 +237,23 @@ cmethod_create(VALUE module,
                VALUE exterior,
                VALUE interior_array)
 {
-  RGeo_FactoryData* factory_data;
   VALUE linear_ring_type;
   GEOSGeometry* exterior_geom;
   unsigned int len;
   GEOSGeometry** interior_geoms;
   unsigned int actual_len;
   unsigned int i;
+  unsigned int j;
   GEOSGeometry* interior_geom;
   GEOSGeometry* polygon;
   int state = 0;
 
   Check_Type(interior_array, T_ARRAY);
-  factory_data = RGEO_FACTORY_DATA_PTR(factory);
   linear_ring_type = rgeo_feature_linear_ring_module;
   exterior_geom = rgeo_convert_to_detached_geos_geometry(
     exterior, factory, linear_ring_type, NULL, &state);
   if (state) {
-    rb_exc_raise(rb_errinfo());
-  }
-  if (!exterior_geom) {
-    return Qnil;
+    rb_jump_tag(state);
   }
 
   len = (unsigned int)RARRAY_LEN(interior_array);
@@ -271,12 +267,15 @@ cmethod_create(VALUE module,
                                                linear_ring_type,
                                                NULL,
                                                &state);
-      if (interior_geom) {
-        interior_geoms[actual_len++] = interior_geom;
-      }
       if (state) {
-        break;
+        for (j = 0; j < i; j++) {
+          GEOSGeom_destroy(interior_geoms[j]);
+        }
+        GEOSGeom_destroy(exterior_geom);
+        FREE(interior_geoms);
+        rb_jump_tag(state);
       }
+      interior_geoms[actual_len++] = interior_geom;
     }
     if (len == actual_len) {
       polygon =
@@ -295,7 +294,7 @@ cmethod_create(VALUE module,
   }
   GEOSGeom_destroy(exterior_geom);
   if (state) {
-    rb_exc_raise(rb_errinfo());
+    rb_jump_tag(state);
   }
   return Qnil;
 }

data/ext/geos_c_impl/polygon.h

@@ -18,7 +18,7 @@ void
 rgeo_init_geos_polygon();
 
 /*
-  Comopares the values of two GEOS polygons. The two given geometries MUST
+  Compares the values of two GEOS polygons. The two given geometries MUST
   be polygon types.
   Returns Qtrue if the polygons are equal, Qfalse if they are inequal, or
   Qnil if an error occurs.

data/ext/geos_c_impl/ruby_more.c

@@ -55,6 +55,13 @@ rb_protect_funcall(VALUE recv, ID mid, int* state, int n, ...)
   return rb_protect(inner_funcall, (VALUE)&args, state);
 }
 
+VALUE
+rb_exc_raise_value(VALUE exc)
+{
+  rb_exc_raise(exc);
+  return Qnil;
+}
+
 RGEO_END_C
 
 #endif

data/ext/geos_c_impl/ruby_more.h

@@ -12,6 +12,14 @@ RGEO_BEGIN_C
 VALUE
 rb_protect_funcall(VALUE recv, ID mid, int* state, int n, ...);
 
+/*
+  Raises an error based on the exception passed in, but also returns
+  a VALUE rather than void. This is so we can pass it into rb_protect
+  without getting type mismatch warnings.
+*/
+VALUE
+rb_exc_raise_value(VALUE exc);
+
 RGEO_END_C
 
 #endif

data/lib/rgeo/cartesian/analysis.rb

@@ -10,7 +10,6 @@ module RGeo
   module Cartesian
     # This provides includes some spatial analysis algorithms supporting
     # Cartesian data.
-
     module Analysis
       class << self
         # Check orientation of a ring, returns `true` if it is counter-clockwise
@@ -79,8 +78,11 @@ module RGeo
           sin = 0.0
           cos = 1.0
           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
+            ready = y > 0.0 &&
+              (sin > 0.0 || sin == 0 && direction == -1) ||
+              y < 0.0 &&
+              (sin < 0.0 || sin == 0 && direction == 1)
+            unless y == 0
               s = sin * x + cos * y
               c = cos * x - sin * y
               r = Math.sqrt(s * s + c * c)

data/lib/rgeo/cartesian/bounding_box.rb

@@ -19,8 +19,40 @@ module RGeo
     # adding the geometries to it. You may then query it for the bounds,
     # or use it to determine whether it encloses other geometries or
     # bounding boxes.
-
     class BoundingBox
+      # Returns the bounding box's factory.
+      attr_reader :factory
+
+      # Returns true if this bounding box tracks Z coordinates.
+      attr_reader :has_z
+
+      # Returns true if this bounding box tracks M coordinates.
+      attr_reader :has_m
+
+      # Returns the minimum X, or nil if this bounding box is empty.
+      attr_reader :min_x
+
+      # Returns the maximum X, or nil if this bounding box is empty.
+      attr_reader :max_x
+
+      # Returns the minimum Y, or nil if this bounding box is empty.
+      attr_reader :min_y
+
+      # Returns the maximum Y, or nil if this bounding box is empty.
+      attr_reader :max_y
+
+      # Returns the minimum Z, or nil if this bounding box is empty.
+      attr_reader :min_z
+
+      # Returns the maximum Z, or nil if this bounding box is empty.
+      attr_reader :max_z
+
+      # Returns the minimum M, or nil if this bounding box is empty.
+      attr_reader :min_m
+
+      # Returns the maximum M, or nil if this bounding box is empty.
+      attr_reader :max_m
+
       # Create a bounding box given two corner points.
       # The bounding box will be given the factory of the first point.
       # You may also provide the same options available to
@@ -69,19 +101,15 @@ module RGeo
         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?(other) # :nodoc:
+        other.is_a?(BoundingBox) && @factory == other.factory &&
+          @min_x == other.min_x && @max_x == other.max_x &&
+          @min_y == other.min_y && @max_y == other.max_y &&
+          @min_z == other.min_z && @max_z == other.max_z &&
+          @min_m == other.min_m && @max_m == other.max_m
       end
       alias == eql?
 
-      # Returns the bounding box's factory.
-
-      attr_reader :factory
-
       # Returns true if this bounding box is still empty.
 
       def empty?
@@ -105,22 +133,6 @@ module RGeo
         @min_x && (@min_x == @max_x || @min_y == @max_y)
       end
 
-      # Returns true if this bounding box tracks Z coordinates.
-
-      attr_reader :has_z
-
-      # Returns true if this bounding box tracks M coordinates.
-
-      attr_reader :has_m
-
-      # Returns the minimum X, or nil if this bounding box is empty.
-
-      attr_reader :min_x
-
-      # Returns the maximum X, or nil if this bounding box is empty.
-
-      attr_reader :max_x
-
       # Returns the midpoint X, or nil if this bounding box is empty.
 
       def center_x
@@ -133,14 +145,6 @@ module RGeo
         @max_x ? @max_x - @min_x : 0
       end
 
-      # Returns the minimum Y, or nil if this bounding box is empty.
-
-      attr_reader :min_y
-
-      # Returns the maximum Y, or nil if this bounding box is empty.
-
-      attr_reader :max_y
-
       # Returns the midpoint Y, or nil if this bounding box is empty.
 
       def center_y
@@ -153,14 +157,6 @@ module RGeo
         @max_y ? @max_y - @min_y : 0
       end
 
-      # Returns the minimum Z, or nil if this bounding box is empty.
-
-      attr_reader :min_z
-
-      # Returns the maximum Z, or nil if this bounding box is empty.
-
-      attr_reader :max_z
-
       # Returns the midpoint Z, or nil if this bounding box is empty or has no Z.
 
       def center_z
@@ -170,16 +166,12 @@ module RGeo
       # Returns the Z span, 0 if this bounding box is empty, or nil if it has no Z.
 
       def z_span
-        @has_z ? (@max_z ? @max_z - @min_z : 0) : nil
-      end
+        return unless @has_z
 
-      # Returns the minimum M, or nil if this bounding box is empty.
-
-      attr_reader :min_m
+        return 0 unless @max_z
 
-      # Returns the maximum M, or nil if this bounding box is empty.
-
-      attr_reader :max_m
+        @max_z - @min_z
+      end
 
       # Returns the midpoint M, or nil if this bounding box is empty or has no M.
 
@@ -190,31 +182,37 @@ module RGeo
       # Returns the M span, 0 if this bounding box is empty, or nil if it has no M.
 
       def m_span
-        @has_m ? (@max_m ? @max_m - @min_m : 0) : nil
+        return unless @has_m
+
+        return 0 unless @max_m
+
+        @max_m - @min_m
       end
 
       # Returns a point representing the minimum extent in all dimensions,
       # or nil if this bounding box is empty.
 
       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)
-        end
+        return unless @min_x
+
+        extras = []
+        extras << @min_z if @has_z
+        extras << @min_m if @has_m
+
+        @factory.point(@min_x, @min_y, *extras)
       end
 
       # Returns a point representing the maximum extent in all dimensions,
       # or nil if this bounding box is empty.
 
       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)
-        end
+        return unless @min_x
+
+        extras = []
+        extras << @max_z if @has_z
+        extras << @max_m if @has_m
+
+        @factory.point(@max_x, @max_y, *extras)
       end
 
       # Adjusts the extents of this bounding box to encompass the given
@@ -280,21 +278,18 @@ module RGeo
       #   have M. Default is false.
 
       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
-          false
-        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) # rubocop:disable Style/IfWithBooleanLiteralBranches
-          false
-        else
-          true
-        end
+        return contains?(BoundingBox.new(@factory).add(rhs)) if Feature::Geometry === rhs
+
+        return true if rhs.empty?
+
+        return false if empty?
+
+        cmp_xymz =
+          (@min_x > rhs.min_x || @max_x < rhs.max_x || @min_y > rhs.min_y || @max_y < rhs.max_y) ||
+          (@has_m && rhs.has_m && !opts[:ignore_m] && (@min_m > rhs.min_m || @max_m < rhs.max_m)) ||
+          (@has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z))
+
+        !cmp_xymz
       end
 
       # Returns this bounding box subdivided, as an array of bounding boxes.

data/lib/rgeo/cartesian/calculations.rb

@@ -23,17 +23,14 @@ module RGeo
         @lensq = @dx * @dx + @dy * @dy
       end
 
-      attr_reader :s
-      attr_reader :e
-      attr_reader :dx
-      attr_reader :dy
+      attr_reader :s, :e, :dx, :dy
 
       def to_s
         "#{@s} - #{@e}"
       end
 
-      def eql?(rhs)
-        rhs.is_a?(Segment) && @s == rhs.s && @e == rhs.e
+      def eql?(other)
+        other.is_a?(Segment) && @s == other.s && @e == other.e
       end
       alias == eql?
 
@@ -45,23 +42,23 @@ module RGeo
       # a positive value if the point is to the right, or
       # 0 if the point is collinear to the segment.
 
-      def side(p)
-        px = p.x
-        py = p.y
+      def side(point)
+        px = point.x
+        py = point.y
         (@sx - px) * (@ey - py) - (@sy - py) * (@ex - px)
       end
 
-      def tproj(p)
+      def tproj(point)
         if @lensq == 0
           nil
         else
-          (@dx * (p.x - @sx) + @dy * (p.y - @sy)) / @lensq
+          (@dx * (point.x - @sx) + @dy * (point.y - @sy)) / @lensq
         end
       end
 
-      def contains_point?(p)
-        if side(p) == 0
-          t = tproj(p)
+      def contains_point?(point)
+        if side(point) == 0
+          t = tproj(point)
           t && t >= 0.0 && t <= 1.0
         else
           false
@@ -84,11 +81,9 @@ module RGeo
         s2 = seg.s
         # Handle degenerate cases
         if seg.degenerate?
-          if @lensq == 0 && @s == s2
-            return @s
-          else
-            return contains_point?(s2) ? s2 : nil
-          end
+          return @s if @lensq == 0 && @s == s2
+
+          return contains_point?(s2) ? s2 : nil
         elsif @lensq == 0
           return seg.contains_point?(@s) ? @s : nil
         end
@@ -132,13 +127,12 @@ module RGeo
             # If this is the case, return the closest point from
             # either segment.
             int_pt = @s.factory.point(x, y)
-            if contains_point?(int_pt)
-              int_pt
-            else
-              # find closest of @s, @e, seg.s, seg.e
-              [@e, seg.s, seg.e].reduce(@s) do |closest, pt|
-                int_pt.distance(pt) < int_pt.distance(closest) ? pt : closest
-              end
+
+            return int_pt if contains_point?(int_pt)
+
+            # find closest of @s, @e, seg.s, seg.e
+            [@e, seg.s, seg.e].reduce(@s) do |closest, pt|
+              int_pt.distance(pt) < int_pt.distance(closest) ? pt : closest
             end
           end
         end