Update app.py

app.py

@@ -1,12 +1,7 @@
 # Author: Sarvamangala Kokatanur
-
-# ============================================================
-
-# SMART TRAFFIC & EV ANALYTICS SYSTEM
-
-# WITH AGENTIC AI DYNAMIC ANALYTICS DASHBOARD
-
-# ============================================================
+# Smart Traffic & EV Analytics System
+# YOLOS + OpenCV + EasyOCR + SQLite + Gradio
+# Dynamic AI Traffic Analytics Dashboard
 
 import gradio as gr
 import torch
@@ -15,1166 +10,2341 @@ import cv2
 import sqlite3
 import pandas as pd
 import matplotlib.pyplot as plt
+import easyocr
 
 from datetime import datetime, timedelta
 from PIL import Image, ImageDraw
 
 from transformers import (
-YolosImageProcessor,
-YolosForObjectDetection
+    YolosImageProcessor,
+    YolosForObjectDetection
 )
 
+
+# ============================================================
+# CONFIGURATION
 # ============================================================
 
-# LOAD LICENSE PLATE DETECTION MODEL
+MODEL_NAME = (
+    "nickmuchi/"
+    "yolos-small-finetuned-license-plate-detection"
+)
+
+EV_DISCOUNT = 50
 
+
+# ============================================================
+# LOAD YOLOS LICENSE PLATE DETECTION MODEL
 # ============================================================
 
+print("Loading YOLOS license plate detection model...")
+
 processor = YolosImageProcessor.from_pretrained(
-"nickmuchi/yolos-small-finetuned-license-plate-detection"
+    MODEL_NAME
 )
 
 model = YolosForObjectDetection.from_pretrained(
-"nickmuchi/yolos-small-finetuned-license-plate-detection"
+    MODEL_NAME
 )
 
 model.eval()
 
+print("YOLOS model loaded successfully.")
+
+
+# ============================================================
+# LOAD EASY OCR
 # ============================================================
 
-# DATABASE
+print("Loading EasyOCR...")
+
+try:
+    reader = easyocr.Reader(
+        ["en"],
+        gpu=torch.cuda.is_available()
+    )
+
+    print("EasyOCR loaded successfully.")
+
+except Exception as e:
+
+    print("EasyOCR loading error:", e)
+
+    reader = None
+
 
+# ============================================================
+# DATABASE
 # ============================================================
 
 conn = sqlite3.connect(
-"vehicles.db",
-check_same_thread=False
+    "vehicles.db",
+    check_same_thread=False
 )
 
 cursor = conn.cursor()
 
+
 cursor.execute("""
 CREATE TABLE IF NOT EXISTS vehicles(
 
-```
-id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
 
-timestamp TEXT,
+    timestamp TEXT,
 
-license_plate TEXT,
+    license_plate TEXT,
 
-vehicle_status TEXT,
+    vehicle_status TEXT,
 
-discount INTEGER
-```
+    discount INTEGER
 
 )
 """)
 
+
 conn.commit()
 
+
+# ============================================================
+# GET VEHICLE DATA
 # ============================================================
 
-# PLATE COLOR CLASSIFIER
+def get_vehicle_dataframe():
 
+    try:
+
+        df = pd.read_sql_query(
+            "SELECT * FROM vehicles ORDER BY id DESC",
+            conn
+        )
+
+        return df
+
+    except Exception as e:
+
+        print("Database error:", e)
+
+        return pd.DataFrame(
+            columns=[
+                "id",
+                "timestamp",
+                "license_plate",
+                "vehicle_status",
+                "discount"
+            ]
+        )
+
+
+# ============================================================
+# PLATE COLOR CLASSIFIER
 # ============================================================
 
 def classify_plate_color(plate_img):
 
