ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/spatial_reference_mixins/importers.rb

@@ -0,0 +1,243 @@
+module OGR
+  module SpatialReferenceMixins
+    module Importers
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # @param code [Fixnum]
+        # @return [OGR::SpatialReference]
+        def new_from_epsg(code)
+          srs = new
+          srs.import_from_epsg(code)
+
+          srs
+        end
+
+        # @param code [Fixnum]
+        # @return [OGR::SpatialReference]
+        def new_from_epsga(code)
+          srs = new
+          srs.import_from_epsg(code)
+
+          srs
+        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 new_from_erm(projection_name, datum_name, linear_unit_name)
+          srs = new
+          srs.import_from_erm(projection_name, datum_name, linear_unit_name)
+
+          srs
+        end
+
+        # @param prj_text [Array<String>]
+        # @return [OGR::SpatialReference]
+        def new_from_esri(prj_text)
+          srs = new
+          srs.import_from_esri(prj_text)
+
+          srs
+        end
+
+        # @param coord_sys [String] The Mapinfo style CoordSys definition string.
+        # @return [OGR::SpatialReference]
+        def new_from_mapinfo(coord_sys)
+          srs = new
+          srs.import_from_mapinfo(coord_sys)
+
+          srs
+        end
+
+        # @param proj [String]
+        # @param units [String]
+        # @param proj_params [Array<String>]
+        # @return [OGR::SpatialReference]
+        def new_from_pci(proj, units, *proj_params)
+          srs = new
+          srs.import_from_pci(proj, units, *proj_params)
+
+          srs
+        end
+
+        # @param proj4 [String]
+        # @return [OGR::SpatialReference]
+        def new_from_proj4(proj4)
+          srs = new
+          srs.import_from_proj4(proj4)
+
+          srs
+        end
+
+        # @param url [String] URL to fetch the spatial reference from.
+        # @return [OGR::SpatialReference]
+        def new_from_url(url)
+          srs = new
+          srs.import_from_url(url)
+
+          srs
+        end
+
+        # @param projection_system_code
+        # @return [OGR::SpatialReference]
+        def new_from_usgs(projection_system_code, zone, datum, *proj_params)
+          srs = new
+          srs.import_from_usgs(projection_system_code, zone, datum, *proj_params)
+
+          srs
+        end
+
+        # This wipes the existing SRS definition and reassigns it based on the
+        # contents of +wkt+.
+        #
+        # @param wkt [String]
+        # @return [OGR::SpatialReference]
+        def new_from_wkt(wkt)
+          srs = new
+          srs.import_from_wkt(wkt)
+
+          srs
+        end
+
+        # Use for importing a GML coordinate system.
+        #
+        # @param xml [String]
+        # @return [OGR::SpatialReference]
+        def new_from_xml(xml)
+          srs = new
+          srs.import_from_xml(xml)
+
+          srs
+        end
+
+        # @return [OGR::SpatialReference]
+        def build_spatial_ref(spatial_reference_or_wkt = nil)
+          object = new(spatial_reference_or_wkt)
+          ogr_err = yield object.c_pointer
+          ogr_err.handle_result
+
+          object
+        end
+      end
+
+      # @param code [Fixnum]
+      # @raise [GDAL::UnsupportedOperation] On unknown EPSG code.
+      def import_from_epsg(code)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromEPSG(@c_pointer, code)
+
+        ogr_err.handle_result
+      end
+
+      # @param code [Fixnum]
+      def import_from_epsga(code)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromEPSGA(@c_pointer, code)
+
+        ogr_err.handle_result
+      end
+
+      # @param wkt [String]
+      def import_from_wkt(wkt)
+        wkt_ptr = FFI::MemoryPointer.from_string(wkt)
+        wkt_ptr_ptr = FFI::MemoryPointer.new(:pointer)
+        wkt_ptr_ptr.write_pointer(wkt_ptr)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromWkt(@c_pointer, wkt_ptr_ptr)
+
+        ogr_err.handle_result
+      end
+
+      # @param proj4 [String]
+      def import_from_proj4(proj4)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromProj4(@c_pointer, proj4)
+
+        ogr_err.handle_result
+      end
+
+      # @param esri_text [Array<String>]
+      def import_from_esri(esri_text)
+        text_array = esri_text.split("\n")
+        esri_ptr_ptr = GDAL._string_array_to_pointer(text_array)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromESRI(@c_pointer, esri_ptr_ptr)
+
+        ogr_err.handle_result
+      end
+
+      # @param proj [String]
+      # @param units [String]
+      # @param proj_params [Array<String>]
+      def import_from_pci(proj, units, *proj_params)
+        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
+
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromPCI(@c_pointer, proj, units, proj_ptr)
+
+        ogr_err.handle_result
+      end
+
+      # @param projection_system_code [Fixnum]
+      # @param zone [Fixnum]
+      # @param datum [Fixnum]
+      # @param proj_params [Array<Float>]
+      def import_from_usgs(projection_system_code, zone, datum, *proj_params)
+        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
+
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromUSGS(
+          @c_pointer,
+          projection_system_code,
+          zone,
+          proj_ptr,
+          datum)
+
+        ogr_err.handle_result
+      end
+
+      # Use for importing a GML coordinate system.
+      #
+      # @param xml [String]
+      def import_from_xml(xml)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromXML(@c_pointer, xml)
+
+        ogr_err.handle_result
+      end
+
+      # @param coord_sys [String] The Mapinfo style CoordSys definition string.
+      def import_from_mapinfo(coord_sys)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromMICoordSys(@c_pointer, coord_sys)
+
+        ogr_err.handle_result
+      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".
+      def import_from_erm(projection_name, datum_name, linear_unit_name)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromERM(
+          @c_pointer,
+          projection_name,
+          datum_name,
+          linear_unit_name)
+
+        ogr_err.handle_result
+      end
+
+      # @param url [String] URL to fetch the spatial reference from.
+      def import_from_url(url)
+        ogr_err = FFI::OGR::SRSAPI.OSRImportFromUrl(@c_pointer, url)
+
+        ogr_err.handle_result
+      end
+    end
+  end
+end

