rgeo 0.1.20 → 0.1.21

data/History.rdoc

@@ -1,3 +1,13 @@
+=== 0.1.21 / 2010-12-03
+
+* API CHANGE: Added "_factory" to the end of the Geography toplevel interface methods, for consistency with the rest of the API.
+* API CHANGE: Simplified initializer API for WKTParser and WKBParser.
+* API CHANGE: Removed ActiveRecord::Base.rgeo_default_factory, and provided a reasonable default rgeo_factory_generator.
+* Removed deprecated pluralized names RGeo::Features and RGeo::Errors.
+* First pass implementation of the ActiveRecord adapters for SpatiaLite and PostGIS.
+* Fixed problems with Proj4 equivalence testing.
+* Several more minor fixes and documentation updates.
+
 === 0.1.20 / 2010-11-30
 
 * API CHANGE: Methods that raised MethodUnimplemented now raise UnsupportedCapability instead. Removed MethodUnimplemented.

data/README.rdoc

@@ -1,25 +1,17 @@
 == RGeo
 
-RGeo is a spatial data library for Ruby.
-
-It provides an implementation of the Open Geospatial Consortium's Simple
-Features Specification, used by most standard spatial/geographic data
-storage systems such as PostGIS. It also provides a suite of useful tools
-for writing location-aware applications using Ruby-based frameworks such
-as Ruby On Rails.
-
-IMPORTANT: RGeo is currently under development, and we consider it to be
-in a "pre-alpha" state. Several features are not yet complete, and there
-are known bugs and holes in the test suite. We also expect the APIs to be
-in flux for a short while longer. Therefore, we do not yet recommend the
-use of RGeo in production.
+RGeo is a geospatial data library for Ruby.
 
 === Summary
 
-RGeo is a core component for writing location-aware applications in the
-Ruby programming language. It provides the basic tools for modeling
-location data and communicating with location-aware storage systems
-and services.
+RGeo is a key component for writing location-aware applications in the
+Ruby programming language. At its core is an implementation of the
+industry standard OGC Simple Features Specification, which provides data
+representations of geometric objects such as points, lines, and polygons,
+along with a set of geometric analysis operations. It also includes a
+suite of components for modeling location data, communicating with
+location-aware services and database systems, and writing location-aware
+applications with Ruby On Rails.
 
 Use RGeo to:
 
@@ -27,22 +19,31 @@ Use RGeo to:
   and polygons in your Ruby application.
 * Perform standard spatial analysis operations such as finding
   intersections, creating buffers, and computing lengths and areas.
-* Correctly handle spherical geometry, and compute projections for
-  geographic data analysis.
-* Store and retrieve spatial data in industry standard spatial database
+* Correctly handle spherical geometry, and compute geographic projections
+  for map display and data analysis.
+* Store and retrieve data in industry standard spatial database
   systems such as MySQL Spatial, SpatiaLite, and PostGIS.
 * Generate and interpret GeoJSON data for communication with common
   location-based web services such as SimpleGeo.
 * Read legacy GIS data from ESRI shapefiles.
 * Extend Ruby On Rails to handle location data in a web application.
-* Follow the latest standards from the Open Geospatial Consortium.
+* Write to the latest standards from the Open Geospatial Consortium.
+
+IMPORTANT: RGeo is currently under development, and we consider it to be
+in a "pre-alpha" state. Several features are not yet complete, and there
+are known bugs and holes in the test suite. We also expect the APIs to be
+in flux for a short while longer. Therefore, we do not yet recommend the
+use of RGeo in production.
 
 === Requirements
 
-RGeo has the following prerequisites:
+RGeo has the following hard requirements:
 
 * Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
   Rubinius and JRuby are not yet supported.
+
+Some features also require the following:
+
 * GEOS 3.2 or later is highly recommended. Some functions will not be
   available without it. This C/C++ library may be available via your
   operating system's package manager, or you can download it from
@@ -55,10 +56,11 @@ RGeo has the following prerequisites:
   install the "json" gem. Ruby 1.9 has JSON support in its standard
   library and does not require the gem.
 * If you are using the shapefile reader, you should install the "dbf"
-  gem, version 1.5.2 or later, which is required to read the attributes.
+  gem, version 1.5.2 or later, which is needed to read the attributes.
 * The ActiveRecord adapters for MySQL Spatial, PostGIS, and SpatiaLite
-  require ActiveRecord 3.0.3 or later, Arel 2.0 or later, and the
-  corresponding database driver gems (e.g. "mysql" or "mysql2").
+  require ActiveRecord 3.0.3 or later, and the corresponding database
+  driver gems (e.g. "mysql", "mysql2", "sqlite3-ruby", "pg", etc.).
+  Note that the adapters are NOT compatible with ActiveRecord 2.3.
 
 === Installation
 
