Deploy TrafficPulse app with Dockerfile and start.sh

.dockerignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+.git
+.vscode/
+models/
+weights/
+data/
+*.ckpt
+.DS_Store
+.env

Dockerfile

@@ -0,0 +1,46 @@
+2 — Replace/update your Dockerfile (copy this exact version)
+
+This is a robust, minimal Dockerfile that:
+
+uses a modern slim base,
+
+updates packages,
+
+installs small system libs (ffmpeg, libgl1) for computer-vision tasks,
+
+installs pip deps from Requirements.txt,
+
+copies code and runs app.py.
+
+Create/replace Dockerfile with:
+
+# Use newer Debian-based Python slim
+FROM python:3.11-slim-bookworm
+
+ENV DEBIAN_FRONTEND=noninteractive
+WORKDIR /app
+
+# Install system deps (ffmpeg for video, git if needed, libs for OpenCV)
+RUN apt-get update && apt-get upgrade -y \
+ && apt-get install -y --no-install-recommends \
+    git \
+    ffmpeg \
+    build-essential \
+    libgl1 \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install Python deps
+COPY Requirements.txt /app/Requirements.txt
+RUN python -m pip install --upgrade pip \
+ && pip install --no-cache-dir -r /app/Requirements.txt
+
+# Copy project files
+COPY . /app
+
+# Expose port (Streamlit default; Hugging Face will map its port)
+ENV PORT=7860
+EXPOSE 7860
+
+# Use start.sh if present, otherwise run wrapper app.py
+# If you added start.sh earlier, use that; otherwise run app.py directly.
+CMD ["bash", "-lc", "if [ -x ./start.sh ]; then ./start.sh; else python app.py; fi"]

Requirements.txt

@@ -0,0 +1,7 @@
+streamlit==1.28.0
+ultralytics==8.1.4
+opencv-python-headless==4.8.0.74
+pandas==2.1.1
+plotly==6.2.0
+numpy==1.26.2
+torch==2.3.1

app.py

@@ -0,0 +1,7 @@
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + "!!"
+
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+demo.launch()

main.py

@@ -0,0 +1,80 @@
+import cv2
+import pandas as pd
+from ultralytics import YOLO
+from tracker import*
+
+model=YOLO('yolov8s.pt')
+
+
+
+def RGB(event, x, y, flags, param):
+    if event == cv2.EVENT_MOUSEMOVE :  
+        colorsBGR = [x, y]
+        print(colorsBGR)
+        
+
+cv2.namedWindow('RGB')
+cv2.setMouseCallback('RGB', RGB)
+
+cap=cv2.VideoCapture('veh2.mp4')
+
+
+my_file = open("coco.txt", "r")
+data = my_file.read()
+class_list = data.split("\n") 
+#print(class_list)
+
+count=0
+
+tracker=Tracker()
+
+cy1=322
+cy2=368
+offset=6
+
+while True:    
+    ret,frame = cap.read()
+    if not ret:
+        break
+    count += 1
+    if count % 3 != 0:
+        continue
+    frame=cv2.resize(frame,(1020,500))
+   
+
+    results=model.predict(frame)
+ #   print(results)
+    a=results[0].boxes.data
+    px=pd.DataFrame(a).astype("float")
+#    print(px)
+    list=[]
+             
+    for index,row in px.iterrows():
+#        print(row)
+ 
+        x1=int(row[0])
+        y1=int(row[1])
+        x2=int(row[2])
+        y2=int(row[3])
+        d=int(row[5])
+        c=class_list[d]
+        if 'car' in c:
+            list.append([x1,y1,x2,y2])
+    bbox_id=tracker.update(list)
+    for bbox in bbox_id:
+        x3,y3,x4,y4,id=bbox
+        cx=int(x3+x4)//2
+        cy=int(y3+y4)//2
+        cv2.circle(frame,(cx,cy),4,(0,0,255),-1)
+        cv2.putText(frame,str(id),(cx,cy),cv2.FONT_HERSHEY_COMPLEX,0.8,(0,255,255),2)
+           
+
+
+#    cv2.line(frame,(274,cy1),(814,cy1),(255,255,255),1)
+#    cv2.line(frame,(177,cy2),(927,cy2),(255,255,255),1)
+    cv2.imshow("RGB", frame)
+    if cv2.waitKey(1)&0xFF==27:
+        break
+cap.release()
+cv2.destroyAllWindows()
+

speed.py

