for elevation

app.py

@@ -1,6 +1,6 @@
 import geopandas as gpd
 import pandas as pd
-from shapely.geometry import Polygon, LineString, Point, LinearRing
+from shapely.geometry import Polygon, LineString, Point
 from shapely.ops import unary_union
 import xml.etree.ElementTree as ET
 import zipfile
@@ -9,100 +9,150 @@ import matplotlib.pyplot as plt
 import streamlit as st
 from transformers import pipeline
 
-def p(kml_file):
-    cont = kml_file.decode('utf-8')
+# ✅ Function to remove Z values (flatten 3D to 2D)
+def drop_z(geom):
+    """Convert 3D geometry to 2D by removing Z values"""
+    if geom.geom_type == 'Polygon':
+        return Polygon([(x, y) for x, y, _ in geom.exterior.coords])
+    elif geom.geom_type == 'LineString':
+        return LineString([(x, y) for x, y, _ in geom.coords])
+    elif geom.geom_type == 'Point':
+        return Point(geom.x, geom.y)
+    return geom  # Return unchanged if not 3D
+
+# ✅ Function to parse KML file
+def parse_kml(kml_file):
+    cont = kml_file.decode('utf-8')  # Decode bytes to string
     k = ET.ElementTree(ET.fromstring(cont))
     root = k.getroot()
     ns = {'kml': 'http://www.opengis.net/kml/2.2'}
-    
+
     shapes = []
     for mark in root.findall('.//kml:Placemark', ns):
-        polygon = mark.find('.//kml:Polygon/kml:coordinates', ns)
+        # Extract Polygon
+        polygon = mark.find('.//kml:Polygon/kml:outerBoundaryIs/kml:LinearRing/kml:coordinates', ns)
         if polygon is not None:
             coordinates = polygon.text.strip().split()
             coords = [(float(lon), float(lat), float(alt)) for lon, lat, alt in [coord.split(',') for coord in coordinates]]
-            shapes.append(Polygon([LinearRing(coords)]))
-        
+            shapes.append(Polygon(coords))
+
+        # Extract LineString
         line = mark.find('.//kml:LineString/kml:coordinates', ns)
         if line is not None:
             coordinates = line.text.strip().split()
             coords = [(float(lon), float(lat), float(alt)) for lon, lat, alt in [coord.split(',') for coord in coordinates]]
             shapes.append(LineString(coords))
-        
+
+        # Extract Point
         point = mark.find('.//kml:Point/kml:coordinates', ns)
         if point is not None:
             lon, lat, alt = map(float, point.text.strip().split(','))
             shapes.append(Point(lon, lat, alt))
-    
+
     return shapes if shapes else None
 
-def ext(kmz_file):
+# ✅ Function to extract KMZ file
+def extract_kmz(kmz_file):
     with zipfile.ZipFile(kmz_file, 'r') as zip_ref:
         zip_ref.extractall('temp_kml')
     kml_file = [f for f in os.listdir('temp_kml') if f.endswith('.kml')][0]
     with open(os.path.join('temp_kml', kml_file), 'rb') as f:
-        return p(f.read())
+        return parse_kml(f.read())
 
-def choose(upf):
-    file_bytes = upf.read()
-    return ext(file_bytes) if upf.name.endswith('.kmz') else p(file_bytes)
+# ✅ Choose between KML and KMZ
+def choose_file(uploaded_file):
+    file_bytes = uploaded_file.read()
+    return extract_kmz(file_bytes) if uploaded_file.name.endswith('.kmz') else parse_kml(file_bytes)
 
-st.title("Flood Zone Analysis with Polygon Z Support")
-upf = st.file_uploader("Upload KML/KMZ file", type=['kml', 'kmz'])
+# ✅ Streamlit UI
+st.title("Flood Zone Analysis")
+uploaded_file = st.file_uploader("Upload KML/KMZ file", type=['kml', 'kmz'])
 
-def bound(f, gdf):
-    if f.empty:
+# ✅ Compare boundaries
+def check_boundary(kml_shapes, gdf):
+    if not kml_shapes:
         return "Invalid KML shape or no valid polygon found.", None
-    overlaps = [gdf[gdf.intersects(kml_shape)] for kml_shape in f if not gdf[gdf.intersects(kml_shape)].empty]
-    return overlaps if overlaps else "Boundary doesn't match", unary_union([geom for intersect in overlaps for geom in intersect.geometry])
 
-def land(overlaps, every_int):
-    all = pd.concat(overlaps)
-    all['area_acres'] = all.geometry.area / 4046.86
-    fza = {zone: all[all['FLD_ZONE'] == zone]['area_acres'].sum() for zone in all['FLD_ZONE'].unique()}
-    non = all[~all['FLD_ZONE'].isin(['A', 'AE', 'AH', 'AO', 'VE'])]['area_acres'].sum()
-    return fza, non, every_int.area / 4046.86
+    kml_gdf = gpd.GeoDataFrame(geometry=kml_shapes, crs="EPSG:4326")
+    kml_gdf['geometry'] = kml_gdf['geometry'].apply(drop_z)  # Remove Z values
+    kml_gdf = kml_gdf.to_crs(epsg=3857)
+
+    overlaps = []
+    for kml_shape in kml_gdf.geometry:
+        intersection = gdf[gdf.intersects(kml_shape)]
+        if not intersection.empty:
+            overlaps.append(intersection)
+
+    if not overlaps:
+        return "Boundary doesn't match", None
+
+    every_int = unary_union([geom for intersect in overlaps for geom in intersect.geometry])
+    return overlaps, every_int
 
