Update backend/main.py

backend/main.py

@@ -4,29 +4,33 @@ from pydantic import BaseModel
 import httpx
 import pyproj
 from typing import List, Dict, Optional, Any
+from distance import calculate_distance
+from area import calculate_area
+from coordinate_converter import convert_coordinates
+from terrain import extract_terrain_data
 
-app = FastAPI(title="Ground Elevation API")
+app = FastAPI(title="GIS Tools API")
 
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 # Define request and response models
 class CoordinateRequest(BaseModel):
     latitude: float
     longitude: float
-    crs: str = "EPSG:4326"  # Default to WGS84
+    crs: str = "EPSG:4326"
 
 class ElevationResponse(BaseModel):
     latitude: float
     longitude: float
     elevation: float
-    wgs84_latitude: float  # Add WGS84 coordinates
+    wgs84_latitude: float
     wgs84_longitude: float
     original_crs: str
 
@@ -34,17 +38,52 @@ class CRSInfo(BaseModel):
     code: str
     name: str
 
+class DistanceRequest(BaseModel):
+    point1: CoordinateRequest
+    point2: CoordinateRequest
+
+class AreaRequest(BaseModel):
+    coordinates: List[CoordinateRequest]
+
+class TerrainRequest(BaseModel):
+    latitude: float
+    longitude: float
+    crs: str = "EPSG:4326"
+
+# Helper: Convert to WGS84
+def convert_to_wgs84(lon, lat, source_crs):
+    if source_crs == "EPSG:4326":
+        return (lon, lat)
+    try:
+        transformer = pyproj.Transformer.from_crs(source_crs, "EPSG:4326", always_xy=True)
+        lon, lat = transformer.transform(lon, lat)
+        return (lon, lat)
+    except Exception as e:
+        raise Exception(f"Coordinate transformation error: {str(e)}")
+
+# Helper: Query Open-Meteo
+async def query_open_meteo(lat, lon):
+    url = f"https://api.open-meteo.com/v1/elevation?latitude={lat}&longitude={lon}"
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            if "elevation" in data and isinstance(data["elevation"], list) and len(data["elevation"]) > 0:
+                return float(data["elevation"][0])
+            else:
+                raise Exception("No elevation data found in API response")
+        except httpx.HTTPStatusError as e:
+            raise Exception(f"Elevation API error: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Error querying elevation: {str(e)}")
+
 # Route for fetching elevation data
 @app.post("/api/elevation", response_model=ElevationResponse)
 async def get_elevation(request: CoordinateRequest):
-    """Get elevation for a given coordinate pair"""
     try:
-        # Convert from source CRS to WGS84 (EPSG:4326) if necessary
         wgs84_coords = convert_to_wgs84(request.longitude, request.latitude, request.crs)
-        
-        # Query Open-Meteo for elevation data
         elevation = await query_open_meteo(wgs84_coords[1], wgs84_coords[0])
-        
         return ElevationResponse(
             latitude=request.latitude,
             longitude=request.longitude,
@@ -56,11 +95,34 @@ async def get_elevation(request: CoordinateRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+# Route for calculating distance
+@app.post("/api/distance")
+async def calculate_distance_route(request: DistanceRequest):
+    # Extract coordinates and CRS
+    p1 = (request.point1.longitude, request.point1.latitude, request.point1.crs)
+    p2 = (request.point2.longitude, request.point2.latitude, request.point2.crs)
+    return {"distance": calculate_distance(p1, p2)}
+
+# Route for calculating area
+@app.post("/api/area")
+async def calculate_area_route(request: AreaRequest):
+    # Convert CoordinateRequest list to list of (lon, lat, crs)
+    coords = [(c.longitude, c.latitude, c.crs) for c in request.coordinates]
+    return {"area": calculate_area(coords)}
+
+# Route for converting coordinates
+@app.post("/api/coordinate-converter")
+async def coordinate_converter_route(request: CoordinateRequest):
+    return convert_coordinates(request.longitude, request.latitude, request.crs)
+
+# Route for extracting terrain data
+@app.post("/api/terrain")
+async def terrain_data_route(request: TerrainRequest):
+    return await extract_terrain_data(request.latitude, request.longitude, request.crs)
+
 # Route for fetching CRS list
 @app.get("/api/crs-list", response_model=List[CRSInfo])
 async def get_crs_list():
-    """Get a list of supported coordinate reference systems"""
-    # List of common CRS systems
     crs_list = [
         {"code": "EPSG:4326", "name": "WGS 84"},
         {"code": "EPSG:3857", "name": "Web Mercator"},
@@ -73,47 +135,9 @@ async def get_crs_list():
     ]
     return crs_list
 
-# Convert coordinates from source CRS to WGS84
-def convert_to_wgs84(x, y, source_crs):
-    """Convert coordinates from source CRS to WGS84"""
-    # If already WGS84, return as is
-    if source_crs == "EPSG:4326":
-        return (x, y)
-    
-    try:
-        # Create transformation
-        transformer = pyproj.Transformer.from_crs(source_crs, "EPSG:4326", always_xy=True)
-        # Transform coordinates
-        lon, lat = transformer.transform(x, y)
-        return (lon, lat)
-    except Exception as e:
-        raise Exception(f"Coordinate transformation error: {str(e)}")
-
-# Query elevation from Open-Meteo API
-async def query_open_meteo(lat, lon):
-    """Query Open-Meteo for elevation data"""
-    url = f"https://api.open-meteo.com/v1/elevation?latitude={lat}&longitude={lon}"
-    
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.get(url)
-            response.raise_for_status()
-            data = response.json()
-            
-            # Extract elevation from response
-            if "elevation" in data and isinstance(data["elevation"], list) and len(data["elevation"]) > 0:
-                return float(data["elevation"][0])
-            else:
-                raise Exception("No elevation data found in API response")
-        except httpx.HTTPStatusError as e:
-            raise Exception(f"Elevation API error: {str(e)}")
-        except Exception as e:
-            raise Exception(f"Error querying elevation: {str(e)}")
-
-# Add additional health check endpoint
+# Health check endpoint
 @app.get("/api/health")
 async def health_check():
-    """Health check endpoint"""
     return {"status": "ok"}
 
 if __name__ == "__main__":