Update app.py

app.py

@@ -1,6 +1,6 @@
 import geopandas as gpd
 import pandas as pd
-from shapely.geometry import Polygon, LineString, Point
+from shapely.geometry import shape, Polygon, LineString, Point
 from shapely.ops import unary_union
 import xml.etree.ElementTree as ET
 import zipfile
@@ -9,22 +9,8 @@ import matplotlib.pyplot as plt
 import streamlit as st
 from transformers import pipeline
 
-# ✅ 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':
-        # Check if the geometry has a Z value and only then unpack
-        return Polygon([(x, y) for x, y, *_ in geom.exterior.coords] if len(geom.exterior.coords[0]) == 3 else geom.exterior.coords)
-    elif geom.geom_type == 'LineString':
-        # Check if the geometry has a Z value and only then unpack
-        return LineString([(x, y) for x, y, *_ in geom.coords] if len(geom.coords[0]) == 3 else geom.coords)
-    elif geom.geom_type == 'Point':
-        # Check if the point has a Z value and only then unpack
-        return Point(geom.x, geom.y) if len(geom.coords) == 2 else Point(geom.x, geom.y, geom.z)
-    return geom  # Return unchanged if not 3D
-
-# ✅ Function to parse KML file
-def parse_kml(kml_file):
+# For KML access, extracting 3D coordinates (Polygon Z)
+def p(kml_file):
     cont = kml_file.decode('utf-8')  # Decode bytes to string
     k = ET.ElementTree(ET.fromstring(cont))
     root = k.getroot()
@@ -32,142 +18,165 @@ def parse_kml(kml_file):
 
     shapes = []
     for mark in root.findall('.//kml:Placemark', ns):
-        # Extract Polygon
-        polygon = mark.find('.//kml:Polygon/kml:outerBoundaryIs/kml:LinearRing/kml:coordinates', ns)
+        polygon = mark.find('.//kml:Polygon/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(coords))
-
-        # Extract LineString
+            coords = [(float(lon), float(lat), float(z) if z else 0) for lon, lat, z in [coord.split(',') for coord in coordinates]]
+            shapes.append(Polygon([coords]))  # Make it a Polygon with Z
+            
         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]]
+            coords = [(float(lon), float(lat), float(z) if z else 0) for lon, lat, z 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))
+            lon, lat, z = point.text.strip().split(',')
+            shapes.append(Point(float(lon), float(lat), float(z) if z else 0))
 
     return shapes if shapes else None
 
-# ✅ Function to extract KMZ file
-def extract_kmz(kmz_file):
+# For file extraction if it is in KMZ form
+def ext(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 parse_kml(f.read())
+        return p(f.read())
 
-# ✅ 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)
+# See if it is a kml or kmz file
+def choose(upf):
+    file_bytes = upf.read()
+    if upf.name.endswith('.kmz'):
+        return ext(file_bytes)
+    else:
+        return p(file_bytes)
 
-# ✅ Streamlit UI
+# For file uploading
 st.title("Flood Zone Analysis")
-uploaded_file = st.file_uploader("Upload KML/KMZ file", type=['kml', 'kmz'])
+upf = st.file_uploader("Upload KML/KMZ file", type=['kml', 'kmz'])
 
-# ✅ Compare boundaries
-def check_boundary(kml_shapes, gdf):
-    if not kml_shapes:
-        return "Invalid KML shape or no valid polygon found.", None
-
-    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)
+# Convert 2D to 3D if needed (add default Z = 0)
+def convert_to_3d(geom):
+    """Convert 2D geometries to 3D by adding a Z value (default = 0)"""
+    if geom.geom_type == 'Polygon':
+        coords = [(x, y, 0) for x, y in geom.exterior.coords]
+        return Polygon(coords)
+    elif geom.geom_type == 'LineString':
+        coords = [(x, y, 0) for x, y in geom.coords]
+        return LineString(coords)
+    elif geom.geom_type == 'Point':
+        return Point(geom.x, geom.y, 0)
+    return geom  # Return unchanged if not 2D
 
-    overlaps = []
-    for kml_shape in kml_gdf.geometry:
+# For comparing the boundary between KML and shapefile
+def bound(f, gdf):
+    if f.empty:  # Handle invalid KML shapes
+        return "Invalid KML shape or no valid polygon found.", None
+    overlaps = []  # Save matching boundaries
+    for kml_shape in f:
         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
 
-# ✅ 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):
+# Find common bound's Acreage and Usable Land
+def land(overlaps, every_int):
+    all = pd.concat(overlaps)
+    all['area'] = all.geometry.area
+    all['area_acres'] = all['area'] / 4046.86  # Convert to acres
+    fza = {zone: all[all['FLD_ZONE'] == zone]['area_acres'].sum() for zone in all['FLD_ZONE'].unique()}
+    areas = ['A', 'AE', 'AH', 'AO', 'VE']
+    non = all[~all['FLD_ZONE'].isin(areas)]['area_acres'].sum()
+    merged_area = every_int.area / 4046.86 
+    return fza, non, merged_area
+
+# Initial summary was with GPT-2
+def summ(fza, non, total_acreage):
     summarizer = pipeline("summarization", model="gpt2")
