Update app.py

app.py

@@ -1,144 +1,251 @@
 import gradio as gr
-import cv2
-import numpy as np
-import easyocr
-from ultralytics import YOLO
-import re
-
-# Load models
-model = YOLO("best.pt")  # your trained number plate model
-reader = easyocr.Reader(['en'])
-
-############################################################
-# Image Enhancement for Night Images
-############################################################
-
-def enhance_image(image):
-    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-
-    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
-    cl = clahe.apply(l)
-
-    enhanced = cv2.merge((cl,a,b))
-    enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR)
-
-    return enhanced
-
-
-############################################################
-# Indian Plate Colour Classification
-############################################################
-
-def classify_plate_color(roi):
-
-    hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
-
-    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]))
+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):
+    pd.DataFrame(columns=["Predicted_Label", "Feedback"]).to_csv(FEEDBACK_FILE, index=False)
+
+# ===============================
+# SIMULATED NUMBER PLATE COLOUR DETECTION
+# Replace with real color detection later
+# ===============================
+def detect_plate_colour():
+    def classify_plate_color(plate_img):
+    try:
+        img = np.array(plate_img)
+        img = cv2.GaussianBlur(img, (5,5), 0)
+        hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
+
+        green_mask = cv2.inRange(hsv, (35, 40, 40), (85, 255, 255))
+        yellow_mask = cv2.inRange(hsv, (15, 50, 50), (35, 255, 255))
+        white_mask = cv2.inRange(hsv, (0, 0, 200), (180, 40, 255))
+
+        green = np.sum(green_mask)
+        yellow = np.sum(yellow_mask)
+        white = np.sum(white_mask)
+
+        if green > yellow and green > white:
+            return "Electric Vehicle (Green Plate)"
+        elif yellow > green and yellow > white:
+            return "Commercial Vehicle (Yellow Plate)"
+        elif white > green and white > yellow:
+            return "Private Vehicle (White Plate)"
+        else:
+            return "Unknown Classification"
+
+    except:
+        return "Unknown Classification"
+
+
+def get_vehicle_type_from_colour(colour):
+    mapping = {
+        "White": "Private Vehicle",
+        "Yellow": "Commercial Vehicle",
+        "Green": "Electric Vehicle",
+        "Black": "Rental Vehicle"
     }
-
-    color_counts = {color: np.sum(mask) for color, mask in masks.items()}
-    dominant_color = max(color_counts, key=color_counts.get)
-
-    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
-
-
-############################################################
-# Main Detection Pipeline
-############################################################
-
-def detect_number_plates(image):
+    return mapping.get(colour, "Unknown")
+
+# ===============================
+# 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
+
+# ===============================
+# EVALUATION SUMMARY
+# ===============================
+def get_evaluation_summary():
+    df = pd.read_csv(FEEDBACK_FILE)
+    total = len(df)
+    correct = len(df[df["Feedback"] == "Correct"])
+    incorrect = len(df[df["Feedback"] == "Incorrect"])
+
+    if total == 0:
+        return "Evaluation Summary:\nNo feedback yet."
+
+    precision = correct / total
+
+    return f"""Evaluation Summary
+Total: {total}
+Correct: {correct}
+Incorrect: {incorrect}
+Accuracy: {precision:.2f}
+"""
+
+# ===============================
+# DETECTION FUNCTION
+# ===============================
+def detect_image(image):
+
+    global total_vehicles, ev_count, total_co2_saved
 
     if image is None:
-        return None, "Upload image first."
-
-    img = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-
-    # Night enhancement
-    img = enhance_image(img)
-
-    results = model(img)
-
-    detected_info = []
-
-    for result in results:
-        boxes = result.boxes.xyxy.cpu().numpy()
-
-        for box in boxes:
-            x1, y1, x2, y2 = map(int, box)
-
-            plate_roi = img[y1:y2, x1:x2]
-
-            # OCR
-            ocr_results = reader.readtext(plate_roi)
-
-            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
-
-            vehicle_type, is_ev = classify_plate_color(plate_roi)
+        return None, "Upload image first.", "", "", "", "", "", ""
+
+    plate_colour = detect_plate_colour()
+    vehicle_type = get_vehicle_type_from_colour(plate_colour)
+    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_type}", fill="red")
+
+    draw.rectangle(plate_box, outline="green", width=4)
+    draw.text((plate_box[0], plate_box[1]-20),
+              f"{plate_number} ({plate_colour})", fill="green")
+
+    fig, ax = plt.subplots()
+    ax.imshow(img)
+    ax.axis("off")
+
+    result_text = f"""
+Vehicle Type: {vehicle_type}
+Plate Colour: {plate_colour}
+Plate Number: {plate_number}
+CO₂ Saved: {co2_saved_this:.2f} kg
+"""
+
+    total_card = f"### 🚘 Total: {total_vehicles}"
+    ev_card = f"### ⚡ EV: {ev_count}"
+    percent_card = f"### 📊 EV Rate: {ev_percent:.2f}%"
+    co2_card = f"### 🌱 CO₂ Saved: {total_co2_saved:.2f} kg"
+
+    dashboard_fig = generate_dashboard()
+
+    summary = get_evaluation_summary()
+
+    return fig, result_text, total_card, ev_card, percent_card, co2_card, dashboard_fig, vehicle_type, summary
+
+# ===============================
+# FEEDBACK SAVE
+# ===============================
+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 "Saved!", get_evaluation_summary()
+
+# ===============================
+# RESET DATABASE
+# ===============================
+def reset_database():
+    pd.DataFrame(columns=["Predicted_Label", "Feedback"]).to_csv(FEEDBACK_FILE, index=False)
+    return "Database Reset!", "Evaluation Summary:\nNo feedback yet."
+
+# ===============================
+# UI
+# ===============================
+with gr.Blocks() as demo:
 
