'total_objects': 0,

'object_speeds': {},

'zone_counts': {},

'detection_history': [],

'fps': 0,

'frame_count': 0,

'start_time': time.time()

"""Process frame buffer to reduce latency."""

if len(frame_buffer) >= buffer_size:

# Use oldest frame to reduce latency

return frame_buffer.pop(0)

"""Calculate frames per second."""

current_time = time.time()

time_diff = current_time - analytics['start_time']

if time_diff > 0:

analytics['fps'] = analytics['frame_count'] / time_diff

analytics['frame_count'] = 0

analytics['start_time'] = current_time

"""Determine which zone an object is in."""

# Calculate object's center

center_x = (x1 + x2) / 2

center_y = (y1 + y2) / 2

# Define zones based on image dimensions

# Divide image into 3x3 grid

zone_width = img_width / 3

zone_height = img_height / 3

# Determine zone

zone_x = int(center_x // zone_width)

zone_y = int(center_y // zone_height)

# Return zone as string (e.g., "1-1", "2-2", etc.)

@wraps(f)

def decorated_function(*args, **kwargs):

if not current_user.is_authenticated or not current_user.is_admin:

flash('You need admin privileges to access this page.', 'danger')

return redirect(url_for('index'))

return f(*args, **kwargs)

# Create a black image with error text

height, width = 480, 640

img = np.zeros((height, width, 3), np.uint8)

# Add text to the image

font = cv2.FONT_HERSHEY_SIMPLEX

font_scale = 0.7

color = (255, 255, 255) # White text

thickness = 2

# Split text into multiple lines if needed

words = error_text.split()

lines = []

current_line = []

for word in words:

current_line.append(word)

text = ' '.join(current_line)

text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]

if text_size[0] > width - 40: # Leave some margin

current_line.pop() # Remove last word

lines.append(' '.join(current_line))

current_line = [word]

if current_line:

lines.append(' '.join(current_line))

# Calculate y position for centered text

y_position = height // 2 - ((len(lines) - 1) * 30) // 2

for line in lines:

text_size = cv2.getTextSize(line, font, font_scale, thickness)[0]

x_position = (width - text_size[0]) // 2

cv2.putText(img, line, (x_position, y_position), font, font_scale, color, thickness)

y_position += 30

# Preprocess image efficiently

img_height, img_width = img.shape[:2]

# Convert to RGB once

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Perform detection with optimized settings

results = model(img_rgb, verbose=False, imgsz=800)

# Get detections

boxes = results[0].boxes

# Skip processing if no detections

if not boxes:

return img

# Process detections efficiently

filtered_boxes = []

for box in boxes:

conf = box.conf[0].item()

if conf < 0.45:

continue

# Get bounding box coordinates

x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()

# Basic size filtering

width = x2 - x1

height = y2 - y1

if width < 15 or height < 15:

continue

filtered_boxes.append((box, width, height))

# If no valid detections after filtering

if not filtered_boxes:

return img

# Process filtered detections

for box, width, height in filtered_boxes:

# Get detection parameters

conf = box.conf[0].item()

class_id = box.cls[0].item()

x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()

# Apply basic filtering

if conf < 0.45:

continue

# Calculate object size

width = x2 - x1

height = y2 - y1

# Basic size filtering

if width < 15 or height < 15:

continue

# Draw bounding box

cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)

# Add label only for high confidence detections

if conf > 0.6:

label = f'{model.names[int(class_id)]} {conf:.2f}'

cv2.putText(img, label, (int(x1), int(y1) - 10),

cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

# Update analytics

analytics['total_objects'] += len(filtered_boxes)

# Update zone counts

for box, width, height in filtered_boxes:

if box.conf[0].item() > 0.45:

x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()

zone = get_zone(x1, y1, x2, y2, img_width, img_height)

analytics['zone_counts'][zone] = analytics['zone_counts'].get(zone, 0) + 1

# Filter based on object size (ignore very small detections)

if width < 20 or height < 20:

continue

# Calculate aspect ratio for better object classification

aspect_ratio = width / height

# Apply class-specific filtering

if class_id == 0: # Person

if aspect_ratio < 0.2 or aspect_ratio > 2.0:

continue

elif class_id == 2: # Car

if aspect_ratio < 0.5 or aspect_ratio > 3.0:

continue

# Draw bounding box efficiently

cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)

