mapplz 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5045761f3327fe2be26fb1769108ca424ab1689
-  data.tar.gz: 6cf61d9ec132edbd8911b73e0317681c3c68ec43
+  metadata.gz: 4da45e726fdc80c0a4ce530e6522f31ed8c8035f
+  data.tar.gz: 5595cad9a95f0ec4b638c183d6f8f6c268ff4bab
 SHA512:
-  metadata.gz: 872d06ba820f726ade5184ee11b6d1977009e8209a7b0792b900eb43180abceeffcf77f3096c4b24c1b29bdd8991614af4bcbc725bfe7d9f68e0961fddea30cd
-  data.tar.gz: ae3c23126048c4a306701e3cf64f22ce7184bb45ab3143fed845826194555bb289273110e51ebd0e7197e3074da82a53ed3a25b0c35cb55f26629f529d83320e
+  metadata.gz: 6d204b6cc48b3803adb797ff19dbf9c15b4187b2db01dc13852264761abd7e4148f478e423414ef7f81ce8081aebc4a79b48d98aa6187c315f19d119f19c1669
+  data.tar.gz: 6e050eea53d3d0f6fd844eb0844267618fbde3a5130c9424a967126bcc99345e024fde465f34437b66cecfd6027b89a07495d6b9d5b3aa2314c08d77000d5685

data/README.md

@@ -110,6 +110,13 @@ mapplz.where('layer = ?', name_of_layer)
 # get a count
 mapplz.count
 mapplz.count('layer = ?', name_of_layer)
+
+# near a point
+mapplz.near([lat, lng])
+mapplz.near([lat, lng], max: 10)
+
+# in an area
+mapplz.inside([point1, point2, point3, point1])
 ```
 
 Queries are returned as an array of GeoItems, which each can be exported as GeoJSON or WKT
@@ -119,6 +126,21 @@ my_features = @mapper.where('points > 10')
 collection = { type: 'FeatureCollection', features: my_features.map { |feature| JSON.parse(feature.to_geojson) } }
 ```
 
+## Files
+
+MapPLZ can be passed a CSV or GeoJSON file.
+
+```
+@mapstore < File.open('test.csv')
+@mapstore < File.open('test.geojson')
+```
+
+If you have gdal installed, you can import files in most formats parseable by the ```ogr2ogr``` command line tool.
+
+```
+@mapstore < File.open('test.shp')
+```
+
 ## Databases
 
 You can store geodata in SQLite/Spatialite, Postgres/PostGIS, or MongoDB.
@@ -147,6 +169,7 @@ require 'mongo'
 mongo_client = Mongo::MongoClient.new
 database = mongo_client['mapplz']
 collection = database['geoitems']
+collection.create_index(geo: Mongo::GEO2DSPHERE)
 mapstore = MapPLZ.new(collection)
 mapstore.choose_db('mongodb')
 
