ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/gdal/raster_band_extensions.rb

@@ -0,0 +1,198 @@
+require 'json'
+
+module GDAL
+  module RasterBandExtensions
+    def overviews
+      0.upto(overview_count - 1).map do |i|
+        overview(i)
+      end
+    end
+
+    # @return [Hash{x => Fixnum, y => Fixnum}]
+    def block_count
+      x_blocks = (x_size + block_size[:x] - 1) / block_size[:x]
+      y_blocks = (y_size + block_size[:y] - 1) / block_size[:y]
+
+      { x: x_blocks, y: y_blocks }
+    end
+
+    # The buffer size to use for block-based IO, based on #block_size.
+    #
+    # @return [Fixnum]
+    def block_buffer_size
+      block_size[:x] * block_size[:y]
+    end
+
+    # Reads through the raster, block-by-block and yields the pixel data that
+    # it gathered.
+    #
+    # @param to_data_type [FFI::GDAL::GDALDataType]
+    # @return [Enumerator, nil] Returns an Enumerable if no block is given,
+    #   allowing to chain with other Enumerable methods.  Returns nil if a
+    #   block is given.
+    def each_by_block(to_data_type=nil)
+      return enum_for(:each_by_block) unless block_given?
+
+      data_type = to_data_type || self.data_type
+      data_pointer = GDAL._pointer_from_data_type(data_type, block_buffer_size)
+
+      0.upto(block_count[:y] - 1).each do |y_block_number|
+        0.upto(block_count[:x] - 1).each do |x_block_number|
+          read_block(x_block_number, y_block_number, data_pointer)
+
+          0.upto(block_size[:y] - 1).each do |block_index|
+            read_offset = block_size[:x] * block_index
+            pixels = if data_type == :GDT_Byte
+              data_pointer.get_array_of_uint8(read_offset, block_size[:x])
+            else
+              data_pointer.get_array_of_float(read_offset, block_size[:x])
+            end
+
+            yield(pixels)
+          end
+        end
+      end
+    end
+
+    # Iterates through all lines and builds an NArray of pixels.
+    #
+    # @return [NArray]
+    def to_na(to_data_type=nil)
+      data_type = to_data_type || self.data_type
+
+      values = each_by_block(to_data_type).map do |pixels|
+        pixels
+      end
+
+      case data_type
+      when :GDT_Byte then NArray.to_na(values).to_type(NArray::BYTE)
+      when :GDT_UInt16 then NArray.to_na(values).to_type(NArray::SINT)
+      when :GDT_Int16 then NArray.to_na(values).to_type(NArray::SINT)
+      when :GDT_UInt32 then NArray.to_na(values).to_type(NArray::INT)
+      when :GDT_Int32 then NArray.to_na(values).to_type(NArray::INT)
+      when :GDT_Float32 then NArray.to_na(values).to_type(NArray::SFLOAT)
+      when :GDT_Float64 then NArray.to_na(values).to_type(NArray::DFLOAT)
+      when :GDT_CInt16 then NArray.to_na(values).to_type(NArray::SCOMPLEX)
+      when :GDT_CInt32 then NArray.to_na(values).to_type(NArray::DCOMPLEX)
+      when :GDT_CFloat32 then NArray.to_na(values).to_type(NArray::SCOMPLEX)
+      when :GDT_CFloat64 then NArray.to_na(values).to_type(NArray::DCOMPLEX)
+      else
+        NArray.to_na(values)
+      end
+    end
+
+    # Sets the band to be a Palette band, then applies an RGB color table using
+    # the given colors.  Colors are distributed evenly across the table based
+    # on the number of colors given.  Note that this will overwrite any existing
+    # color table that may be set on this band.
+    #
+    # @param colors [Array<Fixnum, String>, Fixnum, String] Can be a single or
+    #   many colors, given as either R, G, and B integers (0-255) or as strings
+    #   of Hex.
+    #
+    # @example Colors as RGB values
+    #   # This will make the first 128 values black, and the last 128, red.
+    #   my_band.colorize!([[0, 0, 0], [255, 0, 0]])
+    #
+    # @example Colors as Hex values
+    #   # Same as above...
+    #   my_band.colorize!(%w[#000000 #FF0000])
+    def colorize!(*colors)
+      return if colors.empty?
+
+      table = GDAL::ColorTable.create(:GPI_RGB)
+
+      color_entry_index_count = if data_type == :GDT_Byte
+        256
+      elsif data_type == :GDT_UInt16
+        65536
+      else
+        raise "Can't colorize a #{data_type} band--must be :GDT_Byte or :GDT_UInt16"
+      end
+
+      self.color_interpretation = :GCI_PaletteIndex
+      table.add_color_entry(0, 0, 0, 0, 255)
+      bin_count = (color_entry_index_count / colors.size).to_f
+
+      1.upto(color_entry_index_count - 1) do |color_entry_index|
+        color_number = (color_entry_index / bin_count.to_f).to_i
+
+        color = colors[color_number]
+        color_array = hex_to_rgb(color) unless color.is_a?(Array)
+        table.add_color_entry(color_entry_index,
+          color_array[0], color_array[1], color_array[2], 255)
+      end
+
+      self.color_table = table
+    end
+
+
+    # Gets the colors from the associated ColorTable and returns an Array of
+    # those, where each ColorEntry is [R, G, B, A].
+    #
+    # @return [Array<Array<Fixnum>>]
+    def colors_as_rgb
+      return [] unless color_table
+
+      color_table.color_entries_as_rgb.map do |color_entry|
+        color_entry.to_a
+      end
+    end
+
+    # Gets the colors from the associated ColorTable and returns an Array of
+    # Strings, where the RGB color for each ColorEntry has been converted to
+    # Hex.
+    #
+    # @return [Array<String>]
+    def colors_as_hex
+      colors_as_rgb.map do |rgba|
+        rgb = rgba.to_a[0..2]
+
+        "##{rgb[0].to_s(16)}#{rgb[1].to_s(16)}#{rgb[2].to_s(16)}"
+      end
+    end
+
+    # @param hex [String]
+    def hex_to_rgb(hex)
+      hex.sub!(/^#/, '')
+      matches = hex.match(/(?<red>[a-zA-Z0-9]{2})(?<green>[a-zA-Z0-9]{2})(?<blue>[a-zA-Z0-9]{2})/)
+
+      [matches[:red].to_i(16), matches[:green].to_i(16), matches[:blue].to_i(16)]
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        raster_band: {
+          block_size: block_size,
+          category_names: category_names,
+          color_interpretation: color_interpretation,
+          color_table: color_table,
+          data_type: data_type,
+          default_histogram: default_histogram(true),
+          default_raster_attribute_table: default_raster_attribute_table,
+          has_arbitrary_overviews: arbitrary_overviews?,
+          mask_flags: mask_flags,
+          maximum_value: maximum_value,
+          minimum_value: minimum_value,
+          no_data_value: no_data_value,
+          number: number,
+          offset: offset,
+          overview_count: overview_count,
+          overviews: overviews,
+          scale: scale,
+          statistics: statistics,
+          unit_type: unit_type,
+          x_size: x_size,
+          y_size: y_size
+        },
+        metadata: all_metadata
+      }
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+  end
+end

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

