rgeo 1.1.2 → 2.0.0

data/lib/rgeo/geographic/interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Access to geographic data factories
@@ -88,8 +90,8 @@ module RGeo
       #   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 value should be an implementation of
-      #   CoordSys::SRSDatabase::Interface. If both this and an SRID are
+      #   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>]
@@ -112,30 +114,30 @@ module RGeo
       #   Default is the empty hash, indicating the default configuration
       #   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)
+      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
+            proj4 ||= entry_.proj4
+            coord_sys ||= entry_.coord_sys
           end
         end
-        srid_ ||= coord_sys_.authority_code if coord_sys_
+        srid ||= coord_sys.authority_code if coord_sys
         Geographic::Factory.new("Spherical",
-          has_z_coordinate: opts_[:has_z_coordinate],
-          has_m_coordinate: opts_[:has_m_coordinate],
-          proj4: proj4_ || _proj4_4055,
-          coord_sys: coord_sys_ || _coordsys_4055,
-          uses_lenient_assertions: opts_[:uses_lenient_assertions],
-          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)
+          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],
+          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)
       end
 
       # Creates and returns a geographic factory that is designed for
@@ -210,25 +212,25 @@ module RGeo
       # <tt>:buffer_resolution</tt> options. See RGeo::Geos.factory for
       # more details.
 
-      def simple_mercator_factory(opts_ = {})
-        factory_ = Geographic::Factory.new("Projected",
-          proj4: _proj4_4326,
-          coord_sys: _coordsys_4326,
+      def simple_mercator_factory(opts = {})
+        factory = Geographic::Factory.new("Projected",
+          proj4: proj_4326,
+          coord_sys: coord_sys_4326,
           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])
-        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])
-        factory_._set_projector(projector_)
-        factory_
+          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])
+        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])
+        factory.projector = projector
+        factory
       end
 
       # Creates and returns a geographic factory that includes a
@@ -302,8 +304,8 @@ module RGeo
       #   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 value should be an implementation of
-      #   CoordSys::SRSDatabase::Interface. If both this and an SRID are
+      #   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>]
@@ -343,144 +345,146 @@ module RGeo
       # <tt>:buffer_resolution</tt> options. See RGeo::Geos.factory for
       # more details.
 
-      def projected_factory(opts_ = {})
+      def projected_factory(opts = {})
         CoordSys.check!(:proj4)
-        db_ = opts_[:srs_database]
-        if (projection_factory_ = opts_[:projection_factory])
+        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."
+          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)
-            raise ::ArgumentError, 'The :projection_factory\'s coord_sys is not a ProjectedCoordinateSystem.'
+          projection_coord_sys = projection_factory.coord_sys
+          if projection_coord_sys && !projection_coord_sys.is_a?(CoordSys::CS::ProjectedCoordinateSystem)
+            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]
+          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 (!proj4 || !coord_sys) && srid && db_
+            entry_ = db_.get(srid.to_i)
             if entry_
-              proj4_ ||= entry_.proj4
-              coord_sys_ ||= entry_.coord_sys
+              proj4 ||= entry_.proj4
+              coord_sys ||= entry_.coord_sys
             end
           end
           # Fall back to getting the values from the projection.
-          proj4_ ||= projection_proj4_.get_geographic || _proj4_4326
-          coord_sys_ ||= projection_coord_sys_.geographic_coordinate_system if projection_coord_sys_
-          srid_ ||= coord_sys_.authority_code if coord_sys_
-          srid_ ||= 4326
+          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_,
-            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_)
+          factory = Geographic::Factory.new("Projected",
+            proj4: proj4,
+            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)
         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]
+          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 (!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
+              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."
+          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}"
+          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_
+            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."
+          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_srid ||= projection_coord_sys.authority_code if projection_coord_sys
           # Determine geographic coordinate system. First check parameters.
-          proj4_ = opts_[:proj4]
-          coord_sys_ = opts_[:coord_sys]
-          srid_ = opts_[:srid]
+          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 (!proj4 || !coord_sys) && srid && db_
+            entry_ = db_.get(srid.to_i)
             if entry_
-              proj4_ ||= entry_.proj4
-              coord_sys_ ||= entry_.coord_sys
+              proj4 ||= entry_.proj4
+              coord_sys ||= entry_.coord_sys
             end
           end
           # Fall back to getting the values from the projection.
-          proj4_ ||= projection_proj4_.get_geographic || _proj4_4326
-          coord_sys_ ||= projection_coord_sys_.geographic_coordinate_system if projection_coord_sys_
-          srid_ ||= coord_sys_.authority_code if coord_sys_
-          srid_ ||= 4326
+          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_,
-            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_,
-            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])
+          factory = Geographic::Factory.new("Projected",
+            proj4: proj4,
+            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,
+            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])
         end
-        factory_._set_projector(projector_)
-        factory_
+        factory.projector = projector
+        factory
       end
 
