Django : trouver des utilisateurs à proximité avec des coordonnées et un rayon

Dans le monde d’aujourd’hui, les fonctionnalités basées sur la localisation sont de plus en plus importantes dans les applications Web. L'intégration de données géographiques peut améliorer considérablement l'expérience utilisateur, qu'il s'agisse de trouver des amis à proximité, de localiser des services à proximité ou d'activer du contenu géolocalisé.

Cet article explorera comment utiliser l'ORM de Django pour trouver des utilisateurs à proximité en fonction de leurs coordonnées géographiques (latitude et longitude) et d'un rayon spécifié.

Dans un premier temps, nous définirons un modèle de localisation pour stocker les coordonnées géographiques de chaque utilisateur. Nous utiliserons le modèle User intégré de Django pour associer chaque emplacement à un utilisateur.

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)

user : Une clé étrangère pointant vers le modèle Django User. Cela établit une relation dans laquelle chaque utilisateur peut avoir un ou plusieurs emplacements. latitude et longitude : champ DecimalField utilisé pour stocker les coordonnées géographiques avec une précision allant jusqu'à six décimales, ce qui est suffisant pour la plupart des applications basées sur la localisation.

Implémenter la formule Haversine dans Django

La formule de Haversine est une formule mathématique largement utilisée pour calculer la distance sphérique entre deux points de la surface de la Terre, en utilisant la latitude et la longitude. Cette formule est particulièrement utile dans la navigation, le géorepérage, l'analyse géospatiale et les services basés sur la localisation.

Voici une fonction intégrant la formule Haversine dans le modèle Location pour amener les utilisateurs dans un rayon spécifié à l'aide de l'ORM Django :

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

Cette méthode utilise la formule Haversine pour calculer la distance et filtrer les utilisateurs dans un rayon donné.

Attirez les utilisateurs dans un rayon spécifié

Avec la méthode get_users_within_radius, il est facile d'obtenir des utilisateurs à proximité. Voici comment l'utiliser :

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
]

Explication

• Définir les coordonnées du centre : Remplacez center_latitude et center_longitude par le point central souhaité, tel que l'emplacement de l'utilisateur actuel.
• Spécification du rayon : Réglez radius_km sur le rayon de recherche souhaité en kilomètres.
• Obtenir les emplacements à proximité : Appelez get_users_within_radius pour récupérer les instances de localisation dans un rayon spécifié.
• Extraire les utilisateurs : Parcourez les instances d'emplacement pour collecter les objets utilisateur associés.

La mise en œuvre de la recherche de géolocalisation dans Django est une compétence précieuse pour les développeurs souhaitant créer des services basés sur la localisation. En comprenant la formule de Haversine, les développeurs peuvent créer des recherches efficaces basées sur la localisation.
Pour des fonctionnalités géographiques plus avancées, explorez GeoDjango et les bases de données spatiales.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!