Update app.py

app.py

@@ -4,12 +4,11 @@ import pandas as pd
 import streamlit as st
 from keras.models import load_model
 from sklearn.preprocessing import OneHotEncoder, StandardScaler
-from PIL import Image
 
 # Load the pre-trained model
 loaded_model = load_model('solar_irradiance_model.keras')
 
-# Load dataset for encoder and scaler setup
+# Load the dataset for encoder and scaler setup
 data = pd.read_csv('Solar_Irradiance.csv')
 data['Latitude'] = data['Latitude'].str.rstrip('°').astype(float)
 data['Longitude'] = data['Longitude'].str.rstrip('°').astype(float)
@@ -17,7 +16,7 @@ data['Longitude'] = data['Longitude'].str.rstrip('°').astype(float)
 # Features and encoder/scaler setup
 features = data[['Month', 'Hour', 'Latitude', 'Longitude', 'Panel_Capacity(W)', 'Panel_Efficiency', 'Wind_Speed(km/h)', 'Cloud_Cover(%)', 'temperature (°f)']]
 
-encoder = OneHotEncoder(sparse_output=False)
+encoder = OneHotEncoder(sparse_output=False, categories='auto')
 categorical_features = features[['Month', 'Hour']]
 encoder.fit(categorical_features)
 
@@ -25,118 +24,77 @@ scaler = StandardScaler()
 numerical_features = features[['Latitude', 'Longitude', 'Panel_Capacity(W)', 'Panel_Efficiency', 'Wind_Speed(km/h)', 'Cloud_Cover(%)', 'temperature (°f)']]
 scaler.fit(numerical_features)
 
-# Predict Irradiance Function
-def predict_irradiance(month, hour, latitude, longitude, panel_efficiency, wind_speed, cloud_cover, temperature):
-    # Map month to an integer
-    month_mapping = {m: i + 1 for i, m in enumerate(
-        ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
-    )}
-    month_num = month_mapping[month]
-
-    # Encode month and hour
-    encoded_month_hour = encoder.transform([[month_num, hour]])
+# Shadow Removal Function
+def remove_shadows(image):
+    """Removes shadows using illumination normalization."""
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (21, 21), 0)
+    normalized = cv2.divide(gray, blurred, scale=255)
+    result = cv2.cvtColor(normalized, cv2.COLOR_GRAY2BGR)
+    return result
+
+# Preprocess Image with Canny Edge Detection
+def apply_canny_edge(image):
+    # Step 1: Remove shadows
+    shadow_free_image = remove_shadows(image)
+    
+    # Step 2: Convert to grayscale
+    gray = cv2.cvtColor(shadow_free_image, cv2.COLOR_BGR2GRAY)
+    
+    # Step 3: Apply Canny edge detection
+    edges = cv2.Canny(gray, 100, 200)
+    
+    # Step 4: Dilate the edges to make them more prominent
+    kernel = np.ones((5, 5), np.uint8)
+    dilated_edges = cv2.dilate(edges, kernel, iterations=2)
+    
+    return dilated_edges
 
-    # Scale numerical features
-    panel_capacity = 50000  # Fixed to 50 kW
+# Predict Irradiance Function
+def predict_irradiance(month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature):
+    # Ensure the month is passed as a string (e.g., "January", "February")
+    # Encode the month and hour using the same encoder fitted during training
+    encoded_month_hour = encoder.transform([[month, hour]])
+    
+    # Scale the numerical features
     scaled_features = scaler.transform([[latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature]])
-
-    # Combine encoded and scaled features
+    
+    # Combine the encoded categorical features with the scaled numerical features
     processed_features = np.concatenate((encoded_month_hour, scaled_features), axis=1)
-
+    
     # Reshape features to match LSTM input
     reshaped_features = np.reshape(processed_features, (1, 1, processed_features.shape[1]))
-
-    # Predict irradiance
+    
+    # Predict the irradiance using the trained model
     predicted_irradiance = loaded_model.predict(reshaped_features)