data/lib/ogr/spatial_reference_mixins/morphers.rb

@@ -0,0 +1,25 @@
+module OGR
+  module SpatialReferenceMixins
+    module Morphers
+      # Converts, in place, to ESRI WKT format.
+      #
+      # @return [OGR::SpatialReference, false] If successful, returns self.
+      def morph_to_esri!
+        ogr_err = FFI::OGR::SRSAPI.OSRMorphToESRI(@c_pointer)
+        result = ogr_err.handle_result
+
+        result ? self : result
+      end
+
+      # Converts, in place, from ESRI WKT format.
+      #
+      # @return [OGR::SpatialReference, false] If successful, returns self.
+      def morph_from_esri!
+        ogr_err = FFI::OGR::SRSAPI.OSRMorphFromESRI(@c_pointer)
+        result = ogr_err.handle_result
+
+        result ? self : result
+      end
+    end
+  end
+end

data/lib/ogr/spatial_reference_mixins/parameter_getter_setters.rb

@@ -0,0 +1,122 @@
+module OGR
+  module SpatialReferenceMixins
+    module ParameterGetterSetters
+      # @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::OGR::SRSAPI.OSRGetAttrValue(@c_pointer, name, child)
+      end
+
+      # @param path [String] Path to the node to update/set.  If nested, use the
+      #   pipe symbol to denote nesting.  i.e. 'GEOCCS|UNIT'.
+      # @param value [String] The new value for the node/path.  Should be a String,
+      #   but if not, will be converted for you.
+      def set_attribute_value(path, value)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetAttrValue(@c_pointer, path, value.to_s)
+
+        ogr_err.handle_result
+      end
+
+      # @return [Hash{unit_name: String, value: Float}]  +unit_name+ is the name
+      #   of the unit type ("degree" or "radian").  +value+ is the number to
+      #   multiply angular distances to transform them to radians.
+      def angular_units
+        name = FFI::MemoryPointer.new(:string)
+        name_ptr = FFI::MemoryPointer.new(:pointer)
+        name_ptr.write_pointer(name)
+
+        value = FFI::OGR::SRSAPI.OSRGetAngularUnits(@c_pointer, name_ptr)
+
+        { unit_name: name_ptr.read_pointer.read_string, value: value }
+      end
+
+      # @param unit_label [String]
+      # @param transform_to_radians [Float] The value to multiply an angle to
+      #   transform the value to radians.
+      def set_angular_units(unit_label, transform_to_radians)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetAngularUnits(@c_pointer, unit_label, transform_to_radians.to_f)
+
+        ogr_err.handle_result
+      end
+
+      # @return [Hash{unit_name: String, value: Float}]  +unit_name+ is the name
+      #   of the unit type (e.g. "Meters"). +value+ is the number to multiply
+      #   linear distances to transform them to meters.
+      def linear_units
+        name = FFI::MemoryPointer.new(:string)
+        name_ptr = FFI::MemoryPointer.new(:pointer)
+        name_ptr.write_pointer(name)
+
+        value = FFI::OGR::SRSAPI.OSRGetLinearUnits(@c_pointer, name_ptr)
+
+        { unit_name: name_ptr.read_pointer.read_string, value: value }
+      end
+
+      # @param unit_label [String]
+      # @param transform_to_meters [Float] The value to multiply a length to
+      #   transform the value to meters.
+      def set_linear_units(unit_label, transform_to_meters)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetLinearUnits(@c_pointer, unit_label, transform_to_meters.to_f)
+
+        ogr_err.handle_result
+      end
+
+      # Does the same as #set_linear_units, but also converts parameters to use
+      # the new units.
+      #
+      # @param unit_label [String]
+      # @param transform_to_meters [Float] The value to multiply a length to
+      #   transform the value to meters.
+      def set_linear_units_and_update_parameters(unit_label, transform_to_meters)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetLinearUnitsAndUpdateParameters(
+          @c_pointer,
+          unit_label,
+          transform_to_meters.to_f)
+
+        ogr_err.handle_result
+      end
+
+      # The linear units for the projection.
+      #
+      # @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::OGR::SRSAPI.OSRGetTargetLinearUnits(@c_pointer, target_key, name_ptr)
+
+        { unit_name: name_ptr.read_pointer.read_string, value: value }
+      end
+
+      # @param target_key [String] The keyword to set linear units for ("PROJCS",
+      #   "VERT_CS", etc.).
+      # @param unit_label [String] Name of the units to be used.
+      # @param transform_to_meters [Float] The value to multiple a length to
+      #   transform the value to meters.
+      def set_target_linear_units(target_key, unit_label, transform_to_meters)
+        ogr_err = FFI::OGR::SRSAPI.OSRSetTargetLinearUnits(
+          @c_pointer,
+          target_key,
+          unit_label,
+          transform_to_meters
+        )
+
+        ogr_err.handle_result
+      end
+
+      # @return [Hash]
+      def prime_meridian
+        pm = FFI::MemoryPointer.new(:string)
+        pm_ptr = FFI::MemoryPointer.new(:pointer)
+        pm_ptr.write_pointer(pm)
+
+        value = FFI::OGR::SRSAPI.OSRGetPrimeMeridian(@c_pointer, pm_ptr)
+
+        { name: pm_ptr.read_pointer.read_string, value: value }
+      end
+    end
+  end
+end

