ffi-gdal 1.0.0.beta16 → 1.0.0

data/lib/ogr/error_handling.rb

@@ -10,38 +10,36 @@ module OGR
   # Unlike the OGR API, ffi-gdal defines an Enum for the OGRERR types, which
   # in turns causes OGR to return Symbols on errors (the #defines for those can
   # be found here: http://www.gdal.org/ogr__core_8h.html).  This maps those
-  # Symbols to Ruby exceptions (or lack thereof).  The sad part of this
-  # solution is that any function that returns an OGRErr needs to assign that
-  # Symbol to a variable, then call #handle_result to get that
-  # Symbol-to-Exception mapping to take place.
+  # Symbols to Ruby exceptions (or lack thereof).
   module ErrorHandling
-    def handle_result(msg = nil)
-      error_class_map(self).call(msg)
-    end
+    ERROR_CLASS_MAP = {
+      OGRERR_NONE: nil,
+      OGRERR_NOT_ENOUGH_DATA: OGR::NotEnoughData,
+      OGRERR_NOT_ENOUGH_MEMORY: ::NoMemoryError,
+      OGRERR_UNSUPPORTED_GEOMETRY_TYPE: OGR::UnsupportedGeometryType,
+      OGRERR_UNSUPPORTED_OPERATION: OGR::UnsupportedOperation,
+      OGRERR_CORRUPT_DATA: OGR::CorruptData,
+      OGRERR_FAILURE: OGR::Failure,
+      OGRERR_UNSUPPORTED_SRS: OGR::UnsupportedSRS,
+      OGRERR_INVALID_HANDLE: OGR::InvalidHandle
+    }.freeze
+
+    # Yields, then expects the result to be a Symbol from FFI::OGR::Core::Err.
+    #
+    # @param msg [String]
+    def self.handle_ogr_err(msg)
+      ogr_err_symbol = yield
 
-    private
+      klass = ERROR_CLASS_MAP.fetch(ogr_err_symbol) { raise "Unknown OGRERR type: #{self}" }
 
-    # @param [Symbol] error_class
-    # @return [Proc]
-    def error_class_map(error_class)
-      {
-        OGRERR_NONE: ->(_msg) { true },
-        OGRERR_NOT_ENOUGH_DATA: ->(msg) { raise_exception(OGR::NotEnoughData, msg) },
-        OGRERR_NOT_ENOUGH_MEMORY: ->(msg) { raise_exception(::NoMemoryError, msg) },
-        OGRERR_UNSUPPORTED_GEOMETRY_TYPE: ->(msg) { raise_exception(OGR::UnsupportedGeometryType, msg) },
-        OGRERR_UNSUPPORTED_OPERATION: ->(msg) { raise_exception(OGR::UnsupportedOperation, msg) },
-        OGRERR_CORRUPT_DATA: ->(msg) { raise_exception(OGR::CorruptData, msg) },
-        OGRERR_FAILURE: ->(msg) { raise_exception(OGR::Failure, msg) },
-        OGRERR_UNSUPPORTED_SRS: ->(msg) { raise_exception(OGR::UnsupportedSRS, msg) },
-        OGRERR_INVALID_HANDLE: ->(msg) { raise_exception(OGR::InvalidHandle, msg) }
-      }.fetch(error_class) { raise "Unknown OGRERR type: #{self}" }
+      raise_exception(klass, msg) if klass
     end
 
     # Exists solely to strip off the top 4 lines of the backtrace so it doesn't
     # look like the problem is coming from here.
-    def raise_exception(exception, message)
+    def self.raise_exception(exception, message)
       e = exception.new(message)
-      e.set_backtrace(caller(4))
+      e.set_backtrace(caller(2))
       raise(e)
     end
   end

data/lib/ogr/extensions/all.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, '**/extensions/**/*.rb')].sort.each { |f| require f }

data/lib/ogr/{data_source_mixins → extensions/data_source}/capability_methods.rb

@@ -27,3 +27,5 @@ module OGR
     end
   end
 end
+
+OGR::DataSource.include(OGR::DataSourceMixins::CapabilityMethods)

