Update app.py

app.py

@@ -1,13 +1,15 @@
 import gradio as gr
+import cv2
+import pytesseract
 import numpy as np
 import datetime
-import pytesseract
-import cv2
 import random
 from fpdf import FPDF
+import os
+import threading
 import time
 
-# Quantum Transaction Logic
+# Quantum Simulation Logic
 class QuantumSim:
     def __init__(self):
         self.states = {
@@ -19,31 +21,52 @@ class QuantumSim:
     def evaluate_transaction(self):
         return random.choice(list(self.states.items()))
 
-# OCR + Damage/Injury Detection
+# Computer Vision & OCR Agent
 class CVProcessor:
-    def extract_vehicle_number(self, image):
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    def extract_vehicle_number(self, image_np):
+        if image_np is None:
+            return "No image provided"
+        gray = cv2.cvtColor(image_np, cv2.COLOR_BGR2GRAY)
         text = pytesseract.image_to_string(gray)
-        return text.strip() or "Unknown"
+        return text.strip() or "Not detected"
 
-    def detect_damage_severity(self, image):
-        score = np.random.randint(1, 10)
-        return "Severe" if score > 7 else "Moderate" if score > 4 else "Minor"
+    def detect_damage_severity(self, image_np):
+        if image_np is None:
+            return "No image provided"
+        # Simulate damage level detection
+        damage_score = np.random.randint(1, 10)
+        if damage_score > 7:
+            return "Severe"
+        elif damage_score > 4:
+            return "Moderate"
+        else:
+            return "Minor"
 
-    def detect_person_injury(self, image):
-        return "Critical" if np.random.randint(0, 2) else "Stable"
+    def detect_person_injury(self, image_np):
+        if image_np is None:
+            return "No image provided"
+        injury_score = np.random.randint(0, 2)
+        return "Critical" if injury_score else "Stable"
 
-# Agent Logic
+# Insurance Automation Agent
 class InsuranceAgent:
     def __init__(self):
         self.qsim = QuantumSim()
         self.cv = CVProcessor()
+        self.reports = []
+
+    def simulate_live_camera_feed(self):
+        print("[Agent] Watching live feed... analyzing frame by frame.")
+        for i in range(3):  # Simulate 3 frames for brevity
+            dummy_frame = np.ones((480, 640, 3), dtype=np.uint8) * np.random.randint(0, 255)
+            report = self.process_frame(dummy_frame)
+            self.reports.append(report)
+            time.sleep(2)  # Simulate a delay between frames
 
-    def process_autonomous_claim(self):
-        dummy_frame = np.ones((480, 640, 3), dtype=np.uint8) * np.random.randint(0, 255)
-        vehicle_number = self.cv.extract_vehicle_number(dummy_frame)
-        damage = self.cv.detect_damage_severity(dummy_frame)
-        injury = self.cv.detect_person_injury(dummy_frame)
+    def process_frame(self, frame):
+        vehicle_number = self.cv.extract_vehicle_number(frame)
+        damage = self.cv.detect_damage_severity(frame)
+        injury = self.cv.detect_person_injury(frame)
         q_code, status = self.qsim.evaluate_transaction()
 
         response = {
@@ -60,41 +83,47 @@ class InsuranceAgent:
         }
 
         self.generate_pdf_report(response)
-        return list(response.values())
+        self.notify_services(response)
+        return response
 
     def generate_pdf_report(self, data):
         pdf = FPDF()
         pdf.add_page()
         pdf.set_font("Arial", size=12)
-        pdf.cell(200, 10, txt="Insurance Auto-Claim Report", ln=True, align='C')
+        pdf.cell(200, 10, txt="Auto Insurance Claim Report", ln=True, align='C')
         for key, value in data.items():
             pdf.cell(200, 10, txt=f"{key}: {value}", ln=True)
-        filename = f"claim_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        filename = f"Claim_Report_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
         pdf.output(filename)
+        print(f"[Agent] Report generated: {filename}")
+
+    def notify_services(self, data):
+        print(f"[Hospital] Emergency Level: {data['Injury Level']} → Ambulance dispatched.")
+        print(f"[Tow Vehicle] Vehicle #{data['Vehicle Number']} scheduled for towing.")
+        if data["IRDA Notified"] == "Yes":
+            print("[IRDA] Fraud suspected. Penalty log initiated.")
+
+# Gradio UI for No-Ops Simulation
+if __name__ == "__main__":
+    agent = InsuranceAgent()
+
+    def start_agent_simulation():
+        agent.reports = []  # Clear previous reports
+        agent.simulate_live_camera_feed()
+        all_reports_text = ""
+        for i, report in enumerate(agent.reports):
+            all_reports_text += f"--- Report {i+1} ---\n"
+            for key, value in report.items():
+                all_reports_text += f"{key}: {value}\n"
+            all_reports_text += "\n"
+        return all_reports_text
+
+    with gr.Blocks() as iface:
+        gr.Markdown("# No-Ops AI Agent for Road Accident Management")
+        with gr.Column():
+            start_button = gr.Button("Start Agent Simulation")
+            report_output = gr.Textbox(label="Agent Activity and Reports")
+
+        start_button.click(start_agent_simulation, outputs=report_output)
 
-agent = InsuranceAgent()
-
-def start_no_ops_agent():
-    return agent.process_autonomous_claim()
-
-# Gradio Interface (No Uploads Needed)
-interface = gr.Interface(
-    fn=start_no_ops_agent,
-    inputs=[],
-    outputs=[
-        gr.Textbox(label="Time"),
-        gr.Textbox(label="Vehicle Number"),
-        gr.Textbox(label="Damage Level"),
-        gr.Textbox(label="Injury Level"),
-        gr.Textbox(label="Quantum Status"),
-        gr.Textbox(label="Code"),
-        gr.Textbox(label="Hospital Notified"),
-        gr.Textbox(label="Tow Vehicle Dispatched"),
-        gr.Textbox(label="IRDA Notified"),
-        gr.Textbox(label="Final Status"),
-    ],
-    title="No-Ops AI Agent - Auto Insurance Workflow",
-    description="Fully autonomous agent that handles road accident insurance, hospital dispatch, fraud detection, and IRDA reporting with no human input."
-)
-
-interface.launch()
+    iface.launch()