data/lib/ogr/spatial_reference_mixins/type_checks.rb

@@ -0,0 +1,62 @@
+module OGR
+  module SpatialReferenceMixins
+    module TypeChecks
+      # @return [Boolean] True if the root node is a GEOGCS node.
+      def geographic?
+        FFI::OGR::SRSAPI.OSRIsGeographic(@c_pointer)
+      end
+
+      # @return [Boolean] True if the root node is a LOCAL_CS node.
+      def local?
+        FFI::OGR::SRSAPI.OSRIsLocal(@c_pointer)
+      end
+
+      # @return [Boolean] True if it contains a PROJCS node.
+      def projected?
+        FFI::OGR::SRSAPI.OSRIsProjected(@c_pointer)
+      end
+
+      # @return [Boolean] True if the root node is a COMPD_CS node.
+      def compound?
+        FFI::OGR::SRSAPI.OSRIsCompound(@c_pointer)
+      end
+
+      # @return [Boolean] True if the root node is a GEOCCS node.
+      def geocentric?
+        FFI::OGR::SRSAPI.OSRIsGeocentric(@c_pointer)
+      end
+
+      # @return [Boolean] True if it contains a VERT_CS node.
+      def vertical?
+        FFI::OGR::SRSAPI.OSRIsVertical(@c_pointer)
+      end
+
+      # @param other_spatial_ref [OGR::SpatialReference, FFI::Pointer]
+      # @return [Boolean] True if both SpatialReferences describe the same
+      #   system.
+      def same?(other_spatial_ref)
+        spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, other_spatial_ref)
+
+        FFI::OGR::SRSAPI.OSRIsSame(@c_pointer, spatial_ref_ptr)
+      end
+
+      # @param other_spatial_ref [OGR::SpatialReference, FFI::Pointer]
+      # @return [Boolean] True if the GEOGCS nodes of each SpatialReference
+      #   match.
+      def geog_cs_is_same?(other_spatial_ref)
+        spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, other_spatial_ref)
+
+        FFI::OGR::SRSAPI.OSRIsSameGeogCS(@c_pointer, spatial_ref_ptr)
+      end
+
+      # @param other_spatial_ref [OGR::SpatialReference, FFI::Pointer]
+      # @return [Boolean] True if the VERT_CS nodes of each SpatialReference
+      #   match.
+      def vert_cs_is_same?(other_spatial_ref)
+        spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, other_spatial_ref)
+
+        FFI::OGR::SRSAPI.OSRIsSameVertCS(@c_pointer, spatial_ref_ptr)
+      end
+    end
+  end
+end

