ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/ogr/layer_extensions.rb

@@ -0,0 +1,55 @@
+require 'json'
+
+module OGR
+  module LayerExtensions
+
+    # @return [Array<OGR::Feature>]
+    def features
+      feature_list = 0.upto(feature_count - 1).map do |i|
+        feature(i)
+      end
+
+      @features = feature_list
+    end
+
+    # @return [OGR::Geometry] A convex hull geometry derived from a LineString
+    #   that connects the 4 bounding box points (from the extent).
+    def geometry_from_extent
+      sr = spatial_reference
+      geometry = OGR::Geometry.create(:wkbLineString)
+      geometry.spatial_reference = sr
+
+      geometry.add_point(extent.x_min, extent.y_min)
+      geometry.add_point(extent.x_min, extent.y_max)
+      geometry.add_point(extent.x_max, extent.y_max)
+      geometry.add_point(extent.x_max, extent.y_min)
+      geometry.add_point(extent.x_min, extent.y_min)
+
+      geometry.convex_hull
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        layer: {
+          extent: extent.as_json,
+          feature_count: feature_count,
+          feature_definition: feature_definition.as_json,
+          features: features.map(&:as_json),
+          fid_column: fid_column,
+          geometry_column: geometry_column,
+          geometry_type: geometry_type,
+          name: name,
+          spatial_reference: spatial_reference.as_json,
+          style_table: style_table ? style_table.as_json : nil
+        },
+        metadata: nil #all_metadata
+      }
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/ogr/line_string.rb

@@ -0,0 +1,7 @@
+require_relative 'geometry_types/curve'
+
+module OGR
+  class LineString < Geometry
+    include GeometryTypes::Curve
+  end
+end

data/lib/ogr/linear_ring.rb

@@ -0,0 +1,6 @@
+require_relative 'line_string'
+
+module OGR
+  class LinearRing < LineString
+  end
+end

data/lib/ogr/multi_line_string.rb

@@ -0,0 +1,9 @@
+require_relative 'geometry_types/curve'
+require_relative 'geometry_types/collection'
+
+module OGR
+  class MultiLineString < Geometry
+    include GeometryTypes::Curve
+    include GeometryTypes::Collection
+  end
+end

data/lib/ogr/multi_point.rb

@@ -0,0 +1,7 @@
+require_relative 'geometry_types/collection'
+
+module OGR
+  class MultiPoint < Geometry
+    include GeometryTypes::Collection
+  end
+end

data/lib/ogr/multi_polygon.rb

@@ -0,0 +1,14 @@
+require_relative 'geometry_types/collection'
+require_relative 'geometry_types/surface'
+
+module OGR
+  class MultiPolygon < Geometry
+    include GeometryTypes::Collection
+    include GeometryTypes::Surface
+
+    # @return [OGR::Geometry]
+    def union_cascaded
+      build_geometry { |ptr| FFI::GDAL.OGR_G_UnionCascaded(ptr) }
+    end
+  end
+end

data/lib/ogr/point.rb

