Upload README.md

README.md

@@ -1,166 +1,90 @@
----
-license: mit
-title: Construction Site Safety Analyzer
-sdk: gradio
-emoji: 🏢
-colorFrom: blue
-colorTo: green
-short_description: Enhance workplace safety and compliance with AI
-sdk_version: 5.1.0
----
-## 🏗️ Construction Site Safety Analyzer
+# 🏗️ Construction Site Safety Analyzer
 
-Enhance workplace safety and compliance with AI-powered image analysis using Llama 3.2 90B Vision and expert chat assistance.
+## Overview
 
-### Overview
+The **Construction Site Safety Analyzer** is a powerful tool designed to enhance workplace safety and compliance through AI-powered image and video analysis. Leveraging the capabilities of Llama 3.2 90B Vision and expert chat assistance, this application helps identify safety issues, categorize them, provide detailed descriptions, and suggest steps to resolve them.
 
-This application leverages the power of Groq's AI models to analyze construction site images, identify safety issues, and provide detailed descriptions along with recommended resolutions. The Gradio interface allows users to upload images and interact with the system through a chatbot, making it easy to ask questions and get answers regarding safety measures and regulations.
+## Features
 
-### Features
+### 1. Image Analysis
+- **Upload Multiple Images**: Easily upload multiple construction site images for comprehensive analysis.
+- **Automatic Image Resizing**: Ensures that images do not exceed API size limits while maintaining quality.
+- **Safety Hazard Identification**: Identifies potential safety hazards, categorizes them, and provides detailed descriptions.
+- **Resolution Suggestions**: Offers actionable steps to mitigate identified risks.
 
-- **Image Upload**: Users can upload construction site images either as a file path or a PIL Image object.
-- **AI Analysis**: The application uses advanced computer vision techniques to detect and categorize safety issues within the images.
-- **Chat Interaction**: A built-in chatbot provides detailed responses to questions related to the analyzed images, offering insights and guidance on safety measures and regulations.
-- **Custom CSS**: The interface is styled with custom CSS to enhance readability and usability.
+### 2. Video Analysis
+- **Upload Videos**: Upload videos to analyze specific frames for safety hazard identification.
+- **Key Frame Extraction**: Extracts key frames from videos at specified time points (default: start, middle, end).
+- **Detailed Analysis**: Provides detailed analysis for each extracted frame, similar to image analysis.
 
-### Installation
+### 3. Expert Chat Assistance
+- **Interactive Chat**: Engage in real-time conversations with an AI assistant specializing in construction site safety.
+- **Question-Based Analysis**: Ask questions about specific safety measures or regulations related to the analyzed hazards.
+- **Comprehensive Insights**: Receive detailed answers based on the initial analysis, enhancing understanding and decision-making.
 
-To run this application, you need to have Python installed on your system. Additionally, ensure that you have the required dependencies installed. You can install these dependencies using pip:
+## Getting Started
 
-```bash
-pip install gradio pillow groq-python
-```
+### Prerequisites
+- Python 3.8+
+- `pip` (Python package installer)
 
-### Environment Variables
-
-Before running the application, make sure to set the `GROQ_API_KEY` environment variable. This key is necessary for authenticating requests to the Groq API.
-
-```bash
-export GROQ_API_KEY=your_groq_api_key_here
-```
+### Installation
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/your-repo/construction-site-safety-analyzer.git
+   cd construction-site-safety-analyzer
+   ```
+
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Set up environment variables:
+   ```bash
+   export GROQ_API_KEY="your-groq-api-key"
+   ```
 
 ### Running the Application
-
-To launch the application, simply execute the main script:
-
+To launch the application, simply run the main script:
 ```bash
-python main.py
+python app.py
 ```
 
-The application will start a local server, and you can access it via your web browser at `http://localhost:7860`.
+This will start a local server, and you can access the application via your web browser at `http://localhost:7860`.
 
-### Code Explanation
+## Usage
 
-#### Imports and Setup
+1. **Upload Images/Videos**: Navigate to the "Upload Construction Site Images" or "Upload Construction Site Video" sections and select the appropriate files.
+2. **Analyze Safety Hazards**: Click the "🔍 Analyze Safety Hazards" button to initiate the analysis process.
+3. **View Analysis Results**: The safety analysis results will be displayed in the "Safety Analysis Results and Expert Chat" section.
+4. **Chat with the Assistant**: Engage in interactive conversations with the AI assistant to get more insights or ask questions about specific safety measures.
 