-```
-img = np.array(plate_img)
+    try:
 
-# Convert RGB to HSV
-hsv = cv2.cvtColor(
-    img,
-    cv2.COLOR_RGB2HSV
-)
+        img = np.array(plate_img)
 
-h, w = hsv.shape[:2]
+        if img.size == 0:
+            return "Non-EV"
 
-# Inspect left portion of the plate
-left = hsv[:, :int(w * 0.2)]
+        # PIL RGB -> OpenCV RGB
+        hsv = cv2.cvtColor(
+            img,
+            cv2.COLOR_RGB2HSV
+        )
 
-# Detect green color
-green = cv2.inRange(
-    left,
-    (35, 40, 40),
-    (90, 255, 255)
-)
+        h, w = hsv.shape[:2]
+
+        if w == 0:
+            return "Non-EV"
+
+        # Inspect left 20% of the plate
+        left_width = max(
+            1,
+            int(w * 0.20)
+        )
+
+        left = hsv[:, :left_width]
+
+        # Green HSV range
+        green = cv2.inRange(
+            left,
+            (35, 40, 40),
+            (90, 255, 255)
+        )
+
+        green_ratio = (
+            np.count_nonzero(green)
+            / green.size
+        )
+
+        if green_ratio > 0.15:
+            return "EV"
+
+        return "Non-EV"
+
+    except Exception as e:
+
+        print(
+            "Plate color classification error:",
+            e
+        )
+
+        return "Non-EV"
+
+
+# ============================================================
+# OCR PREPROCESSING
+# ============================================================
+
+def preprocess_plate_for_ocr(plate_img):
+
+    try:
+
+        img = np.array(plate_img)
+
+        if img.size == 0:
+            return None
+
+        # Convert RGB -> grayscale
+        gray = cv2.cvtColor(
+            img,
+            cv2.COLOR_RGB2GRAY
+        )
+
+        # Resize for OCR
+        scale = 3
+
+        gray = cv2.resize(
+            gray,
+            None,
+            fx=scale,
+            fy=scale,
+            interpolation=cv2.INTER_CUBIC
+        )
+
+        # Noise reduction
+        gray = cv2.bilateralFilter(
+            gray,
+            9,
+            75,
+            75
+        )
+
+        # Contrast enhancement
+        gray = cv2.equalizeHist(
+            gray
+        )
+
+        return gray
+
+    except Exception as e:
+
+        print(
+            "OCR preprocessing error:",
+            e
+        )
+
+        return None
+
+
+# ============================================================
+# OCR FUNCTION
+# ============================================================
+
+def read_license_plate(plate_img):
+
+    if reader is None:
+
+        return "OCR_UNAVAILABLE"
+
+    try:
+
+        processed = preprocess_plate_for_ocr(
+            plate_img
+        )
+
+        if processed is None:
+            return "UNKNOWN"
+
+        results = reader.readtext(
+            processed,
+            detail=1,
+            paragraph=False
+        )
+
+        if not results:
+            return "UNKNOWN"
+
+        candidates = []
+
+        for result in results:
+
+            if len(result) >= 3:
+
+                text = str(
+                    result[1]
+                ).strip()
+
+                confidence = float(
+                    result[2]
+                )
+
+                if confidence >= 0.20:
+
+                    candidates.append(
+                        (text, confidence)
+                    )
+
+        if not candidates:
+            return "UNKNOWN"
+
+        # Select highest-confidence result
+        candidates.sort(
+            key=lambda x: x[1],
+            reverse=True
+        )
+
+        text = candidates[0][0]
+
+        # Remove unwanted characters
+        cleaned = "".join(
+            char
+            for char in text
+            if char.isalnum()
+        )
+
+        if cleaned == "":
+            return "UNKNOWN"
+
+        return cleaned.upper()
+
+    except Exception as e:
+
+        print(
+            "OCR error:",
+            e
+        )
+
+        return "UNKNOWN"
+
+
+# ============================================================
+# DUPLICATE VEHICLE CHECK
+# ============================================================
+
+def is_duplicate_vehicle(plate_number):
+
+    if (
+        plate_number is None
+        or plate_number == ""
+        or plate_number == "UNKNOWN"
+    ):
+
+        return False
+
+    try:
+
+        cursor.execute("""
+        SELECT timestamp
+        FROM vehicles
+        WHERE license_plate=?
+        ORDER BY id DESC
+        LIMIT 1
+        """, (plate_number,))
+
+        row = cursor.fetchone()
+
+        if row is None:
+            return False
+
+        last_time = datetime.strptime(
+            row[0],
+            "%Y-%m-%d %H:%M:%S"
+        )
+
+        elapsed = (
+            datetime.now()
+            - last_time
+        )
+
+        if elapsed < timedelta(
+            minutes=5
+        ):
+
+            return True
+
+        return False
+
+    except Exception as e:
+
+        print(
+            "Duplicate check error:",
+            e
+        )
+
+        return False
+
+
+# ============================================================
+# SAVE VEHICLE
+# ============================================================
+
+def save_vehicle(
+    plate,
+    status
+):
+
+    if status == "EV":
+
+        discount = EV_DISCOUNT
+
+    else:
+
+        discount = 0
+
+
+    # Do not use duplicate filtering for UNKNOWN OCR
+    if plate != "UNKNOWN":
+
+        if is_duplicate_vehicle(
+            plate
+        ):
+
+            return "Duplicate"
+
+
+    current_time = datetime.now().strftime(
+        "%Y-%m-%d %H:%M:%S"
+    )
+
+
+    try:
+
+        cursor.execute("""
+        INSERT INTO vehicles(
+
+            timestamp,
+            license_plate,
+            vehicle_status,
+            discount
+
+        )
+
+        VALUES (?, ?, ?, ?)
+
+        """, (
+
+            current_time,
+            plate,
+            status,
+            discount
+
+        ))
+
+
+        conn.commit()
+
+        return "Saved"
+
+
+    except Exception as e:
+
+        print(
+            "Database save error:",
+            e
+        )
+
+        return "Error"
+
+
+# ============================================================
+# STATIC DASHBOARD
+# ============================================================
+
+def get_dashboard():
+
+    df = get_vehicle_dataframe()
+
+    fig, axs = plt.subplots(
+        2,
+        2,
+        figsize=(10, 7)
+    )
+
+
+    # --------------------------------------------------------
+    # NO DATA
+    # --------------------------------------------------------
+
+    if df.empty:
+
+        for ax in axs.flatten():
+
+            ax.text(
+                0.5,
+                0.5,
+                "No Data Available",
+                ha="center",
+                va="center",
+                fontsize=12
+            )
+
+            ax.axis("off")
+
+
+        plt.tight_layout()
+
+        return fig
+
+
+    # --------------------------------------------------------
+    # VEHICLE STATUS
+    # --------------------------------------------------------
+
+    status_counts = (
+        df["vehicle_status"]
+        .value_counts()
+    )
+
+
+    axs[0, 0].bar(
+        status_counts.index,
+        status_counts.values
+    )
+
+
+    axs[0, 0].set_title(
+        "EV vs Non-EV Vehicles"
+    )
+
+
+    axs[0, 0].set_ylabel(
+        "Number of Vehicles"
+    )
+
+
+    # --------------------------------------------------------
+    # PIE CHART
+    # --------------------------------------------------------
+
+    axs[0, 1].pie(
+        status_counts.values,
+        labels=status_counts.index,
+        autopct="%1.1f%%"
+    )
+
+
+    axs[0, 1].set_title(
+        "Vehicle Distribution"
+    )
+
+
+    # --------------------------------------------------------
+    # DISCOUNT
+    # --------------------------------------------------------
+
+    total_discount = int(
+        df["discount"].sum()
+    )
+
+
+    axs[1, 0].bar(
+        ["Discount"],
+        [total_discount]
+    )
+
+
+    axs[1, 0].set_title(
+        "Total EV Discount"
+    )
+
+
+    axs[1, 0].set_ylabel(
+        "Amount (₹)"
+    )
+
+
+    # --------------------------------------------------------
+    # REPORT
+    # --------------------------------------------------------
+
+    axs[1, 1].axis("off")
+
+
+    ev_count = len(
+        df[
+            df["vehicle_status"] == "EV"
+        ]
+    )
+
+
+    non_ev_count = len(
+        df[
+            df["vehicle_status"] == "Non-EV"
+        ]
+    )
+
+
+    ev_percentage = (
+
+        ev_count / len(df) * 100
+
+        if len(df) > 0
+
+        else 0
+
+    )
+
+
+    report = (
+
+        "TRAFFIC ANALYTICS REPORT\n\n"
+
+        f"Total Vehicles : {len(df)}\n\n"
+
+        f"EV Vehicles : {ev_count}\n\n"
+
+        f"Non-EV Vehicles : {non_ev_count}\n\n"
+
+        f"EV Percentage : "
+        f"{ev_percentage:.2f}%\n\n"
+
+        f"Discount Given : "
+        f"₹{total_discount}"
+
+    )
+
+
+    axs[1, 1].text(
+        0.02,
+        0.98,
+        report,
+        fontsize=10,
+        va="top"
+    )
+
+
+    plt.tight_layout()
+
+    plt.close(fig)
+
+    return fig
+
+
+# ============================================================
+# AI ANALYTICS FUNCTIONS
+# ============================================================
+
+def get_total_vehicles():
+
+    df = get_vehicle_dataframe()
+
+    return len(df)
+
+
+def get_ev_count():
+
+    df = get_vehicle_dataframe()
+
+    if df.empty:
+        return 0
+
+    return len(
+        df[
+            df["vehicle_status"] == "EV"
+        ]
+    )
+
+
+def get_non_ev_count():
+
+    df = get_vehicle_dataframe()
+
+    if df.empty:
+        return 0
+
+    return len(
+        df[
+            df["vehicle_status"] == "Non-EV"
+        ]
+    )
+
+
+def get_total_discount():
+
+    df = get_vehicle_dataframe()
+
+    if df.empty:
+        return 0
+
+    return int(
+        df["discount"].sum()
+    )
+
+
+def get_ev_percentage():
+
+    total = get_total_vehicles()
+
+    ev = get_ev_count()
+
+    if total == 0:
+        return 0
+
+    return round(
+        ev / total * 100,
+        2
+    )
+
+
+# ============================================================
+# DAILY TRAFFIC
+# ============================================================
+
+def get_daily_traffic():
+
+    df = get_vehicle_dataframe()
+
+    if df.empty:
+        return pd.DataFrame()
+
+    try:
+
+        df["timestamp"] = pd.to_datetime(
+            df["timestamp"]
+        )
+
+        df["date"] = (
+            df["timestamp"]
+            .dt.date
+        )
+
+        daily = (
+            df.groupby("date")
+            .size()
+            .reset_index(
+                name="vehicles"
+            )
+        )
+
+        return daily
+
+    except Exception as e:
+
+        print(
+            "Daily traffic error:",
+            e
+        )
+
+        return pd.DataFrame()
+
+
+# ============================================================
+# GRAPH - EV VS NON-EV
+# ============================================================
+
+def generate_ev_graph():
+
+    df = get_vehicle_dataframe()
+
+    fig, ax = plt.subplots(
+        figsize=(8, 5)
+    )
+
+
+    if df.empty:
+
+        ax.text(
+            0.5,
+            0.5,
+            "No Vehicle Data Available",
+            ha="center",
+            va="center"
+        )
+
+        ax.axis("off")
+
+        return fig
+
+
+    counts = (
+        df["vehicle_status"]
+        .value_counts()
+    )
+
+
+    ax.bar(
+        counts.index,
+        counts.values
+    )
+
+
+    ax.set_title(
+        "EV vs Non-EV Analysis"
+    )
+
+
+    ax.set_xlabel(
+        "Vehicle Status"
+    )
+
+
+    ax.set_ylabel(
+        "Number of Vehicles"
+    )
+
+
+    plt.tight_layout()
+
+    plt.close(fig)
+
+    return fig
+
+
+# ============================================================
+# GRAPH - DISCOUNT
+# ============================================================
+
+def generate_discount_graph():
+
+    df = get_vehicle_dataframe()
+
+    fig, ax = plt.subplots(
+        figsize=(8, 5)
+    )
+
+
+    if df.empty:
+
+        ax.text(
+            0.5,
+            0.5,
+            "No Discount Data Available",
+            ha="center",
+            va="center"
+        )
+
+        ax.axis("off")
+
+        return fig
+
+
+    discount_data = (
+        df.groupby(
+            "vehicle_status"
+        )["discount"]
+        .sum()
+    )
+
+
+    ax.bar(
+        discount_data.index,
+        discount_data.values
+    )
+
+
+    ax.set_title(
+        "Discount Analysis"
+    )
+
+
+    ax.set_xlabel(
+        "Vehicle Status"
+    )
+
+
+    ax.set_ylabel(
+        "Discount Amount (₹)"
+    )
+
+
+    plt.tight_layout()
+
+    plt.close(fig)
+
+    return fig
+
+
+# ============================================================
+# GRAPH - DAILY TRAFFIC
+# ============================================================
+
+def generate_daily_traffic_graph():
+
+    daily = get_daily_traffic()
+
+    fig, ax = plt.subplots(
+        figsize=(9, 5)
+    )
+
+
+    if daily.empty:
+
+        ax.text(
+            0.5,
+            0.5,
+            "No Traffic Data Available",
+            ha="center",
+            va="center"
+        )
+
+        ax.axis("off")
+
+        return fig
+
+
+    ax.plot(
+        daily["date"].astype(str),
+        daily["vehicles"],
+        marker="o"
+    )
+
+
+    ax.set_title(
+        "Daily Traffic Volume"
+    )
+
+
+    ax.set_xlabel(
+        "Date"
+    )
+
+
+    ax.set_ylabel(
+        "Number of Vehicles"
+    )
+
+
+    plt.xticks(
+        rotation=45
+    )
+
+
+    plt.tight_layout()
+
+    plt.close(fig)
+
+    return fig
+
+
+# ============================================================
+# GRAPH - EV DAILY TRAFFIC
+# ============================================================
+
+def generate_ev_daily_graph():
+
+    df = get_vehicle_dataframe()
+
+    fig, ax = plt.subplots(
+        figsize=(9, 5)
+    )
+
+
+    if df.empty:
+
+        ax.text(
+            0.5,
+            0.5,
+            "No EV Data Available",
+            ha="center",
+            va="center"
+        )
+
+        ax.axis("off")
+
+        return fig
+
+
+    try:
+
+        df["timestamp"] = pd.to_datetime(
+            df["timestamp"]
+        )
+
+        df["date"] = (
+            df["timestamp"]
+            .dt.date
+        )
+
+
+        ev_df = df[
+            df["vehicle_status"] == "EV"
+        ]
+
+
+        if ev_df.empty:
+
+            ax.text(
+                0.5,
+                0.5,
+                "No EV Vehicles Available",
+                ha="center",
+                va="center"
+            )
+
+            ax.axis("off")
+
+            return fig
+
+
+        daily_ev = (
+            ev_df.groupby("date")
+            .size()
+            .reset_index(
+                name="EV Vehicles"
+            )
+        )
+
+
+        ax.plot(
+            daily_ev["date"].astype(str),
+            daily_ev["EV Vehicles"],
+            marker="o"
+        )
+
+
+        ax.set_title(
+            "Daily EV Traffic"
+        )
+
+
+        ax.set_xlabel(
+            "Date"
+        )
+
+
+        ax.set_ylabel(
+            "EV Vehicles"
+        )
+
+
+        plt.xticks(
+            rotation=45
+        )
+
+
+        plt.tight_layout()
+
+        plt.close(fig)
+
+        return fig
+
+
+    except Exception as e:
+
+        print(
+            "EV graph error:",
+            e
+        )
+
+        ax.text(
+            0.5,
+            0.5,
+            "Unable to generate graph",
+            ha="center",
+            va="center"
+        )
+
+        ax.axis("off")
+
+        return fig
+
+
+# ============================================================
+# AGENTIC AI QUERY ENGINE
+# ============================================================
+
+def traffic_ai_agent(user_query):
+
+    if user_query is None:
+
+        return (
+            "Please enter a question.",
+            None
+        )
+
+
+    query = user_query.strip().lower()
+
+
+    if query == "":
+
+        return (
+            "Please enter a question.",
+            None
+        )
+
+
+    # ========================================================
+    # GET LIVE DATABASE VALUES
+    # ========================================================
+
+    total = get_total_vehicles()
+
+    ev = get_ev_count()
+
+    non_ev = get_non_ev_count()
+
+    discount = get_total_discount()
+
+    ev_percentage = get_ev_percentage()
+
+
+    # ========================================================
+    # EV COUNT
+    # ========================================================
+
+    if (
+        "how many ev" in query
+        or "number of ev" in query
+        or "ev count" in query
+        or "ev vehicles" in query
+    ):
+
+        response = (
+
+            "🤖 AI TRAFFIC ANALYSIS\n\n"
+
+            f"EV vehicles detected: {ev}\n\n"
+
+            f"Total vehicles: {total}\n\n"
+
+            f"EV percentage: "
+            f"{ev_percentage:.2f}%"
+
+        )
+
+
+        return (
+            response,
+            generate_ev_graph()
+        )
+
+
+    # ========================================================
+    # NON-EV
+    # ========================================================
+
+    if (
+        "non ev" in query
+        or "non-ev" in query
+        or "non electric" in query
+    ):
+
+        response = (
+
+            "🤖 AI TRAFFIC ANALYSIS\n\n"
+
+            f"Non-EV vehicles detected: "
+            f"{non_ev}\n\n"
+
+            f"EV vehicles detected: {ev}\n\n"
+
+            f"Total vehicles: {total}"
+
+        )
+
+
+        return (
+            response,
+            generate_ev_graph()
+        )
+
+
+    # ========================================================
+    # EV PERCENTAGE
+    # ========================================================
+
+    if (
+        "percentage" in query
+        or "percent" in query
+        or "ratio" in query
+        or "proportion" in query
+    ):
+
+        response = (
+
+            "🤖 AI EV ANALYSIS\n\n"
+
+            f"Total vehicles: {total}\n\n"
+
+            f"EV vehicles: {ev}\n\n"
+
+            f"Non-EV vehicles: {non_ev}\n\n"
+
+            f"EV percentage: "
+            f"{ev_percentage:.2f}%"
+
+        )
+
+
+        return (
+            response,
+            generate_ev_graph()
+        )
+
+
+    # ========================================================
+    # DISCOUNT
+    # ========================================================
+
+    if (
+        "discount" in query
+        or "incentive" in query
+        or "saving" in query
+        or "savings" in query
+    ):
+
+        response = (
+
+            "🤖 AI INCENTIVE ANALYSIS\n\n"
+
+            f"EV vehicles: {ev}\n\n"
+
+            f"Discount per EV: "
+            f"₹{EV_DISCOUNT}\n\n"
+
+            f"Total discount provided: "
+            f"₹{discount}"
+
+        )
+
+
+        return (
+            response,
+            generate_discount_graph()
+        )
+
+
+    # ========================================================
+    # DAILY TRAFFIC
+    # ========================================================
+
+    if (
+        "daily traffic" in query
+        or "traffic by day" in query
+        or "traffic trend" in query
+        or "trend" in query
+    ):
+
+        daily = get_daily_traffic()
+
+
+        if daily.empty:
+
+            response = (
+                "🤖 No daily traffic data "
+                "is currently available."
+            )
+
+        else:
+
+            highest = daily.loc[
+                daily["vehicles"].idxmax()
+            ]
+
+
+            response = (
+
+                "🤖 DAILY TRAFFIC ANALYSIS\n\n"
+
+                f"Number of recorded days: "
+                f"{len(daily)}\n\n"
+
+                f"Highest traffic date: "
+                f"{highest['date']}\n\n"
+
+                f"Vehicles on highest traffic date: "
+                f"{highest['vehicles']}"
+
+            )
+
+
+        return (
+            response,
+            generate_daily_traffic_graph()
+        )
+
+
+    # ========================================================
+    # EV DAILY TRAFFIC
+    # ========================================================
+
+    if (
+        "ev trend" in query
+        or "daily ev" in query
+        or "ev traffic" in query
+    ):
+
+        response = (
+
+            "🤖 EV TRAFFIC TREND\n\n"
+
+            f"Total EV vehicles: {ev}\n\n"
+
+            f"Overall EV percentage: "
+            f"{ev_percentage:.2f}%"
+
+        )
+
+
+        return (
+            response,
+            generate_ev_daily_graph()
+        )
+
+
+    # ========================================================
+    # TOTAL VEHICLES
+    # ========================================================
+
+    if (
+        "total vehicle" in query
+        or "total traffic" in query
+        or "how many vehicle" in query
+        or "number of vehicle" in query
+    ):
+
+        response = (
+
+            "🤖 TRAFFIC ANALYSIS\n\n"
+
+            f"Total vehicles detected: {total}\n\n"
+
+            f"EV vehicles: {ev}\n\n"
+
+            f"Non-EV vehicles: {non_ev}"
+
+        )
+
+
+        return (
+            response,
+            generate_ev_graph()
+        )
+
+
+    # ========================================================
+    # CO2
+    # ========================================================
+
+    if (
+        "co2" in query
+        or "carbon" in query
+        or "environment" in query
+        or "emission" in query
+    ):
+
+        # Project-level illustrative estimate.
+        # Replace with validated emission methodology
+        # for final research evaluation.
+
+        estimated_co2 = ev * 2.3
+
+
+        response = (
+
+            "🌱 AI ENVIRONMENTAL ANALYSIS\n\n"
+
+            f"EV vehicles detected: {ev}\n\n"
+
+            f"Illustrative estimated CO₂ saving: "
+            f"{estimated_co2:.2f} kg\n\n"
+
+            "This is a project-level estimation. "
+            "For a research publication, the emission "
+            "factor and travel-distance assumptions "
+            "should be validated using an appropriate "
+            "transportation emissions methodology."
+
+        )
+
+
+        return (
+            response,
+            generate_ev_graph()
+        )
+
+
+    # ========================================================
+    # SUMMARY / REPORT
+    # ========================================================
+
+    if (
+        "summary" in query
+        or "overall" in query
+        or "report" in query
+        or "dashboard" in query
+    ):
+
+        response = (
+
+            "🤖 SMART TRAFFIC AI SUMMARY\n\n"
+
+            f"🚗 Total Vehicles: {total}\n\n"
+
+            f"⚡ EV Vehicles: {ev}\n\n"
+
+            f"🚙 Non-EV Vehicles: {non_ev}\n\n"
+
+            f"📊 EV Percentage: "
+            f"{ev_percentage:.2f}%\n\n"
+
+            f"💰 Total Discount: ₹{discount}"
+
+        )
+
+
+        return (
+            response,
+            generate_ev_graph()
+        )
+
+
+    # ========================================================
+    # HELP
+    # ========================================================
+
+    response = (
+
+        "🤖 Smart Traffic AI Assistant\n\n"
+
+        "I can analyse the vehicle database. "
+        "Try asking:\n\n"
+
+        "• How many EV vehicles were detected?\n"
+
+        "• How many Non-EV vehicles are there?\n"
+
+        "• What is the total traffic?\n"
+
+        "• What percentage of vehicles are EVs?\n"
+
+        "• What is the total discount?\n"
+
+        "• Show daily traffic trend.\n"
+
+        "• Show EV traffic trend.\n"
+
+        "• Give me an overall summary.\n"
+
+        "• What are the CO2 savings?"
+
+    )
+
+
+    return (
+        response,
+        None
+    )
+
+
+# ============================================================
+# VEHICLE IMAGE PROCESSING
+# ============================================================
+
+def process_image(img):
+
+    if img is None:
+
+        return (
+
+            None,
+
+            "Please upload an image.",
+
+            "0",
+
+            "0",
+
+            "₹0",
+
+            get_dashboard()
+
+        )
+
+
+    try:
+
+        # ----------------------------------------------------
+        # Convert input to PIL
+        # ----------------------------------------------------
+
+        if isinstance(img, np.ndarray):
+
+            image = Image.fromarray(
+                img.astype(np.uint8)
+            )
+
+        elif isinstance(img, Image.Image):
+
+            image = img.copy()
+
+        else:
+
+            return (
 
-green_ratio = (
-    np.count_nonzero(green)
-    / green.size
-)
+                None,
 
-# EV classification
-if green_ratio > 0.15:
-    return "EV"
+                "Unsupported image format.",
 
-return "Non-EV"
-```
+                "0",
 
