ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/spatial_reference_extensions.rb

@@ -2,9 +2,35 @@ require 'json'
 
 module OGR
   module SpatialReferenceExtensions
+    # @param unit_label [Symbol, String] Must match one of the known angular
+    #   unit types from FFI::GDAL::SRS_UA.  Since there are only two, pick either
+    #   :radian or :degree.
+    # @raise [NameError] If the +unit_label+ isn't of a known type.
+    def angular_units=(unit_label)
+      unit_name = unit_label.to_s.upcase
+      unit_label = self.class.const_get("#{unit_name}_LABEL".to_sym)
+      unit_value = self.class.const_get("RADIAN_TO_#{unit_name}".to_sym)
+
+      set_angular_units(unit_label, unit_value)
+    rescue NameError
+      raise NameError, "Param must be a known angular unit type: #{unit_label}"
+    end
+
+    # @param unit_label [Symbol, String] Must match one of the known linear
+    #   unit types from FFI::GDAL::SRS_UL.  I.e. :us_foot.
+    # @raise [NameError] If the +unit_label+ isn't of a known type.
+    def linear_units=(unit_label)
+      unit_name = unit_label.to_s.upcase
+      unit_label = self.class.const_get("#{unit_name}_LABEL".to_sym)
+      unit_value = self.class.const_get("METER_TO_#{unit_name}".to_sym)
+
+      set_linear_units(unit_label, unit_value)
+    rescue NameError
+      raise NameError, "Param must be a known linear unit type: #{unit_label}"
+    end
 
     # @return [Hash]
