Update app.py

app.py

@@ -8,6 +8,9 @@ import torch
 import numpy as np
 import cv2
 import sqlite3
+import os
+import tempfile
+import uuid
 import pandas as pd
 import matplotlib.pyplot as plt
 import easyocr
@@ -1879,6 +1882,253 @@ def process_image(img):
         )
 
 
+
+# ============================================================
+# VIDEO PROCESSING
+# ============================================================
+
+def process_video(video_path, frame_skip=5, max_frames=0):
+    """Process an uploaded traffic video and create an annotated output video."""
+
+    if video_path is None:
+        return None, "Please upload a video.", "0", "0", "₹0", get_dashboard()
+
+    cap = None
+    writer = None
+
+    try:
+        cap = cv2.VideoCapture(video_path)
+
+        if not cap.isOpened():
+            return None, "Unable to open the uploaded video.", "0", "0", "₹0", get_dashboard()
+
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        if not fps or fps <= 0:
+            fps = 25.0
+
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        if width <= 0 or height <= 0:
+            return None, "Invalid video dimensions.", "0", "0", "₹0", get_dashboard()
+
+        try:
+            frame_skip = max(1, int(frame_skip))
+        except Exception:
+            frame_skip = 5
+
+        try:
+            max_frames = max(0, int(max_frames))
+        except Exception:
+            max_frames = 0
+
+        output_path = os.path.join(
+            tempfile.gettempdir(),
+            f"traffic_result_{uuid.uuid4().hex}.mp4"
+        )
+
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(
+            output_path,
+            fourcc,
+            fps,
+            (width, height)
+        )
+
+        if not writer.isOpened():
+            return None, "Unable to create the processed output video.", "0", "0", "₹0", get_dashboard()
+
+        ev_count = 0
+        non_ev_count = 0
+        discount_total = 0
+        detected_plates = 0
+        processed_frames = 0
+        frame_number = 0
+
+        # Prevent repeated database records for the same known plate
+        # across multiple frames of this uploaded video.
+        video_seen_plates = set()
+
+        output_lines = [
+            "VIDEO TRAFFIC ANALYSIS",
+            "",
+            f"Input frames: {total_frames if total_frames > 0 else 'Unknown'}",
+            f"Processing every {frame_skip} frame(s)",
+            ""
+        ]
+
+        while True:
+            ret, frame = cap.read()
+
+            if not ret:
+                break
+
+            if max_frames > 0 and frame_number >= max_frames:
+                break
+
+            # Write unprocessed frames unchanged.
+            if frame_number % frame_skip != 0:
+                writer.write(frame)
+                frame_number += 1
+                continue
+
+            processed_frames += 1
+
+            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            image = Image.fromarray(rgb_frame)
+
+            inputs = processor(
+                images=image,
+                return_tensors="pt"
+            )
+
+            with torch.no_grad():
+                outputs = model(**inputs)
+
+            target_sizes = torch.tensor(
+                [[image.size[1], image.size[0]]]
+            )
+
+            results = processor.post_process_object_detection(
+                outputs,
+                threshold=0.30,
+                target_sizes=target_sizes
+            )[0]
+
+            draw = ImageDraw.Draw(image)
+
+            for i, box in enumerate(results["boxes"]):
+                x1, y1, x2, y2 = map(int, box.tolist())
+
+                x1 = max(0, min(x1, image.width - 1))
+                y1 = max(0, min(y1, image.height - 1))
+                x2 = max(0, min(x2, image.width))
+                y2 = max(0, min(y2, image.height))
+
+                if x2 <= x1 or y2 <= y1:
+                    continue
+
+                plate = image.crop((x1, y1, x2, y2))
+
+                status = classify_plate_color(plate)
+                plate_number = read_license_plate(plate)
+                detected_plates += 1
+
+                normalized_plate = str(plate_number).strip().upper()
+                should_count = True
+
+                if normalized_plate not in ("", "UNKNOWN", "OCR_UNAVAILABLE"):
+                    if normalized_plate in video_seen_plates:
+                        should_count = False
+                    else:
+                        video_seen_plates.add(normalized_plate)
+
+                if should_count:
+                    saved = save_vehicle(plate_number, status)
+
+                    if saved not in ("Duplicate", "Error"):
+                        if status == "EV":
+                            ev_count += 1
+                            discount_total += EV_DISCOUNT
+                        else:
+                            non_ev_count += 1
+
+                        output_lines.extend([
+                            f"Vehicle {ev_count + non_ev_count}",
+                            f"Plate: {plate_number}",
+                            f"Status: {status}",
+                            f"Discount: ₹{EV_DISCOUNT if status == 'EV' else 0}",
+                            ""
+                        ])
+
+                if status == "EV":
+                    outline_color = "green"
+                    label = f"{plate_number} | EV | ₹{EV_DISCOUNT}"
+                else:
+                    outline_color = "red"
+                    label = f"{plate_number} | Non-EV"
+
+                draw.rectangle(
+                    [x1, y1, x2, y2],
+                    outline=outline_color,
+                    width=4
+                )
+
+                text_y = max(0, y1 - 22)
+
+                draw.rectangle(
+                    [
+                        x1,
+                        text_y,
+                        min(image.width, x1 + 330),
+                        y1
+                    ],
+                    fill="black"
+                )
+
+                draw.text(
+                    (x1 + 3, text_y + 3),
+                    label,
+                    fill=outline_color
+                )
+
+            output_frame = cv2.cvtColor(
+                np.array(image),
+                cv2.COLOR_RGB2BGR
+            )
+
+            writer.write(output_frame)
+            frame_number += 1
+
+        cap.release()
+        cap = None
+
+        writer.release()
+        writer = None
+
+        if processed_frames == 0:
+            return None, "No frames were processed.", "0", "0", "₹0", get_dashboard()
+
+        total_unique = ev_count + non_ev_count
+        ev_percentage = (
+            ev_count / total_unique * 100
+            if total_unique > 0 else 0
+        )
+
+        output_lines.extend([
+            "VIDEO SUMMARY",
+            f"Processed frames: {processed_frames}",
+            f"Detected plate instances: {detected_plates}",
+            f"Unique vehicles recorded: {total_unique}",
+            f"EV vehicles: {ev_count}",
+            f"Non-EV vehicles: {non_ev_count}",
+            f"EV percentage: {ev_percentage:.2f}%",
+            f"Total EV discount: ₹{discount_total}"
+        ])
+
+        return (
+            output_path,
+            "\n".join(output_lines),
+            str(ev_count),
+            str(non_ev_count),
+            f"₹{discount_total}",
+            get_dashboard()
+        )
+
+    except Exception as e:
+        print("Video processing error:", e)
+
+        if cap is not None:
+            cap.release()
+
+        if writer is not None:
+            writer.release()
+
+        return None, f"Video processing error: {str(e)}", "0", "0", "₹0", get_dashboard()
+
+
+
 # ============================================================
 # REFRESH DASHBOARD
 # ============================================================
