ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/gdal/geo_transform_extensions.rb

@@ -0,0 +1,90 @@
+require 'json'
+
+module GDAL
+  module GeoTransformExtensions
+
+    # The calculated UTM easting of the pixel on the map.
+    #
+    # @return [Float]
+    def x_projection(x_pixel, y_pixel)
+      return nil if null?
+
+      apply_geo_transform(x_pixel, y_pixel)[:x_location]
+    end
+
+    # The calculated UTM northing of the pixel on the map.
+    #
+    # @return [Float]
+    def y_projection(x_pixel, y_pixel)
+      return nil if null?
+
+      apply_geo_transform(x_pixel, y_pixel)[:y_location]
+    end
+
+    # The algorithm per http://www.gdal.org/gdal_datamodel.html.
+    def pixel_to_world(pixel, line)
+      x_geo = x_origin + (pixel * pixel_width) + (line * x_rotation)
+      y_geo = y_origin + (pixel * pixel_height) + (line * y_rotation)
+
+      { longitude: y_geo, latitude: x_geo }
+    end
+
+    # Adapted from "Advanced Geospatial Python Modeling".  Calculates the
+    # pixel location of a geospatial coordinate.
+    #
+    # @param lon [Fixnum]
+    # @param lat [Fixnum]
+    # @param value_type [Symbol] Data type to return: :float or :integer.
+    # @return [Hash<x, y>] [pixel, line]
+    def world_to_pixel(lon, lat, value_type=:float)
+      pixel = (lon - x_origin) / pixel_width
+      line = (y_origin - lat) / pixel_height
+
+      case value_type
+      when :float
+        { x: pixel.to_f, y: line.to_f }
+      when :integer
+        { x: pixel.to_i, y: line.to_i }
+      else
+        { x: pixel, y: line }
+      end
+    end
+
+    # All attributes as an Array, in the order:
+    #   * x_origin
+    #   * pixel_width
+    #   * x_rotation
+    #   * y_origin
+    #   * y_rotation
+    #   * pixel_height
+    #
+    # @return [Array]
+    def to_a
+      [
+        x_origin,
+        pixel_width,
+        x_rotation,
+        y_origin,
+        y_rotation,
+        pixel_height
+      ]
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        x_origin: x_origin,
+        x_rotation: x_rotation,
+        pixel_width: pixel_width,
+        y_origin: y_origin,
+        y_rotation: y_rotation,
+        pixel_height: pixel_height
+      }
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/gdal/logger.rb

@@ -0,0 +1,7 @@
+require 'log_switch'
+
+module GDAL
+  module Logger
+    include LogSwitch
+  end
+end

data/lib/{ffi-gdal → gdal}/major_object.rb

@@ -3,19 +3,14 @@ require_relative '../ffi/gdal'
 
 module GDAL
   module MajorObject
-    include FFI::GDAL
-
     # @return [Array<String>]
     def metadata_domain_list
-      unless defined? FFI::GDAL::GDALGetMetadataDomainList
+      unless defined? FFI::GDAL.GDALGetMetadataDomainList
         warn "GDALGetMetadataDomainList is't defined. GDAL::MajorObject#metadata_domain_list disabled."
         return []
       end
 
-      # I don't quite get it, but if #GDALGetMetadataDomainList isn't called
-      # twice, the last domain in the list sometimes doesn't get read.
-      GDALGetMetadataDomainList(c_pointer)
-      list_pointer = GDALGetMetadataDomainList(c_pointer)
+      list_pointer = FFI::GDAL.GDALGetMetadataDomainList(c_pointer)
       return [] if list_pointer.null?
 
       strings = list_pointer.get_array_of_string(0)
@@ -25,8 +20,8 @@ module GDAL
 
     # @param domain [String] Name of the domain to get metadata for.
     # @return [Hash]
-    def metadata_for_domain(domain='')
-      m = GDALGetMetadata(c_pointer, domain)
+    def metadata(domain='')
+      m = FFI::GDAL.GDALGetMetadata(c_pointer, domain)
       return {} if m.null?
 
       data_array = m.get_array_of_string(0)
@@ -46,27 +41,33 @@ module GDAL
     # @param domain [String]
     # @return [String]
     def metadata_item(name, domain='')
-      GDALGetMetadataItem(c_pointer, name, domain)
+      FFI::GDAL.GDALGetMetadataItem(c_pointer, name, domain)
+    end
+
+    def set_metadata_item(name, value, domain='')
+      cpl_err = FFI::GDAL.GDALSetMetadataItem(c_pointer, name, value.to_s, domain)
+
+      cpl_err.to_bool
     end
 
     # @return [Hash{domain => Array<String>}]
     def all_metadata
       sub_metadata = metadata_domain_list.each_with_object({}) do |subdomain, obj|
