Update app.py

app.py

@@ -1,289 +1,144 @@
 import gradio as gr
-import matplotlib.pyplot as plt
-import pandas as pd
-import os
-import random
-from PIL import ImageDraw
-
-# ===============================
-# GLOBAL VARIABLES
-# ===============================
-total_vehicles = 0
-ev_count = 0
-total_co2_saved = 0
-
-DISTANCE_KM = 10
-CO2_PER_KM_PETROL = 0.150
-CO2_SAVED_PER_EV = DISTANCE_KM * CO2_PER_KM_PETROL
-
-FEEDBACK_FILE = "feedback.csv"
-
-if not os.path.exists(FEEDBACK_FILE):
-    df_init = pd.DataFrame(columns=["Predicted_Label", "Feedback"])
-    df_init.to_csv(FEEDBACK_FILE, index=False)
-
-# ===============================
-# DUMMY CLASSIFIER (Replace with YOLO)
-# ===============================
-def classify_vehicle():
-    return random.choice([
-        "Car",
-        "Bus",
-        "Truck",
-        "Motorcycle",
-        "Electric Vehicle"
-    ])
-
-# ===============================
-# DASHBOARD
-# ===============================
-def generate_dashboard():
-    global total_vehicles, ev_count
-    non_ev = total_vehicles - ev_count
-
-    fig, ax = plt.subplots()
-    ax.bar(["EV", "Non-EV"], [ev_count, non_ev])
-    ax.set_title("Vehicle Distribution")
-    ax.set_ylabel("Count")
-
-    return fig
-
-# ===============================
-# DETECTION FUNCTION
-# ===============================
-def detect_image(image, threshold):
-
-    global total_vehicles, ev_count, total_co2_saved
+import cv2
+import numpy as np
+import easyocr
+from ultralytics import YOLO
+import re
 
-    if image is None:
-        return None, "Upload image first.", \
-               "### 🚘 Total Vehicles: 0", \
-               "### ⚡ EV Vehicles: 0", \
-               "### 📊 EV Adoption Rate: 0%", \
-               "### 🌱 CO₂ Saved: 0 kg", \
-               generate_dashboard(), ""
-
-    vehicle_type = classify_vehicle()
-    plate_number = "KA01AB1234"
-
-    total_vehicles += 1
-    co2_saved_this = 0
-
-    if vehicle_type == "Electric Vehicle":
-        ev_count += 1
-        co2_saved_this = CO2_SAVED_PER_EV
-        total_co2_saved += co2_saved_this
-
-    ev_percent = (ev_count / total_vehicles) * 100
-
-    # Draw boxes
-    img = image.copy()
-    draw = ImageDraw.Draw(img)
-    w, h = img.size
-
-    vehicle_box = [w*0.1, h*0.2, w*0.9, h*0.8]
-    plate_box = [w*0.4, h*0.6, w*0.7, h*0.75]
-
-    draw.rectangle(vehicle_box, outline="red", width=4)
-    draw.text((vehicle_box[0], vehicle_box[1]-20),
-              f"Vehicle: {vehicle_type}", fill="red")
-
-    draw.rectangle(plate_box, outline="green", width=4)
-    draw.text((plate_box[0], plate_box[1]-20),
-              f"Plate: {plate_number}", fill="green")
-
-    fig, ax = plt.subplots()
-    ax.imshow(img)
-    ax.axis("off")
-    ax.set_title("Detection Result")
-
-    result_text = f"""
-Vehicle Type: {vehicle_type}
-Number Plate: {plate_number}
-Confidence Threshold: {threshold}
-CO₂ Saved (This Detection): {co2_saved_this:.2f} kg
-"""
-
-    total_card = f"### 🚘 Total Vehicles: {total_vehicles}"
-    ev_card = f"### ⚡ EV Vehicles: {ev_count}"
-    percent_card = f"### 📊 EV Adoption Rate: {ev_percent:.2f}%"
-    co2_card = f"### 🌱 CO₂ Saved: {total_co2_saved:.2f} kg"
-
-    dashboard_fig = generate_dashboard()
-
-    return (
-        fig,
-        result_text,
-        total_card,
-        ev_card,
-        percent_card,
-        co2_card,
-        dashboard_fig,
-        vehicle_type
-    )
-
-# ===============================
-# FEEDBACK FUNCTIONS
-# ===============================
-def save_feedback(predicted_label, feedback):
-    df = pd.read_csv(FEEDBACK_FILE)
-    df = pd.concat([df, pd.DataFrame(
-        [{"Predicted_Label": predicted_label, "Feedback": feedback}]
-    )], ignore_index=True)
-    df.to_csv(FEEDBACK_FILE, index=False)
-    return "✅ Feedback Saved!"
-
-def calculate_metrics():
+# Load models
+model = YOLO("best.pt")  # your trained number plate model
+reader = easyocr.Reader(['en'])
 
