Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,374 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from pathlib import Path
+import io
+
+from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, \
+    MaxPool2D, UpSampling2D, concatenate, \
+    Input, Conv2DTranspose, MaxPooling2D, \
+    Dropout, BatchNormalization
+from tensorflow.keras.models import Model
+
+
+# ===========================
+# Model Architecture
+# ===========================
+
+def conv2d_block(input_tensor, n_filters, kernel_size=3, batchnorm=True, sublayers=2):
+    '''In case batchnorm=False "if" statement will be skipped and in amount of "sublayers" convolutional layers will be created.'''
+    for idx in range(sublayers):
+        conv = Conv2D(filters=n_filters, kernel_size=(kernel_size, kernel_size),
+                      kernel_initializer="he_normal", padding="same")(input_tensor if idx == 0 else conv)
+        if batchnorm:
+            normalized = BatchNormalization()(conv)
+        conv = Activation("relu")(conv)
+    return conv
+
+
+def conv2d_transpose_block(input_tensor, concatenate_tensor, n_filters, kernel_size=3, strides=2, transpose=False):
+    if transpose:
+        conv = Conv2DTranspose(n_filters, (kernel_size, kernel_size),
+                               strides=(strides, strides), padding='same')(input_tensor)
+    else:
+        conv = Conv2D(n_filters, (kernel_size, kernel_size), activation='relu', padding='same',
+                      kernel_initializer='he_normal')(UpSampling2D(size=(kernel_size, kernel_size))(input_tensor))
+    conv = Activation("relu")(conv)
+    concatenation = concatenate([conv, concatenate_tensor])
+    return concatenation
+
+
+def build_unet(input_shape=(512, 512, 3), filters=[16, 32, 64, 128, 256], batchnorm=True, transpose=False,
+               dropout_flag=False):
+    conv_dict = dict()
+    inputs = Input(input_shape)
+    dropout_rate = 0.5
+
+    for idx, n_filters in enumerate(filters[:-1]):
+        conv = conv2d_block(inputs if n_filters == filters[0] else max_pool,
+                            n_filters=n_filters, kernel_size=3,
+                            batchnorm=batchnorm)
+        max_pool = MaxPooling2D((2, 2))(conv)
+        conv_dict[f"conv2d_{idx + 1}"] = conv
+
+    conv_middle = conv2d_block(max_pool, n_filters=filters[-1], kernel_size=3, batchnorm=batchnorm)
+
+    for idx, n_filters in enumerate(reversed(filters[:-1])):
+        concatenation = conv2d_transpose_block(conv_middle if idx == 0 else conv,
+                                               conv_dict[f"conv2d_{len(conv_dict) - idx}"],
+                                               n_filters, kernel_size=2, strides=2, transpose=transpose)
+        conv = conv2d_block(concatenation, n_filters=n_filters, kernel_size=3,
+                            batchnorm=batchnorm)
+
+    outputs = Conv2D(3, (1, 1), activation='softmax')(conv)
+    model = Model(inputs=inputs, outputs=outputs)
+    return model
+
+
+# ===========================
+# Model Loading (Cached)
+# ===========================
+
+@st.cache_resource
+def load_model():
+    """Load the pre-trained U-Net model"""
+    model = build_unet(input_shape=(512, 512, 3),
+                       filters=[2 ** i for i in range(5, int(np.log2(2048) + 1))],
+                       batchnorm=False, transpose=False, dropout_flag=False)
+
+    weights_path = Path("src/forest-cover-model-v1.h5")
+    model.load_weights(str(weights_path))
+    return model
+
+
+# ===========================
+# Prediction Function
+# ===========================
+
+def predict_and_calculate(image, model):
+    """Process image and calculate forest cover"""
+    # Resize and normalize
+    img = image.convert("RGB")
+    img = img.resize((512, 512))
+    img_np = np.array(img) / 255.0
+
+    # Predict
+    pred = model.predict(img_np[np.newaxis, ...], verbose=0)[0]
+    pred_class = np.argmax(pred, axis=-1)
+
+    # Forest class = 0
+    forest_mask = (pred_class == 0).astype(np.uint8)
+
+    # Calculate forest cover percentage
+    total_pixels = forest_mask.size
+    forest_pixels = np.sum(forest_mask)
+    forest_cover = (forest_pixels / total_pixels) * 100
+
+    return img_np, forest_mask, forest_cover
+
+
+def create_visualization(image_np, forest_mask, forest_cover):
+    """Create visualization with original, mask, and overlay"""
+    # Create colored mask
+    color_mask = np.zeros((512, 512, 3), dtype=np.uint8)
+    color_mask[forest_mask == 1] = [0, 255, 0]  # GREEN = Forest
+
+    # Create overlay
+    overlay = image_np.copy()
+    overlay[forest_mask == 1] = overlay[forest_mask == 1] * 0.5 + np.array([0, 1, 0]) * 0.5
+
+    # Create matplotlib figure
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+
+    axes[0].imshow(image_np)
+    axes[0].set_title("Original Image", fontsize=12, fontweight='bold')
+    axes[0].axis("off")
+
+    axes[1].imshow(color_mask)
+    axes[1].set_title("Forest Cover Mask", fontsize=12, fontweight='bold')
+    axes[1].axis("off")
+
+    axes[2].imshow(overlay)
+    axes[2].set_title("Overlay Visualization", fontsize=12, fontweight='bold')
+    axes[2].axis("off")
+
+    plt.tight_layout()
+    return fig
+
+
+# ===========================
+# Streamlit App Configuration
+# ===========================
+
+st.set_page_config(
+    page_title="Forest Cover Assessment System",
+    page_icon="🌲",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for professional government theme
+st.markdown("""
+    <style>
+    .main-header {
+        font-size: 42px;
+        font-weight: bold;
+        color: #1e3a5f;
+        text-align: center;
+        padding: 20px 0;
+        border-bottom: 3px solid #2e5c8a;
+        margin-bottom: 30px;
+    }
+    .sub-header {
+        font-size: 18px;
+        color: #4a4a4a;
+        text-align: center;
+        margin-bottom: 40px;
+    }
+    .metric-container {
+        background-color: #f0f4f8;
+        padding: 20px;
+        border-radius: 10px;
+        border-left: 5px solid #2e5c8a;
+        margin: 10px 0;
+    }
+    .metric-value {
+        font-size: 36px;
+        font-weight: bold;
+        color: #1e3a5f;
+    }
+    .metric-label {
+        font-size: 14px;
+        color: #666;
+        text-transform: uppercase;
+    }
+    .footer {
+        text-align: center;
+        color: #666;
+        padding: 20px 0;
+        margin-top: 50px;
+        border-top: 1px solid #ddd;
+        font-size: 12px;
+    }
+    .info-box {
+        background-color: #e8f4f8;
+        padding: 15px;
+        border-radius: 5px;
+        border-left: 4px solid #2196F3;
+        margin: 10px 0;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+
+# ===========================
+# Main Application
+# ===========================
+
+def main():
+    # Header
+    st.markdown('<div class="main-header">Forest Cover Assessment System</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="sub-header">Advanced Satellite Imagery Analysis for Forest Conservation & Monitoring</div>',
+        unsafe_allow_html=True)
+
+    # Sidebar
+    with st.sidebar:
+        st.image("https://via.placeholder.com/250x80/1e3a5f/ffffff?text=Forest+Division", use_container_width=True)
+        st.markdown("### About This System")
+        st.markdown("""
+        This system utilizes deep learning technology to analyze satellite 
+        imagery and accurately assess forest cover percentages in designated areas.
+        
+        **Key Features:**
+        - Automated forest detection
+        - High-precision segmentation
+        - Multi-image batch processing
+        - Visual overlay analysis
+        
+        **Supported Formats:**
+        - PNG, JPG, JPEG
+        - Recommended: High-resolution satellite imagery
+        """)
+
+        st.markdown("---")
+        st.markdown("**System Status:** Operational")
+        st.markdown("**Model Version:** v1.0")
+
+    # Information box
+    st.markdown("""
+    <div class="info-box">
+    <strong>Instructions:</strong> Upload one or more satellite images (PNG, JPG, JPEG) to analyze forest cover. 
+    The system will process each image and provide detailed forest coverage metrics along with visual overlays.
+    </div>
+    """, unsafe_allow_html=True)
+
+    # File uploader
+    uploaded_files = st.file_uploader(
+        "Upload Satellite Images",
+        type=["png", "jpg", "jpeg"],
+        accept_multiple_files=True,
+        help="Select one or more images for forest cover analysis"
+    )
+
+    if uploaded_files:
+        st.markdown("---")
+        st.markdown(f"### Analysis Results ({len(uploaded_files)} image(s) uploaded)")
+
+        # Load model
+        with st.spinner("Loading AI model..."):
+            model = load_model()
+
+        # Process each uploaded image
+        total_forest_cover = 0
+
+        for idx, uploaded_file in enumerate(uploaded_files, 1):
+            st.markdown(f"#### Image {idx}: {uploaded_file.name}")
+
+            # Load image
+            image = Image.open(uploaded_file)
+
+            # Process image
+            with st.spinner(f"Processing {uploaded_file.name}..."):
+                img_np, forest_mask, forest_cover = predict_and_calculate(image, model)
+                total_forest_cover += forest_cover
+
+            # Display metrics
+            col1, col2, col3 = st.columns(3)
+
+            with col1:
+                st.markdown(f"""
+                <div class="metric-container">
+                    <div class="metric-label">Forest Coverage</div>
+                    <div class="metric-value">{forest_cover:.2f}%</div>
+                </div>
+                """, unsafe_allow_html=True)
+
+            with col2:
+                st.markdown(f"""
+                <div class="metric-container">
+                    <div class="metric-label">Non-Forest Area</div>
+                    <div class="metric-value">{100 - forest_cover:.2f}%</div>
+                </div>
+                """, unsafe_allow_html=True)
+
+            with col3:
+                forest_pixels = np.sum(forest_mask)
+                total_pixels = forest_mask.size
+                st.markdown(f"""
+                <div class="metric-container">
+                    <div class="metric-label">Forest Pixels</div>
+                    <div class="metric-value">{forest_pixels:,}/{total_pixels:,}</div>
+                </div>
+                """, unsafe_allow_html=True)
+
+            # Create and display visualization
+            fig = create_visualization(img_np, forest_mask, forest_cover)
+            st.pyplot(fig)
+            plt.close(fig)
+
+            # Add status indicator
+            if forest_cover >= 70:
+                status = "Excellent Forest Coverage"
+                color = "#4CAF50"
+            elif forest_cover >= 40:
+                status = "Moderate Forest Coverage"
+                color = "#FF9800"
+            else:
+                status = "Low Forest Coverage - Attention Required"
+                color = "#F44336"
+
+            st.markdown(f"""
+            <div style="background-color: {color}20; padding: 10px; border-radius: 5px; border-left: 4px solid {color};">
+                <strong>Assessment: {status}</strong>
+            </div>
+            """, unsafe_allow_html=True)
+
+            st.markdown("---")
+
+        # Summary statistics
+        if len(uploaded_files) > 1:
+            avg_forest_cover = total_forest_cover / len(uploaded_files)
+            st.markdown("### Summary Statistics")
+
+            summary_col1, summary_col2, summary_col3 = st.columns(3)
+
+            with summary_col1:
+                st.metric("Total Images Processed", len(uploaded_files))
+
+            with summary_col2:
+                st.metric("Average Forest Coverage", f"{avg_forest_cover:.2f}%")
+
+            with summary_col3:
+                st.metric("Total Forest Coverage", f"{total_forest_cover:.2f}%")
+
+    else:
+        # Show example information when no files uploaded
+        st.info("Please upload satellite images to begin forest cover analysis")
+
+        # Optional: Display example images if they exist
+        example_dir = Path("src")
+        example_images = list(example_dir.glob("image-*.png"))
+
+        if example_images:
+            with st.expander("View Example Images"):
+                cols = st.columns(min(3, len(example_images)))
+                for idx, img_path in enumerate(example_images[:3]):
+                    with cols[idx]:
+                        img = Image.open(img_path)
+                        st.image(img, caption=img_path.name, use_container_width=True)
+
+    # Footer
+    st.markdown("""
+    <div class="footer">
+        <strong>Forest Cover Assessment System</strong> | Powered by Deep Learning & Satellite Imagery Analysis<br>
+        For official use by authorized government personnel only<br>
+        © 2026 Forest Conservation Division
+    </div>
+    """, unsafe_allow_html=True)
+
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()