rgeo 0.1.10

data/lib/rgeo/geography/common/point_methods.rb

@@ -0,0 +1,149 @@
+# -----------------------------------------------------------------------------
+# 
+# Common methods for Point geography features
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+  
+  module Geography
+    
+    module Common
+      
+      
+      module PointMethods
+        
+        
+        def _setup(x_, y_)
+          @x = x_.to_f
+          @y = y_.to_f
+          _validate_geometry
+        end
+        
+        
+        def x
+          @x
+        end
+        
+        
+        def y
+          @y
+        end
+        
+        
+        def eql?(rhs_)
+          rhs_.is_a?(self.class) && @x == rhs_.x && @y == rhs_.y
+        end
+        alias_method :==, :eql?
+        
+        
+        def cast(type_)
+          case type_
+          when Features::Point
+            self
+          when Features::GeometryCollection
+            factory.collection([self]) rescue nil
+          when Features::MultiPoint
+            factory.multi_point([self]) rescue nil
+          else
+            super
+          end
+        end
+        
+        
+        def dimension
+          0
+        end
+        
+        
+        def geometry_type
+          Features::Point
+        end
+        
+        
+        def is_empty?
+          false
+        end
+        
+        
+        def is_simple?
+          true
+        end
+        
+        
+        def envelope
+          self
+        end
+        
+        
+        def boundary
+          factory.collection([])
+        end
+        
+        
+        def equals?(rhs_)
+          return false unless rhs_.factory.is_a?(Factory)
+          rhs_ = factory.convert(rhs_)
+          case rhs_
+          when Features::Point
+            if @y == 90
+              rhs_.y == 90
+            elsif @y == -90
+              rhs_.y == -90
+            else
+              rhs_.x == @x && rhs_.y == @y
+            end
+          when Features::LineString
+            rhs_.num_points > 0 && rhs_.points.all?{ |elem_| equals?(elem_) }
+          when Features::GeometryCollection
+            rhs_.num_geometries > 0 && rhs_.all?{ |elem_| equals?(elem_) }
+          else
+            false
+          end
+        end
+        
+        
+        alias_method :longitude, :x
+        alias_method :lon, :x
+        alias_method :latitude, :y
+        alias_method :lat, :y
+        
+        
+      end
+      
+      
+    end
+    
+  end
+  
+end

data/lib/rgeo/geography/common/polygon_methods.rb

@@ -0,0 +1,122 @@
+# -----------------------------------------------------------------------------
+# 
+# Common methods for Polygon geography features
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+  
+  module Geography
+    
+    module Common
+      
+      
+      module PolygonMethods
+        
+        
+        def _setup(exterior_ring_, interior_rings_)
+          @exterior_ring = exterior_ring_
+          @interior_rings = (interior_rings_ || []).map{ |elem_| factory.convert(elem_) }
+          unless Features::LinearRing.check_type(@exterior_ring)
+            raise Errors::InvalidGeometry, 'Exterior ring must be a LinearRing'
+          end
+          @interior_rings.each do |ring_|
+            unless Features::LinearRing.check_type(ring_)
+              raise Errors::InvalidGeometry, 'Interior ring must be a LinearRing'
+            end
+          end
+          _validate_geometry
+        end
+        
+        
+        def cast(type_)
+          case type_
+          when Features::Polygon
+            self
+          when Features::LinearRing
+            @exterior_ring
+          when Features::LineString
+            @exterior_ring.cast(type_)
+          when Features::GeometryCollection
+            factory.collection([self]) rescue nil
+          when Features::MultiPolygon
+            factory.multi_polygon([self]) rescue nil
+          else
+            super
+          end
+        end
+        
+        
+        def exterior_ring
+          @exterior_ring
+        end
+        
+        
+        def num_interior_rings
+          @interior_rings.size
+        end
+        
+        
+        def interior_ring_n(n_)
+          @interior_rings[n_]
+        end
+        
+        
+        def interior_rings
+          @interior_rings.dup
+        end
+        
+        
+        def dimension
+          2
+        end
+        
+        
+        def geometry_type
+          Features::Polygon
+        end
+        
+        
+        def is_empty?
+          @exterior_ring.is_empty?
+        end
+        
+        
+      end
+      
+      
+    end
+    
+  end
+  
+end

data/lib/rgeo/geography/factories.rb

@@ -0,0 +1,136 @@
+# -----------------------------------------------------------------------------
+# 
+# Access to geographic data factories
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+  
+  module Geography
+    
+    @simple_spherical = nil
+    @simple_mercator = nil
+    
+    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 and area 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.
+      # 
+      # Currently, this implementation is incomplete. Basic input/output
+      # and a few geodesic functions are implemented, but many return nil.
+      # 
+      # 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:
+      # 
+      # * 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.
+      # 
+      # 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).
+      
+      def simple_spherical(opts_={})  # :nodoc:
+        @simple_spherical ||= Geography::Factory.new(Geography::SimpleSpherical)
+      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.
+      # 
+      # 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.
+      
+      def simple_mercator(opts_={})
+        @simple_mercator ||= Geography::Factory.new(Geography::SimpleMercator, :buffer_resolution => opts_[:buffer_resolution])
+      end
+      
+      
+    end
+    
+  end
+  
+end

data/lib/rgeo/geography/factory.rb

