def update_site_covariates(site): site_pk = site.pk point = site.location north_pole = (90, 0) south_pole = (-90, 0) existing_covariates = set(site.covariates.all().values_list("name", flat=True)) supported_covariates = set([c for c, _ in Covariate.SUPPORTED_COVARIATES]) coral_atlas = CoralAtlasCovariate() if ((site_pk and Site.objects.get(pk=site_pk).location == point and not supported_covariates.difference(existing_covariates)) or geopy_distance( (point.y, point.x), north_pole).km < coral_atlas.radius or geopy_distance( (point.y, point.x), south_pole).km < coral_atlas.radius): return results = coral_atlas.fetch([(point.x, point.y)]) if not results: return result = results[0] data_date = result["date"] requested_date = result["requested_date"] aca_covariates = result.get("covariates") or dict() aca_benthic = aca_covariates.get("aca_benthic") or [] aca_geomorphic = aca_covariates.get("aca_geomorphic") or [] aca_benthic_covariate = Covariate.objects.get_or_none( name="aca_benthic", site_id=site_pk) or Covariate(name="aca_benthic", site=site) aca_benthic_covariate.display = "Alan Coral Atlas Benthic" aca_benthic_covariate.datestamp = data_date aca_benthic_covariate.requested_datestamp = requested_date aca_benthic_covariate.value = aca_benthic aca_benthic_covariate.save() aca_geomorphic_covariate = Covariate.objects.get_or_none( name="aca_geomorphic", site=site) or Covariate(name="aca_geomorphic", site=site) aca_geomorphic_covariate.display = "Alan Coral Atlas Geomorphic" aca_geomorphic_covariate.datestamp = data_date aca_geomorphic_covariate.requested_datestamp = requested_date aca_geomorphic_covariate.value = aca_geomorphic aca_geomorphic_covariate.save()
def resolve_tweet(self, tweet): # The Twitter API allows tweet['coordinates'] to both be absent # and None, such that the key exists but has a None value. # "tweet.get('coordinates', {})" would return None in the latter # case, with None.get() in turn causing an AttributeError. (None # or {}), on the other hand, is {}, and {}.get() is okay. tweet_coordinates = (tweet.get('coordinates') or {}).get('coordinates') if not tweet_coordinates: return None tweet_coordinates = Point(longitude=tweet_coordinates[0], latitude=tweet_coordinates[1]) closest_candidate = None closest_distance = float('inf') for cell in self._cells_for(tweet_coordinates.latitude, tweet_coordinates.longitude): for candidate in self.location_map[cell]: candidate_coordinates = Point( candidate.latitude, candidate.longitude) distance = geopy_distance( tweet_coordinates, candidate_coordinates).miles if closest_distance > distance: closest_candidate = candidate closest_distance = distance if closest_distance < self.max_distance: return (False, closest_candidate) return None
def get_customers_within_miles(self, x=5): from geopy.distance import distance as geopy_distance return [ i.pk for i in Customer.objects.all() if i.location and self.location and geopy_distance(i.location.location, self.location.location).mi <= x ]
def findInteractionDataFromShapes(sourceShape, sourceCollarDataPoint, distance=settings.DEFAULT_INTERACTION_DISTANCE, timedelta=None, starttime=None, endtime=None, interactiongroup=None): """ findInteractionDataFromShapes does the same as the above function for animals but with shapes. """ list_of_data_points_to_search = CollarData.objects.all() if starttime: if endtime: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__range=(starttime, endtime)) else: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__gte=starttime) elif endtime: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__lte=endtime) if distance: list_of_data_points_to_search = list_of_data_points_to_search.filter(LOCATION__distance_lte=(sourceShape.shape, D(km=distance))) if timedelta: real_time_delta = datetime.timedelta(seconds=timedelta) start_delta = sourceCollarDataPoint.GMT_DATETIME - real_time_delta end_delta = sourceCollarDataPoint.GMT_DATETIME + real_time_delta list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__range=(start_delta, end_delta)) for match in list_of_data_points_to_search: shape_interaction_to_add = ShapeInteraction() shape_interaction_to_add.source_shapes = sourceShape shape_interaction_to_add.destination_animal_data_point = match shape_interaction_to_add.distance = geopy_distance(sourceShape.shape,match.LOCATION).kilometers shape_interaction_to_add.interaction_group = interactiongroup shape_interaction_to_add.date_time = match.GMT_DATETIME try: shape_interaction_to_add.clean() shape_interaction_to_add.save() except ValidationError: print "The entry already exists" zip_content = ContentFile(exportShape()) interactiongroup.zip_file.save("sampleFile.zip",zip_content) interactiongroup.save()
def find_place_from_info(info, provider): from .venue_providers import venue_providers venue_provider = venue_providers[provider] if not info.get('geo'): if not info.get('address'): print('No address found.') return address = info['address'] point, formatted_address = geocode(address) if not point: print('Geocoding failed.', address) return info['geo'] = point info['address'] = formatted_address place = venue_provider.match_place( [info['geo'].coords[1], info['geo'].coords[0]], info['name']) if not place: print('No match found.') return None place_point = Point(place['lng'], place['lat']) distance = geopy_distance(place_point, info['geo']) if distance.meters > 100: print('Matches too far away.') return None place['geo'] = place_point return place
def resolve_tweet(self, tweet): # The Twitter API allows tweet['coordinates'] to both be absent # and None, such that the key exists but has a None value. # "tweet.get('coordinates', {})" would return None in the latter # case, with None.get() in turn causing an AttributeError. (None # or {}), on the other hand, is {}, and {}.get() is okay. tweet_coordinates = (tweet.get('coordinates') or {}).get('coordinates') if not tweet_coordinates: return None tweet_coordinates = Point(longitude=tweet_coordinates[0], latitude=tweet_coordinates[1]) closest_candidate = None closest_distance = float('inf') for cell in self._cells_for(tweet_coordinates.latitude, tweet_coordinates.longitude): for candidate in self.location_map[cell]: candidate_coordinates = Point(candidate.latitude, candidate.longitude) distance = geopy_distance(tweet_coordinates, candidate_coordinates).miles if closest_distance > distance: closest_candidate = candidate closest_distance = distance if closest_distance < self.max_distance: return (False, closest_candidate) return None
def get(self,request): latitude = self.request.query_params.get('latitude') longitude = self.request.query_params.get('longitude') radius = self.request.query_params.get('radius') point1 = Point(float(latitude), float(longitude)) count = 0 avg = 0 std = 0 values = [] for res in Restaurants.objects.raw('select * from melp_res_restaurants'): point2 = Point(res.lat, res.lng) result = geopy_distance(point1,point2).meters if int(result) <= int(radius): count = count + 1; avg = avg + res.rating values.append(res.rating) if count > 0: avg = avg/count addition = 0 for val in values: addition = addition + abs(val-avg)**2 std = math.sqrt(addition/count) return Response({ "count": count, "avg": avg, "std": std, })
def length(self): '''Determine the length of the route.''' points = (waypoint.point for waypoint in self.waypoint_set.orderby('time')) meters = sum( geopy_distance(a, b).meters for (a, b) in pairwise(points)) return Distance(m=meters)
def get_distance(request): if request.method == "GET": user = request.user serialized_user = serializers.serialize('json', [ user ]) user_latitude = request.GET.get('user_latitude') user_longitude = request.GET.get('user_longitude') user_position = (user_latitude, user_longitude) # fixed_position = (41.8781, 87.6298) fixed_position = (-1.3034531999999999, 36.7927116) #fixed_position = (-1.2828671999999999, 36.831232) distance = geopy_distance(user_position, fixed_position) my_user ={ "first_name":user.first_name, "last_name":user.last_name } dist = distance.meters context = { "distance":dist, "user":serialized_user, "user_data":my_user } print(dist) return JsonResponse(context,safe=False)
def run(self): self.logging.info("Running Gps..") nm2km = 1.852 idx = 0 self.current_position = self.vessel["start_point"] self.next_waypoint = self.vessel["waypoints"][idx] while True: # Coordinates lat1 = self.current_position["lat"] lon1 = self.current_position["lon"] lat2 = self.next_waypoint["lat"] lon2 = self.next_waypoint["lon"] kts = self.current_position["kts"] # Nm travelled over the last random_sleep distance = (kts / 3600) * self.random_sleep bearing = self.get_bearing(lat1, lon1, lat2, lon2) origin = geopy.Point(lat1, lon1) destination = geodesic(kilometers=(distance * nm2km)).destination( origin, bearing) msg = self.gll(destination.latitude, destination.longitude) self.logging.info("{}{}".format(self.log_prefix, msg)) self.mqtt_publisher.publish(self.vessel["id"], msg) msg = self.hdt(bearing) self.logging.info("{}{}".format(self.log_prefix, msg)) self.mqtt_publisher.publish(self.vessel["id"], msg) msg = self.vhw(bearing, kts) self.logging.info("{}{}".format(self.log_prefix, msg)) self.mqtt_publisher.publish(self.vessel["id"], msg) self.current_position["lat"] = destination.latitude self.current_position["lon"] = destination.longitude # Work out how close to waypoint we are. distanceToWaypoint = geopy_distance( geopy.Point(self.current_position["lat"], self.current_position["lon"]), geopy.Point(lat2, lon2)).miles if distanceToWaypoint < 1: if idx == (len(self.vessel["waypoints"]) - 1): idx = 0 else: idx += 1 self.current_position = self.next_waypoint self.next_waypoint = self.vessel["waypoints"][idx] # print("DISTANCE", distanceToWaypoint) time.sleep(self.random_sleep)
def get_restaurants(longitude, latitude, categories): ''' Returns objects at given point that satisfy set of categories, or all of them if categories is empty. input: str longitude str latitude list categories output: list of dicts ''' currentPoint = geos.GEOSGeometry('POINT(%s %s)' %(longitude, latitude)) distance_m = 15000 list_of_cats = [] for c in categories: list_of_cats.append(models.Category.objects.get(name=c)) if list_of_cats: restaurants = models.Restaurant.gis.filter( location__distance_lte=(currentPoint, distance_m), categories__in=list_of_cats ) else: restaurants = models.Restaurant.gis.filter(location__distance_lte=(currentPoint, distance_m)) # seems that this thing doesn't actually order objects by distance # btw at this step there is no distance property in objects or rows in table # restaurants = restaurants.distance(currentPoint).order_by('distance') # String based JSON data = serializers.serialize('json', restaurants) # Actual JSON object to be edited data = json.loads(data) # if venue has multiple categories and some of them # are in list_of_cats than venue will appear in data that some times # so we will uniqify venues in data if len(list_of_cats) > 1: data = {v['pk']:v for v in data}.values() for restaurant in data: d = geopy_distance(currentPoint, restaurant['fields']['location']).kilometers restaurant['fields']['distance'] = round(d, 1) # Fancy splitting on POINT(lon, lat) lng = restaurant['fields']['location'].split()[1][1:] lat = restaurant['fields']['location'].split()[2][:-1] del restaurant['fields']['location'] restaurant['fields']['lng'] = lng restaurant['fields']['lat'] = lat # Replace category ids with names cat_names = [] for cat_id in restaurant['fields']['categories']: cat = models.Category.objects.get(id=cat_id) cat_names.append(cat.name) restaurant['fields']['categories'] = cat_names return data
def get_active_customers_miles(self, x=5, filter_pks=[]): from geopy.distance import distance as geopy_distance if len(filter_pks) > 0: return [ i.pk for i in Customer.objects.exclude(pk__in=filter_pks).filter( verified=True, active=True, offer_count=0) if i.location and self.location and geopy_distance( i.location.location, self.location.location).mi <= x ] else: return [ i.pk for i in Customer.objects.filter( verified=True, active=True, offer_count=0) if i.location and self.location and geopy_distance( i.location.location, self.location.location).mi <= x ]
def get_center_coords(cls, min_lat, min_lng, max_lat, max_lng): approx_distance = distances.geographic_distance( min_lat, min_lng, max_lat, max_lng,) d = geopy_distance(kilometers=approx_distance / 2.0) center = d.destination(GeoPyPoint(max_lat, max_lng), 225) return (center.latitude, center.longitude,)
def count_merchants_within_miles(self, x=5): from geopy.distance import distance as geopy_distance count = 0 for i in Merchant.objects.all() : if i.location and self.location: if geopy_distance(i.location.location,self.location.location).mi<=x: count = count + 1 return count
def count_offers_within_miles (self, x=5): from offer.models import Offer from geopy.distance import distance as geopy_distance count = 0 for i in Offer.objects.filter(expired_time__gt=datetime.now()): if self.location and i.merchant.location: if geopy_distance(self.location.location,i.merchant.location.location).mi<=x: count = count + 1 return count
def count_merchants_within_miles(self, x=5): from geopy.distance import distance as geopy_distance count = 0 for i in Merchant.objects.all(): if i.location and self.location: if geopy_distance(i.location.location, self.location.location).mi <= x: count = count + 1 return count
def get_masjids(longitude, latitude, categories): ''' Returns objects at given point that satisfy set of categories, or all of them if categories is empty. input: str longitude str latitude list categories output: list of dicts ''' currentPoint =Point(float(longitude), float(latitude)) #geos.GEOSGeometry('POINT(%s %s)' % (longitude, latitude)) distance_m = 15000 list_of_cats = [] for c in categories: list_of_cats.append(Cuisine.objects.get(name=c)) if list_of_cats: masjids = Masjid.gis.filter( location__distance_lte=(currentPoint, distance_m), categories__in=list_of_cats ) else: masjids = Masjid.gis.filter(location__distance_lte=(currentPoint, distance_m)) # String based JSON data = serializers.serialize('json', masjids) # Actual JSON object to be edited data = json.loads(data) # if venue has multiple categories and some of them # are in list_of_cats than venue will appear in data that some times # so we will uniqify venues in data if len(list_of_cats) > 1: data = {v['pk']: v for v in data}.values() for masjid in data: d = geopy_distance(currentPoint, masjid['fields']['location']).kilometers masjid['fields']['distance'] = round(d, 1) # Fancy splitting on POINT(lon, lat) lng = masjid['fields']['location'].split()[1][1:] lat = masjid['fields']['location'].split()[2][:-1] del masjid['fields']['location'] masjid['fields']['lng'] = lng masjid['fields']['lat'] = lat # Replace category ids with names cat_names = [] for cat in Sect.objects.filter(id=masjid['fields']['sect']): cat_names.append(cat.name) masjid['fields']['sects'] = cat_names return data
def get_merchants_within_miles(self, x=5): from geopy.distance import distance as geopy_distance #print self.address_1 + " " + self.zipcode.code, self.location.location.x, self.location.location.y #for i in Merchant.objects.all(): #print i , i.location.location.x, i.location.location.y, geopy_distance(i.location.location,self.location.location).mi return [ i.pk for i in Merchant.objects.all() if i.location and self.location and geopy_distance(i.location.location, self.location.location).mi <= x ]
def count_offers_within_miles(self, x=5): from offer.models import Offer from geopy.distance import distance as geopy_distance count = 0 for i in Offer.objects.filter(expired_time__gt=datetime.now()): if self.location and i.merchant.location: if geopy_distance(self.location.location, i.merchant.location.location).mi <= x: count = count + 1 return count
def get_masjids(longitude, latitude, categories): ''' Returns objects at given point that satisfy set of categories, or all of them if categories is empty. input: str longitude str latitude list categories output: list of dicts ''' currentPoint = geos.GEOSGeometry('POINT(%s %s)' %(longitude, latitude)) distance_m = 15000 list_of_cats = [] for c in categories: list_of_cats.append(models.Category.objects.get(name=c)) if list_of_cats: masjids = models.Masjid.gis.filter( location__distance_lte=(currentPoint, distance_m), categories__in=list_of_cats ) else: masjids = models.Masjid.gis.filter(location__distance_lte=(currentPoint, distance_m)) # String based JSON data = serializers.serialize('json', masjids) # Actual JSON object to be edited data = json.loads(data) # if venue has multiple categories and some of them # are in list_of_cats than venue will appear in data that some times # so we will uniqify venues in data if len(list_of_cats) > 1: data = {v['pk']:v for v in data}.values() for masjid in data: d = geopy_distance(currentPoint, masjid['fields']['location']).kilometers masjid['fields']['distance'] = round(d, 1) # Fancy splitting on POINT(lon, lat) lng = masjid['fields']['location'].split()[1][1:] lat = masjid['fields']['location'].split()[2][:-1] del masjid['fields']['location'] masjid['fields']['lng'] = lng masjid['fields']['lat'] = lat # Replace category ids with names cat_names = [] for cat_id in masjid['fields']['categories']: cat = models.Category.objects.get(id=cat_id) cat_names.append(cat.name) masjid['fields']['categories'] = cat_names return data
def getClosestStation(dataPoint): """ getClosestStation will call the above scrape stations method to update the database first. After this has been completed it will get the location of its data point and compare that against all weather stations. Once the closest data point has been found it will return the station and the data point. """ all_stations = Station.objects.all() distance_to_station = geopy_distance(dataPoint.LOCATION, all_stations[0].LOCATION).kilometers the_closest_station = all_stations[0] for station in all_stations: distance = geopy_distance(dataPoint.LOCATION, station.LOCATION).kilometers if distance < distance_to_station: distance_to_station = distance the_closest_station = station print "The closest station was: " + str(the_closest_station) print "It was: " + str(distance_to_station) + " kilometers away from the collar data point." station.distanceToPoint = distance_to_station return station
def add_calculated_fields(*, current_item: Dict[str, Any], initial_status, current_status, position_list, lap_list, total, charging_process_list, forecast, configuration: Configuration, current_item_index: Optional[int], now_dt: pendulum.DateTime): """ Add hardcoded calculated fields into current_item Note the prototype is the same for all calculated functions even if all inputs are not used :param current_item: :param initial_status: :param current_status: :param position_list: :param lap_list: :param total: :param charging_process_list: :param forecast: :param configuration: :param current_item_index: :param now_dt: time to calculate data for. :return: """ initial_odo = initial_status[ 'odometer'] if 'odometer' in initial_status else None current_odo = current_item[ 'odometer'] if 'odometer' in current_item else None start_time = configuration.start_time end_time = configuration.start_time.add(hours=configuration.hours) current_item[ 'distance'] = current_odo - initial_odo if current_odo is not None and initial_odo is not None else None current_item['air_distance'] = geopy_distance( (configuration.start_latitude, configuration.start_longitude), (current_item['latitude'], current_item['longitude']) ).km if 'latitude' in current_item and current_item['latitude'] is not None \ and 'longitude' in current_item and current_item['longitude'] is not None else None current_item['start_time'] = start_time current_item['end_time'] = end_time current_item['time_since_start'] = pendulum.period(start_time, now_dt, True) \ if now_dt >= start_time else pendulum.period(now_dt, now_dt, True) current_item['time_to_end'] = pendulum.period(now_dt, end_time, True) \ if now_dt <= end_time else pendulum.period(now_dt, now_dt, True) current_item['slow_data_age'] = pendulum.period(current_item['slow_data_date'], now_dt) \ if current_item and 'slow_data_date' in current_item and current_item['slow_data_date'] else None current_item['fast_data_age'] = pendulum.period(current_item['fast_data_date'], now_dt) \ if current_item and 'fast_data_date' in current_item and current_item['fast_data_date'] else None current_item['lap_number'] = lap_list[-1]['lap_id'] if lap_list else None
def distance(*points): ''' Find the geodesic distance between two or more points. If more than two points are specified, the points are assumed to be on a route. The total length of this route is calculated. Returns a django.contrib.gis.measure.Distance object. ''' meters = sum(geopy_distance(a, b).meters for (a, b) in pairwise(points)) return Distance(m=meters)
def calculate_distance(user_id1, user_id2, units='miles'): """ calculate distance https://docs.djangoproject.com/en/1.8/ref/contrib/gis/measure/#supported-units km Kilometre, Kilometer mi Mile m Meter, Metre """ g = GeoIP() distance = [10000, 'miles'] try: user1_location = UserLocation.objects.filter( user_id=user_id1).order_by('-timestamp')[0] user1_point = user1_location.geometry except IndexError: try: user_id1_ip = str(UserIPAddress.objects.get(user_id=user_id1).ip) point = g.geos(user_id1_ip) if not point: return distance user1_point = GEOSGeometry(point) except UserIPAddress.DoesNotExist: return distance try: user2_location = UserLocation.objects.filter( user_id=user_id2).order_by('-timestamp')[0] user2_point = user2_location.geometry except IndexError: try: user_id2_ip = str(UserIPAddress.objects.get(user_id=user_id2).ip) point = g.geos(user_id2_ip) if not point: return distance user2_point = GEOSGeometry(point) except UserIPAddress.DoesNotExist: return distance try: _units = FilterState.objects.filter(user_id=user_id1)[0].distance_unit if _units in ('miles', 'km'): units = _units except IndexError: pass distance = geopy_distance(user1_point, user2_point) if getattr(distance, units) < 1.0: if getattr(distance, 'm') <= 10.0: return [10, 'meters'] else: return [int(getattr(distance, 'm')), 'meters'] else: return [int(getattr(distance, units)), units]
def is_forecast_location_accurate(self, forecast): if not forecast.latitude or not forecast.longitude: return False location_service = LocationService(user = self.__user) current_location = location_service.get_current_location() current_coords = (current_location.latitude, current_location.longitude) forecast_coords = (forecast.latitude, forecast.longitude) distance = geopy_distance(current_coords, forecast_coords) if distance.km <= 50: return True else: return False
def get_bounds(cls, center, distance): """ Returns a Bounds object based on a center point and a distance. """ d = geopy_distance(kilometers=distance) point = GeoPyPoint(center.latitude, center.longitude) ne = d.destination(point, 45) sw = d.destination(point, 225) return Bounds( sw=Point(Decimal(sw.latitude), Decimal(sw.longitude)), ne=Point(Decimal(ne.latitude), Decimal(ne.longitude)))
def compute_missing_distances(trackpoints): trackpoints = iter(trackpoints) p = next(trackpoints, None) if p is None: return if p.distance_meters is None: p.distance_meters = 0.0 for t in trackpoints: if not t.distance_meters: t.distance_meters = p.distance_meters + geopy_distance( (p.latitude_degrees, p.longitude_degrees), (t.latitude_degrees, t.longitude_degrees), ).m p = t
def find_default_image(self, user_pnt): cities = SearchQuerySet().using('mobile_api').filter(django_ct='core.citypicture')\ .distance('geometry', user_pnt).order_by('distance') closest_city = cities[0] dist_btwn_city_user = geopy_distance((user_pnt.y, user_pnt.x), (closest_city.geometry.y, closest_city.geometry.x)).miles if dist_btwn_city_user <= closest_city.radius: default_image = closest_city.picture_url else: try: default = cities.filter(text='Default')[0] default_image = default.picture_url except: default_image = 'https://s3.amazonaws.com/pushpennyapp/pushpenny-default.jpg' return default_image
def ponto_1(request): if request.method == 'POST': ulat1 = request.POST.get("latitude1") unome = request.POST.get("nome1") unome2 = request.POST.get("nome2") ulng1 = request.POST.get("longitude1") coord1 = fromstr('POINT(%s %s )' % (ulng1, ulat1), srid=4326) ulat2 = request.POST.get("latitude2") ulng2 = request.POST.get("longitude2") coord2 = fromstr('POINT(%s %s )' % (ulng2, ulat2), srid=4326) ud = geopy_distance(coord1, coord2) novo1 = ponto1(nome=unome, ponto1=coord1, ponto2=coord2, nome2=unome2, d=ud) novo1.save() d = geopy_distance(coord1, coord2) print d.meters return render_to_response('ponto_1.html') else: HttpResponse("ERRO")
def find_default_image(self, user_pnt): cities = SearchQuerySet().using('mobile_api').filter(django_ct='core.citypicture')\ .distance('geometry', user_pnt).order_by('distance') closest_city = cities[0] dist_btwn_city_user = geopy_distance( (user_pnt.y, user_pnt.x), (closest_city.geometry.y, closest_city.geometry.x)).miles if dist_btwn_city_user <= closest_city.radius: default_image = closest_city.picture_url else: try: default = cities.filter(text='Default')[0] default_image = default.picture_url except: default_image = 'https://s3.amazonaws.com/pushpennyapp/pushpenny-default.jpg' return default_image
def get_offers_within_miles(self, x=5): from offer.models import Offer from geopy.distance import distance as geopy_distance """ # for testing print "All offers: %d"%Offer.objects.all().count() for i in Offer.objects.all(): print "Customer location:", self.location.location print "Merchant location:", i.merchant.location.location print "Distance:", geopy_distance(self.location.location, i.merchant.location.location).mi """ return [ i for i in Offer.objects.filter(expired_time__gt=datetime.now()) if self.location and i.merchant.location and geopy_distance( self.location.location, i.merchant.location.location).mi <= x ]
def get_geo_distance(self, pre_ip, cur_ip): '''Caculate a distance in miles and meters with SRC IP and DST IP''' if self.is_ip(pre_ip) is False or self.is_ip(pre_ip) is False: return "" if self._g_geodb == None: return "" pre_gir = self._g_geodb.record_by_addr(pre_ip) pre_loc = [] cur_loc = [] if pre_gir != None: if pre_gir['latitude']: pre_loc.append(pre_gir['latitude']) if pre_gir['longitude']: pre_loc.append(pre_gir['longitude']) cur_gir = self._g_geodb.record_by_addr(cur_ip) if cur_gir != None: if cur_gir['latitude']: cur_loc.append(cur_gir['latitude']) if cur_gir['longitude']: cur_loc.append(cur_gir['longitude']) d = geopy_distance(pre_loc, cur_loc) return (d.meters, d.miles)
def appendSortCSV(tempList): destList = [] geolocator = Nominatim(user_agent="Hello") origin = geolocator.geocode("Stony Brook University") p1 = Point(origin.latitude, origin.longitude) for pos in range(len(tempList)): dest = geolocator.geocode(tempList[pos]) p2 = Point(dest.latitude, dest.longitude) points = (p1, p2) destList.append({ 'Address': tempList[pos], 'Distance': float( round( sum( geopy_distance(a, b).meters for (a, b) in pairwise(points)) * 0.000621371, 4)) }) destList.sort(key=distance) for pos in range(len(destList)): print destList[pos]
def findAllMatchingByDistance(sourceCollar, distance=None): """ findAllMatchingByDistance This checks for interactions based on a distance parameter, dates must be precise """ if not distance: return distance sourceCollarDataPoints = CollarData.objects.filter(collar=sourceCollar) matches = CollarData.objects.exclude(collar=sourceCollar) matchesToReport = [] for sourceDataPoint in sourceCollarDataPoints: thesematches = matches.filter(GMT_DATETIME=sourceDataPoint.GMT_DATETIME) thesematches = thesematches.filter(LOCATION__distance_lte=(sourceDataPoint.LOCATION, D(km=distance))) if len(thesematches) > 0: for i,match in enumerate(thesematches): thisMatch = Collar() thisMatch.sourceCollarID = sourceDataPoint.collar.collarID thisMatch.matchedCollarID = match.collar.collarID thisMatch.datetime = sourceDataPoint.GMT_DATETIME thisMatch.locationX = sourceDataPoint.LOCATION.x thisMatch.locationY = sourceDataPoint.LOCATION.y thisMatch.distance = str(geopy_distance(sourceDataPoint.LOCATION,match.LOCATION)) matchesToReport.append(thisMatch) return matchesToReport
def findInteractionFromDataPoint(sourceCollarDataPoint, distance=settings.DEFAULT_INTERACTION_DISTANCE, timedelta=None, starttime=None, endtime=None, interactiongroup=None): """ findInteractionFromDataPoint is used to calculate interaction data based on a singular data point. Once a match has been reported it is then added to the group. Input parameters should be self explanitory. """ list_of_data_points_to_search = CollarData.objects.exclude(collar=sourceCollarDataPoint.collar) if starttime: if endtime: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__range=(starttime, endtime)) else: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__gte=starttime) elif endtime: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__lte=endtime) if distance: list_of_data_points_to_search = list_of_data_points_to_search.filter(LOCATION__distance_lte=(sourceCollarDataPoint.LOCATION, D(km=distance))) if timedelta: real_time_delta = datetime.timedelta(seconds=timedelta) start_delta = sourceCollarDataPoint.GMT_DATETIME - real_time_delta end_delta = sourceCollarDataPoint.GMT_DATETIME + real_time_delta list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME__range=(start_delta, end_delta)) else: list_of_data_points_to_search = list_of_data_points_to_search.filter(GMT_DATETIME=sourceCollarDataPoint.GMT_DATETIME) for match in list_of_data_points_to_search: animal_interaction_to_add = AnimalInteraction() animal_interaction_to_add.source_animal_data_point = sourceCollarDataPoint animal_interaction_to_add.destination_animal_data_point = match animal_interaction_to_add.distance = geopy_distance(sourceCollarDataPoint.LOCATION,match.LOCATION).kilometers animal_interaction_to_add.interaction_group = interactiongroup try: animal_interaction_to_add.clean() animal_interaction_to_add.save() except ValidationError: print "The entry already exists" zip_content = ContentFile(exportShape()) interactiongroup.zip_file.save("sampleFile.zip",zip_content) interactiongroup.save()
def _vincenty_distance(self, origin: GeoLocation, target: GeoLocation, metric: bool = False) -> float: """Calculate distance between two locations using the proper Vincenty distance. .. note:: This is the proper way of discovering distance between lat/long coordinates. I would not recommend using the Haversine distance calculations in production as they have discrepancies of ~0.5% especially when using long distances. :param GeoLocation origin: The starting location :param GeoLocation target: The ending location :param bool metric: Return results in kilometers rather than miles, optional, defaults to False :return: The vincenty distance between the given coordinates :rtype: float """ distance = geopy_distance((origin.latitude, origin.longitude), (target.latitude, target.longitude)) if metric: return distance.km return distance.miles
def localinfo_return_response(self, request, **kwargs): self.method_check(request, allowed=['get']) self.create_localinfo_index_if_doesnt_exist() params_dict = request.GET params_keys = params_dict.keys() try: location_param = params_dict['location'] except: response = { 'error': {'message': "You must supply a valid user location information."} } return self.create_response(request, response) lat_lng_in_list = location_param.split(',') lat, lng = map(float, lat_lng_in_list) user_pnt = Point(lng, lat) radius = D(mi=float(params_dict['radius'])) if 'radius' in params_keys else D(mi=100) default_radius_filter = '5mi' filters = { "query": { "filtered" : { "query" : { "match_all" : {} }, "filter" : { "geo_distance" : { "distance" : default_radius_filter, "location" : location_param } } } }, "facets": { "search_keyword" : { "terms" : { "field" : "search_keyword", "order" : "count" } }, "search_category" : { "terms" : { "field" : "search_category", "order" : "count" } } } } res = self.es.search(index="localinfo", doc_type='populars', body=filters) popular_nearby_list_raw = res['facets']['search_keyword']['terms'] # popular_category_list_raw = res['facets']['search_category']['terms'] # Not used for now; instead of parent categories. default_image = self.find_default_image(user_pnt) base_response = { "default_image": default_image, "search_categories": [] } popular_category_sub_structure = { "name": "Popular Categories", "list": [] } popular_nearby_sub_structure = { "name": "Popular Nearby", "list": [] } # Always show parent categories as 'popular categories' (minus Special Interest and Product ) for c in self.parent_categories_list: popular_category = self.return_popular_something_insert(user_pnt, c) popular_category_sub_structure['list'].append(popular_category) base_response['search_categories'].append(popular_category_sub_structure) # Always try to show 5 'popular nearby's based on historical searches (min occurance threshold at 100); # To the extent there aren't enough historical popular nearbys, then fill the rest with # randomly selected categories, provided that there are at least 10 deals available under each category. # The user's location & poular_nearbys pair is cached and used for 12hrs; If the user's location changes # more than 50 miles away from any cached locations, then generate a new list of popular nearbys. id_param = params_dict.get('id', 'uuid') cached_data = cache.get(id_param) if id_param != 'uuid' else None if cached_data: cached_locations = cached_data['pop_nearbys'].keys() closest_pnt_to_user = {} for location in cached_locations: lat, lng = map(float, location.split(',')) dist_to_user = geopy_distance((user_pnt.y, user_pnt.x), (lat, lng)).miles if len(closest_pnt_to_user) == 0: closest_pnt_to_user = {location: dist_to_user} continue closest_dist_so_far = closest_pnt_to_user.values()[0] if dist_to_user < closest_dist_so_far: closest_pnt_to_user = {location: dist_to_user} else: continue max_dist_for_caching = 50 # miles if cached_data and (closest_pnt_to_user.values()[0] <= max_dist_for_caching): closest_lat_lng = closest_pnt_to_user.keys()[0] cached_popular_nearbys = cached_data['pop_nearbys'][closest_lat_lng] for n in cached_popular_nearbys: popular_nearby = self.return_popular_something_insert(user_pnt, n) popular_nearby_sub_structure['list'].append(popular_nearby) base_response['search_categories'].append(popular_nearby_sub_structure) else: max_nearbys = 5 for kw in popular_nearby_list_raw[:max_nearbys]: if kw['count'] < 100: break else: popular_nearby = self.return_popular_something_insert(user_pnt, kw['term']) popular_nearby_sub_structure['list'].append(popular_nearby) categories_to_sample_from = copy.copy(self.sanitized_categories_list) while True: popular_nearbys_so_far = [n['name'] for n in popular_nearby_sub_structure['list']] if len(popular_nearbys_so_far) >= max_nearbys: break try: random_pick = random.sample(categories_to_sample_from, 1)[0] except ValueError: # When ran out of categories to choose from. break sqs = SearchQuerySet().using('mobile_api')\ .filter(django_ct='core.coupon', online=False, is_duplicate=False, is_deleted=False, status='considered-active', mobilequery=random_pick)\ .exclude(end__lt=datetime.now(pytz.utc))\ .dwithin('merchant_location', user_pnt, radius)\ .distance('merchant_location', user_pnt).order_by('distance') if (random_pick in popular_nearbys_so_far) or (len(sqs) < 10): categories_to_sample_from.remove(random_pick) continue else: popular_nearby = self.return_popular_something_insert(user_pnt, random_pick) popular_nearby_sub_structure['list'].append(popular_nearby) categories_to_sample_from.remove(random_pick) popular_nearbys_so_far = [n['name'] for n in popular_nearby_sub_structure['list']] if popular_nearbys_so_far: base_response['search_categories'].append(popular_nearby_sub_structure) if id_param != 'uuid': self.cache_it_with_location(id_param, popular_nearbys_so_far, location_param) # only for debugging purposes below # base_response['elasticsearch_res'] = res response = base_response return self.create_response(request, response)
def get_customers_within_miles(self,x=5): from geopy.distance import distance as geopy_distance return [ i.pk for i in Customer.objects.all() if i.location and self.location and geopy_distance(i.location.location,self.location.location).mi<=x]
def get_active_customers_miles(self, x=5, filter_pks=[]): from geopy.distance import distance as geopy_distance if len(filter_pks) > 0: return [ i.pk for i in Customer.objects.exclude(pk__in=filter_pks).filter(verified=True, active=True, offer_count=0) if i.location and self.location and geopy_distance(i.location.location,self.location.location).mi<=x] else: return [ i.pk for i in Customer.objects.filter(verified=True, active=True, offer_count=0) if i.location and self.location and geopy_distance(i.location.location,self.location.location).mi<=x]
def get_offers_within_miles(self,x=5): from offer.models import Offer from geopy.distance import distance as geopy_distance """ # for testing print "All offers: %d"%Offer.objects.all().count() for i in Offer.objects.all(): print "Customer location:", self.location.location print "Merchant location:", i.merchant.location.location print "Distance:", geopy_distance(self.location.location, i.merchant.location.location).mi """ return [i for i in Offer.objects.filter(expired_time__gt=datetime.now()) if self.location and i.merchant.location and geopy_distance(self.location.location, i.merchant.location.location).mi<=x]
def get_merchants_within_miles(self,x=5): from geopy.distance import distance as geopy_distance #print self.address_1 + " " + self.zipcode.code, self.location.location.x, self.location.location.y #for i in Merchant.objects.all(): #print i , i.location.location.x, i.location.location.y, geopy_distance(i.location.location,self.location.location).mi return [ i.pk for i in Merchant.objects.all() if i.location and self.location and geopy_distance(i.location.location,self.location.location).mi<=x]
def find_laps(configuration: Configuration, segment, region=10, min_time=5, start_idx=0) -> List[Dict[str, Any]]: """Return laps given latitude & longitude data. We assume that the first point defines the start and that the last point defines the end and that these are approximately at the same place. Parameters ---------- segment : dict The data for the full track. region : float The region around the starting point which is used to define if we are passing through the starting point and begin a new lap. min_time : float This is the minimum time (in seconds) we should spend in the region before exiting. This will depend on the setting for region and the velocity for the activity. start_idx : integer The starting point for the first lap. """ if not segment: # race not started yet return [] points = [(pt['latitude'], pt['longitude']) for pt in segment] start = (configuration.start_latitude, configuration.start_longitude) \ if configuration.start_latitude is not None and configuration.start_longitude \ else points[start_idx] time = [pt['date'] for pt in segment] # For locating the tracks, we look for point which are such that # we enter the starting region and pass through it. # For each point, find the distance to the starting region: distance = [geopy_distance(point, start) for point in points] #np.set_printoptions(suppress=True) # print(distance) # Now look for points where we enter the region: # We want to avoid cases where we jump back and forth across the # boundary, so we set a minimum time we should spend inside the # region. # let's assume we are in pit or at the lap already at start time lapId = 1 splits = [] pit_entry_idx = None lap_entry_idx = None current_split = None for i, dist in enumerate(distance): if i == start_idx: # in fact that just skips the first one if distance[0] > region: # already at lap, so create new one current_split = LapSplit(lapId=lapId, pitEntryIdx=start_idx, pitLeaveIdx=start_idx, lapEntryIdx=start_idx) else: # in pit current_split = LapSplit( lapId=lapId, pitEntryIdx=start_idx, ) splits.append(current_split) # HACK lapId += 1 continue if dist <= region: # we are inside the pit if distance[i - 1] <= region: # was in pit before if pit_entry_idx: # not recorded yet delta_t = time[i] - time[pit_entry_idx] if min_time < delta_t.total_seconds() or ( i == (len(distance) - 1) ): # check time in pit (if last point and in pit, create anyway if current_split: # long enough, dump the previous one to output list current_split.lapLeaveIdx = pit_entry_idx # HACK splits.append(current_split) current_split = LapSplit( lapId=str(lapId), pitEntryIdx=pit_entry_idx) # and create new one splits.append(current_split) # HACK lapId += 1 pit_entry_idx = None else: # entered the pit (left lap) pit_entry_idx = i # remember entry, start measuring time else: # outside of pit (on lap) if distance[i - 1] > region: # was on lap before if lap_entry_idx: # not recorded yet delta_t = time[i] - time[lap_entry_idx] if min_time < delta_t.total_seconds(): # check time in pit if current_split: # long enough, record switch to lap current_split.pitLeaveIdx = lap_entry_idx current_split.lapEntryIdx = lap_entry_idx pit_entry_idx = None else: # entered the lap (left pit) lap_entry_idx = i # remember exit, start measuring time # HACK if current_split and current_split.lapEntryIdx: # do not include the one having just pit time # HACK splits.append(current_split) agg_splits = aggregate_splits(configuration, splits) # new statuses = extract_lap_statuses(configuration, agg_splits, segment) # TODO implement better way if not agg_splits[-1].lapLeaveIdx or distance[ agg_splits[-1].lapLeaveIdx] > region: statuses[-1]['finished'] = False # outside of region return statuses
INCREMENT_MI = 5.0 # mile(s) GROUPON_KEY = 'cd4f46230f4d6bb2c8467c1695e891f24a0baf37' GROUPON_API_URL = 'http://api.groupon.com/v2/deals' COLLECTED_DEALS = [] request_parameters = { 'client_id': GROUPON_KEY, # 'radius': INCREMENT_MI } # denver bounding box: http://isithackday.com/geoplanet-explorer/index.php?woeid=24701640 north_east = Point(-103.705704,40.284950) south_west = Point(-105.927017,39.128181) x_dist_mi = geopy_distance((north_east.y, north_east.x), (north_east.y, south_west.x)).miles y_dist_mi = geopy_distance((north_east.y, north_east.x), (south_west.y, north_east.x)).miles x_grid_divisor = x_dist_mi / INCREMENT_MI y_grid_divisor = y_dist_mi / INCREMENT_MI x_increment_pnt = (north_east.x - south_west.x) / x_grid_divisor y_increment_pnt = (north_east.y - south_west.y) / y_grid_divisor x_move_count = int(math.ceil(x_grid_divisor)) + 1 y_move_count = int(math.ceil(y_grid_divisor)) + 1 # starting from south_west corner and move right across first, and move up request_parameters['lat'] = south_west.y request_parameters['lng'] = south_west.x request_parameters['radius'] = 5
def deals_return_response(self, request, **kwargs): self.method_check(request, allowed=['get']) params_dict = request.GET params_keys = params_dict.keys() location_param = params_dict.get('location', None) if not location_param: response = { 'error': { 'message': "You must supply a valid user location information." } } return self.create_response(request, response) lat_lng_in_list = location_param.split(',') lat, lng = map(float, lat_lng_in_list) id_param = params_dict.get('id', 'uuid') radius = D( mi=float(params_dict['radius'])) if 'radius' in params_keys else D( mi=10) user_pnt = Point(lng, lat) sqs = SearchQuerySet().using('mobile_api').filter(django_ct='core.coupon', online=False, is_duplicate=False, is_deleted=False, status='considered-active')\ .exclude(end__lt=datetime.now(pytz.utc))\ .dwithin('merchant_location', user_pnt, radius).distance('merchant_location', user_pnt)\ .order_by('distance') if 'query' in params_keys: query = params_dict['query'] sqs_by_query = SearchQuerySet().using('mobile_api').filter( mobilequery=query) sqs = sqs.__and__(sqs_by_query) # Prepare for 'localindex' api service self.create_localinfo_index_if_doesnt_exist() matched_category_indices = [ i for i, s in enumerate(self.available_categories_list) if query.lower() in s.lower() ] matched_category_names = [ self.available_categories_list[i] for i in matched_category_indices ] self.index_it_in_localinfo_populars(id_param, location_param, string.capwords(query), matched_category_names) if 'category_slugs' in params_keys: category_slugs_list = params_dict['category_slugs'].split(',') sqs_by_category = SearchQuerySet().using('mobile_api') for c in category_slugs_list: sqs_by_category = sqs_by_category.filter_or( category_slugs=c.strip()) sqs = sqs.__and__(sqs_by_category) if 'provider_slugs' in params_keys: provider_slugs_list = params_dict['provider_slugs'].split(',') sqs_by_provider = SearchQuerySet().using('mobile_api') for p in provider_slugs_list: sqs_by_provider = sqs_by_provider.filter_or( provider_slugs=p.strip()) sqs = sqs.__and__(sqs_by_provider) updated_after = params_dict.get('updated_after', None) per_page = int(params_dict.get('per_page', 20)) page = int(params_dict.get('page', 1)) start_point = (page - 1) * per_page end_point = page * per_page deals = [] for sqs_obj in sqs[start_point:end_point]: merchant_pnt = sqs_obj.merchant_location if not merchant_pnt: continue dist_to_user = geopy_distance( (user_pnt.y, user_pnt.x), (merchant_pnt.y, merchant_pnt.x)).miles deal_description = sqs_obj.text if sqs_obj.related_deals_count != 0: deal_description = deal_description if deal_description else "" deal_description += "\n\nFind {} more similar deal(s) from this vendor on {}!".format( sqs_obj.related_deals_count, sqs_obj.provider) each_deal = { 'deal': { 'id': sqs_obj.coupon_ref_id, 'title': sqs_obj.embedly_title, 'short_title': sqs_obj.embedly_description, 'description': deal_description, 'fine_print': sqs_obj.restrictions, 'number_sold': None, 'url': sqs_obj.link, 'untracked_url': sqs_obj.directlink, 'price': sqs_obj.price, 'value': sqs_obj.listprice, 'discount_amount': sqs_obj.discount, 'discount_percentage': float(sqs_obj.percent) / 100, 'commission': None, 'provider_name': sqs_obj.provider, 'provider_slug': sqs_obj.provider_slug, 'category_name': ', '.join(sqs_obj.categories) if sqs_obj.categories else None, 'category_slug': ', '.join(sqs_obj.category_slugs) if sqs_obj.category_slugs else None, 'image_url': sqs_obj.image, 'online': sqs_obj.online, 'expires_at': sqs_obj.end, 'created_at': sqs_obj.start, 'updated_at': sqs_obj.lastupdated, 'is_duplicate': sqs_obj.is_duplicate, 'merchant': { 'id': sqs_obj.merchant_ref_id, 'name': sqs_obj.merchant_name, 'address': sqs_obj.merchant_address, 'locality': sqs_obj.merchant_locality, 'region': sqs_obj.merchant_region, 'postal_code': sqs_obj.merchant_postal_code, 'country': "United States", 'country_code': "US", 'latitude': merchant_pnt.y, 'longitude': merchant_pnt.x, 'dist_to_user_mi': dist_to_user, 'url': sqs_obj.merchant_link, } } } deals.append(each_deal) query = { 'total': len(sqs), 'page': page, 'per_page': per_page, 'query': query if 'query' in params_keys else None, 'location': { 'latitude': lat, 'longitude': lng, }, 'radius': float(params_dict['radius']) if 'radius' in params_keys else 10, 'online': False, 'category_slugs': category_slugs_list if 'category_slugs' in params_keys else None, 'provider_slugs': provider_slugs_list if 'provider_slugs' in params_keys else None, 'updated_after': updated_after, } response = { 'query': query, 'deals': deals, } return self.create_response(request, response)
def localinfo_return_response(self, request, **kwargs): self.method_check(request, allowed=['get']) self.create_localinfo_index_if_doesnt_exist() params_dict = request.GET params_keys = params_dict.keys() try: location_param = params_dict['location'] except: response = { 'error': { 'message': "You must supply a valid user location information." } } return self.create_response(request, response) lat_lng_in_list = location_param.split(',') lat, lng = map(float, lat_lng_in_list) user_pnt = Point(lng, lat) radius = D( mi=float(params_dict['radius'])) if 'radius' in params_keys else D( mi=100) default_radius_filter = '5mi' filters = { "query": { "filtered": { "query": { "match_all": {} }, "filter": { "geo_distance": { "distance": default_radius_filter, "location": location_param } } } }, "facets": { "search_keyword": { "terms": { "field": "search_keyword", "order": "count" } }, "search_category": { "terms": { "field": "search_category", "order": "count" } } } } res = self.es.search(index="localinfo", doc_type='populars', body=filters) popular_nearby_list_raw = res['facets']['search_keyword']['terms'] # popular_category_list_raw = res['facets']['search_category']['terms'] # Not used for now; instead of parent categories. default_image = self.find_default_image(user_pnt) base_response = { "default_image": default_image, "search_categories": [] } popular_category_sub_structure = { "name": "Popular Categories", "list": [] } popular_nearby_sub_structure = {"name": "Popular Nearby", "list": []} # Always show parent categories as 'popular categories' (minus Special Interest and Product ) for c in self.parent_categories_list: popular_category = self.return_popular_something_insert( user_pnt, c) popular_category_sub_structure['list'].append(popular_category) base_response['search_categories'].append( popular_category_sub_structure) # Always try to show 5 'popular nearby's based on historical searches (min occurance threshold at 100); # To the extent there aren't enough historical popular nearbys, then fill the rest with # randomly selected categories, provided that there are at least 10 deals available under each category. # The user's location & poular_nearbys pair is cached and used for 12hrs; If the user's location changes # more than 50 miles away from any cached locations, then generate a new list of popular nearbys. id_param = params_dict.get('id', 'uuid') cached_data = cache.get(id_param) if id_param != 'uuid' else None if cached_data: cached_locations = cached_data['pop_nearbys'].keys() closest_pnt_to_user = {} for location in cached_locations: lat, lng = map(float, location.split(',')) dist_to_user = geopy_distance((user_pnt.y, user_pnt.x), (lat, lng)).miles if len(closest_pnt_to_user) == 0: closest_pnt_to_user = {location: dist_to_user} continue closest_dist_so_far = closest_pnt_to_user.values()[0] if dist_to_user < closest_dist_so_far: closest_pnt_to_user = {location: dist_to_user} else: continue max_dist_for_caching = 50 # miles if cached_data and (closest_pnt_to_user.values()[0] <= max_dist_for_caching): closest_lat_lng = closest_pnt_to_user.keys()[0] cached_popular_nearbys = cached_data['pop_nearbys'][ closest_lat_lng] for n in cached_popular_nearbys: popular_nearby = self.return_popular_something_insert( user_pnt, n) popular_nearby_sub_structure['list'].append(popular_nearby) base_response['search_categories'].append( popular_nearby_sub_structure) else: max_nearbys = 5 for kw in popular_nearby_list_raw[:max_nearbys]: if kw['count'] < 100: break else: popular_nearby = self.return_popular_something_insert( user_pnt, kw['term']) popular_nearby_sub_structure['list'].append(popular_nearby) categories_to_sample_from = copy.copy( self.sanitized_categories_list) while True: popular_nearbys_so_far = [ n['name'] for n in popular_nearby_sub_structure['list'] ] if len(popular_nearbys_so_far) >= max_nearbys: break try: random_pick = random.sample(categories_to_sample_from, 1)[0] except ValueError: # When ran out of categories to choose from. break sqs = SearchQuerySet().using('mobile_api')\ .filter(django_ct='core.coupon', online=False, is_duplicate=False, is_deleted=False, status='considered-active', mobilequery=random_pick)\ .exclude(end__lt=datetime.now(pytz.utc))\ .dwithin('merchant_location', user_pnt, radius)\ .distance('merchant_location', user_pnt).order_by('distance') if (random_pick in popular_nearbys_so_far) or (len(sqs) < 10): categories_to_sample_from.remove(random_pick) continue else: popular_nearby = self.return_popular_something_insert( user_pnt, random_pick) popular_nearby_sub_structure['list'].append(popular_nearby) categories_to_sample_from.remove(random_pick) popular_nearbys_so_far = [ n['name'] for n in popular_nearby_sub_structure['list'] ] if popular_nearbys_so_far: base_response['search_categories'].append( popular_nearby_sub_structure) if id_param != 'uuid': self.cache_it_with_location(id_param, popular_nearbys_so_far, location_param) # only for debugging purposes below # base_response['elasticsearch_res'] = res response = base_response return self.create_response(request, response)
def deals_return_response(self, request, **kwargs): self.method_check(request, allowed=['get']) params_dict = request.GET params_keys = params_dict.keys() location_param = params_dict.get('location', None) if not location_param: response = { 'error': {'message': "You must supply a valid user location information."} } return self.create_response(request, response) lat_lng_in_list = location_param.split(',') lat, lng = map(float, lat_lng_in_list) id_param = params_dict.get('id', 'uuid') radius = D(mi=float(params_dict['radius'])) if 'radius' in params_keys else D(mi=10) user_pnt = Point(lng, lat) sqs = SearchQuerySet().using('mobile_api').filter(django_ct='core.coupon', online=False, is_duplicate=False, is_deleted=False, status='considered-active')\ .exclude(end__lt=datetime.now(pytz.utc))\ .dwithin('merchant_location', user_pnt, radius).distance('merchant_location', user_pnt)\ .order_by('distance') if 'query' in params_keys: query = params_dict['query'] sqs_by_query = SearchQuerySet().using('mobile_api').filter(mobilequery=query) sqs = sqs.__and__(sqs_by_query) # Prepare for 'localindex' api service self.create_localinfo_index_if_doesnt_exist() matched_category_indices = [i for i, s in enumerate(self.available_categories_list) if query.lower() in s.lower()] matched_category_names = [self.available_categories_list[i] for i in matched_category_indices] self.index_it_in_localinfo_populars(id_param, location_param, string.capwords(query), matched_category_names) if 'category_slugs' in params_keys: category_slugs_list = params_dict['category_slugs'].split(',') sqs_by_category = SearchQuerySet().using('mobile_api') for c in category_slugs_list: sqs_by_category = sqs_by_category.filter_or(category_slugs=c.strip()) sqs = sqs.__and__(sqs_by_category) if 'provider_slugs' in params_keys: provider_slugs_list = params_dict['provider_slugs'].split(',') sqs_by_provider = SearchQuerySet().using('mobile_api') for p in provider_slugs_list: sqs_by_provider = sqs_by_provider.filter_or(provider_slugs=p.strip()) sqs = sqs.__and__(sqs_by_provider) updated_after = params_dict.get('updated_after', None) per_page = int(params_dict.get('per_page', 20)) page = int(params_dict.get('page', 1)) start_point = (page - 1) * per_page end_point = page * per_page deals = [] for sqs_obj in sqs[start_point:end_point]: merchant_pnt = sqs_obj.merchant_location if not merchant_pnt: continue dist_to_user = geopy_distance((user_pnt.y, user_pnt.x), (merchant_pnt.y, merchant_pnt.x)).miles deal_description = sqs_obj.text if sqs_obj.related_deals_count != 0: deal_description = deal_description if deal_description else "" deal_description += "\n\nFind {} more similar deal(s) from this vendor on {}!".format(sqs_obj.related_deals_count, sqs_obj.provider) each_deal = {'deal': { 'id': sqs_obj.coupon_ref_id, 'title': sqs_obj.embedly_title, 'short_title': sqs_obj.embedly_description, 'description': deal_description, 'fine_print': sqs_obj.restrictions, 'number_sold': None, 'url': sqs_obj.link, 'untracked_url': sqs_obj.directlink, 'price': sqs_obj.price, 'value': sqs_obj.listprice, 'discount_amount': sqs_obj.discount, 'discount_percentage': float(sqs_obj.percent) / 100, 'commission': None, 'provider_name': sqs_obj.provider, 'provider_slug': sqs_obj.provider_slug, 'category_name': ', '.join(sqs_obj.categories) if sqs_obj.categories else None, 'category_slug': ', '.join(sqs_obj.category_slugs) if sqs_obj.category_slugs else None, 'image_url': sqs_obj.image, 'online': sqs_obj.online, 'expires_at': sqs_obj.end, 'created_at': sqs_obj.start, 'updated_at': sqs_obj.lastupdated, 'is_duplicate': sqs_obj.is_duplicate, 'merchant': { 'id': sqs_obj.merchant_ref_id, 'name': sqs_obj.merchant_name, 'address': sqs_obj.merchant_address, 'locality': sqs_obj.merchant_locality, 'region': sqs_obj.merchant_region, 'postal_code': sqs_obj.merchant_postal_code, 'country': "United States", 'country_code': "US", 'latitude': merchant_pnt.y, 'longitude': merchant_pnt.x, 'dist_to_user_mi': dist_to_user, 'url': sqs_obj.merchant_link, } } } deals.append(each_deal) query = { 'total': len(sqs), 'page': page, 'per_page': per_page, 'query': query if 'query' in params_keys else None, 'location': { 'latitude': lat, 'longitude': lng, }, 'radius': float(params_dict['radius']) if 'radius' in params_keys else 10, 'online': False, 'category_slugs': category_slugs_list if 'category_slugs' in params_keys else None, 'provider_slugs': provider_slugs_list if 'provider_slugs' in params_keys else None, 'updated_after': updated_after, } response = { 'query': query, 'deals': deals, } return self.create_response(request, response)
def detalhe(request, codigo_inep): '''Essa rotina monta o territorio educativo com base no codigo inep da escola''' from django.contrib.gis.geos import GEOSGeometry from django.contrib.gis.geos import Point, Polygon, MultiPolygon from django.contrib.gis.measure import Distance, D from escola.models import Escola from ibge.models import Municipio from ibge.models import SetorCensitario from censo_ibge.models import Domicilio01PorSetor from censo_ibge.models import Domicilio02PorSetor from censo_ibge.models import Responsavel01PorSetor from censo_ibge.models import Responsavel02PorSetor from censo_ibge.models import ResponsavelrendaPorSetor from censo_ibge.models import DomiciliorendaPorSetor from censo_ibge.models import PessoarendaPorSetor from censo_ibge.models import BasicoPorSetor from censo_ibge.models import Pessoa11PorSetor from censo_ibge.models import Pessoa12PorSetor from censo_ibge.models import Entorno01PorSetor from censo_ibge.models import Entorno02PorSetor from censo_ibge.models import Entorno03PorSetor from censo_ibge.models import Pessoa01PorSetor from censo_ibge.models import Pessoa02PorSetor from censo_ibge.models import Pessoa03PorSetor from escola.models import DadosEscolas from ideb.models import Ideb escola = Escola.objects.get(codigo_inep = codigo_inep) dados_escolas = DadosEscolas.objects.get(cod_inep = codigo_inep) ll_e = (escola.longitude, escola.latitude) latitude = str(escola.latitude).replace(',','.') longitude = str(escola.longitude).replace(',','.') # Pega o raio personalizado do municipio raio = Municipio.objects.get(cd_geocodm = escola.ibge.cd_geocodm).raio if raio == None: raio = 1 # Calculos censo IBGE distancia_raio = Distance(km = raio) try: todos_setores = SetorCensitario.objects.filter( cd_geocodm = escola.ibge.cd_geocodm).filter( setor_censitario_bruto__distance_lte=(escola.latlong, distancia_raio)) except: todos_setores = [] domicilio_por_setor = { 'casas': 0, 'apartamentos': 0, 'sem_agua': 0, 'sem_banheiro': 0, 'sem_lixo': 0, 'sem_energia': 0, 'casas_p': 0, 'apartamentos_p': 0, 'sem_agua_p': 0, 'sem_banheiro_p': 0, 'sem_lixo_p': 0, 'sem_energia_p': 0, } moradores = { 'casas': 0, 'apartamentos': 0, 'sem_agua': 0, 'sem_banheiro': 0, 'sem_lixo': 0, 'sem_energia': 0, 'casas_p': 0, 'apartamentos_p': 0, 'sem_agua_p': 0, 'sem_banheiro_p': 0, 'sem_lixo_p': 0, 'sem_energia_p': 0, } responsaveis = { 'h_responsaveis': 0, 'h_nao_alfabetizados': 0, 'h_ate_18': 0, 'h_sem_rendimento': 0, 'h_rendimento_1sm': 0, 'h_responsaveis_p': 0, 'h_nao_alfabetizados_p': 0, 'h_ate_18_p': 0, 'h_sem_rendimento_p': 0, 'h_rendimento_1sm_p': 0, 'm_responsaveis': 0, 'm_nao_alfabetizados': 0, 'm_ate_18': 0, 'm_sem_rendimento': 0, 'm_rendimento_1sm': 0, 'm_responsaveis_p': 0, 'm_nao_alfabetizados_p': 0, 'm_ate_18_p': 0, 'm_sem_rendimento_p': 0, 'm_rendimento_1sm_p': 0, 't_responsaveis': 0, 't_nao_alfabetizados': 0, 't_ate_18': 0, 't_sem_rendimento': 0, 't_rendimento_1sm': 0, 't_responsaveis_p': 0, 't_nao_alfabetizados_p': 0, 't_ate_18_p': 0, 't_sem_rendimento_p': 0, 't_rendimento_1sm_p': 0, } renda = { 'dom_sem_rendimento': 0, 'dom_ate_meio': 0, 'dom_de_meio_a_1': 0, 'dom_de_1_a_2': 0, 'dom_de_2_a_3': 0, 'dom_de_3_a_5': 0, 'dom_de_5_a_10': 0, 'dom_de_10_a_15': 0, 'dom_de_15_a_20': 0, 'dom_mais_de_20': 0, 'dom_sem_rendimento_p': 0, 'dom_ate_meio_p': 0, 'dom_de_meio_a_1_p': 0, 'dom_de_1_a_2_p': 0, 'dom_de_2_a_3_p': 0, 'dom_de_3_a_5_p': 0, 'dom_de_5_a_10_p': 0, 'dom_de_10_a_15_p': 0, 'dom_de_15_a_20_p': 0, 'dom_mais_de_20_p': 0, 'h_sem_rendimento': 0, 'h_ate_meio': 0, 'h_de_meio_a_1': 0, 'h_de_1_a_2': 0, 'h_de_2_a_3': 0, 'h_de_3_a_5': 0, 'h_de_5_a_10': 0, 'h_de_10_a_15': 0, 'h_de_15_a_20': 0, 'h_mais_de_20': 0, 'm_sem_rendimento': 0, 'm_ate_meio': 0, 'm_de_meio_a_1': 0, 'm_de_1_a_2': 0, 'm_de_2_a_3': 0, 'm_de_3_a_5': 0, 'm_de_5_a_10': 0, 'm_de_10_a_15': 0, 'm_de_15_a_20': 0, 'm_mais_de_20': 0, } piramide = { 'h_100_mais': 0, 'h_95_99': 0, 'h_90_94': 0, 'h_85_89': 0, 'h_80_84': 0, 'h_75_79': 0, 'h_70_74': 0, 'h_65_69': 0, 'h_60_64': 0, 'h_55_59': 0, 'h_50_54': 0, 'h_45_49': 0, 'h_40_44': 0, 'h_35_39': 0, 'h_30_34': 0, 'h_25_29': 0, 'h_20_24': 0, 'h_15_19': 0, 'h_10_14': 0, 'h_5_9': 0, 'h_0_4': 0, 'm_100_mais': 0, 'm_95_99': 0, 'm_90_94': 0, 'm_85_89': 0, 'm_80_84': 0, 'm_75_79': 0, 'm_70_74': 0, 'm_65_69': 0, 'm_60_64': 0, 'm_55_59': 0, 'm_50_54': 0, 'm_45_49': 0, 'm_40_44': 0, 'm_35_39': 0, 'm_30_34': 0, 'm_25_29': 0, 'm_20_24': 0, 'm_15_19': 0, 'm_10_14': 0, 'm_5_9': 0, 'm_0_4': 0, } infra = { 'd_arborizacao_s': 0, 'd_calcada_s': 0, 'd_iluminacao_s': 0, 'd_pavimentacao_s': 0, 'd_rampa_cadeirante_s': 0, 'd_esgoto_s': 0, 'd_lixo_s': 0, 'm_arborizacao_s': 0, 'm_calcada_s': 0, 'm_iluminacao_s': 0, 'm_pavimentacao_s': 0, 'm_rampa_cadeirante_s': 0, 'm_esgoto_s': 0, 'm_lixo_s': 0, 'd_arborizacao_n': 0, 'd_calcada_n': 0, 'd_iluminacao_n': 0, 'd_pavimentacao_n': 0, 'd_rampa_cadeirante_n': 0, 'd_esgoto_n': 0, 'd_lixo_n': 0, 'm_arborizacao_n': 0, 'm_calcada_n': 0, 'm_iluminacao_n': 0, 'm_pavimentacao_n': 0, 'm_rampa_cadeirante_n': 0, 'm_esgoto_n': 0, 'm_lixo_n': 0, } alfab = { 'h_5_9_s': 0, 'h_10_14_s': 0, 'h_15_19_s': 0, 'h_20_24_s': 0, 'h_25_29_s': 0, 'h_30_34_s': 0, 'h_35_39_s': 0, 'h_40_44_s': 0, 'h_45_49_s': 0, 'h_50_54_s': 0, 'h_55_59_s': 0, 'h_60_64_s': 0, 'h_65_69_s': 0, 'h_70_74_s': 0, 'h_75_79_s': 0, 'h_mais80_s': 0, 'm_5_9_s': 0, 'm_10_14_s': 0, 'm_15_19_s': 0, 'm_20_24_s': 0, 'm_25_29_s': 0, 'm_30_34_s': 0, 'm_35_39_s': 0, 'm_40_44_s': 0, 'm_45_49_s': 0, 'm_50_54_s': 0, 'm_55_59_s': 0, 'm_60_64_s': 0, 'm_65_69_s': 0, 'm_70_74_s': 0, 'm_75_79_s': 0, 'm_mais80_s': 0, 'h_5_9_n': 0, 'h_10_14_n': 0, 'h_15_19_n': 0, 'h_20_24_n': 0, 'h_25_29_n': 0, 'h_30_34_n': 0, 'h_35_39_n': 0, 'h_40_44_n': 0, 'h_45_49_n': 0, 'h_50_54_n': 0, 'h_55_59_n': 0, 'h_60_64_n': 0, 'h_65_69_n': 0, 'h_70_74_n': 0, 'h_75_79_n': 0, 'h_mais80_n': 0, 'm_5_9_n': 0, 'm_10_14_n': 0, 'm_15_19_n': 0, 'm_20_24_n': 0, 'm_25_29_n': 0, 'm_30_34_n': 0, 'm_35_39_n': 0, 'm_40_44_n': 0, 'm_45_49_n': 0, 'm_50_54_n': 0, 'm_55_59_n': 0, 'm_60_64_n': 0, 'm_65_69_n': 0, 'm_70_74_n': 0, 'm_75_79_n': 0, 'm_mais80_n': 0, } raca = { 'branca': 0, 'preta': 0, 'amarela': 0, 'parda': 0, 'indigena': 0, } for s in todos_setores: try: racacor = Pessoa03PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) raca['branca'] += racacor.v002 raca['preta'] += racacor.v003 raca['amarela'] += racacor.v004 raca['parda'] += racacor.v005 raca['indigena'] += racacor.v006 except: pass try: dom01 = Domicilio01PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) domicilio_por_setor['casas'] += dom01.s001 domicilio_por_setor['apartamentos'] += dom01.v005 domicilio_por_setor['sem_agua'] += dom01.s004 domicilio_por_setor['sem_banheiro'] += dom01.v023 domicilio_por_setor['sem_lixo'] += dom01.s005 domicilio_por_setor['sem_energia'] += dom01.v046 domicilio_por_setor['casas_p'] += dom01.ps001 / len(todos_setores) domicilio_por_setor['apartamentos_p'] += dom01.pv005 / len(todos_setores) domicilio_por_setor['sem_agua_p'] += dom01.ps004 / len(todos_setores) domicilio_por_setor['sem_banheiro_p'] += dom01.pv023 / len(todos_setores) domicilio_por_setor['sem_lixo_p'] += dom01.ps005 / len(todos_setores) domicilio_por_setor['sem_energia_p'] += dom01.pv046 / len(todos_setores) except: pass try: mor01 = Domicilio02PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) moradores['casas'] += mor01.s001 moradores['apartamentos'] += mor01.v005 moradores['sem_agua'] += mor01.s004 moradores['sem_banheiro'] += mor01.v023 moradores['sem_lixo'] += mor01.s005 moradores['sem_energia'] += mor01.v041 moradores['casas_p'] += mor01.ps001 / len(todos_setores) moradores['apartamentos_p'] += mor01.pv005 / len(todos_setores) moradores['sem_agua_p'] += mor01.ps004 / len(todos_setores) moradores['sem_banheiro_p'] += mor01.pv023 / len(todos_setores) moradores['sem_lixo_p'] += mor01.ps005 / len(todos_setores) moradores['sem_energia_p'] += mor01.pv041 / len(todos_setores) except: pass try: r01 = Responsavel01PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) r02 = Responsavel02PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) rrenda = ResponsavelrendaPorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) responsaveis['h_responsaveis'] += r02.v109 responsaveis['h_responsaveis_p'] += r02.pv109 / len(todos_setores) responsaveis['h_nao_alfabetizados'] += r02.s004 responsaveis['h_nao_alfabetizados_p'] += r02.ps004 / len(todos_setores) responsaveis['h_ate_18'] += r02.s003 responsaveis['h_ate_18_p'] += r02.ps003 / len(todos_setores) responsaveis['h_sem_rendimento'] += rrenda.v032 responsaveis['h_sem_rendimento_p'] += rrenda.pv032 / len(todos_setores) responsaveis['h_rendimento_1sm'] += rrenda.s002 responsaveis['h_rendimento_1sm_p'] += rrenda.ps002 / len(todos_setores) responsaveis['m_responsaveis'] += r01.v001 responsaveis['m_responsaveis_p'] += r01.pv001 / len(todos_setores) responsaveis['m_nao_alfabetizados'] += r01.s002 responsaveis['m_nao_alfabetizados_p'] += r01.ps002 / len(todos_setores) responsaveis['m_ate_18'] += r01.s001 responsaveis['m_ate_18_p'] += r01.ps001 / len(todos_setores) responsaveis['m_sem_rendimento'] += rrenda.v054 responsaveis['m_sem_rendimento_p'] += rrenda.pv054 / len(todos_setores) responsaveis['m_rendimento_1sm'] += rrenda.s003 responsaveis['m_rendimento_1sm_p'] += rrenda.ps003 / len(todos_setores) responsaveis['t_responsaveis'] += r02.v001 #responsaveis['t_responsaveis_p'] += r02.pv001 / len(todos_setores) responsaveis['t_nao_alfabetizados'] += r02.s002 #responsaveis['t_nao_alfabetizados_p'] += r02.ps002 / len(todos_setores) responsaveis['t_ate_18'] += r02.s001 #responsaveis['t_ate_18_p'] += r02.ps001 / len(todos_setores) responsaveis['t_sem_rendimento'] += rrenda.v010 responsaveis['t_sem_rendimento_p'] += rrenda.pv010 / len(todos_setores) responsaveis['t_rendimento_1sm'] += rrenda.s001 responsaveis['t_rendimento_1sm_p'] += rrenda.ps001 / len(todos_setores) except: pass try: drenda = DomiciliorendaPorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) except: drenda = False pass try: prenda = PessoarendaPorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) except: prenda = False pass try: basico_setor = BasicoPorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) except: basico_setor = False pass if drenda: renda['dom_sem_rendimento'] += drenda.v014 renda['dom_ate_meio'] += drenda.s001 renda['dom_de_meio_a_1'] += drenda.v008 renda['dom_de_1_a_2'] += drenda.v009 renda['dom_de_2_a_3'] += drenda.v010 renda['dom_de_3_a_5'] += drenda.v011 renda['dom_de_5_a_10'] += drenda.v012 renda['dom_de_10_a_15'] += drenda.v013 if prenda: renda['h_sem_rendimento'] += prenda.v032 renda['h_ate_meio'] += prenda.v023 renda['h_de_meio_a_1'] += prenda.v024 renda['h_de_1_a_2'] += prenda.v025 renda['h_de_2_a_3'] += prenda.v026 renda['h_de_3_a_5'] += prenda.v027 renda['h_de_5_a_10'] += prenda.v028 renda['h_de_10_a_15'] += prenda.v029 renda['h_de_15_a_20'] += prenda.v030 renda['h_mais_de_20'] += prenda.v031 renda['m_sem_rendimento'] += prenda.v054 renda['m_ate_meio'] += prenda.v045 renda['m_de_meio_a_1'] += prenda.v046 renda['m_de_1_a_2'] += prenda.v047 renda['m_de_2_a_3'] += prenda.v048 renda['m_de_3_a_5'] += prenda.v049 renda['m_de_5_a_10'] += prenda.v050 renda['m_de_10_a_15'] += prenda.v051 renda['m_de_15_a_20'] += prenda.v052 renda['m_mais_de_20'] += prenda.v053 try: psetor = Pessoa11PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) psetor2 = Pessoa12PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) piramide['h_100_mais'] += psetor.v134 piramide['h_95_99'] += psetor.s020 piramide['h_90_94'] += psetor.s019 piramide['h_85_89'] += psetor.s018 piramide['h_80_84'] += psetor.s017 piramide['h_75_79'] += psetor.s016 piramide['h_70_74'] += psetor.s015 piramide['h_65_69'] += psetor.s014 piramide['h_60_64'] += psetor.s013 piramide['h_55_59'] += psetor.s012 piramide['h_50_54'] += psetor.s011 piramide['h_45_49'] += psetor.s010 piramide['h_40_44'] += psetor.s009 piramide['h_35_39'] += psetor.s008 piramide['h_30_34'] += psetor.s007 piramide['h_25_29'] += psetor.s006 piramide['h_20_24'] += psetor.s005 piramide['h_15_19'] += psetor.s004 piramide['h_10_14'] += psetor.s003 piramide['h_5_9'] += psetor.s002 piramide['h_0_4'] += psetor.s001 piramide['m_100_mais'] += psetor.v134 piramide['m_95_99'] += psetor2.s020 piramide['m_90_94'] += psetor2.s019 piramide['m_85_89'] += psetor2.s018 piramide['m_80_84'] += psetor2.s017 piramide['m_75_79'] += psetor2.s016 piramide['m_70_74'] += psetor2.s015 piramide['m_65_69'] += psetor2.s014 piramide['m_60_64'] += psetor2.s013 piramide['m_55_59'] += psetor2.s012 piramide['m_50_54'] += psetor2.s011 piramide['m_45_49'] += psetor2.s010 piramide['m_40_44'] += psetor2.s009 piramide['m_35_39'] += psetor2.s008 piramide['m_30_34'] += psetor2.s007 piramide['m_25_29'] += psetor2.s006 piramide['m_20_24'] += psetor2.s005 piramide['m_15_19'] += psetor2.s004 piramide['m_10_14'] += psetor2.s003 piramide['m_5_9'] += psetor2.s002 piramide['m_0_4'] += psetor2.s001 except: pass try: entorno01 = Entorno01PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) entorno02 = Entorno03PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) infra['d_arborizacao_s'] += entorno01.s015 infra['d_calcada_s'] += entorno01.s007 infra['d_pavimentacao_s'] += entorno01.s005 infra['d_rampa_cadeirante_s'] += entorno01.s013 infra['d_esgoto_s'] += entorno01.s017 infra['d_lixo_s'] += entorno01.s019 infra['d_iluminacao_s'] += entorno01.s003 infra['d_arborizacao_n'] += entorno01.s016 infra['d_calcada_n'] += entorno01.s008 infra['d_pavimentacao_n'] += entorno01.s006 infra['d_rampa_cadeirante_n'] += entorno01.s014 infra['d_esgoto_n'] += entorno01.s018 infra['d_lixo_n'] += entorno01.s020 infra['d_iluminacao_n'] += entorno01.s004 infra['m_arborizacao_s'] += entorno02.s015 infra['m_calcada_s'] += entorno02.s007 infra['m_pavimentacao_s'] += entorno02.s005 infra['m_rampa_cadeirante_s'] += entorno02.s013 infra['m_esgoto_s'] += entorno02.s017 infra['m_lixo_s'] += entorno02.s019 infra['m_iluminacao_s'] += entorno02.s003 infra['m_arborizacao_n'] += entorno02.s016 infra['m_calcada_n'] += entorno02.s008 infra['m_pavimentacao_n'] += entorno02.s006 infra['m_rampa_cadeirante_n'] += entorno02.s014 infra['m_esgoto_n'] += entorno02.s018 infra['m_lixo_n'] += entorno02.s020 infra['m_iluminacao_n'] += entorno02.s004 except: pass try: p01 = Pessoa02PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) p02 = Pessoa01PorSetor.objects.using('censo_ibge').get(cod_setor = float(s.cd_geocodi)) alfab['h_5_9_s'] += p01.s001 alfab['h_10_14_s'] += p01.s002 alfab['h_15_19_s'] += p01.s003 alfab['h_20_24_s'] += p01.s004 alfab['h_25_29_s'] += p01.s005 alfab['h_30_34_s'] += p01.s006 alfab['h_35_39_s'] += p01.s007 alfab['h_40_44_s'] += p01.s008 alfab['h_45_49_s'] += p01.s009 alfab['h_50_54_s'] += p01.s010 alfab['h_55_59_s'] += p01.s011 alfab['h_60_64_s'] += p01.s012 alfab['h_65_69_s'] += p01.s013 alfab['h_70_74_s'] += p01.s014 alfab['h_75_79_s'] += p01.s015 alfab['h_mais80_s'] += p01.v077 alfab['m_5_9_s'] += p01.s032 alfab['m_10_14_s'] += p01.s033 alfab['m_15_19_s'] += p01.s034 alfab['m_20_24_s'] += p01.s035 alfab['m_25_29_s'] += p01.s036 alfab['m_30_34_s'] += p01.s037 alfab['m_35_39_s'] += p01.s038 alfab['m_40_44_s'] += p01.s039 alfab['m_45_49_s'] += p01.s040 alfab['m_50_54_s'] += p01.s041 alfab['m_55_59_s'] += p01.s042 alfab['m_60_64_s'] += p01.s043 alfab['m_65_69_s'] += p01.s044 alfab['m_70_74_s'] += p01.s045 alfab['m_75_79_s'] += p01.s046 alfab['m_mais80_s'] += p01.v162 alfab['h_5_9_n'] += p01.s016 alfab['h_10_14_n'] += p01.s017 alfab['h_15_19_n'] += p01.s018 alfab['h_20_24_n'] += p01.s019 alfab['h_25_29_n'] += p01.s020 alfab['h_30_34_n'] += p01.s021 alfab['h_35_39_n'] += p01.s022 alfab['h_40_44_n'] += p01.s023 alfab['h_45_49_n'] += p01.s024 alfab['h_50_54_n'] += p01.s025 alfab['h_55_59_n'] += p01.s026 alfab['h_60_64_n'] += p01.s027 alfab['h_65_69_n'] += p01.s028 alfab['h_70_74_n'] += p01.s029 alfab['h_75_79_n'] += p01.s030 alfab['h_mais80_n'] += p01.s031 alfab['m_5_9_n'] += p01.s047 alfab['m_10_14_n'] += p01.s048 alfab['m_15_19_n'] += p01.s049 alfab['m_20_24_n'] += p01.s050 alfab['m_25_29_n'] += p01.s051 alfab['m_30_34_n'] += p01.s052 alfab['m_35_39_n'] += p01.s053 alfab['m_40_44_n'] += p01.s054 alfab['m_45_49_n'] += p01.s055 alfab['m_50_54_n'] += p01.s056 alfab['m_55_59_n'] += p01.s057 alfab['m_60_64_n'] += p01.s058 alfab['m_65_69_n'] += p01.s059 alfab['m_70_74_n'] += p01.s060 alfab['m_75_79_n'] += p01.s061 alfab['m_mais80_n'] += p01.s062 except: pass # Pega os equipamentos de saude from saude.models import Saude equipamentos_saude = [] try: for p in Saude.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters equipamentos_saude.append({ 'nome': p.nome, 'tipo_logradouro': p.tipo_logra, 'nome_logradouro': p.nome_logra, 'numero_logradouro': p.num_lograd, 'id': p.id, 'distancia': distancia, }) except: pass # Pega os teatros from teatro.models import Teatro teatros = [] try: for p in Teatro.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters teatros.append({ 'nome': p.nome, 'tipo_logradouro': p.tipo_logradouro, 'nome_logradouro': p.nome_logradouro, 'numero_logradouro': p.numero_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # pega os museus from museu.models import Museu museus = [] try: for p in Museu.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters museus.append({ 'nome': p.nome, 'tipo_logradouro': p.tipo_logradouro, 'nome_logradouro': p.nome_logradouro, 'numero_logradouro': p.numero_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # Pega as bibliotecas from biblioteca.models import Biblioteca bibliotecas = [] try: for p in Biblioteca.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters bibliotecas.append({ 'nome': p.nome, 'tipo_logradouro': p.tipo_logradouro, 'nome_logradouro': p.nome_logradouro, 'numero_logradouro': p.numero_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # Pega os centros de ciencia from centro_ciencia.models import CentroCiencia centros_ciencia = [] try: for p in CentroCiencia.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters centros_ciencia.append({ 'nome': p.nome, 'tipo_logradouro': p.tipo_logradouro, 'nome_logradouro': p.nome_logradouro, 'numero_logradouro': p.numero_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # Pega CRAs from cra.models import Cra try: cras = Cra.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)) except: cras = [] # Pega os cinemas from cinema.models import Cinema cinemas = [] try: for p in Cinema.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters cinemas.append({ 'nome': p.nome, 'tipo_logradouro': p.tipo_logradouro, 'nome_logradouro': p.nome_logradouro, 'numero_logradouro': p.numero_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # Pega as salas verdes from sala_verde.models import SalaVerde salas_verdes = [] try: for p in SalaVerde.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters salas_verdes.append({ 'nome': p.nome, 'endereco': p.nome_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # Pega os pontos de cultura from ponto_cultura.models import PontoCultura pontos_cultura = [] try: for p in PontoCultura.objects.filter(geom__distance_lte = (escola.latlong, distancia_raio)).distance(escola.latlong).order_by('distance'): ll_p = (p.longitude, p.latitude) distancia = geopy_distance(ll_e, ll_p).meters pontos_cultura.append({ 'projeto': p.projeto, 'tipo_logradouro': p.tipo_logradouro, 'nome_logradouro': p.nome_logradouro, 'numero_logradouro': p.numero_logradouro, 'id': p.id, 'distancia': distancia }) except: pass # Soma domicilios try: total_domicilios = domicilio_por_setor['casas'] + domicilio_por_setor['apartamentos'] except: total_domicilios = 0 try: total_moradores = moradores['casas'] + moradores['apartamentos'] except: total_moradores = 0 try: numero_setores = len(todos_setores) except: numero_setores = 0 try: media_moradores = total_moradores / total_domicilios except: media_moradores = 0 ideb = Ideb.objects.get(codigo_inep = codigo_inep) return render_to_response('territorio/territorio.html', { 'escola': escola, 'latitude': latitude, 'longitude': longitude, 'setores': todos_setores, 'domicilio_por_setor': domicilio_por_setor, 'moradores': moradores, 'responsaveis': responsaveis, 'renda': renda, 'piramide': piramide, 'infra': infra, 'alfab': alfab, 'dados': dados_escolas, 'equipamentos_saude': equipamentos_saude, 'teatros': teatros, 'museus': museus, 'cinemas': cinemas, 'salas_verdes': salas_verdes, 'pontos_cultura': pontos_cultura, 'bibliotecas': bibliotecas, 'centros_ciencia': centros_ciencia, 'cras': cras, 'raca': raca, 'total_domicilios': total_domicilios, 'total_moradores': total_moradores, 'numero_setores': numero_setores, 'media_moradores': media_moradores, 'ideb': ideb, })
def get_distance(self): return geopy_distance( (self.reference.position.y, self.reference.position.x), (self.colocated.position.y, self.colocated.position.x), )