我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用django.contrib.gis.geos.Point()。
def probability(request,ltlat, ltlong, rblat, rblong ,poslat, poslong, dayindex, hourindex): #dayindex starts with 1 for sunday, see https://docs.djangoproject.com/en/dev/ref/models/querysets/#week-day loc = Point(float(poslong),float(poslat),srid=4326 ) #fixme: check that srid=4326 is right print(loc) result = Bikes.objects.filter(timestamp__week_day=dayindex).filter(timestamp__hour=hourindex).filter(bikes__gt=0)\ .extra({'date_found' : "date(timestamp)"}).values('date_found')\ .annotate(min_distance=Min(Distance('place_coords', loc))).order_by('min_distance') result_count = len(result) result_ranges = {} percentages = [0.25,0.50,0.75,0.90] p_ind = 0 for i in range(result_count): # this finds the minimum distance for which the percentages from the list are fullfiled for bike availability percentage_sum = (i+1)/result_count while p_ind < len(percentages): if percentages[p_ind] <= percentage_sum: result_ranges[str(percentages[p_ind])]=result[i]["min_distance"] p_ind+=1 else: break return HttpResponse(json.dumps(result_ranges), content_type='application/json')
def _set_geom(self): xform = self.xform data_dictionary = xform.data_dictionary() geo_xpaths = data_dictionary.geopoint_xpaths() doc = self.get_dict() points = [] if len(geo_xpaths): for xpath in geo_xpaths: geometry = [float(s) for s in doc.get(xpath, u'').split()] if len(geometry): lat, lng = geometry[0:2] points.append(Point(lng, lat)) if not xform.instances_with_geopoints and len(points): xform.instances_with_geopoints = True xform.save() self.geom = GeometryCollection(points)
def update(self, instance, validated_data): data = self.context['request'].data type_id = data.pop('type') site_type = ProjectType.objects.get(pk=type_id) verify_survey = data.pop('is_survey') if verify_survey: validated_data.update({'is_survey': False}) validated_data.update({'is_active': True}) else: validated_data.update({'is_survey': True}) validated_data.update({'is_active': False}) p = Point(float(validated_data.pop('longitude')), float(validated_data.pop('latitude')), srid=4326) validated_data.update({'location':p}) Site.objects.filter(pk=instance.pk).update(**validated_data) site = Site.objects.get(pk=instance.id) site.type = site_type site.save() return site
def test_update_timezone(self): event, l = Event.parse_text(EXAMPLE) timezone = event.timezone latitude = event.latitude longitude = event.longitude event.coordinates = None event.timezone = None event.save() self.assert_(event.update_timezone()) self.assertEquals(event.timezone, timezone) event.timezone = None event.address = None event.coordinates = Point(longitude, latitude) event.save() self.assert_(event.update_timezone()) self.assertEquals(event.timezone, timezone) event.delete()
def form_valid(self, form): # Get data latitude = form.cleaned_data['latitude'] longitude = form.cleaned_data['longitude'] # Get today's date now = timezone.now() # Get next week's date next_week = now + timezone.timedelta(weeks=1) # Get Point location = Point(longitude, latitude, srid=4326) # Look up events events = Event.objects.filter(datetime__gte=now).filter(datetime__lte=next_week).annotate(distance=Distance('venue__location', location)).order_by('distance')[0:5] # Render the template return render_to_response('gigs/lookupresults.html', { 'events': events })
def get_queryset(self): queryset = Service.objects.all() #Order all the services by distance to the requester user location if 'lat' in self.request.query_params and 'lon' in self.request.query_params: # Brings lat and lon in request parameters ref_location = Point(float(self.request.query_params['lon']),float(self.request.query_params['lat']),srid=4326) if not self.request.user.is_anonymous(): # If user is logged in, save his location self.request.user.location = ref_location self.request.user.save() elif not self.request.user.is_anonymous and (self.request.user.location is not None): # User has a location previously saved ref_location = self.request.user.location else: # if no location at all geoip = GeoIP2() ip = self.request.META['REMOTE_ADDR'] try: ref_location = Point(geoip.lon_lat(ip),srid=4326) except AddressNotFoundError: ref_location = Point((-3.8196228, 40.4378698), srid=4326) # Madrid if not self.request.user.is_anonymous: self.request.user.location = ref_location self.request.user.save() return queryset.annotate(dist = Distance('author__location', ref_location)).order_by('dist')
def _create_test_query(self): """ Helper method that returns an example ReservoirQuery. """ accounts = [Account(username='twitter')] locations = [Location(geom=Point(-76.6653729, 39.4904058), buffer_m=1000)] searchterms = [ SearchTerm(term='photos'), SearchTerm(term='media') ] timeframe = self._create_example_timeframe() return ReservoirQuery( accounts=accounts, locations=locations, searchterms=searchterms, timeframe=timeframe )
def convert_circle_to_rectangle(point, radius_m): """ (tuple(int or float, int or float), int or float) -> GEOSGeometry Polygon Takes a circle as a (lng, lat) tuple and a radius in meters. Returns the smallest rectangular Polygon that encompasses the circle. """ # reverse the lng, lat order to convert to geopy Point format center = reverse_coordinate_order(point) # create a geopy coordinate calculator for the given distance calculator = vincenty(meters=radius_m) # calculate points at the given distance in the cardinal directions n_pt = calculator.destination(point=center, bearing=0) s_pt = calculator.destination(point=center, bearing=180) e_pt = calculator.destination(point=center, bearing=90) w_pt = calculator.destination(point=center, bearing=270) bounds = Bounds(n_lat=n_pt.latitude, s_lat=s_pt.latitude, e_lng=e_pt.longitude, w_lng=w_pt.longitude) return bounds.bounding_box
def convert_to_point(location, location_format): """ Takes a dict, tuple, or list of coordinates and converts them to a Point. """ if isinstance(location, Point): return location try: if (isinstance(location, dict) and 'lat' in location and 'lon' in location): return Point(location['lon'], location['lat']) if location_format.lower().startswith('lat'): location = reverse_coordinate_order(location) return Point(location) except Exception as error: LOGGER.error('There was an error processing the location %s: %s', location, error)
def _process_parameters(self, coord, radius_m): """ Helper function to process test parameters through the factor_polygon_into_circles function. """ radius_km = units.meters_to_km(radius_m) polygon = Polygon(coord) points = shapes.factor_polygon_into_circles(polygon, radius_km) # take the generated points and turn them into "circles" (polygons) radius_in_deg = units.convert_meters_to_degrees(radius_m) circles = [Point(point).buffer(radius_in_deg) for point in points] # convert the list of circles into a multipolyon and merge them merged_circles = MultiPolygon(circles).cascaded_union # make sure the merged circles have no holes and completely cover # the original polygon self.assertTrue(merged_circles.num_interior_rings == 0, 'The merged circles had %s holes but should have none' % merged_circles.num_interior_rings) self.assertTrue(merged_circles.prepared.covers(polygon), 'The merged circles do not cover the polygon')
def shape(self): """ Returns a string indicating the feature type. If the feature type is not a Point, Polygon, or Multipolygon, returns 'Other'. """ if isinstance(self.geom, Point): if self.has_buffer(): return 'Circle' else: return 'Point' elif isinstance(self.geom, Polygon): if shapes.is_rectangle(self.geom.exterior_ring): return 'Rectangle' else: return 'Polygon' elif isinstance(self.geom, MultiPolygon): return 'MultiPolygon' else: return 'Other'
def test_put_update_coordinates(self): self.assertEqual(self.location_model.objects.count(), 0) dl = self._create_object_location() url = reverse(self.url_name, args=[dl.device.pk]) url = '{0}?key={1}'.format(url, dl.device.key) self.assertEqual(self.location_model.objects.count(), 1) coords = json.loads(Point(2, 23).geojson) feature = json.dumps({'type': 'Feature', 'geometry': coords}) r = self.client.put(url, feature, content_type='application/json') self.assertEqual(r.status_code, 200) self.assertDictEqual(r.json(), { 'type': 'Feature', 'geometry': coords, 'properties': {'name': dl.location.name} }) self.assertEqual(self.location_model.objects.count(), 1)
def test_olwidget_has_changed(self): """ Check that changes are accurately noticed by OpenLayersWidget. """ geoadmin = admin.site._registry[City] form = geoadmin.get_changelist_form(None)() has_changed = form.fields['point']._has_changed initial = Point(13.4197458572965953, 52.5194108501149799, srid=4326) data_same = "SRID=3857;POINT(1493879.2754093995 6894592.019687599)" data_almost_same = "SRID=3857;POINT(1493879.2754093990 6894592.019687590)" data_changed = "SRID=3857;POINT(1493884.0527237 6894593.8111804)" self.assertTrue(has_changed(None, data_changed)) self.assertTrue(has_changed(initial, "")) self.assertFalse(has_changed(None, "")) self.assertFalse(has_changed(initial, data_same)) self.assertFalse(has_changed(initial, data_almost_same)) self.assertTrue(has_changed(initial, data_changed))
def test02_select_related(self): "Testing `select_related` on geographic models (see #7126)." qs1 = City.objects.all() qs2 = City.objects.select_related() qs3 = City.objects.select_related('location') # Reference data for what's in the fixtures. cities = ( ('Aurora', 'TX', -97.516111, 33.058333), ('Roswell', 'NM', -104.528056, 33.387222), ('Kecksburg', 'PA', -79.460734, 40.18476), ) for qs in (qs1, qs2, qs3): for ref, c in zip(cities, qs): nm, st, lon, lat = ref self.assertEqual(nm, c.name) self.assertEqual(st, c.state) self.assertEqual(Point(lon, lat), c.location.point)
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 create(self,validated_data): request = self.context['request'] book_data = validated_data.pop('BookId') book = Book.objects.create(**book_data) advert = Advert.objects.create(**validated_data) advert.save() advert.BookId = book advert.SellerId_id = self.context['request'].user.id json = self.context['request'].data if 'Image' in json.keys(): photo = PhotoUser.objects.get(token=json['Image']) advert.Photo = photo.Photo advert.save() tuple_x_y = (advert.Latitude,advert.Longitude) advert.Point = Point(tuple_x_y) seller_adverts = Advert.objects.filter(Q(SellerId_id=request.user.id,IsSold=False)) for seller_advert in seller_adverts: if seller_advert.BookId.Name in book.Name: book.delete() advert.delete() return {'IsSuccess':False,context:'same advert'} advert.save() data = {'IsSuccess':True,'context':''} #self.context['request'].user.id return data
def distance(self,obj): if 'location' in self.context.keys(): request = self.context['request'] tuple_x_y = (float(request.query_params['Latitude']),float(request.query_params['Longitude'])) point = Point(tuple_x_y,srid=4326) result = distance(obj.Point,point).km if result < 5: return '5 km içerisinde' elif result > 5 and result < 10: return '10 km içerisinde' elif result > 10 and result < 25: return '25 km içerisinde' elif result > 25 and result < 50: return '50 km içerisinde' else: return obj.City + ' çevresinde' return obj.City + ' çevresinde'
def polygon_requires_clipping(wgs84_polygon): geom_type = wgs84_polygon.geom_type if geom_type == 'MultiPolygon': polygons = wgs84_polygon.coords elif geom_type == 'Polygon': polygons = [wgs84_polygon.coords] else: raise Exception("Unknown geom_type {0}".format(geom_type)) for polygon in polygons: for t in polygon: for x, y in t: point = Point(x, y) if not uk_multipolygon.contains(point): return True return False # ------------------------------------------------------------------------ # Make sure the output directory exists:
def generate_point(): return Point( 24.915 + fake.random.uniform(0, 0.040), 60.154 + fake.random.uniform(0, 0.022), srid=4326, )
def generate_polygon(): center = generate_point() points = [ Point( center.x + fake.random.uniform(-0.001, 0.001), center.y + fake.random.uniform(-0.001, 0.001), srid=4326, ).transform(3879, clone=True) for _ in range(3) ] points.append(points[0]) return Polygon(points)
def create_parking(operator_id=1, registration_number='ABC-123', **kwargs): return Parking( location=Point(60.193609, 24.951394), operator_id=operator_id, registration_number=registration_number, time_end=now() + datetime.timedelta(days=1), time_start=now(), zone=3, **kwargs )
def test_location_set_from_terminal(admin_user): operator = Operator.objects.get_or_create(user=admin_user)[0] terminal = ParkingTerminal.objects.get_or_create( number=4567, defaults={ 'location': Point(61, 25), 'name': "Test terminal"})[0] parking = create_parking(operator_id=operator.pk, terminal_number=4567) parking.location = None parking.save() assert parking.location == terminal.location
def test_location_not_overridden_from_terminal(admin_user): operator = Operator.objects.get_or_create(user=admin_user)[0] terminal = ParkingTerminal.objects.get_or_create( number=4567, defaults={ 'location': Point(61, 25), 'name': "Test terminal"})[0] parking = create_parking(operator_id=operator.pk, terminal_number=4567) location = parking.location parking.save() assert parking.location == location assert parking.location != terminal.location
def _get_polygons(self, geom): """ Turns the XML containing coordinates into a multipolygon """ polygons = [] for pos in geom.iter('*'): # get leaf nodes. Treat LinearRing and MultiSurface the same way if len(pos) == 0: positions = list(filter(None, pos.text.split(' '))) points = [] points_as_pairs = zip(positions[1::2], positions[::2]) for latitude, longitude in points_as_pairs: points.append(Point(float(latitude), float(longitude))) polygons.append(Polygon(points)) return MultiPolygon(polygons)
def geos(self, query): "Returns a GEOS Point object for the given query." ll = self.lon_lat(query) if ll: from django.contrib.gis.geos import Point return Point(ll, srid=4326) else: return None # #### GeoIP Database Information Routines ####
def get_lon_lat(self, lonlat): "Unpacks longitude, latitude from GEOS Points and 2-tuples." if isinstance(lonlat, Point): lon, lat = lonlat.coords else: lon, lat = lonlat return lon, lat
def get_width_height(self, extent): """ Returns the width and height for the given extent. """ # Getting the lower-left, upper-left, and upper-right # coordinates from the extent. ll = Point(extent[:2]) ul = Point(extent[0], extent[3]) ur = Point(extent[2:]) # Calculating the width and height. height = ll.distance(ul) width = ul.distance(ur) return width, height
def geos(self, query): "Return a GEOS Point object for the given query." ll = self.lon_lat(query) if ll: from django.contrib.gis.geos import Point return Point(ll, srid=4326) else: return None # #### GeoIP Database Information Routines ####
def _handle_empty_point(self, geom): from django.contrib.gis.geos import Point if isinstance(geom, Point) and geom.empty: if self.srid: # PostGIS uses POINT(NaN NaN) for WKB representation of empty # points. Use it for EWKB as it's a PostGIS specific format. # https://trac.osgeo.org/postgis/ticket/3181 geom = Point(float('NaN'), float('NaN'), srid=geom.srid) else: raise ValueError('Empty point is not representable in WKB.') return geom
def post(self, request, data): if not data.get('name') and not data.get('lat'): return HttpResponseServerError("Name or coords is required.") if data.get('name'): model = {'city': City, 'subregion': Subregion, 'region': Region}.get(data.get('model')) if not model: return HttpResponseServerError("Invalid model: {}".format(data.get('model'))) obj = get_object_or_404(model, pk=data['name']) else: # http://stackoverflow.com/a/35079313 pnt = Point(float(data.get('lon', 0)), float(data.get('lat', 0)), srid=4326) order_by_expression = CombinedExpression(F('location'), '<->', GeomValue(pnt)) try: obj = City.objects.order_by(order_by_expression)[0] except IndexError: return fields = ['subregion', 'region', 'region__country', 'country'] data = {getattr(obj, key).__class__.__name__: {x: getattr(getattr(obj, key), x) for x in ['id', 'name']} for key in fields if hasattr(obj, key)} if not data.get('name'): # Is geo coord search data['city'] = {'id': obj.pk, 'name': obj.name} if hasattr(obj, 'location'): order_by_expression = CombinedExpression(F('location'), '<->', GeomValue(obj.location)) try: data['postal_code'] = PostalCode.objects.order_by(order_by_expression)[0].code except IndexError: pass data['coords'] = obj.location.coords return data
def post(self, request): if not (request.POST.get('uuid') and request.POST.get('long') and request.POST.get('lat') and request.POST.get('bands') ): return Response("Missing arguments", status=status.HTTP_406_NOT_ACCEPTABLE) req_bands = request.POST.get('bands').split(',') for band in req_bands: if not (band in BTS.bands): return Response("Invalid Arguments", status=status.HTTP_400_BAD_REQUEST) pnt = GEOSGeometry(Point(float(request.POST.get('long')), float(request.POST.get('lat')))) with transaction.atomic(): tower = BTS.objects.get(uuid=request.POST.get('uuid')) nearby_towers = BTS.objects.filter( location__distance_lt=(pnt,D(km=RANGE))).exclude(uuid=request.POST.get('uuid')) used_channels = dict.fromkeys(BTS.bands.keys(), set()) for tower in nearby_towers: if (tower.band): #skip those without set bands used_channels[tower.band].add(tower.channel) free_channels = dict.fromkeys(req_bands) for band in req_bands: free_channels[band] = BTS.bands[band]['valid_values'].difference(used_channels[band]) if (len(free_channels[band]) > 0): #something available return Response({ band : free_channels[band], 'power_level' : POWER_LEVEL}, status=status.HTTP_200_OK) return Response("No Available Bands", status=status.HTTP_404_NOT_FOUND)
def post(self, request): if not ( request.POST.get('uuid') and request.POST.get('lat') and request.POST.get('long') and request.POST.get('band') and request.POST.get('channel') and request.POST.get('power_level') ): return Response("Missing Arguments", status=status.HTTP_406_NOT_ACCEPTABLE) if not ( request.POST.get('band') in BTS.bands and request.POST.get('channel').isdigit() and request.POST.get('power_level').isdigit() ): return Response("Invalid Arguments", status=status.HTTP_400_BAD_REQUEST) pnt = GEOSGeometry(Point(float(request.POST.get('long')), float(request.POST.get('lat')))) with transaction.atomic(): tower = BTS.objects.get(uuid=request.POST.get('uuid')) nearby_towers = BTS.objects.filter( location__distance_lt=(pnt,D(km=RANGE))).filter( band=request.POST.get('band')).exclude(uuid=request.POST.get('uuid')) for t in nearby_towers: if (int(request.POST.get('channel')) == t.channel): return Response("Channel In Use", status=status.HTTP_409_CONFLICT) #no one interfered tower.channel = int(request.POST.get('channel')) tower.location = pnt tower.band = request.POST.get('band') tower.save() return Response("Success", status=status.HTTP_200_OK)
def get_point(self, srid=4326): from django.contrib.gis.geos import Point return Point(float(self._lng), float(self._lat), srid=srid)
def add_potential_georeference(self, lat, long, profile_name, locality_name=False, precision_m=False): # Geographical position point = Point(long, lat) gp, created = GeographicalPosition.objects.get_or_create(point=point) # Precision if precision_m: gp.precision_m = precision_m # Author profile profile = Profile.objects.get(name=profile_name) # Locality name if not locality_name: ln = self.locality_name else: ln, created = LocalityName.objects.get_or_create(locality_name=locality_name) # Georeference gr, created = GeoReference.objects.get_or_create(geographical_position=gp, locality_name=ln, author=profile) # Add it to list if gr not in self.potential_georeferences.values(): self.potential_georeferences.add(gr)