@@ -0,0 +1,89 @@
+module OGR
+  class Point < Geometry
+    # def area
+    #   0.0
+    # end
+
+    # @return [Float]
+    def x
+      return nil if empty?
+
+      FFI::GDAL.OGR_G_GetX(@geometry_pointer, 0)
+    end
+
+    # @return [Float]
+    def y
+      return nil if empty?
+
+      FFI::GDAL.OGR_G_GetY(@geometry_pointer, 0)
+    end
+
+    # @return [Float]
+    def z
+      return nil if empty?
+
+      FFI::GDAL.OGR_G_GetZ(@geometry_pointer, 0)
+    end
+
+    # @return [Array<Float, Float, Float>] [x, y] if 2d or [x, y, z] if 3d.
+    def point
+      return [] if empty?
+
+      x_ptr = FFI::MemoryPointer.new(:double)
+      y_ptr = FFI::MemoryPointer.new(:double)
+      z_ptr = FFI::MemoryPointer.new(:double)
+
+      FFI::GDAL.OGR_G_GetPoint(@geometry_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
+    end
+
+    def set_point(x, y, z=0)
+      FFI::GDAL.OGR_G_SetPoint(@geometry_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=0)
+      FFI::GDAL.OGR_G_AddPoint(@geometry_pointer, x, y, z)
+    end
+
+    # @return [Array<Array>] An array of (x, y) or (x, y, z) points.
+    def points
+      return [[]] if empty?
+
+      x_stride = 2
+      y_stride = 2
+      z_stride = coordinate_dimension == 3 ? 1 : 0
+
+      buffer_size = FFI::Type::DOUBLE.size * 2 * point_count
+
+      x_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
+      y_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
+
+      z_buffer = if coordinate_dimension == 3
+        z_size = FFI::Type::DOUBLE.size * point_count
+        FFI::MemoryPointer.new(:buffer_out, z_size)
+      else
+        nil
+      end
+
+      num_points = FFI::GDAL.OGR_G_GetPoints(@geometry_pointer,
+        x_buffer,
+        x_stride,
+        y_buffer,
+        y_stride,
+        z_buffer,
+        z_stride)
+
+      [point]
+    end
+  end
+end

data/lib/ogr/polygon.rb

@@ -0,0 +1,9 @@
+require_relative 'geometry_types/surface'
+require_relative 'geometry_types/collection'
+
+module OGR
+  class Polygon < Geometry
+    include GeometryTypes::Surface
+    include GeometryTypes::Collection
+  end
+end

data/lib/ogr/spatial_reference.rb

@@ -0,0 +1,723 @@
+require_relative '../ffi/ogr'
+require_relative 'spatial_reference_extensions'
+
+module OGR
+  # Represents a geographic coordinate system.  There are two primary types:
+  #   1. "geographic", where positions are measured in long/lat.
+  #   2. "projected", where positions are measure in meters or feet.
+  class SpatialReference
+    include SpatialReferenceExtensions
+
+    # @return [Array<String>]
+    def self.projection_methods
+      return @projection_methods if @projection_methods
+
+      methods_ptr_ptr = FFI::GDAL.OPTGetProjectionMethods
+      count = FFI::GDAL.CSLCount(methods_ptr_ptr)
+
+      # For some reason #get_array_of_string leaves off the first 6.
+      pointer_array = methods_ptr_ptr.get_array_of_pointer(0, count)
+
+      pointer_array.map(&:read_string).sort
+    end
+
+    # @param projection_method [String] One of
+    #   OGR::SpatialReference.projection_methods.
+    # @return [Hash{parameter => Array<String>, user_visible_name => String}]
+    def self.parameter_list(projection_method)
+      name_ptr = FFI::MemoryPointer.new(:string)
+      name_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      name_ptr_ptr.write_pointer(name_ptr)
+
+      params_ptr_ptr = FFI::GDAL.OPTGetParameterList(projection_method,
+        name_ptr_ptr)
+      count = FFI::GDAL.CSLCount(params_ptr_ptr)
+
+      # For some reason #get_array_of_string leaves off the first 6.
+      pointer_array = params_ptr_ptr.get_array_of_pointer(0, count)
+
+      name = if !name_ptr_ptr.read_pointer.null?
+        name_ptr_ptr.read_pointer.read_string
+      else
+        nil
+      end
+
+      {
+        parameters: pointer_array.map(&:read_string).sort,
+        user_visible_name: name
+      }
+    end
+
+    def self.parameter_info(projection_method, parameter_name)
+      name_ptr = FFI::MemoryPointer.new(:string)
+      name_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      name_ptr_ptr.write_pointer(name_ptr)
+
+      type_ptr = FFI::MemoryPointer.new(:string)
+      type_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      type_ptr_ptr.write_pointer(type_ptr)
+
+      default_value_ptr = FFI::MemoryPointer.new(:double)
+
+      result = FFI::GDAL.OPTGetParameterInfo(projection_method, parameter_name,
+        name_ptr_ptr, type_ptr_ptr, default_value_ptr)
+
+      return {} unless result
+
+      name = if !name_ptr_ptr.read_pointer.null?
+        name_ptr_ptr.read_pointer.read_string
+      else
+        nil
+      end
+
+      type = if !type_ptr_ptr.read_pointer.null?
+        type_ptr_ptr.read_pointer.read_string
+      else
+        nil
+      end
+
+      {
+        type: type,
+        default_value: default_value_ptr.read_double,
+        user_visible_name: name
+      }
+    end
+
+    # @param code [Fixnum]
+    # @return [OGR::SpatialReference]
+    def self.new_from_epsg(code)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromEPSG(spatial_ref.c_pointer, code)
+      end
+    end
+
+    # @param code [Fixnum]
+    # @return [OGR::SpatialReference]
+    def self.new_from_epsga(code)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromEPSGA(spatial_ref.c_pointer, code)
+      end
+    end
+
+    # @param projection_name [String] I.e. "NUTM11" or "GEOGRAPHIC".
+    # @param datum_name [String] I.e. "NAD83".
+    # @param linear_unit_name [String] Plural form of linear units, i.e. "FEET".
+    # @return [OGR::SpatialReference]
+    def self.new_from_erm(projection_name, datum_name, linear_unit_name)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromERM(spatial_ref.c_pointer, projection_name,
+          datum_name, linear_unit_name)
+      end
+    end
+
+    # @param prj_text [Array<String>]
+    # @return [OGR::SpatialReference]
+    def self.new_from_esri(prj_text)
+      build_spatial_ref do |spatial_ref|
+        prj_ptr = FFI::MemoryPointer.new(:string, prj_text.size)
+        prj_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+        prj_ptr_ptr.write_pointer(prj_ptr)
+
+        FFI::GDAL.OSRImportFromESRI(spatial_ref.c_pointer, prj_ptr_ptr)
+      end
+    end
+
+    # @param coord_sys [String] The Mapinfo style CoordSys definition string.
+    # @return [OGR::SpatialReference]
+    def self.new_from_mapinfo(coord_sys)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromMICoordSys(spatial_ref.c_pointer, coord_sys)
+      end
+    end
+
+    # @param proj [String]
+    # @param units [String]
+    # @param proj_params [Array<String>]
+    # @return [OGR::SpatialReference]
+    def self.new_from_pci(proj, units, *proj_params)
+      build_spatial_ref do |spatial_ref|
+        if proj_params.empty?
+          proj_ptr = nil
+        else
+          proj_ptr = FFI::MemoryPointer.new(:double, proj_params.size)
+          proj_ptr.write_array_of_double(proj_params)
+        end
+
+        FFI::GDAL.OSRImportFromPCI(spatial_ref.c_pointer, proj, units, proj_ptr)
+      end
+    end
+
+    # @param proj4 [String]
+    # @return [OGR::SpatialReference]
+    def self.new_from_proj4(proj4)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromProj4(spatial_ref.c_pointer, proj4)
+      end
+    end
+
+    # @param url [String] URL to fetch the spatial reference from.
+    # @return [OGR::SpatialReference]
+    def self.new_from_url(url)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromUrl(spatial_ref.c_pointer, url)
+      end
+    end
+
+    def self.new_from_user_input(definition)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRSetFromUserInput(spatial_ref.c_pointer, definition)
+      end
+    end
+
+    # @param projection_system_code
+    # @return [OGR::SpatialReference]
+    def self.new_from_usgs(projection_system_code, zone, datum, *proj_params)
+      build_spatial_ref do |spatial_ref|
+        if proj_params.empty?
+          proj_ptr = nil
+        else
+          proj_ptr = FFI::MemoryPointer.new(:double, proj_params.size)
+          proj_ptr.write_array_of_double(proj_params)
+        end
+
+        FFI::GDAL.OSRImportFromUSGS(spatial_ref.c_pointer,
+          projection_system_code, zone, proj_ptr, datum)
+      end
+    end
+
+    # This wipes the existing SRS definition and reassigns it based on the
+    # contents of +wkt+.
+    #
+    # @param wkt [String]
+    # @return [OGR::SpatialReference]
+    def self.new_from_wkt(wkt)
+      build_spatial_ref do |spatial_ref|
+        wkt_ptr = FFI::MemoryPointer.from_string(wkt)
+        wkt_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+        wkt_ptr_ptr.write_pointer(wkt_ptr)
+
+        FFI::GDAL.OSRImportFromWkt(spatial_ref.c_pointer, wkt_ptr_ptr)
+      end
+    end
+
+    # Use for importing a GML coordinate system.
+    #
+    # @param xml [String]
+    # @return [OGR::SpatialReference]
+    def self.new_from_xml(xml)
+      build_spatial_ref do |spatial_ref|
+        FFI::GDAL.OSRImportFromXML(spatial_ref.c_pointer, xml)
+      end
+    end
+
+    # @return [OGR::SpatialReference]
+    def self.build_spatial_ref(spatial_reference_or_wkt=nil)
+      object = new(spatial_reference_or_wkt)
+      ogr_err = yield object
+      ogr_err.to_ruby
+
+      object
+    end
+    private_class_method :build_spatial_ref
+
+    # Builds a spatial reference object using either the passed-in WKT string,
+    # OGR::SpatialReference object, or a pointer to an in-memory
+    # SpatialReference object.  If nothing is passed in, an empty
+    # SpatialReference object is created, in which case you'll need to populate
+    # relevant attributes.
+    #
+    # @param spatial_reference_or_wkt [OGR::SpatialReference, FFI::Pointer,
+    #   String]
+    def initialize(spatial_reference_or_wkt=nil)
+      @ogr_spatial_ref_pointer = if spatial_reference_or_wkt.is_a? OGR::SpatialReference
+        spatial_reference_or_wkt.c_pointer
+      elsif spatial_reference_or_wkt.is_a? String
+        FFI::GDAL.OSRNewSpatialReference(spatial_reference_or_wkt)
+      elsif spatial_reference_or_wkt.is_a? FFI::Pointer
+        spatial_reference_or_wkt
+      else
+        FFI::GDAL.OSRNewSpatialReference(nil)
+      end
+
+      close_me = -> { destroy! }
+      ObjectSpace.define_finalizer self, close_me
+    end
+
+    def c_pointer
+      @ogr_spatial_ref_pointer
+    end
+
+    def destroy!
+      FFI::GDAL.OSRDestroySpatialReference(@ogr_spatial_ref_pointer)
+    end
+
+    # Uses the C-API to clone this spatial reference object.
+    def clone
+      new_spatial_ref_ptr = FFI::GDAL.OSRClone(@ogr_spatial_ref_pointer)
+
+      self.class.new(new_spatial_ref_ptr)
+    end
+
+    # Makes a duplicate of the GEOGCS node of this spatial reference.
+    #
+    # @return [OGR::SpatialReference]
+    def clone_geogcs
+      new_spatial_ref_ptr = FFI::GDAL.OSRCloneGeogCS(@ogr_spatial_ref_pointer)
+
+      self.class.new(new_spatial_ref_ptr)
+    end
+
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def validate
+      ogr_err = FFI::GDAL.OSRValidate(@ogr_spatial_ref_pointer)
+
+      ogr_err.to_ruby
+    end
+
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def fixup_ordering!
+      ogr_err = FFI::GDAL.OSRFixupOrdering(@ogr_spatial_ref_pointer)
+
+      ogr_err.to_ruby
+    end
+
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def fixup!
+      ogr_err = FFI::GDAL.OSRFixup(@ogr_spatial_ref_pointer)
+
+      ogr_err.to_ruby
+    end
+
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def strip_ct_parameters!
+      ogr_err = FFI::GDAL.OSRStripCTParms(@ogr_spatial_ref_pointer)
+
+      ogr_err.to_ruby
+    end
+
+    # @param name [String] The case-insensitive tree node to look for.
+    # @param child [Fixnum] The child of the node to fetch.
+    # @return [String, nil]
+    def attribute_value(name, child=0)
+      FFI::GDAL.OSRGetAttrValue(@ogr_spatial_ref_pointer, name, child)
+    end
+
+    # @return [Hash{unit_name: String, value: Float}]
+    def angular_units
+      name = FFI::MemoryPointer.new(:string)
+      name_ptr = FFI::MemoryPointer.new(:pointer)
+      name_ptr.write_pointer(name)
+
+      value = FFI::GDAL.OSRGetAngularUnits(@ogr_spatial_ref_pointer, name_ptr)
+
+      { unit_name: name_ptr.read_pointer.read_string, value: value }
+    end
+
+    # @return [Hash{unit_name: String, value: Float}]
+    def linear_units
+      name = FFI::MemoryPointer.new(:string)
+      name_ptr = FFI::MemoryPointer.new(:pointer)
+      name_ptr.write_pointer(name)
+
+      value = FFI::GDAL.OSRGetLinearUnits(@ogr_spatial_ref_pointer, name_ptr)
+
+      { unit_name: name_ptr.read_pointer.read_string, value: value }
+    end
+
+    # @param target_key [String] I.e. "PROJCS" or "VERT_CS".
+    # @return [Hash]
+    def target_linear_units(target_key)
+      name = FFI::MemoryPointer.new(:string)
+      name_ptr = FFI::MemoryPointer.new(:pointer)
+      name_ptr.write_pointer(name)
+
+      value = FFI::GDAL.OSRGetTargetLinearUnits(@ogr_spatial_ref_pointer, target_key, name_ptr)
+
+      { unit_name: name_ptr.read_pointer.read_string, value: value }
+    end
+
+    # @return [Hash]
+    def prime_meridian
+      pm = FFI::MemoryPointer.new(:string)
+      pm_ptr = FFI::MemoryPointer.new(:pointer)
+      pm_ptr.write_pointer(pm)
+
+      value = FFI::GDAL.OSRGetPrimeMeridian(@ogr_spatial_ref_pointer, pm_ptr)
+
+      { name: pm_ptr.read_pointer.read_string, value: value }
+    end
+
+    # @param projection_name [String]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def projection=(projection_name)
+      ogr_err = FFI::GDAL.OSRSetProjection(@ogr_spatial_ref_pointer, projection_name)
+
+      ogr_err.to_ruby
+    end
+
+    # Sets the EPSG authority info if possible.
+    #
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def auto_identify_epsg!
+      ogr_err = FFI::GDAL.OSRAutoIdentifyEPSG(@ogr_spatial_ref_pointer)
+
+      ogr_err.to_ruby
+    end
+
+    # @return [Boolean] +true+ if this coordinate system should be treated as
+    #   having lat/long coordinate ordering.
+    def epsg_treats_as_lat_long?
+      FFI::GDAL.OSREPSGTreatsAsLatLong(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean] +true+ if this coordinate system should be treated as
+    #   having northing/easting coordinate ordering.
+    def epsg_treats_as_northing_easting?
+      FFI::GDAL.OSREPSGTreatsAsNorthingEasting(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Array<Float>]
+    def towgs84
+      coefficients = FFI::MemoryPointer.new(:double, 7)
+      ogr_err = FFI::GDAL.OSRGetTOWGS84(@ogr_spatial_ref_pointer, coefficients, 7)
+      ogr_err.to_ruby
+
+      coefficients.read_array_of_double(0)
+    end
+
+    # @param target_key [String] The partial or complete path to the node to get
+    #   an authority from ("PROJCS", "GEOCS", "GEOCS|UNIT").  Leave empty to
+    #   search at the root element.
+    # @return [String, nil]
+    def authority_code(target_key=nil)
+      FFI::GDAL.OSRGetAuthorityCode(@ogr_spatial_ref_pointer, target_key)
+    end
+
+    # @param target_key [String] The partial or complete path to the node to get
+    #   an authority from ("PROJCS", "GEOCS", "GEOCS|UNIT").  Leave empty to
+    #   search at the root element.
+    # @return [String, nil]
+    def authority_name(target_key=nil)
+      FFI::GDAL.OSRGetAuthorityName(@ogr_spatial_ref_pointer, target_key)
+    end
+
+    # @param axis_number [Fixnum] The Axis to query (0 or 1.)
+    # @param target_key [String]
+    # @return [String, nil]
+    def axis(axis_number, target_key=nil)
+      axis_orientation_ptr = FFI::MemoryPointer.new(:int)
+
+      name = FFI::GDAL.OSRGetAxis(@ogr_spatial_ref_pointer, target_key, axis_number, axis_orientation_ptr)
+      ao_value = axis_orientation_ptr.read_int
+
+      { name: name, orientation: OGRAxisOrientation[ao_value] }
+    end
+
+    # @return [Float]
+    def spheroid_inverse_flattening
+      err_ptr = FFI::MemoryPointer.new(:int)
+      value = FFI::GDAL.OSRGetInvFlattening(@ogr_spatial_ref_pointer, err_ptr)
+      ogr_err = FFI::GDAL::OGRErr[err_ptr.read_int]
+
+      if ogr_err == :OGRERR_FAILURE && value.is_a?(Float)
+        # noinspection RubyQuotedStringsInspection
+        warn 'WARN: #spheroid_inverse_flattening received error _and_ a value. Something is fishy...'
+      end
+
+      ogr_err.to_ruby
+
+      value
+    end
+
+    # @return [Float]
+    def semi_major
+      err_ptr = FFI::MemoryPointer.new(:int)
+      value = FFI::GDAL.OSRGetSemiMajor(@ogr_spatial_ref_pointer, err_ptr)
+      ogr_err = FFI::GDAL::OGRErr[err_ptr.read_int]
+
+      if ogr_err == :OGRERR_FAILURE && value.is_a?(Float)
+        # noinspection RubyQuotedStringsInspection
+        warn 'WARN: #semi_major received error _and_ a value. Something is fishy...'
+      end
+
+      ogr_err.to_ruby
+
+      value
+    end
+
+    # @param hemisphere [Symbol] :north or :south.
+    # @return [Fixnum] The zone, or 0 if this isn't a UTM definition.
+    def utm_zone(hemisphere=:north)
+      north = case hemisphere
+      when :north then 1
+      when :south then 0
+      else raise "Unknown hemisphere type #{hemisphere}. Please choose :north or :south."
+      end
+      north_ptr = FFI::MemoryPointer.new(:bool)
+      north_ptr.write_bytes(north.to_s)
+
+      FFI::GDAL.OSRGetUTMZone(@ogr_spatial_ref_pointer, north_ptr)
+    end
+
+    # @return [Float]
+    def semi_minor
+      err_ptr = FFI::MemoryPointer.new(:int)
+      value = FFI::GDAL.OSRGetSemiMinor(@ogr_spatial_ref_pointer, err_ptr)
+      ogr_err = FFI::GDAL::OGRErr[err_ptr.read_int]
+
+      if ogr_err == :OGRERR_FAILURE && value.is_a?(Float)
+        # noinspection RubyQuotedStringsInspection
+        warn "WARN: #semi_minor received error _and_ a value. Something is fishy..."
+      end
+
+      ogr_err.to_ruby
+
+      value
+    end
+
+    # Set the user-visible LOCAL_CS name.
+    #
+    # @param name [String]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def local_cs=(name)
+      ogr_err = FFI::GDAL.OSRSetLocalCS(@ogr_spatial_ref_pointer, name)
+
+      ogr_err.to_ruby
+    end
+
+    # Set the user-visible GEOCCS name.
+    #
+    # @param name [String]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def geoccs=(name)
+      ogr_err = FFI::GDAL.OSRSetGeocCS(@ogr_spatial_ref_pointer, name)
+
+      ogr_err.to_ruby
+    end
+
+    # Set the GEOCCS based on a well-knon name.
+    #
+    # @param name [String]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def well_known_geoccs=(name)
+      if GDAL._supported? :OSRSetWellKnownGeocCS
+        ogr_err = FFI::GDAL.OSRSetWellKnownGeocCS(@ogr_spatial_ref_pointer, name)
+
+        ogr_err.to_ruby
+      end
+    end
+
+    # Set the user-visible PROJCS name.
+    #
+    # @param name [String]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def projcs=(name)
+      ogr_err = FFI::GDAL.OSRSetProjCS(@ogr_spatial_ref_pointer, name)
+
+      ogr_err.to_ruby
+    end
+
+    # @return [Hash]
+    def to_erm
+      projection_name = FFI::MemoryPointer.new(:string)
+      datum_name = FFI::MemoryPointer.new(:string)
+      units = FFI::MemoryPointer.new(:string)
+
+      ogr_err = FFI::GDAL.OSRExportToERM(@ogr_spatial_ref_pointer, projection_name,
+        datum_name, units)
+      ogr_err.to_ruby
+
+      {
+        projection_name: projection_name.read_string,
+        datum_name: datum_name.read_string,
+        units: units.read_string
+      }
+    end
+
+    # @return [Array<String>]
+    def to_mapinfo
+      return_ptr = FFI::MemoryPointer.new(:string)
+      return_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      return_ptr_ptr.write_pointer(return_ptr)
+
+      ogr_err = FFI::GDAL.OSRExportToMICoordSys(@ogr_spatial_ref_pointer,
+        return_ptr_ptr)
+      ogr_err.to_ruby
+
+      return_ptr_ptr.get_array_of_string(0)
+    end
+
+    # @return [Hash]
+    def to_pci
+      proj = FFI::MemoryPointer.new(:string)
+      proj_ptr = FFI::MemoryPointer.new(:pointer)
+      proj_ptr.write_pointer(proj)
+
+      units = FFI::MemoryPointer.new(:string)
+      units_ptr = FFI::MemoryPointer.new(:pointer)
+      units_ptr.write_pointer(units)
+
+      prj_params = FFI::MemoryPointer.new(:double)
+      prj_params_ptr = FFI::MemoryPointer.new(:pointer)
+      prj_params_ptr.write_pointer(prj_params)
+
+      ogr_err = FFI::GDAL.OSRExportToPCI(@ogr_spatial_ref_pointer, proj_ptr,
+        units_ptr, prj_params_ptr)
+      ogr_err.to_ruby
+
+      {
+        projection: proj_ptr.read_pointer.read_string,
+        units: units_ptr.read_pointer.read_string,
+        projection_parameters: prj_params_ptr.read_array_of_double(0)
+      }
+    end
+
+    # @return [String]
+    def to_proj4
+      proj4 = FFI::MemoryPointer.new(:string)
+      proj4_ptr = FFI::MemoryPointer.new(:pointer)
+      proj4_ptr.write_pointer(proj4)
+
+      ogr_err = FFI::GDAL.OSRExportToProj4(@ogr_spatial_ref_pointer, proj4_ptr)
+      ogr_err.to_ruby
+
+      proj4_ptr.read_pointer.read_string
+    end
+
+    # @return [Hash]
+    def to_usgs
+      proj_sys = FFI::MemoryPointer.new(:long)
+      zone = FFI::MemoryPointer.new(:long)
+      datum = FFI::MemoryPointer.new(:long)
+      prj_params = FFI::MemoryPointer.new(:double)
+      prj_params_ptr = FFI::MemoryPointer.new(:pointer)
+      prj_params_ptr.write_pointer(prj_params)
+
+      ogr_err = FFI::GDAL.OSRExportToUSGS(@ogr_spatial_ref_pointer, proj_sys,
+        zone, prj_params_ptr, datum)
+      ogr_err.to_ruby
+
+      {
+        projection_system_code: proj_sys.read_long,
+        zone: zone.read_long,
+        projection_parameters: prj_params_ptr.read_array_of_double(0),
+        datum: datum.read_long
+      }
+    end
+
+    # @return [String]
+    def to_wkt
+      wkt_ptr = FFI::MemoryPointer.new(:string)
+      wkt_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      wkt_ptr_ptr.write_pointer(wkt_ptr)
+
+      ogr_err = FFI::GDAL.OSRExportToWkt(@ogr_spatial_ref_pointer, wkt_ptr_ptr)
+      ogr_err.to_ruby
+
+      wkt_ptr_ptr.read_pointer.read_string
+    end
+
+    # @param simplify [Boolean] +true+ strips off +AXIS+, +AUTHORITY+ and
+    #   +EXTENSION+ nodes.
+    def to_pretty_wkt(simplify=false)
+      wkt_ptr = FFI::MemoryPointer.new(:string)
+      wkt_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      wkt_ptr_ptr.write_pointer(wkt_ptr)
+
+      ogr_err = FFI::GDAL.OSRExportToPrettyWkt(@ogr_spatial_ref_pointer,
+        wkt_ptr_ptr, simplify)
+      ogr_err.to_ruby
+
+      wkt_ptr_ptr.read_pointer.read_string
+    end
+
+    # @return [Hash]
+    def to_xml
+      xml_ptr = FFI::MemoryPointer.new(:string)
+      xml_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+      xml_ptr_ptr.write_pointer(xml_ptr)
+      dialect = FFI::MemoryPointer.new(:string)
+
+      ogr_err = FFI::GDAL.OSRExportToXML(@ogr_spatial_ref_pointer, xml_ptr_ptr,
+        dialect)
+      ogr_err.to_ruby
+
+      {
+        dialect: dialect.read_string,
+        xml: xml_ptr_ptr.get_array_of_string(0)
+      }
+    end
+
+    # Converts, in place, to ESRI WKT format.
+    def morph_to_esri!
+      FFI::GDAL.OSRMorphToESRI(@ogr_spatial_ref_pointer)
+    end
+
+    # Converts, in place, from ESRI WKT format.
+    def morph_from_esri!
+      FFI::GDAL.OSRMorphFromESRI(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean]
+    def geographic?
+      FFI::GDAL.OSRIsGeographic(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean]
+    def local?
+      FFI::GDAL.OSRIsLocal(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean]
+    def projected?
+      FFI::GDAL.OSRIsProjected(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean]
+    def compound?
+      FFI::GDAL.OSRIsCompound(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean]
+    def geocentric?
+      FFI::GDAL.OSRIsGeocentric(@ogr_spatial_ref_pointer)
+    end
+
+    # @return [Boolean]
+    def vertical?
+      FFI::GDAL.OSRIsVertical(@ogr_spatial_ref_pointer)
+    end
+
+    # @param other_spatial_ref [OGR::SpatialReference, FFI::Pointer]
+    # @return [Boolean]
+    def same?(other_spatial_ref)
+      spatial_ref_ptr = GDAL._pointer(other_spatial_ref)
+
+      FFI::GDAL.OSRIsSame(@ogr_spatial_ref_pointer, spatial_ref_ptr)
+    end
+    alias_method :==, :same?
+
+    # @param other_spatial_ref [OGR::SpatialReference, FFI::Pointer]
+    # @return [Boolean]
+    def geoccs_is_same?(other_spatial_ref)
+      spatial_ref_ptr = GDAL._pointer(other_spatial_ref)
+
+      FFI::GDAL.OSRIsSameGeogCS(@ogr_spatial_ref_pointer, spatial_ref_ptr)
+    end
+
+    # @param other_spatial_ref [OGR::SpatialReference, FFI::Pointer]
+    # @return [Boolean]
+    def vertcs_is_same?(other_spatial_ref)
+      spatial_ref_ptr = GDAL._pointer(other_spatial_ref)
+
+      FFI::GDAL.OSRIsSameVertCS(@ogr_spatial_ref_pointer, spatial_ref_ptr)
+    end
+
+    # @return [FFI::Pointer] Pointer to an OGRCreateCoordinateTransformation.
+    def create_coordinate_transformation(destination_spatial_ref)
+      dest_ptr = GDAL._pointer(OGR::SpatialReference, destination_spatial_ref)
+
+      FFI::GDAL.OGRCreateCoordinateTransformation(@ogr_spatial_ref_pointer, dest_ptr)
+    end
+  end
+end