-    def as_json
+    def as_json(_options = nil)
       {
         angular_units: angular_units,
         epsg_treats_as_lat_long: epsg_treats_as_lat_long?,
@@ -25,8 +51,8 @@ module OGR
     end
 
     # @return [String]
-    def to_json
-      as_json.to_json
+    def to_json(options = nil)
+      as_json(options).to_json
     end
   end
 end

data/lib/ogr/spatial_reference_mixins/coordinate_system_getter_setters.rb

@@ -0,0 +1,494 @@
+module OGR
+  module SpatialReferenceMixins
+    module CoordinateSystemGetterSetters
+      # Set the user-visible LOCAL_CS name.
+      #
+      # @param name [String]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def set_local_cs(name)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetLocalCS(@c_pointer, name)
+
+        ogr_err.handle_result
+      end
+      alias_method :local_cs=, :set_local_cs
+
+      # Set the user-visible PROJCS name.
+      #
+      # @param name [String]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def set_proj_cs(name)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetProjCS(@c_pointer, name)
+
+        ogr_err.handle_result
+      end
+      alias_method :proj_cs=, :set_proj_cs
+
+      # Set the user-visible PROJCS name.
+      #
+      # @param name [String]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def set_geoc_cs(name)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetGeocCS(@c_pointer, name)
+
+        ogr_err.handle_result
+      end
+      alias_method :geoc_cs=, :set_geoc_cs
+
+      # Set the GEOGCS based on a well-known name.
+      #
+      # @param name [String]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      # @raise [NotImplementedError] If your version of GDAL/OGR doesn't define
+      #   the C function needed for this.
+      def set_well_known_geog_cs(name)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetWellKnownGeogCS(@c_pointer, name)
+
+        ogr_err.handle_result
+      end
+      alias_method :well_known_geog_cs=, :set_well_known_geog_cs
+
+      # @param definition [String]
+      def set_from_user_input(definition)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetFromUserInput(@c_pointer, definition)
+
+        ogr_err.handle_result 'Invalid projection info given.'
+      end
+
+      # @return [Array<Float>]
+      def towgs84
+        coefficients = FFI::MemoryPointer.new(:double, 7)
+        ogr_err = FFI::OGR::SRSAPI.OSRGetTOWGS84(@c_pointer, coefficients, 7)
+        ogr_err.handle_result
+
+        coefficients.read_array_of_double(0)
+      end
+
+      # @param x_distance [Float] (In meters.)
+      # @param y_distance [Float] (In meters.)
+      # @param z_distance [Float] (In meters.)
+      # @param x_rotation [Float] (In arc seconds.)
+      # @param y_rotation [Float] (In arc seconds.)
+      # @param z_rotation [Float] (In arc seconds.)
+      # @param scaling_factor [Float] (In parts-per-million.)
+      def set_towgs84(x_distance: nil, y_distance: nil, z_distance: nil,
+                      x_rotation: 0.0, y_rotation: 0.0, z_rotation: 0.0,
+                      scaling_factor: 0.0)
+
+        ogr_err = FFI::OGR::SRSAPI.OSRSetTOWGS84(
+          @c_pointer,
+          x_distance, y_distance, z_distance,
+          x_rotation, y_rotation, z_rotation,
+          scaling_factor)
+
+        ogr_err.handle_result
+      end
+
+      # @param name [String]
+      # @param horizontal_spatial_ref [OGR::SpatialReference] (a PROJCS or GEOGCS)
+      # @param vertical_spatial_ref [OGR::SpatialReference] (a VERT_CS)
+      # @return [Boolean]
+      def set_compound_cs(name, horizontal_spatial_ref, vertical_spatial_ref)
+        horizontal_spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, horizontal_spatial_ref)
+        vertical_spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, vertical_spatial_ref)
+
+        ogr_err = FFI::OGR::SRSAPI.OSRSetCompoundCS(
+          @c_pointer,
+          name,
+          horizontal_spatial_ref_ptr,
+          vertical_spatial_ref_ptr)
+
+        ogr_err.handle_result
+      end
+
+      # Set the user-visible GEOCCS name.
+      #
+      # @param [String] geog_name
+      # @param [String] datum_name
+      # @param [String] spheroid_name
+      # @param [Float] semi_major
+      # @param [Float] spheroid_inverse_flattening
+      # @param [String] prime_meridian
+      # @param [Double] offset
+      # @param [String] angular_unit_label
+      # @param [Float] transform_to_radians
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def set_geog_cs(geog_name, datum_name, spheroid_name, semi_major, spheroid_inverse_flattening,
+        prime_meridian, offset, angular_unit_label, transform_to_radians)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetGeogCS(
+          @c_pointer,
+          geog_name, datum_name, spheroid_name,
+          semi_major, spheroid_inverse_flattening,
+          prime_meridian, offset,
+          angular_unit_label, transform_to_radians
+        )
+
+        ogr_err.handle_result
+      end
+
+      # Set the vertical coordinate system.
+      #
+      # @param name [String] User-visible name of the CS.
+      # @param datum_name [String] User-visible name of the datum.  It's helpful
+      #   to have this match the EPSG name.
+      # @param datum_type [String] The OGC datum type, usually 2005.
+      def set_vert_cs(name, datum_name, datum_type)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetVertCS(@c_pointer, name, datum_name, datum_type)
+
+        ogr_err.handle_result
+      end
+
+      # @param return_wgs84_on_nil [Boolean] The C-API gives you the option to
+      #   return the value for constant +SRS_WGS84_SEMIMAJOR+ (6378137.0) if no
+      #   semi-major is found.  If set to +true+, this will return that value if
+      #   the semi-major isn't found.
+      # @return [Float]
+      def semi_major(return_wgs84_on_nil = false)
+        err_ptr = FFI::MemoryPointer.new(:int)
+        value = FFI::OGR::SRSAPI.OSRGetSemiMajor(@c_pointer, err_ptr)
+        ogr_err = FFI::OGR::Core::Err[err_ptr.read_int]
+        wgs84_value = return_wgs84_on_nil ? value : nil
+
+        ogr_err == :OGRERR_FAILURE ? wgs84_value : value
+      end
+
+      # @param return_wgs84_on_nil [Boolean] The C-API gives you the option to
+      #   return the value for constant +SRS_WGS84_SEMIMAJOR+ (6378137.0) if no
+      #   semi-major is found.  If set to +true+, this will return that value if
+      #   the semi-major isn't found.
+      # @return [Float]
+      def semi_minor(return_wgs84_on_nil = false)
+        err_ptr = FFI::MemoryPointer.new(:int)
+        value = FFI::OGR::SRSAPI.OSRGetSemiMinor(@c_pointer, err_ptr)
+        ogr_err = FFI::OGR::Core::Err[err_ptr.read_int]
+        wgs84_value = return_wgs84_on_nil ? value : nil
+
+        ogr_err == :OGRERR_FAILURE ? wgs84_value : value
+      end
+
+      # @param return_wgs84_on_nil [Boolean] The C-API gives you the option to
+      #   return the value for constant +SRS_WGS84_INVFLATTENING+ (298.257223563)
+      #   if no semi-major is found.  If set to +true+, this will return that
+      #   value if the semi-major isn't found.
+      # @return [Float]
+      def spheroid_inverse_flattening(return_wgs84_on_nil = false)
+        err_ptr = FFI::MemoryPointer.new(:int)
+        value = FFI::OGR::SRSAPI.OSRGetInvFlattening(@c_pointer, err_ptr)
+        ogr_err = FFI::OGR::Core::Err[err_ptr.read_int]
+        wgs84_value = return_wgs84_on_nil ? value : nil
+
+        ogr_err == :OGRERR_FAILURE ? wgs84_value : value
+      end
+
+      # @param target_key [String] The partial or complete path to the node to
+      #   set an authority on ("PROJCS", "GEOGCS|UNIT").
+      # @param authority [String] I.e. "EPSG".
+      # @param code [Fixnum] Code value for the authority.
+      def set_authority(target_key, authority, code)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetAuthority(
+          @c_pointer,
+          target_key,
+          authority,
+          code)
+
+        ogr_err.handle_result
+      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::OGR::SRSAPI.OSRGetAuthorityCode(@c_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::OGR::SRSAPI.OSRGetAuthorityName(@c_pointer, target_key)
+      end
+
+      # @param projection_name [String]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def set_projection(projection_name)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetProjection(@c_pointer, projection_name)
+
+        ogr_err.handle_result
+      end
+      alias_method :projection=, :set_projection
+
+      # @param param_name [String]
+      # @param value [Float]
+      def set_projection_parameter(param_name, value)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetProjParm(@c_pointer, param_name, value)
+
+        ogr_err.handle_result
+      end
+
+      # @param name [String]
+      # @param default_value [Float] The value to return if the parameter
+      #   doesn't exist.
+      def projection_parameter(name, default_value = 0.0)
+        FFI::OGR::SRSAPI.OSRGetProjParm(@c_pointer, name, default_value, nil)
+      end
+
+      # @param param_name [String]
+      # @param value [Float]
+      def set_normalized_projection_parameter(param_name, value)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetNormProjParm(@c_pointer, param_name, value)
+
+        ogr_err.handle_result
+      end
+
+      # @param name [String] Name of the parameter to fetch; must be from the
+      #   set of SRS_PP codes in ogr_srs_api.h.
+      # @param default_value [Float] The value to return if the parameter
+      #   doesn't exist.
+      def normalized_projection_parameter(name, default_value = 0.0)
+        FFI::OGR::SRSAPI.OSRGetNormProjParm(@c_pointer, name, default_value, nil)
+      end
+
+      # @param zone [Fixnum]
+      # @param north [Boolean] True for northern hemisphere, false for southern.
+      def set_utm(zone, north)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetUTM(@c_pointer, zone, north)
+
+        ogr_err.handle_result
+      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 fail "Unknown hemisphere type #{hemisphere}. Please choose :north or :south."
+          end
+        north_ptr = FFI::MemoryPointer.new(:bool)
+        north_ptr.write_bytes(north.to_s)
+
+        FFI::OGR::SRSAPI.OSRGetUTMZone(@c_pointer, north_ptr)
+      end
+
+      # @param zone [Fixnum] State plane zone number (USGS numbering scheme).
+      # @param nad83 [Boolean] Use NAD83 zone definition or not.
+      def set_state_plane(zone, nad83 = true, override_unit_label = nil, override_unit_transform = 0.0)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetStatePlaneWithUnits(
+          @c_pointer,
+          zone,
+          nad83,
+          override_unit_label,
+          override_unit_transform)
+
+        ogr_err.handle_result
+      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::OGR::SRSAPI.OSRGetAxis(@c_pointer, target_key, axis_number, axis_orientation_ptr)
+        ao_value = axis_orientation_ptr.read_int
+
+        { name: name, orientation: AxisOrientation[ao_value] }
+      end
+
+      def set_albers_conic_equal_area
+        fail NotImplementedError
+      end
+      alias_method :set_acea, :set_albers_conic_equal_area
+
+      def set_ae
+        fail NotImplementedError
+      end
+
+      def set_bonne
+        fail NotImplementedError
+      end
+
+      def set_cea
+        fail NotImplementedError
+      end
+
+      def set_cs
+        fail NotImplementedError
+      end
+
+      def set_ec
+        fail NotImplementedError
+      end
+
+      def set_eckert
+        fail NotImplementedError
+      end
+
+      def set_eckert_iv
+        fail NotImplementedError
+      end
+
+      def set_eckert_vi
+        fail NotImplementedError
+      end
+
+      def set_equirectangular
+        fail NotImplementedError
+      end
+
+      def set_equirectangular2
+        fail NotImplementedError
+      end
+
+      def set_gc
+        fail NotImplementedError
+      end
+
+      def set_gh
+        fail NotImplementedError
+      end
+
+      def set_igh
+        fail NotImplementedError
+      end
+
+      def set_geos
+        fail NotImplementedError
+      end
+
+      def set_gauss_schreiber_transverse_mercator
+        fail NotImplementedError
+      end
+
+      def set_gnomonic
+        fail NotImplementedError
+      end
+
+      def set_om
+        fail NotImplementedError
+      end
+
+      def set_hom
+        fail NotImplementedError
+      end
+
+      def set_hom_2_pno
+        fail NotImplementedError
+      end
+
+      def set_iwm_polyconic
+        fail NotImplementedError
+      end
+
+      def set_krovak
+        fail NotImplementedError
+      end
+
+      def set_laea
+        fail NotImplementedError
+      end
+
+      def set_lcc
+        fail NotImplementedError
+      end
+
+      def set_lcc_1sp
+        fail NotImplementedError
+      end
+
+      def set_lccb
+        fail NotImplementedError
+      end
+
+      def set_mc
+        fail NotImplementedError
+      end
+
+      def set_mercator
+        fail NotImplementedError
+      end
+
+      def set_mollweide
+        fail NotImplementedError
+      end
+
+      def set_nzmg
+        fail NotImplementedError
+      end
+
+      def set_os
+        fail NotImplementedError
+      end
+
+      def set_orthographic
+        fail NotImplementedError
+      end
+
+      def set_polyconic
+        fail NotImplementedError
+      end
+
+      def set_ps
+        fail NotImplementedError
+      end
+
+      def set_robinson
+        fail NotImplementedError
+      end
+
+      def set_sinusoidal
+        fail NotImplementedError
+      end
+
+      def set_stereographic
+        fail NotImplementedError
+      end
+
+      def set_soc
+        fail NotImplementedError
+      end
+
+      # @param center_lat [Float]
+      # @param center_long [Float]
+      # @param scale [Float]
+      # @param false_easting [Float]
+      # @param false_northing [Float]
+      def set_transverse_mercator(center_lat, center_long, scale, false_easting, false_northing)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetTM(
+          @c_pointer,
+          center_lat, center_long,
+          scale,
+          false_easting, false_northing)
+
+        ogr_err.handle_result
+      end
+      alias_method :set_tm, :set_transverse_mercator
+
+      def set_tm_variant
+        fail NotImplementedError
+      end
+
+      def set_tmg
+        fail NotImplementedError
+      end
+
+      def set_tmso
+        fail NotImplementedError
+      end
+
+      def set_vdg
+        fail NotImplementedError
+      end
+
+      def set_wagner
+        fail NotImplementedError
+      end
+
+      def set_qsc
+        fail NotImplementedError
+      end
+    end
+  end
+end

data/lib/ogr/spatial_reference_mixins/exporters.rb

@@ -0,0 +1,134 @@
+module OGR
+  module SpatialReferenceMixins
+    module Exporters
+      # @return [Hash]
+      # @raise [OGR::NotEnoughData] If name, datum name, and units are not set.
+      def to_erm
+        projection_name = FFI::MemoryPointer.new(:string)
+        datum_name = FFI::MemoryPointer.new(:string)
+        units = FFI::MemoryPointer.new(:string)
+
+        ogr_err = FFI::OGR::SRSAPI.OSRExportToERM(@c_pointer, projection_name,
+          datum_name, units)
+        ogr_err.handle_result 'Required parameters (name, datum name, units) are not defined'
+
+        {
+          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::OGR::SRSAPI.OSRExportToMICoordSys(@c_pointer,
+          return_ptr_ptr)
+        ogr_err.handle_result
+
+        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::OGR::SRSAPI.OSRExportToPCI(@c_pointer, proj_ptr,
+          units_ptr, prj_params_ptr)
+        ogr_err.handle_result
+
+        {
+          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]
+      # @raise [GDAL::UnsupportedOperation] If empty definition.
+      def to_proj4
+        proj4 = FFI::MemoryPointer.new(:string)
+        proj4_ptr = FFI::MemoryPointer.new(:pointer)
+        proj4_ptr.write_pointer(proj4)
+
+        ogr_err = FFI::OGR::SRSAPI.OSRExportToProj4(@c_pointer, proj4_ptr)
+        ogr_err.handle_result
+
+        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::OGR::SRSAPI.OSRExportToUSGS(@c_pointer, proj_sys,
+          zone, prj_params_ptr, datum)
+        ogr_err.handle_result
+
+        {
+          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::OGR::SRSAPI.OSRExportToWkt(@c_pointer, wkt_ptr_ptr)
+        ogr_err.handle_result
+
+        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::OGR::SRSAPI.OSRExportToPrettyWkt(@c_pointer,
+          wkt_ptr_ptr, simplify)
+        ogr_err.handle_result
+
+        wkt_ptr_ptr.read_pointer.read_string
+      end
+
+      # @return [String]
+      def to_xml(dialect = nil)
+        xml_ptr = FFI::MemoryPointer.new(:string)
+        xml_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+        xml_ptr_ptr.write_pointer(xml_ptr)
+
+        ogr_err = FFI::OGR::SRSAPI.OSRExportToXML(@c_pointer, xml_ptr_ptr,
+          dialect)
+        ogr_err.handle_result
+
+        xml_ptr_ptr.get_array_of_string(0).join
+      end
+    end
+  end
+end