Update app.py

app.py

@@ -12,19 +12,13 @@ import base64
 import io
 import logging
 
-# Set up logging to debug file writing issues
+# Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Initialize PaddleOCR once with updated parameters
 ocr_model = PaddleOCR(use_textline_orientation=True, lang='en')
 
 def analyze_uv_coverage(img, brightness_threshold=150, kernel_size=5, apply_blur=True, adaptive_thresh=False):
-    """
-    Analyze UV sterilization coverage by thresholding the grayscale image.
-    Optional adaptive thresholding and Gaussian blur for noise reduction.
-    Morphological operations clean the mask for better accuracy.
-    """
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
     if apply_blur:
@@ -39,18 +33,14 @@ def analyze_uv_coverage(img, brightness_threshold=150, kernel_size=5, apply_blur
     else:
         _, binary_mask = cv2.threshold(gray, brightness_threshold, 255, cv2.THRESH_BINARY)
 
-    # Morphological opening (erosion followed by dilation) to remove noise
     kernel = np.ones((kernel_size, kernel_size), np.uint8)
     binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_OPEN, kernel, iterations=1)
-
-    # Morphological closing (dilation followed by erosion) to close small holes inside foreground
     binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
 
     total_pixels = binary_mask.size
     sterilized_pixels = cv2.countNonZero(binary_mask)
     coverage_percent = (sterilized_pixels / total_pixels) * 100
 
-    # Create overlay for visualization: Green = sterilized, Red = unsterilized
     overlay = img.copy()
     overlay[binary_mask == 255] = [0, 255, 0]  # Green
     overlay[binary_mask == 0] = [0, 0, 255]    # Red
