spatial_features 3.1.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9578faf8d4205e8b25b7039b99df9ead3f03f13d82568277930c8824adb48980
-  data.tar.gz: 16a5be2783383686f570f598edd8ecf3da6350fb92d5b393618f8be919ab8c79
+  metadata.gz: 7ba1ab9dfa18160f48292f26a63f75031187e44cc04aff73dba792832d482063
+  data.tar.gz: b25d8a6f4bd0412c3d2d9dd34a57c620a0593979304ddb9061c7f3b3e2d7f834
 SHA512:
-  metadata.gz: 772ab77070751ca764ab8a06cf5260038be3cae8461c6e9c7fa894e644d2164cd8905281c43d0eab48b7ab2f06227b01da809687ec4ffb7bc1ade359c7097eea
-  data.tar.gz: da9f6d66e79f85362f4c6af9e3dc8400b4f6fb51bf0cb5ba84114ccb47b4541e59614d162271877c6d20d9d342fbc9a86b48de7e8a5a1de15b27c7136c09f3b3
+  metadata.gz: 1be4b279b3341582262bdb8d802c0786b1eb3607cef070f2a03813b2bc987d21fb0aa92323d7b49dbec01aa8b2e128f0b9982ce356dc4836875ccd5ad89f7092
+  data.tar.gz: 8e70dfe6f6bad6545c29fc5dbf1406b308b9cb44ff48ebfc849469912af6cf30640c829c2baf363a6790e9207f78d3c039276c002a50ce6319ccf0d9450f9df7

data/README.md

@@ -31,7 +31,6 @@ Adds spatial methods to a model.
         feature_type character varying(255),
         geog geography,
         geom geometry(Geometry,4326),
-        geom_lowres geometry(Geometry,4326),
         tilegeom geometry(Geometry,3857),
         metadata hstore,
         area double precision,
@@ -50,7 +49,6 @@ Adds spatial methods to a model.
     CREATE INDEX index_features_on_feature_type ON features USING btree (feature_type);
     CREATE INDEX index_features_on_spatial_model_id_and_spatial_model_type ON features USING btree (spatial_model_id, spatial_model_type);
     CREATE INDEX index_features_on_geom ON features USING gist (geom);