data/lib/ogr/style_table.rb

@@ -5,13 +5,61 @@ module OGR
   class StyleTable
     include StyleTableExtensions
 
-    # @param style_table [OGR::StyleTable, FFI::Pointer]
-    def initialize(style_table)
-      @ogr_style_table_pointer = GDAL._pointer(OGR::StyleTable, style_table)
+    # @return [FFI::Pointer] C pointer to the C style table.
+    attr_reader :c_pointer
+
+    # @param [FFI::Pointer] c_pointer
+    def initialize(c_pointer = nil)
+      @c_pointer = c_pointer ? c_pointer : FFI::OGR::API.OGR_STBL_Create
+
+      fail 'Unable to create StyleTable' if @c_pointer.null?
+    end
+
+    def destroy!
+      return unless @c_pointer
+
+      FFI::OGR::API.OGR_STBL_Destroy(@c_pointer)
+      @c_pointer = nil
+    end
+
+    # @param name [String] Name of the style.
+    # @param style [String]
+    # @return [Boolean]
+    def add_style(name, style)
+      FFI::OGR::API.OGR_STBL_AddStyle(@c_pointer, name, style)
+    end
+
+    # @param style_name [String]
+    # @return [String, nil]
+    def find(style_name)
+      FFI::OGR::API.OGR_STBL_Find(@c_pointer, style_name)
+    end
+
+    # @return [String, nil] The style name of the last string fetched with #next_style.
+    def last_style_name
+      FFI::OGR::API.OGR_STBL_GetLastStyleName(@c_pointer)
+    end
+
+    # @return [String, nil] The next style string from the table.
+    def next_style
+      FFI::OGR::API.OGR_STBL_GetNextStyle(@c_pointer)
+    end
+
+    # @param file_name [String]
+    # @return [Boolean]
+    def load!(file_name)
+      FFI::OGR::API.OGR_STBL_LoadStyleTable(@c_pointer, file_name)
+    end
+
+    # Resets the #next_style to the 0th style.
+    def reset_style_string_reading
+      FFI::OGR::API.OGR_STBL_ResetStyleStringReading(@c_pointer)
     end
 
-    def c_pointer
-      @ogr_style_table_pointer
+    # @param file_name [String] Path to the file to save to.
+    # @return [Boolean]
+    def save(file_name)
+      FFI::OGR::API.OGR_STBL_SaveStyleTable(@c_pointer, file_name)
     end
   end
 end

data/lib/ogr/style_table_extensions.rb

@@ -2,15 +2,31 @@ require 'json'
 
 module OGR
   module StyleTableExtensions
+    # Gets all of the styles as Hash.  Note that this calls
+    # #reset_style_string_reading.
+    #
+    # @return [Hash{name => style}]
+    def styles
+      styles = {}
+      reset_style_string_reading
 
-    # @return [String]
-    def as_json
-      'StyleTable interface not yet wrapped with ffi-ruby'
+      while style = next_style
+        styles[last_style_name] = style
+      end
+
+      reset_style_string_reading
+
+      styles
+    end
+
+    # @return [Hash]
+    def as_json(_options = nil)
+      styles
     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/style_tool.rb