@@ -44,5 +44,13 @@ module GDAL
     def long_version
       FFI::GDAL.GDALVersionInfo('--version')
     end
+
+    # @param major [Fixnum]
+    # @param minor [Fixnum]
+    # @return [Boolean] +true+ if the runtime GDAL library matches the given
+    #   version params.
+    def check_version(major, minor)
+      FFI::GDAL.GDALCheckVersion(major, minor, 'FFI::GDAL')
+    end
   end
 end

data/lib/gdal/warp_operation.rb

@@ -0,0 +1,96 @@
+module GDAL
+  class WarpOperation
+    def initialize(warp_options)
+      @warp_operation_pointer = FFI::GDAL.GDALCreateWarpOperation(warp_options.ptr)
+    end
+
+    def c_pointer
+      @warp_operation_pointer
+    end
+
+    def destroy!
+      FFI::GDAL.GDALDestroyWarpOperation(@warp_operation_pointer)
+    end
+
+    # @param x_offset [Fixnum] X offset of the destination image.
+    # @param y_offset [Fixnum] Y offset of the destination image.
+    # @param x_size [Fixnum] X size (width) of the destination image.
+    # @param y_size [Fixnum] Y size (height) of the destination image.
+    def chunk_and_warp_image(x_offset, y_offset, x_size, y_size)
+      cpl_err = FFI::GDAL.GDALChunkAndWarpImage(@warp_operation_pointer,
+        x_offset,
+        y_offset,
+        x_size,
+        y_size)
+
+      cpl_err.to_bool
+    end
+
+    # @param x_offset [Fixnum] X offset of the destination image.
+    # @param y_offset [Fixnum] Y offset of the destination image.
+    # @param x_size [Fixnum] X size (width) of the destination image.
+    # @param y_size [Fixnum] Y size (height) of the destination image.
+    # @todo Implement
+    def chunk_and_warp_multi(x_offset, y_offset, x_size, y_size)
+      raise NotImplementedError, '#chunk_and_warp_multi not yet implemented.'
+
+      FFI::GDAL.GDALChunkAndWarpMulti(@warp_operation_pointer,
+      )
+    end
+
+    # @param destination_x_offset [Fixnum] X offset of the destination image.
+    # @param destination_y_offset [Fixnum] Y offset of the destination image.
+    # @param destination_x_size [Fixnum] X size (width) of the destination image.
+    # @param destination_y_size [Fixnum] Y size (height) of the destination image.
+    # @param source_x_offset [Fixnum] X offset of the source image.
+    # @param source_y_offset [Fixnum] Y offset of the source image.
+    # @param source_x_size [Fixnum] X size (width) of the source image.
+    # @param source_y_size [Fixnum] Y size (height) of the source image.
+    def warp_region(destination_x_offset, destination_y_offset,
+      destination_x_size, destination_y_size,
+      source_x_offset, source_y_offset,
+      source_x_size, source_y_size)
+      cpl_err = FFI::GDAL.GDALWarpRegion(@warp_operation_pointer,
+        destination_x_offset,
+        destination_y_offset,
+        destination_x_size,
+        destination_y_size,
+        source_x_offset,
+        source_y_offset,
+        source_x_size,
+        source_y_size)
+
+      cpl_err.to_bool
+    end
+
+    # @param destination_x_offset [Fixnum] X offset of the destination image.
+    # @param destination_y_offset [Fixnum] Y offset of the destination image.
+    # @param destination_x_size [Fixnum] X size (width) of the destination image.
+    # @param destination_y_size [Fixnum] Y size (height) of the destination image.
+    # @param buffer [FFI::Pointer]
+    # @param data_type [FFI::GDAL::GDALDataType]
+    # @param source_x_offset [Fixnum] X offset of the source image.
+    # @param source_y_offset [Fixnum] Y offset of the source image.
+    # @param source_x_size [Fixnum] X size (width) of the source image.
+    # @param source_y_size [Fixnum] Y size (height) of the source image.
+    def warp_region_to_buffer(destination_x_offset, destination_y_offset,
+      destination_x_size, destination_y_size,
+      buffer, data_type,
+      source_x_offset, source_y_offset,
+      source_x_size, source_y_size)
+      cpl_err = FFI::GDAL.GDALWarpRegionToBuffer(@warp_operation_pointer,
+        destination_x_offset,
+        destination_y_offset,
+        destination_x_size,
+        destination_y_size,
+        buffer,
+        data_type,
+        source_x_offset,
+        source_y_offset,
+        source_x_size,
+        source_y_size)
+
+      cpl_err.to_bool
+    end
+  end
+end