# Add label only for high confidence detections

if conf > 0.6:

label = f'{model.names[int(class_id)]} {conf:.2f}'

cv2.putText(img, label, (int(x1), int(y1) - 10),

cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

# Update analytics with more detailed information

analytics['total_objects'] += len(boxes)

# Update zone counts with confidence weighting

for box in boxes:

if box.conf[0].item() > 0.5:

x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()

zone = get_zone(x1, y1, x2, y2, img_width, img_height)

weight = box.conf[0].item() # Use confidence as weight

analytics['zone_counts'][zone] = analytics['zone_counts'].get(zone, 0) + weight

# Track object speed

if zone in analytics['object_speeds']:

analytics['object_speeds'][zone] = (analytics['object_speeds'][zone] + width * height * weight) / 2

else:

analytics['object_speeds'][zone] = width * height * weight

# Convert to JPEG

_, buffer = cv2.imencode('.jpg', img)

"""Render the homepage with analytics."""

return render_template('index.html',

total_objects=analytics['total_objects'],

"""Admin dashboard showing overview of users and messages."""

conn = get_db_connection()

users = conn.execute('SELECT id, username, email, is_admin, created_at FROM users').fetchall()

conn.close()

messages = ContactMessage.get_all()

active_sessions = get_active_sessions()

"""Admin page to manage users."""

conn = get_db_connection()

users = conn.execute('SELECT id, username, email, is_admin, created_at FROM users').fetchall()

conn.close()

"""Make a user an admin."""

conn = get_db_connection()

user = conn.execute('SELECT username FROM users WHERE id = ?', (user_id,)).fetchone()

if not user:

flash('User not found.', 'danger')

else:

conn.execute('UPDATE users SET is_admin = 1 WHERE id = ?', (user_id,))

conn.commit()

flash(f'User {user["username"]} is now an admin.', 'success')

conn.close()

"""Delete a user."""

# Don't allow deleting yourself

if user_id == current_user.id:

flash('You cannot delete your own account.', 'danger')

return redirect(url_for('admin_users'))

conn = get_db_connection()

user = conn.execute('SELECT username FROM users WHERE id = ?', (user_id,)).fetchone()

if not user:

flash('User not found.', 'danger')

else:

conn.execute('DELETE FROM users WHERE id = ?', (user_id,))

conn.commit()

flash(f'User {user["username"]} has been deleted.', 'success')

conn.close()

"""Terminate a user session."""

# This is a placeholder since we don't have actual session tracking

# In a real application, you would remove the session from your session store

flash('Session terminated successfully.', 'success')

"""Handle contact form submission."""

name = request.form.get('name')

email = request.form.get('email')

subject = request.form.get('subject')

message = request.form.get('message')

# Validate form data

if not all([name, email, subject, message]):

flash('Please fill out all fields.', 'danger')

return redirect(url_for('contact'))

try:

# Store the contact message in the database

from models import ContactMessage

contact_message = ContactMessage.create(name, email, subject, message)

# Log the submission

logger.info(f"Contact form submission from {name} ({email}): {subject} - Stored with ID: {contact_message.id}")

# Send email to admin

admin_email = "sunniraj4511@gmail.com"

send_contact_email(name, email, subject, message, admin_email)

# Flash a success message

flash('Thank you for your message! We will get back to you soon.', 'success')

except Exception as e:

logger.error(f"Error processing contact form submission: {str(e)}")

flash('There was an error processing your message. Please try again later.', 'danger')

# Redirect back to the contact page

"""Send contact form data to admin email."""

try:

# Create email content

msg = MIMEMultipart()

msg['From'] = email

msg['To'] = admin_email

msg['Subject'] = f"Contact Form: {subject}"

# Email body

body = f"""New Contact Form Submission

msg.attach(MIMEText(body, 'plain'))

# Connect to SMTP server and send email

# Note: For production, you should use environment variables for these credentials

# and consider using a service like SendGrid, Mailgun, etc.

server = smtplib.SMTP('smtp.gmail.com', 587)

server.starttls()

# You would need to set up an app password for your Gmail account

# and store it securely, not hardcoded like this

# For demonstration purposes only - in production use environment variables

app_password = os.environ.get('EMAIL_PASSWORD', '')

if not app_password:

logger.warning("Email password not set. Email not sent.")

return

server.login(admin_email, app_password)

text = msg.as_string()

server.sendmail(email, admin_email, text)

server.quit()

logger.info(f"Contact email sent to {admin_email} from {email}")

except Exception as e:

logger.error(f"Error sending contact email: {str(e)}")

# Don't raise the exception - we still want to store the message in the database

"""Handle user login."""

if current_user.is_authenticated:

return redirect(url_for('index'))

if request.method == 'POST':

username = request.form.get('username')

password = request.form.get('password')

remember = 'remember' in request.form

# Debug logging

logger.info(f"Login attempt for username: {username}")

user = User.find_by_username(username)

if user:

logger.info(f"User found: {user.username}, ID: {user.id}")

if user.check_password(password):

try:

login_user(user, remember=remember)

logger.info(f"Login successful for user: {username}")

flash('Login successful!', 'success')

next_page = request.args.get('next')

return redirect(next_page or url_for('index'))

except Exception as e:

logger.error(f"Error during login_user: {str(e)}")

flash('An error occurred during login. Please try again.', 'danger')

else:

logger.info(f"Invalid password for user: {username}")

flash('Invalid username or password', 'danger')

else:

logger.info(f"User not found: {username}")

flash('Invalid username or password', 'danger')

"""Handle user registration."""

if current_user.is_authenticated:

return redirect(url_for('index'))

if request.method == 'POST':

username = request.form.get('username')

email = request.form.get('email')

password = request.form.get('password')

confirm_password = request.form.get('confirm_password')

# Validate input

if not username or not email or not password or not confirm_password:

flash('All fields are required', 'danger')

return render_template('register.html')

if password != confirm_password:

flash('Passwords do not match', 'danger')

return render_template('register.html')

if len(password) < 8:

flash('Password must be at least 8 characters long', 'danger')

return render_template('register.html')

# Check if username or email already exists

if User.find_by_username(username):

flash('Username already exists', 'danger')

return render_template('register.html')

if User.find_by_email(email):

flash('Email already exists', 'danger')

return render_template('register.html')

# Create new user

user = User.create(username, email, password)

if user:

flash('Registration successful! You can now log in.', 'success')

return redirect(url_for('login'))

else:

flash('An error occurred during registration', 'danger')

"""Handle user logout."""

logout_user()

flash('You have been logged out', 'info')

"""Serve output files with proper MIME types."""

try:

# Set the correct MIME type for video files

mimetype = None

if filename.endswith('.mp4'):

mimetype = 'video/mp4'

return send_from_directory(OUTPUT_FOLDER, filename, mimetype=mimetype)

except Exception as e:

logger.error(f"Error serving file {filename}: {str(e)}")

"""Start real-time video detection from webcam."""

def generate_frames():

global video_processing, stop_detection

cap = None

try:

# Print available cameras for debugging

logger.info("Checking available camera devices...")

available_cameras = []

for i in range(10): # Check indices 0-9

temp_cap = cv2.VideoCapture(i)

if temp_cap.isOpened():

ret, _ = temp_cap.read()

if ret:

available_cameras.append(i)

logger.info(f"Camera index {i} is available")

temp_cap.release()

if not available_cameras:

logger.error("No cameras detected on the system")

error_frame = create_error_frame("No cameras detected on your system. Please connect a webcam and try again.")

yield (b'--frame\r\n'

b'Content-Type: image/jpeg\r\n\r\n' + error_frame.tobytes() + b'\r\n')

return

logger.info(f"Available cameras: {available_cameras}")

# Try multiple approaches to open the camera

success = False

# First try: DirectShow backend with index 0 (most common webcam)

try:

logger.info("Trying camera 0 with DirectShow backend")

cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)

if cap.isOpened():

ret, test_frame = cap.read()

if ret and test_frame is not None:

logger.info("Successfully opened camera 0 with DirectShow backend")

success = True

else:

logger.warning("Camera opened but couldn't read frame, releasing")

cap.release()

cap = None

else:

logger.warning("Failed to open camera with DirectShow backend")

if cap is not None:

cap.release()

cap = None

except Exception as e:

logger.error(f"Error with DirectShow backend: {str(e)}")

if cap is not None:

cap.release()

cap = None

# Second try: Default backend with index 0

if not success:

try:

logger.info("Trying camera 0 with default backend")

cap = cv2.VideoCapture(0)

if cap.isOpened():

ret, test_frame = cap.read()

if ret and test_frame is not None:

logger.info("Successfully opened camera 0 with default backend")

success = True

else:

logger.warning("Camera opened but couldn't read frame, releasing")

cap.release()

cap = None

else:

logger.warning("Failed to open camera with default backend")

if cap is not None:

cap.release()

cap = None

except Exception as e:

logger.error(f"Error with default backend: {str(e)}")

if cap is not None:

cap.release()

cap = None

# Third try: Try other camera indices

if not success:

for idx in range(1, 3): # Try indices 1 and 2

try:

logger.info(f"Trying camera index {idx}")

cap = cv2.VideoCapture(idx)

if cap.isOpened():

ret, test_frame = cap.read()

if ret and test_frame is not None:

logger.info(f"Successfully opened camera {idx}")

success = True

break

else:

logger.warning(f"Camera {idx} opened but couldn't read frame, releasing")

cap.release()

cap = None

else:

logger.warning(f"Failed to open camera {idx}")

if cap is not None:

cap.release()

cap = None

except Exception as e:

logger.error(f"Error with camera {idx}: {str(e)}")

if cap is not None:

cap.release()

cap = None

# If all attempts failed

if not success or cap is None:

logger.error("Failed to open any camera after multiple attempts")

error_frame = create_error_frame("Could not access webcam. Please check your camera connection and permissions.")

yield (b'--frame\r\n'

b'Content-Type: image/jpeg\r\n\r\n' + error_frame.tobytes() + b'\r\n')

return

# Set webcam properties for better performance

try:

# First read a test frame to make sure the camera is working

test_success, test_frame = cap.read()

if not test_success or test_frame is None:

logger.error("Failed to read initial test frame from webcam")

error_frame = create_error_frame("Camera connected but not providing video stream. Try restarting your computer.")

yield (b'--frame\r\n'

b'Content-Type: image/jpeg\r\n\r\n' + error_frame.tobytes() + b'\r\n')

cap.release()

return

# Set properties for better performance

cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)

cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

cap.set(cv2.CAP_PROP_FPS, 30) # Try to set FPS to 30

cap.set(cv2.CAP_PROP_BUFFERSIZE, 1) # Minimize buffer size for lower latency

# Check if properties were actually set

actual_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)

actual_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)

actual_fps = cap.get(cv2.CAP_PROP_FPS)

logger.info(f"Webcam properties - Width: {actual_width}, Height: {actual_height}, FPS: {actual_fps}")

except Exception as e:

logger.error(f"Error setting webcam properties: {str(e)}")

# Continue anyway, these are just optimizations

logger.info("Webcam opened successfully, starting detection")

video_processing = True

stop_detection = False

frame_count = 0

last_detected_frame_bytes = None

while cap.isOpened() and not stop_detection:

success, frame = cap.read()

if not success:

logger.warning("Failed to read frame from webcam")

# Try to read one more time before giving up

success, frame = cap.read()

if not success:

logger.error("Repeatedly failed to read from webcam, stopping")

error_frame = create_error_frame("Lost connection to webcam")

yield (b'--frame\r\n'

b'Content-Type: image/jpeg\r\n\r\n' + error_frame.tobytes() + b'\r\n')

break

frame_count += 1

frame_bytes = None

# Process every 2nd frame for performance

if frame_count % 2 == 0:

try:

# Make sure frame is not None and has valid dimensions

if frame is None or frame.size == 0:

logger.warning("Empty frame received")

continue

# Check frame dimensions and orientation

h, w = frame.shape[:2]

if h == 0 or w == 0:

logger.warning(f"Invalid frame dimensions: {w}x{h}")

continue

# Resize while maintaining aspect ratio

target_width = 640

aspect_ratio = w / h

target_height = int(target_width / aspect_ratio)

# Ensure target height is reasonable

if target_height > 1000 or target_height < 100:

target_height = 480

frame_resized = cv2.resize(frame, (target_width, target_height))

# Enhanced detection with optimized parameters

# Wrap the model inference in a try-except block

try:

# Optimized settings for faster real-time detection

results = model(

frame_resized,

conf=0.3, # Balanced confidence threshold for accuracy and speed

iou=0.45, # Balanced IoU threshold

max_det=20, # Limit detections for better performance

verbose=False, # Disable verbose output for speed

augment=False # Disable augmentation for faster processing

)

# Simplified and optimized post-processing for better performance

# Use YOLO's built-in visualization but with custom filtering for person detection

# Get the detection results

if len(results[0].boxes) > 0:

# Filter out small person detections (likely hands)

filtered_indices = []

class_counts = {}

# Process each detection

for i, (box, cls, conf) in enumerate(zip(

results[0].boxes.xyxy.cpu().numpy(),

results[0].boxes.cls.cpu().numpy(),

results[0].boxes.conf.cpu().numpy())):

cls_name = results[0].names[int(cls)]

# Only filter person class to avoid hand misclassification

if cls_name == 'person':

# Calculate relative size

width = box[2] - box[0]

height = box[3] - box[1]

box_area = width * height

frame_area = frame_resized.shape[0] * frame_resized.shape[1]

relative_size = box_area / frame_area

# Keep only if it's a reasonable size

if relative_size > 0.03:

filtered_indices.append(i)

class_counts[cls_name] = class_counts.get(cls_name, 0) + 1

else:

# Keep all other object classes

filtered_indices.append(i)

class_counts[cls_name] = class_counts.get(cls_name, 0) + 1

# Use YOLO's built-in plotting for better performance

detected_frame = results[0].plot(boxes=filtered_indices)

# Add a simple detection summary at the top

if class_counts:

summary_text = "Detected: " + ", ".join([f"{count} {name}" for name, count in class_counts.items()])

cv2.rectangle(detected_frame, (0, 0), (detected_frame.shape[1], 30), (0, 0, 0), -1)

cv2.putText(detected_frame, summary_text, (10, 20),

cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)

else:

# No detections, use the original frame

detected_frame = frame_resized.copy()

# Detection summary is already added above

except Exception as model_error:

logger.error(f"Model inference error: {str(model_error)}")

# Fallback: just display the frame with a warning message

detected_frame = frame_resized.copy()

cv2.putText(detected_frame, "Detection model error - showing raw camera feed",

(10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)

# Add timestamp to show the feed is live

timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

cv2.putText(detected_frame, timestamp,

(10, detected_frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)

# Use higher quality JPEG encoding

encode_params = [int(cv2.IMWRITE_JPEG_QUALITY), 90]

_, buffer = cv2.imencode('.jpg', detected_frame, encode_params)

frame_bytes = buffer.tobytes()

last_detected_frame_bytes = frame_bytes

except Exception as e:

logger.error(f"Error processing frame: {str(e)}")

if 'CUDA' in str(e):

# Special handling for CUDA errors

error_frame = create_error_frame("GPU error detected. Try restarting the application.")

yield (b'--frame\r\n'

b'Content-Type: image/jpeg\r\n\r\n' + error_frame.tobytes() + b'\r\n')

break

continue

elif last_detected_frame_bytes:

frame_bytes = last_detected_frame_bytes

if frame_bytes:

yield (b'--frame\r\n'

b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n')

finally:

if 'cap' in locals() and cap is not None:

cap.release()

video_processing = False

logger.info("Webcam detection stopped")

"""Stop real-time video detection."""

global stop_detection

try:

stop_detection = True

logger.info("Detection stop requested")

return jsonify({'message': 'Detection stopped successfully.', 'status': 'success'})

except Exception as e:

logger.error(f"Error stopping detection: {str(e)}")

"""Detect objects in an uploaded image."""

try:

if 'image' not in request.files:

return jsonify({'error': 'No file uploaded'}), 400

file = request.files['image']

if file.filename == '':

return jsonify({'error': 'No selected file'}), 400

filepath = os.path.join(UPLOAD_FOLDER, file.filename)

file.save(filepath)

image = cv2.imread(filepath)

if image is None:

return jsonify({'error': 'Failed to read the image'}), 400

# Lower confidence threshold to detect smaller objects like pens and glasses

results = model(image, conf=0.25)