ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/ogr/geometries/multi_point.rb

@@ -6,9 +6,10 @@ module OGR
     include GeometryTypes::Container
 
     # @param [FFI::Pointer] geometry_ptr
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbMultiPoint)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
     end
   end
 end

data/lib/ogr/geometries/multi_point_25d.rb

@@ -0,0 +1,14 @@
+require_relative 'multi_point'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbMultiPoint (read: 2D instead of 2.5D) until
+  # a Z value is set.
+  class MultiPoint25D < MultiPoint
+    # @param geometry_ptr [FFI::Pointer]
+    # @param spatial_reference [OGR::SpatialReference]
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbMultiPoint25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+  end
+end

data/lib/ogr/geometries/multi_polygon.rb

@@ -8,14 +8,15 @@ module OGR
     include GeometryTypes::Surface
 
     # @param [FFI::Pointer] geometry_ptr
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbMultiPolygon)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
     end
 
     # @return [OGR::Geometry]
     def union_cascaded
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_UnionCascaded(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_UnionCascaded(@c_pointer) }
     end
   end
 end

data/lib/ogr/geometries/multi_polygon_25d.rb

@@ -0,0 +1,13 @@
+require_relative 'multi_polygon'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbMultiPolygon (read: 2D instead of 2.5D)
+  # until a Z value is set.
+  class MultiPolygon25D < MultiPolygon
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbMultiPolygon25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+  end
+end

data/lib/ogr/geometries/point.rb

@@ -1,14 +1,12 @@
-require_relative 'point_extensions'
-
 module OGR
   class Point
     include OGR::Geometry
-    include PointExtensions
 
     # @param [FFI::Pointer] geometry_ptr
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbPoint)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
     end
 
     # @return [Float]
@@ -25,41 +23,40 @@ module OGR
       FFI::OGR::API.OGR_G_GetY(@c_pointer, 0)
     end
 
-    # @return [Float]
-    def z
-      return nil if empty?
-
-      FFI::OGR::API.OGR_G_GetZ(@c_pointer, 0)
-    end
-
-    # @return [Array<Float, Float, Float>] [x, y] if 2d or [x, y, z] if 3d.
+    # @return [<Array<Float, Float>] [x, y].
     def point
       return [] if empty?
 
       x_ptr = FFI::MemoryPointer.new(:double)
       y_ptr = FFI::MemoryPointer.new(:double)
       z_ptr = FFI::MemoryPointer.new(:double)
-
       FFI::OGR::API.OGR_G_GetPoint(@c_pointer, 0, x_ptr, y_ptr, z_ptr)
 
-      if coordinate_dimension == 2
-        [x_ptr.read_double, y_ptr.read_double]
-      else
-        [x_ptr.read_double, y_ptr.read_double, z_ptr.read_double]
-      end
+      [x_ptr.read_double, y_ptr.read_double]
+    end
+    alias point_value point
+
+    # Wrapper around {#point_value} to provide API parity with other geometries
+    # that can have multiple points.
+    #
+    # @return [Array<Array<Float, Float>>]
+    # TODO: move to an extension
+    def point_values
+      [point]
     end
 
-    def set_point(x, y, z = 0)
-      FFI::OGR::API.OGR_G_SetPoint(@c_pointer, 0, x, y, z)
+    # @param x [Number]
+    # @param y [Number]
+    def set_point(x, y)
+      FFI::OGR::API.OGR_G_SetPoint_2D(@c_pointer, 0, x, y)
     end
 
     # Adds a point to a LineString or Point geometry.
     #
     # @param x [Float]
     # @param y [Float]
-    # @param z [Float]
-    def add_point(x, y, z = 0)
-      FFI::OGR::API.OGR_G_AddPoint(@c_pointer, x, y, z)
+    def add_point(x, y)
+      FFI::OGR::API.OGR_G_AddPoint_2D(@c_pointer, x, y)
     end
   end
 end

data/lib/ogr/geometries/point_25d.rb

