Django: Find Nearby Users with Coordinates and Radius

In today’s world, location-based features are increasingly important in web applications. Integrating geographic data can significantly enhance the user experience, whether it's finding nearby friends, locating nearby services, or enabling geotagged content.

This article will explore how to use Django’s ORM to find nearby users based on their geographic coordinates (latitude and longitude) and a specified radius.

First, we will define a Location model to store the geographical coordinates of each user. We'll use Django's built-in User model to associate each location with a user.

<code class="language-python">from django.db import models
from django.contrib.auth.models import User

class Location(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    latitude = models.DecimalField(max_digits=9, decimal_places=6, db_index=True)
    longitude = models.DecimalField(max_digits=9, decimal_places=6, db_index=True)

    def __str__(self):
        return str(self.user)</code>

user: A foreign key pointing to the Django User model. This establishes a relationship where each user can have one or more locations. latitude & longitude: DecimalField field used to store geographic coordinates with an accuracy of up to six decimal places, which is sufficient for most location-based applications.

Implement Haversine formula in Django

Haversine's formula is a widely used mathematical formula for calculating the spherical distance between two points on the Earth's surface, using latitude and longitude. This formula is particularly useful in navigation, geofencing, geospatial analysis, and location-based services.

Here is a function integrating the Haversine formula into the Location model to get users within a specified radius using the Django ORM:

<code class="language-python">from django.db.models import F, Value
from django.db.models.functions import ACos, Cos, Radians, Sin

class Location(models.Model):
    # ... [字段如上] ...

    @classmethod
    def get_users_within_radius(cls, center_latitude, center_longitude, radius_km):
        # Haversine 公式计算距离
        distance_expression = (
            ACos(
                Sin(Radians(F('latitude'))) * Sin(Radians(Value(center_latitude))) +
                Cos(Radians(F('latitude'))) * Cos(Radians(Value(center_latitude))) *
                Cos(Radians(F('longitude')) - Radians(Value(center_longitude)))
            ) * 6371  # 地球半径（公里）
        )

        # 过滤指定半径内的用户
        users_within_radius = cls.objects.annotate(
            distance=distance_expression
        ).filter(
          distance__lte=radius_km
        ).select_related('user')

        return users_within_radius</code>

This method uses the Haversine formula to calculate distance and filter users within a given radius.

Get users within a specified radius

With the get_users_within_radius method, getting nearby users is easy. Here's how to use it:

<code class="language-python">from .models import Location

# 加德满都的纬度和经度
center_latitude = 27.707460
center_longitude = 85.312205

radius_km = 10     # 10 公里

nearby_location_points = Location.get_users_within_radius(
    center_latitude, center_longitude, radius_km
)
nearby_users = [
    location.user for location in nearby_location_points
]</code>

Explanation

• Define center coordinates: Replace center_latitude and center_longitude with the desired center point, such as the current user's location.
• Radius specification: Set radius_km to the desired search radius in kilometers.
• Get nearby locations: Call get_users_within_radius to retrieve Location instances within a specified radius.
• Extract users: Iterate over Location instances to collect associated User objects.

Implementing geolocation search in Django is a valuable skill for developers aiming to create location-based services. By understanding Haversine's formula, developers can build efficient location-based searches.
For more advanced geographic functionality, explore GeoDjango and spatial databases.

The above is the detailed content of Django: Find Nearby Users with Coordinates and Radius. For more information, please follow other related articles on the PHP Chinese website!