-        metadata_array = metadata_for_domain(subdomain)
+        metadata_array = metadata(subdomain)
         obj[subdomain] = metadata_array
       end
 
-      { DEFAULT: metadata_for_domain }.merge(sub_metadata)
+      { DEFAULT: metadata }.merge(sub_metadata)
     end
 
     # @return [String]
     def description
-      GDALGetDescription(c_pointer)
+      FFI::GDAL.GDALGetDescription(c_pointer)
     end
 
     # @param new_description [String]
     def description=(new_description)
-      GDALSetDescription(c_pointer, new_description.to_s)
+      FFI::GDAL.GDALSetDescription(c_pointer, new_description.to_s)
     end
 
     def null?

data/lib/gdal/options.rb

@@ -0,0 +1,49 @@
+require 'ffi'
+
+
+module GDAL
+  # A wrapper for the way GDAL does key/value pair options for methods.
+  class Options < Hash
+    # Shortcut for if you just want to build the options and get the pointer to
+    # them.
+    #
+    # @param hash [Hash]
+    # @return [FFI::MemoryPointer, nil]
+    def self.pointer(hash)
+      hash.empty? ? nil : new(hash).c_pointer
+    end
+
+    def initialize(hash={})
+      super()
+      capitalize_keys!(hash)
+    end
+
+    # @return [FFI::MemoryPointer] The double-char pointer that contains the
+    #   options for GDAL to use.
+    def c_pointer
+      options_ptr = FFI::MemoryPointer.new(:pointer, self.size)
+
+      self.each do |key, value|
+        options_ptr = FFI::GDAL.CSLSetNameValue(options_ptr, key, value)
+      end
+
+      options_ptr
+    end
+
+    # def to_s
+    #   options_ptr = to_gdal
+    #   options_array = options_ptr.read_array_of_pointer(self.size)
+    #
+    #   0.upto(self.size).map do |i|
+    #     options_array[i].first.read_string
+    #   end
+    # end
+    private
+
+    def capitalize_keys!(hash)
+      hash.each_with_object(self) do |(key, value), obj|
+        obj[key.to_s.upcase] = value
+      end
+    end
+  end
+end

data/lib/gdal/raster_attribute_table.rb

