rgeo 0.1.19 → 0.1.20

data/lib/rgeo/geo_json/interface.rb

@@ -43,7 +43,7 @@ module RGeo
       
       # High-level convenience routine for encoding an object as GeoJSON.
       # Pass the object, which may one of the geometry objects specified
-      # in RGeo::Features, or an appropriate GeoJSON wrapper entity such
+      # in RGeo::Feature, or an appropriate GeoJSON wrapper entity such
       # as RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
       # 
       # The only option supported is <tt>:entity_factory</tt>, which lets
@@ -91,7 +91,7 @@ module RGeo
       
       # Creates and returns a coder object of type RGeo::GeoJSON::Coder
       # that encapsulates encoding and decoding settings (principally the
-      # RGeo::Features::Factory and the RGeo::GeoJSON::EntityFactory to be
+      # RGeo::Feature::Factory and the RGeo::GeoJSON::EntityFactory to be
       # used).
       # 
       # The geo factory is a required argument. Other options include:

data/lib/rgeo/geography.rb

@@ -41,19 +41,46 @@ require 'rgeo'
 module RGeo
   
   
-  # The Geography implementation provides geographic features using
-  # latitude/longitude coordinates measured in degrees.
+  # The Geography implementation actually comprises a suite of
+  # implementations with one common feature: they represent geographic
+  # latitude/longitude coordinates measured in degrees. The "x"
+  # coordinate corresponds to longitude, and the "y" coordinate to
+  # latitude. Thus, coordinates are often expressed in reverse
+  # (i.e. long-lat) order. e.g.
+  # 
+  #  location = geography_factory.point(long, lat)
+  # 
+  # Some geography implementations include a secondary factory that
+  # represents a projection. For these implementations, you can quickly
+  # transform data between lat/long coordinates and the projected
+  # coordinate system, and most calculations are done in the projected
+  # coordinate system. For implementations that do not include this
+  # secondary projection factory, calculations are done on the sphereoid.
+  # See the various class methods of Geography for more information on
+  # the behaviors of the factories they generate.
   
   module Geography
-    
-    autoload(:SimpleSpherical, 'rgeo/geography/simple_spherical')
-    autoload(:SimpleMercator, 'rgeo/geography/simple_mercator')
-    
   end
   
   
 end
 
 
+# Dependency files
+require 'rgeo/feature'
+require 'rgeo/coord_sys'
+require 'rgeo/wkrep'
+require 'rgeo/impl_helper'
+require 'rgeo/cartesian'
+
 # Implementation files.
+require 'rgeo/geography/factory'
+require 'rgeo/geography/projected_window'
 require 'rgeo/geography/interface'
+require 'rgeo/geography/spherical_math'
+require 'rgeo/geography/spherical_feature_methods'
+require 'rgeo/geography/spherical_feature_classes'
+require 'rgeo/geography/proj4_projector'
+require 'rgeo/geography/simple_mercator_projector'
+require 'rgeo/geography/projected_feature_methods'
+require 'rgeo/geography/projected_feature_classes'

data/lib/rgeo/geography/factory.rb

@@ -45,31 +45,58 @@ module RGeo
     
     class Factory
       
-      include Features::Factory::Instance
-      
-      
-      def initialize(namespace_, opts_={})  # :nodoc:
-        @namespace = namespace_
-        @opts = opts_.dup
-        if @namespace.const_defined?(:Projector)
-          @projector = @namespace.const_get(:Projector).new(self, opts_)
-        else
-          @projector = nil
-        end
+      include Feature::Factory::Instance
+      
+      
+      def initialize(impl_prefix_, opts_={})  # :nodoc:
+        @impl_prefix = impl_prefix_
+        @point_class = Geography.const_get("#{impl_prefix_}PointImpl")
+        @line_string_class = Geography.const_get("#{impl_prefix_}LineStringImpl")
+        @linear_ring_class = Geography.const_get("#{impl_prefix_}LinearRingImpl")
+        @line_class = Geography.const_get("#{impl_prefix_}LineImpl")
+        @polygon_class = Geography.const_get("#{impl_prefix_}PolygonImpl")
+        @geometry_collection_class = Geography.const_get("#{impl_prefix_}GeometryCollectionImpl")
+        @multi_point_class = Geography.const_get("#{impl_prefix_}MultiPointImpl")
+        @multi_line_string_class = Geography.const_get("#{impl_prefix_}MultiLineStringImpl")
+        @multi_polygon_class = Geography.const_get("#{impl_prefix_}MultiPolygonImpl")
         @support_z = opts_[:support_z_coordinate] ? true : false
         @support_m = opts_[:support_m_coordinate] ? true : false