@@ -75,7 +65,6 @@ def create_pdf_report(coverage_percent, extracted_texts, annotated_image_path, o
     pdf.set_font("Arial", size=10)
     if extracted_texts:
         for text in extracted_texts:
-            # Filter out very short or empty OCR texts to improve clarity
             if len(text.strip()) > 1:
                 pdf.multi_cell(0, 8, f"- {text}")
     else:
@@ -87,11 +76,7 @@ def create_pdf_report(coverage_percent, extracted_texts, annotated_image_path, o
 
     pdf.output(output_path)
 
-# New function to upload image to Salesforce and get URL (adapted from reference code)
 def upload_image_to_salesforce(image_path, image_name, record_id=None):
-    """
-    Upload the image to Salesforce as a ContentVersion and return a public URL.
-    """
     try:
         sf = Salesforce(
             username=os.environ['SF_USERNAME'],
@@ -99,15 +84,12 @@ def upload_image_to_salesforce(image_path, image_name, record_id=None):
             security_token=os.environ['SF_SECURITY_TOKEN'],
             domain=os.environ.get('SF_DOMAIN', 'login')
         )
-        logger.debug(f"Uploading image {image_name} for record ID: {record_id}")
 
-        # Read the image file and encode it as base64
         with open(image_path, "rb") as f:
             image_data = f.read()
 
         encoded_image_data = base64.b64encode(image_data).decode('utf-8')
 
-        # Create a ContentVersion in Salesforce
         content_version_data = {
             "Title": image_name,
             "PathOnClient": image_name,
@@ -119,43 +101,28 @@ def upload_image_to_salesforce(image_path, image_name, record_id=None):
 
         content_version = sf.ContentVersion.create(content_version_data)
         content_version_id = content_version["id"]
-        logger.info(f"Image uploaded to Salesforce with ContentVersion ID: {content_version_id}")
 
-        # Generate the public URL for the image
         image_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/version/download/{content_version_id}"
-        logger.debug(f"Generated image URL: {image_url}")
         return image_url
     except Exception as e:
         logger.error(f"Error uploading image to Salesforce: {str(e)}", exc_info=True)
         raise
 
 def upload_image_and_get_url(image_path):
-    """
-    Upload the image to Salesforce and return a public URL.
-    """
     from datetime import datetime
     import uuid
 
-    # Generate a unique filename to avoid conflicts
     unique_filename = f"{uuid.uuid4().hex}_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}.jpg"
-    
-    # Upload the image to Salesforce and get the URL
-    try:
-        image_url = upload_image_to_salesforce(image_path, unique_filename)
-        return image_url
-    except Exception as e:
-        logger.error(f"Failed to upload image to Salesforce: {e}")
-        raise
+    return upload_image_to_salesforce(image_path, unique_filename)
 
 def save_record_to_salesforce(annotated_image_url, coverage_percent, original_image_pil, compliance_threshold=80):
     sf = Salesforce(
         username=os.environ['SF_USERNAME'],
         password=os.environ['SF_PASSWORD'],
         security_token=os.environ['SF_SECURITY_TOKEN'],
-        domain=os.environ.get('SF_DOMAIN', 'login')  # 'test' for sandbox
+        domain=os.environ.get('SF_DOMAIN', 'login')
     )
     
-    # Save original image temporarily, upload it, get URL
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_orig_img_file:
         original_image_pil.save(temp_orig_img_file.name, format="JPEG")
         temp_orig_img_path = temp_orig_img_file.name
@@ -164,8 +131,7 @@ def save_record_to_salesforce(annotated_image_url, coverage_percent, original_im
     os.unlink(temp_orig_img_path)
 
     compliance_status = 'Pass' if coverage_percent >= compliance_threshold else 'Fail'
-    technician_id = os.environ.get('SF_TECHNICIAN_ID')  # Salesforce UserId lookup
-    
+    technician_id = os.environ.get('SF_TECHNICIAN_ID')
     record_name = f"UV Verification - {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')}"
 
     sf.UV_Verification__c.create({
@@ -179,19 +145,17 @@ def save_record_to_salesforce(annotated_image_url, coverage_percent, original_im
     })
 
 def process_image(input_img, brightness_threshold=150):
-    # Resize the image early to improve processing speed
-    img = np.array(input_img)  # Convert PIL Image to NumPy array
-    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)  # Convert from RGB to BGR
-    
-    # Resize image to reduce the processing time
-    max_dim = 640  # Max dimension for resizing
+    img = np.array(input_img)
+    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+
+    max_dim = 640
     h, w = img.shape[:2]
     if max(h, w) > max_dim:
         scale = max_dim / max(h, w)
         img = cv2.resize(img, (int(w * scale), int(h * scale)))
 
     start_time = time.time()
-    ocr_result = ocr_model.predict(img)  # Use the `predict` method here instead of `ocr`
+    ocr_result = ocr_model.predict(img)
     ocr_time = time.time() - start_time
 
     extracted_texts = []
@@ -212,33 +176,45 @@ def process_image(input_img, brightness_threshold=150):
     temp_pdf_file.close()
     create_pdf_report(coverage_percent, extracted_texts, annotated_img_path, temp_pdf_file.name)
 
-    # Upload annotated image and get URL
     annotated_image_url = upload_image_and_get_url(annotated_img_path)
-
-    # Save record in Salesforce
     save_record_to_salesforce(annotated_image_url, coverage_percent, input_img)
 
     annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)
-
     report_text = f"UV Sterilization Coverage: {coverage_percent:.2f}%"
 
-    # Clean up temp image file after PDF generation
     os.unlink(annotated_img_path)
 
     return annotated_img_rgb, report_text, temp_pdf_file.name
 
-iface = gr.Interface(
-    fn=process_image,
-    inputs=[gr.Image(type="pil", label="Upload Post-UV Sterilization Image"),
-            gr.Slider(50, 255, value=150, step=1, label="Brightness Threshold")],
-    outputs=[gr.Image(type="numpy", label="Annotated Image"),
-             gr.Textbox(label="UV Sterilization Report", lines=5),
-             gr.File(label="Download PDF Report")],
-    title="UV Sterilization Coverage Analyzer",
-    description="Upload a post-UV sterilization image to analyze surface coverage and generate a compliance report."
-)
-
-iface.queue()  # Enable request queuing to improve UX on heavy processing
+# === Gradio Interface with Resetting Brightness Threshold ===
+
+with gr.Blocks() as iface:
+    gr.Markdown("# UV Sterilization Coverage Analyzer")
+    gr.Markdown("Upload a post-UV sterilization image to analyze surface coverage and generate a compliance report.")
+
+    with gr.Row():
+        image_input = gr.Image(type="pil", label="Upload Post-UV Sterilization Image")
+        brightness_slider = gr.Slider(50, 255, value=150, step=1, label="Brightness Threshold")
+
+    output_image = gr.Image(type="numpy", label="Annotated Image")
+    output_text = gr.Textbox(label="UV Sterilization Report", lines=5)
+    output_pdf = gr.File(label="Download PDF Report")
+
+    clear_btn = gr.Button("Clear and Reset")
+
+    # Reset slider to default 150 when a new image is uploaded
+    image_input.change(fn=lambda _: gr.update(value=150), inputs=image_input, outputs=brightness_slider, queue=False)
+
+    # Process image on brightness change or after image upload
+    brightness_slider.change(fn=process_image, inputs=[image_input, brightness_slider], outputs=[output_image, output_text, output_pdf])
+    image_input.upload(fn=process_image, inputs=[image_input, brightness_slider], outputs=[output_image, output_text, output_pdf])
+
+    # Optional: Clear/reset button
+    clear_btn.click(fn=lambda: (None, 150, None, "", None),
+                    inputs=[],
+                    outputs=[image_input, brightness_slider, output_image, output_text, output_pdf])
+
+iface.queue()
 
 if __name__ == "__main__":
     iface.launch()