-def summ(fza, non, total_acreage):
+# ✅ Calculate land use and flood zones
+def calculate_land(overlaps, every_int):
+    all_data = pd.concat(overlaps)
+    all_data['area_acres'] = all_data.geometry.area / 4046.86  # Convert to acres
+
+    flood_zones = {zone: all_data[all_data['FLD_ZONE'] == zone]['area_acres'].sum() for zone in all_data['FLD_ZONE'].unique()}
+    non_flooded_area = all_data[~all_data['FLD_ZONE'].isin(['A', 'AE', 'AH', 'AO', 'VE'])]['area_acres'].sum()
+    merged_acreage = every_int.area / 4046.86
+
+    return flood_zones, non_flooded_area, merged_acreage
+
+# ✅ Generate summary
+def generate_summary(flood_zones, non_flooded, total_acreage):
     summarizer = pipeline("summarization", model="gpt2")
-    flood_zone_summary = "\n".join([f"  Zone {zone}: {fza.get(zone, 0):.2f} acres" for zone in ['A', 'AE', 'AH', 'AO', 'VE']])
+    flood_summary = "\n".join([f"  Zone {zone}: {flood_zones.get(zone, 0):.2f} acres" for zone in ['A', 'AE', 'AH', 'AO', 'VE']])
+
     prompt = f"""
     **Total Land Area**: {total_acreage:.2f} acres
-    **Usable Area**: {non:.2f} acres
+    **Usable Area**: {non_flooded:.2f} acres
     **Flood-prone Zones**:
-    {flood_zone_summary}
-    Summarize the above given data in a 2-3 sentences.
+    {flood_summary}
+    Summarize this in 2-3 sentences.
     """
     response = summarizer(prompt, max_length=200, min_length=30, do_sample=False)
     return response[0]['summary_text']
 
-if upf is not None:
-    dela = gpd.GeoDataFrame(pd.concat([gpd.read_file(f) for f in ["K_FLD_HAZ_AR.shp", "N_FLD_HAZ_AR.shp", "S_FLD_HAZ_AR.shp"]], ignore_index=True))
-    dela = dela.set_crs("EPSG:4326").to_crs(epsg=3857)
+# ✅ Main processing
+if uploaded_file is not None:
+    # Load shapefile
+    kent = gpd.read_file("K_FLD_HAZ_AR.shp")
+    nc = gpd.read_file("N_FLD_HAZ_AR.shp")
+    sussex = gpd.read_file("S_FLD_HAZ_AR.shp")
+    dela = gpd.GeoDataFrame(pd.concat([kent, nc, sussex], ignore_index=True))
+    dela = dela.set_crs(kent.crs, allow_override=True).to_crs(epsg=3857)
     dela['geometry'] = dela['geometry'].apply(lambda x: x.buffer(0) if not x.is_valid else x)
-    
-    f = choose(upf)
-    if f:
-        kml_gdf = gpd.GeoDataFrame(geometry=f, crs="EPSG:4326").to_crs(epsg=3857)
-        intersection, every_int = bound(kml_gdf.geometry, dela)
-        if isinstance(intersection, str):
-            st.write(intersection)
+
+    # Process uploaded KML/KMZ
+    kml_shapes = choose_file(uploaded_file)
+    if kml_shapes:
+        # Remove Z values
+        kml_shapes = [drop_z(geom) for geom in kml_shapes]
+
+        # Compare with SHP
+        result, every_int = check_boundary(kml_shapes, dela)
+
+        if isinstance(result, str):
+            st.write(result)
         else:
-            flood_zone_areas, non, merged_area = land(intersection, every_int)
+            flood_zones, non_flooded, merged_acreage = calculate_land(result, every_int)
             st.write(f"Flood Zone Areas:")
-            for zone, area in flood_zone_areas.items():
+            for zone, area in flood_zones.items():
                 st.write(f"  Zone {zone}: {area:.2f} acres")
-            st.write(f"\nNon-Flooded Land Area: {non:.2f} acres")
-            st.write(f"\nMerged Area of Intersected Boundary: {merged_area:.2f} acres")
-            st.write(f"GPT-2 Summary: {summ(flood_zone_areas, non, merged_area)}")
-        
-        fig, ax = plt.subplots(figsize=(10, 10))
-        dela.plot(ax=ax, color='blue', alpha=0.5)
-        if intersection:
+            st.write(f"\nNon-Flooded Land Area: {non_flooded:.2f} acres")
+            st.write(f"\nMerged Area of Intersected Boundary: {merged_acreage:.2f} acres")
+            summary = generate_summary(flood_zones, non_flooded, merged_acreage)
+            st.write(f"Summary: {summary}")
+
+            # Show map
+            fig, ax = plt.subplots(figsize=(10, 10))
+            dela.plot(ax=ax, color='blue', alpha=0.5)
             gpd.GeoDataFrame(geometry=[every_int], crs=dela.crs).plot(ax=ax, color='red', alpha=0.7)
-        kml_gdf.plot(ax=ax, color='green', alpha=0.3)
-        st.pyplot(fig)
+            gpd.GeoDataFrame(geometry=kml_shapes, crs="EPSG:4326").to_crs(epsg=3857).plot(ax=ax, color='green', alpha=0.3)
+            st.pyplot(fig)
     else:
         st.write("No valid geometries found in the uploaded KML file.")
 else:
-    st.write("Please upload a KML/KMZ file to continue.")
+    st.write("Please upload a KML/KMZ file.")