data/lib/ogr/extensions/data_source/data_source_extensions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'ogr/data_source'
+
+module OGR
+  class DataSource
+    module Extensions
+      # @return [Array<OGR::Layer>]
+      def layers
+        @layers = Array.new(layer_count) { |i| layer(i) }
+      end
+    end
+  end
+end
+
+OGR::DataSource.include(OGR::DataSource::Extensions)

data/lib/ogr/{driver_mixins → extensions/driver}/capability_methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'ogr/driver'
+
 module OGR
   module DriverMixins
     # Helper methods for testing capabilities of the current driver.
@@ -11,8 +13,10 @@ module OGR
 
       # @return [Boolean] +true+ if this driver supports deleting data sources.
       def can_delete_data_source?
-        test_capability('DataDataSource')
+        test_capability('DeleteDataSource')
       end
     end
   end
 end
+
+OGR::Driver.include(OGR::DriverMixins::CapabilityMethods)

data/lib/ogr/extensions/envelope/extensions.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'ogr/envelope'
+
+module OGR
+  class Envelope
+    module Extensions
+      # @return [Float] x_max - x_min
+      def x_size
+        x_max - x_min
+      end
+
+      # @return [Float] y_max - y_min
+      def y_size
+        y_max - y_min
+      end
+
+      # @return [Float] z_max - z_min
+      def z_size
+        return unless z_max && z_min
+
+        z_max - z_min
+      end
+
+      # Adapted from "Advanced Geospatial Python Modeling".  Calculates the
+      # pixel locations of these geospatial coordinates according to the given
+      # GeoTransform.
+      #
+      # @param geo_transform [GDAL::GeoTransform]
+      # @return [Hash{x_min => Integer, y_min => Integer, x_max => Integer, y_max => Integer}]
+      def world_to_pixels(geo_transform)
+        min_values = geo_transform.world_to_pixel(x_min, y_max)
+        max_values = geo_transform.world_to_pixel(x_max, y_min)
+
+        {
+          x_min: min_values[:pixel].round.to_i,
+          y_min: min_values[:line].round.to_i,
+          x_max: max_values[:pixel].round.to_i,
+          y_max: max_values[:line].round.to_i
+        }
+      end
+
+      # Compares min/max X and min/max Y to the other envelope.  The envelopes are
+      # considered equal if those values are the same.
+      #
+      # @param other [OGR::Envelope]
+      # @return [Boolean]
+      def ==(other)
+        x_min == other.x_min && y_min == other.y_min &&
+          x_max == other.x_max && y_max == other.y_max
+      end
+
+      # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
+      #
+      # @param other_envelope [OGR::Envelope] The Envelope to merge self with.
+      # @return [OGR::Envelope]
+      def merge(other_envelope)
+        new_envelope = OGR::Envelope.new
+        new_envelope.x_min = [x_min, other_envelope.x_min].min
+        new_envelope.x_max = [x_max, other_envelope.x_max].max
+        new_envelope.y_min = [y_min, other_envelope.y_min].min
+        new_envelope.y_max = [y_max, other_envelope.y_max].max
+
+        new_envelope
+      end
+
+      # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
+      #
+      # @param other_envelope [OGR::Envelope] The Envelope to check intersection
+      #   with.
+      # @return [Boolean]
+      def intersects?(other_envelope)
+        x_min <= other_envelope.x_max &&
+          x_max >= other_envelope.x_min &&
+          y_min <= other_envelope.y_max &&
+          y_max >= other_envelope.y_min
+      end
+
+      # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
+      #
+      # @param other_envelope [OGR::Envelope] The Envelope to check containment
+      #   with.
+      # @return [Boolean]
+      def contains?(other_envelope)
+        x_min <= other_envelope.x_min &&
+          y_min <= other_envelope.y_min &&
+          x_max >= other_envelope.x_max &&
+          y_max >= other_envelope.y_max
+      end
+
+      # @return [OGR::Polygon]
+      def to_polygon
+        ring = OGR::LinearRing.new
+        ring.point_count = 5
+        ring.set_point(0, x_min, y_max)
+        ring.set_point(1, x_max, y_max)
+        ring.set_point(2, x_max, y_min)
+        ring.set_point(3, x_min, y_min)
+        ring.set_point(4, x_min, y_max)
+
+        polygon = OGR::Polygon.new
+        polygon.add_geometry(ring)
+
+        polygon
+      end
+
+      def to_a
+        [x_min, y_min, x_max, y_max]
+      end
+    end
+  end
+end
+
+OGR::Envelope.include(OGR::Envelope::Extensions)

