Create app.py

app.py

@@ -0,0 +1,242 @@
+import streamlit as st
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+
+# -----------------------------------------------------------------
+# Utility functions
+# -----------------------------------------------------------------
+
+def generate_colorful_image(height=256, width=256, p_blue=0.5):
+    """
+    Generates a synthetic image (height x width) with:
+      - 'p_blue' fraction of blueish pixels
+      - (1 - p_blue) fraction of near-white/grey
+    Includes near-blue shades for more realistic challenge.
+    """
+    img = np.zeros((height, width, 3), dtype=np.uint8)
+    for i in range(height):
+        for j in range(width):
+            if np.random.rand() < p_blue:
+                # Random shade of blue
+                b = np.random.randint(100, 256)
+                g = np.random.randint(0, 121)
+                r = np.random.randint(0, 121)
+                if np.random.rand() < 0.3:  # shift to near-blue
+                    g += np.random.randint(0, 30)
+                    r += np.random.randint(0, 30)
+                b = min(b, 255)
+                g = min(g, 255)
+                r = min(r, 255)
+                img[i, j] = [b, g, r]
+            else:
+                # White/grey region
+                base = np.random.randint(180, 256)
+                diff_r = np.random.randint(-20, 20)
+                diff_g = np.random.randint(-20, 20)
+                diff_b = np.random.randint(-20, 20)
+                b = np.clip(base + diff_b, 0, 255)
+                g = np.clip(base + diff_g, 0, 255)
+                r = np.clip(base + diff_r, 0, 255)
+                img[i, j] = [b, g, r]
+    return img
+
+def simple_threshold_blue(image_bgr):
+    """
+    Simple approach:
+      1) Convert to HSV
+      2) Single broad threshold for blue
+      3) Count ratio of blue pixels
+    """
+    hsv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2HSV)
+    # Broad range for 'blue'
+    lower_blue = np.array([90,  50,  50], dtype=np.uint8)
+    upper_blue = np.array([130, 255, 255], dtype=np.uint8)
+    mask = cv2.inRange(hsv, lower_blue, upper_blue)
+
+    blue_pixels = cv2.countNonZero(mask)
+    total_pixels = image_bgr.shape[0] * image_bgr.shape[1]
+    perc_blue = (blue_pixels / total_pixels) * 100
+    return perc_blue, mask
+
+def advanced_threshold_blue(image_bgr):
+    """
+    Advanced approach:
+      1) Multiple color ranges for deep & light blues
+      2) Morphological cleaning
+      3) Count ratio of blue pixels
+    """
+    hsv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2HSV)
+
+    # Range 1: Deeper/darker blues
+    lower_blue1 = np.array([90, 50, 50], dtype=np.uint8)
+    upper_blue1 = np.array([130, 255, 255], dtype=np.uint8)
+    mask1 = cv2.inRange(hsv, lower_blue1, upper_blue1)
+    
+    # Range 2: Lighter or near-cyan
+    lower_blue2 = np.array([80, 30, 50], dtype=np.uint8)
+    upper_blue2 = np.array([100, 255, 255], dtype=np.uint8)
+    mask2 = cv2.inRange(hsv, lower_blue2, upper_blue2)
+
+    combined_mask = cv2.bitwise_or(mask1, mask2)
+
+    # Morphological cleaning
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
+    cleaned_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel)
+    cleaned_mask = cv2.morphologyEx(cleaned_mask, cv2.MORPH_CLOSE, kernel)
+
+    blue_pixels = cv2.countNonZero(cleaned_mask)
+    total_pixels = image_bgr.shape[0] * image_bgr.shape[1]
+    perc_blue = (blue_pixels / total_pixels) * 100
+    return perc_blue, cleaned_mask
+
+def plot_color_histogram(image_bgr):
+    """
+    Creates a matplotlib figure of B, G, and R channel histograms.
+    """
+    color = ('b','g','r')
+    fig, ax = plt.subplots(figsize=(4,3))
+    for i,col in enumerate(color):
+        hist = cv2.calcHist([image_bgr],[i],None,[256],[0,256])
+        ax.plot(hist, color=col)
+        ax.set_xlim([0,256])
+    ax.set_title("Color Channel Histogram")
+    ax.set_xlabel("Pixel Intensity")
+    ax.set_ylabel("Frequency")
+    fig.tight_layout()
+    return fig
+
+# -----------------------------------------------------------------
+# Streamlit App
+# -----------------------------------------------------------------
+
+# Page config
+st.set_page_config(page_title="ITC PSPD - Blue Area Detection Demo", layout="centered")
+
+st.title("Color Detection Demo for ITC PSPD")
+st.markdown("""
+**This assignment showcases an Industry 4.0 approach** to **color segmentation**,  
+demonstrating how tools like Python, OpenCV, and Streamlit can automate **quality checks**  
+(similar to checking the quality of paperboards, packaging prints, or other color-critical products).
+
+---
+
+**Why It Matters for ITC PSPD**:
+- ITC Paperboards & Specialty Papers Division (PSPD) is a leader in paper, packaging, and specialty solutions.
+- Precise color detection ensures **consistent brand identity**, reduces **defects**, and aligns with ITC's
+  **sustainability** and **innovation** ethos.
+
+Below, you can:
+1. **Generate** a synthetic image with random shades of **blue** and **near-white** regions.
+2. **Analyze** the image using both **Simple** and **Advanced** thresholding.
+3. **Visualize** color histograms and masks.
+4. See how this **digital transformation** approach can benefit large-scale production lines.
+
+---
+""")
+
+st.sidebar.header("Generation Controls")
+p_blue = st.sidebar.slider("Fraction of Blue-ish Pixels", 0.0, 1.0, 0.5, 0.05)
+img_size = st.sidebar.selectbox("Image Size (px)", [128, 192, 256, 320], index=2)
+
+if "random_image" not in st.session_state:
+    st.session_state["random_image"] = None
+
+st.sidebar.markdown("---")
+if st.sidebar.button("Generate New Random Image"):
+    img_bgr = generate_colorful_image(height=img_size, width=img_size, p_blue=p_blue)
+    st.session_state["random_image"] = img_bgr
+
+# Check if we have an image
+if st.session_state["random_image"] is None:
+    st.warning("Use the sidebar to generate a new image.")
+else:
+    st.subheader("1) Randomly Generated Image & Color Analysis")
+
+    # Convert BGR->RGB for display
+    img_bgr = st.session_state["random_image"]
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.image(img_rgb, caption="Synthesized Image (RGB)", width=250)
+
+    with col2:
+        # Show color histogram
+        hist_fig = plot_color_histogram(img_bgr)
+        st.pyplot(hist_fig)
+
+    st.markdown("---")
+
+    # Simple Threshold
+    st.subheader("2) Simple Threshold Approach")
+    simple_perc_blue, simple_mask = simple_threshold_blue(img_bgr)
+
+    col3, col4 = st.columns(2)
+    with col3:
+        st.write(f"**Blue Percentage (Simple):** {simple_perc_blue:.2f}%")
+        st.progress(min(simple_perc_blue/100, 1.0))
+    with col4:
+        st.image(simple_mask, caption="Simple Mask (white=detected blue)", width=250)
+
+    st.markdown("---")
+
+    # Advanced Threshold
+    st.subheader("3) Advanced Threshold Approach")
+    adv_perc_blue, adv_mask = advanced_threshold_blue(img_bgr)
+
+    col5, col6 = st.columns(2)
+    with col5:
+        st.write(f"**Blue Percentage (Advanced):** {adv_perc_blue:.2f}%")
+        st.progress(min(adv_perc_blue/100, 1.0))
+    with col6:
+        st.image(adv_mask, caption="Advanced Mask (white=detected blue)", width=250)
+
+st.markdown("""
+---
+## Relevance to ITC PSPD: 
+- **Digital Quality Control**: A color detection system like this can **validate printed matter** (cartons, labels) in real time.
+- **Big Data Integration**: Results could be uploaded to a **data lake**, enabling historical trend analysis and continuous improvement.
+- **Sustainability**: **Accurate color checks** reduce material wastage, aligning with ITC’s triple bottom line (economic, social, environmental) philosophy.
+- **Industry 4.0**: Coupling this solution with **IoT** sensors, real-time dashboards, and advanced analytics ensures **agile and data-driven** paperboard manufacturing.
+
+## Made By:
+**Kaustubh Raykar**  
+- +91 7020524609  
+- [[email protected]](mailto:[email protected])  
+- [[email protected]](mailto:[email protected])
+
+---
+
+**Thank you for exploring this demonstration!**  
+""")
+
+# -----------------------------------------------------------------
+# How the Code Works - Explanation
+# -----------------------------------------------------------------
+st.header("How This Code Works")
+st.markdown("""
+1. **Utility Functions**  
+   - **generate_colorful_image**: Creates a synthetic image with a customizable proportion of blue pixels. This simulates different real-world scenarios, such as varying amounts of a brand color on packaging.
+   - **simple_threshold_blue**: Uses basic HSV thresholding to identify blue pixels. Provides a quick, broad detection method.
+   - **advanced_threshold_blue**: Combines multiple ranges for different shades of blue and applies morphological operations for noise reduction, giving more robust results.
+   - **plot_color_histogram**: Plots separate color channel (B, G, R) histograms to visualize the distribution of pixel intensities.
+
+2. **Streamlit Layout**  
+   - **Sidebar**: Controls to adjust the fraction of blueish pixels and the image size. A button to generate a new random image is also included.
+   - **Main Page**: 
+     - Displays the generated image and its color histogram side by side.
+     - Shows the simple vs. advanced detection masks with the calculated percentage of blue. 
+     - Progress bars indicate the proportion of blue visually.
+   
+3. **Industry 4.0 Context**  
+   - By integrating this approach with IoT devices, large-scale manufacturing lines can automate color checks. The masks and percentage calculations serve as a foundation for real-time QA alerts, data logging, and future analytics.
+
+4. **Execution Flow**  
+   1. When the user clicks "Generate New Random Image," it calls `generate_colorful_image()` to create a fresh synthetic image.
+   2. The image is converted to RGB for display. Meanwhile, `plot_color_histogram()` renders a histogram for deeper insight into color distribution.
+   3. The **simple_threshold_blue** and **advanced_threshold_blue** functions each produce their own masks and calculations, displayed in the main interface.
+   4. By comparing the results of both methods, users can see the differences in detection accuracy and how morphological operations can refine the result.
+
+This cohesive setup ensures a **user-friendly**, **real-time** demonstration of how color segmentation can be applied to industrial use cases—especially relevant for ITC PSPD's commitments to **quality** and **innovation**.
+""")