rgeo 2.3.1 → 3.0.1

data/lib/rgeo/geographic/interface.rb

@@ -54,12 +54,6 @@ module RGeo
       #   Support a Z coordinate. Default is false.
       # [<tt>:has_m_coordinate</tt>]
       #   Support an M coordinate. Default is false.
-      # [<tt>:uses_lenient_assertions</tt>]
-      #   If set to true, assertion checking is disabled. This includes
-      #   simplicity checking on LinearRing, and validity checks on
-      #   Polygon and MultiPolygon. This may speed up creation of certain
-      #   objects, at the expense of not doing the proper checking for
-      #   OGC compliance. Default is false.
       # [<tt>:buffer_resolution</tt>]
       #   The resolution of buffers around geometries created by this
       #   factory. This controls the number of line segments used to
@@ -70,30 +64,20 @@ module RGeo
       #   for different kinds of buffers is not specified precisely,
       #   but in general the value is taken as the number of segments
       #   per 90-degree curve.
-      # [<tt>:proj4</tt>]
-      #   Provide the coordinate system in Proj4 format. You may pass
-      #   either an RGeo::CoordSys::Proj4 object, or a string or hash
-      #   containing the Proj4 parameters. This coordinate system must be
-      #   a geographic (lat/long) coordinate system. The default is the
-      #   "popular visualization CRS" (EPSG 4055), represented by
-      #   "<tt>+proj=longlat +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +no_defs</tt>".
-      #   Has no effect if Proj4 is not available.
       # [<tt>:coord_sys</tt>]
       #   Provide a coordinate system in OGC format, either as an object
       #   (one of the CoordSys::CS classes) or as a string in WKT format.
       #   This coordinate system must be a GeographicCoordinateSystem.
       #   The default is the "popular visualization CRS" (EPSG 4055).
+      # [<tt>:coord_sys_class</tt>]
+      #   CoordSys::CS::CoordinateSystem implementation used to instansiate
+      #   a coord_sys based on the :srid given.
       # [<tt>:srid</tt>]
       #   The SRID that should be returned by features from this factory.
       #   Default is 4055, indicating EPSG 4055, the "popular
       #   visualization crs". You may alternatively wish to set the srid
       #   to 4326, indicating the WGS84 crs, but note that that value
       #   implies an ellipsoidal datum, not a spherical datum.
-      # [<tt>:srs_database</tt>]
-      #   Optional. If provided, the object should respond to #get and
-      #   #clear_cache. If both this and an SRID are
-      #   provided, they are used to look up the proj4 and coord_sys
-      #   objects from a spatial reference system database.
       # [<tt>:wkt_parser</tt>]
       #   Configure the parser for WKT. The value is a hash of
       #   configuration parameters for WKRep::WKTParser.new. Default is
@@ -115,29 +99,21 @@ module RGeo
       #   for WKRep::WKBGenerator.
 
       def spherical_factory(opts = {})
-        proj4 = opts[:proj4]
         coord_sys = opts[:coord_sys]
         srid = opts[:srid]
-        if (!proj4 || !coord_sys) && srid && (db_ = opts[:srs_database])
-          entry_ = db_.get(srid.to_i)
-          if entry_
-            proj4 ||= entry_.proj4
-            coord_sys ||= entry_.coord_sys
-          end
-        end
         srid ||= coord_sys.authority_code if coord_sys
-        Geographic::Factory.new("Spherical",
+        Geographic::Factory.new(
+          "Spherical",
           has_z_coordinate: opts[:has_z_coordinate],
           has_m_coordinate: opts[:has_m_coordinate],
-          proj4: proj4 || proj_4055,
-          coord_sys: coord_sys || coord_sys_4055,
-          uses_lenient_assertions: opts[:uses_lenient_assertions],
+          coord_sys: coord_sys || coord_sys4055,
           buffer_resolution: opts[:buffer_resolution],
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
           wkt_generator: opts[:wkt_generator],
           wkb_generator: opts[:wkb_generator],
-          srid: (srid || 4055).to_i)
+          srid: (srid || 4055).to_i
+        )
       end
 
       # Creates and returns a geographic factory that is designed for
