Upload README.md

README.md

@@ -1,85 +1,156 @@
----
-license: mit
-title: Construction Image Analyzer with Chat
-sdk: gradio
-emoji: 🏢
-colorFrom: blue
-colorTo: green
-short_description: AI Powered Snaging Tool
-sdk_version: 5.1.0
----
-## Construction Image Analyzer with Chat
+## 🏗️ 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
-This project is a web application built using Gradio that allows users to upload construction site images and receive automated analysis and suggestions for improvement. The application utilizes the Groq AI platform to process and interpret the images, providing detailed insights and actionable steps.
+
+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
-1. **Image Upload**: Users can upload construction site images directly through the web interface.
-2. **Automated Analysis**: The application uses advanced machine learning models to identify potential issues within the images, categorize them, and provide descriptions along with step-by-step solutions.
-3. **Interactive Chat**: Users can ask follow-up questions based on the initial analysis, and receive real-time responses from the AI assistant.
-4. **Logging and Error Handling**: Comprehensive logging and error handling ensure robust operation and easy troubleshooting.
+
+- **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.
 
 ### Installation
-To run this application, you need to have Python installed on your system. Follow these steps to install the required dependencies:
+
+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:
 
 ```bash
-pip install gradio pillow base64 io json groq logging
+pip install gradio pillow groq-python
 ```
 
-Additionally, you will need to obtain a `GROQ_API_KEY` from the Groq platform and set it as an environment variable:
+### 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
 ```
 
-### Usage
-1. **Launch the Application**:
-   Run the main script to start the Gradio interface:
+### Running the Application
 
-   ```bash
-   python your_script_name.py
-   ```
+To launch the application, simply execute the main script:
 
-2. **Access the Interface**:
-   Open a web browser and navigate to `http://localhost:7860`. You should see the Construction Image Analyzer interface.
+```bash
+python main.py
+```
 
-3. **Upload an Image**:
-   - Click on the "Upload Construction Image" button.
-   - Select or drag-and-drop an image file from your local machine.
+The application will start a local server, and you can access it via your web browser at `http://localhost:7860`.
 
-4. **Receive Analysis**:
-   - Once the image is uploaded, click the "Analyze Image" button.
-   - The application will display the analyzed results, including identified issues, categories, and suggested steps.
+### Code Explanation
 
-5. **Interact via Chat**:
-   - Use the text box below the chatbot to ask additional questions related to the image analysis.
-   - The AI assistant will respond in real-time with relevant information.
+#### Imports and Setup
 
-### Code Explanation
+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.
 
-#### Imports
-The code imports necessary libraries and modules, including Gradio for the web interface, Pillow for image processing, and Groq for AI inference.
+```python
+import os
+import base64
+import gradio as gr
+from PIL import Image
+import io
+import json
+from groq import Groq
+import logging
 
-#### Logging Setup
-Logging is configured to capture debug and error messages, which helps in monitoring and debugging the application.
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+```
 
-#### Environment Variable Check
-The script checks if the `GROQ_API_KEY` is set in the environment variables. If not, it logs an error and raises a `ValueError`.
+#### 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.")]
+    ...
+```
 
-#### Image Encoding Function
-The `encode_image` function converts an image (either a file path or a PIL Image object) to a Base64-encoded string.
+#### Gradio Interface
 
-#### Image Analysis Function
-The `analyze_construction_image` function handles the image analysis process. It encodes the image, sends it to the Groq API for analysis, and processes the response to extract and format the results.
+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>
+        """
+    )
+```
 
-#### Chat Function
-The `chat_about_image` function enables interactive chatting with the AI assistant. It constructs a conversation history and makes API calls to receive responses.
+#### Launching the App
 
-#### Gradio Interface
-The Gradio interface is created with components for uploading images, displaying analysis results, and interacting via chat. Events are linked to the corresponding functions to handle user actions.
+Finally, the application is launched with the `iface.launch()` method, which starts a local development server.
 
-#### Main Execution
-The script launches the Gradio interface when executed directly.
+```python
+if __name__ == "__main__":
+    iface.launch(debug=True)
+```
 
 ### Conclusion
-This project provides a powerful tool for construction site managers and inspectors to quickly assess and improve the quality of construction sites. By leveraging AI technology, it simplifies the inspection process and ensures timely resolution of potential issues.
+
+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.