def query(self, sw_lat, sw_lng, ne_lat, ne_lng, max_results=1000): bounds = geotypes.Box(float(ne_lat), float(ne_lng), float(sw_lat), float(sw_lng)) base_query = Shop.all() return Shop.bounding_box_fetch(base_query, bounds, max_results)
def get_user_data(self, user=None, lat_north=90, lng_west=-180, range_lat=-180, range_lng=360, max_results=2000): # log.info("GeoRange: (%6.4f, %6.4f) ZoomStep: (%6.4f, %6.4f)" % (lat_north, lng_west, range_lat, range_lng)) # log.info("Range: (%6.4f - %6.4f), (%6.4f - %6.4f)" % (min(90, max(-90, lat_north + range_lat)), lat_north, min(180, max(-180, lng_west + range_lng)), lng_west)) if user: # not sure why Google was giving latitudes outside of the allowable range near the International Date Line at zoom level 3, # but cap it to the max anyway here. this might result in incorrectly drawn tiles near there, but oh well. if lng_west < -180: lng_west = -180 return UserVenue.bounding_box_fetch( UserVenue.all().filter('user ='******'-last_checkin_at' ), #TODO find a way to specify this elsewhere!! geotypes.Box(min(90, max(-90, lat_north + range_lat)), min(180, max(-180, lng_west + range_lng)), lat_north, lng_west), max_results, ) else: return []
def nearby_items(): response.content_type = 'application/json' if (nearby_param_validate(request) == False): return {'status': 'error-query-paras'} try: if (request.query.type == 'box'): bounds = geotypes.Box(float(request.query.north), float(request.query.east), float(request.query.south), float(request.query.west)) elif (request.query.type == 'center'): center = geotypes.Point(float(request.query.lat), float(request.query.lon)) except: return {'status': 'invalid-query-paras'} max_results = int(request.query.maxresults or '100') max_distance = float(request.query.maxdistance or '80000') # 80 km ~ 50 mi try: base_query = Item.all() if (request.query.type == 'box'): results = Item.bounding_box_fetch(base_query, bounds, max_results=max_results) elif (request.query.type == 'center'): results = Item.proximity_fetch(base_query, center, max_results=max_results, max_distance=max_distance) return results_dump(results) except: return {'status': 'error-database-query'}
def getClosestRecording(lat, lon, search_radius, random_radius): import geoUtils qry = Recording.query(Recording.approved == REC_APPROVED_STATE_TRUE) latMin, lonMin, latMax, lonMax = geoUtils.getBoxCoordinates(lat, lon, search_radius) logging.debug("Lat={}, Lon={}, radius={}, latMin={}, lonMin={}, latMax={}, lonMax={}".format( lat, lon, search_radius, latMin, lonMin, latMax, lonMax)) box = geotypes.Box(latMax, lonMax, latMin, lonMin) # north, east, south, west recs = Recording.bounding_box_fetch(qry, box) num_results = len(recs) if num_results==0: return None if num_results==1: return recs[0] else: minDstRecs = [] minDst = sys.maxint for r in qry: dst = geoUtils.distance((lat,lon),(r.location.lat, r.location.lon)) if dst<(minDst-random_radius): minDst = dst minDstRecs = [r] elif dst<(minDst+random_radius): minDstRecs.append(r) size = len(minDstRecs) randomIndx = int(size*random.random()) return minDstRecs[randomIndx]
def square_bounding_box_centered_at(latitude, longitude, side_in_miles): side_in_meters = miles_to_meters(side_in_miles) latitude_halfside_in_degrees = latitudinal_degrees_from_meters( side_in_meters) / 2.0 longitude_halfside_in_degrees = longitudinal_degrees_from_meters_at_latitude( side_in_meters, latitude) / 2.0 return geotypes.Box(north=latitude + latitude_halfside_in_degrees, east=longitude + longitude_halfside_in_degrees, south=latitude - latitude_halfside_in_degrees, west=longitude - longitude_halfside_in_degrees)
def test_Box(self): # an invalid box self.assertRaises(ValueError, geotypes.Box, 95, 0, 0, 0) # a valid box box = geotypes.Box(37, -122, 34, -125) self.assertEquals(37, box.north) self.assertEquals(34, box.south) self.assertEquals(-122, box.east) self.assertEquals(-125, box.west) # assert north can't be under south self.assertRaises(ValueError, box._set_north, 32) self.assertRaises(ValueError, box._set_south, 39) self.assertTrue(isinstance(box.__str__(), str)) # valid boxes self.assertEquals(geotypes.Box(37, -122, 34, -125), geotypes.Box(34, -122, 37, -125))
def getClosestActiveFermata(lat, lon, radius): origin_point = (lat, lon) latMin, lonMin, latMax, lonMax = geoUtils.getBoxCoordinates( lat, lon, radius) box = geotypes.Box(latMax, lonMax, latMin, lonMin) # north, east, south, west qry = Fermata.query(Fermata.active == True) fermate = Fermata.bounding_box_fetch(qry, box) if fermate: return min( fermate, key=lambda f: geoUtils.distance(origin_point, (f.location.lat, f.location.lon)))
def get_data(self, zoom, layer, lat_north, lng_west, range_lat, range_lng, category, metro): log.info("GeoRange: (%6.4f, %6.4f) ZoomStep: (%6.4f, %6.4f)" % (lat_north, lng_west, range_lat, range_lng)) log.info("Range: (%6.4f - %6.4f), (%6.4f - %6.4f)" % (min(90, max(-90, lat_north + range_lat)), lat_north, min(180, max(-180, lng_west + range_lng)), lng_west)) return DataPoint.bounding_box_fetch( DataPoint.all().filter('category', category).filter('metro', metro), geotypes.Box(min(90, max(-90, lat_north + range_lat)), min(180, max(-180, lng_west + range_lng)), lat_north, lng_west), max_results=1000)
def get_all_data(self, user=None, lat_north=90, lng_west=-180, range_lat=-180, range_lng=360, max_results=2000): if user: self.get_user_data(user, lat_north, lng_west, range_lat, range_lng, max_results) else: return UserVenue.bounding_box_fetch( UserVenue.all().order('-last_checkin_at'), geotypes.Box(min(90, max(-90, lat_north + range_lat)), min(180, max(-180, lng_west + range_lng)), lat_north, lng_west), max_results, )
def get(self): def _simple_error(message, code=400): self.error(code) self.response.out.write( simplejson.dumps({ 'status': 'error', 'error': { 'message': message }, 'results': [] })) return None self.response.headers['Content-Type'] = 'application/json' query_type = self.request.get('type') user = self.request.get('user') if not query_type in ['proximity', 'bounds', 'user', 'default']: return _simple_error( 'type parameter must be ' 'one of "proximity", "bounds", "user".', code=400) if query_type == 'proximity': try: center = geotypes.Point(float(self.request.get('lat')), float(self.request.get('lon'))) except ValueError: return _simple_error( 'lat and lon parameters must be valid latitude ' 'and longitude values.') elif query_type == 'bounds': try: bounds = geotypes.Box(float(self.request.get('north')), float(self.request.get('east')), float(self.request.get('south')), float(self.request.get('west'))) except ValueError: return _simple_error( 'north, south, east, and west parameters must be ' 'valid latitude/longitude values.') max_results = 100 if self.request.get('maxresults'): max_results = int(self.request.get('maxresults')) max_distance = 8000000 # 80 km ~ 50 mi if self.request.get('maxdistance'): max_distance = float(self.request.get('maxdistance')) results = [] try: # Can't provide an ordering here in case inequality filters are used. base_query = Listing.all() #if property_type: #base_query.filter('property_type =', property_type) # Natural ordering chosen to be public school enrollment. #base_query.order('-') # Perform proximity or bounds fetch. if query_type == 'proximity': results = Listing.proximity_fetch(base_query, center, max_results=max_results, max_distance=max_distance) elif query_type == 'bounds': results = Listing.bounding_box_fetch(base_query, bounds, max_results=max_results) elif query_type == 'user': limit = self.request.get("limit") offset = self.request.get("offset") if not limit: limit = 1000 else: limit = int(limit) if not offset: offset = 0 else: offset = int(offset) results = base_query.fetch(limit, offset) public_attrs = Listing.public_attributes() results_obj = [ _merge_dicts( { 'lat': result.location.lat, 'lng': result.location.lon, }, dict([(attr, getattr(result, attr)) for attr in public_attrs])) for result in results ] self.response.out.write( simplejson.dumps({ 'status': 'success', 'results': results_obj, })) except: return _simple_error(str(sys.exc_info()[1]), code=500)
def doSearch(self, cursor_key, **kwargs): query_type = self.request["query_type"] if not query_type in ['proximity', 'bounds']: return _simple_error( 'El parámetro de búsqueda debe ser "proximity" o "bounds".', code=400) if query_type == 'proximity': try: center = geotypes.Point(float(self.request['lat']), float(self.request['lon'])) except ValueError: return _simple_error( 'lat and lon parameters must be valid latitude and longitude values.', code=400) elif query_type == 'bounds': try: bounds = geotypes.Box(float(self.request['north']), float(self.request['east']), float(self.request['south']), float(self.request['west'])) except ValueError: return _simple_error( 'north, south, east, and west parameters must be valid latitude/longitude values.', code=400) max_distance = 80000 # 80 km ~ 50 mi if self.request.has_key('max_distance'): max_distance = float(self.request['max_distance']) #---extirpado-- base_query, price_data = create_query_from_dict( self.request, PropertyIndex) #---extirpado-- max_results = MAX_QUERY_RESULTS if self.request.has_key('max_results'): max_results = int(self.request['max_results']) results, the_box, new_cursor_key = Property.bounding_box_fetch( base_query, bounds, max_results=max_results, cost_function=None, cursor_key=cursor_key) total_count = 'cientos' viewing_count = len(results) return { 'properties': results, 'total_count': total_count, 'viewing': viewing_count, 'the_box': '<br/>' + the_box + '<br/><br/>cursor_key:' + str(cursor_key), 'cursor_key': new_cursor_key, 'price_data': price_data }
def select(self, action): obj_list = [] max_features = action.maxfeatures or 1000 if action.id: obj = self.model.get_by_id(action.id) if obj: obj_list = [obj] else: obj_list = self.model.all() if action.attributes: current_key = None for key, value in action.attributes.items(): if isinstance(value, dict): obj_list = obj_list.filter( "%s %s" % (value['column'], self.query_action_string[value['type']]), value['value']) else: try: value = int(value) except: pass obj_list = obj_list.filter("%s =" % key, value) if action.bbox: #geocell likes N,E,S,W bbox with W, S, E, N = action.bbox #also needs to be valid wgs84 coords W = max(W, -180) E = min(E, 180) S = max(S, -90) N = min(N, 90) obj_list = self.model.bounding_box_fetch( obj_list, geotypes.Box(N, E, S, W), max_results=max_features) return_list = [] for obj in obj_list[:max_features]: props = {} #get attribs for model for key in self.model.fields(): if not key in self.excluded_fields: try: props[key] = getattr(obj, key) except: props[key] = None #get additional attribs for expando stuff for key in obj.dynamic_properties(): try: props[key] = getattr(obj, key) except: props[key] = None try: geom = from_wkt(obj.geometry) except: logging.error('fail on obj %s' % key) continue return_list.append( Feature(id=action.id, geometry=from_wkt(obj.geometry), srs=self.srid_out, props=props)) return return_list
def get(self): def _simple_error(message, code=400): self.error(code) self.response.out.write(simplejson.dumps({ 'status': 'error', 'error': { 'message': message }, 'results': [] })) return None self.response.headers['Content-Type'] = 'application/json' query_type = self.request.get('type') if not query_type in ['proximity', 'bounds']: return _simple_error('type parameter must be ' 'one of "proximity", "bounds".', code=400) if query_type == 'proximity': try: center = geotypes.Point(float(self.request.get('lat')), float(self.request.get('lon'))) except ValueError: return _simple_error('lat and lon parameters must be valid latitude ' 'and longitude values.') elif query_type == 'bounds': try: bounds = geotypes.Box(float(self.request.get('north')), float(self.request.get('east')), float(self.request.get('south')), float(self.request.get('west'))) except ValueError: return _simple_error('north, south, east, and west parameters must be ' 'valid latitude/longitude values.') max_results = 100 if self.request.get('maxresults'): max_results = int(self.request.get('maxresults')) max_distance = 80000 # 80 km ~ 50 mi if self.request.get('maxdistance'): max_distance = float(self.request.get('maxdistance')) school_type = None if self.request.get('schooltype'): try: school_type = int(self.request.get('schooltype')) except ValueError: return _simple_error('If schooltype is provided, ' 'it must be a valid number, as defined in ' 'http://nces.ed.gov/ccd/psadd.asp#type') grade_range = None if self.request.get('mingrade') or self.request.get('maxgrade'): try: grade_range = (int(self.request.get('mingrade')), int(self.request.get('maxgrade'))) if grade_range[0] > grade_range[1]: return _simple_error('mingrade cannot exceed maxgrade.') except ValueError: return _simple_error('If mingrade or maxgrade is provided, ' 'both must be valid integers.') try: # Can't provide an ordering here in case inequality filters are used. base_query = PublicSchool.all() # Add in advanced options (rich query). if grade_range: if grade_range[0] == grade_range[1]: # WARNING: don't forget to build this edge case index! base_query.filter('grades_taught =', grade_range[0]) else: (base_query.filter('grades_taught >=', grade_range[0]) .filter('grades_taught <=', grade_range[1])) # App Engine requires inequality filtered properties to be # the first ordering. Also apply this ordering for grades_taught = # filters to simplify indexes. base_query.order('grades_taught') if school_type: base_query.filter('school_type =', school_type) # Natural ordering chosen to be public school enrollment. base_query.order('-enrollment') # Perform proximity or bounds fetch. if query_type == 'proximity': results = PublicSchool.proximity_fetch( base_query, center, max_results=max_results, max_distance=max_distance) elif query_type == 'bounds': results = PublicSchool.bounding_box_fetch( base_query, bounds, max_results=max_results) public_attrs = PublicSchool.public_attributes() results_obj = [ _merge_dicts({ 'lat': result.location.lat, 'lng': result.location.lon, 'lowest_grade_taught': min(result.grades_taught) if result.grades_taught else None, 'highest_grade_taught': max(result.grades_taught) if result.grades_taught else None, }, dict([(attr, getattr(result, attr)) for attr in public_attrs])) for result in results] self.response.out.write(simplejson.dumps({ 'status': 'success', 'results': results_obj })) except: return _simple_error(str(sys.exc_info()[1]), code=500)