@@ -167,15 +190,6 @@ mapstore = MapPLZ.new(db)
 mapstore.choose_db('spatialite')
 ```
 
-### COMING SOON
-
-```
-# near a point
-mapplz.near([lat, lng])
-
-# in an area
-mapplz.inside([point1, point2, point3, point1])
-```
 
 ## Language
 You can make a map super quickly by using the MapPLZ language. A MapPLZ map

data/lib/mapplz.rb

@@ -2,6 +2,9 @@
 
 require 'sql_parser'
 require 'json'
+require 'csv'
+require 'geokdtree'
+require 'digest'
 include Leaflet::ViewHelpers
 
 # MapPLZ datastore
@@ -33,20 +36,33 @@ class MapPLZ
   end
 
   def add(user_geo, lonlat = false)
-    geo_objects = standardize_geo(user_geo, lonlat)
+    begin
+      geo_objects = MapPLZ.standardize_geo(user_geo, lonlat, @db)
+    rescue MapPLZException
+      geo_objects = code(user_geo)
+    end
 
     if @db_type == 'array'
       @my_array += geo_objects
     elsif @db_type == 'mongodb'
       geo_objects.each do |geo_object|
-        reply = @db_client.insert(geo_object)
+        save_obj = geo_object.clone
+        save_obj.delete(:_id)
+        save_obj.delete(:lat)
+        save_obj.delete(:lng)
+        save_obj.delete(:path)
+        save_obj.delete(:centroid)
+        save_obj.delete(:type)
+        save_obj[:geo] = JSON.parse(geo_object.to_geojson)['geometry']
+        reply = @db_client.insert(save_obj)
         geo_object[:_id] = reply.to_s
       end
     elsif @db_type == 'postgis' || @db_type == 'spatialite'
       geo_objects.each do |geo_object|
         geom = geo_object.to_wkt
         if @db_type == 'postgis'
-          reply = @db_client.exec("INSERT INTO mapplz (label, geom) VALUES ('#{geo_object[:label] || ''}', ST_GeomFromText('#{geom}')) RETURNING id")
+          geojson_props = (JSON.parse(geo_object.to_geojson)['properties'] || {})
+          reply = @db_client.exec("INSERT INTO mapplz (properties, geom) VALUES ('#{geojson_props.to_json}', ST_GeomFromText('#{geom}')) RETURNING id")
         elsif @db_type == 'spatialite'
           reply = @db_client.execute("INSERT INTO mapplz (label, geom) VALUES ('#{geo_object[:label] || ''}', AsText('#{geom}')) RETURNING id")
         end
@@ -63,20 +79,12 @@ class MapPLZ
 
   def count(where_clause = nil, add_on = nil)
     results = query(where_clause, add_on)
-    if @db_type == 'array'
-      results.length
-    elsif @db_type == 'mongodb'
-      if where_clause.present?
-        # @db_client.find().count
-      else
-        @db_client.count
-      end
-    else
-      results.count
-    end
+    results.length
   end
 
   def query(where_clause = nil, add_on = nil)
+    geo_results = []
+
     if where_clause.present?
       if @db_type == 'array'
         geo_results = query_array(where_clause, add_on)
@@ -96,17 +104,19 @@ class MapPLZ
         end
 
         cursor = @db_client.find(mongo_conditions)
-      elsif @db_type == 'postgis' || @db_type == 'spatialite'
+      elsif @db_type == 'postgis'
+        where_prop = where_clause.strip.split(' ')[0]
+        where_clause = where_clause.gsub(where_prop, "json_extract_path_text(properties, '#{where_prop}')")
+
+        cursor = @db_client.exec("SELECT id, ST_AsText(geom) AS geo, properties FROM mapplz WHERE #{where_clause}")
+      elsif @db_type == 'spatialite'
         if add_on.is_a?(String)
           where_clause = where_clause.gsub('?', "'#{add_on}'")
         elsif add_on.is_a?(Integer) || add_on.is_a?(Float)
           where_clause = where_clause.gsub('?', "#{add_on}")
         end
 
-        cursor = @db_client.exec("SELECT id, ST_AsText(geom) AS geom, label FROM mapplz WHERE #{where_clause}") if @db_type == 'postgis'
-        cursor = @db_client.execute("SELECT id, AsText(geom) AS geom, label FROM mapplz WHERE #{where_clause}") if @db_type == 'spatialite'
-      else
-        # @my_db.where(where_clause, add_on)
+        cursor = @db_client.execute("SELECT id, AsText(geom) AS geo, label FROM mapplz WHERE #{where_clause}")
       end
     else
       # query all
@@ -115,47 +125,15 @@ class MapPLZ
       elsif @db_type == 'mongodb'
         cursor = @db_client.find
       elsif @db_type == 'postgis'
-        cursor = @db_client.exec('SELECT id, ST_AsText(geom) AS geom, label FROM mapplz')
+        cursor = @db_client.exec('SELECT id, ST_AsText(geom) AS geo, properties FROM mapplz')
       elsif @db_type == 'spatialite'
-        cursor = @db_client.execute('SELECT id, AsText(geom) AS geom, label FROM mapplz')
+        cursor = @db_client.execute('SELECT id, AsText(geom) AS geo, label FROM mapplz')
       else
         # @my_db.all
       end
     end
 
-    unless cursor.nil?
-      geo_results = []
-      cursor.each do |geo_result|
-        geo_item = GeoItem.new
-        geo_result.keys.each do |key|
-          next if [:geom].include?(key.to_sym)
-          geo_item[key.to_sym] = geo_result[key]
-        end
-
-        if @db_type == 'postgis' || @db_type == 'spatialite'
-          geom = (geo_result['geom'] || geo_result[:geom]).upcase
-          if geom.index('POINT')
-            coordinates = geom.gsub('POINT', '').gsub('(', '').gsub(')', '').split(' ')
-            geo_item[:lat] = coordinates[1].to_f
-            geo_item[:lng] = coordinates[0].to_f
-          elsif geom.index('LINESTRING')
-            line_nodes = geom.gsub('LINESTRING', '').gsub('(', '').gsub(')', '').split(',')
-            geo_item[:path] = line_nodes.map do |pt|
-              pt = pt.split(' ')
-              [pt[1].to_f, pt[0].to_f]
-            end
-          elsif geom.index('POLYGON')
-            line_nodes = geom.gsub('POLYGON', '').gsub('(', '').gsub(')', '').split(', ')
-            geo_item[:path] = line_nodes.map do |pt|
-              pt = pt.split(' ')
-              [pt[1].to_f, pt[0].to_f]
-            end
-          end
-        end
-        geo_results << geo_item
-      end
-    end
-
+    geo_results += read_cursor(cursor)
     geo_results
   end
 
@@ -255,12 +233,415 @@ class MapPLZ
     render_text + '</script>'
   end
 
+  def near(user_geo, limit = 10, max = 40_010_000, lon_lat = false)
+    max = max.to_f # send max in meters
+    limit = limit.to_i
+
+    if user_geo.is_a?(Hash)
+      lat = user_geo[:lat] || user_geo['lat'] || user_geo[:latitude] || user_geo['latitude']
+      lng = user_geo[:lng] || user_geo['lng'] || user_geo[:longitude] || user_geo['longitude']
+      user_geo = [lat.to_f, lng.to_f]
+    elsif user_geo.is_a?(Array)
+      user_geo.reverse! if lon_lat
+    else
+      fail 'must query near a point'
+    end
+
+    lat = user_geo[0].to_f
+    lng = user_geo[1].to_f
+    wkt = "POINT(#{lng} #{lat})"
+    geo_results = []
+
+    if @db_type == 'array'
+      @my_array.sort! do |a, b|
+        a_distance = a.distance_from([lat, lng])
+        b_distance = b.distance_from([lat, lng])
+        a_distance <=> b_distance
+      end
+      geo_results = @my_array.slice(0, limit)
+    elsif @db_type == 'mongodb'
+      cursor = @db_client.find(geo: { '$nearSphere' => { '$geometry' => { type: 'Point', coordinates: [lng, lat] }, '$maxDistance' => max } })
+    elsif @db_type == 'postgis'
+      cursor = @db_client.exec("SELECT id, ST_AsText(geom) AS geo, properties, ST_Distance(start.geom::geography, ST_GeomFromText('#{wkt}')::geography) AS distance FROM mapplz AS start WHERE ST_Distance(start.geom::geography, ST_GeomFromText('#{wkt}')::geography) <= #{max} ORDER BY distance LIMIT #{limit}")
+    elsif @db_type == 'spatialite'
+      cursor = @db_client.execute("SELECT id, AsText(geom) AS geo, label, Distance(start.geom, AsText('#{wkt}')) AS distance FROM mapplz AS start WHERE Distance(start.geom, AsText('#{wkt}')) <= #{max} ORDER BY distance LIMIT #{limit}")
+    end
+
+    geo_results += read_cursor(cursor)
+    geo_results
+  end
+
+  def inside(user_geo)
+    geo_results = []
+
+    # accept [point1, point2, point3, point1] as a polygon search area
+    if user_geo.is_a?(Array) && user_geo[0].is_a?(Array) && !user_geo[0][0].is_a?(Array)
+      user_geo = [user_geo]
+    end
+
+    search_areas = MapPLZ.standardize_geo(user_geo)
+
+    search_areas.each do |search_area|
+      next unless search_area.key?(:path)
+      wkt = search_area.to_wkt
+
+      if @db_type == 'array'
+        # in-Ruby point-in-polygon
+        @my_array.each do |geo_item|
+          GeoItem.centroid(geo_item)
+          geo_results << geo_item if geo_item.inside?(search_area)
+        end
+      elsif @db_type == 'mongodb'
+        polygon_gj = JSON.parse(search_area.to_geojson)['geometry']
+        cursor = @db_client.find(geo: { '$geoWithin' => { '$geometry' => polygon_gj } })
+      elsif @db_type == 'postgis'
+        cursor = @db_client.exec("SELECT id, ST_AsText(geom) AS geo, properties FROM mapplz AS start WHERE ST_Contains(ST_GeomFromText('#{wkt}'), start.geom)")
+      elsif @db_type == 'spatialite'
+        cursor = @db_client.exec("SELECT id, AsText(geom) AS geo, label FROM mapplz WHERE MBRContains(FromText('#{wkt}'), FromText(geom))")
+      end
+
+      geo_results += read_cursor(cursor)
+    end
+    geo_results
+  end
+
   def self.flip_path(path)
     path.map! do |pt|
       [pt[1].to_f, pt[0].to_f]
     end
   end
 
+  def self.parse_wkt(geo_item, geom_string)
+    if geom_string.index('POINT')
+      coordinates = geom_string.gsub('POINT', '').gsub('(', '').gsub(')', '').split(' ')
+      geo_item[:lat] = coordinates[1].to_f
+      geo_item[:lng] = coordinates[0].to_f
+    elsif geom_string.index('LINESTRING')
+      line_nodes = geom_string.gsub('LINESTRING', '').gsub('(', '').gsub(')', '').split(',')
+      geo_item[:path] = line_nodes.map do |pt|
+        pt = pt.split(' ')
+        [pt[1].to_f, pt[0].to_f]
+      end
+    elsif geom_string.index('POLYGON')
+      line_nodes = geom_string.gsub('POLYGON', '').gsub('(', '').gsub(')', '').split(', ')
+      geo_item[:path] = line_nodes.map do |pt|
+        pt = pt.split(' ')
+        [pt[1].to_f, pt[0].to_f]
+      end
+    end
+    geo_item
+  end
+
+  def self.standardize_geo(user_geo, lonlat = false, db = nil)
+    return [user_geo] if user_geo.is_a?(GeoItem)
+    geo_objects = []
+
+    if user_geo.is_a?(File)
+      file_type = File.extname(user_geo)
+      if ['.csv', '.tsv', '.tdv', '.txt', '.geojson', '.json'].include?(file_type)
+        # parse this as if it were sent as a string
+        user_geo = user_geo.read
+      else
+        # convert this with ogr2ogr and parse as a string
+        begin
+          `ogr2ogr -f "GeoJSON" tmp.geojson #{File.path(user_geo)}`
+          user_geo = File.open('tmp.geojson').read
+        rescue
+          raise 'gdal was not installed, or format was not accepted by ogr2ogr'
+        end
+      end
+    end
+
+    if user_geo.is_a?(String)
+      begin
+        user_geo = JSON.parse(user_geo)
+      rescue
+        # not JSON - attempt CSV
+        begin
+          CSV.parse(user_geo.gsub('\"', '""'), headers: true) do |row|
+            geo_objects += standardize_geo(row, lonlat, db)
+          end
+          return geo_objects
+        rescue
+          # not JSON or CSV - attempt mapplz parse
+          raise MapPLZException, 'call code() to parse mapplz language'
+        end
+      end
+    end
+
+    if user_geo.is_a?(Array) && user_geo.length > 0
+      if user_geo[0].is_a?(Array) && user_geo[0].length > 0
+        if user_geo[0][0].is_a?(Array) || (user_geo[0][0].is_a?(Hash) && user_geo[0][0].key?(:lat) && user_geo[0][0].key?(:lng))
+          # lines and shapes
+          user_geo.map! do |path|
+            path_pts = []
+            path.each do |path_pt|
+              if lonlat
+                lat = path_pt[1] || path_pt[:lat]
+                lng = path_pt[0] || path_pt[:lng]
+              else
+                lat = path_pt[0] || path_pt[:lat]
+                lng = path_pt[1] || path_pt[:lng]
+              end
+              path_pts << [lat, lng]
+            end
+
+            # polygon border repeats first point
+            if path_pts[0] == path_pts.last
+              geo_type = 'polygon'
+              path_pts = [path_pts]
+            else
+              geo_type = 'polyline'
+            end
+
+            geoitem = GeoItem.new(db)
+            geoitem[:path] = path_pts
+            geoitem[:type] = geo_type
+            geoitem
+          end
+          return user_geo
+        end
+      end
+
+      # multiple objects being added? iterate through
+      if user_geo[0].is_a?(Hash) || user_geo[0].is_a?(Array)
+        user_geo.each do |geo_piece|
+          geo_objects += standardize_geo(geo_piece, lonlat, db)
+        end
+        return geo_objects
+      end
+
+      # first two spots are a coordinate
+      validate_lat = user_geo[0].to_f != 0 || user_geo[0].to_s == '0'
+      validate_lng = user_geo[1].to_f != 0 || user_geo[1].to_s == '0'
+
+      if validate_lat && validate_lng
+        geo_object = GeoItem.new(db)
+        geo_object[:type] = 'point'
+
+        if lonlat
+          geo_object[:lat] = user_geo[1].to_f
+          geo_object[:lng] = user_geo[0].to_f
+        else
+          geo_object[:lat] = user_geo[0].to_f
+          geo_object[:lng] = user_geo[1].to_f
+        end
+      else
+        fail 'no latitude or longitude found'
+      end
+
+      # assume user properties are an ordered array of values known to the user
+      user_properties = user_geo.drop(2)
+
+      # only one property and it's a hash? it's a hash of properties
+      if user_properties.length == 1 && user_properties[0].is_a?(Hash)
+        user_properties[0].keys.each do |key|
+          geo_object[key.to_sym] = user_properties[0][key]
+        end
+      else
+        geo_object[:properties] = user_properties
+      end
+
+      geo_objects << geo_object
+
+    elsif user_geo.is_a?(Hash) || user_geo.is_a?(CSV::Row)
+      if user_geo.is_a?(CSV::Row)
+        # convert CSV::Row to geo hash
+        geo_hash = {}
+        user_geo.headers.each do |header|
+          geo_hash[header] = user_geo[header]
+        end
+        user_geo = geo_hash
+      end
+
+      # check for lat and lng
+      validate_lat = false
+      validate_lat = 'lat' if user_geo.key?('lat') || user_geo.key?(:lat)
+      validate_lat ||= 'latitude' if user_geo.key?('latitude') || user_geo.key?(:latitude)
+
+      validate_lng = false
+      validate_lng = 'lng' if user_geo.key?('lng') || user_geo.key?(:lng)
+      validate_lng ||= 'lon' if user_geo.key?('lon') || user_geo.key?(:lon)
+      validate_lng ||= 'long' if user_geo.key?('long') || user_geo.key?(:long)
+      validate_lng ||= 'longitude' if user_geo.key?('longitude') || user_geo.key?(:longitude)
+
+      if validate_lat && validate_lng
+        # single hash
+        geo_object = GeoItem.new(db)
+        geo_object[:lat] = user_geo[validate_lat].to_f
+        geo_object[:lng] = user_geo[validate_lng].to_f
+        geo_object[:type] = 'point'
+
+        user_geo.keys.each do |key|
+          next if key == validate_lat || key == validate_lng
+          geo_object[key.to_sym] = user_geo[key]
+        end
+        geo_objects << geo_object
+      elsif user_geo.key?('path') || user_geo.key?(:path)
+        # try line or polygon
+        path_pts = []
+        path = user_geo['path'] if user_geo.key?('path')
+        path = user_geo[:path] if user_geo.key?(:path)
+
+        if path_pts[0].is_a?(Array) && path_pts[0][0].is_a?(Array)
+          # ring polygon
+          path.each do |ring|
+            ring.map! do |path_pt|
+              if lonlat
+                lat = path_pt[1] || path_pt[:lat]
+                lng = path_pt[0] || path_pt[:lng]
+              else
+                lat = path_pt[0] || path_pt[:lat]
+                lng = path_pt[1] || path_pt[:lng]
+              end
+              [lat, lng]
+            end
+          end
+          path_pts = path
+        else
+          path.each do |path_pt|
+            if lonlat
+              lat = path_pt[1] || path_pt[:lat]
+              lng = path_pt[0] || path_pt[:lng]
+            else
+              lat = path_pt[0] || path_pt[:lat]
+              lng = path_pt[1] || path_pt[:lng]
+            end
+            path_pts << [lat, lng]
+          end
+
+          # polygon border repeats first point
+          if path_pts[0] == path_pts.last
+            geo_type = 'polygon'
+            path_pts = [path_pts]
+          else
+            geo_type = 'polyline'
+          end
+        end
+
+        geoitem = GeoItem.new(db)
+        geoitem[:path] = path_pts
+        geoitem[:type] = geo_type
+
+        property_list = user_geo.clone
+        property_list = property_list[:properties] if property_list.key?(:properties)
+        property_list = property_list['properties'] if property_list.key?('properties')
+        property_list.delete(:path)
+        property_list.keys.each do |prop|
+          geoitem[prop.to_sym] = property_list[prop]
+        end
+
+        geo_objects << geoitem
+      elsif user_geo.key?('geo') || user_geo.key?(:geo)
+        # this key is GeoJSON or WKT
+        geotext = (user_geo['geo'] || user_geo[:geo])
+        if geotext.upcase.index('POINT(') || geotext.upcase.index('LINESTRING(') || geotext.upcase.index('POLYGON(')
+          # try WKT
+          geoitem = GeoItem.new(db)
+          geoitem = MapPLZ.parse_wkt(geoitem, geotext)
+        else
+          # GeoJSON
+          begin
+            geoitem = standardize_geo(JSON.parse(geotext), lonlat, db)[0]
+          rescue
+            # did not recognize format
+            raise 'did not recognize format in CSV geo column'
+          end
+        end
+        user_geo.keys.each do |key|
+          next if ['lat', 'lng', 'geo', 'geom', 'geojson', 'wkt', :lat, :lng, :geo, :geom, :geojson, :wkt].include?(key)
+          geoitem[key.to_sym] = user_geo[key]
+        end
+        geo_objects << geoitem
+      else
+        # try GeoJSON
+        if user_geo.key?(:type)
+          user_geo['type'] = user_geo[:type] || ''
+          user_geo['features'] = user_geo[:features] if user_geo.key?(:features)
+          user_geo['properties'] = user_geo[:properties] || {}
+          if user_geo.key?(:geometry)
+            user_geo['geometry'] = user_geo[:geometry]
+            user_geo['geometry']['type'] = user_geo[:geometry][:type]
+            user_geo['geometry']['coordinates'] = user_geo[:geometry][:coordinates]
+          end
+        end
+        if user_geo.key?('type')
+          if user_geo['type'] == 'FeatureCollection' && user_geo.key?('features')
+            # recursive onto features
+            user_geo['features'].each do |feature|
+              geo_objects += standardize_geo(feature, lonlat, db)
+            end
+          elsif user_geo.key?('geometry') && user_geo['geometry'].key?('coordinates')
+            # each feature
+            coordinates = user_geo['geometry']['coordinates']
+
+            if user_geo['geometry']['type'] == 'Point'
+              geo_object = GeoItem.new(db)
+              geo_object[:lat] = coordinates[1].to_f
+              geo_object[:lng] = coordinates[0].to_f
+              geo_object[:type] = 'point'
+              geo_objects << geo_object
+            elsif user_geo['geometry']['type'] == 'LineString'
+              geo_object = GeoItem.new(db)
+              MapPLZ.flip_path(coordinates)
+              geo_object[:path] = coordinates
+              geo_object[:type] = 'polyline'
+              geo_objects << geo_object
+            elsif user_geo['geometry']['type'] == 'Polygon'
+              geo_object = GeoItem.new(db)
+              coordinates.map! do |ring|
+                MapPLZ.flip_path(ring)
+              end
+              geo_object[:path] = coordinates
+              geo_object[:type] = 'polygon'
+              geo_objects << geo_object
+            elsif user_geo['geometry']['type'] == 'MultiPoint'
+              coordinates.each do |point|
+                geo_object = GeoItem.new(db)
+                geo_object[:lat] = point[1].to_f
+                geo_object[:lng] = point[0].to_f
+                geo_object[:type] = 'point'
+                geo_objects << geo_object
+              end
+            elsif user_geo['geometry']['type'] == 'MultiLineString'
+              coordinates.each do |line|
+                geo_object = GeoItem.new(db)
+                geo_object[:path] = MapPLZ.flip_path(line)
+                geo_object[:type] = 'polyline'
+                geo_objects << geo_object
+              end
+            elsif user_geo['geometry']['type'] == 'MultiPolygon'
+              coordinates.each do |poly|
+                geo_object = GeoItem.new(db)
+                poly.map! do |ring|
+                  MapPLZ.flip_path(ring)
+                end
+                geo_object[:path] = poly
+                geo_object[:type] = 'polygon'
+                geo_objects << geo_object
+              end
+            end
+
+            # store properties on all generated geometries
+            prop_keys = {}
+            if user_geo.key?('properties')
+              user_geo['properties'].keys.each do |key|
+                prop_keys[key.to_sym] = user_geo['properties'][key]
+              end
+            end
+            geo_objects.each do |geo|
+              prop_keys.keys.each do |key|
+                geo[key] = prop_keys[key]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    geo_objects
+  end
+
   # alias methods
 
   # aliases for add
