Update app.py

app.py

@@ -15,9 +15,16 @@ import io
 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:
         gray = cv2.GaussianBlur(gray, (5, 5), 0)
+
     if adaptive_thresh:
         binary_mask = cv2.adaptiveThreshold(
             gray, 255,
@@ -26,66 +33,87 @@ def analyze_uv_coverage(img, brightness_threshold=150, kernel_size=5, apply_blur
             11, 2)
     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]
-    overlay[binary_mask == 0] = [0, 0, 255]
+    overlay[binary_mask == 255] = [0, 255, 0]  # Green
+    overlay[binary_mask == 0] = [0, 0, 255]    # Red
+
     annotated_img = cv2.addWeighted(img, 0.6, overlay, 0.4, 0)
+
     return annotated_img, coverage_percent
 
 def create_pdf_report(coverage_percent, extracted_texts, annotated_image_path, output_path):
     pdf = FPDF()
     pdf.add_page()
+
     pdf.set_font("Arial", 'B', 16)
     pdf.cell(200, 10, txt="UV Sterilization Report", ln=True, align='C')
     pdf.ln(10)
+
     pdf.set_font("Arial", size=12)
     pdf.cell(0, 10, f"Sterilization Coverage: {coverage_percent:.2f}%", ln=True)
     pdf.ln(5)
+
     pdf.cell(0, 10, "Extracted Text from Image (OCR):", ln=True)
     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:
         pdf.cell(0, 8, "No text detected.", ln=True)
+
     pdf.ln(10)
     pdf.cell(0, 10, "Annotated Image:", ln=True)
     pdf.image(annotated_image_path, x=10, y=pdf.get_y(), w=pdf.w - 20)
+
     pdf.output(output_path)
 
 def upload_image_and_get_url(image_path):
     """
-    Return empty string because storing base64 data URI exceeds Salesforce field limit.
+    TODO: Implement your image upload to public storage here.
+    For now, returns a placeholder URL.
     """
-    return ""
+    # Example: upload to AWS S3, Azure Blob Storage, or other service
+    # Return the public URL to the uploaded image
+    return "https://example.com/path/to/your/annotated_image.jpg"
 
 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')
+        domain=os.environ.get('SF_DOMAIN', 'login')  # 'test' for sandbox
     )
+    
+    # Encode original image to base64 string for storage
     buffered = io.BytesIO()
     original_image_pil.save(buffered, format="JPEG")
-    original_img_bytes = buffered.getvalue()
-    original_img_b64 = base64.b64encode(original_img_bytes).decode('utf-8')
-    original_img_data_uri = f"data:image/jpeg;base64,{original_img_b64}"
+    original_img_b64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+
     compliance_status = 'Pass' if coverage_percent >= compliance_threshold else 'Fail'
-    technician_id = os.environ.get('SF_TECHNICIAN_ID')
+    technician_id = os.environ.get('SF_TECHNICIAN_ID')  # Salesforce UserId lookup
+    
     record_name = f"UV Verification - {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')}"
+
     sf.UV_Verification__c.create({
         'Name': record_name,
-        'Annotated_Image__c': annotated_image_url,  # will be empty string here
+        'Annotated_Image__c': annotated_image_url,
         'Coverage_Percentage__c': round(coverage_percent, 2),
-        'Original_Image__c': original_img_data_uri,
+        'Original_Image__c': original_img_b64,
         'Compliance_Status__c': compliance_status,
         'Technician_ID__c': technician_id,
         'Verified_On__c': datetime.utcnow().isoformat()
@@ -93,14 +121,18 @@ def save_record_to_salesforce(annotated_image_url, coverage_percent, original_im
 
 def process_image(input_img, brightness_threshold=150):
     img = cv2.cvtColor(np.array(input_img), cv2.COLOR_RGB2BGR)
+
+    # Resize large images for faster processing, preserving aspect ratio
     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.ocr(img)  # Warning about deprecated method remains; you can ignore or update PaddleOCR package
+    ocr_result = ocr_model.ocr(img)
     ocr_time = time.time() - start_time
+
     extracted_texts = []
     for line in ocr_result:
         if line:
@@ -108,18 +140,30 @@ def process_image(input_img, brightness_threshold=150):
                 text = word_info[1][0].strip()
                 if len(text) > 1:
                     extracted_texts.append(text)
+
     annotated_img, coverage_percent = analyze_uv_coverage(img, brightness_threshold)
+
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_img_file:
         cv2.imwrite(temp_img_file.name, annotated_img)
         annotated_img_path = temp_img_file.name
+
     temp_pdf_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
     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(
@@ -137,7 +181,7 @@ iface = gr.Interface(
     description="Upload a post-UV sterilization image to analyze surface coverage and generate a compliance report."
 )
 
-iface.queue()
+iface.queue()  # Enable request queuing to improve UX on heavy processing
 
 if __name__ == "__main__":
     iface.launch()