Support polygon-only analysis flow

app.py

@@ -312,10 +312,28 @@ def generate_site_analysis(
         osm_context=osm_context,
         topography=topography,
         soil=soil,
+        anchor_lat=selection.anchor_lat,
+        anchor_lon=selection.anchor_lon,
     )
     evidence.extend(sample_evidence)
     warnings.extend(sample_warnings)
 
+    (
+        project_name,
+        site_name,
+        project_type,
+        boundary_source,
+        auto_label_warnings,
+    ) = _resolve_project_fields(
+        project_name=project_name,
+        site_name=site_name,
+        project_type=project_type,
+        boundary_source=boundary_source,
+        selection=selection,
+        site_identity=site_identity,
+    )
+    warnings.extend(auto_label_warnings)
+
     diagram_paths = create_diagrams(
         selection,
         climate,
@@ -571,6 +589,63 @@ def _current_wind_direction(climate: dict[str, Any]) -> float | None:
         return None
 
 
+def _resolve_project_fields(
+    *,
+    project_name: str,
+    site_name: str,
+    project_type: str,
+    boundary_source: str,
+    selection: SiteSelection,
+    site_identity: dict[str, Any] | None,
+) -> tuple[str, str, str, str, list[str]]:
+    warnings: list[str] = []
+    project = (project_name or "").strip()
+    site = (site_name or "").strip()
+    ptype = (project_type or "").strip()
+    source = (boundary_source or "").strip()
+
+    if not project:
+        project = "Preliminary Site Analysis"
+        warnings.append("Project name was not provided; the app used a generic title.")
+    if not site or site.lower() in {"untitled site", "untitled", "site"}:
+        site = _auto_site_name(selection, site_identity)
+        warnings.append("Site name was not provided; the app generated a label from the selected area.")
+    if not ptype:
+        ptype = "Early-stage architecture site analysis"
+    if not source:
+        source = _auto_boundary_source(selection)
+        warnings.append("Boundary source was not provided; the report labels the selection from the input mode.")
+    return project, site, ptype, source, warnings
+
+
+def _auto_site_name(selection: SiteSelection, site_identity: dict[str, Any] | None) -> str:
+    if site_identity:
+        for key in ("city", "town", "village", "district", "state"):
+            value = site_identity.get(key)
+            if value:
+                return f"{value} selected site"
+        display = site_identity.get("display_name")
+        if display:
+            return f"{str(display).split(',')[0]} selected site"
+    if selection.anchor_lat is not None and selection.anchor_lon is not None:
+        return f"Selected site {selection.anchor_lat:.5f}, {selection.anchor_lon:.5f}"
+    return "Selected site area"
+
+
+def _auto_boundary_source(selection: SiteSelection) -> str:
+    if selection.selection_type in {"drawn_polygon", "rectangle"}:
+        return "User-drawn boundary on OpenStreetMap base map; approximate and not legal/cadastral."
+    if selection.selection_type == "pin_radius":
+        return "User-selected pin and radius; approximate context analysis, not exact boundary."
+    if selection.selection_type == "dxf_boundary":
+        return "Uploaded DXF boundary candidate selected by user."
+    if selection.selection_type == "geojson_boundary":
+        return "Uploaded GeoJSON boundary selected by user."
+    if selection.selection_type == "kml_boundary":
+        return "Uploaded KML/KMZ boundary selected by user."
+    return "User-provided site selection."
+
+
 def _file_path(file_obj: Any) -> str:
     return str(getattr(file_obj, "name", file_obj))
 
@@ -624,10 +699,24 @@ def build_app() -> gr.Blocks:
                 )
             with gr.Column(scale=5, elem_classes=["control-panel"]):
                 gr.Markdown("### Project Setup")