@@ -0,0 +1,48 @@
+require_relative 'point'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbPoint (read: 2D instead of 2.5D) until a Z
+  # value is set.
+  class Point25D < Point
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbPoint25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+
+    # @return [Float]
+    def z
+      return if empty?
+
+      FFI::OGR::API.OGR_G_GetZ(@c_pointer, 0)
+    end
+
+    # @return [Array<Float, Float, Float>] [x, y, z].
+    def point
+      return [] if empty?
+
+      x_ptr = FFI::MemoryPointer.new(:double)
+      y_ptr = FFI::MemoryPointer.new(:double)
+      z_ptr = FFI::MemoryPointer.new(:double)
+      FFI::OGR::API.OGR_G_GetPoint(@c_pointer, 0, x_ptr, y_ptr, z_ptr)
+
+      [x_ptr.read_double, y_ptr.read_double, z_ptr.read_double]
+    end
+
+    # @param x [Number]
+    # @param y [Number]
+    # @param z [Number]
+    def set_point(x, y, z)
+      FFI::OGR::API.OGR_G_SetPoint(@c_pointer, 0, x, y, z)
+    end
+
+    # Adds a point to a LineString or Point geometry.
+    #
+    # @param x [Float]
+    # @param y [Float]
+    # @param z [Float]
+    def add_point(x, y, z)
+      FFI::OGR::API.OGR_G_AddPoint(@c_pointer, x, y, z)
+    end
+  end
+end

data/lib/ogr/geometries/polygon.rb

@@ -1,14 +1,17 @@
+require_relative '../geometry_types/container'
 require_relative '../geometry_types/surface'
 
 module OGR
   class Polygon
     include OGR::Geometry
     include GeometryTypes::Surface
+    include GeometryTypes::Container
 
     # @param [FFI::Pointer] geometry_ptr
-    def initialize(geometry_ptr = nil)
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
       geometry_ptr ||= OGR::Geometry.create(:wkbPolygon)
       initialize_from_pointer(geometry_ptr)
+      self.spatial_reference = spatial_reference if spatial_reference
     end
   end
 end

data/lib/ogr/geometries/polygon_25d.rb

@@ -0,0 +1,14 @@
+require_relative 'polygon'
+
+module OGR
+  # NOTE: {{#type}} will return :wkbPolygon (read: 2D instead of 2.5D) until a Z
+  # value is set.
+  class Polygon25D < Polygon
+    # @param geometry_ptr [FFI::Pointer]
+    # @param spatial_reference [OGR::SpatialReference]
+    def initialize(geometry_ptr = nil, spatial_reference: nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbPolygon25D)
+      super(geometry_ptr, spatial_reference: spatial_reference)
+    end
+  end
+end

data/lib/ogr/geometry.rb

@@ -1,15 +1,13 @@
-require_relative 'envelope'
-require_relative 'geometry_extensions'
+require_relative '../ogr'
+require_relative 'geometry_mixins/extensions'
 require_relative '../gdal'
-require_relative '../gdal/options'
-require_relative '../gdal/logger'
 
 module OGR
   module Geometry
     module ClassMethods
       def create(type)
         geometry_pointer = FFI::OGR::API.OGR_G_CreateGeometry(type)
-        return nil if geometry_pointer.null?
+        return if geometry_pointer.null?
         geometry_pointer.autorelease = false
 
         factory(geometry_pointer)
@@ -29,23 +27,35 @@ module OGR
           end
 
         new_pointer = geometry.c_pointer
+        return if new_pointer.nil? || new_pointer.null?
 
         case geometry.type
-        when :wkbPoint, :wkbPoint25D then OGR::Point.new(new_pointer)
-        when :wkbLineString, :wkbLineString25D then OGR::LineString.new(new_pointer)
+        when :wkbPoint then OGR::Point.new(new_pointer)
+        when :wkbPoint25D then OGR::Point25D.new(new_pointer)
+        when :wkbLineString
+          if geometry.to_wkt =~ /^LINEARRING/
+            OGR::LinearRing.new(new_pointer)
+          else
+            OGR::LineString.new(new_pointer)
+          end
+        when :wkbLineString25D then OGR::LineString25D.new(new_pointer)
         when :wkbLinearRing then OGR::LinearRing.new(new_pointer)
