Upload 4 files

backend/area.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List
+
+router = APIRouter()
+
+class PolygonCoordinates(BaseModel):
+    coordinates: List[List[float]]  # List of [longitude, latitude] pairs
+
+@router.post("/api/calculate-area")
+async def calculate_area(polygon: PolygonCoordinates):
+    """Calculate the area of a polygon defined by a set of coordinates."""
+    if len(polygon.coordinates) < 3:
+        raise HTTPException(status_code=400, detail="At least three coordinates are required to form a polygon.")
+
+    # Using the Shoelace formula to calculate the area
+    area = 0.0
+    n = len(polygon.coordinates)
+    
+    for i in range(n):
+        x1, y1 = polygon.coordinates[i]
+        x2, y2 = polygon.coordinates[(i + 1) % n]  # Wrap around to the first point
+        area += x1 * y2 - x2 * y1
+    
+    area = abs(area) / 2.0
+    return {"area": area}

backend/coordinate_converter.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import pyproj
+
+router = APIRouter()
+
+class CoordinateConversionRequest(BaseModel):
+    latitude: float
+    longitude: float
+    source_crs: str
+    target_crs: str
+
+class CoordinateConversionResponse(BaseModel):
+    original_coordinates: dict
+    converted_coordinates: dict
+
+@router.post("/api/coordinate-convert", response_model=CoordinateConversionResponse)
+async def convert_coordinates(request: CoordinateConversionRequest):
+    """Convert coordinates between different CRS systems."""
+    try:
+        # Create transformer
+        transformer = pyproj.Transformer.from_crs(request.source_crs, request.target_crs, always_xy=True)
+        # Transform coordinates
+        lon, lat = transformer.transform(request.longitude, request.latitude)
+        
+        return CoordinateConversionResponse(
+            original_coordinates={"latitude": request.latitude, "longitude": request.longitude, "crs": request.source_crs},
+            converted_coordinates={"latitude": lat, "longitude": lon, "crs": request.target_crs}
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/distance.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import math
+
+router = APIRouter()
+
+class DistanceRequest(BaseModel):
+    lat1: float
+    lon1: float
+    lat2: float
+    lon2: float
+
+class DistanceResponse(BaseModel):
+    distance: float  # Distance in kilometers
+
+@router.post("/api/distance", response_model=DistanceResponse)
+async def calculate_distance(request: DistanceRequest):
+    """Calculate the distance between two coordinates using the Haversine formula."""
+    try:
+        # Haversine formula
+        R = 6371.0  # Earth radius in kilometers
+        lat1_rad = math.radians(request.lat1)
+        lon1_rad = math.radians(request.lon1)
+        lat2_rad = math.radians(request.lat2)
+        lon2_rad = math.radians(request.lon2)
+
+        dlat = lat2_rad - lat1_rad
+        dlon = lon2_rad - lon1_rad
+
+        a = math.sin(dlat / 2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon / 2)**2
+        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+        distance = R * c  # Distance in kilometers
+        return DistanceResponse(distance=distance)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/terrain.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter, HTTPException
+import httpx
+
+router = APIRouter()
+
+# Route for extracting terrain data
+@router.post("/api/terrain-data")
+async def extract_terrain_data(latitude: float, longitude: float):
+    """Extract terrain data such as slope or aspect from a given location"""
+    try:
+        # Example API call to a terrain data service (replace with actual service)
+        url = f"https://api.example.com/terrain?latitude={latitude}&longitude={longitude}"
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            
+            # Extract relevant terrain data (e.g., slope, aspect)
+            slope = data.get("slope")
+            aspect = data.get("aspect")
+            
+            if slope is None or aspect is None:
+                raise Exception("No terrain data found in API response")
+            
+            return {
+                "latitude": latitude,
+                "longitude": longitude,
+                "slope": slope,
+                "aspect": aspect
+            }
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=500, detail=f"Terrain API error: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))