-    return max(predicted_irradiance[0][0], 0.0)  # Ensure non-negative output
-
-# Rooftop Usable Area Calculation
-def process_rooftop_image(image, geographic_bounds):
-    """
-    Detect rooftops, exclude shadows, and calculate usable area for solar panels.
-    """
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
-    _, shadow_mask = cv2.threshold(blurred, 80, 255, cv2.THRESH_BINARY_INV)
-    edges = cv2.Canny(blurred, 50, 150)
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
-    closed_edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
-    contours, _ = cv2.findContours(closed_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    rooftop_mask = np.zeros_like(gray)
-    for contour in contours:
-        approx = cv2.approxPolyDP(contour, 0.02 * cv2.arcLength(contour, True), True)
-        if cv2.contourArea(approx) > 500:
-            cv2.drawContours(rooftop_mask, [approx], -1, 255, -1)
-
-    final_mask = cv2.bitwise_and(rooftop_mask, cv2.bitwise_not(shadow_mask))
-    pixel_area = np.sum(final_mask > 0)
-
-    lat_min, lat_max, lon_min, lon_max = (
-        geographic_bounds['lat_min'], geographic_bounds['lat_max'], geographic_bounds['lon_min'], geographic_bounds['lon_max']
-    )
-    earth_radius = 6371000  # in meters
-    lat_conversion = (abs(lat_max - lat_min) * np.pi / 180) * earth_radius
-    lon_conversion = (abs(lon_max - lon_min) * np.pi / 180) * earth_radius * np.cos(lat_min * np.pi / 180)
-    conversion_factor = (lat_conversion * lon_conversion) / (image.shape[0] * image.shape[1])
-    usable_area = pixel_area * conversion_factor
-
-    final_image = image.copy()
-    cv2.drawContours(final_image, contours, -1, (0, 255, 0), 2)
-    return final_image, usable_area
-
-# Streamlit Interface
-st.title("Solar Energy and Rooftop Panel Planner")
-
-# File uploader for rooftop image
-uploaded_file = st.file_uploader("Upload Rooftop Image", type=["png", "jpg", "jpeg"])
-
-# Geographic bounds input with default values
-lat_min = st.number_input("Latitude Min", value=90.34, step=0.0001)
-lat_max = st.number_input("Latitude Max", value=90.37, step=0.0001)
-lon_min = st.number_input("Longitude Min", value=89.78, step=0.0001)
-lon_max = st.number_input("Longitude Max", value=89.80, step=0.0001)
-
-# Environmental inputs for solar irradiance prediction
-month = st.selectbox("Month", ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'])
-hour = st.slider("Hour", 0, 23, step=1)
-latitude = st.number_input("Latitude", value=90.35)
-longitude = st.number_input("Longitude", value=89.79)
-panel_efficiency = st.number_input("Panel Efficiency (0-1)", value=0.15)
-wind_speed = st.number_input("Wind Speed (km/h)", value=6.44)
-cloud_cover = st.number_input("Cloud Cover (%)", value=17.7)
-temperature = st.number_input("Temperature (°F)", value=55.0)
-
-# Panel dimensions and cost
-panel_length = st.number_input("Panel Length (m)", value=5.0)
-panel_breadth = st.number_input("Panel Breadth (m)", value=5.0)
-
-# Button to process the image and calculate solar metrics
-if st.button("Calculate"):
-    if uploaded_file is not None:
-        image = np.array(Image.open(uploaded_file).convert("RGB"))
-        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-
-        geographic_bounds = {
-            'lat_min': lat_min,
-            'lat_max': lat_max,
-            'lon_min': lon_min,
-            'lon_max': lon_max,
-        }
-
-        final_image, usable_area = process_rooftop_image(image, geographic_bounds)
-        panel_area = panel_length * panel_breadth
-        panel_count = int(usable_area // panel_area)
-
-        st.image(cv2.cvtColor(final_image, cv2.COLOR_BGR2RGB), caption="Processed Image with Boundaries")
-        st.write(f"Usable Rooftop Area: **{usable_area:.2f} square meters**")
-        st.write(f"Number of Panels: **{panel_count}**")
-
-        irradiance = predict_irradiance(month, hour, latitude, longitude, panel_efficiency, wind_speed, cloud_cover, temperature)
-        total_energy = (irradiance * panel_efficiency * panel_count * panel_area) / 1000  # Convert to kWh
-        panel_cost = panel_count * 10000  # Fixed cost for 50 kW panels
-        st.write(f"Predicted Irradiance: **{irradiance:.2f} W/m²**")
-        st.write(f"Total Potential Energy: **{total_energy:.2f} kWh**")
-        st.write(f"Total Cost for Panels: **₹{panel_cost:.2f}**")
-    else:
-        st.error("Please upload a rooftop image.")
+    
+    # Ensure the result is not negative
+    return max(predicted_irradiance[0][0], 0.0)
+
+# Streamlit Interface Setup
+st.title("Solar Irradiance Predictor")
+
+# Upload image
+uploaded_image = st.file_uploader("Upload Rooftop Image", type=["jpg", "jpeg", "png"])
+
+if uploaded_image is not None:
+    image = np.array(cv2.imdecode(np.frombuffer(uploaded_image.read(), np.uint8), 1))
+
+    # User inputs
+    month = st.selectbox("Month", ['January', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'])
+    hour = st.slider("Hour", 0, 23, step=1)
+    latitude = st.number_input("Latitude", value=28.57)
+    longitude = st.number_input("Longitude", value=77.33)
+    panel_capacity = st.number_input("Panel Capacity (W)", value=500.0)
+    panel_efficiency = st.number_input("Panel Efficiency (0-1)", value=0.15)
+    wind_speed = st.number_input("Wind Speed (km/h)", value=6.44)
+    cloud_cover = st.number_input("Cloud Cover (%)", value=17.7)
+    temperature = st.number_input("Temperature (°F)", value=55.0)
+
+    # Predict Button
+    if st.button("Predict Irradiance"):
+        irradiance = predict_irradiance(month, hour, latitude, longitude, panel_capacity, panel_efficiency, wind_speed, cloud_cover, temperature)
+
+        # Display results
+        st.subheader("Results")
+        st.text(f"Predicted Irradiance: {irradiance:.2f} W/m²")