Update app.py

app.py

@@ -10,99 +10,100 @@ import streamlit as st
 from transformers import pipeline
 
 
-# Function to parse KML
-def parse_kml(kml_file):
-    # kml_file will be in bytes format, so we decode it to a string
-    kml_content = kml_file.decode('utf-8')  # Decode bytes to string
-    k = ET.ElementTree(ET.fromstring(kml_content))
+# For KML access
+def p(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'}
-    
+
+    #Basically the KML files have polygon and other shapes. So we are stripping that info and putting it in a proper format
     shapes = []
-    for placemark in root.findall('.//kml:Placemark', ns):
-        polygon = placemark.find('.//kml:Polygon/kml:coordinates', ns)
+    for mark in root.findall('.//kml:Placemark', ns):
+        polygon = mark.find('.//kml:Polygon/kml:coordinates', ns)
         if polygon is not None:
             coordinates = polygon.text.strip().split()
             coords = [(float(lon), float(lat)) for lon, lat, _ in [coord.split(',') for coord in coordinates]]
             shapes.append(shape({'type': 'Polygon', 'coordinates': [coords]}))
         
-        line = placemark.find('.//kml:LineString/kml:coordinates', ns)
+        line = mark.find('.//kml:LineString/kml:coordinates', ns)
         if line is not None:
             coordinates = line.text.strip().split()
             coords = [(float(lon), float(lat)) for lon, lat in [coord.split(',') for coord in coordinates]]
             shapes.append(shape({'type': 'LineString', 'coordinates': coords}))
         
-        point = placemark.find('.//kml:Point/kml:coordinates', ns)
+        point = mark.find('.//kml:Point/kml:coordinates', ns)
         if point is not None:
             lon, lat, _ = point.text.strip().split(',')
             shapes.append(shape({'type': 'Point', 'coordinates': (float(lon), float(lat))}))
 
     return shapes if shapes else None
 
-
-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())
 
-# Function to handle KML/KMZ file input
-def handle_kml_upload(uploaded_file):
-    # Read the uploaded file as bytes
-    file_bytes = uploaded_file.read()
+# See if it is a kml or kmz file
+def choose(upf):
+    file_bytes = upf.read()
 
-    # If the file is a KMZ, first extract the KML file from the KMZ archive
-    if uploaded_file.name.endswith('.kmz'):
-        kml_shapes = extract_kmz(file_bytes)
+    # If KMZ, extract the KML file
+    if upf.name.endswith('.kmz'):
+        f = ext(file_bytes)
     else:
-        # Otherwise, it's a direct KML file
-        kml_shapes = parse_kml(file_bytes)
+        # Else KML
+        f = p(file_bytes)
     
-    return kml_shapes
+    return f #(file)
 
 
-# Streamlit file uploader widget
+# 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'])
 
-# Step 7: Compare KML with Shapefile
-def compare_kml_with_shapefile(kml_shapes, gdf):
-    if kml_shapes.empty:  # Correct check for an empty GeoSeries
+# For compaing the boundary between KML and shapefile
+def bound(f, gdf):
+    if f.empty:  #TO handle any case where file has no info
         return "Invalid KML shape or no valid polygon found.", None
-    intersections = []
-    for kml_shape in kml_shapes:
+    overlaps = []  #TO save the matching boundaries
+    for kml_shape in f: 
         intersection = gdf[gdf.intersects(kml_shape)]
         if not intersection.empty:
-            intersections.append(intersection)
-    if not intersections:
+            overlaps.append(intersection)
+    if not overlaps:
         return "Boundary doesn't match", None
-    merged_geometry = unary_union([geom for intersect in intersections for geom in intersect.geometry])
-    return intersections, merged_geometry
-
-
-# Step 8: Calculate Acreage and Usable Land (based on shapefile)
-def calculate_acreage_and_usable_land(intersections, merged_geometry):
-    all_intersections = pd.concat(intersections)
-    all_intersections['area'] = all_intersections.geometry.area
-    all_intersections['area_acres'] = all_intersections['area'] / 4046.86  # Convert to acres
-    flood_zone_areas = {zone: all_intersections[all_intersections['FLD_ZONE'] == zone]['area_acres'].sum() for zone in all_intersections['FLD_ZONE'].unique()}
-    flood_prone_zones = ['A', 'AE', 'AH', 'AO', 'VE']
-    non_flooded_area = all_intersections[~all_intersections['FLD_ZONE'].isin(flood_prone_zones)]['area_acres'].sum()
-    merged_area = merged_geometry.area / 4046.86  # Convert to acres
-    return flood_zone_areas, non_flooded_area, merged_area
-
-# Step 9: Summarize Data using GPT-2
-def summarize_flood_data_gpt2(flood_zone_areas, non_flooded_area, total_acreage):
-    # Use Hugging Face's hosted pipeline for T5 small
-    summarizer = pipeline("summarization", model="t5-small")
-
-    flood_prone_zones = ['A', 'AE', 'AH', 'AO', 'VE']
-    flood_zone_summary = "\n".join([f"  Zone {zone}: {flood_zone_areas.get(zone, 0):.2f} acres" for zone in flood_prone_zones])
+    every_int = unary_union([geom for intersect in overlaps for geom in intersect.geometry])
+    return overlaps, every_int
+
+
+# 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
+    #FLood zones that are unique
+    fza = {zone: all[all['FLD_ZONE'] == zone]['area_acres'].sum() for zone in all['FLD_ZONE'].unique()}
+    #fza = flood zones
+    areas = ['A', 'AE', 'AH', 'AO', 'VE']
+    #For no flood areas
+    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 llama which performed well but due to api issues, had to use GPT-2
+def summ(fza, non, total_acreage):
+    summarizer = pipeline("summarization", model="gpt2")
+
+    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_area:.2f} acres
+    **Usable Area**: {non:.2f} acres
     **Flood-prone Zones**:
     {flood_zone_summary}
     Summarize the above given data in a 2-3 sentences.