data/lib/ogr/coordinate_transformation.rb

@@ -0,0 +1,108 @@
+require 'narray'
+require_relative '../ffi/ogr'
+
+module OGR
+  class CoordinateTransformation
+
+    # @param source_srs [OGR::SpatialReference, FFI::Pointer]
+    # @param destination_srs [OGR::SpatialReference, FFI::Pointer]
+    # @return [OGR::CoordinateTransformation]
+    def self.create(source_srs, destination_srs)
+      source_ptr = GDAL._pointer(OGR::SpatialReference, source_srs)
+      destination_ptr = GDAL._pointer(OGR::SpatialReference, destination_srs)
+      ct_ptr = FFI::GDAL.OCTNewCoordinateTransformation(source_ptr, destination_ptr)
+      return nil if ct_ptr.null?
+
+      source = if source_srs.is_a?(OGR::SpatialReference)
+        source_srs
+      else
+        OGR::SpatialReference.new(source_srs)
+      end
+
+      destination = if destination_srs.is_a?(OGR::SpatialReference)
+        destination_srs
+      else
+        OGR::SpatialReference.new(destination_srs)
+      end
+
+      new(ct_ptr, source, destination)
+    end
+
+    # @param proj4_source [String]
+    # @return [String]
+    def self.proj4_normalize(proj4_source)
+      if GDAL._supported?(:OCTProj4Normalize)
+        FFI::GDAL.OCTProj4Normalize(proj4_source)
+      end
+    end
+
+    # @return [OGR::SpatialReference]
+    attr_reader :source_coordinate_system
+
+    # @return [OGR::SpatialReference]
+    attr_reader :destination_coordinate_system
+
+    # @param coordinate_transformation [OGR::CoordinateTransformation,
+    #   FFI::Pointer]
+    def initialize(coordinate_transformation, source, destination)
+      @transformation_pointer = GDAL._pointer(OGR::CoordinateTransformation,
+        coordinate_transformation)
+      @source_coordinate_system = source
+      @destination_coordinate_system = destination
+
+      close_me = -> { destroy! }
+      ObjectSpace.define_finalizer self, close_me
+    end
+
+    def c_pointer
+      @transformation_pointer
+    end
+
+    # Deletes the object and deallocates all related resources.
+    def destroy!
+      FFI::GDAL.OCTDestroyCoordinateTransformation(@transformation_pointer)
+    end
+
+    # Transforms points in the +source_srs+ space to points in the
+    # +destination_space+ (given in .create).
+    #
+    # @param x_vertices [Array<Float>]
+    # @param y_vertices [Array<Float>]
+    # @param z_vertices [Array<Float>]
+    # @return [Array<Array<Float>,Array<Float>,Array<Float>>] [[x1, y1], [x2,
+    #   y2], etc]
+    def transform(x_vertices, y_vertices, z_vertices=[])
+      x_ptr = FFI::MemoryPointer.new(:pointer, x_vertices.size)
+      x_ptr.write_array_of_double(x_vertices)
+      y_ptr = FFI::MemoryPointer.new(:pointer, y_vertices.size)
+      y_ptr.write_array_of_double(y_vertices)
+
+      if z_vertices.empty?
+        z_ptr = nil
+      else
+        z_ptr = FFI::MemoryPointer.new(:pointer, z_vertices.size)
+        z_ptr.write_array_of_double(z_vertices)
+      end
+
+      point_count = x_vertices.size + y_vertices.size + z_vertices.size
+
+      result = FFI::GDAL.OCTTransform(@transformation_pointer, point_count,
+        x_ptr, y_ptr, z_ptr)
+
+      # maybe this should raise?
+      return false unless result
+
+      x_vals = x_ptr.read_array_of_double
+      y_vals = y_ptr.read_array_of_double
+      z_vals = z_ptr.read_array_of_double unless z_vertices.empty?
+
+      points = if z_vertices.empty?
+                 NMatrix[x_vals, y_vals]
+               else
+                 NMatrix[x_vals, y_vals, z_vals]
+               end
+
+      points.transpose.to_a
+    end
+  end
+end