-        when :wkbPolygon, :wkbPolygon25D then OGR::Polygon.new(new_pointer)
-        when :wkbMultiPoint, :wkbMultiPoint25D then OGR::MultiPoint.new(new_pointer)
-        when :wkbMultiLineString, :wkbMultiLineString25D then OGR::MultiLineString.new(new_pointer)
-        when :wkbMultiPolygon, :wkbMultiPolygon25D then OGR::MultiPolygon.new(new_pointer)
+        when :wkbPolygon then OGR::Polygon.new(new_pointer)
+        when :wkbPolygon25D then OGR::Polygon25D.new(new_pointer)
+        when :wkbMultiPoint then OGR::MultiPoint.new(new_pointer)
+        when :wkbMultiPoint25D then OGR::MultiPoint25D.new(new_pointer)
+        when :wkbMultiLineString then OGR::MultiLineString.new(new_pointer)
+        when :wkbMultiLineString25D then OGR::MultiLineString25D.new(new_pointer)
+        when :wkbMultiPolygon then OGR::MultiPolygon.new(new_pointer)
+        when :wkbMultiPolygon25D then OGR::MultiPolygon25D.new(new_pointer)
         when :wkbGeometryCollection then OGR::GeometryCollection.new(new_pointer)
+        when :wkbGeometryCollection25D then OGR::GeometryCollection25D.new(new_pointer)
         when :wkbNone then OGR::NoneGeometry.new(new_pointer)
         else
           geometry
         end
       end
 
-      # @return [OGR::Geometry]
       # @param wkt_data [String]
       # @param spatial_ref [FFI::Pointer] Optional spatial reference
       #   to assign to the new geometry.
@@ -55,12 +65,7 @@ module OGR
         wkt_pointer_pointer = FFI::MemoryPointer.new(:pointer)
         wkt_pointer_pointer.write_pointer(wkt_data_pointer)
 
-        spatial_ref_pointer =
-          if spatial_ref
-            GDAL._pointer(OGR::SpatialReference, spatial_ref)
-          else
-            nil
-          end
+        spatial_ref_pointer = GDAL._pointer(OGR::SpatialReference, spatial_ref) if spatial_ref
 
         geometry_ptr = FFI::MemoryPointer.new(:pointer)
         geometry_ptr_ptr = FFI::MemoryPointer.new(:pointer)
@@ -69,14 +74,28 @@ module OGR
         FFI::OGR::API.OGR_G_CreateFromWkt(wkt_pointer_pointer,
           spatial_ref_pointer, geometry_ptr_ptr)
 
-        return nil if geometry_ptr_ptr.null? ||
-                      geometry_ptr_ptr.read_pointer.null?
-        geometry_ptr_ptr.read_pointer.nil?
+        return if geometry_ptr_ptr.null? || geometry_ptr_ptr.read_pointer.null?
+
+        factory(geometry_ptr_ptr.read_pointer)
+      end
+
+      # @param wkb_data [String] Binary string of WKB.
+      # @param spatial_ref [OGR::SpatialReference]
+      # @return [OGR::Geometry]
+      def create_from_wkb(wkb_data, spatial_ref = nil)
+        wkb_data_pointer = FFI::MemoryPointer.new(:char, wkb_data.length)
+        wkb_data_pointer.put_bytes(0, wkb_data)
+
+        spatial_ref_pointer = GDAL._pointer(OGR::SpatialReference, spatial_ref) if spatial_ref
 
-        geometry = factory(geometry_ptr_ptr.read_pointer)
-        ObjectSpace.define_finalizer(geometry) { destroy! }
+        geometry_ptr_ptr = GDAL._pointer_pointer(:pointer)
 
-        geometry
+        byte_count = wkb_data.length
+        FFI::OGR::API.OGR_G_CreateFromWkb(wkb_data_pointer, spatial_ref_pointer, geometry_ptr_ptr, byte_count)
+
+        return if geometry_ptr_ptr.null? || geometry_ptr_ptr.read_pointer.null?
+
+        factory(geometry_ptr_ptr.read_pointer)
       end
 
       # @param gml_data [String]
@@ -120,7 +139,7 @@ module OGR
 
     def self.included(base)
       base.send(:include, GDAL::Logger)
-      base.send(:include, GeometryExtensions)
+      base.send(:include, OGR::GeometryMixins::Extensions)
       base.send(:extend, ClassMethods)
     end
 
@@ -131,13 +150,6 @@ module OGR
     # @return [FFI::Pointer]
     attr_reader :c_pointer
 
