rgeo 0.1.18 → 0.1.19

data/lib/rgeo/geos/impl_additions.rb

@@ -50,6 +50,26 @@ module RGeo
     end
     
     
+    class Factory
+      
+      
+      # :stopdoc:
+      IMPL_CLASSES = {
+        Features::Point => PointImpl,
+        Features::LineString => LineStringImpl,
+        Features::LinearRing => LinearRingImpl,
+        Features::Line => LineImpl,
+        Features::GeometryCollection => GeometryCollectionImpl,
+        Features::MultiPoint => MultiPointImpl,
+        Features::MultiLineString => MultiLineStringImpl,
+        Features::MultiPolygon => MultiPolygonImpl,
+      }
+      # :startdoc:
+      
+      
+    end
+    
+    
   end
   
 end

data/lib/rgeo/geos/interface.rb

@@ -55,13 +55,20 @@ module RGeo
       # factory is a GEOS factory.
       
       def is_geos?(object_)
-        supported? ? Factory === object_ || GeometryImpl === object_ : false
+        supported? && (Factory === object_ || GeometryImpl === object_ || ZMFactory === object_ || ZMGeometryImpl === object_)
       end
       
       
       # Returns a factory for the GEOS implementation.
       # Returns nil if the GEOS implementation is not supported.
       # 
+      # Note that GEOS does not natively support 4-dimensional data
+      # (i.e. both z and m values). However, RGeo's GEOS wrapper does
+      # provide a 4-dimensional factory that utilizes an extra native
+      # GEOS object to handle the extra coordinate. Hence, a factory
+      # configured with both Z and M support will work, but will be
+      # slower than a 2-dimensional or 3-dimensional factory.
+      # 
       # Options include:
       # 
       # <tt>:lenient_multi_polygon_assertions</tt>::
@@ -83,17 +90,19 @@ module RGeo
       #   Default is 0.
       # <tt>:support_z_coordinate</tt>::
       #   Support <tt>z_coordinate</tt>. Default is false.
-      #   Note that GEOS 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 GEOS factories cannot support both
-      #   <tt>z_coordinate</tt> and <tt>m_coordinate</tt>. They may at
-      #   most support one or the other.
       
       def factory(opts_={})
-        supported? ? Factory.create(opts_) : nil
+        if supported?
+          if opts_[:support_z_coordinate] && opts_[:support_m_coordinate]
+            ZMFactory.new(opts_)
+          else
+            Factory.create(opts_)
+          end
+        else
+          nil
+        end
       end
       
       

data/lib/rgeo/geos/zm_factory.rb

