def get(self, request): point_of_user = GEOSGeometry("POINT({} {})".format( -106.3911803, 31.6482147)) point_to_go = GEOSGeometry("POINT({} {})".format( -106.354794, 31.627863)) max_distance = 250 # m coordendadas = RutaCoordenda.objects.filter( coordenadas__distance_lt=(point_of_user, Distance( m=max_distance)), ).annotate(distance=qDistance( 'coordenadas', point_of_user)).distinct("ruta") ids = [] for coordendada in coordendadas: print coordendada ids.append(coordendada.ruta_id) coordendadas2 = RutaCoordenda.objects.filter( coordenadas__distance_lt=(point_to_go, Distance(m=max_distance)), ruta__id__in=ids).annotate(distance=qDistance( 'coordenadas', point_to_go)).distinct("ruta") ruta = None for coordendada in coordendadas2: # print "salgo", coordendada.distance, coordendada ruta = coordendada.ruta return render(request, self.template_name, context={"ruta": ruta})
def filter_queryset(self, queryset): # Apply any filter backends filters = {} for field in self.lookup_fields: if self.kwargs[field]: # Ignore empty fields. filters[field] = self.kwargs[field] obj = get_object_or_404(User.objects.all(), **filters) # Lookup the object radius = int(self.request.query_params['radius']) if radius > 100: raise serializers.ValidationError("To high radius") if (obj.usertype == 'HF'): data = User.objects.filter( usertype='HFS', public=False, location__distance_lte=(obj.location, Distance(km=radius))) else: data = User.objects.filter( usertype='HF', public=False, location__distance_lte=(obj.location, Distance(km=radius))) if (validsessionid(obj)): self.check_object_permissions(self.request, obj) return data raise serializers.ValidationError("Invalid Sessionid")
def format_meters(value, unit): if unit == 'km': return '{:.2f} km'.format(Distance(m=value).km) if unit == 'mi': return '{:.2f} miles'.format(Distance(m=value).mi) return '{:.2f} meters'.format(Distance(m=value).m)
def validate_buffer(wkb_geometry, apiary_sites_to_exclude=None): """ This function checks if the wkb_geometry (point) is at least 3km away from the other apiary sites @param wkb_geometry: WKB geometry of a point @param apiary_sites_to_exclude: List or queryset of the apiary sites to be excluded when validation """ if not apiary_sites_to_exclude: from disturbance.components.proposals.models import ApiarySite apiary_sites_to_exclude = ApiarySite.objects.none() site_too_close_error = serializers.ValidationError([ 'Apiary Site: (lat: {}, lng: {}) is too close to another apiary site.'. format( wkb_geometry.coords[1], wkb_geometry.coords[0], ) ]) qs_vacant_site_proposal, qs_vacant_site_approval = get_qs_vacant_site() sites = qs_vacant_site_proposal.exclude( apiary_site__in=apiary_sites_to_exclude).filter( Q(wkb_geometry_processed__distance_lte=(wkb_geometry, Distance( m=RESTRICTED_RADIUS)))) if sites: raise site_too_close_error sites = qs_vacant_site_approval.exclude( apiary_site__in=apiary_sites_to_exclude).filter( Q(wkb_geometry__distance_lte=(wkb_geometry, Distance(m=RESTRICTED_RADIUS)))) if sites: raise site_too_close_error #qs_on_proposal_draft, qs_on_proposal_processed = get_qs_proposal() qs_on_proposal_draft = get_qs_proposal('draft') qs_on_proposal_processed = get_qs_proposal('processed') sites = qs_on_proposal_draft.exclude( apiary_site__in=apiary_sites_to_exclude).filter( Q(wkb_geometry_draft__distance_lte=(wkb_geometry, Distance( m=RESTRICTED_RADIUS)))) if sites: raise site_too_close_error sites = qs_on_proposal_processed.exclude( apiary_site__in=apiary_sites_to_exclude).filter( Q(wkb_geometry_processed__distance_lte=(wkb_geometry, Distance( m=RESTRICTED_RADIUS)))) if sites: raise site_too_close_error qs_on_approval = get_qs_approval() sites = qs_on_approval.exclude( apiary_site__in=apiary_sites_to_exclude).filter( Q(wkb_geometry__distance_lte=(wkb_geometry, Distance(m=RESTRICTED_RADIUS)))) if sites: raise site_too_close_error
def get_queryset(self): queryset = Ad.objects.all() # not detail page if not self.kwargs.get('pk'): queryset = queryset.filter(is_published=True, region__isnull=0) if self.request.query_params.get('own', None) is not None: if self.request.user.is_authenticated(): queryset = Ad.objects.filter(user=self.request.user.id) else: queryset = Ad.objects.none() lon = float(self.request.query_params.get('lon') or 0) lat = float(self.request.query_params.get('lat') or 0) radius = float(self.request.query_params.get('radius') or 5) if lon and lat: if settings.MESTO_USE_GEODJANGO: distance_filters = make_sphere_distance_filters( 'point', Point(lon, lat, srid=4326), Distance(km=radius)) else: distance_filters = make_coords_ranges_filters( (lon, lat), Distance(km=radius)) queryset = queryset.filter(**distance_filters) region_id = self.request.query_params.get('region', None) if region_id is not None: region = Region.objects.get(pk=region_id) queryset = queryset.filter(region__in=region.get_descendants(True)) min_price = int(self.request.query_params.get('min_price') or 0) max_price = int(self.request.query_params.get('max_price') or 0) if min_price or max_price: curr_rate = 1 currency = self.request.query_params.get('currency', None) if currency: curr_rate = get_currency_rates()[currency] if min_price > 0: queryset = queryset.filter(price_uah__gte=min_price * curr_rate) if max_price > 0: queryset = queryset.filter(price_uah__lte=max_price * curr_rate) queryset = queryset.prefetch_related('region', 'phones_in_ad', 'phones', 'photos', 'facilities', 'user', 'user__agencies') return queryset
def validate_similar(self): # 1. Location within buffer # 2. Fuzzy match site name pk = self.instance.pk project_id = self.instance.project_id name = self.instance.name location = self.instance.location # Ignore self and ensure same project qry = self.model.objects.filter(~Q(id=pk)) qry = qry.filter(project_id=project_id) if location is not None: qry = qry.filter( location__distance_lt=(location, Distance(m=self.site_buffer))) # Fuzzy name match qry = qry.annotate(similarity=TrigramSimilarity("name", name)) qry = qry.filter(similarity__gte=self.name_match_percent) qry = qry.order_by("-similarity") results = qry[0:3] if results.count() > 0: matches = [r.id for r in results] data = dict(matches=matches) return self.warning(self.identifier, _(LikeMatchWarning.format(self.name)), data=data) return self.ok(self.identifier)
def parcel_info(request, **kwargs): lat = float(kwargs['lat']) lng = float(kwargs['long']) point = Point(lng, lat) radius = 0.7 parcelz = serialize( 'geojson', ParcelInfo.objects.filter(geom__distance_lt=(point, Distance(km=radius)))) trial = json.loads(parcelz) ids = [element['properties']['parcelid'] for element in trial['features']] queryset = serialize( 'json', History.objects.filter(parcelid__in=ids).order_by('-date')) letsee = json.loads(queryset) for i in trial['features']: id_ = i['properties']['parcelid'] i['properties']['history'] = [ x for x in letsee if x['fields']['parcelid'] == id_ ] # print(queryset) # things = [json.loads(line) for line in f] # i['properties']['history'] = queryset new = json.dumps(trial) return HttpResponse(new, content_type='json')
def get(self, request): # Request must be authorized if not request.user.is_authenticated: return Response('User not authenticated!', status=status.HTTP_401_UNAUTHORIZED) events = Event.objects.all() # if author filter author = request.query_params.get('author') if author: events = events.filter(author=int(author)) # if category filter category = request.query_params.get('category') if category: events = events.filter(category=int(category)) # if geo_location filter lat = request.query_params.get('lat') lon = request.query_params.get('lon') radius = request.query_params.get('r') if lat and lon and radius: events = events.filter( geo_location__distance_lt=(Point(float(lon), float(lat)), Distance(km=radius))) serializer = EventSerializer(events, many=True) # Remove geo_location from response for s in serializer.data: s.pop('geo_location') return Response(serializer.data)
def build_filters(self, filters=None): if filters is None: filters = {} orm_filters = super(ProductResource, self).build_filters(filters) if "q" in filters or "l" in filters: sqs = product_search if "q" in filters: sqs = sqs.auto_query(filters['q']) if "l" in filters: name, coords, radius = GoogleGeocoder().geocode(filters['l']) if all(coords): radius = filters.get('r', radius if radius else DEFAULT_RADIUS) point = Point(coords) sqs = sqs.dwithin( 'location', point, Distance(km=radius)) #.distance('location', point) pk = [] for p in sqs: try: pk.append(int(p.pk)) except ValueError: pass orm_filters.update({"pk__in": pk}) return orm_filters
def filter_queryset(self, request, queryset, view): nearby_pk = request.query_params.get('nearby_pk', None) if nearby_pk is not None: point = models.Request.objects.get(pk=nearby_pk).location return queryset.filter(location__distance_lt=(point, Distance( km=10))).order_by('pk') return queryset
def result2(request, lat, lon='33.00'): if float(lat)<-180 or float(lat)>180: return HttpResponseBadRequest('Error 400') #return HttpResponse(status=400) #AEN: THIS DOESN'T WORK! Maybe it was, but was just sending an empty page. I WANT THE DEFAULT! #raise Http404; #This SHOULD be 400 pt = Point(float(lon), float(lat)) country = WorldBorder.objects.filter(mpoly__contains=pt) countriesNearUS = filter(lambda x:x.closeToUS(), WorldBorder.objects.all()) if not country: context = {'lat':lat, 'lon':lon, 'countriesNearUnitedStates':countriesNearUS} return render(request, 'world/result.html', context) d=Distance(m=500) touching = WorldBorder.objects.filter(mpoly__touches=country[0].mpoly) ### neighbors = WorldBorder.objects.filter(mpoly__distance_lte=(country[0].mpoly, d)) ### neighbors = filter(lambda x: x.id!=country[0].id, neighbors) t = tasks.getArea.delay(country[0].id) t.wait(); #This should be something far more complicated, like a long pull,Perhaps USING rabbitmq to check based on the task.id! area = str(t.result) context = {'country':country, 'lat':lat, 'lon':lon, 'touching':touching, 'neighbors':[], 'distance':d, 'area':area, 'countriesNearUnitedStates':countriesNearUS} return render(request, 'world/result.html', context) '''if not country:
def to_python(self, value): if value in self.empty_values: return None try: obj = json.loads(value) except JSONDecodeError: raise DjangoValidationError(self.default_error_messages['invalid_json'], code='invalid_json') if set(obj) != {'max_distance', 'coordinates'}: raise DjangoValidationError(self.default_error_messages['invalid_fields'], code='invalid_fields') max_distance = obj['max_distance'] coordinates = obj['coordinates'] try: max_distance = float(max_distance) except ValueError: raise DjangoValidationError(self.default_error_messages['invalid_max_distance'], code='invalid_max_distance') if not check_coordinates(coordinates): raise DjangoValidationError(self.default_error_messages['invalid_coordinates'], code='invalid_coordinates') return Point(*coordinates), Distance(m=max_distance)
def test_dwitihin(self, search_queryset): sqs = search_queryset latlong = (0.4, 5.1) list(sqs.dwithin('location', Point(latlong), Distance(km=10))) assert search_params.params['aroundLatLng'] == "0.4,5.1" assert search_params.params['aroundRadius'] == 10000
def validate_value(self, view, field, value, expected_value_type=None): value = super().validate_value(view, field, value, expected_value_type) if 'longitude' not in value or 'latitude' not in value: raise InvalidQuery(self.default_error.format(lookup=self.lookup, field_name=field.name)) longitude, latitude = value['longitude'], value['latitude'] if not self._check_number(longitude, (-180, 180)) or not self._check_number(latitude, (-90, 90)): raise InvalidQuery('Invalid longitude/latitude values.') # Default distance is 100 miles distance_unit = 'mi' distance = 100 max_distance = None if 'distance_in_miles' in value: distance = value['distance_in_miles'] # Equator length is 24901 miles max_distance = 24901 elif 'distance_in_kilometers' in value: distance = value['distance_in_kilometers'] distance_unit = 'km' # Equator length is 40075 km max_distance = 40075 if max_distance is not None and not self._check_number(distance, (0, max_distance), inclusive=True): raise InvalidQuery('Invalid distance value.') return Point(longitude, latitude), Distance(**{distance_unit: distance})
def nearest_stores(request): longitude = float(request.POST.get('longitude')) latitude = float(request.POST.get('latitude')) longitude = 76.702074 latitude = 30.715480 location_point = Point(longitude, latitude) radius = 5 shops = Location.objects.filter( geo_location__distance_lt=(location_point, Distance(km=radius))) results = serializers.serialize('json', shops) data = json.loads(results) x = [shop.geo_location.x for shop in shops] y = [shop.geo_location.y for shop in shops] mapbox_access_token = 'pk.eyJ1Ijoia2F1c2hhbDE3NyIsImEiOiJjazJlbDZseHUwNjNhM2xwdGgxeWZjNXNxIn0.nuPmPOZP5jRSy6LP4XP3gg' print(x[0]) location = [] for i in range(len(x)): g = geocoder.reverse_geocode(y[i], x[i]) location1 = g[0]['formatted'].split(',') print(location1[0]) location.append(location1[0]) print(location) return JsonResponse({'longitude':longitude,'latitude':latitude,\ 'mapbox_access_token': mapbox_access_token,"x":x,'y':y,\ 'shops':data,'location':location})
def to_python(self, value): if value in self.empty_values: return None try: obj = json.loads(value) except JSONDecodeError: raise DjangoValidationError( self.default_error_messages["invalid_json"], code="invalid_json") if set(obj) != {"max_distance", "coordinates"}: raise DjangoValidationError( self.default_error_messages["invalid_fields"], code="invalid_fields") max_distance = obj["max_distance"] coordinates = obj["coordinates"] try: max_distance = float(max_distance) except ValueError: raise DjangoValidationError( self.default_error_messages["invalid_max_distance"], code="invalid_max_distance", ) if not check_coordinates(coordinates): raise DjangoValidationError( self.default_error_messages["invalid_coordinates"], code="invalid_coordinates", ) return Point(*coordinates), Distance(m=max_distance)
def radial_search(request): """View used to search by objects within a specif circular area. This view receives parameters from GET request and returns a html page containing the result. Request params: center: the center coordinate of the circle. radius: the circle radius. """ center = Point(*[float(i) for i in request.GET['center'].split(',')]) radius = Distance(m=float(request.GET['radius'])) distance_query = (Q(points__distance_lte=(center, radius)) | Q(lines__distance_lte=(center, radius)) | Q(polys__distance_lte=(center, radius))) objs = _fetch_geo_objects(distance_query, 100) d = {} if 'communities' in request.GET: d['Community'] = objs['Community'] if 'needs' in request.GET: need_categories = request.GET['need_categories'].split(',') d['Need'] = [] for n in objs['Need']: if [c for c in n.categories.all() if str(c.id) in need_categories]: d['Need'].append(n) if 'organizations' in request.GET: d['Organization'] = objs['Organization'] if 'resources' in request.GET: d['Resource'] = objs['Resource'] return d
def handle(self, *args, **options): print 'start' # Burning.objects.all().delete() # o = Radiation.objects.get(pk=939) # b = Burning() # b.gridcode = o.gridcode # b.day = 1 # b.time = 1 # b.geom = o.geom # b.save() b = Burning.objects.get(pk=939) b.burning = 1 b.day = 1 b.time = 1 b.save() ###################DISTANCE######################## from django.contrib.gis.measure import Distance from django.contrib.gis.geos import * #from django.contrib.gis.geos import GEOSGeometry lon = 148.869028 lat = -35.581528 DISTANCE_LIMIT_METERS = 5000 input_point = Point(lon, lat, srid=4326) #input_point.transform(900913) #for r in Radiation.objects.filter(geom__dwithin=(input_point , D(km=DISTANCE_LIMIT_METERS))): dist = Distance(m=5000) #dist = 5000 #import pdb; pdb.set_trace() pnt = fromstr('POINT(-35.581528 148.869028)', srid=4326)
def convert_values(self, value, field, connection): """ Using the same routines that Oracle does we can convert our extra selection objects into Geometry and Distance objects. TODO: Make converted objects 'lazy' for less overhead. """ if connection.ops.oracle: # Running through Oracle's first. value = super(GeoQuery, self).convert_values(value, field or GeomField(), connection) if value is None: # Output from spatial function is NULL (e.g., called # function on a geometry field with NULL value). pass elif isinstance(field, DistanceField): # Using the field's distance attribute, can instantiate # `Distance` with the right context. value = Distance(**{field.distance_att: value}) elif isinstance(field, AreaField): value = Area(**{field.area_att: value}) elif isinstance(field, (GeomField, GeometryField)) and value: value = Geometry(value) elif field is not None: return super(GeoQuery, self).convert_values(value, field, connection) return value
def _get_distance(self): from django.contrib.gis.measure import Distance if self._distance is None: # We didn't get it from the backend & we haven't tried calculating # it yet. Check if geopy is available to do it the "slow" way # (even though slow meant 100 distance calculations in 0.004 seconds # in my testing). if geopy_distance is None: raise SpatialError( "The backend doesn't have 'DISTANCE_AVAILABLE' enabled & the 'geopy' library could not be imported, so distance information is not available." ) if not self._point_of_origin: raise SpatialError("The original point is not available.") if not hasattr(self, self._point_of_origin["field"]): raise SpatialError( "The field '%s' was not included in search results, so the distance could not be calculated." % self._point_of_origin["field"]) po_lng, po_lat = self._point_of_origin["point"].coords location_field = getattr(self, self._point_of_origin["field"]) if location_field is None: return None lf_lng, lf_lat = location_field.coords self._distance = Distance( km=geopy_distance.distance((po_lat, po_lng), (lf_lat, lf_lng)).km) # We've either already calculated it or the backend returned it, so # let's use that. return self._distance
def to_internal_value(self, data): try: params = {"{}".format(self.units): data} data = Distance(**params) except (TypeError, ValueError): self.fail('invalid') return data
def get_queryset(self): #split params by which it applies to mappoint_params = {} for (param, result) in self.request.query_params.items(): if param in ['max_lat','min_lat','max_lon','min_lon','dataset','tags','tag','state','zipcode']: mappoint_params[param] = result #if none of this is specified, this is just too much if len(mappoint_params) == 0: raise ParseError('Too many results. Please restrict the mappoints.') #now get the queryset points = filter_request(mappoint_params,'mappoint') distances = self.request.GET.getlist('distance') unit = self.request.GET.getlist('unit') if len(unit) > 1: raise ParseError('No more than one unit may be specified.') elif len(unit) == 0: unit = 'mi' elif unit[0] in ['m','km','mi']: unit = unit[0] else: raise ParseError('Accepted units: m, km, mi') if len(distances) == 0: distances = [1,3,5] unit = 'km' else: print distances distances.sort() kwargs = {unit:distances[-1]} take_out = [] for point in points: if point.id in take_out: continue take_out.extend(neighboring_points(point, points, Distance(**kwargs)).exclude(id=point.id).values_list('id',flat=True)) return points.exclude(id__in=take_out).distinct()
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 intersecting(cls, obj, distance=None, ordering=True, field='geom'): """ Small helper to filter all model instances by geometry intersection """ qs = cls.objects if not obj.geom: return qs.none() if hasattr(qs, 'existing'): qs = qs.existing() if distance is None: distance = obj.distance(cls) if distance: qs = qs.filter(**{'{}__dwithin'.format(field): (obj.geom, Distance(m=distance))}) else: qs = qs.filter(**{'{}__intersects'.format(field): obj.geom}) if obj.geom.geom_type == 'LineString' and ordering: # FIXME: move transform from DRF viewset to DRF itself and remove transform here ewkt = obj.geom.transform(settings.SRID, clone=True).ewkt qs = qs.extra(select={'ordering': 'ST_LineLocatePoint(ST_GeomFromEWKT(\'{ewkt}\'), ST_StartPoint((ST_Dump(ST_Intersection(ST_GeomFromEWKT(\'{ewkt}\'), geom))).geom))'.format(ewkt=ewkt)}) qs = qs.extra(order_by=['ordering']) if obj.__class__ == cls: # Prevent self intersection qs = qs.exclude(pk=obj.pk) return qs
def get_context_data(self, **kwargs): """Añade variables de contexto. Incrementa en 1 anuncio.views. Añade las siguientes variables de contexto: - form (MessageCreateForm): Formulario de contacto. - anuncios_related_list (queryset[Anuncio]): Anuncios del mismo tipo en la zona. - favorite_list_by_owner (list): PKs con los favoritos del usuario desde FavoriteListContextMixin. """ context = super().get_context_data(**kwargs) anuncio = self.object # Incrementar en 1 las vistas del anuncio. # Omitir si es superuser o si el usuario es el owner. if not self.request.user.is_superuser and anuncio.owner != self.request.user: anuncio.views += 1 anuncio.save() # Form de contacto. form = MessageCreateForm(self.request.POST or None) form.initial['anuncio'] = anuncio form.initial['sender'] = self.request.user form.initial['recipient'] = anuncio.owner context['form'] = form # Anuncios del mismo tipo en la misma zona. distance = anuncios_settings.ANUNCIO_RELACIONADO_KMS point = Point(anuncio.longitude, anuncio.latitude) anuncios_related_list = Anuncio.get_model_class( anuncio.category).objects.published( type_anuncio=anuncio.type_anuncio, point__distance_lt=(point, Distance(km=distance)) ).exclude(pk=anuncio.pk).select_related('owner').prefetch_related( 'image_anuncio')[0:anuncios_settings.ANUNCIO_NUM_RELACIONADO] context['anuncios_related_list'] = anuncios_related_list return context
def get_near_instructors(self, lat, lon, distance=None, *args, **kwargs): if not distance: distance = 1 current_point = Point(lon, lat) return self.filter( lat_long_points__distance_lte=(current_point, Distance(km=distance)), **kwargs)
def filter_subway_stations(qs, values): if values: q = Q() for subway_station in values: if settings.MESTO_USE_GEODJANGO: distance_filters = make_sphere_distance_filters( 'point', subway_station.point, Distance(m=1000)) else: coords = (subway_station.coords_x, subway_station.coords_y) distance_filters = make_coords_ranges_filters( coords, Distance(m=1000)) q |= Q(**distance_filters) qs = qs.filter(q) return qs
def get_queryset(self): longitude = float(self.request.query_params['longitude']) latitude = float(self.request.query_params['latitude']) radius = 10 point = Point(longitude, latitude) return Party.objects.filter( location__distance_lt=(point, Distance(km=radius)))
def nearby(self,request, *args, **kwargs): location = request.GET['location'].split(',') radius = request.GET['distance'] lat = location[0] lng = location[1] point = Point(float(lng), float(lat)) self.queryset = Climb.objects.filter(location__distance_lt=(point, Distance(km=radius))) return super().list(request)
def filter(self, qs, value): if value in EMPTY_VALUES: return qs lat, lng = value.split("#") point = Point(float(lng), float(lat)) return qs.filter(store__point__distance_lt=(point, Distance(km=100)))