data/lib/ogr/extensions/feature/extensions.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'ogr/feature'
+
+module OGR
+  class Feature
+    module Extensions
+      # Retrieves the value for each field and yields it.
+      #
+      # @return [Enumerator]
+      # @yieldparam [Number, String, Array]
+      def each_field
+        return enum_for(:each_field) unless block_given?
+
+        field_count.times do |i|
+          yield field(i)
+        end
+      end
+
+      # @return [Array] Uses each FieldDefinition to determine the field type at
+      #   each index and returns maps the field as that value type.
+      def fields
+        each_field.to_a
+      end
+
+      # Retrieves a field using +index+, but uses its type from the associated
+      # {OGR::FieldDefinition} to determine it's core type to return as. This
+      # saves from having to find out the type then call the associated
+      # +field_as_[type]+ method if you just want the data in it's originally
+      # intended form.
+      #
+      # @param index [Integer] Index of the field to retrieve the data for.
+      # @return [Number, String, Array]
+      # @raise [OGR::UnsupportedFieldType] if the associated FieldDefinition's
+      #   type has not yet been mapped here (to know how to return the value).
+      def field(index)
+        field_type = field_definition(index).type
+
+        case field_type
+        when :OFTInteger, :OFTInteger64 then                    field_as_integer(index)
+        when :OFTIntegerList, :OFTInteger64List then            field_as_integer_list(index)
+        when :OFTReal then                                      field_as_double(index)
+        when :OFTRealList then                                  field_as_double_list(index)
+        when :OFTString, :OFTWideString then                    field_as_string(index)
+        when :OFTStringList, :OFTWideStringList then            field_as_string_list(index)
+        when :OFTBinary then                                    field_as_binary(index)
+        when :OFTDate, :OFTTime, :OFTDateTime, :OFTMaxType then field_as_date_time(index)
+        else
+          raise OGR::UnsupportedFieldType,
+                "Don't know how to fetch field for field type: #{field_type}"
+        end
+      end
+
+      # @return [Enumerator]
+      # @yieldparam [OGR::GeometryFieldDefinition]
+      def each_geometry_field_definition
+        return enum_for(:each_geometry_field_definition) unless block_given?
+
+        geometry_field_count.times do |i|
+          yield geometry_field_definition(i)
+        end
+      end
+
+      # @return [Array<OGR::GeometryFieldDefinition>]
+      def geometry_field_definitions
+        each_geometry_field_definition.to_a
+      end
+
+      # @return [Enumerator]
+      # @yieldparam [OGR::Geometry]
+      def each_geometry_field
+        return enum_for(:each_geometry_field) unless block_given?
+
+        geometry_field_count.times do |i|
+          yield geometry_field(i)
+        end
+      end
+
+      # @return [Array<OGR::Geometry>]
+      def geometry_fields
+        each_geometry_field.to_a
+      end
+    end
+  end
+end
+
+OGR::Feature.include(OGR::Feature::Extensions)

data/lib/ogr/extensions/feature_definition/extensions.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ogr/feature_definition'
+
+module OGR
+  class FeatureDefinition
+    module Extensions
+      # @return [Array<OGR::FieldDefinition>]
+      def field_definitions
+        return [] if field_count.zero?
+
+        Array.new(field_count) { |i| field_definition(i) }
+      end
+
+      # @return [Array<OGR::GeometryFieldDefinition>]
+      def geometry_field_definitions
+        return [] if geometry_field_count.zero?
+
+        Array.new(geometry_field_count) { |i| geometry_field_definition(i) }
+      end
+
+      # @param name [String]
+      # @return [OGR::FieldDefinition]
+      def field_definition_by_name(name)
+        i = field_index(name)
+        return unless i
+
+        field_definition(i)
+      end
+
+      # @param name [String]
+      # @return [OGR::GeometryFieldDefinition]
+      def geometry_field_definition_by_name(name)
+        g = geometry_field_index(name)
+        return unless g
+
+        geometry_field_definition(g)
+      end
+    end
+  end
+end
+
+OGR::FeatureDefinition.include(OGR::FeatureDefinition::Extensions)