@@ -0,0 +1,118 @@
+require_relative '../ffi/ogr'
+
+module OGR
+  class StyleTool
+    # @return [FFI::Pointer] C pointer to the C style tool.
+    attr_reader :c_pointer
+
+    # @param style_tool_class [FFI::OGR::Core::STClassId] Must be one of :OGRSTCPen,
+    #   :OGRSTCBrush, :OGRSTCSymbol, :OGRSTCLabel.
+    def initialize(style_tool_class)
+      @c_pointer = FFI::OGR::API.OGR_ST_Create(style_tool_class)
+      return if @c_pointer && !@c_pointer.null?
+
+      fail OGR::CreateFailure, "Unable to create StyleTool using class #{style_tool_class}"
+    end
+
+    # @return [String, nil]
+    def style_string
+      FFI::OGR::API.OGR_ST_GetStyleString(@c_pointer)
+    end
+
+    # @return [FFI::OGR::Core::STClassId]
+    def type
+      FFI::OGR::API.OGR_ST_GetType(@c_pointer)
+    end
+
+    # @return [FFI::OGR::Core::STUnitId]
+    def unit
+      FFI::OGR::API.OGR_ST_GetUnit(@c_pointer)
+    end
+
+    # @param new_unit [FFI::OGR::Core::STUnitId]
+    # @param ground_to_paper_scale [Float]
+    def set_unit(new_unit, ground_to_paper_scale)
+      FFI::OGR::API.OGR_ST_SetUnit(@c_pointer, new_unit, ground_to_paper_scale)
+    end
+
+    # @param param_number [Fixnum]
+    # @return [Float, nil]
+    def param_as_double(param_number)
+      value_is_null_ptr = FFI::MemoryPointer.new(:int)
+      value = FFI::OGR::API.OGR_ST_GetParamDbl(@c_pointer, param_number, value_is_null_ptr)
+
+      value_is_null_ptr.read_int.to_bool ? nil : value
+    end
+    alias_method :param_as_float, :param_as_double
+
+    # @param param_number [Fixnum]
+    # @param value [Float]
+    def set_param_as_double(param_number, value)
+      FFI::OGR::API.OGR_ST_SetParamDbl(@c_pointer, param_number, value)
+    end
+    alias_method :set_param_as_float, :set_param_as_double
+
+    # @param param_number [Fixnum]
+    # @return [Fixnum, nil]
+    def param_as_number(param_number)
+      value_is_null_ptr = FFI::MemoryPointer.new(:int)
+      value = FFI::OGR::API.OGR_ST_GetParamNum(@c_pointer, param_number, value_is_null_ptr)
+
+      value_is_null_ptr.read_int.to_bool ? nil : value
+    end
+    alias_method :param_as_integer, :param_as_number
+
+    # @param param_number [Fixnum]
+    # @param value [Fixnum]
+    def set_param_as_number(param_number, value)
+      FFI::OGR::API.OGR_ST_SetParamNum(@c_pointer, param_number, value)
+    end
+    alias_method :set_param_as_integer, :set_param_as_number
+
+    # @param param_number [Fixnum]
+    # @return [String, nil]
+    def param_as_string(param_number)
+      value_is_null_ptr = FFI::MemoryPointer.new(:int)
+      value = FFI::OGR::API.OGR_ST_GetParamStr(@c_pointer, param_number, value_is_null_ptr)
+
+      value_is_null_ptr.read_int.to_bool ? nil : value
+    end
+
+    # @param param_number [Fixnum]
+    # @param value [String]
+    def set_param_as_string(param_number, value)
+      FFI::OGR::API.OGR_ST_SetParamStr(@c_pointer, param_number, value)
+    end
+
+    # Returns the R, G, B, A components of a #RRGGBB[AA] formatted string.
+    #
+    # @param color_string [String]
+    # @return [Hash{red => Fixnum, green => Fixnum, blue => Fixnum, alpha => Fixnum}]
+    def rgb_from_string(color_string)
+      red_ptr = FFI::MemoryPointer.new(:int)
+      green_ptr = FFI::MemoryPointer.new(:int)
+      blue_ptr = FFI::MemoryPointer.new(:int)
+      alpha_ptr = FFI::MemoryPointer.new(:int)
+
+      boolean_result = FFI::OGR::API.OGR_ST_GetRGBFromString(
+        @c_pointer,
+        color_string,
+        red_ptr,
+        green_ptr,
+        blue_ptr,
+        alpha_ptr
+      )
+
+      if boolean_result
+        {
+          red: red_ptr.read_int,
+          green: green_ptr.read_int,
+          blue: blue_ptr.read_int,
+          alpha: alpha_ptr.read_int
+        }
+      else
+        { red: nil, green: nil, blue: nil, alpha: nil }
+      end
+    end
+  end
+end

data/lib/ogr.rb

@@ -0,0 +1,8 @@
+require_relative 'ffi/ogr'
+require_relative 'ogr/internal_helpers'
+
+module OGR
+  include InternalHelpers
+
+  FFI::OGR::API.OGRRegisterAll
+end

data/spec/ffi-gdal_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'ffi-gdal'
 
-
-describe GDAL do
+RSpec.describe GDAL do
 end