rgeo-dschee 0.5.4

data/lib/rgeo/coord_sys/cs/factories.rb

@@ -0,0 +1,148 @@
+# -----------------------------------------------------------------------------
+#
+# OGC CS factory for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module CoordSys
+    # This module contains an implementation of the CS (coordinate
+    # systems) package of the OGC Coordinate Transform spec. It provides
+    # classes for representing ellipsoids, datums, coordinate systems,
+    # and other related concepts, as well as a parser for the WKT format
+    # for specifying coordinate systems.
+    #
+    # Generally, the easiest way to create coordinate system objects is
+    # to use RGeo::CoordSys::CS.create_from_wkt, which parses the WKT
+    # format. You can also use the create methods available for each
+    # object class.
+    #
+    # Most but not all of the spec is implemented here.
+    # Currently missing are:
+    #
+    # * XML format is not implemented. We're assuming that WKT is the
+    #   preferred format.
+    # * The PT and CT packages are not implemented.
+    # * FittedCoordinateSystem is not implemented.
+    # * The defaultEnvelope attribute of CS_CoordinateSystem is not
+    #   implemented.
+
+    module CS
+      # A class implementing the CS_CoordinateSystemFactory interface.
+      # It provides methods for building up complex objects from simpler
+      # objects or values.
+      #
+      # Note that the methods of CS_CoordinateSystemFactory do not provide
+      # facilities for setting the authority. If you need to set authority
+      # values, use the create methods for the object classes themselves.
+
+      class CoordinateSystemFactory
+        # Create a CompoundCoordinateSystem from a name, and two
+        # constituent coordinate systems.
+
+        def create_compound_coordinate_system(name_, head_, tail_)
+          CompoundCoordinateSystem.create(name_, head_, tail_)
+        end
+
+        # Create an Ellipsoid from a name, semi-major axis, and semi-minor
+        # axis. You can also provide a LinearUnit, but this is optional
+        # and may be set to nil.
+
+        def create_ellipsoid(name_, semi_major_axis_, semi_minor_axis_, linear_unit_)
+          Ellipsoid.create_ellipsoid(name_, semi_major_axis_, semi_minor_axis_, linear_unit_)
+        end
+
+        # Create an Ellipsoid from a name, semi-major axis, and an inverse
+        # flattening factor. You can also provide a LinearUnit, but this
+        # is optional and may be set to nil.
+
+        def create_flattened_sphere(name_, semi_major_axis_, inverse_flattening_, linear_unit_)
+          Ellipsoid.create_flattened_sphere(name_, semi_major_axis_, inverse_flattening_, linear_unit_)
+        end
+
+        # Create any object given the OGC WKT format. Raises
+        # Error::ParseError if a syntax error is encounterred.
+
+        def create_from_wkt(str_)
+          WKTParser.new(str_).parse
+        end
+
+        # Create a GeographicCoordinateSystem, given a name, an
+        # AngularUnit, a HorizontalDatum, a PrimeMeridian, and two
+        # AxisInfo objects. The AxisInfo objects are optional and may be
+        # set to nil.
+
+        def create_geographic_coordinate_system(name_, angular_unit_, horizontal_datum_, prime_meridian_, axis0_, axis1_)
+          GeographicCoordinateSystem.create(name_, angular_unit_, horizontal_datum_, prime_meridian_, axis0_, axis1_)
+        end
+
+        # Create a HorizontalDatum given a name, a horizontal datum type
+        # code, an Ellipsoid, and a WGS84ConversionInfo. The
+        # WGS84ConversionInfo is optional and may be set to nil.
+
+        def create_horizontal_datum(name_, horizontal_datum_type_, ellipsoid_, to_wgs84_)
+          HorizontalDatum.create(name_, horizontal_datum_type_, ellipsoid_, to_wgs84_)
+        end
+
+        # Create a LocalCoordinateSystem given a name, a LocalDatum, a
+        # Unit, and an array of at least one AxisInfo.
+
+        def create_local_coordinate_system(name_, datum_, unit_, axes_)
+          LocalCoordinateSystem.create(name_, datum_, unit_, axes_)
+        end
+
+        # Create a LocalDatum given a name and a local datum type code.
+
+        def create_local_datum(_name_, local_datum_type_)
+          LocalDatum.create(name, local_datum_type_)
+        end
+
+        # Create a PrimeMeridian given a name, an AngularUnit, and a
+        # longitude offset.
+
+        def create_prime_meridian(_name_, angular_unit_, longitude_)
+          PrimeMeridian.create(name, angular_unit_, longitude_)
+        end
+
+        # Create a ProjectedCoordinateSystem given a name, a
+        # GeographicCoordinateSystem, and Projection, a LinearUnit, and
+        # two AxisInfo objects. The AxisInfo objects are optional and may
+        # be set to nil.
+
+        def create_projected_coordinate_system(name_, gcs_, projection_, linear_unit_, axis0_, axis1_)
+          ProjectedCoordinateSystem.create(name_, gcs_, projection_, linear_unit_, axis0_, axis1_)
+        end
+
+        # Create a Projection given a name, a projection class, and an
+        # array of ProjectionParameter.
+
+        def create_projection(name_, wkt_projection_class_, parameters_)
+          Projection.create(name_, wkt_projection_class_, parameters_)
+        end
+
+        # Create a VerticalCoordinateSystem given a name, a VerticalDatum,
+        # a VerticalUnit, and an AxisInfo. The AxisInfo is optional and
+        # may be nil.
+
+        def create_vertical_coordinate_system(name_, vertical_datum_, vertical_unit_, axis_)
+          VerticalCoordinateSystem.create(name_, vertical_datum_, vertical_unit_, axis_)
+        end
+
+        # Create a VerticalDatum given a name ane a datum type code.
+
+        def create_vertical_datum(name_, vertical_datum_type_)
+          VerticalDatum.create(name_, vertical_datum_type_)
+        end
+      end
+
+      class << self
+        # Parsees OGC WKT format and returns the object created. Raises
+        # Error::ParseError if a syntax error is encounterred.
+
+        def create_from_wkt(str_)
+          WKTParser.new(str_).parse
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/coord_sys/cs/wkt_parser.rb