@@ -81,7 +83,7 @@ the switches interpreted by the gem command. For example:
 
  gem install rgeo -- --with-geos-dir=/path/to/my/geos/installation
 
-Similarly, the gem installation looks for the Proj.4 library in the
+Similarly, the gem installation looks for the Proj4 library in the
 following locations by default:
 
 * /usr/local
@@ -95,13 +97,14 @@ installation prefix directory using the "--with-proj-dir" option.
 
 === To-do items
 
-This is our planned feature roadmap, in rough priority order.
+This is our planned roadmap, in rough priority order.
 
-* SpatiaLite and PostGIS adapters for ActiveRecord. (We already have an
-  adapter for MySQL Spatial.)
-* Integration with certain third-party services such as SimpleGeo.
+* Continued work on the ActiveRecord adapters.
+* Possible Arel extensions for constructing spatial queries.
+* OGC coordinate system representation.
 * Support for bbox and crs elements of GeoJSON.
 * Ellipsoidal geography implementation, probably utilizing geographiclib.
+* Integration with certain third-party services such as SimpleGeo.
 * Rubinius support for C library integration.
 * JRuby support via JTS integration.
 * Support for writing shapefiles. (Reading is already implemented.)
@@ -126,13 +129,13 @@ Development of RGeo is sponsored by GeoPage, Inc. (http://www.geopage.com/).
 RGeo links with the GEOS library to handle most Cartesian geometric
 calculations, and with the Proj4 library to handle projections and
 coordinate transforms. These libraries are maintained by the Open Source
-Geospatial Foundation; these and other OSGeo projects can be found on
-OSGeo's web site (http://www.osgeo.org/).
+Geospatial Foundation; more information is available on OSGeo's web site
+(http://www.osgeo.org/).
 
 The ActiveRecord adapters owe some debt to the spatial_adapter plugin
-(http://github.com/fragility/spatial_adapter). We made a few different
-design decisions for RGeo, but studying the spatial_adapter source gave
-us a head start on our implementation.
+(http://github.com/fragility/spatial_adapter). RGeo's implementation is
+a little different because we made some different design decisions, but
+studying the spatial_adapter source gave us a head start.
 
 Although we don't use shapelib (http://shapelib.maptools.org/) to read
 ESRI shapefiles, we did borrow a bunch of their test cases.

data/Version

@@ -1 +1 @@
-0.1.20
+0.1.21

data/lib/active_record/connection_adapters/mysql2spatial_adapter.rb

@@ -107,9 +107,7 @@ module ActiveRecord
           if current_index_ != row_[:Key_name]
             next if row_[:Key_name] == 'PRIMARY' # skip the primary key
             current_index_ = row_[:Key_name]
-            new_index_ = ::RGeo::ActiveRecord::MysqlCommon::IndexDefinition.new(row_[:Table], row_[:Key_name], row_[:Non_unique] == 0, [], [])
-            new_index_.spatial = row_[:Index_type] == 'SPATIAL'
-            indexes_ << new_index_
+            indexes_ << ::RGeo::ActiveRecord::Common::IndexDefinition.new(row_[:Table], row_[:Key_name], row_[:Non_unique] == 0, [], [], row_[:Index_type] == 'SPATIAL')
           end
           indexes_.last.columns << row_[:Column_name]
           indexes_.last.lengths << row_[:Sub_part]

data/lib/active_record/connection_adapters/mysqlspatial_adapter.rb

@@ -102,7 +102,9 @@ module ActiveRecord
       def columns(table_name_, name_=nil)
         result_ = execute("SHOW FIELDS FROM #{quote_table_name(table_name_)}", :skip_logging)
         columns_ = []
-        result_.each{ |field_| columns_ << SpatialColumn.new(field_[0], field_[4], field_[1], field_[2] == "YES") }
+        result_.each do |field_|
+          columns_ << SpatialColumn.new(field_[0], field_[4], field_[1], field_[2] == "YES")
+        end
         result_.free
         columns_
       end
@@ -116,9 +118,7 @@ module ActiveRecord
           if current_index_ != row_[2]
             next if row_[2] == "PRIMARY" # skip the primary key
             current_index_ = row_[2]
-            new_index_ = ::RGeo::ActiveRecord::MysqlCommon::IndexDefinition.new(row_[0], row_[2], row_[1] == "0", [], [])
-            new_index_.spatial = row_[10] == 'SPATIAL'
-            indexes_ << new_index_
+            indexes_ << ::RGeo::ActiveRecord::Common::IndexDefinition.new(row_[0], row_[2], row_[1] == "0", [], [], row_[10] == 'SPATIAL')
           end
           indexes_.last.columns << row_[4]
           indexes_.last.lengths << row_[7]

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -0,0 +1,426 @@
+# -----------------------------------------------------------------------------
+# 
+# PostGIS adapter for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# 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 'rgeo/active_record/common'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+
+module ActiveRecord
+  
+  class Base
+    
+    
+    # Create a postgis connection adapter.
+    
+    
+    def self.postgis_connection(config_)
+      require 'pg'
+      
+      config_ = config_.symbolize_keys
+      host_ = config_[:host]
+      port_ = config_[:port] || 5432
+      username_ = config_[:username].to_s if config_[:username]
+      password_ = config_[:password].to_s if config_[:password]
+      if config_.has_key?(:database)
+        database_ = config_[:database]
+      else
+        raise ::ArgumentError, "No database specified. Missing argument: database."
+      end
+      
+      # The postgres drivers don't allow the creation of an unconnected PGconn object,
+      # so just pass a nil connection object for the time being.
+      ConnectionAdapters::PostGisAdapter.new(nil, logger, [host_, port_, nil, nil, database_, username_, password_], config_)
+    end
+    
+    
+  end
+  
+  
+  module ConnectionAdapters  # :nodoc:
+    
+    
+    class PostGisAdapter < PostgreSQLAdapter  # :nodoc:
+      
+      
+      ADAPTER_NAME = 'PostGIS'.freeze
+      
+      @@native_database_types = nil
+      
+      
+      def native_database_types
+        @@native_database_types ||= super.merge(:geometry => {:name => "geometry"}, :point => {:name => "point"}, :line_string => {:name => "linestring"}, :polygon => {:name => "polygon"}, :geometry_collection => {:name => "geometrycollection"}, :multi_point => {:name => "multipoint"}, :multi_line_string => {:name => "multilinestring"}, :multi_polygon => {:name => "multipolygon"})
+      end
+      
+      
+      def adapter_name
+        ADAPTER_NAME
+      end
+      
+      
+      def postgis_lib_version
+        unless defined?(@postgis_lib_version)
+          @postgis_lib_version = select_value("SELECT PostGIS_Lib_Version()") rescue nil
+        end
+        @postgis_lib_version
+      end
+      
+      
+      def quote(value_, column_=nil)
+        if ::RGeo::Feature::Geometry.check_type(value_)
+          "'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value_)}'"
+        else
+          super
+        end
+      end
+      
+      
+      def columns(table_name_, name_=nil)  #:nodoc:
+        table_name_ = table_name_.to_s
+        spatial_info_ = spatial_column_info(table_name_)
+        column_definitions(table_name_).collect do |name_, type_, default_, notnull_|
+          SpatialColumn.new(name_, default_, type_, notnull_ == 'f', type_ =~ /geometry/i ? spatial_info_[name_] : nil)
+        end
+      end
+      
+      
+      def create_table(table_name_, options_={})
+        table_name_ = table_name_.to_s
+        table_definition_ = SpatialTableDefinition.new(self)
+        table_definition_.primary_key(options_[:primary_key] || ::ActiveRecord::Base.get_primary_key(table_name_.singularize)) unless options_[:id] == false
+        yield table_definition_ if block_given?
+        if options_[:force] && table_exists?(table_name_)
+          drop_table(table_name_, options_)
+        end
+        
+        create_sql_ = "CREATE#{' TEMPORARY' if options_[:temporary]} TABLE "
+        create_sql_ << "#{quote_table_name(table_name_)} ("
+        create_sql_ << table_definition_.to_sql
+        create_sql_ << ") #{options_[:options]}"
+        execute create_sql_
+        
+        table_definition_.non_geographic_spatial_columns.each do |col_|
+          type_ = col_.type.to_s.gsub('_', '').upcase
+          has_z_ = col_.has_z?
+          has_m_ = col_.has_m?
+          type_ = "#{type_}M" if has_m_ && !has_z_
+          dimensions_ = 2
+          dimensions_ += 1 if has_z_
+          dimensions_ += 1 if has_m_
+          execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(col_.name)}', #{col_.srid}, '#{quote_string(type_)}', #{dimensions_})")
+        end
+      end
+      
+      
+      def drop_table(table_name_, options_={})
+        execute("DELETE from geometry_columns where f_table_name='#{quote_string(table_name_.to_s)}'")
+        super
+      end
+      
+      
+      def add_column(table_name_, column_name_, type_, options_={})
+        table_name_ = table_name_.to_s
+        if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(type_.to_sym)
+          type_ = type_.to_s.gsub('_', '').upcase
+          has_z_ = options_[:has_z]
+          has_m_ = options_[:has_m]
+          srid_ = (options_[:srid] || 4326).to_i
+          if options_[:geographic]
+            type_ << 'Z' if has_z_
+            type_ << 'M' if has_m_
+            execute("ALTER TABLE #{quote_table_name(table_name_)} ADD COLUMN #{quote_column_name(column_name_)} GEOGRAPHY(#{type_},#{srid_})")
+            change_column_default(table_name_, column_name_, options_[:default]) if options_include_default?(options_)
+            change_column_null(table_name_, column_name_, false, options_[:default]) if options_[:null] == false
+          else
+            type_ = "#{type_}M" if has_m_ && !has_z_
+            dimensions_ = 2
+            dimensions_ += 1 if has_z_
+            dimensions_ += 1 if has_m_
+            execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(column_name_.to_s)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
+          end
+        else
+          super
+        end
+      end
+      
+      
+      def remove_column(table_name_, *column_names_)
+        column_names_ = column_names_.flatten.map{ |n_| n_.to_s }
+        spatial_info_ = spatial_column_info(table_name_)
+        remaining_column_names_ = []
+        column_names_.each do |name_|
+          if spatial_info_.include?(name_)
+            execute("SELECT DropGeometryColumn('#{quote_string(table_name_.to_s)}','#{quote_string(name_)}')")
+          else
+            remaining_column_names_ << name_.to_sym
+          end
+        end
+        if remaining_column_names_.size > 0
+          super(table_name_, *remaining_column_names_)
+        end
+      end
+      
+      
+      def add_index(table_name_, column_name_, options_={})
+        table_name_ = table_name_.to_s
+        column_names_ = ::Array.wrap(column_name_)
+        index_name_ = index_name(table_name_, :column => column_names_)
+        gist_clause_ = ''
+        index_type_ = ''
+        if ::Hash === options_  # legacy support, since this param was a string
+          index_type_ = 'UNIQUE' if options_[:unique]
+          index_name_ = options_[:name].to_s if options_.key?(:name)
+          gist_clause_ = 'USING GIST' if options_[:spatial]
+        else
+          index_type_ = options_
+        end
+        if index_name_.length > index_name_length
+          raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' is too long; the limit is #{index_name_length} characters"
+        end
+        if index_name_exists?(table_name_, index_name_, false)
+          raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' already exists"
+        end
+        quoted_column_names_ = quoted_columns_for_index(column_names_, options_).join(", ")
+        execute "CREATE #{index_type_} INDEX #{quote_column_name(index_name_)} ON #{quote_table_name(table_name_)} #{gist_clause_} (#{quoted_column_names_})"
+      end
+      
+      
+      def spatial_column_info(table_name_)
+        info_ = query("SELECT * FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
+        result_ = {}
+        info_.each do |row_|
+          name_ = row_[3]
+          type_ = row_[6]
+          dimension_ = row_[4].to_i
+          has_m_ = type_ =~ /m$/i ? true : false
+          type_.sub!(/m$/, '')
+          has_z_ = dimension_ > 3 || dimension_ == 3 && !has_m_
+          result_[name_] = {
+            :name => name_,
+            :type => type_,
+            :dimension => dimension_,
+            :srid => row_[5].to_i,
+            :has_z => has_z_,
+            :has_m => has_m_,
+          }
+        end
+        result_
+      end
+      
+      
+      class SpatialTableDefinition < ConnectionAdapters::TableDefinition  # :nodoc:
+        
+        attr_reader :spatial_columns
+        
+        def initialize(base_)
+          super
+        end
+        
+        def column(name_, type_, options_={})
+          super
+          col_ = self[name_]
+          if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(col_.type.to_sym)
+            col_.extend(GeometricColumnDefinitionMethods) unless col_.respond_to?(:geographic?)
+            col_.set_geographic(options_[:geographic])
+            col_.set_srid((options_[:srid] || 4326).to_i)
+            col_.set_has_z(options_[:has_z])
+            col_.set_has_m(options_[:has_m])
+          end
+          self
+        end
+        
+        def to_sql
+          @columns.find_all{ |c_| !c_.respond_to?(:geographic?) || c_.geographic? }.map{ |c_| c_.to_sql } * ', '
+        end
+        
+        def non_geographic_spatial_columns
+          @columns.find_all{ |c_| c_.respond_to?(:geographic?) && !c_.geographic? }
+        end
+        
+      end
+      
+      
+      module GeometricColumnDefinitionMethods  # :nodoc:
+        
+        def geographic?
+          defined?(@geographic) && @geographic
+        end
+        
+        def srid
+          defined?(@srid) ? @srid : 4326
+        end
+        
+        def has_z?
+          defined?(@has_z) && @has_z
+        end
+        
+        def has_m?
+          defined?(@has_m) && @has_m
+        end
+        
+        def set_geographic(value_)
+          @geographic = value_ ? true : false
+        end
+        
+        def set_srid(value_)
+          @srid = value_
+        end
+        
+        def set_has_z(value_)
+          @has_z = value_ ? true : false
+        end
+        
+        def set_has_m(value_)
+          @has_m = value_ ? true : false
+        end
+        
+        def sql_type
+          type_ = type.to_s.upcase.gsub('_', '')
+          type_ << 'Z' if has_z?
+          type_ << 'M' if has_m?
+          "GEOGRAPHY(#{type_},#{srid})"
+        end
+        
+      end
+      
+      
+      class SpatialColumn < ConnectionAdapters::PostgreSQLColumn  # :nodoc:
+        
+        
+        def initialize(name_, default_, sql_type_=nil, null_=true, opts_=nil)
+          super(name_, default_, sql_type_, null_)
+          @geographic = sql_type_ =~ /^geography/ ? true : false
+          if opts_
+            @geometric_type = ::RGeo::ActiveRecord::Common.geometric_type_from_name(opts_[:type])
+            @srid = opts_[:srid].to_i
+            @has_z = opts_[:has_z]
+            @has_m = opts_[:has_m]
+          elsif @geographic
+            if sql_type_ =~ /geography\((\w+[^,zm])(z?)(m?),(\d+)\)/i
+              @has_z = $2.length > 0
+              @has_m = $3.length > 0
+              @srid = $4.to_i
+              @geometric_type = ::RGeo::ActiveRecord::Common.geometric_type_from_name($1)
+            else
+              @geometric_type = ::RGeo::Feature::Geometry
+              @srid = 4326
+              @has_z = @has_m = false
+            end
+          else
+            @geometric_type = @has_z = @has_m = nil
+            @srid = 0
+          end
+          @ar_class = ::ActiveRecord::Base
+        end
+        
+        
+        def set_ar_class(val_)
+          @ar_class = val_
+        end
+        
+        
+        attr_reader :srid
+        attr_reader :geometric_type
+        attr_reader :has_z
+        attr_reader :has_m
+        
+        
+        def spatial?
+          type == :geometry
+        end
+        
+        
+        def geographic?
+          @geographic
+        end
+        
+        
+        def klass
+          type == :geometry ? ::RGeo::Feature::Geometry : super
+        end
+        
+        
+        def type_cast(value_)
+          type == :geometry ? SpatialColumn.string_to_geometry(value_, @ar_class, @geographic, @srid, @has_z, @has_m) : super
+        end
+        
+        
+        def type_cast_code(var_name_)
+          type == :geometry ? "::ActiveRecord::ConnectionAdapters::PostGisAdapter::SpatialColumn.string_to_geometry(#{var_name_}, self.class, #{@geographic ? 'true' : 'false'}, #{@srid.inspect}, #{@has_z ? 'true' : 'false'}, #{@has_m ? 'true' : 'false'})" : super
+        end
+        
+        
+        private
+        
+        
+        def simplified_type(sql_type_)
+          sql_type_ =~ /geography|geometry|point|linestring|polygon/i ? :geometry : super
+        end
+        
+        
+        def self.string_to_geometry(str_, ar_class_, geographic_, srid_, has_z_, has_m_)
+          case str_
+          when ::RGeo::Feature::Geometry
+            str_
+          when ::String
+            if str_.length == 0
+              nil
+            else
+              factory_ = ar_class_.rgeo_factory_generator.call(:srid => srid_, :support_z_coordinate => has_z_, :support_m_coordinate => has_m_, :geographic => geographic_)
+              marker_ = str_[0,1]
+              if marker_ == "\x00" || marker_ == "\x01"
+                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse(str_) rescue nil
+              elsif str_[0,4] =~ /[0-9a-fA-F]{4}/
+                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse_hex(str_) rescue nil
+              else
+                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(str_) rescue nil
+              end
+            end
+          else
+            nil
+          end
+        end
+        
+        
+      end
+      
+      
+    end
+    
+    
+  end
+  
+  
+end