@@ -0,0 +1,185 @@
+require_relative '../ffi/gdal'
+require_relative 'raster_attribute_table_extensions'
+
+
+module GDAL
+  class RasterAttributeTable
+    include RasterAttributeTableExtensions
+
+    # @return [GDAL::RasterAttributeTable]
+    def self.create
+      raster_attribute_table_ptr = FFI::GDAL.GDALCreateRasterAttributeTable
+
+      new(raster_attribute_table_ptr)
+    end
+
+    # Create an object from a ColorTable.
+    #
+    # @param color_table [GDAL::ColorTable, FFI::Pointer]
+    # @return [GDAL::RasterAttributeTable]
+    def self.from_color_table(color_table)
+      color_table_ptr = GDAL._pointer(GDAL::ColorTable, color_table)
+      rat_ptr = FFI::GDAL.GDALCreateRasterAttributeTable
+      cpl_err = FFI::GDAL.GDALRATInitializeFromColorTable(rat_ptr, color_table_ptr)
+      cpl_err.to_bool
+
+      new(rat_ptr)
+    end
+
+    # @param raster_attribute_table [GDAL::RasterAttributeTable, FFI::Pointer]
+    def initialize(raster_attribute_table=nil)
+      @rat_pointer = GDAL._pointer(GDAL::RasterAttributeTable, raster_attribute_table)
+    end
+
+    def destroy!
+      FFI::GDAL.GDALDestroyRasterAttributeTable(@rat_pointer)
+    end
+
+    def c_pointer
+      @rat_pointer
+    end
+
+    # Clone using the C API.
+    #
+    # @return [GDAL::RasterAttributeTable]
+    def clone
+      rat_ptr = FFI::GDAL.GDALRATClone(@rat_pointer)
+      return nil if rat_ptr.null?
+
+      self.class.new(rat_ptr)
+    end
+
+    # +true+ if the changes made to this RAT have been written to the associated
+    # dataset.
+    #
+    # @return [Boolean]
+    def changes_written_to_file?
+      FFI::GDAL.GDALRATChangesAreWrittenToFile(@rat_pointer)
+    end
+
+    # @return [Fixnum]
+    def column_count
+      FFI::GDAL.GDALRATGetColumnCount(@rat_pointer)
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [String]
+    def column_name(index)
+      FFI::GDAL.GDALRATGetNameOfCol(@rat_pointer, index)
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [GDALRATFieldUsage]
+    def column_usage(index)
+      FFI::GDAL.GDALRATGetUsageOfCol(@rat_pointer, index)
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [GDALRATFieldType]
+    def column_type(index)
+      FFI::GDAL.GDALRATGetTypeOfCol(@rat_pointer, index)
+    end
+
+    # @param field_usage [GDALRATFieldUsage]
+    # @return [Fixnum] The column number.
+    def column_of_usage(field_usage)
+      FFI::GDAL.GDALRATGetColOfUsage(@rat_pointer, field_usage)
+    end
+
+    # @param name [String]
+    # @param type [FFI::GDALRATFieldType]
+    # @param usage [FFI::GDALRATFieldUsage]
+    # @return [Boolean]
+    def create_column(name, type, usage)
+      cpl_err = FFI::GDAL.GDALRATCreateColumn(@rat_pointer, name, type, usage)
+
+      cpl_err.to_bool
+    end
+
+    # @return [Fixnum] The number of rows.
+    def row_count
+      FFI::GDAL.GDALRATGetRowCount(@rat_pointer)
+    end
+
+    # @return [Fixnum] The number of rows.
+    def row_count=(count)
+      FFI::GDAL.GDALRATSetRowCount(@rat_pointer, count)
+    end
+
+    # Get the row for a pixel value.
+    #
+    # @param value [Float]
+    # @return [Fixnum]
+    def row_of_value(value)
+      FFI::GDAL.GDALRATGetRowOfValue(@rat_pointer, value)
+    end
+
+    # @param row [Fixnum]
+    # @param field [Fixnum]
+    # @return [String]
+    def value_to_s(row, field)
+      FFI::GDAL.GDALRATGetValueAsString(@rat_pointer, row, field)
+    end
+
+    # @param row [Fixnum]
+    # @param field [Fixnum]
+    # @return [Fixnum]
+    def value_to_i(row, field)
+      FFI::GDAL.GDALRATGetValueAsInt(@rat_pointer, row, field)
+    end
+
+    # @param row [Fixnum]
+    # @param field [Fixnum]
+    # @return [Float]
+    def value_to_f(row, field)
+      FFI::GDAL.GDALRATGetValueAsDouble(@rat_pointer, row, field)
+    end
+
+    # @param row [Fixnum]
+    # @param field [Fixnum]
+    # @param value [String, Float, Fixnum]
+    def add_value(row, field, value)
+      case value.class.name
+      when 'String'
+        FFI::GDAL.GDALRATSetValueAsString(@rat_pointer, row, field, value)
+      when 'Float'
+        FFI::GDAL.GDALRATSetValueAsDouble(@rat_pointer, row, field, value)
+      when 'Fixnum'
+        FFI::GDAL.GDALRATSetValueAsInt(@rat_pointer, row, field, value)
+      else
+        raise "Unknown value type for value '#{value}'"
+      end
+    end
+
+    # @return [Hash{row_0_minimum => Float, bin_size => Float}]
+    def linear_binning
+      row_0_min_ptr = FFI::MemoryPointer.new(:double)
+      bin_size_ptr = FFI::MemoryPointer.new(:double)
+      FFI::GDAL.GDALRATGetLinearBinning(@rat_pointer, row_0_min_ptr, bin_size_ptr)
+
+      {
+        row_0_minimum: row_0_min_ptr.read_double,
+        bin_size: bin_size_ptr.read_double
+      }
+    end
+
+    # @param entry_count [Fixnum] The number of entries to produce.  The default
+    #   will try to auto-determine the number.
+    # @return [GDAL::ColorTable]
+    def to_color_table(entry_count = -1)
+      color_table_pointer = FFI::GDAL.GDALRATTranslateToColorTable(@rat_pointer, entry_count)
+
+      GDAL::ColorTable.new(color_table_pointer)
+    end
+
+    # @param file_path [String]
+    def dump_readable(file_path=nil)
+      file = if file_path
+        File.open(file_path, 'r')
+      else
+        file_path
+      end
+      FFI::GDAL.GDALRATDumpReadable(@rat_pointer, file)
+    end
+  end
+end

data/lib/gdal/raster_attribute_table_extensions.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module GDAL
+  module RasterAttributeTableExtensions
+
+    # Get +column_name+, +column_usage+, +column_type+ as a Hash.
+    #
+    # @param index [Fixnum]
+    # @return [Hash]
+    def column(index)
+      {
+        name: column_name(index),
+        usage: column_usage(index),
+        type: column_type(index)
+      }
+    end
+
+    # @return [Array<Hash>]
+    def columns
+      0.upto(column_count - 1).map do |i|
+        column(i)
+      end
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        column_count: column_count,
+        columns: columns,
+        linear_binning: linear_binning,
+        row_count: row_count
+      }
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+  end
+end