-    df = pd.read_csv(FEEDBACK_FILE)
+############################################################
+# Image Enhancement for Night Images
+############################################################
 
-    if len(df) == 0:
-        return "No feedback data available.", None
+def enhance_image(image):
+    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+    l, a, b = cv2.split(lab)
 
-    tp = len(df[df["Feedback"] == "Correct"])
-    fp = len(df[df["Feedback"] == "Incorrect"])
-    total = len(df)
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+    cl = clahe.apply(l)
 
-    precision = tp / (tp + fp) if (tp + fp) else 0
-    recall = tp / total if total else 0
+    enhanced = cv2.merge((cl,a,b))
+    enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR)
 
-    metrics_text = f"""
-Total Samples: {total}
+    return enhanced
 
-True Positives: {tp}
-False Positives: {fp}
 
-Precision: {precision:.2f}
-Recall: {recall:.2f}
-"""
+############################################################
+# Indian Plate Colour Classification
+############################################################
 
-    fig, ax = plt.subplots()
-    matrix = [[tp, fp], [0, 0]]
-    ax.imshow(matrix)
+def classify_plate_color(roi):
 
-    ax.set_xticks([0,1])
-    ax.set_yticks([0,1])
-    ax.set_xticklabels(["Correct", "Incorrect"])
-    ax.set_yticklabels(["Predicted"])
+    hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
 
-    for i in range(2):
-        for j in range(2):
-            ax.text(j, i, matrix[i][j], ha="center", va="center")
+    masks = {
+        "white": cv2.inRange(hsv, np.array([0,0,180]), np.array([180,60,255])),
+        "yellow": cv2.inRange(hsv, np.array([15,80,80]), np.array([40,255,255])),
+        "green": cv2.inRange(hsv, np.array([35,50,50]), np.array([85,255,255]))
+    }
 
-    ax.set_title("Confusion Matrix")
+    color_counts = {color: np.sum(mask) for color, mask in masks.items()}
+    dominant_color = max(color_counts, key=color_counts.get)
 
-    return metrics_text, fig
+    if dominant_color == "white":
+        return "Private Vehicle", False
+    elif dominant_color == "yellow":
+        return "Commercial Vehicle", False
+    elif dominant_color == "green":
+        return "Electric Vehicle (EV)", True
+    else:
+        return "Unknown", False
 
-def reset_database():
-    df = pd.DataFrame(columns=["Predicted_Label", "Feedback"])
-    df.to_csv(FEEDBACK_FILE, index=False)
-    return "🗑 Database Reset Successfully!"
 
-def download_feedback():
-    return FEEDBACK_FILE
+############################################################
+# Main Detection Pipeline
+############################################################
 
-# ===============================
-# GRADIO UI
-# ===============================
-with gr.Blocks() as demo:
+def detect_number_plates(image):
 
-    # ----------------------------
-    # DETECTION TAB
-    # ----------------------------
-    with gr.Tab("🚦 Detection System"):
+    if image is None:
+        return None, "Upload image first."
 
-        gr.Markdown("## Smart Vehicle Classification & EV CO₂ Dashboard")
+    img = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
 
-        slider = gr.Slider(0.3, 1.0, 0.5, step=0.05,
-                           label="Confidence Threshold")
+    # Night enhancement
+    img = enhance_image(img)
 
-        with gr.Row():
-            img_input = gr.Image(type="pil", label="Upload Vehicle Image")
-            img_output = gr.Plot(label="Detection Output")
+    results = model(img)
 
-        result_box = gr.Textbox(label="Detection Result", lines=6)
+    detected_info = []
 