data/lib/ogr/extensions/geometries/point/extensions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'ogr/geometry'
+
+module OGR
+  class Point
+    module Extensions
+      # Wrapper around {#point_value} to provide API parity with other geometries
+      # that can have multiple points.
+      #
+      # @return [Array<Array<Float, Float>>]
+      def point_values
+        [point]
+      end
+    end
+  end
+end
+
+OGR::Point.include(OGR::Point::Extensions)

data/lib/ogr/extensions/geometry/container_mixins.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ogr/geometries/geometry_collection'
+require 'ogr/geometries/geometry_collection_25d'
+require 'ogr/geometries/multi_line_string'
+require 'ogr/geometries/multi_line_string_25d'
+require 'ogr/geometries/multi_point'
+require 'ogr/geometries/multi_point_25d'
+require 'ogr/geometries/multi_polygon'
+require 'ogr/geometries/multi_polygon_25d'
+require 'ogr/geometries/polygon'
+require 'ogr/geometries/polygon_25d'
+
+module OGR
+  module GeometryMixins
+    module ContainerMixins
+      include Enumerable
+
+      def collection?
+        true
+      end
+
+      # Iterates over each geometry in the container geometry. Per `OGR` docs, the
+      # yielded geometry should not be modified; if you need to do something to
+      # that geometry, you should {{#clone}} it. Additionally, the yielded
+      # geometry is only valid until the container changes.
+      #
+      # @yieldparam [OGR::Geometry]
+      # @return [Enumerator]
+      # @see http://gdal.org/1.11/ogr/ogr__api_8h.html#a6bac93150529a5c98811db29e289dd66
+      def each
+        return enum_for(:each) unless block_given?
+
+        geometry_count.times do |i|
+          yield geometry_at(i)
+        end
+      end
+    end
+  end
+end
+
+# Using prepend here to override the `#collection?` method that's already defined on Geometry.
+OGR::GeometryCollection.prepend(OGR::GeometryMixins::ContainerMixins)
+OGR::GeometryCollection25D.prepend(OGR::GeometryMixins::ContainerMixins)
+
+OGR::MultiPolygon.prepend(OGR::GeometryMixins::ContainerMixins)
+OGR::MultiPolygon25D.prepend(OGR::GeometryMixins::ContainerMixins)
+
+OGR::MultiLineString.prepend(OGR::GeometryMixins::ContainerMixins)
+OGR::MultiLineString25D.prepend(OGR::GeometryMixins::ContainerMixins)
+
+OGR::MultiPoint.prepend(OGR::GeometryMixins::ContainerMixins)
+OGR::MultiPoint25D.prepend(OGR::GeometryMixins::ContainerMixins)
+
+OGR::Polygon.prepend(OGR::GeometryMixins::ContainerMixins)
+OGR::Polygon25D.prepend(OGR::GeometryMixins::ContainerMixins)

data/lib/ogr/extensions/geometry/ewkb_io_extensions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'ogr/spatial_reference'
+require_relative 'ewkb_record'
+require_relative 'wkb_record'
+
+module OGR
+  module Geometry
+    # Extends OGR::Geometry with methods that allow creating a Geometry from
+    # EKWB or outputting a Geometry as EWKB (EWKB is the WKB format that PostGIS
+    # uses).
+    module EWKBIOExtensions
+      # Methods to extend OGR::Geometry with.
+      module ClassMethods
+        # @param ewkb_data [String] Binary EWKB string.
+        # @return [OGR::Geometry]
+        def create_from_ewkb(ewkb_data)
+          e = EWKBRecord.read(ewkb_data)
+
+          if e.srid?
+            spatial_ref = OGR::SpatialReference.new.import_from_epsg(e.srid)
+            create_from_wkb(e.to_wkb, spatial_ref)
+          else
+            create_from_wkb(e.to_wkb)
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # @return [String] Binary string representative of EWKB.
+      def to_ewkb
+        wkb_record = WKBRecord.read(to_wkb)
+        srid = spatial_reference ? spatial_reference.authority_code.to_i : 0
+
+        EWKBRecord.from_wkb_record(wkb_record, srid).to_binary_s
+      end
+    end
+  end
+end
+
+OGR::Geometry.include OGR::Geometry::EWKBIOExtensions

