add matplotlib

app.py

@@ -1,154 +1,145 @@
-# Ci-Dave from BSCS-AI
-# Description: This Python script creates a Streamlit web application for image analysis using computer vision techniques and AI-generated explanations. 
-# The app allows users to upload an image, apply edge detection, segmentation, feature extraction, and AI classification. 
-# The explanations for each technique are generated using the Gemini API for AI-generated content.
-
 import streamlit as st  # Streamlit library to create the web interface
 import numpy as np  # Library for numerical operations
 import google.generativeai as genai  # Gemini API for AI-generated explanations
 
-# Random Forest and Logistic Regression model for classification
-from sklearn.ensemble import RandomForestClassifier   
-from sklearn.linear_model import LogisticRegression   
-
-from skimage.filters import sobel  # Sobel edge detection filter from skimage
-from skimage.segmentation import watershed  # Watershed segmentation method
-from skimage.feature import canny, hog  # Canny edge detection and HOG feature extraction
-from skimage.color import rgb2gray  # Convert RGB images to grayscale
-
-from skimage import io  # I/O functions for reading images
-from sklearn.preprocessing import StandardScaler  # Standardization of image data
+# Import necessary computer vision functions
+from skimage.filters import sobel
+from skimage.segmentation import watershed
+from skimage.feature import canny, hog
+from skimage.color import rgb2gray
+from skimage import io
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+import matplotlib.pyplot as plt  # For better visualization
 
 # Load Gemini API key from Streamlit Secrets configuration
-api_key = st.secrets["gemini"]["api_key"]  # Get API key from Streamlit secrets
-genai.configure(api_key=api_key)  # Configure the Gemini API with the API key
+api_key = st.secrets["gemini"]["api_key"]
+genai.configure(api_key=api_key)
 
-MODEL_ID = "gemini-1.5-flash"  # Specify the model ID for Gemini
-gen_model = genai.GenerativeModel(MODEL_ID)  # Initialize the Gemini model
+MODEL_ID = "gemini-1.5-flash"
+gen_model = genai.GenerativeModel(MODEL_ID)
 
-# Function to generate explanations using the Gemini API
 def explain_ai(prompt):
     """Generate an explanation using Gemini API with error handling."""
     try:
-        response = gen_model.generate_content(prompt)  # Get AI-generated content based on prompt
-        return response.text  # Return the explanation text
+        response = gen_model.generate_content(prompt)
+        return response.text
     except Exception as e:
-        return f"Error: {str(e)}"  # Return error message if there's an issue
+        return f"Error: {str(e)}"
 
 # App title
 st.title("Imaize: Smart Image Analyzer with XAI")
 
 # Image upload section
-uploaded_file = st.file_uploader("Upload an image", type=["jpg", "png", "jpeg"])  # Allow user to upload an image file
+uploaded_file = st.file_uploader("Upload an image", type=["jpg", "png", "jpeg"])
 
 # App Description 
 st.markdown("""
 This app combines AI-powered image analysis techniques with an easy-to-use interface for explanation generation. 
 It leverages advanced computer vision algorithms such as **edge detection**, **image segmentation**, and **feature extraction**. 
 Additionally, the app provides **explanations** for each method used, powered by the Gemini API, to make the process more understandable.
-
-The main functionalities of the app include:
-- **Edge Detection**: Choose between the Canny and Sobel edge detection methods.
-- **Segmentation**: Apply Watershed or Thresholding methods to segment images.
-- **Feature Extraction**: Extract Histogram of Oriented Gradients (HOG) features from images.
-- **AI Classification**: Classify images using Random Forest or Logistic Regression models.
-
-Whether you're exploring computer vision or simply curious about how these techniques work, this app will guide you through the process with easy-to-understand explanations.
 """)
 
-# Instructions on how to use the app 
+# Instructions for using the app
 st.markdown("""
 ### How to Use the App:
-
-1. **Upload an Image**: Click on the "Upload an image" button to upload an image (in JPG, PNG, or JPEG format) for analysis.
-2. **Select Edge Detection**: Choose between **Canny** or **Sobel** edge detection methods. The app will process the image and display the result.
-3. **Apply Segmentation**: Select **Watershed** or **Thresholding** segmentation. You can also adjust the threshold for thresholding segmentation.
-4. **Extract HOG Features**: Visualize the HOG (Histogram of Oriented Gradients) features from the image.
-5. **Choose AI Model for Classification**: Select either **Random Forest** or **Logistic Regression** to classify the image based on pixel information.
-6. **Read the Explanations**: For each technique, you'll find a detailed explanation of how it works, powered by AI. Simply read the generated explanation to understand the underlying processes.
-
-### Enjoy exploring and understanding image analysis techniques with AI!
+1. **Upload an Image**: Click on the "Upload an image" button to upload an image (in JPG, PNG, or JPEG format).
+2. **Edge Detection**: Choose between **Canny** or **Sobel** edge detection methods.
+3. **Segmentation**: Select **Watershed** or **Thresholding** segmentation.
+4. **Extract HOG Features**: Visualize the Histogram of Oriented Gradients (HOG) features.
+5. **AI Classification**: Classify the image using Random Forest or Logistic Regression models.
+6. **Read the Explanations**: For each technique, you'll find a detailed explanation generated by AI.
 """)
 
 # If an image is uploaded, proceed with the analysis
 if uploaded_file is not None:
-    image = io.imread(uploaded_file)  # Read the uploaded image using skimage
+    image = io.imread(uploaded_file)
     if image.shape[-1] == 4:  # If the image has 4 channels (RGBA), remove the alpha channel
         image = image[:, :, :3]
-
-    gray = rgb2gray(image)  # Convert the image to grayscale for processing
     
-    st.image(image, caption="Uploaded Image", use_container_width=True)  # Display the uploaded image
+    # Convert to grayscale
+    gray = rgb2gray(image)
+
+    # Normalize grayscale image to make it visible (if it's in float range 0-1)
+    gray_normalized = (gray * 255).astype(np.uint8)  # Convert grayscale image to 8-bit format
+
+    # Display uploaded image
+    st.image(image, caption="Uploaded Image", use_container_width=True)
 
     # Edge Detection Section
-    st.subheader("Edge Detection")  # Title for edge detection section
-    edge_method = st.selectbox("Select Edge Detection Method", ["Canny", "Sobel"], key="edge")  # Select edge detection method
-    edges = canny(gray) if edge_method == "Canny" else sobel(gray)  # Apply chosen edge detection method
+    st.subheader("Edge Detection")
+    edge_method = st.selectbox("Select Edge Detection Method", ["Canny", "Sobel"], key="edge")
+    edges = canny(gray) if edge_method == "Canny" else sobel(gray)
     edges = (edges * 255).astype(np.uint8)  # Convert edge map to 8-bit image format
-    
-    col1, col2 = st.columns([1, 1])  # Create two columns for layout
+
+    col1, col2 = st.columns([1, 1])
     with col1:
-        st.image(edges, caption=f"{edge_method} Edge Detection", use_container_width=True)  # Display the edge detection result
+        st.image(edges, caption=f"{edge_method} Edge Detection", use_container_width=True)
     with col2:
-        st.write("### Explanation")  # Show explanation header
-        explanation = explain_ai(f"Explain how {edge_method} edge detection works in computer vision.")  # Get explanation from AI
-        st.text_area("Explanation", explanation, height=300)  # Display explanation in a text area
+        st.write("### Explanation")
+        explanation = explain_ai(f"Explain how {edge_method} edge detection works in computer vision.")
+        st.text_area("Explanation", explanation, height=300)
 
     # Segmentation Section
-    st.subheader("Segmentation")  # Title for segmentation section
-    seg_method = st.selectbox("Select Segmentation Method", ["Watershed", "Thresholding"], key="seg")  # Select segmentation method
-    
-    # Perform segmentation based on chosen method
+    st.subheader("Segmentation")
+    seg_method = st.selectbox("Select Segmentation Method", ["Watershed", "Thresholding"], key="seg")
+
     if seg_method == "Watershed":
-        elevation_map = sobel(gray)  # Create elevation map using Sobel filter
-        markers = np.zeros_like(gray)  # Initialize marker array
-        markers[gray < 0.3] = 1  # Mark low-intensity regions
-        markers[gray > 0.7] = 2  # Mark high-intensity regions
-        segmented = watershed(elevation_map, markers.astype(np.int32))  # Apply watershed segmentation
+        elevation_map = sobel(gray)
+        markers = np.zeros_like(gray)
+        markers[gray < 0.3] = 1
+        markers[gray > 0.7] = 2
+        segmented = watershed(elevation_map, markers.astype(np.int32))
     else:
-        threshold_value = st.slider("Choose threshold value", 0, 255, 127)  # Slider to choose threshold value
-        segmented = (gray > (threshold_value / 255)).astype(np.uint8) * 255  # Apply thresholding segmentation
+        threshold_value = st.slider("Choose threshold value", 0, 255, 127)
+        segmented = (gray > (threshold_value / 255)).astype(np.uint8) * 255
     
-    col1, col2 = st.columns([1, 1])  # Create two columns for layout
+    # Normalize segmented result for better visibility
+    segmented_normalized = (segmented * 255).astype(np.uint8)
+
+    col1, col2 = st.columns([1, 1])
     with col1:
-        st.image(segmented, caption=f"{seg_method} Segmentation", use_container_width=True)  # Display segmentation result
+        st.image(segmented_normalized, caption=f"{seg_method} Segmentation", use_container_width=True)
     with col2:
-        st.write("### Explanation")  # Show explanation header
-        explanation = explain_ai(f"Explain how {seg_method} segmentation works in image processing.")  # Get explanation from AI
-        st.text_area("Explanation", explanation, height=300)  # Display explanation in a text area
+        st.write("### Explanation")
+        explanation = explain_ai(f"Explain how {seg_method} segmentation works in image processing.")
+        st.text_area("Explanation", explanation, height=300)
 
     # HOG Feature Extraction Section
-    st.subheader("HOG Feature Extraction")  # Title for HOG feature extraction section
-    fd, hog_image = hog(gray, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualize=True)  # Extract HOG features
-    
-    col1, col2 = st.columns([1, 1])  # Create two columns for layout
+    st.subheader("HOG Feature Extraction")
+    fd, hog_image = hog(gray, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualize=True)
+
+    # Normalize HOG image for display
+    hog_image = (hog_image * 255).astype(np.uint8)
+
+    col1, col2 = st.columns([1, 1])
     with col1:
-        st.image(hog_image, caption="HOG Features", use_container_width=True)  # Display HOG feature image
+        st.image(hog_image, caption="HOG Features", use_container_width=True)
     with col2:
-        st.write("### Explanation")  # Show explanation header
-        explanation = explain_ai("Explain how Histogram of Oriented Gradients (HOG) feature extraction works.")  # Get explanation from AI
-        st.text_area("Explanation", explanation, height=300)  # Display explanation in a text area
+        st.write("### Explanation")
+        explanation = explain_ai("Explain how Histogram of Oriented Gradients (HOG) feature extraction works.")
+        st.text_area("Explanation", explanation, height=300)
 
     # AI Classification Section
-    st.subheader("AI Classification")  # Title for AI classification section
-    model_choice = st.selectbox("Select AI Model", ["Random Forest", "Logistic Regression"], key="model")  # Select AI model for classification
-    
-    flat_image = gray.flatten().reshape(-1, 1)  # Flatten the grayscale image into a 1D array for classification
-    labels = (flat_image > 0.5).astype(int).flatten()  # Generate binary labels based on intensity threshold
-    
-    # Choose model (Random Forest or Logistic Regression)
-    ai_model = RandomForestClassifier(n_jobs=1) if model_choice == "Random Forest" else LogisticRegression()  # Initialize the model
-    scaler = StandardScaler()  # Standardize the image data for better classification
-    flat_image_scaled = scaler.fit_transform(flat_image)  # Scale the image data
-    
-    ai_model.fit(flat_image_scaled, labels)  # Train the AI model on the image data
-    predictions = ai_model.predict(flat_image_scaled).reshape(gray.shape)  # Make predictions on the image
-    predictions = (predictions * 255).astype(np.uint8)  # Convert predictions to 8-bit image format
-    
-    col1, col2 = st.columns([1, 1])  # Create two columns for layout
+    st.subheader("AI Classification")
+    model_choice = st.selectbox("Select AI Model", ["Random Forest", "Logistic Regression"], key="model")
+
+    flat_image = gray.flatten().reshape(-1, 1)
+    labels = (flat_image > 0.5).astype(int).flatten()
+
+    ai_model = RandomForestClassifier(n_jobs=1) if model_choice == "Random Forest" else LogisticRegression()
+    scaler = StandardScaler()
+    flat_image_scaled = scaler.fit_transform(flat_image)
+
+    ai_model.fit(flat_image_scaled, labels)
+    predictions = ai_model.predict(flat_image_scaled).reshape(gray.shape)
+    predictions = (predictions * 255).astype(np.uint8)
+
+    col1, col2 = st.columns([1, 1])
     with col1:
-        st.image(predictions, caption=f"{model_choice} Pixel Classification", use_container_width=True)  # Display classification result
+        st.image(predictions, caption=f"{model_choice} Pixel Classification", use_container_width=True)
     with col2:
-        st.write("### Explanation")  # Show explanation header
-        explanation = explain_ai(f"Explain how {model_choice} is used for image classification.")  # Get explanation from AI
-        st.text_area("Explanation", explanation, height=300)  # Display explanation in a text area
+        st.write("### Explanation")
+        explanation = explain_ai(f"Explain how {model_choice} is used for image classification.")
+        st.text_area("Explanation", explanation, height=300)