-    CREATE INDEX index_features_on_geom_lowres ON features USING gist (geom_lowres);
     CREATE INDEX index_features_on_tilegeom ON features USING gist (tilegeom);
 
     CREATE TABLE spatial_caches (
@@ -182,6 +180,14 @@ add_index :features, :tilegeom, :using => :gist
 Feature.update_all('tilegeom = ST_Transform(geom, 3857)')
 ```
 
+## Upgrading From 3.0/3.1 to 3.2
+SpatialProximity now expects the `model_a` and `model_b` records to be decided based on the name of the record type so
+queries can be optimized. Migrate existing SpatialProximity rows to this new scheme by running the code below.
+
+```ruby
+SpatialProximity.normalize
+```
+
 ## Testing
 
 Create a postgres database:

data/app/models/abstract_feature.rb

@@ -49,8 +49,14 @@ class AbstractFeature < ActiveRecord::Base
     where(:feature_type => 'point')
   end
 
-  def self.within_distance_of_point(lat, lng, distance_in_meters)
-    where("ST_DWithin(features.geog, ST_Point(:lng, :lat), :distance)", :lat => lat, :lng => lng, :distance => distance_in_meters)
+  def self.within_distance_of_point(lat, lng, distance_in_meters, geom = 'geom_lowres')
+    point_sql =
+      case geom.to_s
+      when 'geog' then 'ST_Point(:lng, :lat)'
+      else "ST_Transform(ST_SetSRID(ST_Point(:lng, :lat), 4326), #{detect_srid(geom)})"
+      end
+
+    where("ST_DWithin(features.#{geom}, #{point_sql}, :distance)", :lat => lat, :lng => lng, :distance => distance_in_meters)
   end
 
   def self.area_in_square_meters(geom = 'geom_lowres')
@@ -69,11 +75,11 @@ class AbstractFeature < ActiveRecord::Base
   end
 
   def self.intersecting(other)
-    join_other_features(other).where('ST_Intersects(features.geom_lowres, other_features.geom_lowres)').uniq
+    join_other_features(other).where('ST_Intersects(features.geom_lowres, other_features.geom_lowres)').distinct
   end
 
   def self.within_distance(other, distance_in_meters)
-    join_other_features(other).where('ST_DWithin(features.geom_lowres, other_features.geom_lowres, ?)', distance_in_meters).uniq
+    join_other_features(other).where('ST_DWithin(features.geom_lowres, other_features.geom_lowres, ?)', distance_in_meters).distinct
   end
 
   def self.invalid(column = 'geog::geometry')
@@ -126,8 +132,8 @@ class AbstractFeature < ActiveRecord::Base
     SQL
   end
 
-  def self.mvt(*args)
-    select_sql = mvt_sql(*args)
+  def self.mvt(*args, **kwargs)
+    select_sql = mvt_sql(*args, **kwargs)
 
     # Result is a hex string representing the desired binary output so we need to convert it to binary
     result = SpatialFeatures::Utils.select_db_value(select_sql)
@@ -248,7 +254,7 @@ class AbstractFeature < ActiveRecord::Base
     self.geog = SpatialFeatures::Utils.select_db_value("SELECT ST_Force2D('#{geog}')")
   end
 
-  SRID_CACHE = {}
+  SRID_CACHE = HashWithIndifferentAccess.new
   def self.detect_srid(column_name)
     SRID_CACHE[column_name] ||= SpatialFeatures::Utils.select_db_value("SELECT Find_SRID('public', '#{table_name}', '#{column_name}')")
   end

data/app/models/spatial_proximity.rb

@@ -2,10 +2,34 @@ class SpatialProximity < ActiveRecord::Base
   belongs_to :model_a, :polymorphic => true
   belongs_to :model_b, :polymorphic => true
 
-  def self.between(scope_1, scope_2)
-    where <<-SQL.squish
-      (#{SpatialFeatures::Utils.polymorphic_condition(scope_1, 'model_a')} AND #{SpatialFeatures::Utils.polymorphic_condition(scope_2, 'model_b')}) OR
-      (#{SpatialFeatures::Utils.polymorphic_condition(scope_2, 'model_a')} AND #{SpatialFeatures::Utils.polymorphic_condition(scope_1, 'model_b')})
+  def self.between(scope1, scope2)
+    where condition_sql(scope1, scope2, <<~SQL.squish)
+      (#{SpatialFeatures::Utils.polymorphic_condition(scope1, 'model_a')} AND #{SpatialFeatures::Utils.polymorphic_condition(scope2, 'model_b')})
     SQL
   end
+
+  def self.condition_sql(scope1, scope2, template, pattern_a = 'model_a', pattern_b = 'model_b')
+    scope1_type = SpatialFeatures::Utils.base_class_of(scope1).to_s
+    scope2_type = SpatialFeatures::Utils.base_class_of(scope2).to_s
+
+    if scope1_type < scope2_type
+      template
+    elsif scope1_type > scope2_type
+      template.gsub(pattern_a, 'model_c').gsub(pattern_b, pattern_a).gsub('model_c', pattern_b)
+    else
+      <<~SQL.squish
+        (#{template}) OR (#{template.gsub(pattern_a, 'model_c').gsub(pattern_b, pattern_a).gsub('model_c', pattern_b)})
+      SQL
+    end
+  end
+
+  # Ensure the 'earliest' model is always model a
+  def self.normalize
+    unnormalized
+      .update_all('model_a_type = model_b_type, model_b_type = model_a_type, model_a_id = model_b_id, model_b_id = model_a_id')
+  end
+
+  def self.unnormalized
+    where('model_a_type > model_b_type OR (model_a_type = model_b_type AND model_a_id > model_b_id)')
+  end
 end

data/config/initializers/mime_types.rb

@@ -3,3 +3,7 @@ Mime::Type.register "application/vnd.bounds+json", :bounds
 Mime::Type.register "application/vnd.mapbox-vector-tile", :mvt
 Mime::Type.register "application/vnd.google-earth.kml+xml", :kml
 Mime::Type.register "application/vnd.google-earth.kmz", :kmz
+Mime::Type.register "application/zip", :zip
+Mime::Type.register "application/zip", :piz
+Mime::Type.register "application/zip", :zap
+Mime::Type.register "application/zip", :shpz

data/lib/spatial_features/caching.rb

@@ -84,11 +84,13 @@ module SpatialFeatures
     results.each do |id, distance, area|
       klass_record.id = id
       SpatialProximity.create! do |proximity|
+        # Always make the spatial model earliest type and id be model a so we can optimize queries
+        data = [[Utils.base_class(record).to_s, record.id], [Utils.base_class(klass_record).to_s, klass_record.id]]
+        data.sort!
+
         # Set id and type instead of model to avoid autosaving the klass_record
-        proximity.model_a_id = record.id
-        proximity.model_a_type = Utils.base_class(record)
-        proximity.model_b_id = klass_record.id
-        proximity.model_b_type = Utils.base_class(klass_record)
+        proximity.model_a_type, proximity.model_a_id = data.first
+        proximity.model_b_type, proximity.model_b_id = data.second
         proximity.distance_in_meters = distance
         proximity.intersection_area_in_square_meters = area
       end

data/lib/spatial_features/download.rb

@@ -4,14 +4,14 @@ module SpatialFeatures
   module Download
     # file can be a url, path, or file, any of which can return be a zipped archive
     def self.open(file)
-      file = Kernel.open(file)
+      file = URI.open(file)
       file = normalize_file(file) if file.is_a?(StringIO)
       return file
     end
 
     # file can be a url, path, or file, any of which can return be a zipped archive
-    def self.open_each(file, unzip: nil, **unzip_options)
-      file = Download.open(file)
+    def self.open_each(path_or_url, unzip: nil, **unzip_options)
+      file = Download.open(path_or_url)
       files = if unzip && Unzip.is_zip?(file)
         find_in_zip(file, find: unzip, **unzip_options)
       else

data/lib/spatial_features/has_spatial_features/feature_import.rb

@@ -13,14 +13,14 @@ module SpatialFeatures
     end
 
     module ClassMethods
-      def update_features!(skip_invalid: false, **options)
+      def update_features!(skip_invalid: false, allow_blank: false, **options)
         find_each do |record|
-          record.update_features!(skip_invalid: skip_invalid, **options)
+          record.update_features!(skip_invalid: skip_invalid, allow_blank: allow_blank, **options)
         end
       end
     end
 
-    def update_features!(skip_invalid: false, **options)
+    def update_features!(skip_invalid: false, allow_blank: false, **options)
       options = options.reverse_merge(spatial_features_options)
       tmpdir = options.fetch(:tmpdir) { Dir.mktmpdir("ruby_spatial_features") }
 
@@ -31,7 +31,7 @@ module SpatialFeatures
         return if features_cache_key_matches?(cache_key)
 
         run_callbacks :update_features do
-          import_features(imports, skip_invalid)
+          features = import_features(imports, skip_invalid)
           update_features_cache_key(cache_key)
           update_features_area
 
@@ -40,11 +40,17 @@ module SpatialFeatures
           else
             update_spatial_cache(options.slice(:spatial_cache))
           end
-        end
 
-        return true
+          if imports.present? && features.compact_blank.empty? && !allow_blank
+            raise EmptyImportError, "No spatial features were found when updating"
+          end
+        end
       end
+
+      return true
     rescue StandardError => e
+      raise e if e.is_a?(EmptyImportError)
+
       if skip_invalid
         Rails.logger.warn "Error updating #{self.class} #{self.id}. #{e.message}"
         return nil
@@ -137,7 +143,7 @@ module SpatialFeatures
         raise ImportError, "Error updating #{self.class} #{self.id}. #{errors.to_sentence}"
       end
 
-      return features
+      valid
     end
 
     def features_cache_key_matches?(cache_key)

data/lib/spatial_features/has_spatial_features.rb

@@ -13,14 +13,14 @@ module SpatialFeatures
         has_many :features, lambda { extending FeaturesAssociationExtensions }, :as => :spatial_model, :dependent => :delete_all
         has_one :aggregate_feature, lambda { extending FeaturesAssociationExtensions }, :as => :spatial_model, :dependent => :delete
 
-        scope :with_features, lambda { joins(:features).uniq }
+        scope :with_features, lambda { joins(:features).distinct }
         scope :without_features, lambda { joins("LEFT OUTER JOIN features ON features.spatial_model_type = '#{Utils.base_class(name)}' AND features.spatial_model_id = #{table_name}.id").where("features.id IS NULL") }
         scope :include_bounds, lambda { SQLHelpers.append_select(joins(:aggregate_feature), :north, :east, :south, :west) }
         scope :include_area, lambda { SQLHelpers.append_select(joins(:aggregate_feature), :area) }
 
-        scope :with_spatial_cache, lambda {|klass| joins(:spatial_caches).where(:spatial_caches => { :intersection_model_type =>  Utils.class_name_with_ancestors(klass) }).uniq }
+        scope :with_spatial_cache, lambda {|klass| joins(:spatial_caches).where(:spatial_caches => { :intersection_model_type =>  Utils.class_name_with_ancestors(klass) }).distinct }
         scope :without_spatial_cache, lambda {|klass| joins("LEFT OUTER JOIN #{SpatialCache.table_name} ON #{SpatialCache.table_name}.spatial_model_id = #{table_name}.id AND #{SpatialCache.table_name}.spatial_model_type = '#{Utils.base_class(name)}' and intersection_model_type IN ('#{Utils.class_name_with_ancestors(klass).join("','") }')").where("#{SpatialCache.table_name}.spatial_model_id IS NULL") }
-        scope :with_stale_spatial_cache, lambda { joins(:spatial_caches).where("#{table_name}.features_hash != spatial_caches.features_hash").uniq } if has_spatial_features_hash?
+        scope :with_stale_spatial_cache, lambda { has_spatial_features_hash? ? joins(:spatial_caches).where("#{table_name}.features_hash != spatial_caches.features_hash").distinct : none }
 
         has_many :spatial_caches, :as => :spatial_model, :dependent => :delete_all, :class_name => 'SpatialCache'
         has_many :model_a_spatial_proximities, :as => :model_a, :class_name => 'SpatialProximity', :dependent => :delete_all
@@ -136,10 +136,8 @@ module SpatialFeatures
       other_class = Utils.base_class_of(other)
       self_class = Utils.base_class_of(self)
 
-      joins <<~SQL
-        INNER JOIN spatial_proximities
-        ON (spatial_proximities.model_a_type = '#{self_class}' AND spatial_proximities.model_a_id = #{table_name}.id AND spatial_proximities.model_b_type = '#{other_class}' AND spatial_proximities.model_b_id IN (#{Utils.id_sql(other)}))
-        OR (spatial_proximities.model_b_type = '#{self_class}' AND spatial_proximities.model_b_id = #{table_name}.id AND spatial_proximities.model_a_type = '#{other_class}' AND spatial_proximities.model_a_id IN (#{Utils.id_sql(other)}))
+      joins "INNER JOIN spatial_proximities ON " + SpatialProximity.condition_sql(self, other, <<~SQL.squish)
+        (spatial_proximities.model_a_type = '#{self_class}' AND spatial_proximities.model_a_id = #{table_name}.id AND spatial_proximities.model_b_type = '#{other_class}' AND spatial_proximities.model_b_id IN (#{Utils.id_sql(other)}))
       SQL
     end
 
@@ -228,20 +226,19 @@ module SpatialFeatures
     end
 
     def total_intersection_area_percentage(klass)
-      return 0.0 unless features_area_in_square_meters > 0
+      total_area = features_area_in_square_meters
 
-      ((total_intersection_area_in_square_meters(klass) / features_area_in_square_meters) * 100).round(1)
+      return if total_area.nil?
+      return 0.0 if total_area.zero?
+
+      ((total_intersection_area_in_square_meters(klass) / total_area) * 100).round(1)
     end
 
     def features_area_in_square_meters
-      @features_area_in_square_meters ||=
-        if has_attribute?(:area)
-          area
-        elsif association(:aggregate_feature).loaded?
-          aggregate_feature&.area
-        else
-          aggregate_features.pluck(:area).first
-        end
+      @features_area_in_square_meters ||= area if has_attribute?(:area) # Calculated area column
+      @features_area_in_square_meters ||= features_area if has_attribute?(:features_area) # Cached area column
+      @features_area_in_square_meters ||= aggregate_feature&.area if association(:aggregate_feature).loaded?
+      @features_area_in_square_meters ||= aggregate_features.pluck(:area).first
     end
 
     def total_intersection_area_in_square_meters(other)

data/lib/spatial_features/importers/base.rb

@@ -56,4 +56,5 @@ module SpatialFeatures
   # EXCEPTIONS
 
   class ImportError < StandardError; end
+  class EmptyImportError < ImportError; end
 end

data/lib/spatial_features/importers/file.rb

@@ -3,16 +3,23 @@ require 'open-uri'
 module SpatialFeatures
   module Importers
     class File < SimpleDelegator
-      INVALID_ARCHIVE = "Archive did not contain a .kml, .shp, .json, or .geojson file.".freeze
+      SUPPORTED_SPATIAL_FORMATS = %w(application/zip application/x-shp+zip application/vnd.google-earth.kml+xml application/vnd.google-earth.kmz application/vnd.geo+json).freeze
+      SUPPORTED_SPATIAL_FILE_EXTENSIONS = %w(.zip .zap .piz .shpz .kml .kmz .json .geojson).freeze
       SUPPORTED_FORMATS = "Supported formats are KMZ, KML, zipped ArcGIS shapefiles, ESRI JSON, and GeoJSON.".freeze
 
+      def self.invalid_archive!(filename)
+        filename = ::File.basename(filename.to_s)
+        raise ImportError, "#{filename} did not contain a spatial file. #{SUPPORTED_FORMATS}"
+      end
+      delegate :invalid_archive!, :to => :class
+
       FILE_PATTERNS = [/\.kml$/, /\.shp$/, /\.json$/, /\.geojson$/]
       def self.create_all(data, **options)
         Download.open_each(data, unzip: FILE_PATTERNS, downcase: true, tmpdir: options[:tmpdir]).map do |file|
           new(data, **options, current_file: file)
         end
       rescue Unzip::PathNotFound
-        raise ImportError, INVALID_ARCHIVE + " " + SUPPORTED_FORMATS
+        invalid_archive!(data)
       end
 
       # The File importer may be initialized multiple times by `::create_all` if it
@@ -21,24 +28,32 @@ module SpatialFeatures
       # processed.
       #
       # If no `current_file` is passed then we just take the first valid file that we find.
-      def initialize(data, *args, current_file: nil, **options)
+      def initialize(data, current_file: nil, **options)
         begin
           current_file ||= Download.open_each(data, unzip: FILE_PATTERNS, downcase: true, tmpdir: options[:tmpdir]).first
         rescue Unzip::PathNotFound
-          raise ImportError, INVALID_ARCHIVE
+          invalid_archive!(data)
         end
 
-        case ::File.extname(current_file.path.downcase)
+        filename = current_file.path.downcase
+
+        case ::File.extname(filename)
         when '.kml'
-          __setobj__(KMLFile.new(current_file, *args, **options))
+          __setobj__(KMLFile.new(current_file, **options))
         when '.shp'
-          __setobj__(Shapefile.new(current_file, *args, **options))
+          __setobj__(Shapefile.new(current_file, **options))
         when '.json', '.geojson'
-          __setobj__(ESRIGeoJSON.new(current_file.path, *args, **options))
+          __setobj__(ESRIGeoJSON.new(current_file.path, **options))
         else
-          raise ImportError, "Could not import file. " + SUPPORTED_FORMATS
+          import_error!(filename)
         end
       end
+
+      private
+
+      def import_error!(filename)
+        raise ImportError, "Could not import #{filename}. " + SUPPORTED_FORMATS
+      end
     end
   end
 end

data/lib/spatial_features/importers/geomark.rb

@@ -1,8 +1,8 @@
 module SpatialFeatures
   module Importers
     class Geomark < KMLFile
-      def initialize(geomark, *args)
-        super geomark_url(geomark), *args
+      def initialize(geomark, **options)
+        super geomark_url(geomark), **options
       end
 
       private

data/lib/spatial_features/importers/kml.rb

@@ -6,9 +6,15 @@ module SpatialFeatures
       # <SimpleData name> keys that may contain <img> tags
       IMAGE_METADATA_KEYS = %w[pdfmaps_photos].freeze
 
-      def initialize(data, base_dir: nil, **args)
+      # matches a coordinate pair with an optional altitude, including invalid altitudes like NaN
+      #   -118.1,50.9,NaN
+      #   -118.1,50.9,0
+      #   -118.1,50.9
+      COORDINATES_WITH_ALTITUDE = /((-?\d+\.\d+,-?\d+\.\d+)(,-?[a-zA-Z\d\.]+))/.freeze
+
+      def initialize(data, base_dir: nil, **options)
         @base_dir = base_dir
-        super data, **args
+        super data, **options
       end
 
       private
@@ -39,6 +45,7 @@ module SpatialFeatures
         @kml_document ||= begin
           doc = Nokogiri::XML(@data)
           raise ImportError, "Invalid KML document (root node was '#{doc.root&.name}')" unless doc.root&.name.to_s.casecmp?('kml')
+          raise ImportError, "NetworkLink elements are not supported" unless doc.search('NetworkLink').empty?
           doc
         end
       end
@@ -51,6 +58,8 @@ module SpatialFeatures
         geom = nil
         conn = nil
 
+        strip_altitude(kml)
+
         # Do query in a new thread so we use a new connection (if the query fails it will poison the transaction of the current connection)
         #
         # We manually checkout a new connection since Rails re-uses DB connections across threads.
@@ -105,6 +114,13 @@ module SpatialFeatures
         end
         return metadata
       end
+
+      def strip_altitude(kml)
+        kml.css('coordinates').each do |coordinates|
+          next unless COORDINATES_WITH_ALTITUDE.match?(coordinates.content)
+          coordinates.content = coordinates.content.gsub(COORDINATES_WITH_ALTITUDE, '\2')
+        end
+      end
     end
   end
 end

data/lib/spatial_features/importers/kml_file_arcgis.rb

@@ -3,7 +3,7 @@ require 'ostruct'
 module SpatialFeatures
   module Importers
     class KMLFileArcGIS < KMLFile
-      def initialize(data, *args)
+      def initialize(data, **options)
         super
 
       rescue SocketError, Errno::ECONNREFUSED

data/lib/spatial_features/importers/shapefile.rb

@@ -6,7 +6,7 @@ module SpatialFeatures
     class Shapefile < Base
       class_attribute :default_proj4_projection
 
-      def initialize(data, *args, proj4: nil, **options)
+      def initialize(data, proj4: nil, **options)
         super(data, **options)
         @proj4 = proj4
       end
@@ -20,7 +20,7 @@ module SpatialFeatures
           new(file, **options)
         end
       rescue Unzip::PathNotFound
-        raise ImportError, INVALID_ARCHIVE
+        invalid_archive!(data)
       end
 
       private

data/lib/spatial_features/venn_polygons.rb

@@ -56,7 +56,7 @@ module SpatialFeatures
     # Instantiate objects to hold the kml and records for each venn polygon
     polygons.group_by{|row| row['kml']}.collect do |kml, rows|
       # Uniq on row id in case a single record had self intersecting multi geometry, which would cause it to appear duplicated on a single venn polygon
-      records = rows.uniq{|row| row.values_at('id', 'type') }.collect{|row| eager_load_hash.fetch(row['type']).detect{|record| record.id == row['id'].to_i } }
+      records = rows.uniq {|row| row.values_at('id', 'type') }.collect{|row| eager_load_hash.fetch(row['type']).detect{|record| record.id == row['id'].to_i } }
       OpenStruct.new(:kml => kml, :records => records)
     end
   end

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "3.1.0"
+  VERSION = "3.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-24 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -203,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.23
 signing_key: 
 specification_version: 4
 summary: Adds spatial methods to a model.