data/lib/ogr/extensions/geometry/ewkb_record.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'bindata'
+require 'ffi-gdal'
+require 'ogr'
+require_relative 'wkb_record'
+
+# rubocop:disable Naming/PredicateName
+module OGR
+  module Geometry
+    # Parses raw EWKB and turns into a data structure. Only really exists for
+    # converting to and from EWKB.
+    #
+    # @see http://trac.osgeo.org/postgis/browser/trunk/doc/ZMSgeoms.txt
+    # @see OGR::Geometry::EWKBRecord
+    class EWKBRecord < BinData::Record
+      uint8 :endianness, assert: -> { [0, 1].include?(value) }
+
+      # Choose the type based on the endianness.
+      choice :wkb_type, selection: :endianness do
+        uint32be 0
+        uint32le 1
+      end
+
+      # Make sure the geometry_type is one OGR knows about.
+      virtual assert: -> { FFI::OGR::Core::WKBGeometryType.symbol_map.value?(geometry_type) }
+
+      # If the wkb_type has the SRID flag set, there's an SRID.
+      choice :srid, onlyif: :has_srid?, selection: :endianness do
+        uint32be 0
+        uint32le 1
+      end
+
+      # The #geometry attribute is just the rest of the data. We don't care what
+      # kind of geom it actually is; that doesn't matter for building EWKB.
+      rest :geometry
+
+      WKB_Z     = 0x8000_0000
+      WKB_M     = 0x4000_0000
+      WKB_SRID  = 0x2000_0000
+
+      # @param wkb_record [OGR::Geometry::WKBRecord]
+      # @param srid [Fixnum]
+      # @return [OGR::Geometry::EWKBRecord]
+      def self.from_wkb_record(wkb_record, srid = 0)
+        ewkb_type_flag = if srid.zero?
+                           wkb_record.wkb_type
+                         else
+                           (wkb_record.wkb_type | WKB_SRID)
+                         end
+
+        ewkb_type_flag |= WKB_Z if wkb_record.has_z?
+
+        new(endianness: wkb_record.endianness,
+            wkb_type: ewkb_type_flag,
+            srid: srid,
+            geometry: wkb_record.geometry)
+      end
+
+      # @return [Boolean] Is the Z flag set?
+      def has_z?
+        wkb_type & WKB_Z != 0
+      end
+
+      # @return [Boolean] Is the M flag set?
+      def has_m?
+        wkb_type & WKB_M != 0
+      end
+
+      # @return [Boolean] Is the SRID flag set?
+      def has_srid?
+        wkb_type & WKB_SRID != 0
+      end
+
+      # @return [Fixnum] Enum number that matches the FFI::OGR::Core::WKBGeometryType.
+      def geometry_type
+        type = wkb_type & 0x0fff_ffff
+
+        has_z? ? (type | WKB_Z) : type
+      end
+
+      # @return [OGR::Geometry::WKBRecord]
+      def to_wkb_record
+        WKBRecord.from_ewkb_record(self)
+      end
+
+      # @return [String] WKB binary string.
+      def to_wkb
+        to_wkb_record.to_binary_s
+      end
+    end
+  end
+end
+# rubocop:enable Naming/PredicateName

data/lib/ogr/{geometry_mixins → extensions/geometry}/extensions.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
 
-require 'json'
+require 'ogr/geometry'
 
 module OGR
   module GeometryMixins
     module Extensions