-# ============================================================
+                "0",
 
-# DUPLICATE VEHICLE CHECK
+                "₹0",
 
-# ============================================================
+                get_dashboard()
 
-def is_duplicate_vehicle(plate_number):
+            )
 
-```
-cursor.execute("""
-SELECT timestamp
-FROM vehicles
-WHERE license_plate=?
-ORDER BY id DESC
-LIMIT 1
-""", (plate_number,))
 
-row = cursor.fetchone()
+        # ----------------------------------------------------
+        # YOLOS PROCESSING
+        # ----------------------------------------------------
 
-if row is None:
-    return False
+        inputs = processor(
+            images=image,
+            return_tensors="pt"
+        )
 
-last_time = datetime.strptime(
-    row[0],
-    "%Y-%m-%d %H:%M:%S"
-)
 
-if datetime.now() - last_time < timedelta(minutes=5):
-    return True
+        with torch.no_grad():
 
-return False
-```
+            outputs = model(
+                **inputs
+            )
 
-# ============================================================
 
-# SAVE VEHICLE TO DATABASE
+        target_sizes = torch.tensor(
+            [
+                [
+                    image.size[1],
+                    image.size[0]
+                ]
+            ]
+        )
 
-# ============================================================
 
-def save_vehicle(plate, status):
+        results = (
+            processor
+            .post_process_object_detection(
+                outputs,
+                threshold=0.30,
+                target_sizes=target_sizes
+            )[0]
+        )
 
