zm_factory.rb in rgeo-3.0.0.pre.rc.3

- old
+ new

@@ -39,19 +39,18 @@
           new(opts)
         end
       end
 
       def initialize(opts = {}) # :nodoc:
-        proj4 = opts[:proj4]
         coord_sys = opts[:coord_sys]
         srid = opts[:srid]
         srid ||= coord_sys.authority_code if coord_sys
         config = {
           buffer_resolution: opts[:buffer_resolution], auto_prepare: opts[:auto_prepare],
           wkt_generator: opts[:wkt_generator], wkt_parser: opts[:wkt_parser],
           wkb_generator: opts[:wkb_generator], wkb_parser: opts[:wkb_parser],
-          srid: srid.to_i, proj4: proj4, coord_sys: coord_sys
+          srid: srid.to_i, coord_sys: coord_sys
         }
         native_interface = opts[:native_interface] || Geos.preferred_native_interface
         if native_interface == :ffi
           @zfactory = FFIFactory.new(config.merge(has_z_coordinate: true))
           @mfactory = FFIFactory.new(config.merge(has_m_coordinate: true))
@@ -101,26 +100,18 @@
           "wktp" => @wkt_parser.properties,
           "wkbp" => @wkb_parser.properties,
           "apre" => @zfactory.property(:auto_prepare) == :simple,
           "nffi" => @zfactory.is_a?(FFIFactory)
         }
-        proj4 = @zfactory.proj4
         coord_sys = @zfactory.coord_sys
-        hash["proj4"] = proj4.marshal_dump if proj4
         hash["cs"] = coord_sys.to_wkt if coord_sys
         hash
       end
 
       def marshal_load(data) # :nodoc:
-        if (proj4_data = data["proj4"]) && CoordSys.check!(:proj4)
-          proj4 = CoordSys::Proj4.allocate
-          proj4.marshal_load(proj4_data)
-        else
-          proj4 = nil
-        end
         if (coord_sys_data = data["cs"])
-          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data)
         else
           coord_sys = nil
         end
         initialize(
           native_interface: (data["nffi"] ? :ffi : :capi),
@@ -131,11 +122,10 @@
           wkt_generator: symbolize_hash(data["wktg"]),
           wkb_generator: symbolize_hash(data["wkbg"]),
           wkt_parser: symbolize_hash(data["wktp"]),
           wkb_parser: symbolize_hash(data["wkbp"]),
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
 
       # Psych support
@@ -147,32 +137,18 @@
         coder["wkb_generator"] = @wkb_generator.properties
         coder["wkt_parser"] = @wkt_parser.properties
         coder["wkb_parser"] = @wkb_parser.properties
         coder["auto_prepare"] = @zfactory.property(:auto_prepare).to_s
         coder["native_interface"] = @zfactory.is_a?(FFIFactory) ? "ffi" : "capi"
-        if (proj4 = @zfactory.proj4)
-          str = proj4.original_str || proj4.canonical_str
-          coder["proj4"] = proj4.radians? ? { "proj4" => str, "radians" => true } : str
-        end
         if (coord_sys = @zfactory.coord_sys)
           coder["coord_sys"] = coord_sys.to_wkt
         end
       end
 
       def init_with(coder) # :nodoc:
-        if (proj4_data = coder["proj4"])
-          CoordSys.check!(:proj4)
-          if proj4_data.is_a?(Hash)
-            proj4 = CoordSys::Proj4.create(proj4_data["proj4"], radians: proj4_data["radians"])
-          else
-            proj4 = CoordSys::Proj4.create(proj4_data.to_s)
-          end
-        else
-          proj4 = nil
-        end
         if (coord_sys_data = coder["cs"])
-          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data.to_s)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data.to_s)
         else
           coord_sys = nil
         end
         initialize(
           native_interface: coder["native_interface"] == "ffi" ? :ffi : :capi,
@@ -183,11 +159,10 @@
           wkt_generator: symbolize_hash(coder["wkt_generator"]),
           wkb_generator: symbolize_hash(coder["wkb_generator"]),
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
           auto_prepare: coder["auto_prepare"] == "disabled" ? :disabled : :simple,
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
 
       # Returns the SRID of geometries created by this factory.
@@ -301,16 +276,10 @@
 
       def multi_polygon(elems)
         create_feature(ZMMultiPolygonImpl, @zfactory.multi_polygon(elems), @mfactory.multi_polygon(elems))
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      def proj4
-        @zfactory.proj4
-      end
-
       # See RGeo::Feature::Factory#coord_sys
 
       def coord_sys
         @zfactory.coord_sys
       end
@@ -326,19 +295,19 @@
         case original
         when ZMGeometryMethods
           # Optimization if we're just changing factories, but to
           # another ZM factory.
           if original.factory != self && ntype == type &&
-              (!project || original.factory.proj4 == @proj4)
+              (!project || original.factory.coord_sys == @coord_sys)
             zresult = original.z_geometry.dup
             zresult.factory = @zfactory
             mresult = original.m_geometry.dup
             mresult.factory = @mfactory
             return original.class.create(self, zresult, mresult)
           end
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
-              (!project || original.factory.proj4 == @proj4) &&
+              (!project || original.factory.coord_sys == @coord_sys) &&
               type.subtypeof?(Feature::LineString) && ntype.subtypeof?(Feature::LineString)
             klass = Factory::IMPL_CLASSES[ntype]
             zresult = klass._copy_from(@zfactory, original.z_geometry)
             mresult = klass._copy_from(@mfactory, original.m_geometry)
             return ZMLineStringImpl.create(self, zresult, mresult)