@@ -0,0 +1,246 @@
+# -----------------------------------------------------------------------------
+# 
+# Geographic data factory implementation
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+  
+  module Geography
+    
+    
+    # This class implements the various factories for geography features.
+    # See methods of the RGeo::Geography module for the API for creating
+    # geography factories.
+    
+    class Factory
+      
+      include Features::Factory
+      
+      
+      def initialize(namespace_, opts_={})  # :nodoc:
+        @namespace = namespace_
+        @opts = opts_.dup
+        @projector = @namespace.const_get(:Projector).new(self, opts_) rescue nil
+      end
+      
+      
+      # Equivalence test.
+      
+      def eql?(rhs_)
+        rhs_.is_a?(self.class) && @namespace == rhs_.instance_variable_get(:@namespace) &&
+          @opts == rhs_.instance_variable_get(:@opts)
+      end
+      alias_method :==, :eql?
+      
+      
+      # Returns true if this factory supports a projection.
+      
+      def has_projection?
+        !@projector.nil?
+      end
+      
+      
+      # Returns the factory for the projected coordinate space,
+      # or nil if this factory does not support a projection.
+      
+      def projection_factory
+        @projector ? @projector.projection_factory : nil
+      end
+      
+      
+      # 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::IllegalGeometry if the given geometry is not of
+      # this factory.
+      
+      def project(geometry_)
+        return nil unless @projector
+        unless geometry_.factory == self
+          raise Errors::IllegalGeometry, 'Wrong geometry type'
+        end
+        @projector.project(geometry_)
+      end
+      
+      
+      # Reverse-projects the given geometry from the projected coordinate
+      # space into lat-long space.
+      # Raises Errors::IllegalGeometry 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::IllegalGeometry, 'You can unproject only features that are in the projected coordinate space.'
+        end
+        @projector.unproject(geometry_)
+      end
+      
+      
+      # Returns true if this factory supports a projection and the
+      # projection wraps its x (easting) direction. For example, a
+      # Mercator projection wraps, but a local projection that is valid
+      # only for a small area does not wrap.
+      
+      def projection_wraps?
+        @projector ? @projector.wraps? : nil
+      end
+      
+      
+      # Returns a ProjectedWindow specifying the limits of the domain of
+      # the projection space.
+      # Returns nil if this factory does not support a projection.
+      
+      def projection_limits_window
+        @projector ? (@projection_limits_window ||= @projector.limits_window) : nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#parse_wkt
+      
+      def parse_wkt(str_)
+        Common::Helper.parse_wkt(str_, self)
+      end
+      
+      
+      # See ::RGeo::Features::Factory#parse_wkb
+      
+      def parse_wkb(str_)
+        Common::Helper.parse_wkb(str_, self)
+      end
+      
+      
+      # See ::RGeo::Features::Factory#point
+      
+      def point(x_, y_)
+        @namespace.const_get(:PointImpl).new(self, x_, y_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#line_string
+      
+      def line_string(points_)
+        @namespace.const_get(:LineStringImpl).new(self, points_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#line
+      
+      def line(start_, end_)
+        @namespace.const_get(:LineImpl).new(self, start_, end_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#linear_ring
+      
+      def linear_ring(points_)
+        if points_.size > 1 && points_.first != points_.last
+          points_ << points_.first
+        end
+        @namespace.const_get(:LinearRingImpl).new(self, points_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#polygon
+      
+      def polygon(outer_ring_, inner_rings_=nil)
+        inner_rings_ = inner_rings_.to_a unless inner_rings_.kind_of?(::Array)
+        @namespace.const_get(:PolygonImpl).new(self, outer_ring_, inner_rings_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#collection
+      
+      def collection(elems_)
+        @namespace.const_get(:GeometryCollectionImpl).new(self, elems_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#multi_point
+      
+      def multi_point(elems_)
+        @namespace.const_get(:MultiPointImpl).new(self, elems_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#multi_line_string
+      
+      def multi_line_string(elems_)
+        @namespace.const_get(:MultiLineStringImpl).new(self, elems_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#multi_polygon
+      
+      def multi_polygon(elems_)
+        @namespace.const_get(:MultiPolygonImpl).new(self, elems_) rescue nil
+      end
+      
+      
+      # See ::RGeo::Features::Factory#convert
+      
+      def convert(original_, force_new_=false)
+        if self == original_.factory
+          force_new_ ? original_.dup : original_
+        else
+          case original_
+          when Features::Point
+            @namespace.const_get(:PointImpl).new(self, original_.x, original_.y) rescue nil
+          when Features::Line
+            @namespace.const_get(:LineImpl).new(self, original_.start_point, original_.end_point) rescue nil
+          when Features::LinearRing
+            @namespace.const_get(:LinearRingImpl).new(self, original_.points) rescue nil
+          when Features::LineString
+            @namespace.const_get(:LineStringImpl).new(self, original_.points) rescue nil
+          when Features::Polygon
+            @namespace.const_get(:PolygonImpl).new(self, original_.exterior_ring, original_.interior_rings) rescue nil
+          when Features::MultiPoint
+            @namespace.const_get(:MultiPointImpl).new(self, original_.to_a) rescue nil
+          when Features::MultiLineString
+            @namespace.const_get(:MultiLineStringImpl).new(self, original_.to_a) rescue nil
+          when Features::MultiPolygon
+            @namespace.const_get(:MultiPolygonImpl).new(self, original_.to_a) rescue nil
+          when Features::GeometryCollection
+            @namespace.const_get(:GeometryCollectionImpl).new(self, original_.to_a) rescue nil
+          else
+            nil
+          end
+        end
+      end
+      
+      
+    end
+    
+  end
+  
+end