@@ -110,64 +111,61 @@ def summarize_flood_data_gpt2(flood_zone_areas, non_flooded_area, total_acreage)
     
     response = summarizer(prompt, max_length=200, min_length=30, do_sample=False)
     
-    # Use summary_text instead of generated_text for T5 model output
     return response[0]['summary_text']
 
 
-if uploaded_file is not None:
-    # Step 1: Read in the shapefiles
-    shapefile_1 = gpd.read_file("K_FLD_HAZ_AR.shp")
-    shapefile_2 = gpd.read_file("N_FLD_HAZ_AR.shp")
-    shapefile_3 = gpd.read_file("S_FLD_HAZ_AR.shp")
+if upf is not None:
+    # Read shapefiles
+    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")
+
+    # Put them together
+    dela = gpd.GeoDataFrame(pd.concat([kent, nc, sussex], ignore_index=True))
 
-    # Step 2: Concatenate them into a single GeoDataFrame
-    merged_gdf = gpd.GeoDataFrame(pd.concat([shapefile_1, shapefile_2, shapefile_3], ignore_index=True))
+    # Add Coordinate Reference System
+    dela = dela.set_crs(kent.crs, allow_override=True)
 
-    # Step 3: Ensure CRS consistency
-    merged_gdf = merged_gdf.set_crs(shapefile_1.crs, allow_override=True)
+    dela = dela.to_crs(epsg=3857)
 
-    # Step 4: Reproject GeoDataFrame to a common projected CRS (EPSG:3857)
-    merged_gdf = merged_gdf.to_crs(epsg=3857)
+    # fix invalid geometries
+    dela['geometry'] = dela['geometry'].apply(lambda x: x.buffer(0) if not x.is_valid else x)
 
-    # Step 5: Validate and fix invalid geometries
-    merged_gdf['geometry'] = merged_gdf['geometry'].apply(lambda x: x.buffer(0) if not x.is_valid else x)
+    # Uplead KML/KMZ file
+    f = choose(upf)
 
-    # Step 6: Process uploaded KML/KMZ file
-    kml_shapes = handle_kml_upload(uploaded_file)
+    if f:
+        # check if KML has valid geometries
+        kml_gdf = gpd.GeoDataFrame(geometry=f, crs="EPSG:4326")
 
-    if kml_shapes:
-        # Ensure that the KML shapes are valid geometries
-        kml_gdf = gpd.GeoDataFrame(geometry=kml_shapes, crs="EPSG:4326")
 
-        # Convert to projected CRS (EPSG:3857) for consistency with shapefile
         kml_gdf = kml_gdf.to_crs(epsg=3857)
 
         # Compare KML and Shapefile
-        intersection, merged_geometry = compare_kml_with_shapefile(kml_gdf.geometry, merged_gdf)
+        intersection, every_int = bound(kml_gdf.geometry, dela)
 
         if isinstance(intersection, str):
             st.write(intersection)
         else:
-            flood_zone_areas, non_flooded_area, merged_area = calculate_acreage_and_usable_land(intersection, merged_geometry)
+            flood_zone_areas, non, merged_area = land(intersection, every_int)
             st.write(f"Flood Zone Areas:")
             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_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")
-            summary = summarize_flood_data_gpt2(flood_zone_areas, non_flooded_area, merged_area)
+            summary = summ(flood_zone_areas, non, merged_area)
             st.write(f"GPT-2 Summary: {summary}")
 
-        # Step 10: Visualize the intersection of KML shapes and merged shapefile
+        # Show map
         fig, ax = plt.subplots(figsize=(10, 10))
 
-        # Plot the merged shapefile (blue color)
-        merged_gdf.plot(ax=ax, color='blue', alpha=0.5)
+        # shapefile
+        dela.plot(ax=ax, color='blue', alpha=0.5)
 
-        # Highlight the intersection area (overlap with KML)
+        # Show overlap with KML
         if intersection:
-            # Combine the intersection geometries into a single geometry for display
             intersection_geom = unary_union([geom for intersect in intersection for geom in intersect.geometry])
-            gpd.GeoDataFrame(geometry=[intersection_geom], crs=merged_gdf.crs).plot(ax=ax, color='red', alpha=0.7)
+            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)