-The code begins by importing necessary libraries and setting up logging for debugging purposes. It also loads the `GROQ_API_KEY` from the environment variables and initializes a Groq client.
+## Requirements
 
-```python
-import os
-import base64
-import gradio as gr
-from PIL import Image
-import io
-import json
-from groq import Groq
-import logging
+The application requires the following Python packages:
+- `os`
+- `base64`
+- `gradio`
+- `PIL`
+- `io`
+- `json`
+- `groq`
+- `logging`
+- `cv2`
+- `numpy`
+- `traceback`
 
-# Set up logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-```
+These dependencies can be installed using `pip` as shown in the installation instructions.
 
-#### Helper Functions
-
-The `encode_image` function encodes an image into a base64 string, which is useful for sending images over APIs. The `analyze_construction_image` function handles the main logic of image analysis, including sending requests to the Groq API and processing the results.
-
-```python
-def encode_image(image):
-    try:
-        if isinstance(image, str):
-            with open(image, "rb") as image_file:
-                return base64.b64encode(image_file.read()).decode('utf-8')
-        elif isinstance(image, Image.Image):
-            buffered = io.BytesIO()
-            image.save(buffered, format="PNG")
-            return base64.b64encode(buffered.getvalue()).decode('utf-8')
-        else:
-            raise ValueError(f"Unsupported image type: {type(image)}")
-    except Exception as e:
-        logger.error(f"Error encoding image: {str(e)}")
-        raise
-
-def analyze_construction_image(image):
-    if image is None:
-        logger.warning("No image provided")
-        return [("No image uploaded", "Error: Please upload an image for analysis.")]
-    ...
-```
+## Contributing
 
-#### Gradio Interface
-
-The Gradio interface is created using the `gr.Blocks` context manager. It includes a form for uploading images, a button to trigger analysis, and a chatbot for displaying results and handling user queries.
-
-```python
-with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as iface:
-    gr.HTML(
-        """
-        <div class="container">
-            <div class="header">
-                <h1>🏗️ Construction Site Safety Analyzer</h1>
-            </div>
-            <p class="subheader">Enhance workplace safety and compliance with AI-powered image analysis using Llama 3.2 90B Vision and expert chat assistance.</p>
-        </div>
-        """
-    )
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            image_input = gr.Image(type="pil", label="Upload Construction Site Image", elem_classes="image-container")
-            analyze_button = gr.Button("🔍 Analyze Safety Hazards", elem_classes="analyze-button")
-        with gr.Column(scale=2):
-            with gr.Group(elem_classes="chat-container"):
-                chatbot = gr.Chatbot(label="Safety Analysis Results and Expert Chat", elem_classes="chatbot")
-                with gr.Row(elem_classes="input-row"):
-                    msg = gr.Textbox(
-                        label="Ask about safety measures or regulations",
-                        placeholder="E.g., 'What OSHA guidelines apply to this hazard?'",
-                        show_label=False,
-                        elem_classes="chat-input"
-                    )
-                    clear = gr.Button("🗑️ Clear", elem_classes="clear-button")
-
-    def update_chat(history, new_message):
-        history = history or []
-        history.append(new_message)
-        return history
-
-    analyze_button.click(
-        analyze_construction_image,
-        inputs=[image_input],
-        outputs=[chatbot],
-        postprocess=lambda x: update_chat(chatbot.value, x[0])
-    )
-
-    msg.submit(chat_about_image, [msg, chatbot], [msg, chatbot])
-    clear.click(lambda: None, None, chatbot, queue=False)
-
-    gr.HTML(
-        """
-        <div class="groq-badge">Powered by Groq</div>
-        """
-    )
-```
-
-#### Launching the App
+Contributions are welcome! Feel free to submit pull requests, report bugs, or suggest improvements.
 
-Finally, the application is launched with the `iface.launch()` method, which starts a local development server.
+## License
 
-```python
-if __name__ == "__main__":
-    iface.launch(debug=True)
-```
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-### Conclusion
+---
 
-This Construction Site Safety Analyzer is a powerful tool for enhancing workplace safety and compliance through AI-driven image analysis and expert chat assistance. With its intuitive interface and advanced capabilities, it helps users quickly identify and address potential hazards on construction sites.
+Built with ❤️ by [Your Name]