@@ -293,9 +674,14 @@ class MapPLZ
 
   private
 
+  # internal error record
+  class MapPLZException < Exception
+  end
+
   # internal map object record
   class GeoItem < Hash
-    def initialize(db = { type: 'array', client: nil })
+    def initialize(db = nil)
+      db = { type: 'array', client: nil } if db.nil?
       @db = db
       @db_type = db[:type]
       @db_client = db[:client]
@@ -304,22 +690,28 @@ class MapPLZ
     def save!
       # update record in database
       if @db_type == 'mongodb'
-        consistent_id = self[:_id]
-        delete(:_id)
-        @db[:client].update({ _id: BSON::ObjectId(consistent_id) }, self)
-        self[:_id] = consistent_id
-      elsif @db_type == 'postgis' || @db_type == 'spatialite'
+        save_obj = clone
+        save_obj.delete(:_id)
+        save_obj.delete(:lat)
+        save_obj.delete(:lng)
+        save_obj.delete(:path)
+        save_obj.delete(:centroid)
+        save_obj.delete(:type)
+        save_obj[:geo] = JSON.parse(to_geojson)['geometry']
+        @db[:client].update({ _id: BSON::ObjectId(self[:_id]) }, save_obj)
+      elsif @db_type == 'postgis'
+        geojson_props = (JSON.parse(to_geojson)['properties'] || {})
+        @db_client.exec("UPDATE mapplz SET geom = ST_GeomFromText('#{to_wkt}'), properties = '#{geojson_props.to_json}' WHERE id = #{self[:id]}") if @db_type == 'postgis'
+      elsif @db_type == 'spatialite'
         updaters = []
         keys.each do |key|
