如何用R语言识别阿姆斯特丹中心3公里范围外的GPS点位？

Hey there! Let's figure out how to filter those 500 GPS points to find the ones that lie more than 3km away from Amsterdam's center (latitude: 52.37, longitude: 4.88). Since GPS coordinates are on a spherical Earth, we can't rely on simple straight-line distance—we need to use a spherical distance formula like Haversine to get accurate results. Here are a few practical implementations:

Method 1: Use the haversine Python Library (Quick & Easy) #

This library handles all the complex math for you, so it's perfect for getting up and running fast.

1. First, install the library:

   pip install haversine
   

2. Then use this code to process your dataset:

   from haversine import haversine, Unit
   
   # Define Amsterdam's center coordinates (latitude, longitude)
   amsterdam_center = (52.37, 4.88)
   # Replace this with your actual list of 500 GPS points (each as (lat, lon) tuple)
   gps_points = [
       (52.36, 4.89),  # Example point near center
       (52.42, 4.96),  # Example point outside 3km
       # ... add all your 500 points here
   ]
   
   # Filter points outside the 3km radius
   points_outside_3km = []
   for point in gps_points:
       # Calculate distance in kilometers
       distance = haversine(amsterdam_center, point, unit=Unit.KILOMETERS)
       if distance > 3:
           points_outside_3km.append(point)
   
   print(f"Found {len(points_outside_3km)} points outside the 3km radius")
   

Method 2: Manual Haversine Formula (No Third-Party Dependencies) #

If you don't want to install extra libraries, you can implement the Haversine formula directly—no external tools needed:

import math

def calculate_spherical_distance(lat1, lon1, lat2, lon2):
    # Convert degrees to radians (required for trigonometric functions)
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)

    # Haversine formula calculations
    delta_lat = lat2_rad - lat1_rad
    delta_lon = lon2_rad - lon1_rad
    a = math.sin(delta_lat / 2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(delta_lon / 2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

    # Earth's radius in kilometers
    earth_radius_km = 6371
    return earth_radius_km * c

# Amsterdam center coordinates
center_lat, center_lon = 52.37, 4.88
# Your GPS dataset
gps_points = [(52.37, 4.88), (52.41, 4.93), ...]  # Replace with your 500 points

# Filter points
points_outside = []
for lat, lon in gps_points:
    distance = calculate_spherical_distance(center_lat, center_lon, lat, lon)
    if distance > 3:
        points_outside.append((lat, lon))

print(f"Filtered result: {len(points_outside)} points are outside the 3km radius")

Method 3: For Large Datasets (Pandas Vectorized Operation) #

If your GPS points are stored in a CSV or DataFrame, using pandas with vectorized operations will be much faster for 500+ points:

import pandas as pd
from haversine import haversine_vector, Unit

# Load your dataset (replace with your file path)
df = pd.read_csv("amsterdam_gps_points.csv")

# Create a list of center coordinates matching the number of rows in the DataFrame
center_coords = [(52.37, 4.88)] * len(df)

# Calculate distance for all points at once (vectorized, fast!)
df["distance_to_center_km"] = haversine_vector(
    center_coords,
    list(zip(df["latitude"], df["longitude"])),
    unit=Unit.KILOMETERS
)

# Filter rows where distance exceeds 3km
outside_df = df[df["distance_to_center_km"] > 3]

# Save the filtered results to a new CSV
outside_df.to_csv("points_outside_3km.csv", index=False)
print(f"Saved {len(outside_df)} points to 'points_outside_3km.csv'")

All these methods will accurately identify points outside your desired 3km radius. The key thing to remember is using spherical distance instead of straight-line—this ensures your calculations are geographically correct!

内容的提问来源于stack exchange，提问作者Cashmaker777