@@ -0,0 +1,272 @@
+# -----------------------------------------------------------------------------
+#
+# OGC CS wkt parser for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module CoordSys
+    module CS
+      class WKTParser # :nodoc:
+        def initialize(str_)
+          @scanner = ::StringScanner.new(str_)
+          next_token
+        end
+
+        def parse(containing_type_ = nil) # :nodoc:
+          if @cur_token.is_a?(QuotedString) ||
+            @cur_token.is_a?(::Numeric) ||
+            (containing_type_ == "AXIS" && @cur_token.is_a?(TypeString))
+            value_ = @cur_token
+            next_token
+            return value_
+          end
+          unless @cur_token.is_a?(TypeString)
+            raise Error::ParseError("Found token #{@cur_token} when we expected a value")
+          end
+          type_ = @cur_token
+          next_token
+          consume_token_type(:begin)
+          args_ = ArgumentList.new
+          args_ << parse(type_)
+          loop do
+            break unless @cur_token == :comma
+            next_token
+            args_ << parse(type_)
+          end
+          consume_token_type(:end)
+          obj_ = nil
+          case type_
+          when "AUTHORITY"
+            obj_ = AuthorityClause.new(args_.shift(QuotedString), args_.shift(QuotedString))
+          when "EXTENSION"
+            obj_ = ExtensionClause.new(args_.shift(QuotedString), args_.shift(QuotedString))
+          when "AXIS"
+            obj_ = AxisInfo.create(args_.shift(QuotedString), args_.shift(TypeString))
+          when "TOWGS84"
+            bursa_wolf_params_ = args_.find_all(::Numeric)
+            unless bursa_wolf_params_.size == 7
+              raise Error::ParseError("Expected 7 Bursa Wolf parameters but found #{bursa_wolf_params_.size}")
+            end
+            obj_ = WGS84ConversionInfo.create(*bursa_wolf_params_)
+          when "UNIT"
+            case containing_type_
+            when "GEOCCS", "VERT_CS", "PROJCS", "SPHEROID"
+              klass_ = LinearUnit
+            when "GEOGCS"
+              klass_ = AngularUnit
+            else
+              klass_ = Unit
+            end
+            obj_ = klass_.create(args_.shift(QuotedString), args_.shift(::Numeric), *args_.create_optionals)
+          when "PARAMETER"
+            obj_ = ProjectionParameter.create(args_.shift(QuotedString), args_.shift(::Numeric))
+          when "PRIMEM"
+            obj_ = PrimeMeridian.create(args_.shift(QuotedString), nil, args_.shift(::Numeric), *args_.create_optionals)
+          when "SPHEROID"
+            obj_ = Ellipsoid.create_flattened_sphere(args_.shift(QuotedString), args_.shift(::Numeric), args_.shift(::Numeric), args_.find_first(LinearUnit), *args_.create_optionals)
+          when "PROJECTION"
+            name_ = args_.shift(QuotedString)
+            obj_ = Projection.create(name_, name_, args_.find_all(ProjectionParameter), *args_.create_optionals)
+          when "DATUM"
+            name_ = args_.shift(QuotedString)
+            ellipsoid_ = args_.find_first(Ellipsoid)
+            to_wgs84_ = args_.find_first(WGS84ConversionInfo)
+            obj_ = HorizontalDatum.create(name_, HD_GEOCENTRIC, ellipsoid_, to_wgs84_, *args_.create_optionals)
+          when "VERT_DATUM"
+            obj_ = VerticalDatum.create(args_.shift(QuotedString), args_.shift(::Numeric), *args_.create_optionals)
+          when "LOCAL_DATUM"
+            obj_ = LocalDatum.create(args_.shift(QuotedString), args_.shift(::Numeric), *args_.create_optionals)
+          when "COMPD_CS"
+            obj_ = CompoundCoordinateSystem.create(args_.shift(QuotedString), args_.shift(CoordinateSystem), args_.shift(CoordinateSystem), *args_.create_optionals)
+          when "LOCAL_CS"
+            name_ = args_.shift(QuotedString)
+            local_datum_ = args_.find_first(LocalDatum)
+            unit_ = args_.find_first(Unit)
+            axes_ = args_.find_all(AxisInfo)
+            unless axes_.size > 0
+              raise Error::ParseError("Expected at least one AXIS in a LOCAL_CS")
+            end
+            obj_ = LocalCoordinateSystem.create(name_, local_datum_, unit_, axes_, *args_.create_optionals)
+          when "GEOCCS"
+            name_ = args_.shift(QuotedString)
+            horizontal_datum_ = args_.find_first(HorizontalDatum)
+            prime_meridian_ = args_.find_first(PrimeMeridian)
+            linear_unit_ = args_.find_first(LinearUnit)
+            axes_ = args_.find_all(AxisInfo)
+            unless axes_.size == 0 || axes_.size == 3
+              raise Error::ParseError("GEOCCS must contain either 0 or 3 AXIS parameters")
+            end
+            obj_ = GeocentricCoordinateSystem.create(name_, horizontal_datum_, prime_meridian_, linear_unit_, axes_[0], axes_[1], axes_[2], *args_.create_optionals)
+          when "VERT_CS"
+            name_ = args_.shift(QuotedString)
+            vertical_datum_ = args_.find_first(VerticalDatum)
+            linear_unit_ = args_.find_first(LinearUnit)
+            axis_ = args_.find_first(AxisInfo)
+            obj_ = VerticalCoordinateSystem.create(name_, vertical_datum_, linear_unit_, axis_, *args_.create_optionals)
+          when "GEOGCS"
+            name_ = args_.shift(QuotedString)
+            horizontal_datum_ = args_.find_first(HorizontalDatum)
+            prime_meridian_ = args_.find_first(PrimeMeridian)
+            angular_unit_ = args_.find_first(AngularUnit)
+            axes_ = args_.find_all(AxisInfo)
+            unless axes_.size == 0 || axes_.size == 2
+              raise Error::ParseError("GEOGCS must contain either 0 or 2 AXIS parameters")
+            end
+            obj_ = GeographicCoordinateSystem.create(name_, angular_unit_, horizontal_datum_, prime_meridian_, axes_[0], axes_[1], *args_.create_optionals)
+          when "PROJCS"
+            name_ = args_.shift(QuotedString)
+            geographic_coordinate_system_ = args_.find_first(GeographicCoordinateSystem)
+            projection_ = args_.find_first(Projection)
+            parameters_ = args_.find_all(ProjectionParameter)
+            projection_.instance_variable_get(:@parameters).concat(parameters_)
+            linear_unit_ = args_.find_first(LinearUnit)
+            axes_ = args_.find_all(AxisInfo)
+            unless axes_.size == 0 || axes_.size == 2
+              raise Error::ParseError("PROJCS must contain either 0 or 2 AXIS parameters")
+            end
+            obj_ = ProjectedCoordinateSystem.create(name_, geographic_coordinate_system_, projection_, linear_unit_, axes_[0], axes_[1], *args_.create_optionals)
+          else
+            raise Error::ParseError, "Unrecognized type: #{type_}"
+          end
+          args_.assert_empty
+          obj_
+        end
+
+        def consume_token_type(type_) # :nodoc:
+          expect_token_type(type_)
+          tok_ = @cur_token
+          next_token
+          tok_
+        end
+
+        def expect_token_type(type_) # :nodoc:
+          unless type_ === @cur_token
+            raise Error::ParseError, "#{type_.inspect} expected but #{@cur_token.inspect} found."
+          end
+        end
+
+        def next_token # :nodoc:
+          @scanner.skip(/\s+/)
+          case @scanner.peek(1)
+          when '"'
+            @scanner.getch
+            @cur_token = QuotedString.new(@scanner.scan(/[^"]*/))
+            @scanner.getch
+          when ","
+            @scanner.getch
+            @cur_token = :comma
+          when "(", "["
+            @scanner.getch
+            @cur_token = :begin
+          when "]", ")"
+            @scanner.getch
+            @cur_token = :end
+          when /[a-zA-Z]/
+            @cur_token = TypeString.new(@scanner.scan(/[a-zA-Z]\w*/))
+          when "", nil
+            @cur_token = nil
+          else
+            @scanner.scan_until(/[^\s\(\)\[\],"]+/)
+            token_ = @scanner.matched
+            if token_ =~ /^[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?$/
+              @cur_token = token_.to_f
+            else
+              raise Error::ParseError, "Bad token: #{token_.inspect}"
+            end
+          end
+          @cur_token
+        end
+
+        attr_reader :cur_token
+
+        class QuotedString < ::String # :nodoc:
+        end
+
+        class TypeString < ::String # :nodoc:
+        end
+
+        class AuthorityClause # :nodoc:
+          def initialize(name_, code_) # :nodoc:
+            @name = name_
+            @code = code_
+          end
+
+          def to_a # :nodoc:
+            [@name, @code]
+          end
+        end
+
+        class ExtensionClause # :nodoc:
+          def initialize(key_, value_) # :nodoc:
+            @key = key_
+            @value = value_
+          end
+
+          attr_reader :key # :nodoc:
+          attr_reader :value # :nodoc:
+        end
+
+        class ArgumentList # :nodoc:
+          def initialize  # :nodoc:
+            @values = []
+          end
+
+          def <<(value_)  # :nodoc:
+            @values << value_
+          end
+
+          def assert_empty # :nodoc:
+            if @values.size > 0
+              names_ = @values.map do |val_|
+                val_.is_a?(Base) ? val_._wkt_typename : val_.inspect
+              end
+              raise Error::ParseError, "#{@values.size} unexpected arguments: #{names_.join(', ')}"
+            end
+          end
+
+          def find_first(klass_) # :nodoc:
+            @values.each_with_index do |val_, index_|
+              if val_.is_a?(klass_)
+                @values.slice!(index_)
+                return val_
+              end
+            end
+            nil
+          end
+
+          def find_all(klass_)  # :nodoc:
+            results_ = []
+            nvalues_ = []
+            @values.each do |val_|
+              if val_.is_a?(klass_)
+                results_ << val_
+              else
+                nvalues_ << val_
+              end
+            end
+            @values = nvalues_
+            results_
+          end
+
+          def create_optionals  # :nodoc:
+            hash_ = {}
+            find_all(ExtensionClause).each { |ec_| hash_[ec_.key] = ec_.value }
+            (find_first(AuthorityClause) || [nil, nil]).to_a + [nil, nil, nil, hash_]
+          end
+
+          def shift(klass_ = nil) # :nodoc:
+            val_ = @values.shift
+            unless val_
+              raise Error::ParseError, "No arguments left... expected #{klass_}"
+            end
+            if klass_ && !val_.is_a?(klass_)
+              raise Error::ParseError, "Expected #{klass_} but got #{val_.class}"
+            end
+            val_
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/coord_sys/proj4.rb

@@ -0,0 +1,293 @@
+# -----------------------------------------------------------------------------
+#
+# Proj4 wrapper for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module CoordSys
+    # This is a Ruby wrapper around a Proj4 coordinate system.
+    # It represents a single geographic coordinate system, which may be
+    # a flat projection, a geocentric (3-dimensional) coordinate system,
+    # or a geographic (latitude-longitude) coordinate system.
+    #
+    # Generally, these are used to define the projection for a
+    # Feature::Factory. You can then convert between coordinate systems
+    # by casting geometries between such factories using the :project
+    # option. You may also use this object directly to perform low-level
+    # coordinate transformations.
+
+    class Proj4
+      def inspect # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} #{canonical_str.inspect}>"
+      end
+
+      def to_s  # :nodoc:
+        canonical_str
+      end
+
+      def hash  # :nodoc:
+        @hash ||= canonical_hash.hash
+      end
+
+      # Returns true if this Proj4 is equivalent to the given Proj4.
+      #
+      # Note: this tests for equivalence by comparing only the hash
+      # definitions of the Proj4 objects, and returning true if those
+      # definitions are equivalent. In some cases, this may still return
+      # false even if the actual coordinate systems are identical, since
+      # there are sometimes multiple ways to express a given coordinate
+      # system.
+
+      def eql?(rhs_)
+        rhs_.class == self.class && rhs_.canonical_hash == canonical_hash && rhs_._radians? == _radians?
+      end
+      alias_method :==, :eql?
+
+      # Marshal support
+
+      def marshal_dump # :nodoc:
+        { "rad" => radians?, "str" => original_str || canonical_str }
+      end
+
+      def marshal_load(data_) # :nodoc:
+        _set_value(data_["str"], data_["rad"])
+      end
+
+      # Psych support
+
+      def encode_with(coder_) # :nodoc:
+        coder_["proj4"] = original_str || canonical_str
+        coder_["radians"] = radians?
+      end
+
+      def init_with(coder_) # :nodoc:
+        if coder_.type == :scalar
+          _set_value(coder_.scalar, false)
+        else
+          _set_value(coder_["proj4"], coder_["radians"])
+        end
+      end
+
+      # Returns the "canonical" string definition for this coordinate
+      # system, as reported by Proj4. This may be slightly different
+      # from the definition used to construct this object.
+
+      def canonical_str
+        unless defined?(@canonical_str)
+          @canonical_str = _canonical_str
+          if @canonical_str.respond_to?(:force_encoding)
+            @canonical_str.force_encoding("US-ASCII")
+          end
+        end
+        @canonical_str
+      end
+
+      # Returns the "canonical" hash definition for this coordinate
+      # system, as reported by Proj4. This may be slightly different
+      # from the definition used to construct this object.
+
+      def canonical_hash
+        unless defined?(@canonical_hash)
+          @canonical_hash = {}
+          canonical_str.strip.split(/\s+/).each do |elem_|
+            @canonical_hash[Regexp.last_match(1)] = Regexp.last_match(3) if elem_ =~ /^\+(\w+)(=(\S+))?$/
+          end
+        end
+        @canonical_hash
+      end
+
+      # Returns the string definition originally used to construct this
+      # object. Returns nil if this object wasn't created by a string
+      # definition; i.e. if it was created using get_geographic.
+
+      def original_str
+        _original_str
+      end
+
+      # Returns true if this Proj4 object is a geographic (lat-long)
+      # coordinate system.
+
+      def geographic?
+        _geographic?
+      end
+
+      # Returns true if this Proj4 object is a geocentric (3dz)
+      # coordinate system.
+
+      def geocentric?
+        _geocentric?
+      end
+
+      # Returns true if this Proj4 object uses radians rather than degrees
+      # if it is a geographic coordinate system.
+
+      def radians?
+        _radians?
+      end
+
+      # Get the geographic (unprojected lat-long) coordinate system
+      # corresponding to this coordinate system; i.e. the one that uses
+      # the same ellipsoid and datum.
+
+      def get_geographic
+        _get_geographic
+      end
+
+      class << self
+        # Returns true if Proj4 is supported in this installation.
+        # If this returns false, the other methods such as create
+        # will not work.
+
+        def supported?
+          respond_to?(:_create)
+        end
+
+        # Returns the Proj library version as a string of the format "x.y.z".
+
+        def version
+          ::RGeo::VERSION
+        end
+
+        # Create a new Proj4 object, given a definition, which may be
+        # either a string or a hash. Returns nil if the given definition
+        # is invalid or Proj4 is not supported.
+        #
+        # Recognized options include:
+        #
+        # [<tt>:radians</tt>]
+        #   If set to true, then this proj4 will represent geographic
+        #   (latitude/longitude) coordinates in radians rather than
+        #   degrees. If this is a geographic coordinate system, then its
+        #   units will be in radians. If this is a projected coordinate
+        #   system, then its units will be unchanged, but any geographic
+        #   coordinate system obtained using get_geographic will use
+        #   radians as its units. If this is a geocentric or other type of
+        #   coordinate system, this has no effect. Default is false.
+        #   (That is all coordinates are in degrees by default.)
+
+        def create(defn_, opts_ = {})
+          result_ = nil
+          if supported?
+            if defn_.is_a?(::Hash)
+              defn_ = defn_.map { |k_, v_| v_ ? "+#{k_}=#{v_}" : "+#{k_}" }.join(" ")
+            end
+            unless defn_ =~ /^\s*\+/
+              defn_ = defn_.sub(/^(\s*)/, '\1+').gsub(/(\s+)([^+\s])/, '\1+\2')
+            end
+            result_ = _create(defn_, opts_[:radians])
+            result_ = nil unless result_._valid?
+          end
+          result_
+        end
+
+        # Create a new Proj4 object, given a definition, which may be
+        # either a string or a hash. Raises Error::UnsupportedOperation
+        # if the given definition is invalid or Proj4 is not supported.
+        #
+        # Recognized options include:
+        #
+        # [<tt>:radians</tt>]
+        #   If set to true, then this proj4 will represent geographic
+        #   (latitude/longitude) coordinates in radians rather than
+        #   degrees. If this is a geographic coordinate system, then its
+        #   units will be in radians. If this is a projected coordinate
+        #   system, then its units will be unchanged, but any geographic
+        #   coordinate system obtained using get_geographic will use
+        #   radians as its units. If this is a geocentric or other type of
+        #   coordinate system, this has no effect. Default is false.
+        #   (That is all coordinates are in degrees by default.)
+
+        def new(defn_, opts_ = {})
+          result_ = create(defn_, opts_)
+          unless result_
+            raise Error::UnsupportedOperation, "Proj4 not supported in this installation"
+          end
+          result_
+        end
+
+        # Low-level coordinate transform method.
+        # Transforms the given coordinate (x, y, [z]) from one proj4
+        # coordinate system to another. Returns an array with either two
+        # or three elements.
+
+        def transform_coords(from_proj_, to_proj_, x_, y_, z_ = nil)
+          if !from_proj_._radians? && from_proj_._geographic?
+            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+          end
+          result_ = _transform_coords(from_proj_, to_proj_, x_, y_, z_)
+          if result_ && !to_proj_._radians? && to_proj_._geographic?
+            result_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
+            result_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
+          end
+          result_
+        end
+
+        # Low-level geometry transform method.
+        # Transforms the given geometry between the given two projections.
+        # The resulting geometry is constructed using the to_factory.
+        # Any projections associated with the factories themselves are
+        # ignored.
+
+        def transform(from_proj_, from_geometry_, to_proj_, to_factory_)
+          case from_geometry_
+          when Feature::Point
+            _transform_point(from_proj_, from_geometry_, to_proj_, to_factory_)
+          when Feature::Line
+            to_factory_.line(from_geometry_.points.map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+          when Feature::LinearRing
+            _transform_linear_ring(from_proj_, from_geometry_, to_proj_, to_factory_)
+          when Feature::LineString
+            to_factory_.line_string(from_geometry_.points.map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+          when Feature::Polygon
+            _transform_polygon(from_proj_, from_geometry_, to_proj_, to_factory_)
+          when Feature::MultiPoint
+            to_factory_.multi_point(from_geometry_.map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+          when Feature::MultiLineString
+            to_factory_.multi_line_string(from_geometry_.map { |g_| transform(from_proj_, g_, to_proj_, to_factory_) })
+          when Feature::MultiPolygon
+            to_factory_.multi_polygon(from_geometry_.map { |p_| _transform_polygon(from_proj_, p_, to_proj_, to_factory_) })
+          when Feature::GeometryCollection
+            to_factory_.collection(from_geometry_.map { |g_| transform(from_proj_, g_, to_proj_, to_factory_) })
+          end
+        end
+
+        def _transform_point(from_proj_, from_point_, to_proj_, to_factory_) # :nodoc:
+          from_factory_ = from_point_.factory
+          from_has_z_ = from_factory_.property(:has_z_coordinate)
+          from_has_m_ = from_factory_.property(:has_m_coordinate)
+          to_has_z_ = to_factory_.property(:has_z_coordinate)
+          to_has_m_ = to_factory_.property(:has_m_coordinate)
+          x_ = from_point_.x
+          y_ = from_point_.y
+          if !from_proj_._radians? && from_proj_._geographic?
+            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
+          end
+          coords_ = _transform_coords(from_proj_, to_proj_, x_, y_, from_has_z_ ? from_point_.z : nil)
+          if coords_
+            if !to_proj_._radians? && to_proj_._geographic?
+              coords_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
+              coords_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
+            end
+            extras_ = []
+            extras_ << coords_[2].to_f if to_has_z_
+            extras_ << from_has_m_ ? from_point_.m : 0.0 if to_has_m_
+            to_factory_.point(coords_[0], coords_[1], *extras_)
+          end
+        end
+
+        def _transform_linear_ring(from_proj_, from_ring_, to_proj_, to_factory_) # :nodoc:
+          to_factory_.linear_ring(from_ring_.points[0..-2].map { |p_| _transform_point(from_proj_, p_, to_proj_, to_factory_) })
+        end
+
+        def _transform_polygon(from_proj_, from_polygon_, to_proj_, to_factory_) # :nodoc:
+          ext_ = _transform_linear_ring(from_proj_, from_polygon_.exterior_ring, to_proj_, to_factory_)
+          int_ = from_polygon_.interior_rings.map { |r_| _transform_linear_ring(from_proj_, r_, to_proj_, to_factory_) }
+          to_factory_.polygon(ext_, int_)
+        end
+      end
+    end
+  end
+end