-    # @param value [Boolean]
-    attr_writer :read_only
-
-    def read_only?
-      @read_only || false
-    end
-
     def destroy!
       return unless @c_pointer
 
@@ -145,6 +157,13 @@ module OGR
       @c_pointer = nil
     end
 
+    # @return [OGR::Geometry]
+    def clone
+      new_geometry_ptr = FFI::OGR::API.OGR_G_Clone(@c_pointer)
+
+      OGR::Geometry.factory(new_geometry_ptr)
+    end
+
     # Clears all information from the geometry.
     #
     # @return nil
@@ -167,7 +186,7 @@ module OGR
     # @param new_coordinate_dimension [Fixnum]
     def coordinate_dimension=(new_coordinate_dimension)
       unless [2, 3].include?(new_coordinate_dimension)
-        fail "Can't set coordinate to #{new_coordinate_dimension}.  Must be 2 or 3."
+        raise "Can't set coordinate to #{new_coordinate_dimension}.  Must be 2 or 3."
       end
 
       FFI::OGR::API.OGR_G_SetCoordinateDimension(@c_pointer, new_coordinate_dimension)
@@ -184,10 +203,10 @@ module OGR
         FFI::OGR::API.OGR_G_GetEnvelope3D(@c_pointer, envelope)
       when 0 then return nil
       else
-        fail 'Unknown envelope dimension.'
+        raise 'Unknown envelope dimension.'
       end
 
-      return nil if envelope.null?
+      return if envelope.null?
 
       OGR::Envelope.new(envelope)
     end
@@ -211,6 +230,7 @@ module OGR
     def geometry_count
       FFI::OGR::API.OGR_G_GetGeometryCount(@c_pointer)
     end
+    alias count geometry_count
 
     # @return [Fixnum]
     def point_count
@@ -222,22 +242,22 @@ module OGR
     # @return [Fixnum]
     # @todo This regularly crashes, so disabling it.
     def centroid
-      fail NotImplementedError, '#centroid not yet implemented.'
+      point = is_3d? ? OGR::Point25D.new : OGR::Point.new
 
-      point = OGR::Geometry.create(:wkbPoint)
-      FFI::OGR::API.OGR_G_Centroid(@c_pointer, point.c_pointer)
-      return nil if point.c_pointer.null?
+      ogr_err = FFI::OGR::API.OGR_G_Centroid(@c_pointer, point.c_pointer)
+      return if point.c_pointer.null? || ogr_err > 0
 
       point
     end
 
-    # # Dump as WKT to the give +file+.
+    # Dump as WKT to the given +file_path+; dumps to STDOUT if none is given.
     #
-    # @param file [String] The text file to write to.
+    # @param file_path [String] The text file to write to.
     # @param prefix [String] The prefix to put on each line of output.
-    # @return [String]
-    def dump_readable(file, prefix = nil)
-      FFI::OGR::API.OGR_G_DumpReadable(@c_pointer, file, prefix)
+    def dump_readable(file_path = nil, prefix: nil)
+      file_ptr = file_path ? FFI::CPL::Conv.CPLOpenShared(file_path, 'w', false) : nil
+      FFI::OGR::API.OGR_G_DumpReadable(@c_pointer, file_ptr, prefix)
+      FFI::CPL::Conv.CPLCloseShared(file_ptr) if file_ptr
     end
 
     # Converts this geometry to a 2D geometry.
@@ -259,7 +279,7 @@ module OGR
 
       FFI::OGR::API.OGR_G_Equals(@c_pointer, geometry.c_pointer)
     end
-    alias_method :==, :equals?
+    alias == equals?
 
     # @param geometry [OGR::Geometry, FFI::Pointer]
     # @return [Boolean]
@@ -330,31 +350,25 @@ module OGR
     def ring?
       FFI::OGR::API.OGR_G_IsRing(@c_pointer)
     rescue GDAL::Error => ex
-      if ex.message.include? 'IllegalArgumentException'
-        false
-      else
-        raise
-      end
+      return false if ex.message.include? 'IllegalArgumentException'
+
+      raise
     end
 
     # @param other_geometry [OGR::Geometry]
     # @return [OGR::Geometry]
     # @todo This regularly crashes, so disabling it.
     def intersection(other_geometry)
