update KML

app.py

@@ -1,50 +1,153 @@
+import gradio as gr
+import geopandas as gpd
+import requests
+import io
+import re
 from fastapi import FastAPI
-from pydantic import BaseModel
+import kml2geojson  # Using this library for robust KML parsing
 
-# Initialize the FastAPI application
-app = FastAPI(
-    title="JSON Calculator API",
-    description="A simple REST API to perform addition and multiplication on two numbers and return the result as a JSON object.",
-    version="1.0.0",
-)
-
-# Define the structure of the incoming request data using Pydantic
-# This ensures that any request to the API has these two float fields
-class CalculationInput(BaseModel):
-    number_1: float
-    number_2: float
-
-@app.get("/")
-def read_root():
+def get_gdf_from_file_url(file_url: str):
     """
-    A simple root endpoint to check if the API is running.
+    Downloads a file from a URL (handling Google Drive links), determines if it's
+    KML or GeoJSON, and reads it into a GeoDataFrame.
+    
+    Args:
+        file_url: The URL of the KML or GeoJSON file.
+
+    Returns:
+        A GeoDataFrame containing the data from the file.
     """
-    return {"status": "ok", "message": "Welcome to the JSON Calculator API. Send a POST request to /calculate."}
+    # --- Handle different Google Drive URL formats ---
+    if "drive.google.com" in file_url:
+        # Use regex to extract the file ID robustly
+        match = re.search(r'/d/([a-zA-Z0-9_-]+)', file_url) or re.search(r'id=([a-zA-Z0-9_-]+)', file_url)
+        if match:
+            file_id = match.group(1)
+            download_url = f'https://drive.google.com/uc?export=download&id={file_id}'
+        else:
+            raise ValueError("Could not extract file ID from Google Drive URL.")
+    else:
+        download_url = file_url
+
+    # --- Download the file content ---
+    response = requests.get(download_url, timeout=30)
+    response.raise_for_status()
+    
+    bytes_data = io.BytesIO(response.content)
+    # Decode for sniffing, handle potential encoding issues
+    try:
+        string_data = response.content.decode('utf-8')
+    except UnicodeDecodeError:
+        string_data = response.content.decode('latin-1')
+
 
-@app.post("/calculate")
-def calculate_numbers(data: CalculationInput):
+    # --- Determine file type and parse ---
+    # If it looks like XML, it's likely KML.
+    if string_data.strip().startswith("<?xml"):
+        # kml2geojson requires the file path or a stream of the file
+        bytes_data.seek(0) # Reset stream position
+        geojson_data = kml2geojson.convert(bytes_data)
+        
+        # Extract features from the converted GeoJSON
+        # The output of kml2geojson is a list of geojson objects
+        all_features = []
+        for gj in geojson_data:
+            all_features.extend(gj.get('features', []))
+
+        if not all_features:
+            raise ValueError("KML file parsed, but no features were found.")
+            
+        input_gdf = gpd.GeoDataFrame.from_features(all_features, crs="EPSG:4326")
+    else:
+        # Assume it's GeoJSON or another format GeoPandas can read directly
+        bytes_data.seek(0) # Reset stream position
+        input_gdf = gpd.read_file(bytes_data)
+
+    return input_gdf
+
+
+def calculate_geometry(file_url: str) -> tuple[str, str]:
     """
-    This endpoint receives two numbers, calculates their sum and product,
-    and returns the result in a structured JSON format.
+    Main function for the Gradio interface. It orchestrates the downloading,
+    parsing, validation, and calculation of area and perimeter.
+    
+    Args:
+        file_url: The URL of the KML or GeoJSON file.
+
+    Returns:
+        A tuple containing the formatted area and perimeter strings.
     """
-    num1 = data.number_1
-    num2 = data.number_2
-
-    # Perform the calculations
-    addition_result = num1 + num2
-    multiplication_result = num1 * num2
-
-    # Create the response dictionary
-    results_dict = {
-        "calculation_inputs": {
-            "number_1": num1,
-            "number_2": num2
-        },
-        "calculation_outputs": {
-            "addition": addition_result,
-            "multiplication": multiplication_result
-        }
-    }
-
-    # FastAPI automatically converts this dictionary to a JSON response
-    return results_dict
+    if not file_url or not file_url.strip():
+        return "Error: Please provide a URL.", ""
+
+    try:
+        # 1. Get GeoDataFrame from the URL
+        input_gdf = get_gdf_from_file_url(file_url)
+
+        if input_gdf.empty:
+            return "Error: Could not find any geometric features in the file.", ""
+        
+        # 2. Find the first valid polygon in the GeoDataFrame
+        geometry_gdf = None
+        for i, row in input_gdf.iterrows():
+            if row.geometry.geom_type in ['Polygon', 'MultiPolygon']:
+                # Create a new GDF with just this valid geometry
+                geometry_gdf = gpd.GeoDataFrame([row], crs=input_gdf.crs)
+                break
+        
+        if geometry_gdf is None:
+            return "Error: No valid Polygon or MultiPolygon geometry found in the file.", ""
+
+        # 3. Reproject for accurate measurement
+        # Ensure the initial CRS is set correctly (WGS84) before reprojecting
+        if geometry_gdf.crs is None or geometry_gdf.crs.to_epsg() != 4326:
+             geometry_gdf = geometry_gdf.set_crs(epsg=4326, allow_override=True)
+
+        # Determine the correct UTM zone for accurate measurements in meters
+        centroid = geometry_gdf.geometry.iloc[0].centroid
+        utm_zone = int((centroid.x + 180) / 6) + 1
+        epsg_code = 32600 + utm_zone if centroid.y >= 0 else 32700 + utm_zone
+        
+        gdf_proj = geometry_gdf.to_crs(epsg=epsg_code)
+
+        # 4. Calculate area and perimeter
+        area_m2 = gdf_proj.geometry.iloc[0].area
+        perimeter_m = gdf_proj.geometry.iloc[0].length
+
+        # 5. Format output
+        area_km2 = area_m2 / 1_000_000
+        perimeter_km = perimeter_m / 1_000
+
+        area_str = f"{area_m2:,.2f} square meters ({area_km2:,.2f} km²)"
+        perimeter_str = f"{perimeter_m:,.2f} meters ({perimeter_km:,.2f} km)"
+
+        return area_str, perimeter_str
+
+    except Exception as e:
+        return f"An error occurred: {e}", ""
+
+# Create the Gradio user interface
+gradio_interface = gr.Interface(
+    fn=calculate_geometry,
+    inputs=gr.Textbox(
+        label="Google Drive KML/GeoJSON File URL",
+        placeholder="Paste the URL to your file here..."
+    ),
+    outputs=[
+        gr.Textbox(label="Calculated Area", interactive=False),
+        gr.Textbox(label="Calculated Perimeter", interactive=False)
+    ],
+    title="Polygon Area & Perimeter Calculator 🗺️",
+    description=(
+        "Enter the public Google Drive URL of a KML or GeoJSON file that contains a polygon. "
+        "The tool will find the first valid polygon and calculate its area and perimeter."
+    ),
+    examples=[
+        ["https://drive.google.com/file/d/123KCak3o1VUcrYQO6v-HxVPYDrYLw4Ft/view?usp=drivesdk"]
+    ],
+    allow_flagging="never"
+)
+
+# Initialize the FastAPI app and mount the Gradio interface
+app = FastAPI()
+app = gr.mount_gradio_app(app, gradio_interface, path="/")