rgeo 0.2.9 → 0.3.0

data/lib/rgeo/geos/ffi_factory.rb

@@ -0,0 +1,503 @@
+# -----------------------------------------------------------------------------
+# 
+# FFI-GEOS 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
+    
+    
+    # This the FFI-GEOS implementation of ::RGeo::Feature::Factory.
+    
+    class FFIFactory
+      
+      
+      include Feature::Factory::Instance
+      
+      
+      # Create a new factory. Returns nil if the FFI-GEOS implementation
+      # is not supported.
+      # 
+      # See ::RGeo::Geos.factory for a list of supported options.
+      
+      def initialize(opts_={})
+        # Main flags
+        @uses_lenient_multi_polygon_assertions = opts_[:lenient_multi_polygon_assertions] ||
+          opts_[:uses_lenient_multi_polygon_assertions]
+        @has_z = opts_[:has_z_coordinate]
+        @has_m = opts_[:has_m_coordinate]
+        if @has_z && @has_m
+          raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
+        end
+        @_has_3d = @has_z || @has_m
+        @buffer_resolution = opts_[:buffer_resolution].to_i
+        @buffer_resolution = 1 if @buffer_resolution < 1
+        
+        # Interpret the generator options
+        wkt_generator_ = opts_[:wkt_generator]
+        case wkt_generator_
+        when :geos
+          @wkt_writer = ::Geos::WktWriter.new
+          @wkt_generator = nil
+        when ::Hash
+          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
+          @wkt_writer = nil
+        else
+          @wkt_generator = WKRep::WKTGenerator.new(:convert_case => :upper)
+          @wkt_writer = nil
+        end
+        wkb_generator_ = opts_[:wkb_generator]
+        case wkb_generator_
+        when :geos
+          @wkb_writer = ::Geos::WkbWriter.new
+          @wkb_generator = nil
+        when ::Hash
+          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator_)
+          @wkb_writer = nil
+        else
+          @wkb_generator = WKRep::WKBGenerator.new
+          @wkb_writer = nil
+        end
+        
+        # Coordinate system (srid, proj4, and coord_sys)
+        @srid = opts_[:srid]
+        @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
+        @coord_sys = opts_[:coord_sys]
+        if @coord_sys.kind_of?(::String)
+          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys) rescue nil
+        end
+        if (!@proj4 || !@coord_sys) && @srid && (db_ = opts_[:srs_database])
+          entry_ = db_.get(@srid.to_i)
+          if entry_
+            @proj4 ||= entry_.proj4
+            @coord_sys ||= entry_.coord_sys
+          end
+        end
+        @srid ||= @coord_sys.authority_code if @coord_sys
+        @srid = @srid.to_i
+        
+        # Interpret parser options
+        wkt_parser_ = opts_[:wkt_parser]
+        case wkt_parser_
+        when :geos
+          @wkt_reader = ::Geos::WktReader.new
+          @wkt_parser = nil
+        when ::Hash
+          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser_)
+          @wkt_reader = nil
+        else
+          @wkt_parser = WKRep::WKTParser.new(self)
+          @wkt_reader = nil
+        end
+        wkb_parser_ = opts_[:wkb_parser]
+        case wkb_parser_
+        when :geos
+          @wkb_reader = ::Geos::WktReader.new
+          @wkb_parser = nil
+        when ::Hash
+          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser_)
+          @wkb_reader = nil
+        else
+          @wkb_parser = WKRep::WKBParser.new(self)
+          @wkb_reader = nil
+        end
+      end
+      
+      
+      def inspect  # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} srid=#{srid}>"
+      end
+      
+      
+      # Factory equivalence test.
+      
+      def eql?(rhs_)
+        rhs_.is_a?(self.class) && @srid == rhs_.srid &&
+          @has_z == rhs_.property(:has_z_coordinate) &&
+          @has_m == rhs_.property(:has_m_coordinate)
+      end
+      alias_method :==, :eql?
+      
+      
+      # Returns the SRID of geometries created by this factory.
+      
+      def srid
+        @srid
+      end
+      
+      
+      # Returns the resolution used by buffer calculations on geometries
+      # created by this factory
+      
+      def buffer_resolution
+        @buffer_resolution
+      end
+      
+      
+      # Returns true if this factory is lenient with MultiPolygon assertions
+      
+      def lenient_multi_polygon_assertions?
+        @uses_lenient_multi_polygon_assertions
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#property
+      
+      def property(name_)
+        case name_
+        when :has_z_coordinate
+          @has_z
+        when :has_m_coordinate
+          @has_m
+        when :is_cartesian
+          true
+        when :buffer_resolution
+          @buffer_resolution
+        when :uses_lenient_multi_polygon_assertions
+          @uses_lenient_multi_polygon_assertions
+        else
+          nil
+        end
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#parse_wkt
+      
+      def parse_wkt(str_)
+        if @wkt_reader
+          @wkt_reader.read(str_)
+        else
+          @wkt_parser.parse(str_)
+        end
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#parse_wkb
+      
+      def parse_wkb(str_)
+        if @wkb_reader
+          @wkb_reader.read(str_)
+        else
+          @wkb_parser.parse(str_)
+        end
+      end
+      
+      
+      def wrap_fg_geom(fg_geom_, klass_=nil)  # :nodoc:
+        klasses_ = nil
+        unless klass_.kind_of?(::Class)
+          is_collection_ = false
+          case fg_geom_.type_id
+          when ::Geos::GeomTypes::GEOS_POINT
+            inferred_klass_ = FFIPointImpl
+          when ::Geos::GeomTypes::GEOS_MULTIPOINT
+            inferred_klass_ = FFIMultiPointImpl
+            is_collection_ = true
+          when ::Geos::GeomTypes::GEOS_LINESTRING
+            inferred_klass_ = FFILineStringImpl
+          when ::Geos::GeomTypes::GEOS_LINEARRING
+            inferred_klass_ = FFILinearRingImpl
+          when ::Geos::GeomTypes::GEOS_MULTILINESTRING
+            inferred_klass_ = FFIMultiLineStringImpl
+            is_collection_ = true
+          when ::Geos::GeomTypes::GEOS_POLYGON
+            inferred_klass_ = FFIPolygonImpl
+          when ::Geos::GeomTypes::GEOS_MULTIPOLYGON
+            inferred_klass_ = FFIMultiPolygonImpl
+            is_collection_ = true
+          when ::Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION
+            inferred_klass_ = FFIGeometryCollectionImpl
+            is_collection_ = true
+          else
+            inferred_klass_ = FFIGeometryImpl
+          end
+          if is_collection_ && klass_.is_a?(::Array)
+            klasses_ = klass_
+          end
+          klass_ = inferred_klass_
+        end
+        klass_.new(self, fg_geom_, klasses_)
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#point
+      
+      def point(x_, y_, z_=0)
+        cs_ = ::Geos::CoordinateSequence.new(1, 3)
+        cs_.set_x(0, x_)
+        cs_.set_y(0, y_)
+        cs_.set_z(0, z_)
+        FFIPointImpl.new(self, ::Geos::Utils.create_point(cs_), nil)
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#line_string
+      
+      def line_string(points_)
+        points_ = points_.to_a unless points_.kind_of?(::Array)
+        size_ = points_.size
+        return nil if size_ == 1
+        cs_ = ::Geos::CoordinateSequence.new(size_, 3)
+        points_.each_with_index do |p_, i_|
+          return nil unless ::RGeo::Feature::Point.check_type(p_)
+          cs_.set_x(i_, p_.x)
+          cs_.set_y(i_, p_.y)
+          if @has_z
+            cs_.set_z(i_, p_.z)
+          elsif @has_m
+            cs_.set_z(i_, p_.m)
+          end
+        end
+        FFILineStringImpl.new(self, ::Geos::Utils.create_line_string(cs_), nil)
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#line
+      
+      def line(start_, end_)
+        return nil unless ::RGeo::Feature::Point.check_type(start_) &&
+          ::RGeo::Feature::Point.check_type(end_)
+        cs_ = ::Geos::CoordinateSequence.new(2, 3)
+        cs_.set_x(0, start_.x)
+        cs_.set_x(1, end_.x)
+        cs_.set_y(0, start_.y)
+        cs_.set_y(1, end_.y)
+        if @has_z
+          cs_.set_z(0, start_.z)
+          cs_.set_z(1, end_.z)
+        elsif @has_m
+          cs_.set_z(0, start_.m)
+          cs_.set_z(1, end_.m)
+        end
+        FFILineImpl.new(self, ::Geos::Utils.create_line_string(cs_), nil)
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#linear_ring
+      
+      def linear_ring(points_)
+        points_ = points_.to_a unless points_.kind_of?(::Array)
+        fg_geom_ = _create_fg_linear_ring(points_)
+        fg_geom_ ? FFILinearRingImpl.new(self, fg_geom_, nil) : nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#polygon
+      
+      def polygon(outer_ring_, inner_rings_=nil)
+        inner_rings_ = inner_rings_.to_a unless inner_rings_.kind_of?(::Array)
+        return nil unless ::RGeo::Feature::LineString.check_type(outer_ring_)
+        outer_ring_ = _create_fg_linear_ring(outer_ring_.points)
+        inner_rings_.map! do |r_|
+          return nil unless ::RGeo::Feature::LineString.check_type(r_)
+          _create_fg_linear_ring(r_.points)
+        end
+        inner_rings_.compact!
+        fg_geom_ = ::Geos::Utils.create_polygon(outer_ring_, *inner_rings_)
+        fg_geom_ ? FFIPolygonImpl.new(self, fg_geom_, nil) : nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#collection
+      
+      def collection(elems_)
+        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        klasses_ = []
+        fg_geoms_ = []
+        elems_.each do |elem_|
+          k_ = elem_._klasses if elem_.is_a?(FFIGeometryImpl)
+          elem_ = ::RGeo::Feature.cast(elem_, self, :force_new, :keep_subtype)
+          if elem_
+            klasses_ << (k_ || elem_.class)
+            fg_geoms_ << elem_._detach_fg_geom
+          end
+        end
+        fg_geom_ = ::Geos::Utils.create_collection(
+          ::Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION, fg_geoms_)
+        fg_geom_ ? FFIGeometryCollectionImpl.new(self, fg_geom_, klasses_) : nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#multi_point
+      
+      def multi_point(elems_)
+        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        fg_geoms_ = []
+        elems_.map! do |elem_|
+          elem_ = ::RGeo::Feature.cast(elem_, self, ::RGeo::Feature::Point,
+            :force_new, :keep_subtype)
+          return nil unless elem_
+          elem_._detach_fg_geom
+        end
+        klasses_ = ::Array.new(elems_.size, FFIPointImpl)
+        fg_geom_ = ::Geos::Utils.create_collection(
+          ::Geos::GeomTypes::GEOS_MULTIPOINT, elems_)
+        fg_geom_ ? FFIMultiPointImpl.new(self, fg_geom_, klasses_) : nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#multi_line_string
+      
+      def multi_line_string(elems_)
+        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        klasses_ = []
+        elems_.map! do |elem_|
+          elem_ = ::RGeo::Feature.cast(elem_, self, ::RGeo::Feature::LineString,
+            :force_new, :keep_subtype)
+          return nil unless elem_
+          klasses_ << elem_.class
+          elem_._detach_fg_geom
+        end
+        fg_geom_ = ::Geos::Utils.create_collection(
+          ::Geos::GeomTypes::GEOS_MULTILINESTRING, elems_)
+        fg_geom_ ? FFIMultiLineStringImpl.new(self, fg_geom_, klasses_) : nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#multi_polygon
+      
+      def multi_polygon(elems_)
+        elems_ = elems_.to_a unless elems_.kind_of?(::Array)
+        elems_.map! do |elem_|
+          elem_ = ::RGeo::Feature.cast(elem_, self, ::RGeo::Feature::Polygon,
+            :force_new, :keep_subtype)
+          return nil unless elem_
+          elem_._detach_fg_geom
+        end
+        unless @uses_lenient_multi_polygon_assertions
+          (1...elems_.size).each do |i_|
+            (0...i_).each do |j_|
+              igeom_ = elems_[i_]
+              jgeom_ = elems_[j_]
+              return nil if igeom_.relate_pattern(jgeom_, "2********") ||
+                igeom_.relate_pattern(jgeom_, "****1****")
+            end
+          end
+        end
+        klasses_ = ::Array.new(elems_.size, FFIPolygonImpl)
+        fg_geom_ = ::Geos::Utils.create_collection(
+          ::Geos::GeomTypes::GEOS_MULTIPOLYGON, elems_)
+        fg_geom_ ? FFIMultiPolygonImpl.new(self, fg_geom_, klasses_) : nil
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#proj4
+      
+      def proj4
+        @proj4
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#coord_sys
+      
+      def coord_sys
+        @coord_sys
+      end
+      
+      
+      # See ::RGeo::Feature::Factory#override_cast
+      
+      def override_cast(original_, ntype_, flags_)
+        false
+        # TODO
+      end
+      
+      
+      attr_reader :_has_3d  # :nodoc:
+      
+      
+      def _convert_to_fg_geometry(obj_, type_=nil)  # :nodoc:
+        if type_.nil? && obj_.factory == self
+          obj_
+        else
+          obj_ = Feature.cast(obj_, self, type_)
+        end
+        obj_ ? obj_.fg_geom : nil
+      end
+      
+      
+      def _create_fg_linear_ring(points_)  # :nodoc:
+        size_ = points_.size
+        return nil if size_ == 1 || size_ == 2
+        if size_ > 0 && points_.first != points_.last
+          points_ = points_ + [points_.first]
+          size_ += 1
+        end
+        cs_ = ::Geos::CoordinateSequence.new(size_, 3)
+        points_.each_with_index do |p_, i_|
+          return nil unless ::RGeo::Feature::Point.check_type(p_)
+          cs_.set_x(i_, p_.x)
+          cs_.set_y(i_, p_.y)
+          if @has_z
+            cs_.set_z(i_, p_.z)
+          elsif @has_m
+            cs_.set_z(i_, p_.m)
+          end
+        end
+        ::Geos::Utils.create_linear_ring(cs_)
+      end
+      
+      
+      def _generate_wkt(geom_)  # :nodoc:
+        if @wkt_writer
+          @wkt_writer.write(geom_.fg_geom)
+        else
+          @wkt_generator.generate(geom_)
+        end
+      end
+      
+      
+      def _generate_wkb(geom_)  # :nodoc:
+        if @wkb_writer
+          @wkb_writer.write(geom_.fg_geom)
+        else
+          @wkb_generator.generate(geom_)
+        end
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end