-                project_name = gr.Textbox(label="Project name", value="Architecture Site Analysis")
-                site_name = gr.Textbox(label="Site name", value="Untitled site")
-                project_type = gr.Textbox(label="Project type", placeholder="Thesis, resort, housing, institute...")
-                boundary_source = gr.Textbox(label="Boundary source", placeholder="Faculty CAD, Google Earth/KML, rough map draw, manual pin...")
+                project_name = gr.Textbox(
+                    label="Project name (optional)",
+                    placeholder="Auto: Preliminary Site Analysis",
+                    info="Leave blank if you only want to draw/select a site and generate analysis.",
+                )
+                site_name = gr.Textbox(
+                    label="Site name (optional)",
+                    placeholder="Auto-filled from approximate address or coordinates",
+                    info="If blank, the app labels the selected polygon/pin from reverse geocoding or coordinates.",
+                )
+                project_type = gr.Textbox(
+                    label="Project type (optional)",
+                    placeholder="Thesis, resort, housing, institute...",
+                )
+                boundary_source = gr.Textbox(
+                    label="Boundary source (optional)",
+                    placeholder="Auto-labelled from map draw, pin radius, CAD, KML/KMZ, or GeoJSON",
+                )
                 manual_location = gr.Textbox(
                     label="Lat/lon or Google Maps URL",
                     placeholder="21.002, 70.245 or a Google Maps URL with coordinates",

src/sample_data.py

@@ -7,9 +7,19 @@ from .evidence import make_evidence
 from .models import EvidenceItem
 
 
-def is_sample_site(project_name: str, site_name: str, boundary_source: str) -> bool:
+CHORWAD_SAMPLE_LAT = 21.00248
+CHORWAD_SAMPLE_LON = 70.24537
+
+
+def is_sample_site(
+    project_name: str,
+    site_name: str,
+    boundary_source: str,
+    anchor_lat: float | None = None,
+    anchor_lon: float | None = None,
+) -> bool:
     text = " ".join([project_name or "", site_name or "", boundary_source or ""]).lower()
-    return "chorwad" in text and "sample" in text
+    return ("chorwad" in text and "sample" in text) or _near_chorwad_sample(anchor_lat, anchor_lon)
 
 
 def apply_chorwad_sample_fallbacks(
@@ -22,8 +32,10 @@ def apply_chorwad_sample_fallbacks(
     osm_context: dict[str, Any],
     topography: dict[str, Any],
     soil: dict[str, Any],
+    anchor_lat: float | None = None,
+    anchor_lon: float | None = None,
 ) -> tuple[dict[str, Any] | None, dict[str, Any], dict[str, Any], dict[str, Any], dict[str, Any], list[EvidenceItem], list[str]]:
-    if not is_sample_site(project_name, site_name, boundary_source):
+    if not is_sample_site(project_name, site_name, boundary_source, anchor_lat, anchor_lon):
         return site_identity, climate, osm_context, topography, soil, [], []
 
     evidence: list[EvidenceItem] = []
@@ -70,6 +82,12 @@ def apply_chorwad_sample_fallbacks(
     return site_identity, climate, osm_context, topography, soil, evidence, warnings
 
 
+def _near_chorwad_sample(anchor_lat: float | None, anchor_lon: float | None) -> bool:
+    if anchor_lat is None or anchor_lon is None:
+        return False
+    return abs(anchor_lat - CHORWAD_SAMPLE_LAT) <= 0.01 and abs(anchor_lon - CHORWAD_SAMPLE_LON) <= 0.01
+
+
 def _missing_climate(climate: dict[str, Any]) -> bool:
     for key in ("forecast", "recent_historical", "climate_normal"):
         value = climate.get(key)

tests/test_app_defaults.py

@@ -0,0 +1,79 @@
+import unittest
+
+from app import _resolve_project_fields
+from src.models import SiteSelection
+
+
+class AppDefaultTests(unittest.TestCase):
+    def test_polygon_only_metadata_is_auto_labelled(self):
+        selection = SiteSelection(
+            id="S1",
+            selection_type="drawn_polygon",
+            coordinate_mode="wgs84",
+            geometry_geojson={"type": "Polygon", "coordinates": []},
+            local_geometry=None,
+            anchor_lat=21.00248,
+            anchor_lon=70.24537,
+            radius_m=None,
+            area_sqm=11978,
+            perimeter_m=439,
+            centroid=(21.00248, 70.24537),
+            bbox=(70.2447, 21.0019, 70.246, 21.003),
+            unit_source="WGS84 drawn map",
+            accuracy_label="user-drawn approximate boundary",
+            source_files=[],
+            selected_boundary_id=None,
+            limitations=["Drawn map boundaries are approximate."],
+        )
+
+        project, site, project_type, source, warnings = _resolve_project_fields(
+            project_name="",
+            site_name="",
+            project_type="",
+            boundary_source="",
+            selection=selection,
+            site_identity={"city": "Chorwad", "state": "Gujarat", "country": "India"},
+        )
+
+        self.assertEqual(project, "Preliminary Site Analysis")
+        self.assertEqual(site, "Chorwad selected site")
+        self.assertEqual(project_type, "Early-stage architecture site analysis")
+        self.assertIn("User-drawn boundary", source)
+        self.assertGreaterEqual(len(warnings), 3)
+
+    def test_default_untitled_site_is_replaced(self):
+        selection = SiteSelection(
+            id="S2",
+            selection_type="pin_radius",
+            coordinate_mode="wgs84",
+            geometry_geojson=None,
+            local_geometry=None,
+            anchor_lat=21.0,
+            anchor_lon=70.0,
+            radius_m=250,
+            area_sqm=196349.5,
+            perimeter_m=1570.8,
+            centroid=(21.0, 70.0),
+            bbox=None,
+            unit_source="meters",
+            accuracy_label="pin-radius approximation",
+            source_files=[],
+            selected_boundary_id=None,
+            limitations=["This is approximate context analysis."],
+        )
+
+        _, site, _, source, _ = _resolve_project_fields(
+            project_name="Architecture Site Analysis",
+            site_name="Untitled site",
+            project_type="",
+            boundary_source="",
+            selection=selection,
+            site_identity=None,
+        )
+
+        self.assertEqual(site, "Selected site 21.00000, 70.00000")
+        self.assertIn("pin and radius", source)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_sample_data.py

@@ -8,6 +8,8 @@ class SampleDataTests(unittest.TestCase):
         self.assertTrue(is_sample_site("Chorwad Coastal Thesis Sample", "", "sample drawn boundary"))
         self.assertFalse(is_sample_site("Real thesis", "Chorwad site", "faculty CAD"))
         self.assertFalse(is_sample_site("Sample", "Mumbai site", "manual pin"))
+        self.assertTrue(is_sample_site("", "", "", anchor_lat=21.00248, anchor_lon=70.24537))
+        self.assertFalse(is_sample_site("", "", "", anchor_lat=19.076, anchor_lon=72.8777))
 
     def test_sample_fallback_fills_missing_layers_and_warns(self):
         identity, climate, context, topo, soil, evidence, warnings = apply_chorwad_sample_fallbacks(
@@ -63,6 +65,28 @@ class SampleDataTests(unittest.TestCase):
         self.assertEqual(evidence, [])
         self.assertEqual(warnings, [])
 
+    def test_coordinate_sample_fallback_supports_polygon_only_demo(self):
+        identity, climate, context, topo, soil, evidence, warnings = apply_chorwad_sample_fallbacks(
+            project_name="",
+            site_name="",
+            boundary_source="",
+            site_identity=None,
+            climate={"forecast": None, "recent_historical": None, "climate_normal": None},
+            osm_context={"counts": {}, "features": []},
+            topography={},
+            soil={},
+            anchor_lat=21.00248,
+            anchor_lon=70.24537,
+        )
+
+        self.assertEqual(identity["state"], "Gujarat")
+        self.assertIn("forecast", climate)
+        self.assertGreater(context["counts"]["water"], 0)
+        self.assertGreater(topo["mean_elevation_m"], 0)
+        self.assertIn("texture_signal", soil)
+        self.assertEqual(len(evidence), 1)
+        self.assertIn("demo/testing", warnings[0])
+
 
 if __name__ == "__main__":
     unittest.main()