Update app.py

app.py

@@ -1,289 +1,182 @@
 import gradio as gr
-import matplotlib.pyplot as plt
-import pandas as pd
+import cv2
+import numpy as np
 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 pandas as pd
+from datetime import datetime
 
-    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
-"""
+# Store evaluation data
+feedback_data = []
 
-    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
-    )
+##############################################
+# Utility: Detect plate color and 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 classify_vehicle_by_plate_color(roi):
 
-def calculate_metrics():
+    hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
 
-    df = pd.read_csv(FEEDBACK_FILE)
+    # Masks for colors
+    masks = {}
 
-    if len(df) == 0:
-        return "No feedback data available.", None
+    # White
+    masks["white"] = cv2.inRange(hsv, np.array([0, 0, 180]), np.array([180, 60, 255]))
 
-    tp = len(df[df["Feedback"] == "Correct"])
-    fp = len(df[df["Feedback"] == "Incorrect"])
-    total = len(df)
+    # Yellow
+    masks["yellow"] = cv2.inRange(hsv, np.array([15, 80, 80]), np.array([40, 255, 255]))
 
-    precision = tp / (tp + fp) if (tp + fp) else 0
-    recall = tp / total if total else 0
+    # Green
+    masks["green"] = cv2.inRange(hsv, np.array([35, 50, 50]), np.array([85, 255, 255]))
 
-    metrics_text = f"""
-Total Samples: {total}
+    # Red
+    masks["red1"] = cv2.inRange(hsv, np.array([0, 70, 50]), np.array([10, 255, 255]))
+    masks["red2"] = cv2.inRange(hsv, np.array([170, 70, 50]), np.array([180, 255, 255]))
+    masks["red"] = masks["red1"] + masks["red2"]
 
-True Positives: {tp}
-False Positives: {fp}
+    # Blue
+    masks["blue"] = cv2.inRange(hsv, np.array([90, 50, 50]), np.array([130, 255, 255]))
 