-          next if [:id, :lat, :lng, :path, :type].include?(key)
+          next if [:id, :lat, :lng, :path, :type, :centroid].include?(key)
           updaters << "#{key} = '#{self[key]}'" if self[key].is_a?(String)
           updaters << "#{key} = #{self[key]}" if self[key].is_a?(Integer) || self[key].is_a?(Float)
         end
-        updaters << "geom = ST_GeomFromText('#{to_wkt}')" if @db_type == 'postgis'
-        updaters << "geom = AsText('#{to_wkt}')" if @db_type == 'spatialite'
+        updaters << "geom = AsText('#{to_wkt}')"
         if updaters.length > 0
-          @db_client.exec("UPDATE mapplz SET #{updaters.join(', ')} WHERE id = #{self[:id]}") if @db_type == 'postgis'
-          @db_client.execute("UPDATE mapplz SET #{updaters.join(', ')} WHERE id = #{self[:id]}") if @db_type == 'spatialite'
+          @db_client.execute("UPDATE mapplz SET #{updaters.join(', ')} WHERE id = #{self[:id]}")
         end
       end
     end
@@ -360,11 +752,12 @@ class MapPLZ
       if key?(:properties)
         property_list = { properties: self[:properties] }
       else
-        property_list = self.clone
+        property_list = clone
         property_list.delete(:lat)
         property_list.delete(:lng)
         property_list.delete(:path)
         property_list.delete(:type)
