ffi-gdal 1.0.0.beta16 → 1.0.0

data/lib/ogr/extensions/geometry/wkb_record.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'bindata'
+require 'ffi-gdal'
+require 'ogr'
+
+module OGR
+  module Geometry
+    # Parses raw WKB and turns into a data structure. Only really exists for
+    # converting to and from EWKB.
+    #
+    # @see OGR::Geometry::EWKBRecord
+    class WKBRecord < BinData::Record
+      uint8 :endianness, assert: -> { [0, 1].include?(value) }
+
+      # Choose the type based on the endianness
+      choice :wkb_type, selection: :endianness do
+        uint32be 0
+        uint32le 1
+      end
+
+      # Make sure the geometry_type is one OGR knows about.
+      virtual assert: -> { FFI::OGR::Core::WKBGeometryType.symbol_map.value?(geometry_type) }
+
+      # The #geometry attribute is just the rest of the data. We don't care what
+      # kind of geom it actually is; that doesn't matter for building EWKB.
+      rest :geometry
+
+      WKB_Z = 0x8000_0000
+
+      # @param ewkb_record [OGR::Geometry::EWKBRecord]
+      # @return [OGR::Geometry::WKBRecord]
+      def self.from_ewkb_record(ewkb_record)
+        new(endianness: ewkb_record.endianness,
+            wkb_type: ewkb_record.geometry_type,
+            geometry: ewkb_record.geometry)
+      end
+
+      # @param ewkb_data [String] Binary string with the EWKB data.
+      # @return [OGR::Geometry::WKBRecord]
+      def self.from_ewkb(ewkb_data)
+        from_ewkb_record(EWKBRecord.read(ewkb_data))
+      end
+
+      # @return [Boolean] Is the Z flag set?
+      def has_z? # rubocop:disable Naming/PredicateName
+        geometry_type & WKB_Z != 0
+      end
+
+      # @return [Fixnum] Enum number that matches the FFI::OGR::Core::WKBGeometryType.
+      #   Defined to keep the API consistent with EWKBRecord.
+      def geometry_type
+        # ISO SQL/MM style Z types are between 1001 and 1007
+        if wkb_type.value >= 1001 && wkb_type.value <= 1007
+          raw_type_int = wkb_type.value - 1000
+          raw_type_int | WKB_Z
+        else
+          wkb_type.value
+        end
+      end
+    end
+  end
+end

data/lib/ogr/extensions/geometry_types/curve/extensions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'ogr/geometry'
+require 'gdal/extensions/geo_transform/extensions'
+
+module OGR
+  module GeometryTypes
+    module Curve
+      module Extensions
+        # It seems as if {{#point}} should return an OGR::Point, but since OGR's
+        # OGR_G_GetPoint only returns coordinates, this allows getting the point
+        # as an OGR::Point.
+        #
+        # @param number [Integer] Index of the point to get.
+        # @return [OGR::Point]
+        def point_geometry(number)
+          coords = point(number)
+          point = OGR::Point.new
+          point.set_point(0, *coords)
+
+          point
+        end
+
+        # @return [Enumerator]
+        # @yieldparam [OGR::Point]
+        def each_point_geometry
+          return enum_for(:each_point_geometry) unless block_given?
+
+          point_count.times do |point_num|
+            yield point_as_geometry(point_num)
+          end
+        end
+
+        # @return [Array<OGR::Point>]
+        # @see #each_point_geometry, #point_geometry
+        def point_geometries
+          each_point_geometry.to_a
+        end
+
+        # @param geo_transform [GDAL::GeoTransform]
+        # @return [Array<Array>]
+        def pixels(geo_transform)
+          log "points count: #{point_count}"
+          points.map do |x_and_y|
+            result = geo_transform.world_to_pixel(*x_and_y)
+
+            [result[:pixel].to_i.abs, result[:line].to_i.abs]
+          end
+        end
+
+        def start_point
+          point(0)
+        end
+
+        def end_point
+          point(point_count - 1)
+        end
+
+        def closed?
+          start_point == end_point
+        end
+      end
+    end
+  end
+end
+
+OGR::LineString.include(OGR::GeometryTypes::Curve::Extensions)
+OGR::MultiLineString.include(OGR::GeometryTypes::Curve::Extensions)

data/lib/ogr/{layer_mixins → extensions/layer}/capability_methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'ogr/layer'
+
 module OGR
   module LayerMixins
     # Helper methods for checking what the Layer is capable of.
@@ -102,3 +104,5 @@ module OGR
     end
   end
 end
+
+OGR::Layer.include(OGR::LayerMixins::CapabilityMethods)