-      fail NotImplementedError, '#intersection not yet implemented.'
-
-      return nil unless intersects?(other_geometry)
-
-      build_geometry do |ptr|
-        FFI::OGR::API.OGR_G_Intersection(ptr, other_geometry.c_pointer)
+      build_geometry do
+        FFI::OGR::API.OGR_G_Intersection(@c_pointer, other_geometry.c_pointer)
       end
     end
 
     # @param other_geometry [OGR::Geometry]
     # @return [OGR::Geometry]
     def union(other_geometry)
-      build_geometry do |ptr|
-        FFI::OGR::API.OGR_G_Union(ptr, other_geometry.c_pointer)
+      build_geometry do
+        FFI::OGR::API.OGR_G_Union(@c_pointer, other_geometry.c_pointer)
       end
     end
 
@@ -371,24 +385,24 @@ module OGR
     #   MultiLineString or if it's impossible to reassemble due to topological
     #   inconsistencies.
     def polygonize
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_Polygonize(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_Polygonize(@c_pointer) }
     end
 
     # @param geometry [OGR::Geometry]
     # @return [OGR::Geometry]
     def difference(geometry)
       new_geometry_ptr = FFI::OGR::API.OGR_G_Difference(@c_pointer, geometry.c_pointer)
-      return nil if new_geometry_ptr.null?
+      return if new_geometry_ptr.null?
 
       self.class.factory(new_geometry_ptr)
     end
-    alias_method :-, :difference
+    alias - difference
 
     # @param geometry [OGR::Geometry]
     # @return [OGR::Geometry]
     def symmetric_difference(geometry)
       new_geometry_ptr = FFI::OGR::API.OGR_G_SymDifference(@c_pointer, geometry.c_pointer)
-      return nil if new_geometry_ptr.null?
+      return if new_geometry_ptr.null?
 
       self.class.factory(new_geometry_ptr)
     end
@@ -404,7 +418,7 @@ module OGR
     # @return [OGR::SpatialReference]
     def spatial_reference
       spatial_ref_ptr = FFI::OGR::API.OGR_G_GetSpatialReference(@c_pointer)
-      return nil if spatial_ref_ptr.null?
+      return if spatial_ref_ptr.null?
 
       OGR::SpatialReference.new(spatial_ref_ptr)
     end
@@ -449,7 +463,7 @@ module OGR
     # @return [Boolean]
     def transform_to!(new_spatial_ref)
       new_spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, new_spatial_ref)
-      return nil if new_spatial_ref_ptr.null?
+      return if new_spatial_ref_ptr.null?
 
       ogr_err = FFI::OGR::API.OGR_G_TransformTo(@c_pointer, new_spatial_ref_ptr)
 
@@ -462,11 +476,11 @@ module OGR
     # @param preserve_topology [Boolean]
     # @return [OGR::Geometry]
     def simplify(distance_tolerance, preserve_topology: false)
-      build_geometry do |ptr|
+      build_geometry do
         if preserve_topology
-          FFI::OGR::API.OGR_G_SimplifyPreserveTopology(ptr, distance_tolerance)
+          FFI::OGR::API.OGR_G_SimplifyPreserveTopology(@c_pointer, distance_tolerance)
         else
-          FFI::OGR::API.OGR_G_Simplify(ptr, distance_tolerance)
+          FFI::OGR::API.OGR_G_Simplify(@c_pointer, distance_tolerance)
         end
       end
     end
@@ -474,13 +488,16 @@ module OGR
     # Modify the geometry so that it has no segments longer than +max_length+.
     #
     # @param max_length [Float]
+    # @return [OGR::Geometry] Returns self that's been segmentized.
     def segmentize!(max_length)
       FFI::OGR::API.OGR_G_Segmentize(@c_pointer, max_length)
+
+      self
     end
 
     # @return [OGR::Geometry]
     def boundary
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_Boundary(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_Boundary(@c_pointer) }
     end
 
     # Computes the buffer of the geometry by building a new geometry that
@@ -490,15 +507,22 @@ module OGR
     # @param quad_segments [Fixnum] The number of segments to use to approximate
     #   a 90 degree (quadrant) of curvature.
     # @return [OGR::Polygon]