-      def _proj4_4055 # :nodoc:
-        unless defined?(@proj4_4055)
-          @proj4_4055 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +no_defs")
+      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
-        @proj4_4055
+        @proj44055
       end
 
-      def _coordsys_4055 # :nodoc:
-        unless defined?(@coordsys_4055)
-          @coordsys_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"]]')
+      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
-        @coordsys_4055
+        @coord_sys_4055
       end
 
-      def _proj4_4326 # :nodoc:
-        unless defined?(@proj4_4326)
-          @proj4_4326 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
+      def proj_4326
+        unless defined?(@proj_4326)
+          @proj_4326 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
         end
-        @proj4_4326
+        @proj_4326
       end
 
-      def _coordsys_4326 # :nodoc:
-        unless defined?(@coordsys_4326)
-          @coordsys_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"]]')
+      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
-        @coordsys_4326
+        @coord_sys_4326
       end
     end
   end

data/lib/rgeo/geographic/proj4_projector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Proj4 projection
@@ -7,22 +9,22 @@
 module RGeo
   module Geographic
     class Proj4Projector # :nodoc:
-      def initialize(geography_factory_, projection_factory_)
-        @geography_factory = geography_factory_
-        @projection_factory = projection_factory_
+      def initialize(geography_factory, projection_factory)
+        @geography_factory = geography_factory
+        @projection_factory = projection_factory
       end
 
-      def _set_factories(geography_factory_, projection_factory_) # :nodoc:
-        @geography_factory = geography_factory_
-        @projection_factory = projection_factory_
+      def set_factories(geography_factory, projection_factory)
+        @geography_factory = geography_factory
+        @projection_factory = projection_factory
       end
 
-      def project(geometry_)
-        Feature.cast(geometry_, @projection_factory, :project)
+      def project(geometry)
+        Feature.cast(geometry, @projection_factory, :project)
       end
 
-      def unproject(geometry_)
-        Feature.cast(geometry_, @geography_factory, :project)
+      def unproject(geometry)
+        Feature.cast(geometry, @geography_factory, :project)
       end
 
       attr_reader :projection_factory
@@ -36,21 +38,24 @@ module RGeo
       end
 
       class << self
-        def create_from_existing_factory(geography_factory_, projection_factory_)
-          new(geography_factory_, projection_factory_)
+        def create_from_existing_factory(geography_factory, projection_factory)
+          new(geography_factory, projection_factory)
         end
 
-        def create_from_proj4(geography_factory_, proj4_, opts_ = {})
-          projection_factory_ = Cartesian.preferred_factory(proj4: proj4_,
-                                                            coord_sys: opts_[:coord_sys], srid: opts_[:srid],
-                                                            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])
-          new(geography_factory_, projection_factory_)
+        def create_from_proj4(geography_factory, proj4, opts = {})
+          projection_factory =
+            Cartesian.preferred_factory(
+              proj4: proj4,
+              coord_sys: opts[:coord_sys], srid: opts[:srid],
+              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]
+            )
+          new(geography_factory, projection_factory)
         end
       end
     end

data/lib/rgeo/geographic/projected_feature_classes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Projtected geographic feature classes
@@ -12,8 +14,6 @@ module RGeo
       include ImplHelper::BasicPointMethods
       include ProjectedGeometryMethods
       include ProjectedPointMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
     end
 
     class ProjectedLineStringImpl  # :nodoc:
@@ -23,8 +23,6 @@ module RGeo
       include ProjectedGeometryMethods
       include ProjectedNCurveMethods
       include ProjectedLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
     end
 
     class ProjectedLinearRingImpl  # :nodoc:
@@ -35,8 +33,6 @@ module RGeo
       include ProjectedGeometryMethods
       include ProjectedNCurveMethods
       include ProjectedLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
     end
 
     class ProjectedLineImpl # :nodoc:
@@ -47,8 +43,6 @@ module RGeo
       include ProjectedGeometryMethods
       include ProjectedNCurveMethods
       include ProjectedLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
     end
 
     class ProjectedPolygonImpl # :nodoc:
@@ -58,8 +52,6 @@ module RGeo
       include ProjectedGeometryMethods
       include ProjectedNSurfaceMethods
       include ProjectedPolygonMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
     end
 
     class ProjectedGeometryCollectionImpl # :nodoc:
@@ -67,8 +59,6 @@ module RGeo
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ProjectedGeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
     end
 
     class ProjectedMultiPointImpl # :nodoc:
@@ -77,8 +67,6 @@ module RGeo
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPointMethods
       include ProjectedGeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
     end
 
     class ProjectedMultiLineStringImpl # :nodoc:
@@ -88,8 +76,6 @@ module RGeo
       include ImplHelper::BasicMultiLineStringMethods
       include ProjectedGeometryMethods
       include ProjectedNCurveMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
     end
 
     class ProjectedMultiPolygonImpl # :nodoc:
@@ -100,8 +86,6 @@ module RGeo
       include ProjectedGeometryMethods
       include ProjectedNSurfaceMethods
       include ProjectedMultiPolygonMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
     end
   end
 end