-```
-if status == "EV":
-    discount = 50
-else:
-    discount = 0
 
-if is_duplicate_vehicle(plate):
-    return "Duplicate"
+        draw = ImageDraw.Draw(
+            image
+        )
 
-current_time = datetime.now().strftime(
-    "%Y-%m-%d %H:%M:%S"
-)
 
-cursor.execute("""
+        ev_count = 0
 
-INSERT INTO vehicles(
+        non_ev_count = 0
 
-    timestamp,
-    license_plate,
-    vehicle_status,
-    discount
+        discount_total = 0
 
-)
+        output_text = ""
 
-VALUES (?, ?, ?, ?)
 
-""", (
-    current_time,
-    plate,
-    status,
-    discount
-))
+        # ----------------------------------------------------
+        # NO PLATE DETECTION
+        # ----------------------------------------------------
 
-conn.commit()
+        if len(results["boxes"]) == 0:
 
-return "Saved"
-```
+            return (
 
-# ============================================================
+                image,
 
-# GET STATIC DASHBOARD
+                "No license plate detected.",
 
-# ============================================================
+                "0",
 
-def get_dashboard():
+                "0",
 
-```
-df = pd.read_sql(
-    "SELECT * FROM vehicles",
-    conn
-)
+                "₹0",
 
-fig, axs = plt.subplots(
-    2,
-    2,
-    figsize=(10, 7)
-)
+                get_dashboard()
 
-if df.empty:
+            )
 
-    for ax in axs.flatten():
 
-        ax.text(
-            0.5,
-            0.5,
-            "No Data Available",
-            ha="center",
-            va="center",
-            fontsize=12
-        )
+        # ----------------------------------------------------
+        # PROCESS EACH DETECTED PLATE
+        # ----------------------------------------------------
 
-        ax.axis("off")
+        processed_count = 0
 
-    plt.tight_layout()
 
-    return fig
+        for i, box in enumerate(
+            results["boxes"]
+        ):
 
-# --------------------------------------------------------
-# EV VS NON-EV
-# --------------------------------------------------------
 
-status_counts = (
-    df["vehicle_status"]
-    .value_counts()
-)
+            x1, y1, x2, y2 = map(
+                int,
+                box.tolist()
+            )
 
-axs[0, 0].bar(
-    status_counts.index,
-    status_counts.values
-)
 
-axs[0, 0].set_title(
-    "EV vs Non-EV Vehicles"
-)
+            # ------------------------------------------------
+            # Boundary validation
+            # ------------------------------------------------
 
-axs[0, 0].set_ylabel(
-    "Number of Vehicles"
-)
+            x1 = max(
+                0,
+                min(x1, image.width - 1)
+            )
 
+            y1 = max(
+                0,
+                min(y1, image.height - 1)
+            )
 
-# --------------------------------------------------------
-# PIE CHART
-# --------------------------------------------------------
+            x2 = max(
+                0,
+                min(x2, image.width)
+            )
 
-axs[0, 1].pie(
-    status_counts.values,
-    labels=status_counts.index,
-    autopct="%1.1f%%"
-)
+            y2 = max(
+                0,
+                min(y2, image.height)
+            )
 
-axs[0, 1].set_title(
-    "Vehicle Distribution"
-)
 
+            if x2 <= x1 or y2 <= y1:
+                continue
 
-# --------------------------------------------------------
-# DISCOUNT
-# --------------------------------------------------------
 
-total_discount = df["discount"].sum()
+            # ------------------------------------------------
+            # Crop license plate
+            # ------------------------------------------------
 
-axs[1, 0].bar(
-    ["Total Discount"],
-    [total_discount]
-)
+            plate = image.crop(
+                (
+                    x1,
+                    y1,
+                    x2,
+                    y2
+                )
+            )
 
-axs[1, 0].set_title(
-    "EV Discount Provided"
-)
 
-axs[1, 0].set_ylabel(
-    "Amount (₹)"
-)
+            # ------------------------------------------------
+            # EV / NON-EV
+            # ------------------------------------------------
 
+            status = classify_plate_color(
+                plate
+            )
 
-# --------------------------------------------------------
-# REPORT
-# --------------------------------------------------------
 
-axs[1, 1].axis("off")
+            # ------------------------------------------------
+            # OCR
+            # ------------------------------------------------
 
-ev_count = len(
-    df[
-        df["vehicle_status"] == "EV"
-    ]
-)
+            plate_number = read_license_plate(
+                plate
+            )
 
-non_ev_count = len(
-    df[
-        df["vehicle_status"] == "Non-EV"
-    ]
-)
 
-report = (
-    "TRAFFIC ANALYTICS REPORT\n\n"
-    f"Total Vehicles: {len(df)}\n\n"
-    f"EV Vehicles: {ev_count}\n\n"
-    f"Non-EV Vehicles: {non_ev_count}\n\n"
-    f"Total Discount: ₹{total_discount}"
-)
+            # ------------------------------------------------
+            # Save database record
+            # ------------------------------------------------
 
-axs[1, 1].text(
-    0.05,
-    0.95,
-    report,
-    fontsize=11,
-    va="top"
-)
+            saved = save_vehicle(
+                plate_number,
+                status
+            )
 
-plt.tight_layout()
 
-plt.close(fig)
+            if saved == "Duplicate":
 
-return fig
-```
+                output_text += (
 
-# ============================================================
+                    f"Vehicle {i + 1}\n"
 
-# AGENTIC AI DATABASE TOOLS
+                    f"Plate: {plate_number}\n"
 
-# ============================================================
+                    f"Status: {status}\n"
 
-def get_vehicle_dataframe():
+                    "Result: Duplicate - "
+                    "not added again\n\n"
 
-```
-df = pd.read_sql(
-    "SELECT * FROM vehicles",
-    conn
-)
+                )
 
-return df
-```
+                continue
 
-def get_total_vehicles():
 
-```
-df = get_vehicle_dataframe()
+            if saved == "Error":
 
-return len(df)
-```
+                output_text += (
 
-def get_ev_count():
+                    f"Vehicle {i + 1}\n"
 
-```
-df = get_vehicle_dataframe()
+                    f"Plate: {plate_number}\n"
 
-return len(
-    df[
-        df["vehicle_status"] == "EV"
-    ]
-)
-```
+                    f"Status: {status}\n"
 
-def get_non_ev_count():
+                    "Database: Error\n\n"
 
-```
-df = get_vehicle_dataframe()
+                )
 
-return len(
-    df[
-        df["vehicle_status"] == "Non-EV"
-    ]
-)
-```
 
-def get_total_discount():
+            # ------------------------------------------------
+            # EV
+            # ------------------------------------------------
 
-```
-df = get_vehicle_dataframe()
+            if status == "EV":
 
-if df.empty:
-    return 0
+                ev_count += 1
 
-return int(df["discount"].sum())
-```
+                discount = EV_DISCOUNT
 
-def get_ev_percentage():
+                discount_total += discount
 
-```
-total = get_total_vehicles()
+                label = (
+                    f"{plate_number} | "
+                    f"EV | ₹{discount}"
+                )
 
-ev_count = get_ev_count()
+                outline_color = "green"
 
-if total == 0:
-    return 0
 
-return round(
-    (ev_count / total) * 100,
-    2
-)
-```
+            # ------------------------------------------------
+            # NON-EV
+            # ------------------------------------------------
 
-# ============================================================
+            else:
 
-# DYNAMIC GRAPH GENERATOR
+                non_ev_count += 1
 
-# ============================================================
+                discount = 0
 
-def generate_ev_graph():
+                label = (
+                    f"{plate_number} | Non-EV"
+                )
 
-```
-df = get_vehicle_dataframe()
+                outline_color = "red"
 
-fig, ax = plt.subplots(
-    figsize=(8, 5)
-)
 
-if df.empty:
+            processed_count += 1
 
-    ax.text(
-        0.5,
-        0.5,
-        "No Vehicle Data Available",
-        ha="center",
-        va="center",
-        fontsize=14
-    )
 
-    ax.axis("off")
+            # ------------------------------------------------
+            # Draw bounding box
+            # ------------------------------------------------
 
-    return fig
+            draw.rectangle(
+                [
+                    x1,
+                    y1,
+                    x2,
+                    y2
+                ],
+                outline=outline_color,
+                width=4
+            )
 
-counts = (
-    df["vehicle_status"]
-    .value_counts()
-)
 
-ax.bar(
-    counts.index,
-    counts.values
-)
+            # ------------------------------------------------
+            # Draw label background
+            # ------------------------------------------------
 
-ax.set_title(
-    "EV vs Non-EV Vehicle Analysis"
-)
+            text_y = max(
+                0,
+                y1 - 22
+            )
 
-ax.set_xlabel(
-    "Vehicle Type"
-)
 
-ax.set_ylabel(
-    "Number of Vehicles"
-)
+            draw.rectangle(
+                [
+                    x1,
+                    text_y,
+                    min(
+                        image.width,
+                        x1 + 300
+                    ),
+                    y1
+                ],
+                fill="black"
+            )
 
-plt.tight_layout()
 
-return fig
-```
+            draw.text(
+                (
+                    x1 + 3,
+                    text_y + 3
+                ),
+                label,
+                fill=outline_color
+            )
 
-def generate_discount_graph():
 
-```
-df = get_vehicle_dataframe()
+            # ------------------------------------------------
+            # Output summary
+            # ------------------------------------------------
 
-fig, ax = plt.subplots(
-    figsize=(8, 5)
-)
+            output_text += (
 
-if df.empty:
+                f"Vehicle {i + 1}\n"
 
-    ax.text(
-        0.5,
-        0.5,
-        "No Discount Data Available",
-        ha="center",
-        va="center"
-    )
+                f"Plate: {plate_number}\n"
 
-    ax.axis("off")
+                f"Status: {status}\n"
 
-    return fig
+                f"Discount: ₹{discount}\n\n"
 
-discount_by_status = (
-    df.groupby("vehicle_status")["discount"]
-    .sum()
-)
+            )
 
-ax.bar(
-    discount_by_status.index,
-    discount_by_status.values
-)
 
-ax.set_title(
-    "Discount Analysis"
-)
+        # ----------------------------------------------------
+        # If every detection was invalid
+        # ----------------------------------------------------
 
-ax.set_xlabel(
-    "Vehicle Status"
-)
+        if processed_count == 0:
 
-ax.set_ylabel(
-    "Total Discount (₹)"
-)
+            return (
 
-plt.tight_layout()
+                image,
 
-return fig
-```
+                "No valid license plate was processed.",
 
-# ============================================================
+                "0",
 
-# AGENTIC AI QUERY ENGINE
+                "0",
 
-# ============================================================
+                "₹0",
 
-def traffic_ai_agent(user_query):
+                get_dashboard()
 
-```
-if not user_query:
-    return (
-        "Please ask a question about the traffic data.",
-        None
-    )
+            )
 
-query = user_query.lower()
 
-total = get_total_vehicles()
-ev_count = get_ev_count()
-non_ev_count = get_non_ev_count()
-discount = get_total_discount()
-ev_percentage = get_ev_percentage()
+        # ----------------------------------------------------
+        # Refresh dashboard
+        # ----------------------------------------------------
 
+        dashboard = get_dashboard()
 
-# --------------------------------------------------------
-# EV COUNT
-# --------------------------------------------------------
 
-if (
-    "how many ev" in query
-    or "number of ev" in query
-    or "ev count" in query
-):
+        return (
 
-    response = (
-        f"AI Analysis:\n\n"
-        f"The system has detected "
-        f"{ev_count} EV vehicle(s).\n\n"
-        f"Total vehicles analysed: {total}."
-    )
+            image,
 
-    return response, generate_ev_graph()
+            output_text,
 
+            str(ev_count),
 
-# --------------------------------------------------------
-# NON-EV COUNT
-# --------------------------------------------------------
+            str(non_ev_count),
 
-elif (
-    "non ev" in query
-    or "non-ev" in query
-):
+            f"₹{discount_total}",
 
-    response = (
-        f"AI Analysis:\n\n"
-        f"Non-EV vehicles detected: "
-        f"{non_ev_count}.\n\n"
-        f"EV vehicles detected: "
-        f"{ev_count}."
-    )
+            dashboard
 
-    return response, generate_ev_graph()
+        )
 
 
-# --------------------------------------------------------
-# TOTAL VEHICLES
-# --------------------------------------------------------
+    except Exception as e:
 
-elif (
-    "total vehicle" in query
-    or "how many vehicle" in query
-    or "traffic" in query
-):
+        print(
+            "Image processing error:",
+            e
+        )
 
-    response = (
-        f" AI Traffic Analysis:\n\n"
-        f"Total vehicles detected: "
-        f"{total}.\n\n"
-        f"EV vehicles: {ev_count}\n"
-        f"Non-EV vehicles: {non_ev_count}"
-    )
 
-    return response, generate_ev_graph()
+        return (
 
+            img,
 
-# --------------------------------------------------------
-# EV PERCENTAGE
-# --------------------------------------------------------
+            f"Processing error: {str(e)}",
 
-elif (
-    "percentage" in query
-    or "percent" in query
-):
+            "0",
 
-    response = (
-        f" AI Analysis:\n\n"
-        f"EV Percentage: "
-        f"{ev_percentage}%\n\n"
-        f"This means {ev_count} out of "
-        f"{total} detected vehicles are EVs."
-    )
+            "0",
 
-    return response, generate_ev_graph()
+            "₹0",
 
+            get_dashboard()
 
-# --------------------------------------------------------
-# DISCOUNT
-# --------------------------------------------------------
+        )
 
-elif (
-    "discount" in query
-    or "incentive" in query
-    or "money" in query
-):
 
-    response = (
-        f"AI Discount Analysis:\n\n"
-        f"Total EV discount provided: "
-        f"₹{discount}.\n\n"
-        f"Number of EV vehicles: "
-        f"{ev_count}."
-    )
+# ============================================================
+# REFRESH DASHBOARD
+# ============================================================
 
-    return response, generate_discount_graph()
+def refresh_dashboard():
 
+    return get_dashboard()
 
-# --------------------------------------------------------
-# CO2 SAVINGS
-# --------------------------------------------------------
 
-elif (
-    "co2" in query
-    or "carbon" in query
-    or "environment" in query
-):
+# ============================================================
+# CLEAR AI QUERY
+# ============================================================
 
-    # Example estimation
-    co2_savings = ev_count * 2.3
+def clear_ai():
 
-    response = (
-        f" AI Environmental Analysis:\n\n"
-        f"Based on the configured estimation model, "
-        f"{ev_count} EV vehicles could contribute to "
-        f"approximately {co2_savings:.2f} kg of "
-        f"potential CO₂ savings.\n\n"
-        f"Note: This value is an estimated project "
-        f"metric and can be replaced with a validated "
-        f"emission calculation model."
+    return (
+        "",
+        "",
+        None
     )
 
-    return response, generate_ev_graph()
 
+# ============================================================
+# CSS
+# ============================================================
 
-# --------------------------------------------------------
-# SUMMARY
-# --------------------------------------------------------
+css = """
 
-elif (
-    "summary" in query
-    or "report" in query
-    or "overall" in query
-):
+.gradio-container {
 
-    response = (
-        f"SMART TRAFFIC AI SUMMARY\n\n"
-        f"Total Vehicles: {total}\n\n"
-        f"EV Vehicles: {ev_count}\n\n"
-        f"Non-EV Vehicles: {non_ev_count}\n\n"
-        f"EV Percentage: {ev_percentage}%\n\n"
-        f"Total Discount: ₹{discount}"
-    )
+    max-width: 98% !important;
 
-    return response, generate_ev_graph()
+    margin: auto;
 
+}
 
-# --------------------------------------------------------
-# DEFAULT RESPONSE
-# --------------------------------------------------------
+textarea {
 
-else:
+    font-size: 15px !important;
 
-    response = (
-        "I am your Smart Traffic AI Assistant.\n\n"
-        "You can ask questions such as:\n\n"
-        "• How many EV vehicles were detected?\n"
-        "• How many Non-EV vehicles are there?\n"
-        "• What is the total traffic?\n"
-        "• What percentage of vehicles are EVs?\n"
-        "• What is the total EV discount?\n"
-        "• Give me a traffic summary.\n"
-        "• Show CO₂ savings."
-    )
+}
 
-    return response, None
-```
+h1 {
 
-# ============================================================
+    text-align: center;
 
-# MAIN VEHICLE PROCESSING PIPELINE
+}
 
-# ============================================================
+.block {
 
-def process_image(img):
+    border-radius: 12px;
 
-```
-if img is None:
+}
 
-    return (
-        None,
-        "Please upload an image.",
-        "0",
-        "0",
-        "₹0",
-        get_dashboard()
-    )
+.gr-image {
 
+    min-height: 350px;
 
-image = Image.fromarray(img)
+}
 
+"""
 
-# --------------------------------------------------------
-# MODEL INPUT
-# --------------------------------------------------------
 
-inputs = processor(
-    images=image,
-    return_tensors="pt"
-)
+# ============================================================
+# GRADIO APPLICATION
+# ============================================================
 
-with torch.no_grad():
+with gr.Blocks(
+    css=css
+) as demo:
 
-    outputs = model(**inputs)
 
+    # ========================================================
+    # TITLE
+    # ========================================================
 
-target_sizes = torch.tensor([
-    [
-        image.size[1],
-        image.size[0]
-    ]
-])
+    gr.Markdown(
+        "# 🚦 Smart Traffic & EV Analytics System"
+    )
 
 
-results = processor.post_process_object_detection(
-    outputs,
-    threshold=0.3,
-    target_sizes=target_sizes
-)[0]
+    gr.Markdown(
+        "YOLOS License Plate Detection • "
+        "OpenCV EV Classification • "
+        "EasyOCR • EV Incentives • "
+        "Dynamic AI Analytics"
+    )
 
 
-draw = ImageDraw.Draw(image)
+    # ========================================================
+    # TAB 1 - VEHICLE DETECTION
+    # ========================================================
 
+    with gr.Tab(
+        "🚗 Vehicle Detection"
+    ):
 
-ev_count = 0
-non_ev_count = 0
-discount_total = 0
 
-output_text = ""
+        with gr.Row(
+            equal_height=True
+        ):
 
 
-# --------------------------------------------------------
-# NO DETECTION
-# --------------------------------------------------------
+            # ------------------------------------------------
+            # INPUT
+            # ------------------------------------------------
 
-if len(results["boxes"]) == 0:
+            with gr.Column(
+                scale=1
+            ):
 
-    return (
-        image,
-        "No license plate detected.",
-        "0",
-        "0",
-        "₹0",
-        get_dashboard()
-    )
+                input_img = gr.Image(
 
+                    type="numpy",
 
-# --------------------------------------------------------
-# PROCESS DETECTED PLATES
-# --------------------------------------------------------
+                    label="Input Vehicle Image",
 
-for i, box in enumerate(results["boxes"]):
+                    sources=[
+                        "upload",
+                        "webcam"
+                    ],
 
-    x1, y1, x2, y2 = map(
-        int,
-        box.tolist()
-    )
+                    height=350
 
+                )
 
-    # Crop plate
-    plate = image.crop(
-        (x1, y1, x2, y2)
-    )
 
+                btn = gr.Button(
 
-    # Classify EV / Non-EV
-    status = classify_plate_color(
-        plate
-    )
+                    "🔍 Scan Vehicle",
 
+                    variant="primary",
 
-    # Temporary vehicle ID
-    plate_number = (
-        f"Vehicle_"
-        f"{datetime.now().strftime('%H%M%S%f')}"
-        f"_{i}"
-    )
+                    size="lg"
 
+                )
 
-    saved = save_vehicle(
-        plate_number,
-        status
-    )
 
+            # ------------------------------------------------
+            # OUTPUT
+            # ------------------------------------------------
 
-    if saved == "Duplicate":
-        continue
+            with gr.Column(
+                scale=1
+            ):
 
+                output_img = gr.Image(
 
-    # ----------------------------------------------------
-    # EV
-    # ----------------------------------------------------
+                    label="Detection Result",
 
-    if status == "EV":
+                    height=350
 
-        ev_count += 1
+                )
 
-        discount = 50
 
-        discount_total += discount
+            # ------------------------------------------------
+            # SUMMARY
+            # ------------------------------------------------
 
-        color = "green"
+            with gr.Column(
+                scale=1
+            ):
 
-        label = (
-            f"EV | ₹{discount}"
-        )
+                summary_box = gr.Textbox(
 
+                    label="Detection Summary",
 
-    # ----------------------------------------------------
-    # NON-EV
-    # ----------------------------------------------------
+                    lines=16
 
-    else:
+                )
 
-        non_ev_count += 1
 
-        discount = 0
+        # ====================================================
+        # STATISTICS
+        # ====================================================
 
-        color = "red"
+        with gr.Row():
 
-        label = "Non-EV"
 
+            ev_box = gr.Textbox(
+                label="⚡ EV Vehicles"
+            )
 
-    # Draw bounding box
 
-    draw.rectangle(
-        [x1, y1, x2, y2],
-        outline=color,
-        width=3
-    )
+            non_ev_box = gr.Textbox(
+                label="🚗 Non-EV Vehicles"
+            )
 
 
-    # Draw label
+            discount_box = gr.Textbox(
+                label="💰 Total Discount"
+            )
 
-    draw.text(
-        (
-            x1,
-            max(0, y1 - 25)
-        ),
-        label,
-        fill=color
-    )
 
+        # ====================================================
+        # STATIC DASHBOARD
+        # ====================================================
 
-    output_text += (
+        gr.Markdown(
+            "## 📊 Traffic Analytics Dashboard"
+        )
 
-        f"Vehicle {i+1}\n"
-        f"Plate ID: {plate_number}\n"
-        f"Status: {status}\n"
-        f"Discount: ₹{discount}\n\n"
 
-    )
+        dashboard = gr.Plot(
+            label="Analytics"
+        )
 
 
-dashboard = get_dashboard()
+        btn.click(
 
+            fn=process_image,
 
-return (
+            inputs=input_img,
 
-    image,
+            outputs=[
 
-    output_text,
+                output_img,
 
-    str(ev_count),
+                summary_box,
 
-    str(non_ev_count),
+                ev_box,
 
-    f"₹{discount_total}",
+                non_ev_box,
 
-    dashboard
+                discount_box,
 
-)
-```
+                dashboard
 
-# ============================================================
+            ]
 
-# GRADIO UI
+        )
 
-# ============================================================
 
-css = """
+    # ========================================================
+    # TAB 2 - AGENTIC AI DASHBOARD
+    # ========================================================
 
-.gradio-container {
-max-width: 98% !important;
-margin: auto;
-}
+    with gr.Tab(
+        "🤖 Agentic AI Dashboard"
+    ):
 
-textarea {
-font-size: 15px !important;
-}
 
-h1 {
-text-align: center;
-}
+        gr.Markdown(
+            "## 🤖 Agentic AI Traffic Analytics Assistant"
+        )
 
-.block {
-border-radius: 12px;
-}
 
-.gr-image {
-min-height: 350px;
-}
+        gr.Markdown(
+            """
+Ask questions about your vehicle database
+using natural language.
 
+The AI analytics layer dynamically reads the
+SQLite database and selects the appropriate
+analytics operation.
 """
+        )
 
-with gr.Blocks(css=css) as demo:
-
-```
-# ========================================================
-# TITLE
-# ========================================================
-
-gr.Markdown(
-    "# Smart Traffic & EV Analytics System"
-)
 
-gr.Markdown(
-    "AI License Plate Detection • EV Classification • "
-    "Discount Calculation • Agentic AI Analytics"
-)
+        # ----------------------------------------------------
+        # Query input
+        # ----------------------------------------------------
 
+        user_query = gr.Textbox(
 
-# ========================================================
-# TAB 1 - VEHICLE DETECTION
-# ========================================================
+            label="Ask your traffic analytics question",
 
-with gr.Tab("🚗 Vehicle Detection"):
+            placeholder=(
+                "Example: How many EV vehicles "
+                "were detected?"
+            ),
 
+            lines=3
 
-    with gr.Row(equal_height=True):
+        )
 
 
-        # INPUT
+        with gr.Row():
 
-        with gr.Column(scale=1):
 
-            input_img = gr.Image(
-                type="numpy",
-                label="Input Vehicle Image",
-                sources=[
-                    "upload",
-                    "webcam"
-                ],
-                height=350
-            )
+            ask_button = gr.Button(
 
+                "🤖 Ask AI",
 
-            btn = gr.Button(
-                "Scan Vehicle",
                 variant="primary",
+
                 size="lg"
+
             )
 
 
-        # OUTPUT IMAGE
+            clear_button = gr.Button(
+
+                "Clear",
 
-        with gr.Column(scale=1):
+                size="lg"
 
-            output_img = gr.Image(
-                label="Detection Result",
-                height=350
             )
 
 
-        # SUMMARY
+        # ----------------------------------------------------
+        # AI RESPONSE
+        # ----------------------------------------------------
 
-        with gr.Column(scale=1):
+        ai_response = gr.Textbox(
 
-            summary_box = gr.Textbox(
-                label="Detection Summary",
-                lines=16
-            )
+            label="🤖 AI Analysis",
 
+            lines=12
 
-    # ====================================================
-    # STATISTICS
-    # ====================================================
+        )
 
-    with gr.Row():
 
-        ev_box = gr.Textbox(
-            label="EV Vehicles"
-        )
+        # ----------------------------------------------------
+        # DYNAMIC GRAPH
+        # ----------------------------------------------------
 
-        non_ev_box = gr.Textbox(
-            label="Non-EV Vehicles"
-        )
+        ai_graph = gr.Plot(
 
-        discount_box = gr.Textbox(
-            label="Total Discount"
-        )
+            label="📊 Dynamic AI Visualization"
 
+        )
 
-    # ====================================================
-    # STATIC DASHBOARD
-    # ====================================================
 
-    gr.Markdown(
-        "##  Traffic Analytics Dashboard"
-    )
+        # ----------------------------------------------------
+        # BUTTON ACTION
+        # ----------------------------------------------------
 
-    dashboard = gr.Plot(
-        label="Analytics"
-    )
+        ask_button.click(
 
+            fn=traffic_ai_agent,
 
-    btn.click(
+            inputs=user_query,
 
-        fn=process_image,
+            outputs=[
+                ai_response,
+                ai_graph
+            ]
 
-        inputs=input_img,
+        )
 
-        outputs=[
-            output_img,
-            summary_box,
-            ev_box,
-            non_ev_box,
-            discount_box,
-            dashboard
-        ]
 
-    )
+        clear_button.click(
 
+            fn=clear_ai,
 
-# ========================================================
-# TAB 2 - AGENTIC AI DASHBOARD
-# ========================================================
+            inputs=[],
 
-with gr.Tab("AI Traffic Assistant"):
+            outputs=[
+                user_query,
+                ai_response,
+                ai_graph
+            ]
 
+        )
 
-    gr.Markdown(
-        "## Agentic AI Traffic Analytics Dashboard"
-    )
 
+        # ====================================================
+        # SUGGESTED QUESTIONS
+        # ====================================================
 
-    gr.Markdown(
-        "Ask questions about your traffic and EV database "
-        "using natural language."
-    )
+        gr.Markdown(
+            """
+### 💡 Suggested Questions
 
+**Traffic**
+- How many vehicles were detected?
+- What is the total traffic?
+- Show daily traffic trend.
 
-    user_query = gr.Textbox(
+**EV Analysis**
+- How many EV vehicles were detected?
+- How many Non-EV vehicles are there?
+- What percentage of vehicles are EVs?
+- Show EV traffic trend.
 
-        label="Ask the AI Assistant",
+**Incentives**
+- What is the total discount?
+- How much incentive was provided?
 
-        placeholder=(
-            "Example: How many EV vehicles were detected?"
-        ),
+**Environmental**
+- What are the CO2 savings?
 
-        lines=2
+**Overall**
+- Give me an overall traffic summary.
+"""
+        )
 
-    )
 
+    # ========================================================
+    # TAB 3 - ADMIN / DATABASE
+    # ========================================================
 
-    ask_button = gr.Button(
+    with gr.Tab(
+        "⚙️ Admin Dashboard"
+    ):
 
-        "Ask AI",
 
-        variant="primary",
+        gr.Markdown(
+            "## ⚙️ Vehicle Database"
+        )
 
-        size="lg"
 
-    )
+        database_table = gr.Dataframe(
 
+            label="Stored Vehicle Records",
 
-    ai_response = gr.Textbox(
+            interactive=False
 
-        label="AI Response",
+        )
 
-        lines=12
 
-    )
+        with gr.Row():
 
 
-    ai_graph = gr.Plot(
+            refresh_button = gr.Button(
+                "🔄 Refresh Database"
+            )
 
-        label="Dynamic AI Generated Graph"
 
-    )
+            refresh_graph_button = gr.Button(
+                "📊 Refresh Dashboard"
+            )
 
 
-    ask_button.click(
+        admin_dashboard = gr.Plot(
+            label="Current Database Analytics"
+        )
 
-        fn=traffic_ai_agent,
 
-        inputs=user_query,
+        def load_database():
 
-        outputs=[
-            ai_response,
-            ai_graph
-        ]
+            return get_vehicle_dataframe()
 
-    )
 
+        refresh_button.click(
 
-    # ====================================================
-    # SUGGESTED QUESTIONS
-    # ====================================================
+            fn=load_database,
 
-    gr.Markdown(
-        """
-```
+            inputs=[],
 
-### 💡 Suggested Questions
+            outputs=database_table
 
-• How many EV vehicles were detected?
+        )
 
-• How many Non-EV vehicles are there?
 
-• What is the total traffic?
+        refresh_graph_button.click(
 
-• What percentage of vehicles are EVs?
+            fn=refresh_dashboard,
 
-• What is the total EV discount?
+            inputs=[],
 
-• Give me an overall traffic summary.
+            outputs=admin_dashboard
 
-• Show the CO₂ savings.
-"""
-)
-# ============================================================
+        )
 
-# RUN APPLICATION
 
 # ============================================================
+# APPLICATION START
+# ============================================================
+
+if __name__ == "__main__":
 
-if **name** == "**main**":
+    print(
+        "Starting Smart Traffic & EV Analytics System..."
+    )
 
-```
-demo.queue()
+    demo.queue()
 
-demo.launch(
-    ssr_mode=False
-)
-```
+    demo.launch(
+        ssr_mode=False
+    )