@@ -0,0 +1,100 @@
+import cv2
+import pandas as pd
+import math
+from ultralytics import YOLO
+from tracker import Tracker
+from datetime import datetime
+
+def estimate_speed(p1, p2, fps, ppm=8):
+    """Estimate speed in km/h from two points, frames per second, and pixels-per-meter scale."""
+    distance_pixels = math.hypot(p2[0] - p1[0], p2[1] - p1[1])
+    distance_meters = distance_pixels / ppm
+    speed_mps = distance_meters * fps
+    speed_kmph = speed_mps * 3.6
+    return speed_kmph
+
+def run_speed_estimation(video_path, output_path):
+    model = YOLO('yolov8s.pt')
+
+    with open("coco.txt", "r") as my_file:
+        class_list = my_file.read().split("\n")
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print(f"Error opening video file: {video_path}")
+        return
+
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (1020, 500))
+
+    tracker = Tracker()
+    count = 0
+    log_data = []
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        count += 1
+        if count % 3 != 0:
+            continue
+
+        frame = cv2.resize(frame, (1020, 500))
+        timestamp = count / fps
+
+        results = model.predict(frame)
+        boxes = results[0].boxes.data
+        px = pd.DataFrame(boxes).astype("float")
+
+        det_list = []
+        for _, row in px.iterrows():
+            x1, y1, x2, y2 = map(int, row[:4])
+            class_id = int(row[5])
+            label = class_list[class_id]
+            if 'car' in label:
+                det_list.append([x1, y1, x2, y2])
+
+        bbox_id = tracker.update(det_list)
+
+        for bbox in bbox_id:
+            x3, y3, x4, y4, obj_id = bbox
+            cx = (x3 + x4) // 2
+            cy = (y3 + y4) // 2
+            center = (cx, cy)
+
+            # Estimate speed
+            speed = 0
+            history = tracker.track_history[obj_id]
+            if len(history) >= 2:
+                speed = estimate_speed(history[-2], history[-1], fps)
+                speed = round(speed, 2)
+
+            # Draw info
+            cv2.circle(frame, center, 4, (0, 0, 255), -1)
+            cv2.putText(frame, f"ID {obj_id} | {speed} km/h", (cx, cy),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
+
+            # Save to CSV log
+            log_data.append({
+                'timestamp_sec': round(timestamp, 2),
+                'vehicle_id': obj_id,
+                'x': cx,
+                'y': cy,
+                'speed_kmph': speed
+            })
+
+        out.write(frame)
+
+    cap.release()
+    out.release()
+
+    # Save CSV log
+    df = pd.DataFrame(log_data)
+    df.to_csv('static/vehicle_log.csv', index=False)
+
+    print(f"Processing complete. Output saved to {output_path}")

start.sh

@@ -0,0 +1,20 @@
+cat > start.sh <<'EOF'
+#!/usr/bin/env bash
+set -e
+
+MODEL_DIR=/app/models
+mkdir -p "$MODEL_DIR"
+
+# Download model if not present (replace URL)
+if [ ! -f "$MODEL_DIR/model.pt" ]; then
+  echo "Downloading model..."
+  wget --timeout=60 -O "$MODEL_DIR/model.pt" "https://huggingface.co/<user>/<repo>/resolve/main/model.pt"
+fi
+
+# Launch app via wrapper (app.py)
+exec python app.py
+EOF
+
+chmod +x start.sh
+git add start.sh
+git commit -m "Add start.sh to download model at container start"

streamlit_app.py

@@ -0,0 +1,40 @@
+import sys
+import os
+import importlib.util
+
+# Ensure Python can find track.py in the same folder
+sys.path.append(os.path.dirname(__file__))
+
+import streamlit as st
+# Try importing run_tracker from track.py in the same directory
+try:
+    from track import run_tracker
+except ModuleNotFoundError:
+    st.error("track.py not found in the current directory. Please ensure track.py exists.")
+    sys.exit(1)
+
+st.set_page_config(page_title="🚗 Real-Time Vehicle Counter", layout="wide")
+st.title("🚗 Real-Time Vehicle Counter")
+
+st.markdown("""
+This app uses YOLOv8 to detect and count vehicles in real-time from your webcam or a video file.
+""")
+
+# Sidebar for video input
+video_source = st.sidebar.radio(
+    "Select Video Source:",
+    ("Webcam", "Upload Video")
+)
+
+video_path = 0  # default to webcam
+if video_source == "Upload Video":
+    uploaded_file = st.sidebar.file_uploader("Upload a video file", type=["mp4", "mov", "avi"])
+    if uploaded_file is not None:
+        # Save uploaded file to a temporary file
+        with open("temp_video.mp4", "wb") as f:
+            f.write(uploaded_file.read())
+        video_path = "temp_video.mp4"
+
+# Start tracking
+if st.button("Start Tracking"):
+    run_tracker(video_path)

track.py

@@ -0,0 +1,76 @@
+import os
+import streamlit as st
+import cv2
+from ultralytics import YOLO
+import pandas as pd
+import plotly.express as px
+from datetime import datetime
+import csv
+from collections import defaultdict
+import uuid
+from huggingface_hub import hf_hub_download
+
+# Class ID to label mapping
+CLASS_MAP = {
+    2: 'car',
+    3: 'motorbike',
+    5: 'bus',
+    7: 'truck'
+}
+
+# Function to download YOLOv8 weights if not present
+def get_model_path():
+    model_file = "yolov8l.pt"
+    if not os.path.exists(model_file):
+        # Download from the existing Hugging Face repo
+        model_file = hf_hub_download(
+            repo_id="lkk688/yolov8l-model",
+            filename="yolov8l.pt"
+        )
+    return model_file
+
+@st.cache_resource
+def load_model():
+    model_path = get_model_path()
+    return YOLO(model_path)
+
+def run_tracker(video_path=0):
+    model = load_model()  # Load model safely
+    vehicle_counts = defaultdict(int)
+
+    st.title("🚗 Real-Time Vehicle Counter")
+    stframe = st.empty()
+    chart_placeholder = st.empty()
+
+    cap = cv2.VideoCapture(video_path)
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        results = model(frame, stream=True)
+
+        for r in results:
+            for box in r.boxes:
+                cls_id = int(box.cls[0])
+                label = CLASS_MAP.get(cls_id)
+                if label:
+                    vehicle_counts[label] += 1
+                    xyxy = box.xyxy[0].cpu().numpy().astype(int)
+                    cv2.rectangle(frame, tuple(xyxy[:2]), tuple(xyxy[2:]), (0, 255, 0), 2)
+                    cv2.putText(frame, label, tuple(xyxy[:2]), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+
+        stframe.image(frame, channels='BGR', use_column_width=True)
+
+        df = pd.DataFrame(vehicle_counts.items(), columns=['Vehicle', 'Count'])
+        fig = px.bar(df, x='Vehicle', y='Count', title='Live Vehicle Count')
+        chart_placeholder.plotly_chart(fig, use_container_width=True, key=f"chart_{uuid.uuid4()}")
+
+        if sum(vehicle_counts.values()) % 50 == 0:
+            os.makedirs("static", exist_ok=True)
+            with open("static/vehicle_log.csv", "a", newline="") as file:
+                writer = csv.writer(file)
+                writer.writerow([datetime.now()] + list(vehicle_counts.values()))
+
+    cap.release()

tracker.py

@@ -0,0 +1,42 @@
+from collections import defaultdict
+import math
+
+class Tracker:
+    def __init__(self, max_distance=35, max_history=30):
+        self.track_history = defaultdict(lambda: [])  # {id: [(x, y), (x, y), ...]}
+        self.id_count = 0
+        self.max_distance = max_distance
+        self.max_history = max_history
+
+    def update(self, objects_rect):
+        objects_bbs_ids = []
+
+        for rect in objects_rect:
+            x1, y1, x2, y2 = rect
+            cx = (x1 + x2) // 2
+            cy = (y1 + y2) // 2
+
+            same_object_detected = False
+            for obj_id, track in self.track_history.items():
+                prev_center = track[-1]
+                dist = math.hypot(cx - prev_center[0], cy - prev_center[1])
+                if dist < self.max_distance:
+                    self.track_history[obj_id].append((cx, cy))
+                    if len(self.track_history[obj_id]) > self.max_history:
+                        self.track_history[obj_id].pop(0)  # Retain only the last 'max_history' points
+                    objects_bbs_ids.append([x1, y1, x2, y2, obj_id])
+                    same_object_detected = True
+                    break
+
+            if not same_object_detected:
+                self.track_history[self.id_count].append((cx, cy))
+                objects_bbs_ids.append([x1, y1, x2, y2, self.id_count])
+                self.id_count += 1
+
+        new_track_history = defaultdict(lambda: [])
+        for obj_bb_id in objects_bbs_ids:
+            _, _, _, _, object_id = obj_bb_id
+            new_track_history[object_id] = self.track_history[object_id]
+
+        self.track_history = new_track_history.copy()
+        return objects_bbs_ids