@@ -207,35 +183,33 @@ module RGeo
       #
       # You may also provide options understood by the underlying
       # projected Cartesian factory. For example, if GEOS is used for the
-      # projected factory, you may also set the
-      # <tt>:lenient_multi_polygon_assertions</tt> and
-      # <tt>:buffer_resolution</tt> options. See RGeo::Geos.factory for
-      # more details.
+      # projected factory, you may also set the <tt>:buffer_resolution</tt>
+      # options. See RGeo::Geos.factory for more details.
 
       def simple_mercator_factory(opts = {})
-        factory = Geographic::Factory.new("Projected",
-          proj4: proj_4326,
-          coord_sys: coord_sys_4326,
+        factory = Geographic::Factory.new(
+          "Projected",
+          coord_sys: coord_sys4326,
           srid: 4326,
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
           wkt_generator: opts[:wkt_generator],
           wkb_generator: opts[:wkb_generator],
           has_z_coordinate: opts[:has_z_coordinate],
-          has_m_coordinate: opts[:has_m_coordinate],
-          uses_lenient_assertions: opts[:uses_lenient_assertions])
-        projector = Geographic::SimpleMercatorProjector.new(factory,
+          has_m_coordinate: opts[:has_m_coordinate]
+        )
+        projector = Geographic::SimpleMercatorProjector.new(
+          factory,
           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])
+          has_m_coordinate: opts[:has_m_coordinate]
+        )
         factory.projector = projector
         factory
       end
 
       # Creates and returns a geographic factory that includes a
-      # projection specified by a Proj4 coordinate system. Like all
+      # projection specified by a coordinate system. Like all
       # geographic factories, this one creates features using latitude-
       # longitude values. However, calculations such as intersections are
       # done in the projected coordinate system, and size and distance
@@ -251,30 +225,24 @@ module RGeo
       # === Options
       #
       # When creating a projected implementation, you must provide enough
-      # information to construct a Proj4 specification for the projection.
+      # information to construct a CoordinateSystem specification for the projection.
       # Generally, this means you will provide either the projection's
       # factory itself (via the <tt>:projection_factory</tt> option), in
-      # which case the factory must include a Proj4 coordinate system;
-      # or, alternatively, you should provide the Proj4 coordinate system
+      # which case the factory must include a coord_sys;
+      # or, alternatively, you should provide the coordinate system
       # and let this method construct a projection factory for you (which
       # it will do using the preferred Cartesian factory generator).
-      # If you choose this second method, you may provide the proj4
-      # directly via the <tt>:projection_proj4</tt> option, or indirectly
-      # by providing both an <tt>:srid</tt> and a <tt>:srs_database</tt>
-      # to use to look up the coordinate system.
+      # If you choose this second method, you may provide the coord_sys
+      # via the <tt>:projection_coord_sys</tt> or <option or <tt>:projection_srid</tt>.
       #
       # Following are detailed descriptions of the various options you can
       # pass to this method.
       #
       # [<tt>:projection_factory</tt>]
       #   Specify an existing Cartesian factory to use for the projection.
-      #   This factory must have a non-nil Proj4. If this is provided, any
-      #   <tt>:projection_proj4</tt>, <tt>:projection_coord_sys</tt>, and
+      #   This factory must have a non-nil coord_sys. If this is provided, any
+      #   <tt>:projection_coord_sys</tt> and
       #   <tt>:projection_srid</tt> are ignored.
-      # [<tt>:projection_proj4</tt>]
-      #   Specify a Proj4 projection to use to construct the projection
-      #   factory. This may be specified as a CoordSys::Proj4 object, or
-      #   as a Proj4 string or hash representation.
       # [<tt>:projection_coord_sys</tt>]
       #   Specify a OGC coordinate system for the projection. This may be
       #   specified as an RGeo::CoordSys::CS::GeographicCoordinateSystem
