Update app.py

app.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from PIL import Image, ImageEnhance, ImageStat
+from PIL import Image, ImageEnhance
 import os
 from dotenv import load_dotenv
 from simple_salesforce import Salesforce
@@ -8,11 +8,18 @@ import hashlib
 import shutil
 import base64
 import pytz
-import time
-import statistics
+import logging
+
+# Setup logging
+logging.basicConfig(
+    filename="construction_analyzer.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
 
 # Load environment variables
-print("Loading environment variables at", datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%Y-%m-%d %H:%M:%S IST"))
+logging.info("Loading environment variables")
 load_dotenv()
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
@@ -20,55 +27,79 @@ SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
 
 # Validate Salesforce credentials
 if not all([SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN]):
+    logging.error("Missing Salesforce credentials")
     raise ValueError("Missing Salesforce credentials. Set SF_USERNAME, SF_PASSWORD, and SF_SECURITY_TOKEN in environment variables.")
-print("Salesforce credentials validated successfully.")
+logging.info("Salesforce credentials validated successfully")
 
 # Initialize Salesforce connection
 try:
-    print("Attempting Salesforce connection at", datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%Y-%m-%d %H:%M:%S IST"))
+    logging.info("Attempting Salesforce connection")
     sf = Salesforce(
         username=SF_USERNAME,
         password=SF_PASSWORD,
         security_token=SF_SECURITY_TOKEN,
         domain='login'
     )
-    print("Salesforce connection established successfully.")
+    logging.info("Salesforce connection established successfully")
 except Exception as e:
-    print(f"Salesforce connection failed: {str(e)}")
+    logging.error(f"Salesforce connection failed: {str(e)}")
     raise
 
-print("Initializing application at", datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%Y-%m-%d %H:%M:%S IST"))
-
-# Updated Milestone Percentages
-milestone_percentage_map = {
-    "Excavation and Foundation": 10,
-    "Structural Framework": 40,
-    "Roofing": 70,
-    "Exterior Work": 85,
-    "Interior Work": 95,
-    "Final Completion": 100
+# Milestone definitions with completed and pending tasks
+milestone_data = {
+    "Excavation and Foundation": {
+        "percentage": 10,
+        "completed": ["Site clearing", "Excavation", "Foundation pouring"],
+        "pending": ["Structural framework", "Roofing", "Exterior work", "Interior work", "Final inspection"]
+    },
+    "Structural Framework": {
+        "percentage": 40,
+        "completed": ["Site clearing", "Excavation", "Foundation pouring", "Structural columns and beams"],
+        "pending": ["Roofing", "Exterior work", "Interior work", "Final inspection"]
+    },
+    "Roofing": {
+        "percentage": 70,
+        "completed": ["Site clearing", "Excavation", "Foundation pouring", "Structural columns and beams", "Roof installation"],
+        "pending": ["Exterior work", "Interior work", "Final inspection"]
+    },
+    "Exterior Work": {
+        "percentage": 85,
+        "completed": ["Site clearing", "Excavation", "Foundation pouring", "Structural columns and beams", "Roof installation", "Exterior walls", "Windows and doors"],
+        "pending": ["Interior work", "Final inspection"]
+    },
+    "Interior Work": {
+        "percentage": 95,
+        "completed": ["Site clearing", "Excavation", "Foundation pouring", "Structural columns and beams", "Roof installation", "Exterior walls", "Windows and doors", "Interior plumbing", "Electrical work", "Drywall and painting"],
+        "pending": ["Final inspection"]
+    },
+    "Final Completion": {
+        "percentage": 100,
+        "completed": ["Site clearing", "Excavation", "Foundation pouring", "Structural columns and beams", "Roof installation", "Exterior walls", "Windows and doors", "Interior plumbing", "Electrical work", "Drywall and painting", "Final inspection"],
+        "pending": []
+    }
 }
 
-# Adjust the timezone to your local timezone
+# Adjust the timezone to Asia/Kolkata
 local_timezone = pytz.timezone("Asia/Kolkata")
 
-# Enhanced AI model to simulate Grok LLM
+# Enhanced mock AI model simulating Grok-like analysis
 def mock_ai_model(image):
+    logging.info("Analyzing image for construction progress")
     img = image.convert("RGB")
     max_size = 1024
     img.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
 
     # Enhance contrast and brightness for feature detection
-    enhancer_contrast = ImageEnhance.Contrast(img)
-    img_enhanced = enhancer_contrast.enhance(1.5)
-    enhancer_brightness = ImageEnhance.Brightness(img_enhanced)
-    img_enhanced = enhancer_brightness.enhance(1.2)
+    enhancer = ImageEnhance.Contrast(img)
+    img_enhanced = enhancer.enhance(2.0)
+    enhancer = ImageEnhance.Brightness(img_enhanced)
+    img_enhanced = enhancer.enhance(1.2)
 
-    # Analyze image statistics
-    stats = ImageStat.Stat(img_enhanced)
-    mean_color = stats.mean  # Average RGB values
-    stddev_color = stats.stddev  # Standard deviation for color variation
-    total_pixels = img_enhanced.size[0] * img_enhanced.size[1]
+    # Analyze image features
+    img_data = list(img_enhanced.getdata())
+    total_pixels = len(img_data)
+    brightness_avg = sum(sum(pixel) / 3 for pixel in img_data) / total_pixels
+    color_variation = max(max(pixel) - min(pixel) for pixel in img_data)
 
     # Edge detection
     edge_count = 0
@@ -77,73 +108,65 @@ def mock_ai_model(image):
         for y in range(height - 1):
             r, g, b = img_enhanced.getpixel((x, y))
             r_next, g_next, b_next = img_enhanced.getpixel((x + 1, y + 1))
-            if abs(r - r_next) > 60 or abs(g - g_next) > 60 or abs(b - b_next) > 60:
+            if abs(r - r_next) > 50 or abs(g - g_next) > 50 or abs(b - b_next) > 50:
                 edge_count += 1
-    edge_ratio = edge_count / total_pixels
+    edge_ratio = edge_count / (width * height)
 
-    # Color distribution analysis
-    color_variation = sum(stddev_color) / 3  # Average standard deviation across RGB
-    brightness_avg = sum(mean_color) / 3  # Average brightness
-
-    # Simulate Grok's reasoning for milestone detection
-    reasoning = []
-    milestone = "Excavation and Foundation"  # Default
-    confidence_score = 0.85
-    percent_complete = milestone_percentage_map[milestone]
-
-    # Rules to simulate Grok's intelligent analysis
-    if brightness_avg > 220 and color_variation < 10 and edge_ratio < 0.03:
+    # Simulate Grok-like reasoning for milestone detection
+    if brightness_avg > 220 and color_variation < 15 and edge_ratio < 0.05:
         milestone = "Final Completion"
-        confidence_score = 0.95
-        reasoning.append("The image shows high brightness, low color variation, and minimal edges, indicating a finished, polished construction site.")
-    elif edge_ratio > 0.2 and color_variation > 50:
-        milestone = "Excavation and Foundation"
-        confidence_score = 0.90
-        reasoning.append("High edge density and significant color variation suggest an early-stage site with exposed earth and equipment.")
-    elif mean_color[2] > 150 and edge_ratio < 0.15:  # High blue (sky) and moderate edges
-        milestone = "Roofing"
-        confidence_score = 0.88
-        reasoning.append("Presence of blue tones (likely sky) and moderate edges indicate roofing stage with open structures.")
-    elif color_variation > 30 and edge_ratio < 0.1:
-        milestone = "Exterior Work"
-        confidence_score = 0.87
-        reasoning.append("Moderate color variation and low edges suggest exterior finishing, like painting or cladding.")
-    elif brightness_avg > 180 and color_variation < 20:
+        confidence = 0.95
+    elif brightness_avg > 180 and edge_ratio < 0.1:
         milestone = "Interior Work"
-        confidence_score = 0.89
-        reasoning.append("High brightness and low color variation indicate interior work with finished surfaces.")
-    else:
+        confidence = 0.90
+    elif brightness_avg > 150 and edge_ratio < 0.2:
+        milestone = "Exterior Work"
+        confidence = 0.88
+    elif brightness_avg > 120 and edge_ratio < 0.3:
+        milestone = "Roofing"
+        confidence = 0.85
+    elif brightness_avg > 90 and edge_ratio < 0.4:
         milestone = "Structural Framework"
-        confidence_score = 0.86
-        reasoning.append("Defaulting to structural framework due to mixed features, likely indicating concrete or steel structures.")
+        confidence = 0.82
+    else:
+        milestone = "Excavation and Foundation"
+        confidence = 0.80
 
-    percent_complete = milestone_percentage_map[milestone]
-    reasoning_str = " ".join(reasoning)
-    return milestone, percent_complete, confidence_score, reasoning_str
+    completed_tasks = milestone_data[milestone]["completed"]
+    pending_tasks = milestone_data[milestone]["pending"]
+    percentage = milestone_data[milestone]["percentage"]
+    
+    logging.info(f"Image analyzed: Milestone={milestone}, Percentage={percentage}, Confidence={confidence}")
+    return milestone, percentage, confidence, completed_tasks, pending_tasks
 
-# Image processing and Salesforce upload for multiple images
+# Process images and upload to Salesforce
 def process_image(images, project_name, project_type):
+    logging.info(f"Processing {len(images)} images for project {project_name}")
     try:
         if not images:
-            return "<p style='color: red;'>Error: Please upload at least one image to proceed.</p>", "Pending", "", "", 0
+            logging.warning("No images uploaded")
+            return "<p style='color: red;'>Error: Please upload at least one image.</p>", "Pending", "", "", 0
 
         if not project_name:
+            logging.warning("Project name missing")
             return "<p style='color: red;'>Error: Project Name is required.</p>", "Pending", "", "", 0
 
         results = []
         image_urls = []
-        milestone_confidences = []
         all_percentages = []
         all_milestones = set()
+        all_completed_tasks = set()
+        all_pending_tasks = set()
         dominant_milestone = None
         dominant_image_url = None
-        all_reasonings = []
+        max_confidence = 0
 
         for idx, image_path in enumerate(images):
             try:
                 img = Image.open(image_path)
-                milestone, percent_complete, confidence_score, reasoning = mock_ai_model(img)
+                milestone, percent_complete, confidence, completed_tasks, pending_tasks = mock_ai_model(img)
 
+                # Save image locally
                 upload_dir = "public_uploads"
                 os.makedirs(upload_dir, exist_ok=True)
                 unique_id = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -151,6 +174,7 @@ def process_image(images, project_name, project_type):
                 saved_image_path = os.path.join(upload_dir, image_filename)
                 shutil.copy(image_path, saved_image_path)
 
+                # Upload to Salesforce
                 with open(saved_image_path, 'rb') as image_file:
                     image_data = base64.b64encode(image_file.read()).decode('utf-8')
 
@@ -165,32 +189,44 @@ def process_image(images, project_name, project_type):
                     content_version_id = content_version_result['id']
                     file_url = f"https://sathkruthatechsolutionspri8-dev-ed.develop.lightning.force.com/{content_version_id}"
                     image_urls.append(file_url)
+                    logging.info(f"Image {idx+1} uploaded to Salesforce: {file_url}")
                 except Exception as e:
+                    logging.error(f"Image {idx+1} upload failed: {str(e)}")
                     results.append(f"Image {idx+1}: Failed to upload to Salesforce - {str(e)}")
-                    all_reasonings.append(f"Error: Failed to upload image {idx+1}.")
                     continue
 
-                if percent_complete > (all_percentages[0] if all_percentages else -1):  # For dominant milestone
+                if percent_complete > (all_percentages[0] if all_percentages else -1):
                     dominant_milestone = milestone
                     dominant_image_url = file_url
 
                 all_percentages.append(percent_complete)
                 all_milestones.add(milestone)
-                milestone_confidences.append((milestone, confidence_score))
-                all_reasonings.append(f"Image {idx+1}: {milestone} - {percent_complete}% completion (Confidence: {confidence_score}). Reasoning: {reasoning}")
-                results.append(f"Image {idx+1}: {milestone} - {percent_complete}% completion (Confidence: {confidence_score})")
+                all_completed_tasks.update(completed_tasks)
+                all_pending_tasks.update(pending_tasks)
+                if confidence > max_confidence:
+                    max_confidence = confidence
+
+                results.append(
+                    f"Image {idx+1}: {milestone} - {percent_complete}% completion (Confidence: {confidence})<br>"
+                    f"<strong>Completed:</strong> {', '.join(completed_tasks)}<br>"
+                    f"<strong>Pending:</strong> {', '.join(pending_tasks) if pending_tasks else 'None'}"
+                )
 
             except Exception as e:
+                logging.error(f"Image {idx+1} processing failed: {str(e)}")
                 results.append(f"Image {idx+1}: Error processing image - {str(e)}")
-                all_reasonings.append(f"Error: Failed to process image {idx+1} - {str(e)}")
                 continue
 
         if not results:
+            logging.warning("No images processed successfully")
             return "<p style='color: red;'>Error: No images were successfully processed.</p>", "Failure", "", "", 0
 
-        total_percent_complete = round(statistics.mean(all_percentages), 2) if all_percentages else 0
+        total_percent_complete = round(sum(all_percentages) / len(all_percentages), 2)
         all_milestones_str = ", ".join(all_milestones)
+        all_completed_tasks_str = ", ".join(sorted(all_completed_tasks))
+        all_pending_tasks_str = ", ".join(sorted(all_pending_tasks)) if all_pending_tasks else "None"
 
+        # Create Salesforce record
         now = datetime.now(local_timezone)
         local_time = now.strftime("%Y-%m-%dT%H:%M:%S") + now.strftime("%z")[:-2] + ":" + now.strftime("%z")[-2:]
 
@@ -201,43 +237,52 @@ def process_image(images, project_name, project_type):
             "Current_Milestone__c": all_milestones_str,
             "Last_Updated_On__c": local_time,
             "Upload_Status__c": "Success",
-            "Comments__c": f"Project {project_name} with {total_percent_complete}% completion",
+            "Comments__c": (
+                f"Project {project_name} at {total_percent_complete}% completion. "
+                f"Completed tasks: {all_completed_tasks_str}. "
+                f"Pending tasks: {all_pending_tasks_str}."
+            ),
             "Last_Updated_Image__c": dominant_image_url or ""
         }
 
         try:
             sf.Construction__c.create(record)
+            logging.info(f"Salesforce record created for project {project_name}")
         except Exception as e:
+            logging.error(f"Failed to create Salesforce record: {str(e)}")
             return f"<p style='color: red;'>Error: Failed to update Salesforce - {str(e)}</p>", "Failure", "", "", 0
 
-        # Grok-like conversational summary
-        grok_summary = f"Hello! I've analyzed the images for your project '{project_name}' ({project_type}). Here's what I found:\n"
-        grok_summary += "\n".join(all_reasonings)
-        grok_summary += f"\n\nOverall, the project is approximately {total_percent_complete}% complete, based on an average of the analyzed images. The milestones detected include: {all_milestones_str}. The image with the highest completion ({dominant_milestone}) has been stored in Salesforce for reference. Let me know if you'd like further insights or have more images to analyze!"
-
+        # Format output
         output_html = "<div class='output'>"
         output_html += "<h3>Processing Results:</h3><ul>"
         for result in results:
-            if 'Error' in result:
+            if 'Error' in result or 'Failed' in result:
                 output_html += f"<li class='error'>{result}</li>"
             else:
                 output_html += f"<li class='success'>{result}</li>"
         output_html += "</ul>"
-        output_html += f"<p><strong>Project Record Created:</strong> {project_name} (Total: {total_percent_complete}%)</p>"
-        output_html += f"<p><strong>Grok's Analysis:</strong> {grok_summary}</p>"
-        output_html += f"<p><strong>Note:</strong> Only the image with the highest completion percentage is stored in Salesforce due to field length constraints.</p>"
+        output_html += f"<h3>Project Summary:</h3>"
+        output_html += f"<p><strong>Project:</strong> {project_name} ({project_type})</p>"
+        output_html += f"<p><strong>Total Completion:</strong> {total_percent_complete}%</p>"
+        output_html += f"<p><strong>Milestones Detected:</strong> {all_milestones_str}</p>"
+        output_html += f"<p><strong>Completed Tasks:</strong> {all_completed_tasks_str}</p>"
+        output_html += f"<p><strong>Pending Tasks:</strong> {all_pending_tasks_str}</p>"
+        output_html += f"<p><strong>Max Confidence:</strong> {max_confidence}</p>"
+        output_html += f"<p><strong>Note:</strong> Only the image with the highest completion percentage is stored in Salesforce.</p>"
         output_html += "</div>"
 
-        return output_html, "Success", "", f"Max Confidence: {max([conf for _, conf in milestone_confidences], default=0)}", f"{total_percent_complete}%"
+        return output_html, "Success", "", f"Max Confidence: {max_confidence}", f"{total_percent_complete}%"
 
     except Exception as e:
+        logging.error(f"Processing failed: {str(e)}")
         return f"<p style='color: red;'>Error: {str(e)}</p>", "Failure", "", "", "0%"
 
-# Gradio UI with updated new styling
+# Gradio UI
 with gr.Blocks(css="""
     .gradio-container {
         background-color: #f9f9f9;
         font-family: 'Roboto', sans-serif;
+        padding: 20px;
     }
     .title {
         color: #34495e;
@@ -249,8 +294,10 @@ with gr.Blocks(css="""
     }
     .gradio-row {
         text-align: center;
+        max-width: 800px;
+        margin: 0 auto;
     }
-    .gradio-container .output {
+    .output {
         text-align: left;
         margin-top: 20px;
         padding: 30px;
@@ -261,32 +308,32 @@ with gr.Blocks(css="""
         margin-left: auto;
         margin-right: auto;
     }
-    .gradio-container .output h3 {
+    .output h3 {
         color: #2c3e50;
         font-size: 22px;
         font-weight: bold;
         margin-bottom: 20px;
     }
-    .gradio-container .output ul {
+    .output ul {
         list-style-type: none;
         padding: 0;
     }
-    .gradio-container .output li {
+    .output li {
         padding: 14px;
         margin-bottom: 18px;
         border-radius: 10px;
         font-size: 16px;
         transition: background-color 0.3s ease;
     }
-    .gradio-container .output li.success {
+    .output li.success {
         background-color: #27ae60;
         color: white;
     }
-    .gradio-container .output li.error {
+    .output li.error {
         background-color: #e74c3c;
         color: white;
     }
-    .gradio-container .button {
+    .button {
         display: block;
         margin: 25px auto;
         background-color: #3498db;
@@ -298,23 +345,24 @@ with gr.Blocks(css="""
         font-size: 18px;
         transition: background-color 0.3s ease;
     }
-    .gradio-container .button:hover {
+    .button:hover {
         background-color: #2980b9;
     }
-    .gradio-container .input {
+    .input {
         text-align: center;
+        max-width: 800px;
+        margin: 0 auto;
     }
 """) as demo:
-    gr.Markdown("<h1 class='title'>Construction Progress Analyzer (Powered by Grok-like AI)</h1>")
-    
+    gr.Markdown("<h1 class='title'>Construction Progress Analyzer</h1>")
     with gr.Row():
         project_type_input = gr.Dropdown(label="Project Type", choices=["House", "Apartment"], value="House")
         project_name_input = gr.Textbox(label="Project Name (Required)", placeholder="e.g. Project_12345")
-        
+    
     image_input = gr.File(
         file_count="multiple",
         file_types=["image"],
-        label="Upload Construction Site Photos (JPG/PNG, ≤ 20MB each)"
+        label="Upload Construction Site Photos (JPG/PNG, ≤20MB each)"
     )
     submit_button = gr.Button("Process Images")
     output_html = gr.HTML(label="Result")
@@ -325,12 +373,5 @@ with gr.Blocks(css="""
         outputs=[output_html]
     )
 
-print("Launching Gradio interface at", datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%Y-%m-%d %H:%M:%S IST"))
-try:
-    demo.launch(share=True, debug=True)  # Block and enable debug mode
-    print("Gradio interface launched successfully.")
-    while True:  # Keep the script alive
-        time.sleep(10)
-except Exception as e:
-    print(f"Failed to launch Gradio interface: {str(e)}")
-    raise
+logging.info("Launching Gradio interface")
+demo.launch()