+        @srid = opts_[:srid] || 4326
+        @proj4 = opts_[:proj4]
+        if CoordSys::Proj4.supported?
+          if @proj4.kind_of?(::String) || @proj4.kind_of?(::Hash)
+            @proj4 = CoordSys::Proj4.create(@proj4)
+          end
+        else
+          @proj4 = nil
+        end
+      end
+      
+      
+      def _set_projector(projector_)  # :nodoc:
+        @projector = projector_
       end
       
       
       # Equivalence test.
       
       def eql?(rhs_)
-        rhs_.is_a?(self.class) && @namespace == rhs_.instance_variable_get(:@namespace) &&
-          @opts == rhs_.instance_variable_get(:@opts)
+        rhs_.is_a?(Geography::Factory) &&
+          @impl_prefix == rhs_.instance_variable_get(:@impl_prefix) &&
+          @support_z == rhs_.instance_variable_get(:@support_z) &&
+          @support_m == rhs_.instance_variable_get(:@support_m) &&
+          @proj4 == rhs_.instance_variable_get(:@proj4)
       end
       alias_method :==, :eql?
       
       
+      # Returns the srid reported by this factory.
+      
+      def srid
+        @srid
+      end
+      
+      
       # Returns true if this factory supports a projection.
       
       def has_projection?
@@ -88,13 +115,13 @@ module RGeo
       # Projects the given geometry into the projected coordinate space,
       # and returns the projected geometry.
       # Returns nil if this factory does not support a projection.
-      # Raises Errors::InvalidGeometry if the given geometry is not of
+      # Raises Error::InvalidGeometry if the given geometry is not of
       # this factory.
       
       def project(geometry_)
         return nil unless @projector
         unless geometry_.factory == self
-          raise Errors::InvalidGeometry, 'Wrong geometry type'
+          raise Error::InvalidGeometry, 'Wrong geometry type'
         end
         @projector.project(geometry_)
       end
@@ -102,12 +129,12 @@ module RGeo
       
       # Reverse-projects the given geometry from the projected coordinate
       # space into lat-long space.
-      # Raises Errors::InvalidGeometry if the given geometry is not of
+      # Raises Error::InvalidGeometry if the given geometry is not of
       # the projection defined by this factory.
       
       def unproject(geometry_)
         unless @projector && @projector.projection_factory == geometry_.factory
-          raise Errors::InvalidGeometry, 'You can unproject only features that are in the projected coordinate space.'
+          raise Error::InvalidGeometry, 'You can unproject only features that are in the projected coordinate space.'
         end
         @projector.unproject(geometry_)
       end
@@ -128,11 +155,18 @@ module RGeo
       # Returns nil if this factory does not support a projection.
       
       def projection_limits_window
-        @projector ? (@projection_limits_window ||= @projector.limits_window) : nil
+        if @projector
+          unless defined?(@projection_limits_window)
+            @projection_limits_window = @projector.limits_window
+          end
+          @projection_limits_window
+        else
+          nil
+        end
       end
       
       
-      # See ::RGeo::Features::Factory#has_capability?
+      # See ::RGeo::Feature::Factory#has_capability?
       
       def has_capability?(name_)
         case name_
@@ -140,86 +174,95 @@ module RGeo
           @support_z
         when :m_coordinate
           @support_m
