rgeo 0.1.10

data/lib/rgeo/features/polygon.rb

@@ -0,0 +1,141 @@
+# -----------------------------------------------------------------------------
+# 
+# Polygon feature interface
+# 
+# -----------------------------------------------------------------------------
+# 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 Features
+    
+    
+    # == SFS 1.1 Description
+    # 
+    # A Polygon is a planar Surface defined by 1 exterior boundary and 0 or
+    # more interior boundaries. Each interior boundary defines a hole in
+    # the Polygon.
+    # 
+    # The assertions for Polygons (the rules that define valid Polygons)
+    # are as follows:
+    # 
+    # (a) Polygons are topologically closed;
+    # 
+    # (b) The boundary of a Polygon consists of a set of LinearRings that
+    # make up its exterior and interior boundaries;
+    # 
+    # (c) No two Rings in the boundary cross and the Rings in the boundary
+    # of a Polygon may intersect at a Point but only as a tangent;
+    # 
+    # (d) A Polygon may not have cut lines, spikes or punctures;
+    # 
+    # (e) The interior of every Polygon is a connected point set;
+    # 
+    # (f) The exterior of a Polygon with 1 or more holes is not connected.
+    # Each hole defines a connected component of the exterior.
+    # 
+    # In the above assertions, interior, closure and exterior have the
+    # standard topological definitions. The combination of (a) and (c) make
+    # a Polygon a regular closed Point set.
+    # 
+    # Polygons are simple geometric objects.
+    # 
+    # == Notes
+    # 
+    # Polygon is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method. A corresponding === operator is also provided to
+    # to support case-when constructs.
+    
+    module Polygon
+      
+      include Surface
+      include ::Enumerable
+      
+      
+      # === SFS 1.1 Description
+      # 
+      # Returns the exterior ring of this Polygon.
+      # 
+      # === Notes
+      # 
+      # Returns an object that supports the LinearRing interface.
+      
+      def exterior_ring
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      # === SFS 1.1 Description
+      # 
+      # Returns the number of interiorRings in this Polygon.
+      # 
+      # === Notes
+      # 
+      # Returns an integer.
+      
+      def num_interior_rings
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      # === SFS 1.1 Description
+      # 
+      # Returns the Nth interiorRing for this Polygon as a LineString.
+      # 
+      # === Notes
+      # 
+      # Returns an object that supports the LineString interface, or nil
+      # if the given n is out of range.
+      
+      def interior_ring_n(n_)
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      # Returns the interior rings as a (possibly empty) array of objects
+      # that support the LinearRing interface.
+      
+      def interior_rings
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      
+    end
+  
+    
+  end
+  
+end

data/lib/rgeo/features/surface.rb

@@ -0,0 +1,121 @@
+# -----------------------------------------------------------------------------
+# 
+# Surface feature interface
+# 
+# -----------------------------------------------------------------------------
+# 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 Features
+    
+    
+    # == SFS 1.1 Description
+    # 
+    # A Surface is a 2-dimensional geometric object.
+    # 
+    # A simple Surface consists of a single "patch" that is associated with
+    # one "exterior boundary" and 0 or more "interior" boundaries. Simple
+    # Surfaces in 3-dimensional space are isomorphic to planar Surfaces.
+    # Polyhedral Surfaces are formed by "stitching" together simple
+    # Surfaces along their boundaries, polyhedral Surfaces in 3-dimensional
+    # space may not be planar as a whole.
+    # 
+    # The boundary of a simple Surface is the set of closed Curves
+    # corresponding to its "exterior" and "interior" boundaries.
+    # 
+    # The only instantiable subclass of Surface defined in this
+    # specification, Polygon, is a simple Surface that is planar.
+    # 
+    # == Notes
+    # 
+    # Surface is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method. A corresponding === operator is also provided to
+    # to support case-when constructs.
+    # 
+    # Some implementations may support higher dimensional points.
+    
+    module Surface
+      
+      include Geometry
+      
+      
+      # === SFS 1.1 Description
+      # 
+      # The area of this Surface, as measured in the spatial reference
+      # system of this Surface.
+      # 
+      # === Notes
+      # 
+      # Returns a floating-point scalar value.
+      
+      def area
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      # === SFS 1.1 Description
+      # 
+      # The mathematical centroid for this Surface as a Point. The result
+      # is not guaranteed to be on this Surface.
+      # 
+      # === Notes
+      # 
+      # Returns an object that supports the Point interface.
+      
+      def centroid
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      # === SFS 1.1 Description
+      # 
+      # A Point guaranteed to be on this Surface.
+      # 
+      # === Notes
+      # 
+      # Returns an object that supports the Point interface.
+      
+      def point_on_surface
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+    end
+  
+    
+  end
+  
+end

data/lib/rgeo/geo_json.rb

