Update app.py

app.py

@@ -1,13 +1,15 @@
+import streamlit as st
 import cv2
 import numpy as np
+from PIL import Image
 
-def process_rooftop_image(image_path, geographic_bounds):
+def process_rooftop_image(image, geographic_bounds):
     """
-    Process the rooftop image to detect rooftops, exclude shadows, 
+    Process the rooftop image to detect rooftops, exclude shadows and waste areas, 
     and calculate usable area for solar panels.
 
     Parameters:
-        image_path (str): Path to the input image (PNG or JPG).
+        image (numpy array): Input image as a NumPy array.
         geographic_bounds (dict): Geographic bounds with the following keys:
             - lat_min, lat_max, lon_min, lon_max (floats): Latitude and longitude bounds of the image.
 
@@ -15,45 +17,42 @@ def process_rooftop_image(image_path, geographic_bounds):
         final_image (numpy array): Image with predicted boundaries and excluded shadows.
         usable_area (float): Computed rooftop area usable for solar panels in square meters.
     """
-    # Load the image
-    image = cv2.imread(image_path)
-    if image is None:
-        raise FileNotFoundError("Image file not found. Please check the path.")
-    
-    # Step 1: Convert to grayscale for processing
+    # Convert the image to grayscale
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
-    # Step 2: Apply Gaussian Blur to reduce noise
+    # Apply Gaussian Blur to reduce noise
     blurred = cv2.GaussianBlur(gray, (5, 5), 0)
 
-    # Step 3: Edge detection (Canny)
+    # Shadow detection (thresholding for dark regions)
+    _, shadow_mask = cv2.threshold(blurred, 80, 255, cv2.THRESH_BINARY_INV)
+
+    # Edge detection (Canny)
     edges = cv2.Canny(blurred, 50, 150)
 
-    # Step 4: Morphological operations to close gaps in edges
+    # Morphological operations to close gaps in edges
     kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
     closed_edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
 
-    # Step 5: Find contours of the rooftop
+    # Find contours of the rooftop
     contours, _ = cv2.findContours(closed_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
-    # Create a blank mask for shadow removal
-    mask = np.zeros_like(gray)
+    # Create a blank mask for the rooftop area
+    rooftop_mask = np.zeros_like(gray)
 
     for contour in contours:
         # Approximate the contour and filter out unwanted small areas
         approx = cv2.approxPolyDP(contour, 0.02 * cv2.arcLength(contour, True), True)
         area = cv2.contourArea(approx)
         if area > 500:  # Minimum area threshold to remove noise
-            cv2.drawContours(mask, [approx], -1, 255, -1)
+            cv2.drawContours(rooftop_mask, [approx], -1, 255, -1)
 
-    # Step 6: Exclude shadows (thresholding)
-    shadow_removed = cv2.bitwise_and(gray, gray, mask=mask)
-    _, thresholded = cv2.threshold(shadow_removed, 120, 255, cv2.THRESH_BINARY)
+    # Exclude shadows from the rooftop mask
+    final_mask = cv2.bitwise_and(rooftop_mask, cv2.bitwise_not(shadow_mask))
 
-    # Step 7: Calculate the area in pixels
-    pixel_area = np.sum(thresholded > 0)
+    # Calculate the area in pixels
+    pixel_area = np.sum(final_mask > 0)
 
-    # Step 8: Convert pixels to real-world area
+    # Convert pixels to real-world area
     lat_min, lat_max, lon_min, lon_max = (
         geographic_bounds['lat_min'],
         geographic_bounds['lat_max'],
@@ -72,44 +71,45 @@ def process_rooftop_image(image_path, geographic_bounds):
     conversion_factor = (lat_conversion * lon_conversion) / (image.shape[0] * image.shape[1])
     usable_area = pixel_area * conversion_factor  # in square meters
 
-    # Step 9: Overlay contours on the original image
+    # Overlay contours on the original image
     final_image = image.copy()
     cv2.drawContours(final_image, contours, -1, (0, 255, 0), 2)
 
     return final_image, usable_area
 
 
-if __name__ == "__main__":
-    # Prompt user for inputs
-    image_path = input("Enter the path to the rooftop image (PNG or JPG): ")
-    print("Enter the geographic bounds of the image:")
-    lat_min = float(input("Latitude Min: "))
-    lat_max = float(input("Latitude Max: "))
-    lon_min = float(input("Longitude Min: "))
-    lon_max = float(input("Longitude Max: "))
-    
-    geographic_bounds = {
-        'lat_min': lat_min,
-        'lat_max': lat_max,
-        'lon_min': lon_min,
-        'lon_max': lon_max,
-    }
-
-    try:
-        # Process the image and calculate the usable area
-        final_image, calculated_area = process_rooftop_image(image_path, geographic_bounds)
-        
-        # Save and display results
-        output_path = "output_rooftop_with_boundaries.jpg"
-        cv2.imwrite(output_path, final_image)
-        
-        print(f"Usable Rooftop Area for Solar Panels: {calculated_area:.2f} square meters")
-        print(f"Processed image saved to: {output_path}")
-
-        # Display the final image with detected boundaries
-        cv2.imshow("Processed Rooftop", final_image)
-        cv2.waitKey(0)
-        cv2.destroyAllWindows()
-
-    except Exception as e:
-        print(f"Error: {e}")
+# Streamlit Interface
+st.title("Rooftop Usable Area for Solar Panels")
+st.write("Upload a rooftop image and provide geographic bounds to calculate the usable area for solar panels.")
+
+# File uploader for the image
+uploaded_file = st.file_uploader("Upload an image (PNG or JPG)", type=["png", "jpg", "jpeg"])
+
+# Input fields for geographic bounds
+lat_min = st.number_input("Latitude Min", value=0.0, step=0.0001)
+lat_max = st.number_input("Latitude Max", value=0.0, step=0.0001)
+lon_min = st.number_input("Longitude Min", value=0.0, step=0.0001)
+lon_max = st.number_input("Longitude Max", value=0.0, step=0.0001)
+
+# Button to process the image
+if st.button("Calculate Usable Area"):
+    if uploaded_file is not None:
+        # Read the uploaded image
+        image = np.array(Image.open(uploaded_file).convert("RGB"))  # Convert PIL image to NumPy array
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)  # Convert RGB to BGR for OpenCV
+
+        geographic_bounds = {
+            'lat_min': lat_min,
+            'lat_max': lat_max,
+            'lon_min': lon_min,
+            'lon_max': lon_max,
+        }
+
+        # Process the image
+        final_image, usable_area = process_rooftop_image(image, geographic_bounds)
+
+        # Display results
+        st.image(cv2.cvtColor(final_image, cv2.COLOR_BGR2RGB), caption="Processed Image with Boundaries")
+        st.write(f"Usable Rooftop Area for Solar Panels (excluding shadows): **{usable_area:.2f} square meters**")
+    else:
+        st.error("Please upload an image to proceed.")