rgeo 2.4.0 → 3.0.0

data/lib/rgeo/geographic/projected_feature_methods.rb

@@ -19,29 +19,48 @@ module RGeo
       end
 
       def envelope
-        factory.unproject(projection.envelope)
+        factory.unproject(projection.unsafe_envelope)
       end
 
-      def empty?
-        projection.empty?
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
+      def empty?
+        projection.empty?
       end
 
       def simple?
         projection.simple?
       end
 
-      def is_simple?
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
+      def valid?
+        projection.valid?
+      end
+
+      def invalid_reason
+        projection.invalid_reason
+      end
+
+      # (see RGeo::ImplHelper::ValidityCheck#make_valid)
+      def make_valid
+        factory.unproject projection.make_valid
       end
 
       def boundary
-        boundary = projection.boundary
+        boundary = projection.unsafe_boundary
         boundary ? factory.unproject(boundary) : nil
       end
 
@@ -50,79 +69,79 @@ module RGeo
       end
 
       def disjoint?(rhs)
-        projection.disjoint?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_disjoint?(Feature.cast(rhs, factory).projection)
       end
 
       def intersects?(rhs)
-        projection.intersects?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_intersects?(Feature.cast(rhs, factory).projection)
       end
 
       def touches?(rhs)
-        projection.touches?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_touches?(Feature.cast(rhs, factory).projection)
       end
 
       def crosses?(rhs)
-        projection.crosses?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_crosses?(Feature.cast(rhs, factory).projection)
       end
 
       def within?(rhs)
-        projection.within?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_within?(Feature.cast(rhs, factory).projection)
       end
 
       def contains?(rhs)
-        projection.contains?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_contains?(Feature.cast(rhs, factory).projection)
       end
 
       def overlaps?(rhs)
-        projection.overlaps?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_overlaps?(Feature.cast(rhs, factory).projection)
       end
 
       def relate(rhs, pattern_)
-        projection.relate(Feature.cast(rhs, factory).projection, pattern_)
+        projection.unsafe_relate(Feature.cast(rhs, factory).projection, pattern_)
       end
 
       def distance(rhs)
-        projection.distance(Feature.cast(rhs, factory).projection)
+        projection.unsafe_distance(Feature.cast(rhs, factory).projection)
       end
 
       def buffer(distance)
-        factory.unproject(projection.buffer(distance))
+        factory.unproject(projection.unsafe_buffer(distance))
       end
 
       def buffer_with_style(distance, end_cap_style, join_style, mitre_limit)
-        factory.unproject(projection.buffer_with_style(distance, end_cap_style, join_style, mitre_limit))
+        factory.unproject(projection.unsafe_buffer_with_style(distance, end_cap_style, join_style, mitre_limit))
       end
 
       def simplify(tolerance)
-        factory.unproject(projection.simplify(tolerance))
+        factory.unproject(projection.unsafe_simplify(tolerance))
       end
 
       def simplify_preserve_topology(tolerance)
-        factory.unproject(projection.simplify_preserve_topology(tolerance))
+        factory.unproject(projection.unsafe_simplify_preserve_topology(tolerance))
       end
 
       def convex_hull
-        factory.unproject(projection.convex_hull)
+        factory.unproject(projection.unsafe_convex_hull)
       end
 
       def intersection(rhs)