@@ -0,0 +1,58 @@
+# -----------------------------------------------------------------------------
+# 
+# GeoJSON implementation for RGeo
+# 
+# -----------------------------------------------------------------------------
+# 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
+  
+  
+  # This is a namespace for a set of tools that provide GeoJSON encoding.
+  # See http://geojson.org/ for more information about this specification.
+  
+  module GeoJSON
+  end
+  
+  
+end
+
+
+# Dependency source files.
+paths_ = [
+  'features',
+  'geo_json/entities',
+  'geo_json/coder',
+  'geo_json/interface',
+]
+
+paths_.each{ |path_| require "rgeo/#{path_}" }

data/lib/rgeo/geo_json/coder.rb

@@ -0,0 +1,305 @@
+# -----------------------------------------------------------------------------
+# 
+# GeoJSON encoder object
+# 
+# -----------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'json'
+
+
+module RGeo
+  
+  module GeoJSON
+    
+    
+    # This object encapsulates encoding and decoding settings (principally
+    # the RGeo::Features::Factory and the RGeo::GeoJSON::EntityFactory to
+    # be used) so that you can encode and decode without specifying those
+    # settings every time.
+    
+    class Coder
+      
+      
+      # Create a new coder settings object. The geo factory is passed as
+      # a required argument. The entity factory is optional. To provide
+      # one, pass an option with key <tt>:entity_factory</tt>. It defaults
+      # to the default RGeo::GeoJSON::EntityFactory, which generates
+      # objects of type RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
+      
+      def initialize(geo_factory_, opts_={})
+        @geo_factory = geo_factory_
+        @entity_factory = opts_[:entity_factory] || EntityFactory.instance
+      end
+      
+      
+      # Encode the given object as GeoJSON. The object may be one of the
+      # geometry objects specified in RGeo::Features, or an appropriate
+      # GeoJSON wrapper entity supported by this coder's entity factory.
+      
+      def encode(object_)
+        if @entity_factory.is_feature_collection?(object_)
+          {
+            'type' => 'FeatureCollection',
+            'features' => @entity_factory.map_feature_collection(object_){ |f_| _encode_feature(f_) },
+          }
+        elsif @entity_factory.is_feature?(object_)
+          _encode_feature(object_)
+        else
+          _encode_geometry(object_)
+        end
+      end
+      
+      
+      # Decode an object from GeoJSON. The input may be a JSON hash, a
+      # String, or an IO object from which to read the JSON string.
+      
+      def decode(input_)
+        if input_.kind_of?(::IO)
+          input_ = input_.read rescue nil
+        end
+        if input_.kind_of?(::String)
+          input_ = ::JSON.parse(input_) rescue nil
+        end
+        unless input_.kind_of?(::Hash)
+          return nil
+        end
+        case input_['type']
+        when 'FeatureCollection'
+          features_ = input_['features']
+          features_ = [] unless features_.kind_of?(::Array)
+          decoded_features_ = []
+          features_.each do |f_|
+            if f_['type'] == 'Feature'
+              decoded_features_ << _decode_feature(f_)
+            end
+          end
+          @entity_factory.feature_collection(decoded_features_)
+        when 'Feature'
+          _decode_feature(input_)
+        else
+          _decode_geometry(input_)
+        end
+      end
+      
+      
+      # Returns the RGeo::Features::Factory used to generate geometry objects.
+      
+      def geo_factory
+        @geo_factory
+      end
+      
+      
+      # Returns the RGeo::GeoJSON::EntityFactory used to generate GeoJSON
+      # wrapper entities.
+      
+      def entity_factory
+        @entity_factory
+      end
+      
+      
+      def _encode_feature(object_)  # :nodoc:
+        json_ = {
+          'type' => 'Feature',
+          'geometry' => _encode_geometry(@entity_factory.get_feature_geometry(object_)),
+          'properties' => @entity_factory.get_feature_properties(object_).dup,
+        }
+        id_ = @entity_factory.get_feature_id(object_)
+        json_['id'] = id_ if id_
+        json_
+      end
+      
+      
+      def _encode_geometry(object_)  # :nodoc:
+        case object_
+        when Features::Point
+          {
+            'type' => 'Point',
+            'coordinates' => [object_.x, object_.y],
+          }
+        when Features::LineString
+          {
+            'type' => 'LineString',
+            'coordinates' => object_.points.map{ |p_| [p_.x, p_.y] },
+          }
+        when Features::Polygon
+          {
+            'type' => 'Polygon',
+            'coordinates' => [object_.exterior_ring.points.map{ |p_| [p_.x, p_.y] }] + object_.interior_rings.map{ |r_| r_.points.map{ |p_| [p_.x, p_.y] } }
+          }
+        when Features::MultiPoint
+          {
+            'type' => 'MultiPoint',
+            'coordinates' => object_.map{ |p_| [p_.x, p_.y] },
+          }
+        when Features::MultiLineString
+          {
+            'type' => 'MultiLineString',
+            'coordinates' => object_.map{ |ls_| ls_.points.map{ |p_| [p_.x, p_.y] } },
+          }
+        when Features::MultiPolygon
+          {
+            'type' => 'MultiPolygon',
+            'coordinates' => object_.map{ |poly_| [poly_.exterior_ring.points.map{ |p_| [p_.x, p_.y] }] + poly_.interior_rings.map{ |r_| r_.points.map{ |p_| [p_.x, p_.y] } } },
+          }
+        when Features::GeometryCollection
+          {
+            'type' => 'GeometryCollection',
+            'geometries' => object_.map{ |geom_| _encode_geometry(geom_) },
+          }
+        else
+          nil
+        end
+      end
+      
+      
+      def _decode_feature(input_)  # :nodoc:
+        geometry_ = _decode_geometry(input_['geometry'])
+        if geometry_
+          @entity_factory.feature(geometry_, input_['id'], input_['properties'])
+        else
+          nil
+        end
+      end
+      
+      
+      def _decode_geometry(input_)  # :nodoc:
+        case input_['type']
+        when 'GeometryCollection'
+          _decode_geometry_collection(input_)
+        when 'Point'
+          _decode_point_coords(input_['coordinates'])
+        when 'LineString'
+          _decode_line_string_coords(input_['coordinates'])
+        when 'Polygon'
+          _decode_polygon_coords(input_['coordinates'])
+        when 'MultiPoint'
+          _decode_multi_point_coords(input_['coordinates'])
+        when 'MultiLineString'
+          _decode_multi_line_string_coords(input_['coordinates'])
+        when 'MultiPolygon'
+          _decode_multi_polygon_coords(input_['coordinates'])
+        else
+          nil
+        end
+      end
+      
+      
+      def _decode_geometry_collection(input_)  # :nodoc:
+        geometries_ = input_['geometries']
+        geometries_ = [] unless geometries_.kind_of?(::Array)
+        decoded_geometries_ = []
+        geometries_.each do |g_|
+          g_ = _decode_geometry(g_)
+          decoded_geometries_ << g_ if g_
+        end
+        @geo_factory.collection(decoded_geometries_)
+      end
+      
+      
+      def _decode_point_coords(point_coords_)  # :nodoc:
+        return nil unless point_coords_.kind_of?(::Array)
+        @geo_factory.point(point_coords_[0].to_f, point_coords_[1].to_f) rescue nil
+      end
+      
+      
+      def _decode_line_string_coords(line_coords_)  # :nodoc:
+        return nil unless line_coords_.kind_of?(::Array)
+        points_ = []
+        line_coords_.each do |point_coords_|
+          point_ = _decode_point_coords(point_coords_)
+          points_ << point_ if point_
+        end
+        @geo_factory.line_string(points_)
+      end
+      
+      
+      def _decode_polygon_coords(poly_coords_)  # :nodoc:
+        return nil unless poly_coords_.kind_of?(::Array)
+        rings_ = []
+        poly_coords_.each do |ring_coords_|
+          return nil unless ring_coords_.kind_of?(::Array)
+          points_ = []
+          ring_coords_.each do |point_coords_|
+            point_ = _decode_point_coords(point_coords_)
+            points_ << point_ if point_
+          end
+          ring_ = @geo_factory.linear_ring(points_)
+          rings_ << ring_ if ring_
+        end
+        if rings_.size == 0
+          nil
+        else
+          @geo_factory.polygon(rings_[0], rings_[1..-1])
+        end
+      end
+      
+      
+      def _decode_multi_point_coords(multi_point_coords_)  # :nodoc:
+        return nil unless multi_point_coords_.kind_of?(::Array)
+        points_ = []
+        multi_point_coords_.each do |point_coords_|
+          point_ = _decode_point_coords(point_coords_)
+          points_ << point_ if point_
+        end
+        @geo_factory.multi_point(points_)
+      end
+      
+      
+      def _decode_multi_line_string_coords(multi_line_coords_)  # :nodoc:
+        return nil unless multi_line_coords_.kind_of?(::Array)
+        lines_ = []
+        multi_line_coords_.each do |line_coords_|
+          line_ = _decode_line_string_coords(line_coords_)
+          lines_ << line_ if line_
+        end
+        @geo_factory.multi_line_string(lines_)
+      end
+      
+      
+      def _decode_multi_polygon_coords(multi_polygon_coords_)  # :nodoc:
+        return nil unless multi_polygon_coords_.kind_of?(::Array)
+        polygons_ = []
+        multi_polygon_coords_.each do |poly_coords_|
+          poly_ = _decode_polygon_coords(poly_coords_)
+          polygons_ << poly_ if poly_
+        end
+        @geo_factory.multi_polygon(polygons_)
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end