@@ -0,0 +1,241 @@
+# -----------------------------------------------------------------------------
+# 
+# GEOS zm 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 Geos
+    
+    
+    # A factory for Geos that handles both Z and M.
+    
+    class ZMFactory
+      
+      include Features::Factory::Instance
+      
+      
+      class << self
+        
+        
+        # Create a new factory. Returns nil if the GEOS implementation is
+        # not supported.
+        
+        def create(opts_={})
+          return nil unless Geos.supported?
+          new(opts_)
+        end
+        
+        
+      end
+      
+      
+      def initialize(opts_={})  # :nodoc:
+        @zfactory = Factory.create(:support_z_coordinate => true, :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions], :buffer_resolution => opts_[:buffer_resolution], :srid => opts_[:srid])
+        @mfactory = Factory.create(:support_m_coordinate => true, :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions], :buffer_resolution => opts_[:buffer_resolution], :srid => opts_[:srid])
+      end
+      
+      
+      # Returns the SRID of geometries created by this factory.
+      
+      def srid
+        @zfactory._srid
+      end
+      
+      
+      # Returns the resolution used by buffer calculations on geometries
+      # created by this factory
+      
+      def buffer_resolution
+        @zfactory._buffer_resolution
+      end
+      
+      
+      # Returns true if this factory is lenient with MultiPolygon assertions
+      
+      def lenient_multi_polygon_assertions?
+        @zfactory.lenient_multi_polygon_assertions?
+      end
+      
+      
+      # Returns the z-only factory corresponding to this factory.
+      
+      def z_factory
+        @zfactory
+      end
+      
+      
+      # Returns the m-only factory corresponding to this factory.
+      
+      def m_factory
+        @mfactory
+      end
+      
+      
+      # Factory equivalence test.
+      
+      def eql?(rhs_)
+        rhs_.is_a?(ZMFactory) && rhs_.z_factory == @zfactory
+      end
+      alias_method :==, :eql?
+      
+      
+      # See ::RGeo::Features::Factory#has_capability?
+      
+      def has_capability?(name_)
+        case name_
+        when :z_coordinate, :m_coordinate
+          true
+        else
+          @zfactory.has_capability?(name_)
+        end
+      end
+      
+      
+      # See ::RGeo::Features::Factory#parse_wkt
+      
+      def parse_wkt(str_)
+        WKRep::WKTParser.new(:default_factory => self).parse(str_)
+      end
+      
+      
+      # See ::RGeo::Features::Factory#parse_wkb
+      
+      def parse_wkb(str_)
+        WKRep::WKBParser.new(:default_factory => self).parse(str_)
+      end
+      
+      
+      # See ::RGeo::Features::Factory#point
+      
+      def point(x_, y_, z_=0, m_=0)
+        ZMPointImpl.create(self, @zfactory.point(x_, y_, z_), @mfactory.point(x_, y_, m_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#line_string
+      
+      def line_string(points_)
+        ZMLineStringImpl.create(self, @zfactory.line_string(points_), @mfactory.line_string(points_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#line
+      
+      def line(start_, end_)
+        ZMLineStringImpl.create(self, @zfactory.line(start_, end_), @mfactory.line(start_, end_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#linear_ring
+      
+      def linear_ring(points_)
+        ZMLineStringImpl.create(self, @zfactory.linear_ring(points_), @mfactory.linear_ring(points_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#polygon
+      
+      def polygon(outer_ring_, inner_rings_=nil)
+        ZMPolygonImpl.create(self, @zfactory.polygon(outer_ring_, inner_rings_), @mfactory.polygon(outer_ring_, inner_rings_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#collection
+      
+      def collection(elems_)
+        ZMGeometryCollectionImpl.create(self, @zfactory.collection(elems_), @mfactory.collection(elems_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#multi_point
+      
+      def multi_point(elems_)
+        ZMGeometryCollectionImpl.create(self, @zfactory.multi_point(elems_), @mfactory.multi_point(elems_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#multi_line_string
+      
+      def multi_line_string(elems_)
+        ZMMultiLineStringImpl.create(self, @zfactory.multi_line_string(elems_), @mfactory.multi_line_string(elems_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#multi_polygon
+      
+      def multi_polygon(elems_)
+        ZMMultiPolygonImpl.create(self, @zfactory.multi_polygon(elems_), @mfactory.multi_polygon(elems_))
+      end
+      
+      
+      # See ::RGeo::Features::Factory#override_cast
+      
+      def override_cast(original_, ntype_, flags_)
+        return nil unless Geos.supported?
+        keep_subtype_ = flags_[:keep_subtype]
+        force_new_ = flags_[:force_new]
+        type_ = original_.geometry_type
+        ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
+        case original_
+        when ZMGeometryImpl
+          # Optimization if we're just changing factories, but to
+          # another ZM factory.
+          if original_.factory != self && ntype_ == type_
+            zresult_ = original_.z_geometry.dup
+            zresult_._set_factory(@zfactory)
+            mresult_ = original_.m_geometry.dup
+            mresult_._set_factory(@mfactory)
+            return original_.class.create(self, zresult_, mresult_)
+          end
+          # LineString conversion optimization.
+          if (original_.factory != self || ntype_ != type_) &&
+              type_.subtype_of?(Features::LineString) && ntype_.subtype_of?(Features:LineString)
+          then
+            klass_ = Factory::IMPL_CLASSES[ntype_]
+            zresult_ = klass_._copy_from(@zfactory, original_.z_geometry)
+            mresult_ = klass_._copy_from(@mfactory, original_.m_geometry)
+            return ZMLineStringImpl.create(self, zresult_, mresult_)
+          end
+        end
+        false
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end

data/lib/rgeo/geos/zm_impl.rb

@@ -0,0 +1,432 @@
+# -----------------------------------------------------------------------------
+# 
+# GEOS implementation additions written in Ruby
+# 
+# -----------------------------------------------------------------------------
+# 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 Geos
+    
+    
+    class ZMGeometryImpl  # :nodoc:
+      
+      include Features::Type::Instance
+      
+      
+      def initialize(factory_, zgeometry_, mgeometry_)
+        @factory = factory_
+        @zgeometry = zgeometry_
+        @mgeometry = mgeometry_
+      end
+      
+      
+      def inspect  # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
+      end
+      
+      def to_s  # :nodoc:
+        as_text
+      end
+      
+      
+      def factory
+        @factory
+      end
+      
+      
+      def z_geometry
+        @zgeometry
+      end
+      
+      
+      def m_geometry
+        @mgeometry
+      end
+      
+      
+      def eql?(rhs_)
+        rhs_.is_a?(self.class) && @factory.eql?(rhs_.factory) && @zgeometry.eql?(rhs_.z_geometry) && @mgeometry.eql?(rhs_.m_geometry)
+      end
+      
+      
+      def dimension
+        @zgeometry.dimension
+      end
+      
+      
+      def geometry_type
+        @zgeometry.geometry_type
+      end
+      
+      
+      def srid
+        @factory.srid
+      end
+      
+      
+      def envelope
+        ZMGeometryImpl.create(@factory, @zgeometry.envelope, @mgeometry.envelope)
+      end
+      
+      
+      def as_text
+        WKRep::WKTGenerator.new.generate(self)
+      end
+      
+      
+      def as_binary
+        WKRep::WKBGenerator.new.generate(self)
+      end
+      
+      
+      def is_empty?
+        @zgeometry.is_empty?
+      end
+      
+      
+      def is_simple?
+        @zgeometry.is_simple?
+      end
+      
+      
+      def boundary
+        ZMGeometryImpl.create(@factory, @zgeometry.boundary, @mgeometry.boundary)
+      end
+      
+      
+      def equals?(rhs_)
+        @zgeometry.equals?(rhs_)
+      end
+      
+      
+      def disjoint?(rhs_)
+        @zgeometry.disjoint?(rhs_)
+      end
+      
+      
+      def intersects?(rhs_)
+        @zgeometry.intersects?(rhs_)
+      end
+      
+      
+      def touches?(rhs_)
+        @zgeometry.touches?(rhs_)
+      end
+      
+      
+      def crosses?(rhs_)
+        @zgeometry.crosses?(rhs_)
+      end
+      
+      
+      def within?(rhs_)
+        @zgeometry.within?(rhs_)
+      end
+      
+      
+      def contains?(rhs_)
+        @zgeometry.contains?(rhs_)
+      end
+      
+      
+      def overlaps?(rhs_)
+        @zgeometry.overlaps?(rhs_)
+      end
+      
+      
+      def relate(rhs_, pattern_)
+        @zgeometry.relate(rhs_, pattern_)
+      end
+      
+      
+      def distance(rhs_)
+        @zgeometry.distance(rhs_)
+      end
+      
+      
+      def buffer(distance_)
+        ZMGeometryImpl.create(@factory, @zgeometry.buffer(distance_), @mgeometry.buffer(distance_))
+      end
+      
+      
+      def convex_hull
+        ZMGeometryImpl.create(@factory, @zgeometry.convex_hull, @mgeometry.convex_hull)
+      end
+      
+      
+      def intersection(rhs_)
+        ZMGeometryImpl.create(@factory, @zgeometry.intersection(rhs_), @mgeometry.intersection(rhs_))
+      end
+      
+      
+      def union(rhs_)
+        ZMGeometryImpl.create(@factory, @zgeometry.union(rhs_), @mgeometry.union(rhs_))
+      end
+      
+      
+      def difference(rhs_)
+        ZMGeometryImpl.create(@factory, @zgeometry.difference(rhs_), @mgeometry.difference(rhs_))
+      end
+      
+      
+      def sym_difference(rhs_)
+        ZMGeometryImpl.create(@factory, @zgeometry.sym_difference(rhs_), @mgeometry.sym_difference(rhs_))
+      end
+      
+      
+      alias_method :==, :equals?
+      alias_method :-, :difference
+      alias_method :+, :union
+      alias_method :*, :intersection
+      
+    end
+    
+    
+    class ZMPointImpl < ZMGeometryImpl  # :nodoc:
+      
+      
+      def x
+        @zgeometry.x
+      end
+      
+      
+      def y
+        @zgeometry.y
+      end
+      
+      
+      def z
+        @zgeometry.z
+      end
+      
+      
+      def m
+        @mgeometry.m
+      end
+      
+      
+    end
+    
+    
+    class ZMLineStringImpl < ZMGeometryImpl  # :nodoc:
+      
+      
+      def length
+        @zgeometry.length
+      end
+      
+      
+      def start_point
+        point_n(0)
+      end
+      
+      
+      def end_point
+        point_n(num_points - 1)
+      end
+      
+      
+      def is_closed?
+        @zgeometry.is_closed?
+      end
+      
+      
+      def is_ring?
+        @zgeometry.is_ring?
+      end
+      
+      
+      def num_points
+        @zgeometry.num_points
+      end
+      
+      
+      def point_n(n_)
+        ZMPointImpl.create(@factory, @zgeometry.point_n(n_), @mgeometry.point_n(n_))
+      end
+      
+      
+      def points
+        result_ = []
+        zpoints_ = @zgeometry.points
+        mpoints_ = @mgeometry.points
+        zpoints_.size.times do |i_|
+          result_ << ZMPointImpl.create(@factory, zpoints_[i_], mpoints_[i_])
+        end
+        result_
+      end
+      
+      
+    end
+    
+    
+    class ZMPolygonImpl < ZMGeometryImpl  # :nodoc:
+      
+      
+      def area
+        @zgeometry.area
+      end
+      
+      
+      def centroid
+        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+      end
+      
+      
+      def point_on_surface
+        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+      end
+      
+      
+      def exterior_ring
+        ZMLineStringImpl.create(@factory, @zgeometry.exterior_ring, @mgeometry.exterior_ring)
+      end
+      
+      
+      def num_interior_rings
+        @zgeometry.num_interior_rings
+      end
+      
+      
+      def interior_ring_n(n_)
+        ZMLineStringImpl.create(@factory, @zgeometry.interior_ring_n(n_), @mgeometry.interior_ring_n(n_))
+      end
+      
+      
+      def interior_rings
+        result_ = []
+        zrings_ = @zgeometry.interior_rings
+        mrings_ = @mgeometry.interior_rings
+        zrings_.size.times do |i_|
+          result_ << ZMLineStringImpl.create(@factory, zrings_[i_], mrings_[i_])
+        end
+        result_
+      end
+      
+      
+    end
+    
+    
+    class ZMGeometryCollectionImpl < ZMGeometryImpl  # :nodoc:
+      
+      
+      include ::Enumerable
+      
+      
+      def num_geometries
+        @zgeometry.num_geometries
+      end
+      alias_method :size, :num_geometries
+      
+      
+      def geometry_n(n_)
+        ZMGeometryImpl.create(@factory, @zgeometry.geometry_n(n_), @mgeometry.geometry_n(n_))
+      end
+      alias_method :[], :geometry_n
+      
+      
+      def each
+        num_geometries.times do |i_|
+          yield geometry_n(i_)
+        end
+      end
+      
+      
+    end
+    
+    
+    class ZMMultiLineStringImpl < ZMGeometryCollectionImpl  # :nodoc:
+      
+      
+      def length
+        @zgeometry.length
+      end
+      
+      
+      def is_closed?
+        @zgeometry.is_closed?
+      end
+      
+      
+    end
+    
+    
+    class ZMMultiPolygonImpl < ZMGeometryCollectionImpl  # :nodoc:
+      
+      
+      def area
+        @zgeometry.area
+      end
+      
+      
+      def centroid
+        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+      end
+      
+      
+      def point_on_surface
+        ZMPointImpl.create(@factory, @zgeometry.centroid, @mgeometry.centroid)
+      end
+      
+      
+    end
+    
+    
+    class ZMGeometryImpl  # :nodoc:
+      
+      TYPE_KLASSES = {
+        Features::Point => ZMPointImpl,
+        Features::LineString => ZMLineStringImpl,
+        Features::Line => ZMLineStringImpl,
+        Features::LinearRing => ZMLineStringImpl,
+        Features::Polygon => ZMPolygonImpl,
+        Features::GeometryCollection => ZMGeometryCollectionImpl,
+        Features::MultiPoint => ZMGeometryCollectionImpl,
+        Features::MultiLineString => ZMMultiLineStringImpl,
+        Features::MultiPolygon => ZMMultiPolygonImpl,
+      }
+      
+      
+      def self.create(factory_, zgeometry_, mgeometry_)
+        klass_ = self == ZMGeometryImpl ? TYPE_KLASSES[zgeometry_.geometry_type] : self
+        klass_ && zgeometry_ && mgeometry_ ? klass_.new(factory_, zgeometry_, mgeometry_) : nil
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end