data/lib/ogr/data_source.rb

@@ -0,0 +1,172 @@
+require 'uri'
+require 'json'
+require_relative '../ffi/gdal'
+require_relative '../ffi/ogr'
+require_relative 'data_source_extensions'
+require_relative 'exceptions'
+require_relative 'layer'
+require_relative 'style_table'
+
+
+module OGR
+  class DataSource
+    include GDAL::MajorObject
+    include GDAL::Logger
+    include DataSourceExtensions
+
+    # @param path [String] Path/URL to the file to open.
+    # @param access_flag [String] 'r' for read, 'w', for write.
+    # @return [OGR::DataSource]
+    def self.open(path, access_flag = 'r')
+      uri = URI.parse(path)
+      file_path = uri.scheme.nil? ? ::File.expand_path(path) : path
+
+      pointer = FFI::GDAL.OGROpen(file_path, OGR._boolean_access_flag(access_flag), nil)
+      raise OGR::OpenFailure.new(file_path) if pointer.null?
+
+      new(pointer)
+    end
+
+    # @param data_source_pointer [FFI::Pointer]
+    def initialize(data_source_pointer)
+      @data_source_pointer = data_source_pointer
+      @file_name = name
+      @layers = []
+
+      close_me = -> { destroy }
+      ObjectSpace.define_finalizer self, close_me
+    end
+
+    def c_pointer
+      @data_source_pointer
+    end
+
+    def reopen(access_flag)
+      if driver.name == 'Memory'
+        raise "Can't reopen DataSources that were created and closed using the 'Memory' driver."
+      end
+
+      @data_source_pointer = FFI::GDAL.OGROpen(@file_path,
+        OGR._boolean_access_flag(access_flag), nil)
+    end
+
+    # Closes opened data source and releases allocated resources.
+    def destroy
+      FFI::GDAL.OGR_DS_Destroy(@data_source_pointer)
+    end
+    alias_method :close, :destroy
+
+    # Name of the file represented by this object.
+    #
+    # @return [String]
+    def name
+      FFI::GDAL.OGR_DS_GetName(@data_source_pointer)
+    end
+
+    # @return [OGR::Driver]
+    def driver
+      return @driver if @driver
+
+      driver_ptr = FFI::GDAL.OGR_DS_GetDriver(@data_source_pointer)
+      return nil if driver_ptr.nil?
+
+      @driver = OGR::Driver.new(driver_ptr)
+    end
+
+    # @return [Fixnum]
+    def layer_count
+      FFI::GDAL.OGR_DS_GetLayerCount(@data_source_pointer)
+    end
+
+    # @param index [Fixnum] 0-offset index of the layer to retrieve.
+    # @return [OGR::Layer]
+    def layer(index)
+      @layers.fetch(index) do
+        layer_pointer = FFI::GDAL.OGR_DS_GetLayer(@data_source_pointer, index)
+        return nil if layer_pointer.null?
+
+        l = OGR::Layer.new(layer_pointer)
+        @layers.insert(index, l)
+
+        l
+      end
+    end
+
+    # @param name [String]
+    # @return [OGR::Layer]
+    def layer_by_name(name)
+      layer_pointer = FFI::GDAL.OGR_DS_GetLayerByName(@data_source_pointer, name)
+      return nil if layer_pointer.null?
+
+      OGR::Layer.new(layer_pointer)
+    end
+
+    # @param name [String] The name for the new layer.
+    # @param geometry_type [FFI::GDAL::OGRwkbGeometryType]
+    # @param spatial_reference [OGR::SpatialReference] The coordinate system
+    #   to use for the new layer or nil if none is available.
+    # @return [OGR::Layer]
+    def create_layer(name, geometry_type: :wkbUnknown, spatial_reference: nil, **options)
+      spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, spatial_reference)
+      options_obj = GDAL::Options.pointer(options)
+
+      layer_ptr = FFI::GDAL.OGR_DS_CreateLayer(@data_source_pointer, name,
+        spatial_ref_ptr, geometry_type, options_obj)
+
+      return nil if layer_ptr.null?
+
+      OGR::Layer.new(layer_ptr)
+    end
+
+    # @param source_layer [OGR::Layer, FFI::Pointer]
+    # @param new_name [String]
+    # @param options [Hash]
+    # @return [OGR::Layer, nil]
+    def copy_layer(source_layer, new_name, **options)
+      source_layer_ptr = GDAL._pointer(OGR::Layer, source_layer)
+      options_ptr = GDAL::Options.pointer(options)
+
+      layer_ptr = FFI::GDAL.OGR_DS_CopyLayer(@data_source_pointer, source_layer_ptr,
+        new_name, options_ptr)
+      return nil if layer_ptr.null?
+
+      OGR::Layer.new(layer_ptr)
+    end
+
+    # @param index [Fixnum]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def delete_layer(index)
+      ogr_err = FFI::GDAL.OGR_DS_DeleteLayer(@data_source_pointer, index)
+
+      ogr_err.to_ruby
+    end
+
+    # @param command [String] The SQL to execute.
+    # @param spatial_filter [OGR::Geometry, FFI::Pointer]
+    # @param dialect [String] Can pass in 'SQLITE' to use that instead of the
+    #   default OGRSQL dialect.
+    # @return [OGR::Layer, nil]
+    # @see http://www.gdal.org/ogr_sql.html
+    # TODO: not sure how to handle the call to OGR_DS_ReleaseResultSet here...
+    def execute_sql(command, spatial_filter=nil, dialect=nil)
+      geometry_ptr = GDAL._pointer(OGR::Geometry, spatial_filter)
+
+      layer_ptr = FFI::GDAL.OGR_DS_ExecuteSQL(@data_source_pointer, command, geometry_ptr,
+        dialect)
+
+      return nil if layer_ptr.null?
+
+      OGR::Layer.new(layer_ptr)
+    end
+
+    # @return [OGR::StyleTable, nil]
+    def style_table
+      return @style_table if @style_table
+
+      style_table_ptr = FFI::GDAL.OGR_DS_GetStyleTable(@data_source_pointer)
+      return nil if style_table_ptr.null?
+
+      @style_table = OGR::StyleTable.new(style_table_ptr)
+    end
+  end
+end