Update app.py

app.py

@@ -1,265 +1,155 @@
-import io
-import cv2
 import gradio as gr
-import matplotlib
-matplotlib.use("Agg")
-
 import matplotlib.pyplot as plt
-import torch
 import numpy as np
-import sqlite3
-import pandas as pd
-import pytesseract
-
 from PIL import Image
-from transformers import YolosImageProcessor, YolosForObjectDetection
-
-# ---------------- CONFIG ----------------
-
-MODEL_NAME = "nickmuchi/yolos-small-finetuned-license-plate-detection"
-BASE_AMT = 100
-
-# ---------------- DATABASE ----------------
-
-conn = sqlite3.connect("vehicles.db", check_same_thread=False)
-cursor = conn.cursor()
-
-cursor.execute("""
-CREATE TABLE IF NOT EXISTS vehicles (
-    plate TEXT,
-    type TEXT,
-    amount REAL,
-    time TEXT
-)
-""")
-
-cursor.execute("""
-CREATE TABLE IF NOT EXISTS feedback (
-    result TEXT,
-    feedback TEXT
-)
-""")
-
-conn.commit()
-
-# ---------------- MODEL (Lazy Load) ----------------
-
-processor = None
-model = None
-
-def load_model():
-    global processor, model
-    if processor is None:
-        processor = YolosImageProcessor.from_pretrained(MODEL_NAME)
-        model = YolosForObjectDetection.from_pretrained(MODEL_NAME)
-        model.eval()
-    return processor, model
-
-# ---------------- LOGIC ----------------
-
-def compute_discount(vehicle_type):
-    if vehicle_type == "EV":
-        return BASE_AMT * 0.9
-    return BASE_AMT
-
-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 "EV"
-        elif yellow > green and yellow > white:
-            return "Commercial"
-        elif white > green and white > yellow:
-            return "Personal"
-        else:
-            return "Unknown"
-
-    except Exception as e:
-        return "Unknown"
-
-def read_plate(plate_img):
-    try:
-        gray = cv2.cvtColor(np.array(plate_img), cv2.COLOR_RGB2GRAY)
-        gray = cv2.threshold(gray, 120, 255, cv2.THRESH_BINARY)[1]
-
-        text = pytesseract.image_to_string(
-            gray,
-            config="--psm 7 -c tessedit_char_whitelist=ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-        )
-        return text.strip() if text.strip() else "UNKNOWN"
-    except:
-        return "UNKNOWN"
-
-def make_prediction(img):
-    processor, model = load_model()
-    inputs = processor(images=img, return_tensors="pt")
-
-    with torch.no_grad():
-        outputs = model(**inputs)
-
-    img_size = torch.tensor([img.size[::-1]])
-    results = processor.post_process_object_detection(
-        outputs, threshold=0.3, target_sizes=img_size
-    )
-
-    return results[0], model.config.id2label
-
-# ---------------- VISUALIZATION ----------------
-
-def visualize(img, output, id2label, threshold):
-    try:
-        keep = output["scores"] > threshold
-        boxes = output["boxes"][keep]
-        labels = output["labels"][keep]
-
-        fig, ax = plt.subplots(figsize=(6,6))
-        ax.imshow(img)
-        results_text = []
+import random
+
+# -------------------------------
+# Global Counters
+# -------------------------------
+total_vehicles = 0
+ev_count = 0
+total_co2_saved = 0  # in kg
+
+# -------------------------------
+# CO2 Assumptions
+# -------------------------------
+DISTANCE_KM = 10
+CO2_PER_KM_PETROL = 0.150  # 150g = 0.15kg per km
+CO2_SAVED_PER_EV = DISTANCE_KM * CO2_PER_KM_PETROL  # 1.5 kg
+
+
+# -------------------------------
+# Dummy Vehicle Classifier
+# Replace this with your YOLO model
+# -------------------------------
+def classify_vehicle():
+    vehicle_types = [
+        "Car",
+        "Bus",
+        "Truck",
+        "Motorcycle",
+        "Electric Vehicle"
+    ]
+    return random.choice(vehicle_types)
+
+
+# -------------------------------
+# Dashboard Plot
+# -------------------------------
+def generate_dashboard():
+    global total_vehicles, ev_count, total_co2_saved
+
+    non_ev = total_vehicles - ev_count
+
+    fig, ax = plt.subplots()
+    labels = ["EV", "Non-EV"]
+    values = [ev_count, non_ev]
+
+    ax.bar(labels, values)
+    ax.set_title("Vehicle Distribution")
+    ax.set_ylabel("Count")
 
-        for box, label in zip(boxes, labels):
-            label_name = id2label[label.item()].lower()
-
-            if "plate" not in label_name:
-                continue
-
-            x1,y1,x2,y2 = map(int, box.tolist())
-            plate_img = img.crop((x1,y1,x2,y2))
-
-            plate = read_plate(plate_img)
-            vtype = classify_plate_color(plate_img)
-            toll = compute_discount(vtype)
+    return fig
 
-            cursor.execute(
-                "INSERT INTO vehicles VALUES (?, ?, ?, datetime('now'))",
-                (plate, vtype, toll)
-            )
-            conn.commit()
 
-            results_text.append(f"{plate} | {vtype} | ₹{int(toll)}")
+# -------------------------------
+# Main Detection Function
+# -------------------------------
+def detect_image(image, threshold):
 
-            ax.add_patch(
-                plt.Rectangle((x1,y1), x2-x1, y2-y1,
-                              fill=False, color="red", linewidth=2)
-            )
-            ax.text(x1, y1-5, f"{plate} ({vtype})",
-                    color="yellow", fontsize=8)
+    global total_vehicles, ev_count, total_co2_saved
 
-        ax.axis("off")
+    if image is None:
+        return None, "Please upload an image.", \
+               "### 🚘 Total Vehicles: 0", \
+               "### ⚡ EV Vehicles: 0", \
+               "### 📊 EV Adoption Rate: 0%", \
+               "### 🌱 CO₂ Saved: 0 kg", \
+               generate_dashboard()
 
-        if not results_text:
-            return fig, "No plate detected"
+    # Simulated detection
+    vehicle_type = classify_vehicle()
 
-        return fig, "\n".join(results_text)
+    total_vehicles += 1
 
-    except Exception as e:
-        return None, f"Error: {str(e)}"
+    co2_saved_this = 0
 
-# ---------------- DASHBOARD ----------------
+    if vehicle_type.lower() == "electric vehicle":
+        ev_count += 1
+        co2_saved_this = CO2_SAVED_PER_EV
+        total_co2_saved += co2_saved_this
 
-def get_dashboard():
-    df = pd.read_sql("SELECT * FROM vehicles", conn)
-    fig, ax = plt.subplots(figsize=(8,5))
+    ev_percent = (ev_count / total_vehicles) * 100
 
-    if df.empty:
-        ax.text(0.5, 0.5, "No vehicle data yet",
-                ha="center", va="center", fontsize=12)
-        ax.axis("off")
-        return fig
+    # Create dummy detection visualization
+    fig, ax = plt.subplots()
+    ax.imshow(image)
+    ax.set_title(f"Detected: {vehicle_type}")
+    ax.axis("off")
 
-    counts = df["type"].value_counts()
+    result_text = f"""
+Vehicle Type: {vehicle_type}
+Confidence Threshold Used: {threshold}
+CO₂ Saved (This Vehicle): {co2_saved_this:.2f} kg
+"""
 
-    counts.plot(kind="bar", ax=ax)
+    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"
 
-    ax.set_title("Vehicle Classification Distribution", fontsize=12)
-    ax.set_xlabel("Vehicle Type")
-    ax.set_ylabel("Number of Vehicles")
-    ax.tick_params(axis='x', rotation=30)
+    dashboard_fig = generate_dashboard()
 
-    plt.tight_layout()
-    return fig
+    return (
+        fig,
+        result_text,
+        total_card,
+        ev_card,
+        percent_card,
+        co2_card,
+        dashboard_fig
+    )
 
-def detect_image(img, threshold):
-    if img is None:
-        return None, "No image provided"
-    output, id2label = make_prediction(img)
-    return visualize(img, output, id2label, threshold)
 
-# ---------------- UI ----------------
+# -------------------------------
+# Gradio UI
+# -------------------------------
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
-with gr.Blocks() as demo:
-    gr.Markdown("## 🚦 Smart Vehicle Classification System")
+    gr.Markdown("## 🚦 Smart Vehicle Classification & EV CO₂ Analytics Dashboard")
 
-    slider = gr.Slider(0.3, 1.0, 0.5, label="Confidence Threshold")
+    slider = gr.Slider(0.3, 1.0, 0.5, step=0.05, label="Confidence Threshold")
 
     with gr.Row():
-        img_input = gr.Image(type="pil")
-        img_output = gr.Plot()
-
-    result_box = gr.Textbox(label="Detection Result", lines=4)
+        img_input = gr.Image(type="pil", label="Upload Vehicle Image")
+        img_output = gr.Plot(label="Detection Output")
 
-    dashboard_plot = gr.Plot()
-    detect_btn.click(
-    detect_image,
-    inputs=[img_input, slider],
-    outputs=[img_output, result_box, dashboard_plot]
-    )
-
-    gr.Markdown("### Feedback")
-    feedback_radio = gr.Radio(["Correct", "Incorrect"], label="Prediction correct?")
-    feedback_btn = gr.Button("Submit Feedback")
-    feedback_msg = gr.Textbox(label="Feedback Status")
-
-    feedback_btn.click(
-        submit_feedback,
-        inputs=[result_box, feedback_radio],
-        outputs=feedback_msg
-    )
-
-    gr.Markdown("### Model Accuracy")
-    accuracy_btn = gr.Button("Show Accuracy")
-    accuracy_box = gr.Textbox(label="Accuracy")
-
-    accuracy_btn.click(show_accuracy, outputs=accuracy_box)
+    result_box = gr.Textbox(label="Detection Result", lines=5)
 
-    gr.Markdown("### 📊 Dashboard")
-    dashboard_plot = gr.Plot()
+    # Metric Cards
+    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")
 
-# ---------------- FEEDBACK ----------------
+    dashboard_plot = gr.Plot(label="Analytics Dashboard")
 
-def submit_feedback(result_text, feedback_choice):
-    if not result_text:
-        return "No result available."
+    detect_btn = gr.Button("🔍 Detect Vehicle")
 
-    cursor.execute(
-        "INSERT INTO feedback VALUES (?, ?)",
-        (result_text, feedback_choice)
+    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
+        ]
     )
-    conn.commit()
-    return "Feedback recorded!"
-
-def show_accuracy():
-    df = pd.read_sql("SELECT * FROM feedback", conn)
-
-    if df.empty:
-        return "No feedback yet."
-
-    correct = len(df[df["feedback"] == "Correct"])
-    total = len(df)
-
-    accuracy = (correct / total) * 100
-    return f"Accuracy (User Feedback Based): {accuracy:.2f}%"
-
-# ---------------- CALLBACK ----------------
 
 demo.launch()