@@ -2112,8 +2362,96 @@ with gr.Blocks(
         )
 
 
+
+    # ========================================================
+    # TAB 2 - VIDEO PROCESSING
+    # ========================================================
+
+    with gr.Tab("Video Processing"):
+
+        gr.Markdown("## Video Traffic & EV Analysis")
+
+        gr.Markdown(
+            "Upload a traffic video to detect license plates, "
+            "classify EV/Non-EV vehicles, read plate numbers using "
+            "EasyOCR, calculate EV incentives, and generate an "
+            "annotated output video."
+        )
+
+        with gr.Row(equal_height=True):
+
+            with gr.Column(scale=1):
+
+                input_video = gr.Video(
+                    label="Upload Traffic Video",
+                    sources=["upload"],
+                    format="mp4"
+                )
+
+                frame_skip = gr.Slider(
+                    minimum=1,
+                    maximum=15,
+                    value=5,
+                    step=1,
+                    label="Process Every Nth Frame",
+                    info="1 = every frame; higher values reduce processing time."
+                )
+
+                max_frames = gr.Number(
+                    value=0,
+                    precision=0,
+                    label="Maximum Frames",
+                    info="0 = process the complete video."
+                )
+
+                video_btn = gr.Button(
+                    "Process Video",
+                    variant="primary",
+                    size="lg"
+                )
+
+            with gr.Column(scale=1):
+
+                output_video = gr.Video(
+                    label="Processed Video",
+                    autoplay=False
+                )
+
+                video_summary = gr.Textbox(
+                    label="Video Analysis Summary",
+                    lines=18
+                )
+
+        with gr.Row():
+
+            video_ev_box = gr.Textbox(label="EV Vehicles")
+            video_non_ev_box = gr.Textbox(label="Non-EV Vehicles")
+            video_discount_box = gr.Textbox(label="Total Discount")
+
+        gr.Markdown("## Video Traffic Analytics Dashboard")
+
+        video_dashboard = gr.Plot(label="Video Analytics")
+
+        video_btn.click(
+            fn=process_video,
+            inputs=[
+                input_video,
+                frame_skip,
+                max_frames
+            ],
+            outputs=[
+                output_video,
+                video_summary,
+                video_ev_box,
+                video_non_ev_box,
+                video_discount_box,
+                video_dashboard
+            ]
+        )
+
+
     # ========================================================
-    # TAB 2 - AGENTIC AI DASHBOARD
+    # TAB 3 - AGENTIC AI DASHBOARD
     # ========================================================
 
     with gr.Tab(
@@ -2267,7 +2605,7 @@ analytics operation.
         )
 
     # ========================================================
-    # TAB 3 - ADMIN / DATABASE
+    # TAB 4 - ADMIN / DATABASE
     # ========================================================
 
     with gr.Tab(