-      # @return [Fixnum] The number of the UTM zone this geometry belongs to.
+      # @return [Integer] The number of the UTM zone this geometry belongs to.
       def utm_zone
         return unless spatial_reference
 
-        if spatial_reference.authority_code == '4326'
-          self_as4326 = self
-        else
-          self_as4326 = dup
-          self_as4326.transform_to!(OGR::SpatialReference.new_from_epsg(4326))
-        end
+        self_as4326 =
+          if spatial_reference.authority_code == '4326'
+            self
+          else
+            # NOTE: #clone here has overriden Ruby's clone and calls OGR_G_Clone;
+            # it's important to do this and
+            as4326 = clone
+            return unless as4326.transform_to!(OGR::SpatialReference.new.import_from_epsg(4326))
 
-        self_as4326 = self_as4326.buffer(0) unless self_as4326.valid?
+            as4326
+          end
+
+        self_as4326.self_as4326.buffer!(0) unless valid?
 
         return unless self_as4326.point_on_surface.x
 
@@ -80,3 +85,5 @@ module OGR
     end
   end
 end
+
+OGR::Geometry.include(OGR::GeometryMixins::Extensions)

data/lib/ogr/extensions/geometry/rttopo_extensions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'ogr'
+require 'ffi/extensions/rttopo'
+
+module OGR
+  module Geometry
+    # Methods for {{OGR::Geometry}}s that use rttopo to operate on
+    # themselves.
+    #
+    # @see http://postgis.net/docs/doxygen/2.1/da/de7/librttopo_8h_af8d208cf4c0bb7c9f96c75bddc6c498a.html#af8d208cf4c0bb7c9f96c75bddc6c498a
+    module RttopoExtensions
+      # Uses rttopo's make_valid to make the current geometry valid.
+      #
+      # @return [OGR::Geometry] Returns a new geometry, based on the
+      #   rttopo_make_valid call.
+      def make_valid
+        ctx = FFI::Rttopo.rtgeom_init FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL
+        geom = FFI::Rttopo.rtgeom_from_wkb(ctx, to_wkb, wkb_size, false)
+        valid_geom = FFI::Rttopo.rtgeom_make_valid(ctx, geom)
+        valid_wkb_size = FFI::MemoryPointer.new(:size_t)
+        valid_wkb_ptr = FFI::Rttopo.rtgeom_to_wkb(ctx, valid_geom, FFI::Rttopo::RTWKB_EXTENDED, valid_wkb_size)
+        valid_wkb = valid_wkb_ptr.read_bytes(valid_wkb_size.read_int)
+
+        FFI::Rttopo.rtfree ctx, geom
+        FFI::Rttopo.rtfree ctx, valid_geom
+        FFI::Rttopo.rtfree ctx, valid_wkb_ptr
+        FFI::Rttopo.rtgeom_finish ctx
+        OGR::Geometry.create_from_wkb(valid_wkb)
+      end
+    end
+  end
+end
+
+OGR::GeometryCollection25D.include(OGR::Geometry::RttopoExtensions)
+OGR::LineString.include(OGR::Geometry::RttopoExtensions)
+OGR::LineString25D.include(OGR::Geometry::RttopoExtensions)
+OGR::LinearRing.include(OGR::Geometry::RttopoExtensions)
+OGR::MultiLineString.include(OGR::Geometry::RttopoExtensions)
+OGR::MultiLineString25D.include(OGR::Geometry::RttopoExtensions)
+OGR::MultiPoint.include(OGR::Geometry::RttopoExtensions)
+OGR::MultiPoint25D.include(OGR::Geometry::RttopoExtensions)
+OGR::MultiPolygon.include(OGR::Geometry::RttopoExtensions)
+OGR::MultiPolygon25D.include(OGR::Geometry::RttopoExtensions)
+OGR::Point.include(OGR::Geometry::RttopoExtensions)
+OGR::Point25D.include(OGR::Geometry::RttopoExtensions)
+OGR::Polygon.include(OGR::Geometry::RttopoExtensions)
+OGR::Polygon25D.include(OGR::Geometry::RttopoExtensions)