spatial_features 2.7.8 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43b6f41ecc826e85e2be68987e93993eadf956bd9b97e8cf690ad3f8e5afda6f
-  data.tar.gz: 0bb2d37dc10ac0ab0c7e1a69d35f41c1a3bd5770c2a899846064227eb2f5ccc7
+  metadata.gz: b3acf24e6695a55827725efd2ca6290b96a4ba54d230e8aa176a7bbd356fe6fe
+  data.tar.gz: 48e9527307f5daabd632acf5e76f9d544bcfc3beaeadacb349c37184986321fa
 SHA512:
-  metadata.gz: 3eb2027c5e4f5ab75f592834d9fcfa496c9211c5ae626e1d29fadb3ebd9cbccd7516de96a978da7601f5aa0bbb277a32b8eac50796f5321c2bf81d7018664aea
-  data.tar.gz: 00ea8df16128ca618626c4d2b2db34c7551863cc1951f1fcea9282e821cc98ff53a1234df4efd65384364e7b58c6d69e0101a03ccdfdc1a07a7e5945ef26aee8
+  metadata.gz: 668a6afb0582a4470d1cab7b2e582392ae8fe392514cc0ac363488458052dd6f90dff13c5004aa5423b25f843bc7b79eec0e1e3e056802d80963b40bd4c6f7e9
+  data.tar.gz: 7c17ddc09d78bd90ef1d75a5f0cb67ee0ebb47fe286c6a272f3812f5b733e2e29dfce265e2ea8b91512d6dabcb1d2ccad089acf5b3e15c0a7368c41eda2a11e3

data/README.md