-            if is_ev:
-                benefit = "EV Benefits: Toll & Parking Discount"
-            else:
-                benefit = "No EV Benefits"
+    gr.Markdown("## 🚦 Smart Vehicle Detection Based on Number Plate Colour")
 
-            # Draw bounding box
-            cv2.rectangle(img, (x1,y1), (x2,y2), (0,255,0), 2)
+    with gr.Row():
+        img_input = gr.Image(type="pil", label="Upload Vehicle Image")
+        img_output = gr.Plot()
 
-            label = f"{plate_number} | {vehicle_type}"
-            cv2.putText(img, label,
-                        (x1, y1-10),
-                        cv2.FONT_HERSHEY_SIMPLEX,
-                        0.7,
-                        (0,255,0),
-                        2)
+    detect_btn = gr.Button("Detect", size="sm")
 
-            detected_info.append(
-                f"Plate: {plate_number}\nType: {vehicle_type}\n{benefit}"
-            )
+    result_box = gr.Textbox(label="Detection Result", lines=5)
 
-    if len(detected_info) == 0:
-        summary = "No number plates detected."
-    else:
-        summary = "\n\n".join(detected_info)
+    with gr.Row():
+        total_card = gr.Markdown("### 🚘 Total: 0")
+        ev_card = gr.Markdown("### ⚡ EV: 0")
+        percent_card = gr.Markdown("### 📊 EV Rate: 0%")
+        co2_card = gr.Markdown("### 🌱 CO₂ Saved: 0 kg")
 
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    dashboard_plot = gr.Plot()
 
-    return img, summary
+    predicted_label_state = gr.State()
 
+    detect_btn.click(
+        fn=detect_image,
+        inputs=[img_input],
+        outputs=[
+            img_output,
+            result_box,
+            total_card,
+            ev_card,
+            percent_card,
+            co2_card,
+            dashboard_plot,
+            predicted_label_state,
+            gr.Markdown()  # evaluation summary placeholder
+        ]
+    )
 
-############################################################
-# Gradio UI
-############################################################
+    # -------------------------
+    # FEEDBACK + EVALUATION ROW
+    # -------------------------
+    with gr.Row():
 
-with gr.Blocks() as demo:
+        with gr.Column(scale=1):
+            correct_btn = gr.Button("✔", size="sm")
+            incorrect_btn = gr.Button("✘", size="sm")
+            feedback_status = gr.Textbox(label="Feedback", lines=1)
 
-    gr.Markdown("## 🚦 Smart Traffic CCTV Number Plate Detection System")
+        with gr.Column(scale=1):
+            evaluation_summary = gr.Textbox(label="Evaluation Summary", lines=6)
 
-    image_input = gr.Image(type="pil", label="Upload CCTV Image")
-    detect_btn = gr.Button("Detect Plates", size="sm")
+    correct_btn.click(
+        fn=save_feedback,
+        inputs=[predicted_label_state, gr.State("Correct")],
+        outputs=[feedback_status, evaluation_summary]
+    )
 
-    output_image = gr.Image(label="Detection Output")
-    output_text = gr.Textbox(label="Detection Summary")
+    incorrect_btn.click(
+        fn=save_feedback,
+        inputs=[predicted_label_state, gr.State("Incorrect")],
+        outputs=[feedback_status, evaluation_summary]
+    )
 
-    detect_btn.click(
-        fn=detect_number_plates,
-        inputs=image_input,
-        outputs=[output_image, output_text]
+    reset_btn = gr.Button("Reset Database", size="sm")
+    reset_btn.click(
+        fn=reset_database,
+        outputs=[feedback_status, evaluation_summary]
     )
 
 demo.launch(theme=gr.themes.Soft())