-        with gr.Row():
-            total_card = gr.Markdown("### 🚘 Total Vehicles: 0")
-            ev_card = gr.Markdown("### ⚡ EV Vehicles: 0")
-            percent_card = gr.Markdown("### 📊 EV Adoption Rate: 0%")
-            co2_card = gr.Markdown("### 🌱 CO₂ Saved: 0 kg")
+    for result in results:
+        boxes = result.boxes.xyxy.cpu().numpy()
 
-        dashboard_plot = gr.Plot(label="Analytics Dashboard")
+        for box in boxes:
+            x1, y1, x2, y2 = map(int, box)
 
-        predicted_label_state = gr.State()
+            plate_roi = img[y1:y2, x1:x2]
 
-        detect_btn = gr.Button("🔍 Detect Vehicle")
+            # OCR
+            ocr_results = reader.readtext(plate_roi)
 
-        detect_btn.click(
-            fn=detect_image,
-            inputs=[img_input, slider],
-            outputs=[
-                img_output,
-                result_box,
-                total_card,
-                ev_card,
-                percent_card,
-                co2_card,
-                dashboard_plot,
-                predicted_label_state
-            ]
-        )
+            plate_number = "Unknown"
+            for res in ocr_results:
+                text = re.sub(r'[^A-Z0-9]', '', res[1].upper())
+                if len(text) >= 8:
+                    plate_number = text
+                    break
 
-        gr.Markdown("### Provide Feedback")
+            vehicle_type, is_ev = classify_plate_color(plate_roi)
 
-        correct_btn = gr.Button("✔ Correct")
-        incorrect_btn = gr.Button("✘ Incorrect")
-        feedback_status = gr.Textbox(label="Feedback Status")
+            if is_ev:
+                benefit = "EV Benefits: Toll & Parking Discount"
+            else:
+                benefit = "No EV Benefits"
 
-        correct_btn.click(
-            fn=save_feedback,
-            inputs=[predicted_label_state, gr.State("Correct")],
-            outputs=feedback_status
-        )
+            # Draw bounding box
+            cv2.rectangle(img, (x1,y1), (x2,y2), (0,255,0), 2)
 
-        incorrect_btn.click(
-            fn=save_feedback,
-            inputs=[predicted_label_state, gr.State("Incorrect")],
-            outputs=feedback_status
-        )
+            label = f"{plate_number} | {vehicle_type}"
+            cv2.putText(img, label,
+                        (x1, y1-10),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.7,
+                        (0,255,0),
+                        2)
 
-    # ----------------------------
-    # ADMIN DASHBOARD TAB
-    # ----------------------------
-    with gr.Tab("📊 Admin Dashboard"):
+            detected_info.append(
+                f"Plate: {plate_number}\nType: {vehicle_type}\n{benefit}"
+            )
 
-        gr.Markdown("## Model Evaluation Dashboard")
+    if len(detected_info) == 0:
+        summary = "No number plates detected."
+    else:
+        summary = "\n\n".join(detected_info)
 
-        metrics_box = gr.Textbox(label="Evaluation Metrics", lines=10)
-        confusion_plot = gr.Plot()
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
 
-        evaluate_btn = gr.Button("Calculate Metrics")
+    return img, summary
 
-        evaluate_btn.click(
-            fn=calculate_metrics,
-            outputs=[metrics_box, confusion_plot]
-        )
 
-        gr.Markdown("### Download Feedback CSV")
+############################################################
+# Gradio UI
+############################################################
 
-        download_button = gr.Button("Download CSV")
-        download_file = gr.File()
+with gr.Blocks() as demo:
 
-        download_button.click(
-            fn=download_feedback,
-            outputs=download_file
-        )
+    gr.Markdown("## 🚦 Smart Traffic CCTV Number Plate Detection System")
 
-        gr.Markdown("### Reset Database")
+    image_input = gr.Image(type="pil", label="Upload CCTV Image")
+    detect_btn = gr.Button("Detect Plates", size="sm")
 
-        reset_btn = gr.Button("Reset Database")
-        reset_output = gr.Textbox()
+    output_image = gr.Image(label="Detection Output")
+    output_text = gr.Textbox(label="Detection Summary")
 
-        reset_btn.click(
-            fn=reset_database,
-            outputs=reset_output
-        )
+    detect_btn.click(
+        fn=detect_number_plates,
+        inputs=image_input,
+        outputs=[output_image, output_text]
+    )
 
-# Gradio 6 theme must be passed here
 demo.launch(theme=gr.themes.Soft())