-Precision: {precision:.2f}
-Recall: {recall:.2f}
-"""
+    # Count pixels
+    color_counts = {color: np.sum(mask) for color, mask in masks.items()}
 
-    fig, ax = plt.subplots()
-    matrix = [[tp, fp], [0, 0]]
-    ax.imshow(matrix)
+    dominant_color = max(color_counts, key=color_counts.get)
 
-    ax.set_xticks([0,1])
-    ax.set_yticks([0,1])
-    ax.set_xticklabels(["Correct", "Incorrect"])
-    ax.set_yticklabels(["Predicted"])
+    # Classification logic
+    if dominant_color == "white":
+        return "Private Vehicle"
+    elif dominant_color == "yellow":
+        return "Commercial Vehicle"
+    elif dominant_color == "green":
+        return "Electric Vehicle (EV)"
+    elif dominant_color == "red":
+        return "Temporary Registration Vehicle"
+    elif dominant_color == "blue":
+        return "Diplomatic Vehicle"
+    else:
+        return "Unknown Vehicle Type"
 
-    for i in range(2):
-        for j in range(2):
-            ax.text(j, i, matrix[i][j], ha="center", va="center")
+##############################################
+# Main Detection Function
+##############################################
 
-    ax.set_title("Confusion Matrix")
+def detect_vehicles(image):
 
-    return metrics_text, fig
+    if image is None:
+        return None, "No image uploaded."
 
-def reset_database():
-    df = pd.DataFrame(columns=["Predicted_Label", "Feedback"])
-    df.to_csv(FEEDBACK_FILE, index=False)
-    return "Database Reset Successfully!"
+    img = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
-def download_feedback():
-    return FEEDBACK_FILE
+    # Simple plate-like contour detection
+    edges = cv2.Canny(gray, 100, 200)
+    contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
 
-# ===============================
-# GRADIO UI
-# ===============================
-with gr.Blocks() as demo:
+    detected_info = []
+    count = 0
+
+    for cnt in contours:
+        x, y, w, h = cv2.boundingRect(cnt)
+
+        # Plate aspect ratio filter
+        if 2 < w / h < 6 and w > 100:
+            plate_roi = img[y:y+h, x:x+w]
+            vehicle_type = classify_vehicle_by_plate_color(plate_roi)
 
-    # ----------------------------
-    # DETECTION TAB
-    # ----------------------------
-    with gr.Tab("Detection System"):
+            cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
+            cv2.putText(img, vehicle_type,
+                        (x, y-10),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.6,
+                        (0, 255, 0),
+                        2)
 
-        gr.Markdown("## Smart Vehicle Classification & EV CO₂ Dashboard")
+            detected_info.append(vehicle_type)
+            count += 1
 
-        slider = gr.Slider(0.3, 1.0, 0.5, step=0.05,
-                           label="Confidence Threshold")
+    if count == 0:
+        summary = "No vehicles detected."
+    else:
+        summary = f"{count} Vehicle(s) Detected: " + ", ".join(detected_info)
 
-        with gr.Row():
-            img_input = gr.Image(type="pil", label="Upload Vehicle Image")
-            img_output = gr.Plot(label="Detection Output")
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
 
-        result_box = gr.Textbox(label="Detection Result", lines=6)
+    return img, summary
 
-        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")
 
-        dashboard_plot = gr.Plot(label="Analytics Dashboard")
+##############################################
+# Feedback System
+##############################################
 
-        predicted_label_state = gr.State()
+def submit_feedback(is_correct):
+    global feedback_data
 
-        detect_btn = gr.Button("Detect Vehicle")
+    feedback_data.append({
+        "timestamp": datetime.now(),
+        "correct": is_correct
+    })
 
-        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
-            ]
-        )
+    return generate_summary()
 
-        gr.Markdown("### Provide Feedback")
 
-        correct_btn = gr.Button("Correct")
-        incorrect_btn = gr.Button("Incorrect")
-        feedback_status = gr.Textbox(label="Feedback Status")
+def generate_summary():
+    total = len(feedback_data)
+    if total == 0:
+        return "No evaluations yet."
 
-        correct_btn.click(
-            fn=save_feedback,
-            inputs=[predicted_label_state, gr.State("Correct")],
-            outputs=feedback_status
-        )
+    correct = sum(1 for f in feedback_data if f["correct"])
+    accuracy = (correct / total) * 100
 
-        incorrect_btn.click(
-            fn=save_feedback,
-            inputs=[predicted_label_state, gr.State("Incorrect")],
-            outputs=feedback_status
-        )
+    return f"""
+📊 Evaluation Summary  
+Total Samples: {total}  
+Correct: {correct}  
+Accuracy: {accuracy:.2f}%
+"""
+
+
+##############################################
+# Gradio UI
+##############################################
+
+with gr.Blocks() as demo:
 
-    # ----------------------------
-    # ADMIN DASHBOARD TAB
-    # ----------------------------
-    with gr.Tab("Admin Dashboard"):
+    gr.Markdown("## Smart Traffic Vehicle Classification System")
 
-        gr.Markdown("## Model Evaluation Dashboard")
+    with gr.Row():
 
-        metrics_box = gr.Textbox(label="Evaluation Metrics", lines=10)
-        confusion_plot = gr.Plot()
+        with gr.Column(scale=2):
 
-        evaluate_btn = gr.Button("Calculate Metrics")
+            image_input = gr.Image(type="pil", label="Upload Vehicle Image")
 
-        evaluate_btn.click(
-            fn=calculate_metrics,
-            outputs=[metrics_box, confusion_plot]
-        )
+            detect_btn = gr.Button("Detect", size="sm")
 
-        gr.Markdown("### Download Feedback CSV")
+            output_image = gr.Image(label="Output Image")
+            output_text = gr.Textbox(label="Detection Summary")
 
-        download_button = gr.Button("Download CSV")
-        download_file = gr.File()
+        with gr.Column(scale=1):
 
-        download_button.click(
-            fn=download_feedback,
-            outputs=download_file
-        )
+            gr.Markdown("### Feedback")
 
-        gr.Markdown("### Reset Database")
+            correct_btn = gr.Button("Correct", size="sm")
+            incorrect_btn = gr.Button("Incorrect", size="sm")
 
-        reset_btn = gr.Button("Reset Database")
-        reset_output = gr.Textbox()
+            summary_box = gr.Textbox(label="Evaluation Summary")
 
-        reset_btn.click(
-            fn=reset_database,
-            outputs=reset_output
-        )
+    # Button actions
+    detect_btn.click(
+        fn=detect_vehicles,
+        inputs=image_input,
+        outputs=[output_image, output_text]
+    )
+
+    correct_btn.click(
+        fn=lambda: submit_feedback(True),
+        outputs=summary_box
+    )
+
+    incorrect_btn.click(
+        fn=lambda: submit_feedback(False),
+        outputs=summary_box
+    )
 
-# Gradio 6 theme passed here
 demo.launch(theme=gr.themes.Soft())