-    flood_summary = "\n".join([f"  Zone {zone}: {flood_zones.get(zone, 0):.2f} acres" for zone in ['A', 'AE', 'AH', 'AO', 'VE']])
 
+    areas = ['A', 'AE', 'AH', 'AO', 'VE']
+    flood_zone_summary = "\n".join([f"  Zone {zone}: {fza.get(zone, 0):.2f} acres" for zone in areas])
+    
     prompt = f"""
     **Total Land Area**: {total_acreage:.2f} acres
-    **Usable Area**: {non_flooded:.2f} acres
+    **Usable Area**: {non:.2f} acres
     **Flood-prone Zones**:
-    {flood_summary}
-    Summarize this in 2-3 sentences.
+    {flood_zone_summary}
+    Summarize the above given data in 2-3 sentences.
     """
+    
     response = summarizer(prompt, max_length=200, min_length=30, do_sample=False)
+    
     return response[0]['summary_text']
 
-# ✅ Main processing
-if uploaded_file is not None:
-    # Load shapefile
+if upf is not None:
+    # Read shapefiles and convert them to 3D if needed
     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")
+
+    # Combine them
     dela = gpd.GeoDataFrame(pd.concat([kent, nc, sussex], ignore_index=True))
 
-    # First, check if the shapefile already has a CRS
-    if dela.crs is None:
-        # Set the CRS for the shapefile if it doesn't have one
-        dela = dela.set_crs("EPSG:4326", allow_override=True)
-    else:
-        # If the shapefile already has a CRS, make sure it's in the same CRS
-        dela = dela.to_crs("EPSG:4326")
+    # Add Coordinate Reference System
+    dela = dela.set_crs(kent.crs, allow_override=True)
+
+    # Convert to 3D (add Z = 0 if missing)
+    dela['geometry'] = dela['geometry'].apply(convert_to_3d)
 
-    # Reproject to Web Mercator (EPSG:3857)
     dela = dela.to_crs(epsg=3857)
 
-    # Ensure valid geometries
+    # Fix invalid geometries
     dela['geometry'] = dela['geometry'].apply(lambda x: x.buffer(0) if not x.is_valid else x)
 
-    # 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]
+    # Upload KML/KMZ file
+    f = choose(upf)
 
-        # Compare with SHP
-        result, every_int = check_boundary(kml_shapes, dela)
+    if f:
+        # Check if KML has valid geometries
+        kml_gdf = gpd.GeoDataFrame(geometry=f, crs="EPSG:4326")
+        kml_gdf = kml_gdf.to_crs(epsg=3857)
 
-        if isinstance(result, str):
-            st.write(result)
+        # Convert KML to 3D (add Z = 0 if missing)
+        kml_gdf['geometry'] = kml_gdf['geometry'].apply(convert_to_3d)
+
+        # Compare KML and Shapefile
+        intersection, every_int = bound(kml_gdf.geometry, dela)
+
+        if isinstance(intersection, str):
+            st.write(intersection)
         else:
-            flood_zones, non_flooded, merged_acreage = calculate_land(result, every_int)
+            flood_zone_areas, non, merged_area = land(intersection, every_int)
             st.write(f"Flood Zone Areas:")
-            for zone, area in flood_zones.items():
+            for zone, area in flood_zone_areas.items():
                 st.write(f"  Zone {zone}: {area:.2f} acres")
-            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)
-            gpd.GeoDataFrame(geometry=kml_shapes, crs="EPSG:4326").to_crs(epsg=3857).plot(ax=ax, color='green', alpha=0.3)
-            st.pyplot(fig)
+            st.write(f"\nNon-Flooded Land Area: {non:.2f} acres")
+            st.write(f"\nMerged Area of Intersected Boundary: {merged_area:.2f} acres")
+            summary = summ(flood_zone_areas, non, merged_area)
+            st.write(f"GPT-2 Summary: {summary}")
+
+        # Show map
+        fig, ax = plt.subplots(figsize=(10, 10))
+
+        # shapefile
+        dela.plot(ax=ax, color='blue', alpha=0.5)
+
+        # Show overlap with KML
+        if intersection:
+            intersection_geom = unary_union([geom for intersect in intersection for geom in intersect.geometry])
+            gpd.GeoDataFrame(geometry=[intersection_geom], crs=dela.crs).plot(ax=ax, color='red', alpha=0.7)
+
+        # Plot the KML boundary (green color)
+        kml_gdf.plot(ax=ax, color='green', alpha=0.3)
+
+        # Display the plot
+        st.pyplot(fig)
     else:
         st.write("No valid geometries found in the uploaded KML file.")
 else:
-    st.write("Please upload a KML/KMZ file.")
+    st.write("Please upload a KML/KMZ file to continue.")