+        when :proj4
+          @proj4 ? true : false
         else
           nil
         end
       end
       
       
-      # See ::RGeo::Features::Factory#parse_wkt
+      # See ::RGeo::Feature::Factory#parse_wkt
       
       def parse_wkt(str_)
         WKRep::WKTParser.new(:default_factory => self).parse(str_)
       end
       
       
-      # See ::RGeo::Features::Factory#parse_wkb
+      # See ::RGeo::Feature::Factory#parse_wkb
       
       def parse_wkb(str_)
         WKRep::WKBParser.new(:default_factory => self).parse(str_)
       end
       
       
-      # See ::RGeo::Features::Factory#point
+      # See ::RGeo::Feature::Factory#point
       
       def point(x_, y_, *extra_)
-        @namespace.const_get(:PointImpl).new(self, x_, y_, *extra_) rescue nil
+        @point_class.new(self, x_, y_, *extra_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#line_string
+      # See ::RGeo::Feature::Factory#line_string
       
       def line_string(points_)
-        @namespace.const_get(:LineStringImpl).new(self, points_) rescue nil
+        @line_string_class.new(self, points_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#line
+      # See ::RGeo::Feature::Factory#line
       
       def line(start_, end_)
-        @namespace.const_get(:LineImpl).new(self, start_, end_) rescue nil
+        @line_class.new(self, start_, end_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#linear_ring
+      # See ::RGeo::Feature::Factory#linear_ring
       
       def linear_ring(points_)
-        @namespace.const_get(:LinearRingImpl).new(self, points_) rescue nil
+        @linear_ring_class.new(self, points_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#polygon
+      # See ::RGeo::Feature::Factory#polygon
       
       def polygon(outer_ring_, inner_rings_=nil)
-        @namespace.const_get(:PolygonImpl).new(self, outer_ring_, inner_rings_) rescue nil
+        @polygon_class.new(self, outer_ring_, inner_rings_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#collection
+      # See ::RGeo::Feature::Factory#collection
       
       def collection(elems_)
-        @namespace.const_get(:GeometryCollectionImpl).new(self, elems_) rescue nil
+        @geometry_collection_class.new(self, elems_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#multi_point
+      # See ::RGeo::Feature::Factory#multi_point
       
       def multi_point(elems_)
-        @namespace.const_get(:MultiPointImpl).new(self, elems_) rescue nil
+        @multi_point_class.new(self, elems_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#multi_line_string
+      # See ::RGeo::Feature::Factory#multi_line_string
       
       def multi_line_string(elems_)
-        @namespace.const_get(:MultiLineStringImpl).new(self, elems_) rescue nil
+        @multi_line_string_class.new(self, elems_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#multi_polygon
+      # See ::RGeo::Feature::Factory#multi_polygon
       
       def multi_polygon(elems_)
-        @namespace.const_get(:MultiPolygonImpl).new(self, elems_) rescue nil
+        @multi_polygon_class.new(self, elems_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#proj4
+      
+      def proj4
+        @proj4
       end
       
       

data/lib/rgeo/geography/interface.rb

@@ -41,22 +41,30 @@ module RGeo
     class << self
       
       
-      # Geographic features provided by this factory perform calculations
-      # assuming a spherical earth. In other words, geodesics are treated
-      # as great circle arcs, and size and geometric calculations are
-      # treated accordingly. Distance calculations report results in
-      # meters. This makes this implementation ideal for everyday
-      # calculations on the globe where accuracy within about 0.5 percent
-      # is sufficient.
+      # Creates and returns a geographic factory that does not include a
+      # a projection, and which performs calculations assuming a
+      # spherical earth. In other words, geodesics are treated as great
+      # circle arcs, and geometric calculations are handled accordingly.
+      # Size and distance calculations report results in meters.
+      # This implementation is thus ideal for everyday calculations on
+      # the globe in which good accuracy is desired, but in which it is
+      # not deemed necessary to perform the complex ellipsoidal
+      # calculations needed for greater precision.
+      # 
+      # The maximum error is about 0.5 percent, for objects and
+      # calculations that span a significant percentage of the globe, due
+      # to distortion caused by rotational flattening of the earth. For
+      # calculations that span a much smaller area, the error can drop to
+      # a few meters or less.
       # 
       # === Limitations
       # 
-      # This implementation does not implement many of the more advanced
+      # This implementation does not implement some of the more advanced
       # geometric operations. In particular:
       # 
-      # * Relational operators such as Features::Geometry#intersects? are
+      # * Relational operators such as Feature::Geometry#intersects? are
       #   not implemented for most types.
-      # * Relational constructors such as Features::Geometry#union are
+      # * Relational constructors such as Feature::Geometry#union are
       #   not implemented for most types.
       # * Buffer, convex hull, and envelope calculations are not
       #   implemented for most types. Boundaries are available except for
@@ -69,38 +77,81 @@ module RGeo
       # 
       # Unimplemented operations will return nil if invoked.
       # 
-      # === SRID for simple_spherical
+      # === Options
       # 
-      # Simple_spherical features report SRID=4326, indicating EPSG 4326
-      # (i.e. the WGS84 spheroid and the lat/lon system commonly used by
-      # most GIS systems).
-      # This is technically not correct, for two reasons:
+      # You may use the following options when creating a spherical
+      # factory:
       # 
-      # * We are running calculations on a spherical approximation of the
-      #   WGS84 spheroid rather than the ellipsoidal shape itself.
-      # * While most functions use the EPSG 4326 unit of degrees longitude
-      #   and latitude, a few (specifically, distance and area calculations)
-      #   return their results in meters.
+      # <tt>:support_z_coordinate</tt>::
+      #   Support <tt>z_coordinate</tt>. Default is false.
+      # <tt>:support_m_coordinate</tt>::
+      #   Support <tt>m_coordinate</tt>. Default is false.
+      # <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>: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.
+      
+      def spherical(opts_={})
+        Geography::Factory.new('Spherical', :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate], :proj4 => opts_[:proj4] || '+proj=longlat +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +no_defs', :srid => opts_[:srid] || 4055)
+      end
+      
+      
+      # Creates and returns a geographic factory that is designed for
+      # visualization applications that use Google or Bing maps, or any
+      # other visualization systems that use the same projection. It
+      # includes a projection factory that matches the projection used
+      # by those mapping systems.
+      # 
+      # 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 calculations report results in the projected
+      # units.
+      # 
+      # The behavior of the simple_mercator factory could also be obtained
+      # using a projected with appropriate Proj4 specifications. However,
+      # the simple_mercator implementation is done without actually
+      # requiring the Proj4 library. The projections are simple enough to
+      # be implemented in pure ruby.
       # 
-      # We, however, hereby punt on this issue for this particular factory,
-      # on the theory that, for "most applications" that we expect will
-      # want to use this library, these behaviors are sufficient, and the
-      # SRID imprecision isn't crucial.
-      # Note, however, that this means features created with this factory
-      # may generate slightly different results from geodesic calculations 
-      # than those generated by, e.g., PostGIS (unless you direct PostGIS
-      # to use spherical geodesics).
+      # === About the coordinate system
+      # 
+      # Many popular visualization technologies, such as Google and Bing
+      # maps, actually use two coordinate systems. The first is the
+      # standard WSG84 lat-long system used by the GPS and represented
+      # by EPSG 4326. Most API calls and input-output in these mapping
+      # technologies utilize this coordinate system. The second is a
+      # Mercator projection based on a "sphericalization" of the WGS84
+      # lat-long system. This projection is the basis of the map's screen
+      # and tiling coordinates, and has been assigned EPSG 3857.
+      # 
+      # This factory represents both coordinate systems. The main factory
+      # produces data in the lat-long system and reports SRID 4326, and
+      # the projected factory produces data in the projection and reports
+      # SRID 3857. Latitudes are restricted to the range
+      # (-85.05112877980659, 85.05112877980659), which conveniently
+      # results in a square projected domain.
       # 
       # === Options
       # 
-      # You may use the following options when creating a simple_spherical
+      # You may use the following options when creating a simple_mercator
       # factory:
       # 
       # <tt>:lenient_multi_polygon_assertions</tt>::
       #   If set to true, assertion checking on MultiPolygon is disabled.
       #   This may speed up creation of MultiPolygon objects, at the
       #   expense of not doing the proper checking for OGC MultiPolygon
-      #   compliance. See RGeo::Features::MultiPolygon for details on
+      #   compliance. See RGeo::Feature::MultiPolygon for details on
       #   the MultiPolygon assertions. Default is false.
       # <tt>:buffer_resolution</tt>::
       #   The resolution of buffers around geometries created by this
@@ -121,68 +172,57 @@ module RGeo
       #   <tt>z_coordinate</tt> and <tt>m_coordinate</tt>. They may at
       #   most support one or the other.
       
-      def simple_spherical(opts_={})
-        namespace_ = Geography::SimpleSpherical
-        Geography::Factory.new(namespace_, :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate])
+      def simple_mercator(opts_={})
+        factory_ = Geography::Factory.new('Projected', :proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid => 4326, :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate])
+        projector_ = Geography::SimpleMercatorProjector.new(factory_, :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions], :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate])
+        factory_._set_projector(projector_)
+        factory_
       end
       
       
-      # Geographic features provided by this factory perform calculations
-      # on the simple mercator projection currently used by Google and
-      # Bing maps. This makes this implementation ideal for representing
-      # and performing calculations on features to be visualized using
-      # those technologies. Note, however, that significant discrepancies
-      # may occur for large features between the "mapping visualization"
-      # sizes and shapes, and the actual sizes and shapes on the globe,
-      # because the mercator projection, like all projections of a
-      # non-flat earth onto a flat coordinate system, does introduce
-      # distortions (especially near the poles.)
-      # 
-      # Distance and area computations return results in meters, whereas
-      # all coordinates are represented in degrees latitude and longitude.
-      # 
-      # === About the coordinate system
+      # Creates and returns a geographic factory that includes a
+      # projection specified by a Proj4 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
+      # calculations report results in the projected units.
       # 
-      # This is not a true projected spatial reference: point coordinates
-      # are still represented in degrees latitude and longitude. However,
-      # computations are done in the projected spatial reference. (That
-      # spatial reference is EPSG 3857, for the interested.) This means,
-      # for example, that a line segment whose endpoints fall on a line of
-      # latitude away from the equator will follow the line of latitude
-      # rather than the actual geodesic (which will curve away from the
-      # equator in the projected coordinate system). It also means that
-      # latitudes very near the poles are excluded. Specifically,
-      # latitudes are restricted to the range (-85.05112877980659,
-      # 85.05112877980659), which conveniently results in a square
-      # projected domain.
-      # 
-      # In general, this implementation is designed specifically for
-      # mapping applications using Google and Bing maps, and any others
-      # that use the same projection.
-      # 
-      # Simple_mercator features report SRID=4326, indicating EPSG 4326
-      # (i.e. the WGS84 spheroid and the lat/lon system commonly used by
-      # most GIS systems).
-      # This is actualy grossly inaccurate for a number of reasons, chief
-      # among them being that calculations are being done on a projection,
-      # whereas EPSG 4326 calculations are supposed to be done on the
-      # spheroid. However, we continue to report SRID=4326 because the x
-      # and y coordinates represent latitude and longitude rather than
-      # projected coordinates. There is no EPSG spatial reference that
-      # describes the <i>actual</i> behavior of the common map
-      # visualization APIs, so we've decided to fudge on this in the
-      # interest of being true to our expected application use cases.
+      # This implementation is intended for advanced GIS applications
+      # requiring intimate control over the projection being used.
       # 
       # === Options
       # 
-      # You may use the following options when creating a simple_mercator
-      # factory:
+      # When creating a projected implementation, you must provide either
+      # the <tt>:projection_factory</tt> option, indicating an existing
+      # Cartesian factory to use for the projection, or the
+      # <tt>:projection_proj4</tt> option, indicating a Proj4 projection
+      # to use to construct an appropriate projection factory.
+      # 
+      # If you provide <tt>:projection_factory</tt>, the following options
+      # are supported.
+      # 
+      # <tt>:projection_factory</tt>::
+      #   Specify an existing Cartesian factory to use for the projection.
+      #   This factory must support the <tt>:proj4</tt> capability.
+      # 
+      # Note that in this case, the geography factory's z-coordinate and
+      # m-coordinate availability will be set to match the projection's
+      # z-coordinate and m-coordinate availability.
       # 
+      # If you provide <tt>:projection_proj4</tt>, the following options
+      # are supported.
+      # 
+      # <tt>:projection_proj4</tt>::
+      #   Specify a Proj4 projection to use. This may be specified as a
+      #   CoordSys::Proj4 object, or as a Proj4 string or hash
+      #   representation.
+      # <tt>:projection_srid</tt>::
+      #   An SRID value to use for the projection factory. Default is 0.
       # <tt>:lenient_multi_polygon_assertions</tt>::
       #   If set to true, assertion checking on MultiPolygon is disabled.
       #   This may speed up creation of MultiPolygon objects, at the
       #   expense of not doing the proper checking for OGC MultiPolygon
-      #   compliance. See RGeo::Features::MultiPolygon for details on
+      #   compliance. See RGeo::Feature::MultiPolygon for details on
       #   the MultiPolygon assertions. Default is false.
       # <tt>:buffer_resolution</tt>::
       #   The resolution of buffers around geometries created by this
@@ -194,18 +234,24 @@ module RGeo
       #   for different kinds of buffers is defined by GEOS.
       # <tt>:support_z_coordinate</tt>::
       #   Support <tt>z_coordinate</tt>. Default is false.
-      #   Note that simple_mercator factories cannot support both
-      #   <tt>z_coordinate</tt> and <tt>m_coordinate</tt>. They may at
-      #   most support one or the other.
       # <tt>:support_m_coordinate</tt>::
       #   Support <tt>m_coordinate</tt>. Default is false.
-      #   Note that simple_mercator factories cannot support both
-      #   <tt>z_coordinate</tt> and <tt>m_coordinate</tt>. They may at
-      #   most support one or the other.
       
-      def simple_mercator(opts_={})
-        namespace_ = Geography::SimpleMercator
-        Geography::Factory.new(namespace_, :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions], :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate])
+      def projected(opts_={})
+        unless CoordSys::Proj4.supported?
+          raise Error::UnsupportedCapability, "Proj4 is not supported because the proj4 library was not found at install time."
+        end
+        if (projection_factory_ = opts_[:projection_factory])
+          factory_ = Geography::Factory.new('Projected', :proj4 => opts_[:proj4] || '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid => opts_[:srid] || 4326, :support_z_coordinate => projection_factory_.has_capability?(:z_coordinate), :support_m_coordinate => projection_factory_.has_capability?(:m_coordinate))
+          projector_ = Geography::Proj4Projector.create_from_existing_factory(factory_, projection_factory_)
+        elsif opts_[:projection_proj4]
+          factory_ = Geography::Factory.new('Projected', :proj4 => opts_[:proj4] || '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid => opts_[:srid] || 4326, :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate])
+          projector_ = Geography::Proj4Projector.create_from_proj4(factory_, opts_[:projection_proj4], :srid => opts_[:projection_srid], :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions], :support_z_coordinate => opts_[:support_z_coordinate], :support_m_coordinate => opts_[:support_m_coordinate])
+        else
+          raise ::ArgumentError, 'You must provide either :projection_proj4 or :projection_factory.'
+        end
+        factory_._set_projector(projector_)
+        factory_
       end