Update app.py

app.py

@@ -1,91 +1,98 @@
 import cv2
 import numpy as np
-import matplotlib.pyplot as plt
-import streamlit as st
-from skimage import measure
-from io import BytesIO
 
-# Define the scale factor: 1 pixel = X meters (for example, 1 pixel = 0.5 meter)
-SCALE_FACTOR = 0.5  # In meters, adjust as per your image's scale
-
-def preprocess_image(image):
-    img = cv2.imdecode(np.frombuffer(image.read(), np.uint8), cv2.IMREAD_COLOR)
-    
-    if img is None:
-        st.error("Error: Unable to load image")
-        return None, None
-    
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+def process_rooftop_image(image_path, geographic_bounds):
+    """
+    Process the rooftop image to detect rooftops, exclude shadows, and calculate real-world area.
+
+    Parameters:
+        image_path (str): Path to the input image (PNG or JPG).
+        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.
+
+    Returns:
+        final_image (numpy array): Image with predicted boundaries and excluded shadows.
+        real_world_area (float): Computed rooftop area 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.")
     
-    return img, blurred
-
-def detect_edges(blurred_image):
-    edges = cv2.Canny(blurred_image, 50, 150)
-    return edges
-
-def find_contours(edges_image):
-    contours, _ = cv2.findContours(edges_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    return contours
-
-def filter_contours(contours, min_area=1000):
-    filtered_contours = [contour for contour in contours if cv2.contourArea(contour) > min_area]
-    return filtered_contours
-
-def draw_contours(image, contours):
-    output_image = image.copy()
-    cv2.drawContours(output_image, contours, -1, (0, 255, 0), 3)
-    return output_image
-
-def calculate_area_in_meters(contours):
-    total_area_pixels = sum(cv2.contourArea(contour) for contour in contours)
-    
-    # Convert pixel area to real-world area (in square meters)
-    total_area_meters = total_area_pixels * (SCALE_FACTOR ** 2)
-    return total_area_meters
-
-def remove_shadows(image):
-    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
-    lower_shadow = np.array([0, 0, 0])
-    upper_shadow = np.array([180, 255, 80])
-    shadow_mask = cv2.inRange(hsv, lower_shadow, upper_shadow)
-    result = cv2.inpaint(image, shadow_mask, 3, cv2.INPAINT_TELEA)
-    return result
+    # Step 1: Convert to grayscale for processing
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
-def main():
-    st.title("Rooftop Area Calculation from Satellite Image")
-
-    # Allow the user to upload a file
-    uploaded_file = st.file_uploader("Upload a rooftop image", type=["jpg", "png"])
-
-    if uploaded_file is not None:
-        # Step 1: Preprocess image
-        img, blurred = preprocess_image(uploaded_file)
-        
-        if img is None:
-            return
-
-        # Step 2: Detect edges
-        edges = detect_edges(blurred)
-
-        # Step 3: Find contours
-        contours = find_contours(edges)
-
-        # Step 4: Filter contours to exclude unwanted areas
-        filtered_contours = filter_contours(contours)
-
-        # Step 5: Remove shadows from the image
-        image_no_shadows = remove_shadows(img)
-
-        # Step 6: Draw the predicted rooftop boundaries
-        output_img = draw_contours(image_no_shadows, filtered_contours)
-
-        # Step 7: Calculate the actual area of the rooftop (in square meters)
-        total_area = calculate_area_in_meters(filtered_contours)
-
-        # Step 8: Display the result
-        st.image(output_img, channels="BGR", caption="Detected Rooftop with Boundaries")
-        st.write(f"Total Rooftop Area: {total_area:.2f} square meters")
+    # Step 2: Apply Gaussian Blur to reduce noise
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
 
-if __name__ == "__main__":
-    main()
+    # Step 3: Edge detection (Canny)
+    edges = cv2.Canny(blurred, 50, 150)
+
+    # Step 4: 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
+    contours, _ = cv2.findContours(closed_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Create a blank mask for shadow removal
+    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)
+
+    # Step 6: Exclude shadows (thresholding)
+    shadow_removed = cv2.bitwise_and(gray, gray, mask=mask)
+    _, thresholded = cv2.threshold(shadow_removed, 120, 255, cv2.THRESH_BINARY)
+
+    # Step 7: Calculate the area in pixels
+    pixel_area = np.sum(thresholded > 0)
+
+    # Step 8: Convert pixels to real-world area
+    lat_min, lat_max, lon_min, lon_max = (
+        geographic_bounds['lat_min'],
+        geographic_bounds['lat_max'],
+        geographic_bounds['lon_min'],
+        geographic_bounds['lon_max'],
+    )
+    lat_diff = abs(lat_max - lat_min)
+    lon_diff = abs(lon_max - lon_min)
+
+    # Assuming Earth radius = 6371 km
+    earth_radius = 6371000  # in meters
+    lat_conversion = (lat_diff * np.pi / 180) * earth_radius
+    lon_conversion = (lon_diff * np.pi / 180) * earth_radius * np.cos(lat_min * np.pi / 180)
+
+    # Conversion factor: real-world area per pixel
+    conversion_factor = (lat_conversion * lon_conversion) / (image.shape[0] * image.shape[1])
+    real_world_area = pixel_area * conversion_factor  # in square meters
+
+    # Step 9: Overlay contours on the original image
+    final_image = image.copy()
+    cv2.drawContours(final_image, contours, -1, (0, 255, 0), 2)
+
+    return final_image, real_world_area
+
+# Example Usage
+geographic_bounds = {
+    'lat_min': 12.9716,
+    'lat_max': 12.9756,
+    'lon_min': 77.5946,
+    'lon_max': 77.5986,
+}
+input_image_path = "rooftop_image.jpg"
+
+final_image, calculated_area = process_rooftop_image(input_image_path, geographic_bounds)
+print(f"Calculated Rooftop Area: {calculated_area:.2f} square meters")
+
+# Save the final image with contours
+cv2.imwrite("processed_image_with_boundaries.jpg", final_image)
+
+# Display the final image
+cv2.imshow("Rooftop Detection", final_image)
+cv2.waitKey(0)
+cv2.destroyAllWindows()