Expand max exploration radius to 50km or above

- Made hexagonal arrangement of circles to cover a larger circular area of exploration
- Fetch responses from wiki api for all of them, process the response and pass them to frontend.
- Make frontend Exploration Radius dynamic.

backend/utils.py

@@ -0,0 +1,43 @@
+import math
+def generate_circle_centers(center_lat, center_lon, radius_km, small_radius_km=10):
+    """
+        Generate a list of centers of small circles (radius=10km) needed to cover a larger circle.
+        Circles are arranged in hexagonal pattern to minimize # of small circles.
+        No overlapping among small circles, but some small circles may be outside the larger circle.
+        Input:
+        - center_lat: Latitude of the center of the larger circle
+        - center_lon: Longitude of the center of the larger circle
+        - radius_km: Radius of the larger circle in kilometers
+        - small_radius_km: Radius of the smaller circles in kilometers (default 15km)
+
+        Output:
+        - A list of tuples, each containing the latitude and longitude of a small circle's center. [(lat1, lon1), (lat2, lon2),...]
+    """
+    R = 6371  # Earth radius
+
+    dx = 2 * small_radius_km
+    dy = math.sqrt(3) * small_radius_km
+    max_dist = radius_km + small_radius_km
+
+    results = []
+    lat_rad = math.radians(center_lat)
+    n_y = int(max_dist // dy) + 2
+
+    for row in range(-n_y, n_y + 1):
+        y = row * dy
+        offset = 0 if row % 2 == 0 else dx / 2
+        n_x = int((max_dist + dx) // dx) + 2
+
+        for col in range(-n_x, n_x + 1):
+            x = col * dx + offset
+            distance = math.sqrt(x ** 2 + y ** 2)
+
+            if distance <= max_dist:
+                delta_lat = (y / R) * (180 / math.pi)
+                delta_lon = (x / (R * math.cos(lat_rad))) * (180 / math.pi)
+
+                lat = center_lat + delta_lat
+                lon = center_lon + delta_lon
+                results.append((lat, lon))
+    
+    return results

frontend/src/components/Map.js

@@ -26,6 +26,8 @@ L.Icon.Default.mergeOptions({
 // Add scale
 // L.control.scale().addTo(window.Map);
 
+const maxExplorationLimit = 50; // kilometers, the maximum amount user can select to explore.
+
 const ClickHandler = ({ onClick }) => {
     useMapEvents({
       click(e) {
@@ -245,7 +247,9 @@ const Map = ( { onMapClick, searchQuery, contentType, setSearchQuery, setSubmitt
                 
                 if (res.ok) {
                     const data = await res.json();
-                    const markers = data.pages.map(page => ({
+                    const markers = data.pages.filter(
+                                page => typeof page.dist === "number" && page.dist <= explorationRadius * 1000
+                            ).map(page => ({
                         position: [page.lat, page.lon],
                         title: page.title,
                         distance: page.dist
@@ -985,7 +989,7 @@ const Map = ( { onMapClick, searchQuery, contentType, setSearchQuery, setSubmitt
                             <input
                                 type="range"
                                 min="1"
-                                max="10"
+                                max={maxExplorationLimit}
                                 value={explorationRadius}
                                 onChange={(e) => setExplorationRadius(parseInt(e.target.value))}
                                 style={{ width: '100%' }}
@@ -1004,7 +1008,7 @@ const Map = ( { onMapClick, searchQuery, contentType, setSearchQuery, setSubmitt
                                     value={explorationRadius}
                                     onChange={(e) => {
                                         const value = parseInt(e.target.value);
-                                        if (value >= 1 && value <= 10) {
+                                        if (value >= 1 && value <= maxExplorationLimit) {
                                             setExplorationRadius(value);
                                         }
                                     }}

main.py

@@ -2,12 +2,13 @@ from fastapi import FastAPI, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
-import requests
+import requests, httpx, asyncio
 from geopy.geocoders import Nominatim
 import geopy.distance
 from cachetools import TTLCache
 import os
 from dotenv import load_dotenv
+from backend.utils import generate_circle_centers
 
 load_dotenv()
 
@@ -25,7 +26,7 @@ class Geodistance(BaseModel):
 class NearbyWikiPage(BaseModel):
     lat: float = Field(default=54.163337, ge=-90, le=90)
     lon: float = Field(default=37.561109, ge=-180, le=180)
-    radius: int = Field(default=1000, ge=10, le=10000,description="Distance in meters from the reference point")
+    radius: int = Field(default=1000, ge=10, le=100_000,description="Distance in meters from the reference point")
     limit: int = Field(10, ge=1, description="Number of pages to return")
 
 app.add_middleware(
@@ -173,6 +174,18 @@ def get_geodistance(payload: Geodistance):
         status_code=200
     )
 
+
+async def fetch_url(client: httpx.AsyncClient, url: str):
+    try:
+        response = await client.get(url, timeout=10.0)
+        return {
+            "url": url,
+            "status": response.status_code,
+            "data": response.json() if response.status_code == 200 else None,
+        }
+    except Exception as e:
+        return {"url": url, "error": str(e)}
+    
 @app.post("/wiki/nearby")
 async def get_nearby_wiki_pages(payload: NearbyWikiPage):
     """
@@ -198,42 +211,82 @@ async def get_nearby_wiki_pages(payload: NearbyWikiPage):
             ],
             "count": 10 #Total no. of such pages
         }
+    Example raw respone from Wikipedia API: https://en.wikipedia.org/w/api.php?action=query&list=geosearch&gscoord=40.7128%7C-74.0060&gsradius=10000&gslimit=1&format=json
     """
-    lat, lon = payload.lat, payload.lon
+    lat_center, lon_center = payload.lat, payload.lon
     radius = payload.radius
     limit = payload.limit
 
-    url = ("https://en.wikipedia.org/w/api.php"+"?action=query"
-            "&list=geosearch"
-            f"&gscoord={lat}|{lon}"
-            f"&gsradius={radius}"
-            f"&gslimit={limit}"
-            "&format=json")
-    print(url)
-    try:
-        response = requests.get(url, timeout=10)
-        if response.status_code != 200:
+    if radius <= 10000:
+        url = ("https://en.wikipedia.org/w/api.php"+"?action=query"
+                "&list=geosearch"
+                f"&gscoord={lat_center}|{lon_center}"
+                f"&gsradius={radius}"
+                f"&gslimit={limit}"
+                "&format=json")
+        # print(url)
+        try:
+            response = requests.get(url, timeout=10)
+            if response.status_code != 200:
+                return JSONResponse(
+                    content={"error": "Failed to fetch nearby pages"},
+                    status_code=500
+                )
+            data = response.json()
+
+            pages = data.get("query", {}).get("geosearch", [])
+
+            return JSONResponse(
+                content={
+                    "pages": pages,
+                    "count": len(pages)
+                },
+                status_code=200
+            )
+        except Exception as e:
             return JSONResponse(
-                content={"error": "Failed to fetch nearby pages"},
+                content={"error": str(e)},
                 status_code=500
             )
-        data = response.json()
+    elif radius > 10000:
+        small_circle_centers = generate_circle_centers(lat_center, lon_center, radius / 1000, small_radius_km=10)
+        all_pages = []
+        base_url = "https://en.wikipedia.org/w/api.php?action=query&list=geosearch&gscoord={lat}|{lon}&gsradius={small_radius_km}&gslimit={page_limit}&format=json"
+        urls = [base_url.format(lat=center[0], lon=center[1], small_radius_km=10*1000, page_limit=100) for center in small_circle_centers]
 
-        pages = data.get("query", {}).get("geosearch", [])
+        print("URL Counts:", len(urls))
+        try:
+            async with httpx.AsyncClient() as client:
+                tasks = [fetch_url(client, url) for url in urls]
+                results = await asyncio.gather(*tasks)
+            
+            # print(results)
+            for result in results:
+                for unit in result.get("data", {}).get("query", {}).get("geosearch", []):
+                    lat, lon = unit.get("lat"), unit.get("lon")
+                    if lat is not None and lon is not None:
+                        dist = int(geopy.distance.distance(
+                                (lat_center, lon_center), (lat, lon)
+                            ).m)
+                        print(dist)
+                    else: 
+                        dist = None
 
-        return JSONResponse(
-            content={
-                "pages": pages,
-                "count": len(pages)
-            },
-            status_code=200
-        )
-    except Exception as e:
-        return JSONResponse(
-            content={"error": str(e)},
-            status_code=500
-        )
-    
+                    unit_with_dist = {**unit, "dist": dist}
+                    all_pages.append(unit_with_dist)
+
+            return JSONResponse(
+                content={
+                    "pages": all_pages,
+                    "count": len(all_pages)
+                }
+            )
+        
+        except Exception as e:
+            return JSONResponse(
+                content={"error": str(e)},
+                status_code=500
+        )