+        property_list.delete(:centroid)
       end
 
       output_geo = {
@@ -386,13 +779,119 @@ class MapPLZ
         }
       elsif self[:type] == 'polygon'
         # polygon
+        rings = self[:path].clone
+        rings.map! do |ring|
+          MapPLZ.flip_path(ring)
+        end
         output_geo[:geometry] = {
           type: 'Polygon',
-          coordinates: [MapPLZ.flip_path(self[:path])]
+          coordinates: rings
         }
       end
       output_geo.to_json
     end
+
+    def centroid
+      # verify up-to-date centroid exists
+      path_hash = Digest::SHA256.digest(self[:path].to_s)
+      (key?(:path) && key?(:centroid) && self[:centroid] == path_hash)
+    end
+
+    def distance_from(user_geo)
+      GeoItem.centroid(self)
+      user_geo = MapPLZ.standardize_geo(user_geo)[0]
+      GeoItem.centroid(user_geo)
+
+      Geokdtree::Tree.distance([user_geo[:lat], user_geo[:lng]], [self[:lat], self[:lng]])
+    end
+
+    def inside?(user_geo)
+      GeoItem.centroid(self)
+
+      # accept [point1, point2, point3, point1] as a polygon search area
+      if user_geo.is_a?(Array) && user_geo[0].is_a?(Array) && !user_geo[0][0].is_a?(Array)
+        user_geo = [user_geo]
+      end
+
+      user_geo = MapPLZ.standardize_geo(user_geo)[0]
+      path_pts = user_geo[:path]
+      path_pts = path_pts[0] if user_geo[:type] == 'polygon'
+
+      # point in polygon from http://jakescruggs.blogspot.com/2009/07/point-inside-polygon-in-ruby.html
+      c = false
+      i = -1
+      j = path_pts.size - 1
+      while (i += 1) < path_pts.size
+        if (path_pts[i][0] <= self[:lat] && self[:lat] < path_pts[j][0]) || (path_pts[j][0] <= self[:lat] && self[:lat] < path_pts[i][0])
+          if self[:lng] < (path_pts[j][1] - path_pts[i][1]) * (self[:lat] - path_pts[i][0]) / (path_pts[j][0] - path_pts[i][0]) + path_pts[i][1]
+            c = !c
+          end
+        end
+        j = i
+      end
+      c
+    end
+
+    def self.centroid(geo_item)
+      # generate centroid if possible and not already existing
+      if geo_item.key?(:path) && !geo_item.centroid
+        coordinates = geo_item[:path].clone
+
+        # centroid calculation from https://code.google.com/p/tokland/source/browse/trunk/centroid
+        consecutive_pairs = (coordinates + [coordinates.first]).each_cons(2)
+        area = 0.5 * consecutive_pairs.map do |(x0, y0), (x1, y1)|
+          (x0 * y1) - (x1 * y0)
+        end
+        area.inject(:+)
+
+        consecutive_pairs.map! do |(x0, y0), (x1, y1)|
+          cross = (x0 * y1 - x1 * y0)
+          [(x0 + x1) * cross, (y0 + y1) * cross]
+        end
+        (center_lat, center_lng) = consecutive_pairs.transpose.map do |cs|
+          cs.inject(:+) / (6 * area)
+        end
+
+        geo_item[:centroid] = Digest::SHA256.digest(geo_item[:path].to_s)
+        geo_item[:lat] = center_lat
+        geo_item[:lng] = center_lng
+      end
+    end
+  end
+
+  def read_cursor(cursor)
+    if cursor.nil?
+      []
+    else
+      geo_results = []
+      cursor.each do |geo_result|
+        if @db_type == 'postgis'
+          geo_item = GeoItem.new(@db)
+          geom = (geo_result['geo'] || geo_result[:geo]).upcase
+          geo_item = MapPLZ.parse_wkt(geo_item, geom)
+          geo_result = JSON.parse(geo_result['properties'])
+        elsif @db_type == 'spatialite'
+          geo_item = GeoItem.new(@db)
+          geom = (geo_result['geo'] || geo_result[:geo]).upcase
+          geo_item = MapPLZ.parse_wkt(geo_item, geom)
+        elsif @db_type == 'mongodb'
+          geom = { 'type' => 'Feature', 'geometry' => geo_result['geo'] }
+          geo_item = MapPLZ.standardize_geo(geom, true, @db)[0]
+        end
+
+        if geo_result.is_a?(Array)
+          geo_item[:properties] = geo_result
+        else
+          geo_result.keys.each do |key|
+            next if [:geo].include?(key.to_sym)
+            geo_item[key.to_sym] = geo_result[key]
+          end
+        end
+
+        geo_results << geo_item
+      end
+      geo_results
+    end
   end
 
   def code_line(index)