@@ -282,16 +250,12 @@ module RGeo
       # [<tt>:projection_srid</tt>]
       #   The SRID value to use for the projection factory. Defaults to
       #   the given projection coordinate system's authority code, or to
-      #   0 if no projection coordinate system is known.
-      # [<tt>:proj4</tt>]
-      #   A proj4 projection for the geographic (lat-lon) factory. You may
-      #   pass either an RGeo::CoordSys::Proj4 object, or a string or hash
-      #   containing the Proj4 parameters. This coordinate system must be
-      #   a geographic (lat/long) coordinate system. It defaults to the
-      #   geographic part of the projection factory's coordinate system.
-      #   Generally, you should leave it at the default unless you want
-      #   the geographic coordinate system to be based on a different
-      #   horizontal datum than the projection.
+      #   0 if no projection coordinate system is known. If this is provided
+      #   without a projection_coord_sys, one will be instansiated from
+      #   the default_coord_sys_class or projection_coord_sys_class if given.
+      # [<tt>:projection_coord_sys_class</tt>]
+      #   Class to create the projection_coord_sys from if only a projection_srid
+      #   is provided.
       # [<tt>:coord_sys</tt>]
       #   An OGC coordinate system for the geographic (lat-lon) factory,
       #   which may be an RGeo::CoordSys::CS::GeographicCoordinateSystem
@@ -304,11 +268,6 @@ module RGeo
       #   The SRID value to use for the main geographic factory. Defaults
       #   to the given geographic coordinate system's authority code, or
       #   to 0 if no geographic coordinate system is known.
-      # [<tt>:srs_database</tt>]
-      #   Optional. If provided, the object should respond to #get and
-      #   #clear_cache. If both this and an SRID are
-      #   provided, they are used to look up the proj4 and coord_sys
-      #   objects from a spatial reference system database.
       # [<tt>:has_z_coordinate</tt>]
       #   Support a Z coordinate. Default is false.
       #   Note: this is ignored if a <tt>:projection_factory</tt> is
@@ -342,117 +301,77 @@ module RGeo
       # If a <tt>:projection_factory</tt> is _not_ provided, you may also
       # provide options for configuring the projected Cartesian factory.
       # For example, if GEOS is used for the projected factory, you may
-      # also set the <tt>:lenient_multi_polygon_assertions</tt> and
-      # <tt>:buffer_resolution</tt> options. See RGeo::Geos.factory for
-      # more details.
+      # also set the <tt>:buffer_resolution</tt> option. See RGeo::Geos.factory
+      # for more details.
 
       def projected_factory(opts = {})
-        CoordSys.check!(:proj4)
-        db_ = opts[:srs_database]
         if (projection_factory = opts[:projection_factory])
           # Get the projection coordinate systems from the given factory
-          projection_proj4 = projection_factory.proj4
-          unless projection_proj4
-            raise ArgumentError, "The :projection_factory does not have a proj4."
-          end
           projection_coord_sys = projection_factory.coord_sys
-          if projection_coord_sys && !projection_coord_sys.is_a?(CoordSys::CS::ProjectedCoordinateSystem)
+
+          if projection_coord_sys && !projection_coord_sys.projected?
             raise ArgumentError, "The :projection_factory's coord_sys is not a ProjectedCoordinateSystem."
           end
+
           # Determine geographic coordinate system. First check parameters.
-          proj4 = opts[:proj4]
           coord_sys = opts[:coord_sys]
           srid = opts[:srid]
-          # Lookup srid from srs database if needed
-          if (!proj4 || !coord_sys) && srid && db_
-            entry_ = db_.get(srid.to_i)
-            if entry_
-              proj4 ||= entry_.proj4
-              coord_sys ||= entry_.coord_sys
-            end
-          end
           # Fall back to getting the values from the projection.