-    def buffer(distance, quad_segments)
-      build_geometry do |ptr|
-        FFI::OGR::API.OGR_G_Buffer(ptr, distance, quad_segments)
+    def buffer(distance, quad_segments = 30)
+      build_geometry do
+        FFI::OGR::API.OGR_G_Buffer(@c_pointer, distance, quad_segments)
       end
     end
 
     # @return [OGR::Geometry]
     def convex_hull
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_ConvexHull(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_ConvexHull(@c_pointer) }
+    end
+
+    # Returns a point that's guaranteed to lie on the surface.
+    #
+    # @return [OGR::Point]
+    def point_on_surface
+      build_geometry { FFI::OGR::API.OGR_G_PointOnSurface(@c_pointer) }
     end
 
     # @param wkb_data [String] Binary WKB data.
@@ -580,7 +604,28 @@ module OGR
     #
     # @return [OGR::Geometry]
     def to_line_string
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_ForceToLineString(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_ForceToLineString(clone.c_pointer) }
+    end
+
+    # Since GDAL doesn't provide converting to a LinearRing, this is a hackish
+    # method for doing so.
+    #
+    # @return [OGR::LinearRing]
+    def to_linear_ring(close_rings = false)
+      line_string = to_line_string
+
+      return line_string unless line_string.is_a?(OGR::LineString)
+
+      linear_ring = OGR::LinearRing.new
+
+      if line_string.spatial_reference
+        linear_ring.spatial_reference = line_string.spatial_reference.clone
+      end
+
+      linear_ring.import_from_wkt(line_string.to_wkt.tr('LINESTRING', 'LINEARRING'))
+      linear_ring.close_rings! if close_rings
+
+      linear_ring
     end
 
     # Converts the current geometry to a Polygon geometry.  The returned object
@@ -588,7 +633,7 @@ module OGR
     #
     # @return [OGR::Geometry]
     def to_polygon
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_ForceToPolygon(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_ForceToPolygon(clone.c_pointer) }
     end
 
     # Converts the current geometry to a MultiPoint geometry.  The returned
@@ -596,7 +641,7 @@ module OGR
     #
     # @return [OGR::Geometry]
     def to_multi_point
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_ForceToMultiPoint(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_ForceToMultiPoint(clone.c_pointer) }
     end
 
     # Converts the current geometry to a MultiLineString geometry.  The returned
@@ -604,7 +649,7 @@ module OGR
     #
     # @return [OGR::Geometry]
     def to_multi_line_string
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_ForceToMultiLineString(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_ForceToMultiLineString(clone.c_pointer) }
     end
 
     # Converts the current geometry to a MultiPolygon geometry.  The returned
@@ -612,35 +657,22 @@ module OGR
     #
     # @return [OGR::MultiPolygon]
     def to_multi_polygon
-      build_geometry { |ptr| FFI::OGR::API.OGR_G_ForceToMultiPolygon(ptr) }
+      build_geometry { FFI::OGR::API.OGR_G_ForceToMultiPolygon(@c_pointer) }
     end
 
     private
 
     # @param geometry_ptr [OGR::Geometry, FFI::Pointer]
     def initialize_from_pointer(geometry_ptr)
-      fail OGR::InvalidHandle, "Must initialize with a valid pointer: #{geometry_ptr}" if geometry_ptr.nil?
+      raise OGR::InvalidHandle, "Must initialize with a valid pointer: #{geometry_ptr}" if geometry_ptr.nil?
       @c_pointer = GDAL._pointer(OGR::Geometry, geometry_ptr)
-      @read_only = false
-      @spatial_reference = nil
     end
 
     def build_geometry
-      new_geometry_ptr = yield(@c_pointer)
-      return nil if new_geometry_ptr.nil? || new_geometry_ptr.null?
+      new_geometry_ptr = yield
+      return if new_geometry_ptr.nil? || new_geometry_ptr.null? || new_geometry_ptr == @c_pointer
 
       OGR::Geometry.factory(new_geometry_ptr)
     end
   end
 end
-
-require_relative 'geometries/geometry_collection'
-require_relative 'geometries/line_string'
-require_relative 'geometries/linear_ring'
-require_relative 'geometries/multi_line_string'
-require_relative 'geometries/multi_point'
-require_relative 'geometries/multi_polygon'
-require_relative 'geometries/none_geometry'
-require_relative 'geometries/point'
-require_relative 'geometries/polygon'
-require_relative 'geometries/unknown_geometry'