@@ -515,241 +1014,6 @@ class MapPLZ
     code_line(index + 1)
   end
 
-  def standardize_geo(user_geo, lonlat = false)
-    geo_objects = []
-
-    if user_geo.is_a?(String)
-      begin
-        user_geo = JSON.parse(user_geo)
-      rescue
-        # not JSON string - attempt mapplz parse
-        return code(user_geo)
-      end
-    end
-
-    if user_geo.is_a?(Array) && user_geo.length > 0
-      if user_geo[0].is_a?(Array) && user_geo[0].length > 0
-        if user_geo[0][0].is_a?(Array) || (user_geo[0][0].is_a?(Hash) && user_geo[0][0].key?(:lat) && user_geo[0][0].key?(:lng))
-          # lines and shapes
-          user_geo.map! do |path|
-            path_pts = []
-            path.each do |path_pt|
-              if lonlat
-                lat = path_pt[1] || path_pt[:lat]
-                lng = path_pt[0] || path_pt[:lng]
-              else
-                lat = path_pt[0] || path_pt[:lat]
-                lng = path_pt[1] || path_pt[:lng]
-              end
-              path_pts << [lat, lng]
-            end
-
-            # polygon border repeats first point
-            if path_pts[0] == path_pts.last
-              geo_type = 'polygon'
-            else
-              geo_type = 'polyline'
-            end
-
-            geoitem = GeoItem.new(@db)
-            geoitem[:path] = path_pts
-            geoitem[:type] = geo_type
-            geoitem
-          end
-          return user_geo
-        end
-      end
-
-      # multiple objects being added? iterate through
-      if user_geo[0].is_a?(Hash) || user_geo[0].is_a?(Array)
-        user_geo.each do |geo_piece|
-          geo_objects += standardize_geo(geo_piece)
-        end
-        return geo_objects
-      end
-
-      # first two spots are a coordinate
-      validate_lat = user_geo[0].to_f != 0 || user_geo[0].to_s == '0'
-      validate_lng = user_geo[1].to_f != 0 || user_geo[1].to_s == '0'
-
-      if validate_lat && validate_lng
-        geo_object = GeoItem.new(@db)
-        geo_object[:type] = 'point'
-
-        if lonlat
-          geo_object[:lat] = user_geo[1].to_f
-          geo_object[:lng] = user_geo[0].to_f
-        else
-          geo_object[:lat] = user_geo[0].to_f
-          geo_object[:lng] = user_geo[1].to_f
-        end
-      else
-        fail 'no latitude or longitude found'
-      end
-
-      # assume user properties are an ordered array of values known to the user
-      user_properties = user_geo.drop(2)
-
-      # only one property and it's a hash? it's a hash of properties
-      if user_properties.length == 1 && user_properties[0].is_a?(Hash)
-        user_properties[0].keys.each do |key|
-          geo_object[key.to_sym] = user_properties[0][key]
-        end
-      else
-        geo_object[:properties] = user_properties
-      end
-
-      geo_objects << geo_object
-
-    elsif user_geo.is_a?(Hash)
-      # check for lat and lng
-      validate_lat = false
-      validate_lat = 'lat' if user_geo.key?('lat') || user_geo.key?(:lat)
-      validate_lat ||= 'latitude' if user_geo.key?('latitude') || user_geo.key?(:latitude)
-
-      validate_lng = false
-      validate_lng = 'lng' if user_geo.key?('lng') || user_geo.key?(:lng)
-      validate_lng ||= 'lon' if user_geo.key?('lon') || user_geo.key?(:lon)
-      validate_lng ||= 'long' if user_geo.key?('long') || user_geo.key?(:long)
-      validate_lng ||= 'longitude' if user_geo.key?('longitude') || user_geo.key?(:longitude)
-
-      if validate_lat && validate_lng
-        # single hash
-        geo_object = GeoItem.new(@db)
-        geo_object[:lat] = user_geo[validate_lat].to_f
-        geo_object[:lng] = user_geo[validate_lng].to_f
-        geo_object[:type] = 'point'
-
-        user_geo.keys.each do |key|
-          next if key == validate_lat || key == validate_lng
-          geo_object[key.to_sym] = user_geo[key]
-        end
-        geo_objects << geo_object
-      elsif user_geo.key?('path') || user_geo.key?(:path)
-        # try line or polygon
-        path_pts = []
-        path = user_geo['path'] if user_geo.key?('path')
-        path = user_geo[:path] if user_geo.key?(:path)
-        path.each do |path_pt|
-          if lonlat
-            lat = path_pt[1] || path_pt[:lat]
-            lng = path_pt[0] || path_pt[:lng]
-          else
-            lat = path_pt[0] || path_pt[:lat]
-            lng = path_pt[1] || path_pt[:lng]
-          end
-          path_pts << [lat, lng]
-        end
-
-        # polygon border repeats first point
-        if path_pts[0] == path_pts.last
-          geo_type = 'polygon'
-        else
-          geo_type = 'polyline'
-        end
-
-        geoitem = GeoItem.new(@db)
-        geoitem[:path] = path_pts
-        geoitem[:type] = geo_type
-
-        property_list = user_geo.clone
-        property_list = property_list[:properties] if property_list.key?(:properties)
-        property_list = property_list['properties'] if property_list.key?('properties')
-        property_list.delete(:path)
-        property_list.keys.each do |prop|
-          geoitem[prop.to_sym] = property_list[prop]
-        end
-
-        geo_objects << geoitem
-      else
-        # try GeoJSON
-        if user_geo.key?(:type)
-          user_geo['type'] = user_geo[:type] || ''
-          user_geo['features'] = user_geo[:features] if user_geo.key?(:features)
-          user_geo['properties'] = user_geo[:properties] || {}
-          if user_geo.key?(:geometry)
-            user_geo['geometry'] = user_geo[:geometry]
-            user_geo['geometry']['type'] = user_geo[:geometry][:type]
-            user_geo['geometry']['coordinates'] = user_geo[:geometry][:coordinates]
-          end
-        end
-        if user_geo.key?('type')
-          if user_geo['type'] == 'FeatureCollection' && user_geo.key?('features')
-            # recursive onto features
-            user_geo['features'].each do |feature|
-              geo_objects += standardize_geo(feature)
-            end
-          elsif user_geo.key?('geometry') && user_geo['geometry'].key?('coordinates')
-            # each feature
-            coordinates = user_geo['geometry']['coordinates']
-
-            if user_geo['geometry']['type'] == 'Point'
-              geo_object = GeoItem.new(@db)
-              geo_object[:lat] = coordinates[1].to_f
-              geo_object[:lng] = coordinates[0].to_f
-              geo_object[:type] = 'point'
-              geo_objects << geo_object
-            elsif user_geo['geometry']['type'] == 'LineString'
-              geo_object = GeoItem.new(@db)
-              MapPLZ.flip_path(coordinates)
-              geo_object[:path] = coordinates
-              geo_object[:type] = 'polyline'
-              geo_objects << geo_object
-            elsif user_geo['geometry']['type'] == 'Polygon'
-              geo_object = GeoItem.new(@db)
-              coordinates.map! do |ring|
-                MapPLZ.flip_path(ring)
-              end
-              geo_object[:path] = coordinates
-              geo_object[:type] = 'polygon'
-              geo_objects << geo_object
-            elsif user_geo['geometry']['type'] == 'MultiPoint'
-              coordinates.each do |point|
-                geo_object = GeoItem.new(@db)
-                geo_object[:lat] = point[1].to_f
-                geo_object[:lng] = point[0].to_f
-                geo_object[:type] = 'point'
-                geo_objects << geo_object
-              end
-            elsif user_geo['geometry']['type'] == 'MultiLineString'
-              coordinates.each do |line|
-                geo_object = GeoItem.new(@db)
-                geo_object[:path] = MapPLZ.flip_path(line)
-                geo_object[:type] = 'polyline'
-                geo_objects << geo_object
-              end
-            elsif user_geo['geometry']['type'] == 'MultiPolygon'
-              coordinates.each do |poly|
-                geo_object = GeoItem.new(@db)
-                poly.map! do |ring|
-                  MapPLZ.flip_path(ring)
-                end
-                geo_object[:path] = poly
-                geo_object[:type] = 'polygon'
-                geo_objects << geo_object
-              end
-            end
-
-            # store properties on all generated geometries
-            prop_keys = {}
-            if user_geo.key?('properties')
-              user_geo['properties'].keys.each do |key|
-                prop_keys[key.to_sym] = user_geo['properties'][key]
-              end
-            end
-            geo_objects.each do |geo|
-              prop_keys.keys.each do |key|
-                geo[key] = prop_keys[key]
-              end
-            end
-          end
-        end
-      end
-    end
-
-    geo_objects
-  end
-
   def parse_sql(where_clause, add_on = nil)
     where_clause.downcase! unless where_clause.blank?
     where_clause = where_clause.gsub('?', '\'?\'') if add_on.present?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mapplz
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Nick Doiron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-10 00:00:00.000000000 Z
+date: 2014-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec