spatial_features 1.5.6 → 1.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1b2fd845f974c81c193ab65128205450944af69
-  data.tar.gz: 4b31e9277f2c4d97662faaa707b9a40e54f6198c
+  metadata.gz: 6cbe6788f92697f84521cb44e3fd3189b7b4d85d
+  data.tar.gz: b4e5fe7c097c9f78cb600d886b24be42c87903cc
 SHA512:
-  metadata.gz: 944dc0f7f777bac917f94d9fdf5e31d98fe484d3fef6194bd5eb7363b17cd0e65a3434ec0c762c51a93286bb0ca5d786fe538c8160d61adb8aed38e60f119044
-  data.tar.gz: 4a685e2b5d74ae77842dff7f3b8eedd21529a8e71ae72f43a249e187518fd88653a014cd4fc7c1141e8de0d2618710d38a0b577545180c88cee3df0736b54700
+  metadata.gz: 3f19855ec3be02877f845513e146d170f8ba5eaf659b7cfb21f700529b041647589abe8fc012375ebb76e1594928ec4b6502d3c372e22ecf05f8e89e845837d4
+  data.tar.gz: d04249b6d2971b45fd966a66ed30f5ffcf6f06154c5ec60d2a4eda1dfabdee6197070ab4ba77f5701d21658b67cfd57a4e902d9151c2543f3f6ab00a379f428a

data/lib/spatial_features/has_spatial_features.rb

@@ -9,6 +9,8 @@ module SpatialFeatures
       scope :with_features, lambda { joins(:features).uniq }
       scope :without_features, lambda { joins("LEFT OUTER JOIN features ON features.spatial_model_type = '#{name}' AND features.spatial_model_id = #{table_name}.id").where("features.id IS NULL") }
 
+      scope :with_stale_spatial_cache, lambda { joins(:spatial_cache).where("#{table_name}.features_hash != spatial_caches.features_hash").uniq } if has_spatial_features_hash?
+
       has_many :spatial_cache, :as => :spatial_model, :dependent => :delete_all
       has_many :model_a_spatial_proximities, :as => :model_a, :class_name => 'SpatialProximity', :dependent => :delete_all
       has_many :model_b_spatial_proximities, :as => :model_b, :class_name => 'SpatialProximity', :dependent => :delete_all
@@ -38,26 +40,15 @@ module SpatialFeatures
       # Cache only works on single records, not scopes.
       # This is because the cached intersection_area doesn't account for overlaps between the features in the scope.
       if options[:cache] != false && other.is_a?(ActiveRecord::Base)
-        # Don't use the cache if it doesn't exist
-        return all.extending(UncachedRelation) unless other.spatial_cache_for?(class_for(self), buffer_in_meters)
-
-        scope = cached_spatial_join(other).select("#{table_name}.*")
-        scope = scope.where("spatial_proximities.distance_in_meters <= ?", buffer_in_meters) if buffer_in_meters
-        scope = scope.select("spatial_proximities.distance_in_meters") if options[:distance]
-        scope = scope.select("spatial_proximities.intersection_area_in_square_meters") if options[:intersection_area]
-      else # NON-CACHED
-        scope = joins_features_for(other).select("#{table_name}.*").group("#{table_name}.#{primary_key}")
-        scope = scope.where('ST_DWithin(features_for.geom, features_for_other.geom, ?)', buffer_in_meters) if buffer_in_meters
-        scope = scope.select("MIN(ST_Distance(features_for.geom, features_for_other.geom)) AS distance_in_meters") if options[:distance]
-        scope = scope.select("ST_Area(ST_Intersection(ST_UNION(features_for.geom), ST_UNION(features_for_other.geom))) AS intersection_area_in_square_meters") if options[:intersection_area]
+        cached_within_buffer_scope(other, buffer_in_meters, options)
+      else
+        uncached_within_buffer_scope(other, buffer_in_meters, options)
       end
-
-      return scope
     end
 
     def covering(other)
       scope = joins_features_for(other).select("#{table_name}.*").group("#{table_name}.#{primary_key}")
-      scope = scope.where('ST_Covers(features_for.geom, features_for_other.geom)')
+      scope = scope.where('ST_Covers(features.geom, features_for_other.geom)')
 
       return scope
     end
@@ -85,16 +76,13 @@ module SpatialFeatures
     # Returns a scope that includes the features for this record as the table_alias and the features for other as #{table_alias}_other
     # Can be used to perform spatial calculations on the relationship between the two sets of features
     def joins_features_for(other, table_alias = 'features_for')
-      joins_features(table_alias)
-        .joins_features("#{table_alias}_other", class_for(other), spatial_model_id = ids_sql_for(other))
+      joins(:features).joins(%Q(INNER JOIN (#{other_features_union(other).to_sql}) AS "#{table_alias}_other" ON true))
     end
 
-    # Returns a scope that includes the features for this record as the table_alias
-    # Default arguments can be overridden to include features for a different set of records
-    def joins_features(table_alias = 'features_for', spatial_model_type = name, spatial_model_id = "#{table_name}.id")
-      joins %Q(INNER JOIN features "#{table_alias}"
-               ON "#{table_alias}".spatial_model_type = '#{spatial_model_type}'
-               AND "#{table_alias}".spatial_model_id IN (#{spatial_model_id}))
+    def other_features_union(other)
+      scope = Feature.select('ST_Union(geom) AS geom').where(:spatial_model_type => class_for(other))
+      scope = scope.where(:spatial_model_id => other) unless class_for(other) == other
+      return scope
     end
 
     # Returns true if the model stores a hash of the features so we don't need to process the features if they haven't changed
@@ -107,8 +95,40 @@ module SpatialFeatures
       column_names.include? 'features_area'
     end
 
+    def area_in_square_meters
+      features.area_in_square_meters
+    end
+
     private
 
+    def cached_within_buffer_scope(other, buffer_in_meters, options)
+      # Don't use the cache if it doesn't exist
+      return all.extending(UncachedRelation) unless other.spatial_cache_for?(class_for(self), buffer_in_meters)
+
+      scope = cached_spatial_join(other).select("#{table_name}.*")
+      scope = scope.where("spatial_proximities.distance_in_meters <= ?", buffer_in_meters) if buffer_in_meters
+      scope = scope.select("spatial_proximities.distance_in_meters") if options[:distance]
+      scope = scope.select("spatial_proximities.intersection_area_in_square_meters") if options[:intersection_area]
+      return scope
+    end
+
+    def uncached_within_buffer_scope(other, buffer_in_meters, options)
+      scope = joins_features_for(other).select("#{table_name}.*")
+      scope = scope.where('ST_Intersects(features.geom, features_for_other.geom)') if buffer_in_meters == 0 # Optimize the 0 buffer case, ST_DWithin was slower in testing
+      scope = scope.where('ST_DWithin(features.geom, features_for_other.geom, ?)', buffer_in_meters) if buffer_in_meters.to_f > 0
+
+      # 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, features_for_other.geom)) AS distance_in_meters") if options[:distance]
+      scope = scope.select("ST_Area(ST_Intersection(ST_UNION(features.geom), ST_UNION(features_for_other.geom))) AS intersection_area_in_square_meters") if options[:intersection_area]
+      return scope
+    end
+
     def cached_spatial_join(other)
       other_class = class_for(other)
 
@@ -185,15 +205,8 @@ module SpatialFeatures
       @features_area_in_square_meters ||= features.area
     end
 
-    def total_intersection_area_in_square_meters(klass, options = {})
-      self.class
-        .select(%Q(ST_Area(ST_Intersection(ST_Union(features_for.geog_lowres::geometry), ST_Union(features_for_other.geog_lowres::geometry))::geography) AS intersection_area_in_square_meters))
-        .joins_features_for(klass)
-        .where(:id => self.id)
-        .where('ST_DWithin(features_for.geog_lowres, features_for_other.geog_lowres, 0)')
-        .group("#{self.class.table_name}.id")
-        .first
-        .try(:intersection_area_in_square_meters) || 0
+    def total_intersection_area_in_square_meters(other)
+      features.total_intersection_area_in_square_meters(other.features)
     end
 
     def spatial_cache_for?(klass, buffer_in_meters)

data/lib/spatial_features/models/feature.rb

@@ -27,6 +27,19 @@ class Feature < ActiveRecord::Base
     where(:feature_type => 'point')
   end
 
+  def self.area_in_square_meters
+    current_scope = all
+    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)
+    scope = join_other_features(other)
+      .where('ST_Intersects(features.geog_lowres, other_features.geog_lowres)')
+      .select('ST_Area(ST_Intersection(ST_Union(features.geog_lowres::geometry), ST_Union(other_features.geog_lowres::geometry))::geography) AS intersection_area_in_square_meters')
+
+    connection.select_value(scope).to_f
+  end
+
   def self.invalid
     select('features.*, ST_IsValidReason(geog::geometry) AS invalid_geometry_message').where.not('ST_IsValid(geog::geometry)')
   end
@@ -66,6 +79,10 @@ class Feature < ActiveRecord::Base
 
   private
 
+  def self.join_other_features(other)
+    joins('INNER JOIN features AS other_features ON true').where(:other_features => {:id => other})
+  end
+
   def geometry_is_valid
     if geog?
       instance = self.class.unscoped.invalid.from("(SELECT '#{sanitize_input_for_sql(self.geog)}'::geometry AS geog) #{self.class.table_name}").to_a.first

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "1.5.6"
+  VERSION = "1.5.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 1.5.6
+  version: 1.5.9
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-26 00:00:00.000000000 Z
+date: 2016-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Adds spatial methods to a model.