Upload 10 files

Adding Project files

.gitignore

@@ -0,0 +1,178 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Model files
+models/*
+!models/.gitkeep

Dockerfile

@@ -0,0 +1,28 @@
+# Use an official Python base image
+FROM python:3.9-slim
+
+# Set environment variables
+ENV PORT 7860
+ENV PYTHONUNBUFFERED=1
+
+# Set workdir
+WORKDIR /app
+
+# Install system dependencies (if needed)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+# Copy the rest of your code
+COPY . .
+
+# Expose the port Streamlit will run on
+EXPOSE 7860
+
+# Run Streamlit on container start
+CMD streamlit run app.py --server.port $PORT --server.address 0.0.0.0 

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mahmoud Al Refaey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,84 @@
+# Land Cover Classification (Hugging Face Space)
+
+A web-based land cover classification system using a pretrained ResNet50 model and the EuroSAT dataset. This Space features a modern Streamlit interface for easy image upload, prediction, and visualization of land type probabilities.
+
+## 🚀 Demo
+
+[![Open in Spaces](https://huggingface.co/datasets/huggingface/badges/raw/main/open-in-spaces-sm.svg)](https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME)
+
+## Features
+
+- **Deep Learning Model**: Pretrained ResNet50 fine-tuned on EuroSAT satellite imagery.
+- **User-Friendly Web App**: Built with Streamlit for interactive image upload and real-time predictions.
+- **Class Visualization**: Displays prediction confidence for each land cover class.
+- **Modular Code**: Clean separation of model, data processing, and visualization logic.
+
+## How to Use
+
+1. **Upload a satellite image** (PNG, JPG, JPEG, TIFF).
+2. **Preview the image** and click "Run Classification".
+3. **View the predicted land cover class** and confidence scores.
+
+## Land Cover Classes
+
+| Index | Class Name             |
+|-------|------------------------|
+| 0     | AnnualCrop             |
+| 1     | Forest                 |
+| 2     | HerbaceousVegetation   |
+| 3     | Highway                |
+| 4     | Industrial             |
+| 5     | Pasture                |
+| 6     | PermanentCrop          |
+| 7     | Residential            |
+| 8     | River                  |
+| 9     | SeaLake                |
+
+## Project Structure
+
+```
+.
+├── app.py                # Streamlit web app
+├── model_handler.py      # Model loading and prediction logic
+├── data_processor.py     # Data preprocessing utilities
+├── config.py             # Configuration (class names, paths)
+├── requirements.txt      # Python dependencies
+├── models/               # Model files (see below)
+├── assets/               # Static images for the app
+├── Dockerfile            # Docker configuration for Hugging Face Spaces
+└── README.md             # This file
+```
+
+## Model Files
+
+The following files must be present in the `models/` directory:
+- `ResNet50_eurosat.h5`
+- `model.weights.best.keras`
+- `class_indices.npy`
+
+If you fork this Space, upload these files via the Hugging Face web interface if they are too large for git.
+
+## Deploying on Hugging Face Spaces
+
+### Docker Space Deployment
+
+1. **Create a new Space on Hugging Face:**
+   - Go to [Hugging Face Spaces](https://huggingface.co/spaces).
+   - Click **"Create new Space"**.
+   - Choose **SDK: Docker**.
+
+2. **Push your code:**
+   - Push your entire project (including the `Dockerfile`) to the Space.
+   - If your model files are too large for git, upload them via the Hugging Face web interface after the initial push.
+
+3. **Wait for the build:**
+   - Hugging Face will build and run your Docker container.
+   - Your Streamlit app will be available at the Space URL.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+*This Space is powered by [Streamlit](https://streamlit.io/) and [Hugging Face Spaces](https://huggingface.co/spaces).*

app.py

@@ -0,0 +1,182 @@
+import streamlit as st
+import sys
+import os
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+from PIL import Image
+import matplotlib.pyplot as plt
+import seaborn as sns
+import io
+import cv2
+from config import DATA_CONFIG, CLASS_NAMES
+
+# Add current directory to Python path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+
+from model_handler import ModelHandler
+from data_processor import DataProcessor
+from visualizer import Visualizer
+
+class WebApp:
+    def __init__(self):
+        self.model_handler = ModelHandler()
+        self.data_processor = DataProcessor()
+        self.visualizer = Visualizer()
+        
+        # Load model and class indices
+        if not self.model_handler.load_model():
+            st.error("Failed to load model. Please check if models/ResNet50_eurosat.h5 exists.")
+        if not self.model_handler.load_class_indices():
+            st.error("Failed to load class indices. Please check if models/class_indices.npy exists.")
+    
+    def main_page(self):
+        st.title("Project DEPI - Land Cover Classification")
+        st.caption("Welcome to the Land Cover Classification System")
+        
+        # Display welcome image
+        st.image("assets/satellite.jpg", use_column_width=True)
+        
+        # Image upload section
+        uploaded_image = self.upload()
+        
+        if uploaded_image is not None:
+            # Store the uploaded image in session state
+            st.session_state.uploaded_image = uploaded_image
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.subheader("Image Preview")
+                st.image(uploaded_image, use_column_width=True)
+            with col2:
+                st.subheader("Classification")
+                if st.button('Run Classification'):
+                    self.run_classification(uploaded_image)
+
+    def upload(self):
+        """Handle image upload"""
+        uploaded_file = st.file_uploader(
+            "Choose an image file",
+            type=DATA_CONFIG['allowed_formats']
+        )
+        return uploaded_file.read() if uploaded_file is not None else None
+
+    def run_classification(self, image_data):
+        """Run classification on uploaded image"""
+        try:
+            with st.spinner('Running classification...'):
+                prediction = self.model_handler.predict(image_data)
+                st.success(f"Classification Result: {prediction['class_name']}")
+                st.write(f"Confidence: {prediction['confidence']:.2%}")
+                # Use visualizer for confidence bar
+                class_names = [self.model_handler.class_indices.get(str(i), f"Class_{i}") 
+                              for i in range(len(prediction['all_predictions']))]
+                fig = self.visualizer.plot_confidence_bar(class_names, prediction['all_predictions'])
+                st.plotly_chart(fig, use_column_width=True)
+        except Exception as e:
+            st.error(f"Error during classification: {str(e)}")
+
+    def charts_page(self):
+        """Display various charts and visualizations"""
+        st.title("Charts and Visualizations")
+        
+        tab1, tab2 = st.tabs(["Model evaluation", "Image Analysis"])
+        
+        with tab1:
+            st.subheader("Model Performance")
+            st.title("Model Training Results")
+            st.image("assets/model_performance.jpg", caption="Training Progress Over Time", use_column_width=True)
+            with st.expander("Accuracy Analysis"):
+                st.markdown("""
+                - **Training Accuracy**: Shows how well the model learns from training data
+                - **Validation Accuracy**: Indicates real-world performance on unseen data
+                - **Ideal Scenario**: Both metrics should increase and stabilize at similar values
+                """)
+            with st.expander("Loss Analysis"):
+                st.markdown("""
+                - **Training Loss**: Measures error reduction during training
+                - **Validation Loss**: Tracks generalization error
+                - **Healthy Pattern**: Both should decrease steadily without significant divergence
+                """)
+            st.header("What This Means")
+            st.write("""
+            The model is learning properly without overfitting.
+            Both accuracy and loss show good progress.
+            You could stop training earlier when it stops improving.
+            """)
+        with tab2:
+            st.subheader("Image Analysis")
+            if 'uploaded_image' in st.session_state:
+                uploaded_image = st.session_state.uploaded_image
+                st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
+                try:
+                    img = Image.open(io.BytesIO(uploaded_image))
+                    img_array = np.array(img)
+                    # Use visualizer for RGB histograms
+                    st.subheader("RGB Color Histograms")
+                    figs = self.visualizer.plot_rgb_histograms(img_array)
+                    col1, col2, col3 = st.columns(3)
+                    for i, col in enumerate([col1, col2, col3]):
+                        with col:
+                            st.pyplot(figs[i])
+                    # Visualization selector
+                    analysis_type = st.selectbox(
+                        "Select Analysis Type",
+                        ["Image Statistics", "Edge Detection", "Intensity Map"]
+                    )
+                    if analysis_type == "Image Statistics":
+                        stats = self.visualizer.image_statistics(img_array)
+                        for key, value in stats.items():
+                            st.write(f"**{key}:** {value}")
+                    elif analysis_type == "Edge Detection":
+                        edges = self.visualizer.edge_detection(img_array)
+                        st.image(edges, caption="Edge Detection", use_column_width=True)
+                    elif analysis_type == "Intensity Map":
+                        fig = self.visualizer.intensity_map(img_array)
+                        st.plotly_chart(fig)
+                except Exception as e:
+                    st.error(f"Error processing image: {str(e)}")
+            else:
+                st.warning("Please upload an image in the main page first.")
+
+    def classes_page(self):
+        """Display detailed information about each class"""
+        st.title("Land Cover Classes")
+        
+        # List of (class_name, description)
+        class_info = [
+            ("AnnualCrop", "Agricultural areas where crops are planted and harvested within a single year."),
+            ("Forest", "Areas dominated by trees, forming a continuous canopy."),
+            ("HerbaceousVegetation", "Areas covered by non-woody plants and grasses."),
+            ("Highway", "Major roads and transportation infrastructure."),
+            ("Industrial", "Areas containing factories, warehouses, and industrial facilities."),
+            ("Pasture", "Land used for grazing livestock."),
+            ("PermanentCrop", "Agricultural areas with long-term crops like orchards and vineyards."),
+            ("Residential", "Areas containing houses and residential buildings."),
+            ("River", "Natural watercourses and their immediate surroundings."),
+            ("SeaLake", "Large bodies of water including seas and lakes.")
+        ]
+        
+        cols = st.columns(2)
+        for idx, (name, desc) in enumerate(class_info):
+            with cols[idx % 2]:
+                with st.expander(f"{name}"):
+                    st.write(desc)
+
+# Initialize and run the app
+if __name__ == "__main__":
+    app = WebApp()
+    
+    # Navigation
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio("Go to", ["Home", "Charts", "Classes"])
+    
+    if page == "Home":
+        app.main_page()
+    elif page == "Charts":
+        app.charts_page()
+    elif page == "Classes":
+        app.classes_page()

config.py

@@ -0,0 +1,31 @@
+"""
+Configuration file for the Land Cover Classification System
+"""
+
+# EuroSAT class names
+CLASS_NAMES = {
+    '0': 'AnnualCrop',
+    '1': 'Forest',
+    '2': 'HerbaceousVegetation',
+    '3': 'Highway',
+    '4': 'Industrial',
+    '5': 'Pasture',
+    '6': 'PermanentCrop',
+    '7': 'Residential',
+    '8': 'River',
+    '9': 'SeaLake'
+}
+
+# Model configuration
+MODEL_CONFIG = {
+    'input_shape': (64, 64, 3),
+    'model_path': 'models/ResNet50_eurosat.h5',
+    'best_model_path': 'models/model.weights.best.keras',
+    'indices_path': 'models/class_indices.npy'
+}
+
+# Data processing configuration
+DATA_CONFIG = {
+    'allowed_formats': ['png', 'jpg', 'jpeg', 'tiff'],
+    'max_image_size': (1024, 1024)  # Maximum dimensions for uploaded images
+} 

data_processor.py

@@ -0,0 +1,99 @@
+import os
+import hashlib
+from PIL import Image
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from sklearn.model_selection import StratifiedShuffleSplit
+import pandas as pd
+import io
+
+class DataProcessor:
+    def __init__(self):
+        self.input_shape = (64, 64, 3)  # Default input shape for EuroSAT
+        
+    def preprocess_for_inference(self, image):
+        """Preprocess a single image for model inference"""
+        if isinstance(image, bytes):
+            # Convert bytes to PIL Image
+            image = Image.open(io.BytesIO(image))
+            
+            # Convert RGBA to RGB if necessary
+            if image.mode == 'RGBA':
+                image = image.convert('RGB')
+            
+            # Convert PIL Image to numpy array
+            image = np.array(image)
+            
+            # Convert to float32 and normalize
+            image = image.astype(np.float32) / 255.0
+            
+            # Resize image
+            image = tf.image.resize(image, (self.input_shape[0], self.input_shape[1]))
+            
+            # Add batch dimension
+            image = tf.expand_dims(image, 0)
+            
+            return image
+        else:
+            raise ValueError("Input must be bytes (image file content)")
+
+    @staticmethod
+    def check_image_size(image_path):
+        """Check dimensions of an image file"""
+        with Image.open(image_path) as img:
+            return img.size
+
+    @staticmethod
+    def check_image_dimensions(dataset_path):
+        """Check dimensions of all images in dataset"""
+        all_dimensions = set()
+        for folder in os.listdir(dataset_path):
+            class_path = os.path.join(dataset_path, folder)
+            if os.path.isdir(class_path):
+                for image_name in os.listdir(class_path):
+                    image_path = os.path.join(class_path, image_name)
+                    width, height = DataProcessor.check_image_size(image_path)
+                    all_dimensions.add((width, height))
+        return all_dimensions
+
+    @staticmethod
+    def get_data_generators():
+        """Get data generators for training and validation"""
+        train_gen = ImageDataGenerator(
+            rescale=1./255,
+            rotation_range=60,
+            width_shift_range=0.2,
+            height_shift_range=0.2,
+            shear_range=0.2,
+            zoom_range=0.2,
+            horizontal_flip=True,
+            vertical_flip=True
+        )
+
+        test_gen = ImageDataGenerator(rescale=1./255)
+        
+        return train_gen, test_gen
+
+    @staticmethod
+    def get_image_hash(image_path):
+        """Calculate MD5 hash of an image file"""
+        with open(image_path, "rb") as f:
+            return hashlib.md5(f.read()).hexdigest()
+
+    @staticmethod
+    def check_duplicates(dataset_path):
+        """Find duplicate images in dataset"""
+        seen_hashes = set()
+        duplicates = []
+        for folder in os.listdir(dataset_path):
+            class_path = os.path.join(dataset_path, folder)
+            if os.path.isdir(class_path):
+                for image_name in os.listdir(class_path):
+                    image_path = os.path.join(class_path, image_name)
+                    img_hash = DataProcessor.get_image_hash(image_path)
+                    if img_hash in seen_hashes:
+                        duplicates.append(image_path)
+                    else:
+                        seen_hashes.add(img_hash)
+        return duplicates

model_handler.py

@@ -0,0 +1,116 @@
+import tensorflow as tf
+from tensorflow.keras.models import load_model, Model
+from tensorflow.keras.applications import ResNet50
+from tensorflow.keras.layers import Flatten, Dense, Dropout
+from tensorflow.keras.optimizers import Adam
+import numpy as np
+import os
+from PIL import Image
+import io
+from config import CLASS_NAMES, MODEL_CONFIG
+
+class ModelHandler:
+    def __init__(self):
+        self.model = None
+        self.class_indices = CLASS_NAMES
+        self.input_shape = MODEL_CONFIG['input_shape']
+        
+    def load_model(self, model_path=MODEL_CONFIG['model_path']):
+        """Load the pre-trained ResNet50 model"""
+        try:
+            self.model = load_model(model_path)
+            return True
+        except Exception as e:
+            print(f"Error loading model: {str(e)}")
+            return False
+            
+    def load_class_indices(self, indices_path=MODEL_CONFIG['indices_path']):
+        """Load class indices mapping"""
+        try:
+            # Load indices from file if it exists
+            if os.path.exists(indices_path):
+                loaded_indices = np.load(indices_path, allow_pickle=True).item()
+                # Update class indices with loaded values
+                self.class_indices.update(loaded_indices)
+            return True
+        except Exception as e:
+            print(f"Error loading class indices: {str(e)}")
+            return False
+            
+    def preprocess_image(self, image):
+        """Preprocess image for model input"""
+        if isinstance(image, bytes):
+            # Convert bytes to PIL Image
+            image = Image.open(io.BytesIO(image))
+            
+            # Convert RGBA to RGB if necessary
+            if image.mode == 'RGBA':
+                image = image.convert('RGB')
+            
+            # Convert PIL Image to numpy array
+            image = np.array(image)
+            
+            # Convert to float32 and normalize
+            image = image.astype(np.float32) / 255.0
+            
+            # Resize image
+            image = tf.image.resize(image, (self.input_shape[0], self.input_shape[1]))
+            
+            # Add batch dimension
+            image = tf.expand_dims(image, 0)
+            
+            return image
+        else:
+            raise ValueError("Input must be bytes (image file content)")
+        
+    def predict(self, image):
+        """Make prediction on input image"""
+        if self.model is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+            
+        # Preprocess image
+        processed_image = self.preprocess_image(image)
+        
+        # Get prediction
+        predictions = self.model.predict(processed_image)
+        
+        # Get top prediction
+        top_pred_idx = np.argmax(predictions[0])
+        confidence = predictions[0][top_pred_idx]
+        
+        # Get class name from indices
+        class_name = self.class_indices.get(str(top_pred_idx), f"Class_{top_pred_idx}")
+        
+        return {
+            'class_name': class_name,
+            'confidence': float(confidence),
+            'all_predictions': predictions[0].tolist()
+        }
+
+    @staticmethod
+    def compile_model(input_shape, n_classes, optimizer, fine_tune=None):
+        """Compile a new ResNet50 model (for training)"""
+        conv_base = ResNet50(include_top=False,
+                            weights='imagenet',
+                            input_shape=input_shape)
+
+        top_model = conv_base.output
+        top_model = Flatten()(top_model)
+        top_model = Dense(2048, activation='relu')(top_model)
+        top_model = Dropout(0.2)(top_model)
+        output_layer = Dense(n_classes, activation='softmax')(top_model)
+
+        model = Model(inputs=conv_base.input, outputs=output_layer)
+
+        if isinstance(fine_tune, int):
+            for layer in conv_base.layers[fine_tune:]:
+                layer.trainable = True
+        else:
+            for layer in conv_base.layers:
+                layer.trainable = False
+
+        model.compile(optimizer=optimizer,
+                     loss='categorical_crossentropy',
+                     metrics=['categorical_accuracy'])
+
+        return model

requirements.txt

@@ -0,0 +1,12 @@
+tensorflow>=2.0.0
+streamlit>=1.0.0
+plotly>=4.14.3
+pandas>=1.2.0
+numpy>=1.19.2
+Pillow>=8.0.0
+scikit-learn>=0.24.0
+seaborn>=0.11.0
+matplotlib>=3.3.0
+python-dotenv>=0.19.0
+tqdm>=4.62.0
+opencv-python>=4.5.0

visualizer.py

@@ -0,0 +1,98 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+import plotly.express as px
+import cv2
+import pandas as pd
+from PIL import Image
+import io
+import streamlit as st
+
+class Visualizer:
+    def __init__(self):
+        pass
+        
+    def plot_confusion_matrix(self, cm, labels):
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
+        plt.title('Confusion Matrix')
+        plt.ylabel('True Label')
+        plt.xlabel('Predicted Label')
+        return plt
+        
+    def plot_training_history(self, history):
+        plt.figure(figsize=(12, 4))
+        
+        plt.subplot(1, 2, 1)
+        plt.plot(history.history['accuracy'], label='Training Accuracy')
+        plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+        plt.title('Model Accuracy')
+        plt.xlabel('Epoch')
+        plt.ylabel('Accuracy')
+        plt.legend()
+        
+        plt.subplot(1, 2, 2)
+        plt.plot(history.history['loss'], label='Training Loss')
+        plt.plot(history.history['val_loss'], label='Validation Loss')
+        plt.title('Model Loss')
+        plt.xlabel('Epoch')
+        plt.ylabel('Loss')
+        plt.legend()
+        
+        return plt
+
+    def plot_confidence_bar(self, class_names, predictions):
+        df = pd.DataFrame({
+            'Class': class_names,
+            'Confidence': predictions
+        }).sort_values('Confidence', ascending=False)
+        fig = px.bar(df, 
+                    x='Class', 
+                    y='Confidence',
+                    title='Classification Confidence Scores',
+                    labels={'Confidence': 'Confidence Score'},
+                    color='Confidence',
+                    color_continuous_scale='Viridis')
+        fig.update_layout(
+            xaxis_title="Land Cover Class",
+            yaxis_title="Confidence Score",
+            yaxis_tickformat='.1%',
+            showlegend=False
+        )
+        return fig
+
+    def plot_rgb_histograms(self, img_array):
+        colors = ['Red', 'Green', 'Blue']
+        figs = []
+        for i, color in enumerate(colors):
+            fig, ax = plt.subplots()
+            histogram = np.histogram(img_array[:,:,i], bins=256, range=(0,256))[0]
+            ax.plot(histogram, color=color.lower(), alpha=0.8)
+            ax.set_title(f"{color} Channel")
+            ax.set_xlabel("Pixel Intensity")
+            ax.set_ylabel("Frequency")
+            figs.append(fig)
+        return figs
+
+    def image_statistics(self, img_array):
+        stats = {
+            "Mean Brightness": float(np.mean(img_array)),
+            "Standard Deviation": float(np.std(img_array)),
+            "Min Value": int(np.min(img_array)),
+            "Max Value": int(np.max(img_array)),
+            "Image Size": f"{img_array.shape[1]}x{img_array.shape[0]}",
+            "Channels": img_array.shape[2]
+        }
+        return stats
+
+    def edge_detection(self, img_array):
+        gray = np.mean(img_array, axis=2).astype(np.uint8)
+        edges = cv2.Canny(gray, 100, 200)
+        return edges
+
+    def intensity_map(self, img_array):
+        gray = np.mean(img_array, axis=2)
+        fig = px.imshow(gray, 
+                        title="Intensity Map",
+                        color_continuous_scale='viridis')
+        return fig