@@ -24,6 +24,7 @@ Adds spatial methods to a model.
 
     CREATE TABLE features (
         id integer NOT NULL,
+        type character varying(255),
         spatial_model_type character varying(255),
         spatial_model_id integer,
         name character varying(255),

data/app/models/abstract_feature.rb

@@ -0,0 +1,167 @@
+class AbstractFeature < ActiveRecord::Base
+  self.table_name = 'features'
+
+  class_attribute :lowres_simplification
+  self.lowres_simplification = 2 # Threshold in meters
+
+  belongs_to :spatial_model, :polymorphic => :true, :autosave => false
+
+  attr_writer :make_valid
+
+  FEATURE_TYPES = %w(polygon point line)
+
+  before_validation :sanitize_feature_type
+  validates_presence_of :geog
+  validate :validate_geometry
+  before_save :sanitize
+  after_save :cache_derivatives
+
+  def self.cache_key
+    "#{maximum(:id)}-#{count}"
+  end
+
+  def self.with_metadata(k, v)
+    if k.present? && v.present?
+      where('metadata->? = ?', k, v)
+    else
+      all
+    end
+  end
+
+  def self.polygons
+    where(:feature_type => 'polygon')
+  end
+
+  def self.lines
+    where(:feature_type => 'line')
+  end
+
+  def self.points
+    where(:feature_type => 'point')
+  end
+
+  def self.area_in_square_meters(geom = 'geom_lowres')
+    current_scope = all.polygons
+    unscoped { connection.select_value(select("ST_Area(ST_Union(#{geom}))").from(current_scope, :features)).to_f }
+  end
+
+  def self.total_intersection_area_in_square_meters(other_features, geom = 'geom_lowres')
+    scope = unscope(:select).select("ST_Union(#{geom}) AS geom").polygons
+    other_scope = other_features.polygons
+
+    query = base_class.unscoped.select('ST_Area(ST_Intersection(ST_Union(features.geom), ST_Union(other_features.geom)))')
+                    .from(scope, "features")
+                    .joins("INNER JOIN (#{other_scope.to_sql}) AS other_features ON ST_Intersects(features.geom, other_features.geom)")
+    return connection.select_value(query).to_f
+  end
+
+  def self.intersecting(other)
+    join_other_features(other).where('ST_Intersects(features.geom_lowres, other_features.geom_lowres)').uniq
+  end
+
+  def self.invalid(column = 'geog::geometry')
+    select("features.*, ST_IsValidReason(#{column}) AS invalid_geometry_message").where.not("ST_IsValid(#{column})")
+  end
+
+  def self.valid
+    where('ST_IsValid(geog::geometry)')
+  end
+
+  def envelope(buffer_in_meters = 0)
+    envelope_json = JSON.parse(self.class.select("ST_AsGeoJSON(ST_Envelope(ST_Buffer(features.geog, #{buffer_in_meters})::geometry)) AS result").where(:id => id).first.result)
+    envelope_json = envelope_json["coordinates"].first
+
+    raise "Can't calculate envelope for Feature #{self.id}" if envelope_json.blank?
+
+    return envelope_json.values_at(0,2)
+  end
+
+  def self.cache_derivatives(options = {})
+    update_all <<-SQL.squish
+      geom         = ST_Transform(geog::geometry, #{detect_srid('geom')}),
+      north        = ST_YMax(geog::geometry),
+      east         = ST_XMax(geog::geometry),
+      south        = ST_YMin(geog::geometry),
+      west         = ST_XMin(geog::geometry),
+      area         = ST_Area(geog),
+      centroid     = ST_PointOnSurface(geog::geometry)
+    SQL
+
+    invalid('geom').update_all <<-SQL.squish
+      geom         = ST_Buffer(geom, 0)
+    SQL
+
+    update_all <<-SQL.squish
+      geom_lowres  = ST_SimplifyPreserveTopology(geom, #{options.fetch(:lowres_simplification, lowres_simplification)})
+    SQL
+
+    invalid('geom_lowres').update_all <<-SQL.squish
+      geom_lowres  = ST_Buffer(geom_lowres, 0)
+    SQL
+  end
+
+  def feature_bounds
+    {n: north, e: east, s: south, w: west}
+  end
+
+  def cache_derivatives(*args)
+    self.class.where(:id => self.id).cache_derivatives(*args)
+  end
+
+  def kml(options = {})
+    geometry = options[:lowres] ? kml_lowres : super()
+    geometry = "<MultiGeometry>#{geometry}#{kml_centroid}</MultiGeometry>" if options[:centroid]
+    return geometry
+  end
+
+  def make_valid?
+    @make_valid
+  end
+
+  private
+
+  def make_valid
+    self.geog = ActiveRecord::Base.connection.select_value("SELECT ST_Buffer('#{sanitize}', 0)")
+  end
+
+  # Use ST_Force2D to discard z-coordinates that cause failures later in the process
+  def sanitize
+    self.geog = ActiveRecord::Base.connection.select_value("SELECT ST_Force2D('#{geog}')")
+  end
+
+  SRID_CACHE = {}
+  def self.detect_srid(column_name)
+    SRID_CACHE[column_name] ||= connection.select_value("SELECT Find_SRID('public', '#{table_name}', '#{column_name}')")
+  end
+
+  def self.join_other_features(other)
+    joins('INNER JOIN features AS other_features ON true').where(:other_features => {:id => other})
+  end
+
+  def validate_geometry
+    return unless geog?
+
+    error = geometry_validation_message
+    if error && make_valid?
+      make_valid
+      self.make_valid = false
+      validate_geometry
+    elsif error
+      errors.add :geog, error
+    end
+  end
+
+  def geometry_validation_message
+    klass = self.class.base_class # Use the base class because we don't want to have to include a type column in our select
+    error = klass.connection.select_one(klass.unscoped.invalid.from("(SELECT '#{sanitize_input_for_sql(self.geog)}'::geometry AS geog) #{klass.table_name}"))
+    return error.fetch('invalid_geometry_message') if error
+  end
+
+  def sanitize_feature_type
+    self.feature_type = FEATURE_TYPES.find {|type| self.feature_type.to_s.strip.downcase.include?(type) }
+  end
+
+  def sanitize_input_for_sql(input)
+    self.class.send(:sanitize_sql_for_conditions, input)
+  end
+end

data/app/models/aggregate_feature.rb

@@ -0,0 +1,17 @@
+require_dependency SpatialFeatures::Engine.root.join('app/models/abstract_feature')
+
+class AggregateFeature < AbstractFeature
+  has_many :features, lambda { |aggregate| where(:spatial_model_type => aggregate.spatial_model_type) }, :foreign_key => :spatial_model_id, :primary_key => :spatial_model_id
+
+  # Aggregate the features for the spatial model into a single feature
+  def refresh
+    self.geog = ActiveRecord::Base.connection.select_value <<~SQL
+      SELECT ST_Collect(ARRAY[
+        (#{features.select('ST_UNION(ST_CollectionExtract(geog::geometry, 1))').to_sql}),
+        (#{features.select('ST_UNION(ST_CollectionExtract(geog::geometry, 2))').to_sql}),
+        (#{features.select('ST_UNION(ST_CollectionExtract(geog::geometry, 3))').to_sql})
+      ])::geography
+    SQL
+    self.save!
+  end
+end

data/app/models/feature.rb

@@ -1,170 +1,62 @@
-class Feature < ActiveRecord::Base
-  belongs_to :spatial_model, :polymorphic => :true, :autosave => false
+class Feature < AbstractFeature
+  class_attribute :automatically_refresh_aggregate
+  self.automatically_refresh_aggregate = true
 
-  attr_writer :make_valid
+  class_attribute :lowres_precision
+  self.lowres_precision = 5
 
-  FEATURE_TYPES = %w(polygon point line)
+  has_one :aggregate_feature, lambda { |feature| where(:spatial_model_type => feature.spatial_model_type) }, :foreign_key => :spatial_model_id, :primary_key => :spatial_model_id
 
-  before_validation :sanitize_feature_type
-  validates_presence_of :geog
-  validate :validate_geometry
   validates_inclusion_of :feature_type, :in => FEATURE_TYPES
-  before_save :sanitize
-  after_save :cache_derivatives
 
-  def self.cache_key
-    "#{maximum(:id)}-#{count}"
-  end
-
-  def self.with_metadata(k, v)
-    if k.present? && v.present?
-      where('metadata->? = ?', k, v)
-    else
-      all
-    end
-  end
+  after_save :refresh_aggregate, if: :automatically_refresh_aggregate?
 
-  def self.polygons
-    where(:feature_type => 'polygon')
-  end
-
-  def self.lines
-    where(:feature_type => 'line')
-  end
+  def self.defer_aggregate_refresh(&block)
+    start_at = Feature.maximum(:id).to_i + 1
+    output = without_aggregate_refresh(&block)
 
-  def self.points
-    where(:feature_type => 'point')
-  end
+    where(:id => start_at..Float::INFINITY).refresh_aggregates
 
-  def self.area_in_square_meters(geom = 'geom_lowres')
-    current_scope = all.polygons
-    unscoped { connection.select_value(select("ST_Area(ST_Union(#{geom}))").from(current_scope, :features)).to_f }
+    return output
   end
 
-  def self.total_intersection_area_in_square_meters(other_features, geom = 'geom_lowres')
-    scope = unscope(:select).select("ST_Union(#{geom}) AS geom").polygons
-    other_scope = other_features.polygons
-
-    query = unscoped.select('ST_Area(ST_Intersection(ST_Union(features.geom), ST_Union(other_features.geom)))')
-                    .from(scope, "features")
-                    .joins("INNER JOIN (#{other_scope.to_sql}) AS other_features ON ST_Intersects(features.geom, other_features.geom)")
-    return connection.select_value(query).to_f
+  def self.without_aggregate_refresh
+    old = Feature.automatically_refresh_aggregate
+    Feature.automatically_refresh_aggregate = false
+    yield
+  ensure
+    Feature.automatically_refresh_aggregate = old
   end
 
-  def self.intersecting(other)
-    join_other_features(other).where('ST_Intersects(features.geom_lowres, other_features.geom_lowres)').uniq
-  end
+  def self.refresh_aggregates
+    # Find one feature from each spatial model and trigger the aggregate feature refresh
+    ids = select('MAX(id)')
+            .where.not(:spatial_model_type => nil, :spatial_model_id => nil)
+            .group('spatial_model_type, spatial_model_id')
 
-  def self.invalid(column = 'geog::geometry')
-    select("features.*, ST_IsValidReason(#{column}) AS invalid_geometry_message").where.not("ST_IsValid(#{column})")
+    where(:id => ids).find_each(&:refresh_aggregate)
   end
 
-  def self.valid
-    where('ST_IsValid(geog::geometry)')
+  def refresh_aggregate
+    # puts "Refreshing AggregateFeature for #{spatial_model_type} #{spatial_model_id}"
+    build_aggregate_feature unless aggregate_feature&.persisted?
+    aggregate_feature.refresh
   end
 
-  def envelope(buffer_in_meters = 0)
-    envelope_json = JSON.parse(self.class.select("ST_AsGeoJSON(ST_Envelope(ST_Buffer(features.geog, #{buffer_in_meters})::geometry)) AS result").where(:id => id).first.result)
-    envelope_json = envelope_json["coordinates"].first
-
-    raise "Can't calculate envelope for Feature #{self.id}" if envelope_json.blank?
-
-    return envelope_json.values_at(0,2)
+  def automatically_refresh_aggregate?
+    # Check if there is a spatial model id because nothing prevents is from creating a Feature without one. Depending on
+    # how you assign a feature to a record, you may end up saving it before assigning it to a record, thereby leaving
+    # this field blank.
+    spatial_model_id? && automatically_refresh_aggregate
   end
 
+  # Features are used for display so we also cache their KML representation
   def self.cache_derivatives(options = {})
-    options.reverse_merge! :lowres_simplification => 2, :lowres_precision => 5
-
-    update_all <<-SQL.squish
-      geom         = ST_Transform(geog::geometry, #{detect_srid('geom')}),
-      north        = ST_YMax(geog::geometry),
-      east         = ST_XMax(geog::geometry),
-      south        = ST_YMin(geog::geometry),
-      west         = ST_XMin(geog::geometry),
-      area         = ST_Area(geog),
-      centroid     = ST_PointOnSurface(geog::geometry)
-    SQL
-
-    invalid('geom').update_all <<-SQL.squish
-      geom         = ST_Buffer(geom, 0)
-    SQL
-
-    update_all <<-SQL.squish
-      geom_lowres  = ST_SimplifyPreserveTopology(geom, #{options[:lowres_simplification]})
-    SQL
-
-    invalid('geom_lowres').update_all <<-SQL.squish
-      geom_lowres  = ST_Buffer(geom_lowres, 0)
-    SQL
-
+    super
     update_all <<-SQL.squish
       kml          = ST_AsKML(geog, 6),
-      kml_lowres   = ST_AsKML(geom_lowres, #{options[:lowres_precision]}),
+      kml_lowres   = ST_AsKML(geom_lowres, #{options.fetch(:lowres_precision, lowres_precision)}),
       kml_centroid = ST_AsKML(centroid)
     SQL
   end
-
-  def feature_bounds
-    {n: north, e: east, s: south, w: west}
-  end
-
-  def cache_derivatives(*args)
-    self.class.where(:id => self.id).cache_derivatives(*args)
-  end
-
-  def kml(options = {})
-    geometry = options[:lowres] ? kml_lowres : super()
-    geometry = "<MultiGeometry>#{geometry}#{kml_centroid}</MultiGeometry>" if options[:centroid]
-    return geometry
-  end
-
-  def make_valid?
-    @make_valid
-  end
-
-  private
-
-  def make_valid
-    self.geog = ActiveRecord::Base.connection.select_value("SELECT ST_Buffer('#{sanitize}', 0)")
-  end
-
-  # Use ST_Force2D to discard z-coordinates that cause failures later in the process
-  def sanitize
-    self.geog = ActiveRecord::Base.connection.select_value("SELECT ST_Force2D('#{geog}')")
-  end
-
-  SRID_CACHE = {}
-  def self.detect_srid(column_name)
-    SRID_CACHE[column_name] ||= connection.select_value("SELECT Find_SRID('public', '#{table_name}', '#{column_name}')")
-  end
-
-  def self.join_other_features(other)
-    joins('INNER JOIN features AS other_features ON true').where(:other_features => {:id => other})
-  end
-
-  def validate_geometry
-    return unless geog?
-
-    error = geometry_validation_message
-    if error && make_valid?
-      make_valid
-      self.make_valid = false
-      validate_geometry
-    elsif error
-      errors.add :geog, error
-    end
-  end
-
-  def geometry_validation_message
-    error = self.class.connection.select_one(self.class.unscoped.invalid.from("(SELECT '#{sanitize_input_for_sql(self.geog)}'::geometry AS geog) #{self.class.table_name}"))
-    return error.fetch('invalid_geometry_message') if error
-  end
-
-  def sanitize_feature_type
-    self.feature_type = FEATURE_TYPES.find {|type| self.feature_type.to_s.strip.downcase.include?(type) }
-  end
-
-  def sanitize_input_for_sql(input)
-    self.class.send(:sanitize_sql_for_conditions, input)
-  end
 end

data/lib/spatial_features/has_spatial_features/feature_import.rb

@@ -79,9 +79,11 @@ module SpatialFeatures
 
     def import_features(imports, skip_invalid)
       self.features.delete_all
-      valid, invalid = imports.flat_map(&:features).partition do |feature|
-        feature.spatial_model = self
-        feature.save
+      valid, invalid = Feature.defer_aggregate_refresh do
+        imports.flat_map(&:features).partition do |feature|
+          feature.spatial_model = self
+          feature.save
+        end
       end
 
       errors = imports.flat_map(&:errors)

data/lib/spatial_features/has_spatial_features.rb

@@ -11,6 +11,7 @@ module SpatialFeatures
         include FeatureImport
 
         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 :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") }
@@ -128,24 +129,8 @@ module SpatialFeatures
       scope = spatial_join(other, buffer_in_meters)
       scope = scope.select(options[:columns])
 
-      # Ensure records with multiple features don't appear multiple times
-      if options[:distance] || options[:intersection_area]
-        scope = scope.group("#{table_name}.#{primary_key}") # Aggregate functions require grouping
-      else
-        scope = scope.distinct
-      end
-
-      scope = scope.select("MIN(ST_Distance(features.geom, other_features.geom)) AS distance_in_meters") if options[:distance]
-      scope = scope.select <<~SQL if options[:intersection_area]
-        ST_Area(
-          ST_Intersection(
-            /* Extract only polygons to calculations since we're calculating area */
-            /* Union to aggregate features from all records in the query before intersection to flatten geometry and avoid possible self intersection */
-            ST_Union(ST_CollectionExtract(features.geom, 3)),
-            ST_Union(ST_CollectionExtract(other_features.geom, 3))
-          )
-        ) AS intersection_area_in_square_meters
-      SQL
+      scope = scope.select("ST_Distance(features.geom, other_features.geom) AS distance_in_meters") if options[:distance]
+      scope = scope.select("ST_Area(ST_Intersection(features.geom, other_features.geom)) AS intersection_area_in_square_meters") if options[:intersection_area]
 
       return scope
     end
@@ -165,7 +150,7 @@ module SpatialFeatures
     end
 
     def features_scope(other)
-      scope = Feature
+      scope = AggregateFeature
       scope = scope.where(:spatial_model_type => Utils.base_class_of(other).to_s)
       scope = scope.where(:spatial_model_id => other) unless Utils.class_of(other) == other
       return scope

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "2.7.8"
+  VERSION = "2.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 2.7.8
+  version: 2.8.0
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-10 00:00:00.000000000 Z
+date: 2019-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -167,6 +167,8 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/models/abstract_feature.rb
+- app/models/aggregate_feature.rb
 - app/models/feature.rb
 - app/models/spatial_cache.rb
 - app/models/spatial_proximity.rb