-          proj4 ||= projection_proj4.get_geographic || _proj_4326
           coord_sys ||= projection_coord_sys.geographic_coordinate_system if projection_coord_sys
           srid ||= coord_sys.authority_code if coord_sys
           srid ||= 4326
           # Now we should have all the coordinate system info.
-          factory = Geographic::Factory.new("Projected",
-            proj4: proj4,
+          factory = Geographic::Factory.new(
+            "Projected",
             coord_sys: coord_sys,
             srid: srid.to_i,
             has_z_coordinate: projection_factory.property(:has_z_coordinate),
             has_m_coordinate: projection_factory.property(:has_m_coordinate),
             wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],
-            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator])
-          projector = Geographic::Proj4Projector.create_from_existing_factory(factory,
-            projection_factory)
+            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator]
+          )
+          projector = Geographic::Projector.create_from_existing_factory(
+            factory,
+            projection_factory
+          )
         else
           # Determine projection coordinate system. First check the parameters.
-          projection_proj4 = opts[:projection_proj4]
-          projection_coord_sys = opts[:projection_coord_sys]
-          projection_srid = opts[:projection_srid]
-          # Check the case where we need to look up a srid from an srs database.
-          if (!projection_proj4 || !projection_coord_sys) && projection_srid && db_
-            entry_ = db_.get(projection_srid.to_i)
-            if entry_
-              projection_proj4 ||= entry_.proj4
-              projection_coord_sys ||= entry_.coord_sys
-            end
-          end
-          # A projection proj4 is absolutely required.
-          unless projection_proj4
-            raise ArgumentError, "Unable to determine the Proj4 for the projected coordinate system."
-          end
-          # Check the projection coordinate systems, and parse if needed.
-          if projection_proj4.is_a?(String) || projection_proj4.is_a?(Hash)
-            actual_projection_proj4 = CoordSys::Proj4.create(projection_proj4)
-            unless actual_projection_proj4
-              raise ArgumentError, "Bad proj4 syntax: #{projection_proj4.inspect}"
-            end
-            projection_proj4 = actual_projection_proj4
-          end
-          if projection_coord_sys && !projection_coord_sys.is_a?(CoordSys::CS::ProjectedCoordinateSystem)
-            raise ArgumentError, "The :projection_coord_sys is not a ProjectedCoordinateSystem."
-          end
-          projection_srid ||= projection_coord_sys.authority_code if projection_coord_sys
+          projection_coord_sys_info = ImplHelper::Utils.setup_coord_sys(
+            opts[:projection_srid],
+            opts[:projection_coord_sys],
+            opts[:projection_coord_sys_class]
+          )
+          projection_coord_sys = projection_coord_sys_info[:coord_sys]
+          projection_srid = projection_coord_sys_info[:srid]
+
           # Determine geographic coordinate system. First check parameters.
-          proj4 = opts[:proj4]
           coord_sys = opts[:coord_sys]
           srid = opts[:srid]
-          # Lookup srid from srs database if needed
-          if (!proj4 || !coord_sys) && srid && db_
-            entry_ = db_.get(srid.to_i)
-            if entry_
-              proj4 ||= entry_.proj4
-              coord_sys ||= entry_.coord_sys
-            end
-          end
+
           # Fall back to getting the values from the projection.
-          proj4 ||= projection_proj4.get_geographic || _proj_4326
           coord_sys ||= projection_coord_sys.geographic_coordinate_system if projection_coord_sys
           srid ||= coord_sys.authority_code if coord_sys
           srid ||= 4326
           # Now we should have all the coordinate system info.
-          factory = Geographic::Factory.new("Projected",
-            proj4: proj4,
+          factory = Geographic::Factory.new(
+            "Projected",
             coord_sys: coord_sys,
             srid: srid.to_i,
             has_z_coordinate: opts[:has_z_coordinate],
             has_m_coordinate: opts[:has_m_coordinate],
             wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],
-            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator])
-          projector = Geographic::Proj4Projector.create_from_proj4(factory,
-            projection_proj4,
+            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator]
+          )
+          projector = Geographic::Projector.create_from_opts(
+            factory,
             srid: projection_srid,
             coord_sys: projection_coord_sys,
             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],