-        factory.unproject(projection.intersection(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_intersection(Feature.cast(rhs, factory).projection))
       end
 
       def union(rhs)
-        factory.unproject(projection.union(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_union(Feature.cast(rhs, factory).projection))
       end
 
       def difference(rhs)
-        factory.unproject(projection.difference(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_difference(Feature.cast(rhs, factory).projection))
       end
 
       def sym_difference(rhs)
-        factory.unproject(projection.sym_difference(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_sym_difference(Feature.cast(rhs, factory).projection))
       end
 
       def point_on_surface
-        factory.unproject(projection.point_on_surface)
+        factory.unproject(projection.unsafe_point_on_surface)
       end
     end
 
@@ -154,7 +173,8 @@ module RGeo
 
       private
 
-      def validate_geometry
+      # Ensure coordinates fall within a valid range.
+      def init_geometry
         @y = 85.0511287 if @y > 85.0511287
         @y = -85.0511287 if @y < -85.0511287
         super
@@ -163,48 +183,53 @@ module RGeo
 
     module ProjectedNCurveMethods # :nodoc:
       def length
-        projection.length
+        projection.unsafe_length
       end
     end
 
     module ProjectedLineStringMethods # :nodoc:
       private
 
-      def validate_geometry
+      # Ensure coordinates fall within a valid range.
+      def init_geometry
         @points = @points.map(&:canonical_point)
         super
       end
     end
 
+    module ProjectedLinearRingMethods # :nodoc:
+      def simple?
+        projection.valid?
+      end
+    end
+
     module ProjectedNSurfaceMethods # :nodoc:
       def area
-        projection.area
+        projection.unsafe_area
       end
 
       def centroid
-        factory.unproject(projection.centroid)
+        factory.unproject(projection.unsafe_centroid)
       end
     end
 
     module ProjectedPolygonMethods # :nodoc:
       private
 
-      def validate_geometry
+      # Ensure projection is available.
+      def init_geometry
         super
-        unless projection
-          raise Error::InvalidGeometry, "Polygon failed assertions"
-        end
+        raise Error::InvalidGeometry, "Polygon failed assertions" unless projection
       end
     end
 
     module ProjectedMultiPolygonMethods # :nodoc:
       private
 
-      def validate_geometry
+      # Ensure projection is available.
+      def init_geometry
         super
-        unless projection
-          raise Error::InvalidGeometry, "MultiPolygon failed assertions"
-        end
+        raise Error::InvalidGeometry, "MultiPolygon failed assertions" unless projection
       end
     end
   end

data/lib/rgeo/geographic/projected_window.rb

@@ -13,7 +13,6 @@ module RGeo
     # map visualization, an envelope in a projected coordinate system, or
     # a spatial constraint. It must be attached to a Geographic::Factory
     # that has a projection.
-
     class ProjectedWindow
       # Create a new ProjectedWindow given the Geographic::Factory, and the
       # x and y extents of the rectangle.
@@ -64,38 +63,33 @@ module RGeo
         to_s
       end
 
-      def eql?(obj_) # :nodoc:
-        return false unless obj_.is_a?(ProjectedWindow)
-        @factory == obj_.factory && @x_min == obj_.x_min && @x_max == obj_.x_max &&
-          @y_min = obj_.y_min && @y_max = obj_.y_max
+      def eql?(other) # :nodoc:
+        return false unless other.is_a?(ProjectedWindow)
+        @factory == other.factory && @x_min == other.x_min && @x_max == other.x_max &&
+          @y_min = other.y_min && @y_max = other.y_max
       end
       alias == eql?
 
       def hash # :nodoc:
-        @factory.hash + @x_min.hash + @x_max.hash + @y_min.hash + @y_max.hash
+        [@factory, @x_min, @x_max, @y_min, @y_max].hash
       end
 
       # Returns the Geographic::Factory associated with this window.
       # Note that this factory is the overall geography factory, not the
       # projected factory (which can be obtained by calling
       # Geographic::Factory#projection_factory on this factory).
-
       attr_reader :factory
 
       # Returns the lower limit in the x (easting) direction.
-
       attr_reader :x_min
 
       # Returns the upper limit in the x (easting) direction.
-
       attr_reader :x_max
 
       # Returns the lower limit in the y (northing) direction.
-
       attr_reader :y_min
 
       # Returns the upper limit in the y (northing) direction.
-
       attr_reader :y_max
 
       # Returns true if the projection wraps along the x axis, and this
@@ -146,35 +140,45 @@ module RGeo
       # (lat/lng) space, as a Feature::Point object.
 
       def sw_point
-        @sw ||= @factory.unproject(@factory.projection_factory.point(@x_min, @y_min))
+        return @sw_point if defined?(@sw_point)
+
+        @sw_point = @factory.unproject(@factory.projection_factory.point(@x_min, @y_min))
       end
 
       # Returns the southeast corner of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def se_point
-        @se ||= @factory.unproject(@factory.projection_factory.point(@x_max, @y_min))
+        return @se_point if defined?(@se_point)
+
+        @se_point = @factory.unproject(@factory.projection_factory.point(@x_max, @y_min))
       end
 
       # Returns the northwest corner of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def nw_point
-        @nw ||= @factory.unproject(@factory.projection_factory.point(@x_min, @y_max))
+        return @nw_point if defined?(@nw_point)
+
+        @nw_point = @factory.unproject(@factory.projection_factory.point(@x_min, @y_max))
       end
 
       # Returns the northeast corner of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def ne_point
-        @ne ||= @factory.unproject(@factory.projection_factory.point(@x_max, @y_max))
+        return @ne_point if defined?(@ne_point)
+
+        @ne_point = @factory.unproject(@factory.projection_factory.point(@x_max, @y_max))
       end
 
       # Returns the center of the rectangle in _unprojected_
       # (lat/lng) space, as a Feature::Point object.
 
       def center_point
-        @center ||= @factory.unproject(@factory.projection_factory.point(*center_xy))
+        return @center_point if defined?(@center_point)
+
+        @center_point = @factory.unproject(@factory.projection_factory.point(*center_xy))
       end
 
       # Returns a random point inside the rectangle in _unprojected_
@@ -233,7 +237,7 @@ module RGeo
 
       def scaled_by(x_factor_, y_factor_ = nil)
         y_factor_ ||= x_factor_
-        if x_factor_ != 1.0 || y_factor_ != 1.0
+        if x_factor_ != 1 || y_factor_ != 1
           x_, y_ = *center_xy
           xr_ = x_span * 0.5 * x_factor_
           yr_ = y_span * 0.5 * y_factor_
@@ -287,9 +291,14 @@ module RGeo
 
       def with_margin(x_margin_, y_margin_ = nil)
         y_margin_ ||= x_margin_
-        if x_margin_ != 0.0 || y_margin_ != 0.0
-          ProjectedWindow.new(@factory, @x_min - x_margin_, @y_min - y_margin_,
-            @x_max + x_margin_, @y_max + y_margin_)
+        if x_margin_ != 0 || y_margin_ != 0
+          ProjectedWindow.new(
+            @factory,
+            @x_min - x_margin_,
+            @y_min - y_margin_,
+            @x_max + x_margin_,
+            @y_max + y_margin_
+          )
         else
           self
         end
@@ -318,8 +327,13 @@ module RGeo
           y_margin_ ||= x_margin_
           factory_ = point_.factory
           projection_ = factory_.project(point_)
-          ProjectedWindow.new(factory_, projection_.x - x_margin_, projection_.y - y_margin_,
-            projection_.x + x_margin_, projection_.y + y_margin_)
+          ProjectedWindow.new(
+            factory_,
+            projection_.x - x_margin_,
+            projection_.y - y_margin_,
+            projection_.x + x_margin_,
+            projection_.y + y_margin_
+          )
         end
 
         # Creates a new window that contains all of the given points.

data/lib/rgeo/geographic/{proj4_projector.rb → projector.rb}

@@ -8,7 +8,7 @@
 
 module RGeo
   module Geographic
-    class Proj4Projector # :nodoc:
+    class Projector # :nodoc:
       def initialize(geography_factory, projection_factory)
         @geography_factory = geography_factory
         @projection_factory = projection_factory
@@ -42,14 +42,12 @@ module RGeo
           new(geography_factory, projection_factory)
         end
 
-        def create_from_proj4(geography_factory, proj4, opts = {})
+        def create_from_opts(geography_factory, opts = {})
           projection_factory =
             Cartesian.preferred_factory(
-              proj4: proj4,
               coord_sys: opts[:coord_sys], srid: opts[:srid],
+              coord_sys_class: opts[:coord_sys_class],
               buffer_resolution: opts[:buffer_resolution],
-              lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
-              uses_lenient_assertions: opts[:uses_lenient_assertions],
               has_z_coordinate: opts[:has_z_coordinate],
               has_m_coordinate: opts[:has_m_coordinate],
               wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -14,11 +14,8 @@ module RGeo
       def initialize(geography_factory, opts = {})
         @geography_factory = geography_factory
         @projection_factory = Cartesian.preferred_factory(srid: 3857,
-                                                          proj4: SimpleMercatorProjector._proj4_3857,
                                                           coord_sys: SimpleMercatorProjector._coordsys_3857,
                                                           buffer_resolution: opts[:buffer_resolution],
-                                                          lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
-                                                          uses_lenient_assertions: opts[:uses_lenient_assertions],
                                                           has_z_coordinate: opts[:has_z_coordinate],
                                                           has_m_coordinate: opts[:has_m_coordinate])
       end
@@ -35,8 +32,10 @@ module RGeo
         when Feature::Point
           rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
           radius = EQUATORIAL_RADIUS
-          @projection_factory.point(geometry.x * rpd_ * radius,
-            Math.log(Math.tan(Math::PI / 4.0 + geometry.y * rpd_ / 2.0)) * radius)
+          @projection_factory.point(
+            geometry.x * rpd_ * radius,
+            Math.log(Math.tan(Math::PI / 4.0 + geometry.y * rpd_ / 2.0)) * radius
+          )
         when Feature::Line
           @projection_factory.line(project(geometry.start_point), project(geometry.end_point))
         when Feature::LinearRing
@@ -62,8 +61,10 @@ module RGeo
         when Feature::Point
           dpr = ImplHelper::Math::DEGREES_PER_RADIAN
           radius = EQUATORIAL_RADIUS
-          @geography_factory.point(geometry.x / radius * dpr,
-            (2.0 * Math.atan(Math.exp(geometry.y / radius)) - Math::PI / 2.0) * dpr)
+          @geography_factory.point(
+            geometry.x / radius * dpr,
+            (2.0 * Math.atan(Math.exp(geometry.y / radius)) - Math::PI / 2.0) * dpr
+          )
         when Feature::Line
           @geography_factory.line(unproject(geometry.start_point), unproject(geometry.end_point))
         when Feature::LinearRing
@@ -71,8 +72,10 @@ module RGeo
         when Feature::LineString
           @geography_factory.line_string(geometry.points.map { |p| unproject(p) })
         when Feature::Polygon
-          @geography_factory.polygon(unproject(geometry.exterior_ring),
-            geometry.interior_rings.map { |p| unproject(p) })
+          @geography_factory.polygon(
+            unproject(geometry.exterior_ring),
+            geometry.interior_rings.map { |p| unproject(p) }
+          )
         when Feature::MultiPoint
           @geography_factory.multi_point(geometry.map { |p| unproject(p) })
         when Feature::MultiLineString
@@ -89,24 +92,22 @@ module RGeo
       end
 
       def limits_window
-        @limits_window ||= ProjectedWindow.new(@geography_factory,
-          -20_037_508.342789, -20_037_508.342789, 20_037_508.342789, 20_037_508.342789,
-          is_limits: true)
-      end
+        return @limits_window if defined?(@limits_window)
 
-      def self._proj4_3857 # :nodoc:
-        return unless CoordSys.supported?(:proj4)
-        unless defined?(@proj4_3857)
-          @proj4_3857 = CoordSys::Proj4.create("+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs")
-        end
-        @proj4_3857
+        @limits_window = ProjectedWindow.new(
+          @geography_factory,
+          -20_037_508.342789,
+          -20_037_508.342789,
+          20_037_508.342789,
+          20_037_508.342789,
+          is_limits: true
+        )
       end
 
       def self._coordsys_3857 # :nodoc:
-        unless defined?(@coordsys_3857)
-          @coordsys_3857 = CoordSys::CS.create_from_wkt('PROJCS["Popular Visualisation CRS / Mercator",GEOGCS["Popular Visualisation CRS",DATUM["Popular_Visualisation_Datum",SPHEROID["Popular Visualisation Sphere",6378137,0,AUTHORITY["EPSG","7059"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6055"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4055"]],UNIT["metre",1,AUTHORITY["EPSG","9001"]],PROJECTION["Mercator_1SP"],PARAMETER["central_meridian",0],PARAMETER["scale_factor",1],PARAMETER["false_easting",0],PARAMETER["false_northing",0],AUTHORITY["EPSG","3785"],AXIS["X",EAST],AXIS["Y",NORTH]]')
-        end
-        @coordsys_3857
+        return @coordsys_3857 if defined?(@coordsys_3857)
+
+        @coordsys_3857 = CoordSys::CONFIG.default_coord_sys_class.create(3857)
       end
     end
   end

data/lib/rgeo/geographic/spherical_feature_classes.rb

@@ -8,78 +8,98 @@
 
 module RGeo
   module Geographic
-    class SphericalPointImpl # :nodoc:
+    class SphericalPointImpl
       include Feature::Point
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPointMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalPointMethods
     end
 
-    class SphericalLineStringImpl # :nodoc:
+    class SphericalLineStringImpl
       include Feature::LineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalLineStringMethods
     end
 
-    class SphericalLineImpl # :nodoc:
+    class SphericalLineImpl
       include Feature::Line
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLineMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalLineStringMethods
     end
 
-    class SphericalLinearRingImpl # :nodoc:
+    class SphericalLinearRingImpl
       include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLinearRingMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalLineStringMethods
     end
 
-    class SphericalPolygonImpl # :nodoc:
+    class SphericalPolygonImpl
       include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPolygonMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalPolygonMethods
     end
 
-    class SphericalGeometryCollectionImpl # :nodoc:
+    class SphericalGeometryCollectionImpl
       include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
     end
 
-    class SphericalMultiPointImpl # :nodoc:
+    class SphericalMultiPointImpl
       include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPointMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
     end
 
-    class SphericalMultiLineStringImpl # :nodoc:
+    class SphericalMultiLineStringImpl
       include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiLineStringMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalMultiLineStringMethods
     end
 
-    class SphericalMultiPolygonImpl # :nodoc:
+    class SphericalMultiPolygonImpl
       include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPolygonMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end