data/lib/ogr/{layer_mixins → extensions/layer}/extensions.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'json'
+require 'ogr/layer'
 
 module OGR
-  module LayerMixins
+  class Layer
     # Methods not part of the C Layer API.
     module Extensions
       # Enumerates through all associated features. Beware: it calls
       # {#reset_reading} both before and after it's called. If you're using
-      # {OGR::Layer#next_feature} for iterating through features somewhere in
+      # {OGR::LayerMixins::OGRFeatureMethods#next_feature} for iterating through features somewhere in
       # your code, this will reset that reading.
       #
       # @return [Enumerator]
@@ -115,7 +115,7 @@ module OGR
         return [] if feature_count.zero?
 
         field_indices = with_attributes.keys.map { |field_name| find_field_index(field_name) }
-        values = Array.new(feature_count) { Array.new(2 + with_attributes.size) }
+        values = Array.new(feature_count) { Array.new(with_attributes.size + 2) }
         start = Time.now
         i = 0
 
@@ -128,7 +128,7 @@ module OGR
         # I've tried refactoring chunks of this out to separate methods and
         # performance suffers greatly. Since this is a key part of gridding (at
         # least at this point), it needs to be as fast as possible.
-        each_feature_pointer do |feature_ptr|
+        each_feature_pointer do |feature_ptr| # rubocop:todo Metrics/BlockLength
           field_values = field_indices.map.with_index do |j, attribute_index|
             FFI::OGR::API.send("OGR_F_GetFieldAs#{with_attributes.values[attribute_index].capitalize}", feature_ptr, j)
           end
@@ -160,6 +160,7 @@ module OGR
 
             count.times do |ring_num|
               next if ring_num.zero?
+
               ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(geom_ptr, ring_num)
 
               extract_ring_points(ring_ptr, x_ptr, y_ptr) do |points|
@@ -197,6 +198,7 @@ module OGR
 
               count.times do |ring_num|
                 next if ring_num.zero?
+
                 ring_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(polygon_ptr, ring_num)
                 ring_ptr.autorelease = false
 
@@ -207,7 +209,7 @@ module OGR
               end
             end
           else raise OGR::UnsupportedGeometryType,
-            "Not sure how to extract point_values for a #{geom_type}"
+                     "Not sure how to extract point_values for a #{geom_type}"
           end
         end
 
@@ -224,6 +226,7 @@ module OGR
 
         each_feature_pointer do |feature_ptr|
           break if found_z_geom
+
           geom_ptr = FFI::OGR::API.OGR_F_GetGeometryRef(feature_ptr)
           geom_ptr.autorelease = false
           coordinate_dimension = FFI::OGR::API.OGR_G_GetCoordinateDimension(geom_ptr)
@@ -264,3 +267,5 @@ module OGR
     end
   end
 end
+
+OGR::Layer.include(OGR::Layer::Extensions)

data/lib/ogr/extensions/spatial_reference/extensions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'ogr/spatial_reference'
+
+module OGR
+  class SpatialReference
+    module Extensions
+      # @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
+    end
+  end
+end
+
+OGR::SpatialReference.include(OGR::SpatialReference::Extensions)

data/lib/ogr/extensions/spatial_reference/initializers.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'ogr/spatial_reference'
+
+module OGR
+  module SpatialReferenceMixins
+    module Initializers
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # @param code [Integer]
+        # @return [OGR::SpatialReference]
+        def new_from_epsg(code)
+          srs = new
+          srs.import_from_epsg(code)
+
+          srs
+        end
+
+        # @param code [Integer]
+        # @return [OGR::SpatialReference]
+        def new_from_epsga(code)
+          srs = new
+          srs.import_from_epsga(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]
+        # @raise [OGR::Failure]
+        def build_spatial_ref(spatial_reference_or_wkt = nil)
+          object = new(spatial_reference_or_wkt)
+          ogr_err = yield object.c_pointer
+
+          OGR::ErrorHandling.handle_ogr_err('Unable to build SpatialReference') do
+            ogr_err
+          end
+
+          object
+        end
+      end
+    end
+  end
+end
+
+OGR::SpatialReference.include(OGR::SpatialReferenceMixins::Initializers)

data/lib/ogr/extensions/style_table/extensions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'ogr/style_table'
+
+module OGR
+  class StyleTable
+    module Extensions
+      # 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
+
+        loop do
+          style = next_style
+          break unless style
+
+          styles[last_style_name] = style
+        end
+
+        reset_style_string_reading
+
+        styles
+      end
+    end
+  end
+end
+
+OGR::StyleTable.include(OGR::StyleTable::Extensions)