-            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator])
+            wkb_parser: opts[:wkb_parser], wkb_generator: opts[:wkb_generator]
+          )
         end
         factory.projector = projector
         factory
@@ -460,32 +379,16 @@ module RGeo
 
       private
 
-      def proj_4055
-        unless defined?(@proj44055)
-          @proj44055 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +no_defs")
-        end
-        @proj44055
-      end
+      def coord_sys4055
+        return @coord_sys4055 if defined?(@coord_sys4055)
 
-      def coord_sys_4055
-        unless defined?(@coord_sys_4055)
-          @coord_sys_4055 = CoordSys::CS.create_from_wkt('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"]]')
-        end
-        @coord_sys_4055
+        @coord_sys4055 = CoordSys::CONFIG.default_coord_sys_class.create(4055)
       end
 
-      def proj_4326
-        unless defined?(@proj_4326)
-          @proj_4326 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
-        end
-        @proj_4326
-      end
+      def coord_sys4326
+        return @coord_sys4326 if defined?(@coord_sys4326)
 
-      def coord_sys_4326
-        unless defined?(@coord_sys_4326)
-          @coord_sys_4326 = CoordSys::CS.create_from_wkt('GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]')
-        end
-        @coord_sys_4326
+        @coord_sys4326 = CoordSys::CONFIG.default_coord_sys_class.create(4326)
       end
     end
   end

data/lib/rgeo/geographic/projected_feature_classes.rb

@@ -8,16 +8,18 @@
 
 module RGeo
   module Geographic
-    class ProjectedPointImpl # :nodoc:
+    class ProjectedPointImpl
       include Feature::Point
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPointMethods
       include ProjectedGeometryMethods
       include ProjectedPointMethods
     end
 
-    class ProjectedLineStringImpl  # :nodoc:
+    class ProjectedLineStringImpl
       include Feature::LineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ProjectedGeometryMethods
@@ -25,18 +27,21 @@ module RGeo
       include ProjectedLineStringMethods
     end
 
-    class ProjectedLinearRingImpl  # :nodoc:
+    class ProjectedLinearRingImpl
       include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLinearRingMethods
       include ProjectedGeometryMethods
       include ProjectedNCurveMethods
       include ProjectedLineStringMethods
+      include ProjectedLinearRingMethods
     end
 
-    class ProjectedLineImpl # :nodoc:
+    class ProjectedLineImpl
       include Feature::Line
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLineMethods
@@ -45,8 +50,9 @@ module RGeo
       include ProjectedLineStringMethods
     end
 
-    class ProjectedPolygonImpl # :nodoc:
+    class ProjectedPolygonImpl
       include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPolygonMethods
       include ProjectedGeometryMethods
@@ -54,23 +60,26 @@ module RGeo
       include ProjectedPolygonMethods
     end
 
-    class ProjectedGeometryCollectionImpl # :nodoc:
+    class ProjectedGeometryCollectionImpl
       include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ProjectedGeometryMethods
     end
 
-    class ProjectedMultiPointImpl # :nodoc:
+    class ProjectedMultiPointImpl
       include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPointMethods
       include ProjectedGeometryMethods
     end
 
-    class ProjectedMultiLineStringImpl # :nodoc:
+    class ProjectedMultiLineStringImpl
       include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiLineStringMethods
@@ -78,8 +87,9 @@ module RGeo
       include ProjectedNCurveMethods
     end
 
-    class ProjectedMultiPolygonImpl # :nodoc:
+    class ProjectedMultiPolygonImpl
       include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPolygonMethods
@@ -87,5 +97,7 @@ module RGeo
       include ProjectedNSurfaceMethods
       include ProjectedMultiPolygonMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end