guides/security-alarm-system/

[giscus[bot]]

guides/security-alarm-system/

Security Alarm System Project Using Ultralytics YOLOv8. Learn How to implement a Security Alarm System Using ultralytics YOLOv8

https://docs.ultralytics.com/guides/security-alarm-system/

[Bronx0910]

Hi! Can I add a confidence on this let's say 90% to display on the box plots and before it sends out an email? Thanks!

[glenn-jocher]

Hello! 😊 Absolutely, you can display the confidence level on the bounding boxes and include that information before sending out an email. You would utilize the confidence scores returned by the model predictions. Here's a small modification to the plot_bboxes function in your code where you can format the label to include confidence scores (assuming a 90% threshold for email alerts):

def plot_bboxes(self, results, im0):
    self.annotator = Annotator(im0, 3, results[0].names)
    boxes = results[0].boxes.xyxy.cpu().numpy()
    confs = results[0].boxes.conf.cpu().numpy()
    clss = results[0].boxes.cls.cpu().tolist()
    names = results[0].names
    for box, conf, cls in zip(boxes, confs, clss):
        if conf >= 0.9:  # Checking for at least 90% confidence
            label = f'{names[int(cls)]} {conf:.2f}'
            self.annotator.box_label(box, label=label, color=colors(int(cls), True))
    return im0

And then in your detection loop:

if len(class_ids) > 0 and any(conf >= 0.9 for conf in confs):  # Modify condition for email
    if not self.email_sent:
        send_email(to_email, from_email, len(class_ids))
        self.email_sent = True

Remember, the confidence threshold (in this case, 90%) needs to align with your requirement for triggering an email alert. Feel free to adjust it as necessary! If you have further questions or need more customization tips, don't hesitate to ask.

[Bronx0910]

Great! At this way I was able to lessen false email alerts. Thank you for your help!

[glenn-jocher]

I'm thrilled to hear that tweaking the alert system has helped reduce false alarms! 🎉 It's great to know our guidance was useful. If you're curious about diving deeper into projects like the security alarm system or exploring more functionalities, our Security Alarm System Project Using Ultralytics YOLOv8 might have just the insights you need. Keep up the fantastic work, and don't hesitate to reach out if you have more questions or need further assistance!

[e9l7a5f]

hi, i cant do the email setting, of Sign in with app passwords and the authentication part , it looks like google change the setting i cant find them, is there another way?

[glenn-jocher]

Hey there! 😊 It seems like Google's app password settings have indeed evolved, and I appreciate you reaching out for assistance on this. While the current documentation may reference older interfaces, the essence of setting up app passwords for projects like the Security Alarm System with Ultralytics YOLOv8 remains relevant.

If you're experiencing difficulties locating the specific options for app passwords on Google, you might consider looking into alternative email sending services that offer API support, such as SendGrid, Mailgun, or even using a local SMTP server setup, depending on your project's complexity and scale.

For a quick fix using smtplib with Gmail, ensure you've enabled two-factor authentication on your account, and then create an app password here: https://myaccount.google.com/apppasswords.

Here's a simplified version of how to use an app password:

import smtplib

EMAIL = "your_email @eee7aaa.com"
APP_PASSWORD = "your_app_password"

with smtplib.SMTP("smtp.gmail.com", 587) as smtp:
    smtp.starttls()
    smtp.login(EMAIL, APP_PASSWORD)
    subject = "Security Alert"
    body = "Alert description"
    msg = f"Subject: {subject}\n\n{body}"
    smtp.sendmail(EMAIL, "receiver_email@gmail.com", msg)

Make sure to replace "your_email@gmail.com" and "your_app_password" with your actual Gmail email and the 16-digit app password you generate, respectively.

It's recommended to review the current Gmail documentation or seek updated guidance if Google's procedures have significantly changed since our last update. Hope this helps! If you have further questions or need more personalized assistance, feel free to ask.

[e9l7a5f]

thanks for replying, i fix it for the yolov8 as the same steps u explained, now i want to use it on yolov9 but i cant with these steps, because i am using the detect.py and i dont know how to deal with it , where to put each code, i dont have that much background in DL and python codes. the email part is working now

[glenn-jocher]

@e9l7a5f you can use YOLOv9 models the same way as you currently use YOLOv8 models. For usage examples see https://docs.ultralytics.com/models/yolov9.

[mimnsam]

[glenn-jocher]

Hey there! 🌟

For your Raspberry Pi security project, you're on a great track! You want to activate a GPIO pin and save a 10-second video when a specific class is detected. Here’s a concise approach to include GPIO control and video recording. Make sure you have RPi.GPIO and OpenCV installed.

First, you'll need to import the necessary libraries for GPIO control and initialize the pin you'll use:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)  # Use BCM GPIO numbering
GPIO_pin = 18  # Replace with your GPIO pin number
GPIO.setup(GPIO_pin, GPIO.OUT)

To record a 10-second video, you can use OpenCV's VideoWriter. Here's how to integrate it with object detection:

import cv2
import RPi.GPIO as GPIO
from picamera2 import Picamera2
from ultralytics import YOLO

# Setup GPIO
GPIO.setmode(GPIO.BCM)
GPIO_pin = 18
GPIO.setup(GPIO_pin, GPIO.OUT)

# Initialize PiCamera
picam2 = Picamera2()
# Camera setup code here...

# Initialize YOLO model
model = YOLO('best (1).pt') 

record = False
video_writer = None
frame_size = (800, 600)  # Frame size from your camera setup

while True:
    # Capture frame from PiCamera
    im = picam2.capture_array()
    
    # Perform object detection with YOLO
    results = model(im, conf=0.4)
    
    # Check for your specific class detection
    if 'person' in results.names:  # Replace 'person' with your interested class
        GPIO.output(GPIO_pin, GPIO.HIGH)  # Set GPIO pin high
        
        # Start recording if not already
        if not record:
            video_writer = cv2.VideoWriter('detected_event.avi', cv2.VideoWriter_fourcc(*'XVID'), 10, frame_size)
            record = True
            start_time = cv2.getTickCount()
    
    # Record video if activated
    if record:
        video_writer.write(im)
        if (cv2.getTickCount() - start_time)/cv2.getTickFrequency() > 10:  # Record for 10 seconds
            GPIO.output(GPIO_pin, GPIO.LOW)  # Reset GPIO pin
            video_writer.release()  # Stop recording
            record = False
    
    # Display image & exit condition here...

# Cleanup
GPIO.cleanup()

Notes:

• Replace 'person' with the class ID/name you're interested in.
• Adjust frame_size based on your camera's configuration.
• This example assumes continuous detection and recording for 10 seconds once the specified class is detected.

This should get you started on enhancing your security project! If you need further assistance or have questions, feel free to ask. Good luck with your project! 🚀

[mimnsam]

thanks alot. let me try this out

…

On Wed, Apr 17, 2024 at 12:03 AM Glenn Jocher ***@***.***> wrote: Hey there! 🌟 For your Raspberry Pi security project, you're on a great track! You want to activate a GPIO pin and save a 10-second video when a specific class is detected. Here’s a concise approach to include GPIO control and video recording. Make sure you have RPi.GPIO and OpenCV installed. First, you'll need to import the necessary libraries for GPIO control and initialize the pin you'll use: import RPi.GPIO as GPIOGPIO.setmode(GPIO.BCM) # Use BCM GPIO numberingGPIO_pin = 18 # Replace with your GPIO pin numberGPIO.setup(GPIO_pin, GPIO.OUT) To record a 10-second video, you can use OpenCV's VideoWriter. Here's how to integrate it with object detection: import cv2import RPi.GPIO as GPIOfrom picamera2 import Picamera2from ultralytics import YOLO # Setup GPIOGPIO.setmode(GPIO.BCM)GPIO_pin = 18GPIO.setup(GPIO_pin, GPIO.OUT) # Initialize PiCamerapicam2 = Picamera2()# Camera setup code here... # Initialize YOLO modelmodel = YOLO('best (1).pt') record = Falsevideo_writer = Noneframe_size = (800, 600) # Frame size from your camera setup while True: # Capture frame from PiCamera im = picam2.capture_array() # Perform object detection with YOLO results = model(im, conf=0.4) # Check for your specific class detection if 'person' in results.names: # Replace 'person' with your interested class GPIO.output(GPIO_pin, GPIO.HIGH) # Set GPIO pin high # Start recording if not already if not record: video_writer = cv2.VideoWriter('detected_event.avi', cv2.VideoWriter_fourcc(*'XVID'), 10, frame_size) record = True start_time = cv2.getTickCount() # Record video if activated if record: video_writer.write(im) if (cv2.getTickCount() - start_time)/cv2.getTickFrequency() > 10: # Record for 10 seconds GPIO.output(GPIO_pin, GPIO.LOW) # Reset GPIO pin video_writer.release() # Stop recording record = False # Display image & exit condition here... # CleanupGPIO.cleanup() *Notes:* - Replace 'person' with the class ID/name you're interested in. - Adjust frame_size based on your camera's configuration. - This example assumes continuous detection and recording for 10 seconds once the specified class is detected. This should get you started on enhancing your security project! If you need further assistance or have questions, feel free to ask. Good luck with your project! 🚀 — Reply to this email directly, view it on GitHub <#9395 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BH3Z3KW4EGMFBBG4SPQT7ULY5WGZZAVCNFSM6AAAAABFN47Q7CVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TCMZVGE4TQ> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

Hey there!

I'm delighted to hear you're giving the provided advice a go! 🌟 If you run into any hitches or if there's anything else you're curious about, don't hesitate to reach out.

Just so you know, there's also a comprehensive guide on creating a Security Alarm System using Ultralytics YOLOv8 that might interest you. It dives deeper into object detection for security systems, complete with a code example on how to send email alerts upon detection. Check it out on our docs page for more nifty details and tips! 🚀

Happy coding, and best of luck with your Raspberry Pi security project!

[mimnsam]

Thanks alot. I tried out that project of sending via my email account but Google had updated its third party policy in that it had banned the allowance of non secure sources from sending emails. I really don't recall what the actual statement was but it was similar to that. But was trying out the one of sending the video to telegram but got tangled in the code 😀😁. I believe assistance here would really be helpful. This my currently the code import cv2 from picamera2 import Picamera2 from ultralytics import YOLO import time import os import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) # Use BCM GPIO numbering GPIO_pin = 25 # Replace with your GPIO pin number GPIO.setup(GPIO_pin, GPIO.OUT) # Initialize PiCamera picam2 = Picamera2() picam2.preview_configuration.main.size = (800, 600) picam2.preview_configuration.main.format = "RGB888" picam2.preview_configuration.align() picam2.configure("preview") picam2.start() # Initialize YOLO model model = YOLO('best (1).pt') frame_size = (800, 600) # Frame size from your camera setup detection_count = 0 first_detection_time = 0 second_detection_time = 0 while True: record = False video_writer = None # Capture frame from PiCamera im = picam2.capture_array() # Perform object detection with YOLO results = model(im, conf=0.3) # After running detection for result in results: for box in result.boxes: # Assuming 'person' class index is 0, adjust based on your model if box.cls == 0: # Check for your specific class detection GPIO.output(GPIO_pin, GPIO.HIGH) # Turn on the buzzer print("Person detected!") # Increment detection count and record the time of detections if detection_count == 0: first_detection_time = time.time() elif detection_count == 1: second_detection_time = time.time() detection_count += 1 # Start recording if two detections within 5 seconds if detection_count == 2 and (second_detection_time - first_detection_time) <= 5: record = True # Record video if activated if record: video_name = f'detected_event_{int(time.time())}.avi' video_writer = cv2.VideoWriter(video_name, cv2.VideoWriter_fourcc(*'XVID'), 30, frame_size) # Set frame rate to 30 fps start_time = cv2.getTickCount() GPIO.output(GPIO_pin, GPIO.HIGH) # Turn on the buzzer while (cv2.getTickCount() - start_time) / cv2.getTickFrequency() < 5: # Record for 5 seconds im = picam2.capture_array() video_writer.write(im) GPIO.output(GPIO_pin, GPIO.LOW) # Reset GPIO pin video_writer.release() # Stop recording print(f"Video {video_name} saved!") detection_count = 0 # Reset detection count # Draw bounding boxes on the image # results.show() # Display the image with bounding boxes cv2.imshow("YOLO Object Detection", im) # Exit if 'q' is pressed if cv2.waitKey(1) == ord('q'): break # Clean up cv2.destroyAllWindows() 6 But firstly am still here trying to integrate the ultrasonic sensor so that it can display the distance of the detected object from the sensor together with the video from the camera. Any assistance offered will be really helpful. Thanks again

…

On Wed, 17 Apr 2024, 20:03 Glenn Jocher, ***@***.***> wrote: Hey there! I'm delighted to hear you're giving the provided advice a go! 🌟 If you run into any hitches or if there's anything else you're curious about, don't hesitate to reach out. Just so you know, there's also a comprehensive guide on creating a Security Alarm System using Ultralytics YOLOv8 that might interest you. It dives deeper into object detection for security systems, complete with a code example on how to send email alerts upon detection. Check it out on our docs page for more nifty details and tips! 🚀 Happy coding, and best of luck with your Raspberry Pi security project! — Reply to this email directly, view it on GitHub <#9395 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BH3Z3KW33CHY5ZMI6YH7WVDY52TPBAVCNFSM6AAAAABFN47Q7CVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TCNBVG43DC> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

Hey there!

Looks like you're putting together something really interesting with PiCamera, Ultralytics YOLO, and aiming to integrate it with Telegram for notifications! 👏 Navigating through APIs and integrating different components can indeed get a bit complex, but no worries, we've got your back.

Regarding the Google email issue you encountered, it's true that Google has tightened its security policies for less secure apps, which might be causing the hiccup you're facing. A workaround could be to use "App Passwords" if you're using 2-Step Verification. This generates a unique password for your mail script to log in, bypassing the less secure app block. Here's more info on App Passwords.

For sending messages to Telegram, you would typically use the Telegram Bot API. Here's a short snippet on how you'd send a message or a video to a Telegram chat:

import requests

def send_telegram_message(bot_token, chat_id, message):
    send_url = f'https://api.telegram.org/bot{bot_token}/sendMessage'
    params = {'chat_id': chat_id, 'text': message}
    requests.get(send_url, params=params)

def send_telegram_video(bot_token, chat_id, video_path):
    send_url = f'https://api.telegram.org/bot{bot_token}/sendVideo'
    files = {'video': open(video_path, 'rb')}
    data = {'chat_id': chat_id}
    requests.post(send_url, files=files, data=data)

# Usage
bot_token = 'YOUR_BOT_TOKEN'
chat_id = 'YOUR_CHAT_ID'
send_telegram_message(bot_token, chat_id, 'Hello, world!')
send_telegram_video(bot_token, chat_id, 'path/to/your/video.mp4')

Replace 'YOUR_BOT_TOKEN' with your actual bot token and 'YOUR_CHAT_ID' with your Telegram chat ID. This should enable your Raspberry Pi project to send alerts via Telegram efficiently.

Concerning the integration of the ultrasonic sensor to display the distance of detected objects, you might consider calculating the distance and appending it to the detection message sent to Telegram. If you have specific questions about integrating ultrasonic sensor data, feel free to ask!

Hope this helps, and best of luck with your project! If you need further assistance, just drop a message! 😊

[bishtn05]

Hi! I have used both object detection and object tracking module and I have few questions.

1. I want to do the object detection within a certain boundary. I have seen application of drawing regions in the object counting module. How can I achieve the similar functionality in security alarm system for detecting people when they cross a certain boundary?
2. When a person is detected, I want to send the picture especially face as notification. Is there a way to get best non-blurry image of the person from the scene?
3. Also, I have implemented the email functionality as mentioned in the comments. So, when the person remains in the frame, I am getting notifications after every few seconds for the same person. How can i keep track of the person with object detection module? I tried to implement both detection and tracking, but it made the app very slow.
4. I have CUDA installed on my system, but I'm not able to utilize the GPU to its full potential. I can see it running only half. Is there a setting where it can run more efficiently.
5. For security alarm system, especially running on mobile, there is some lag with streaming. How can we make it run faster so that detections are also real-time and people are notified instantly.

[pderrenger]

Hello!

1. Object Boundary Detection: To detect objects within a specific boundary in a security alarm system, you can define a region of interest (ROI) in the image. Use OpenCV to create a mask for your ROI and then check if detected object coordinates intersect with this region. Here's a basic example:

   import cv2
   
   # Assuming 'box' is the bounding box of a detected object [x1, y1, x2, y2]
   # Define your ROI
   roi = (100, 100, 400, 400)  # [x1, y1, x2, y2] of the ROI
   
   # Check if the box is inside the ROI
   if box[0] >= roi[0] and box[1] >= roi[1] and box[2] <= roi[2] and box[3] <= roi[3]:
       print("Object within boundary detected.")

2. Optimal Image Capture: To capture the best non-blurry image of a person’s face, employ frame analysis techniques that evaluate the sharpness or clarity. Tap into frames where detected faces have minimal motion blur. Techniques like Laplacian variance might help in selecting the sharpest frame.

3. Object Tracking Without Multiple Alerts: To manage multiple alerts per detected person, you can integrate a tracking ID using the tracking feature in YOLO. Use a unique identifier for each person detected and manage their state. Do not trigger new alerts as long as the ID is active and within the scene.

4. GPU Utilization: Ensure your CUDA and cuDNN libraries are properly installed. Maximize GPU utilization by adjusting batch sizes and workers (threading). Larger batch sizes typically increase GPU efficiency:

   yolo detect train data=coco128.yaml model=yolov8n.pt batch=64

5. Reducing Lag in Mobile Streaming: For real-time applications on mobile, focus on lightweight models, and consider reducing the input image size to speed up the processing. Mobile-specific versions like YOLOv8n-lite or enabling hardware acceleration on mobile devices are advisable.

Hope these suggestions help in optimizing your security alarm system!

[pderrenger]

Hello! I'd be happy to help you set up your security camera system with the YOLOv8 model.

1. Handling Multiple Camera Feeds: You can handle multiple camera feeds by initializing separate threads or processes for each camera feed. Each thread can independently capture frames from its respective camera and perform detection using the YOLO model. Python's threading or multiprocessing module can be very useful here.

   Here's a brief example using threading:

   import threading
   from ultralytics import YOLO
   
   def camera_feed_thread(camera_index):
       # Load the model
       model = YOLO('yolov8n.pt', device='cuda')
   
       # Capture the video
       cap = cv2.VideoCapture(camera_index)
       while cap.isOpened():
           ret, frame = cap.read()
           if ret:
               # Perform detection
               results = model(frame)
               # Handle results
               ...
       cap.release()
   
   # Start a thread for each camera
   cameras = [0, 1, 2]  # Example camera indexes or URLs
   for index in cameras:
       threading.Thread(target=camera_feed_thread, args=(index,)).start()

2. Recommended Hardware for Medium Size Models: For running medium-sized models especially while handling multiple streams like 4-6 camera feeds in 1080p, I recommend using a robust GPU. NVIDIA GPUs like the RTX 3060, RTX 3070, or even more powerful depending on your budget and requirement would be very effective. Ensure your system has sufficient RAM and a good CPU (like an Intel i7 or Ryzen 7) to handle the data preprocessing and other tasks efficiently.

Utilizing a powerful GPU will help you maximize the real-time processing capabilities of the YOLOv8 models, especially when dealing with multiple high-resolution video feeds. Make sure your setup optimizes the use of resources across the GPU and CPU for best performance.

[mimnsam]

Hi there. Thanks for the help rendered to me earlier on. It really helped me alot Am still working on my code for the security system but I experienced an error during the drawing of the bounding boxes on the video so I first commented it out. Below is my code import cv2 from picamera2 import Picamera2 from ultralytics import YOLO import time import os import RPi.GPIO as GPIO import requests import threading import Adafruit_ADS1x15 import json # Telegram Bot API token telegram_token = "TELEGRAM TOKEN" telegram_chat_id = "CHAT ID" telegram_url_base = f"https://api.telegram.org/bot{telegram_token}/" # Initialize the ADC using I2C bus_number = 1 adc = Adafruit_ADS1x15.ADS1015(busnum=bus_number) GAIN = 1 # GPIO pin setup GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) echo_pin1, trig_pin1 = 36, 37 # North Wing sensor pins echo_pin2, trig_pin2 = 38, 40 # East Wing sensor pins buzzer1_pin, buzzer2_pin = 29, 31 # Buzzer pins # Setup GPIO pins for output/input GPIO.setup([buzzer1_pin, buzzer2_pin, trig_pin1, trig_pin2], GPIO.OUT) GPIO.setup([echo_pin1, echo_pin2], GPIO.IN) # Initialize PiCamera picam2 = Picamera2() picam2.preview_configuration.main.size = (800, 600) picam2.preview_configuration.main.format = "RGB888" picam2.preview_configuration.align() picam2.configure("preview") picam2.start() # Initialize YOLO model model = YOLO('best (1).pt') frame_size = (800, 600) # Frame size from your camera setup detection_count = 0 first_detection_time = 0 second_detection_time = 0 last_video_message_id = None def ultrasonic_distance(trig_pin, echo_pin): """Calculate distance using ultrasonic sensor.""" GPIO.output(trig_pin, True) time.sleep(0.00001) GPIO.output(trig_pin, False) start_time, stop_time = time.time(), time.time() while GPIO.input(echo_pin) == 0: start_time = time.time() while GPIO.input(echo_pin) == 1: stop_time = time.time() elapsed_time = stop_time - start_time distance = (elapsed_time * 34300) / 2 return distance def send_telegram_message(message): url = f"https://api.telegram.org/bot{telegram_token}/sendMessage" params = {"chat_id": telegram_chat_id, "text": message} requests.post(url, params=params) def delete_telegram_message(message_id): url = f"https://api.telegram.org/bot{telegram_token}/deleteMessage" params = {"chat_id": telegram_chat_id, "message_id": message_id} requests.post(url, params=params) def send_video_to_telegram(video_path): global last_video_message_id if last_video_message_id: time.sleep(15) delete_telegram_message(last_video_message_id) url = f"https://api.telegram.org/bot{telegram_token}/sendVideo" files = {'video': open(video_path, 'rb')} data = {'chat_id': telegram_chat_id} response = requests.post(url, files=files, data=data).json() last_video_message_id = response.get('result', {}).get('message_id') def record_video(): video_name = f'detected_event_{int(time.time())}.avi' video_path = os.path.join(os.getcwd(), video_name) video_writer = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'XVID'), 30, frame_size) # Set frame rate to 30 fps start_time = cv2.getTickCount() while (cv2.getTickCount() - start_time) / cv2.getTickFrequency() < 5: # Record for 5 seconds im = picam2.capture_array() video_writer.write(im) video_writer.release() # Stop recording send_telegram_message(f"Video of intrusion saved. Please check.") send_video_to_telegram(video_path) def handle_buzzers(distance1, distance2): """Activate buzzers based on distance readings.""" if distance1 < distance2: intrusion_side = "North Wing" else: intrusion_side = "East Wing" if distance1 <= 7 or distance2 <= 7: GPIO.output(buzzer1_pin, GPIO.HIGH) GPIO.output(buzzer2_pin, GPIO.HIGH) print(f"Intrusion detected on both sides, very close in the {intrusion_side}.") time.sleep(20) GPIO.output(buzzer1_pin, GPIO.LOW) GPIO.output(buzzer2_pin, GPIO.LOW) elif distance1 <= 15 or distance2 <= 15: GPIO.output(buzzer1_pin, GPIO.HIGH) print(f"Intrusion detected in the {intrusion_side}.") time.sleep(20) GPIO.output(buzzer1_pin, GPIO.LOW) def turn_off_buzzer(buzzer_pin): GPIO.output(buzzer_pin, GPIO.LOW) send_telegram_message(f"Buzzer connected to pin {buzzer_pin} has been turned off.") def check_telegram_commands(): url = telegram_url_base + "getUpdates" response = requests.get(url) data = response.json() # Parse JSON response # Check if the "result" key exists in the response if "result" in data: messages = data["result"] if messages: for message in messages: try: text = message["message"]["text"] if text == "off1": turn_off_buzzer(buzzer1_pin) elif text == "off2": turn_off_buzzer(buzzer2_pin) # Update offset to only receive new messages later last_update_id = message["update_id"] + 1 requests.get(url, params={"offset": last_update_id}) except KeyError: continue while True: check_thread = threading.Thread(target=check_telegram_commands) # Regularly check for new commands check_thread.start() record = False resistance = adc.read_adc(0, gain=GAIN) if resistance > 750: distance1 = ultrasonic_distance(trig_pin1, echo_pin1) distance2 = ultrasonic_distance(trig_pin2, echo_pin2) print(f"North Wing Distance: {distance1:.2f} cm, East Wing Distance: {distance2:.2f} cm") # Capture frame from PiCamera im = picam2.capture_array() # Perform object detection with YOLO results = model(im, conf=0.4) # After running detection for result in results: num_people_detected = 0 for box in result.boxes: # Assuming 'person' class index is 0, adjust based on your model if box.cls == 0: threading.Thread(target=handle_buzzers, args=(distance1, distance2)).start() num_people_detected += 1 print("Person detected within range!") if num_people_detected > 0: people_message = f"{num_people_detected} {'person' if num_people_detected == 1 else 'people'} detected within {distance1} cm." send_telegram_message(people_message + f" Distance left to reach the house: {distance1} cm.") # Start recording if two detections within 5 seconds if detection_count == 0: first_detection_time = time.time() elif detection_count == 1: second_detection_time = time.time() detection_count += num_people_detected if detection_count >= 1 and (second_detection_time - first_detection_time) <= 5: record = True # Record video if activated if record: threading.Thread(target=record_video).start() detection_count = 0 # Reset detection count # Draw bounding boxes on the image # results.show() # Display the image with bounding boxes cv2.imshow("YOLO Object Detection", im) # Exit if 'q' is pressed if cv2.waitKey(1) == ord('q'): break # Clean up GPIO.cleanup() cv2.destroyAllWindows() The code works in this format it gets readings from the ldr, incase below threshold, it activates the camera to carry out object detection, incase the class is detected it activates the buzzers according to the activation distance of each buzzer, and then sends the recorded video plus distance left to reach the house from the different ultrasonic readings and I wanted some help so that the distance is labelled like intruder found in the north wing, distance left to reach the house..... and then like that for also the east wing to the specified telegram bot but the diatance shouldbe sent if its less than 15cm, and then deletes the sent video after 15sec by replacing it with the new recorded video, plus I wanted some help so that the system is always listening for incoming commands from the telegram bot to turn off specified buzzers. Also wanted to ask for the best way of applying threading to the code because the previous ways I tried where sending a video with an unrecognised format. I also wanted to enable live streaming to the telegram bot but failed. Any help rendered to me will be priceless. Thank you

[pderrenger]

Hello! I'm glad the previous assistance was helpful. For drawing bounding boxes on the video using your system, you seem to have most components set up correctly. However, to help you further with your requirements, here are some pointers:

1. Bounding Boxes Drawing:
   If the results.show() method is unfavorably commented out, ensure that the frames you get from the picam2.capture_array() call are in the correct format. Then, you can overlay the bounding boxes using this snippet right before your cv2.imshow():

   for result in results:
       if result.boxes:
           annotated_image = result.plot()  # Adds boxes to the image
           cv2.imshow("YOLO Object Detection", annotated_image)

2. Distance Labeling and Telegram Messaging:
   Modify the send_telegram_message function to include the distance based on your needs. It sounds like you want to append distance information per location:

   def send_telegram_message_with_distance(message, distance, location):
       final_message = f"{message} Intruder found in the {location}, distance left to reach the house: {distance} cm."
       params = {"chat_id": telegram_chat_id, "text": final_message}
       requests.post(telegram_url_base + "sendMessage", params=params)

   Use this function and pass the respective distance and location when calling within your detection conditions.

3. Threading for Real-time Commands:
   For managing threading and ensuring video format integrity, make sure to set the correct codec and format when initializing cv2.VideoWriter.

   fourcc = cv2.VideoWriter_fourcc(*'XVID')
   video_writer = cv2.VideoWriter(video_path, fourcc, 20.0, (640, 480))

4. Live Streaming to Telegram:
   Live streaming directly to Telegram is complex because Telegram doesn't support real-time video streaming. Instead, consider using a different platform that supports streaming, like YouTube Live, and then share the link through Telegram.

For threaded operations, ensure each thread handles a distinct task to prevent resource clashes, and always synchronize shared resources appropriately.

If you encounter further issues or specific errors, do share the error messages or symptoms to better address the problems!

Hope this helps! 🚀

[mimnsam]

Thanks alot. It really worked out well. But I happened to face a challenge, i tried to integrate the bounding boxes onto the video that was being sent but then it seemed as if the video that was being sent was just an image with 0sec. Any help rendered would be appreciated. Secondly am inquiring on how I can make this program run on start. I am using VS Code to run it but when I try running the program using crontab, it fails to identify the model yet both are in the same folder. Thank you

…

On Tue, 14 May 2024, 00:12 Paula Derrenger, ***@***.***> wrote: Hello! I'm glad the previous assistance was helpful. For drawing bounding boxes on the video using your system, you seem to have most components set up correctly. However, to help you further with your requirements, here are some pointers: 1. *Bounding Boxes Drawing:* If the results.show() method is unfavorably commented out, ensure that the frames you get from the picam2.capture_array() call are in the correct format. Then, you can overlay the bounding boxes using this snippet right before your cv2.imshow(): for result in results: if result.boxes: annotated_image = result.plot() # Adds boxes to the image cv2.imshow("YOLO Object Detection", annotated_image) 2. *Distance Labeling and Telegram Messaging:* Modify the send_telegram_message function to include the distance based on your needs. It sounds like you want to append distance information per location: def send_telegram_message_with_distance(message, distance, location): final_message = f"{message} Intruder found in the {location}, distance left to reach the house: {distance} cm." params = {"chat_id": telegram_chat_id, "text": final_message} requests.post(telegram_url_base + "sendMessage", params=params) Use this function and pass the respective distance and location when calling within your detection conditions. 3. *Threading for Real-time Commands:* For managing threading and ensuring video format integrity, make sure to set the correct codec and format when initializing cv2.VideoWriter. fourcc = cv2.VideoWriter_fourcc(*'XVID')video_writer = cv2.VideoWriter(video_path, fourcc, 20.0, (640, 480)) 4. *Live Streaming to Telegram:* Live streaming directly to Telegram is complex because Telegram doesn't support real-time video streaming. Instead, consider using a different platform that supports streaming, like YouTube Live, and then share the link through Telegram. For threaded operations, ensure each thread handles a distinct task to prevent resource clashes, and always synchronize shared resources appropriately. If you encounter further issues or specific errors, do share the error messages or symptoms to better address the problems! Hope this helps! 🚀 — Reply to this email directly, view it on GitHub <#9395 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BH3Z3KSOUG54AI5TLXIX2GLZCEUDPAVCNFSM6AAAAABFN47Q7CVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TIMRWGA3DM> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

Hello! It sounds like you're making great progress with your project. Let's address your concerns:

1. Video as an Image Issue: It seems the video might not be encoded correctly when being saved. Ensure you're using cv2.VideoWriter to save the video and set the correct codec and frame size. Here’s a quick example:

   fourcc = cv2.VideoWriter_fourcc(*'XVID')
   out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640, 480))
   while True:
       ret, frame = cap.read()
       if ret:
           # your detection code
           out.write(frame)  # save frame to video
       else:
           break
   out.release()

2. Auto-Start on System Boot: For running scripts at startup with crontab, ensure your script uses absolute paths for the model and any other files it accesses. Also, specify the full path to the Python interpreter. Here’s an example crontab entry:

   @mimnsam /usr/bin/python3 /home/user/my_script.py

Make sure your Python script and all related files (like the model file) are accessible from the path where the script runs, and that all necessary environment variables are set correctly in the script or sourced in the crontab.

If you need more detailed guidance, feel free to check out our Security Alarm System guide for more insights on setting up projects with YOLOv8. Keep up the great work! 🚀

[mimnsam]

thank you. but ive failed to integrate them . this is my code. def record_video(): video_name = f'detected_event_{int(time.time())}.avi' video_path = os.path.join(os.getcwd(), video_name) # Initialize video writer fourcc = cv2.VideoWriter_fourcc(*'XVID') video_writer = cv2.VideoWriter(video_path, fourcc, 20.0, frame_size) start_time = time.time() while (time.time() - start_time) < 5: # Record for 5 seconds im = picam2.capture_array() # Perform object detection and annotate frame results = model(im, conf=0.4) annotated_image = im.copy() for result in results: for box in result.boxes: annotated_image = result.plot(annotated_image) # Adds boxes to the image video_writer.write(annotated_image) # Save frame to video cv2.imshow("YOLO Object Detection", annotated_image) cv2.waitKey(1) # Display the frame video_writer.release() # Stop recording cv2.destroyAllWindows() send_telegram_message("Video of intrusion saved. Please check.") send_video_to_telegram(video_path)

…

On Tue, May 21, 2024 at 5:22 PM Glenn Jocher ***@***.***> wrote: Hello! It sounds like you're making great progress with your project. Let's address your concerns: 1. *Video as an Image Issue*: It seems the video might not be encoded correctly when being saved. Ensure you're using cv2.VideoWriter to save the video and set the correct codec and frame size. Here’s a quick example: fourcc = cv2.VideoWriter_fourcc(*'XVID')out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640, 480))while True: ret, frame = cap.read() if ret: # your detection code out.write(frame) # save frame to video else: breakout.release() 2. *Auto-Start on System Boot*: For running scripts at startup with crontab, ensure your script uses absolute paths for the model and any other files it accesses. Also, specify the full path to the Python interpreter. Here’s an example crontab entry: @mimnsam /usr/bin/python3 /home/user/my_script.py Make sure your Python script and all related files (like the model file) are accessible from the path where the script runs, and that all necessary environment variables are set correctly in the script or sourced in the crontab. If you need more detailed guidance, feel free to check out our Security Alarm System guide <https://docs.ultralytics.com/guides/security-alarm-system/> for more insights on setting up projects with YOLOv8. Keep up the great work! 🚀 — Reply to this email directly, view it on GitHub <#9395 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BH3Z3KQGDXNRWMMVDKNDO5LZDNKDJAVCNFSM6AAAAABFN47Q7CVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TKMBZGI3TS> . You are receiving this because you commented.Message ID: ***@***.*** com>

[pderrenger]

@mimnsam hello! It looks like you're almost there with integrating the video recording and object detection. I noticed a small issue in your code where you're trying to plot bounding boxes. You should update the plot_bboxes method to handle the results correctly. Here's a corrected snippet for your loop:

# Perform object detection and annotate frame
results = model(im, conf=0.4)
annotated_image = results.render()[0]  # This will render the detections directly onto the image

video_writer.write(annotated_image)  # Save frame to video
cv2.imshow("YOLO Object Detection", annotated_image)
cv2.waitKey(1)  # Display the frame

Make sure that model is properly loaded with the YOLO model and configured before this loop. This adjustment should help you integrate the detection results directly into your video stream correctly. If you need further assistance, feel free to ask! 🚀

[mimnsam]

thanks for the help but i experienced this error Exception in thread Thread-15 (record_video): Traceback (most recent call last): File "/usr/lib/python3.11/threading.py", line 1038, in _bootstrap_inner self.run() File "/usr/lib/python3.11/threading.py", line 975, in run self._target(*self._args, **self._kwargs) File "/home/Abdul/project/annotated video.py", line 125, in record_video annotated_image = results.render()[0] # This will render the detections directly onto the image ^^^^^^^^^^^^^^ AttributeError: 'list' object has no attribute 'render'

…

On Wed, May 22, 2024 at 1:23 AM Paula Derrenger ***@***.***> wrote: @mimnsam <https://github.com/mimnsam> hello! It looks like you're almost there with integrating the video recording and object detection. I noticed a small issue in your code where you're trying to plot bounding boxes. You should update the plot_bboxes method to handle the results correctly. Here's a corrected snippet for your loop: # Perform object detection and annotate frameresults = model(im, conf=0.4)annotated_image = results.render()[0] # This will render the detections directly onto the image video_writer.write(annotated_image) # Save frame to videocv2.imshow("YOLO Object Detection", annotated_image)cv2.waitKey(1) # Display the frame Make sure that model is properly loaded with the YOLO model and configured before this loop. This adjustment should help you integrate the detection results directly into your video stream correctly. If you need further assistance, feel free to ask! 🚀 — Reply to this email directly, view it on GitHub <#9395 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BH3Z3KRE7YCZHSTKH6AWMXTZDPCPJAVCNFSM6AAAAABFN47Q7CVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TKMJUGI2TQ> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

Hello! It looks like you're encountering an AttributeError because the render() method is not available for the list object returned by the model prediction. In the latest versions of Ultralytics YOLO, you should use the plot() method on the Results object to render the detections onto the image. Here's how you can modify your code:

results = model(im0)  # Run the model prediction
annotated_image = results.plot()[0]  # This will render the detections directly onto the image

Make sure to replace results.render()[0] with results.plot()[0] in your code. This should resolve the error and allow you to continue with your project. If you have any more questions or need further assistance, feel free to ask. Happy coding! 🚀

[kipropcheruiyot]

Hello,
Hello, i am requesting assistance,in attaching camera recording (15sec) to the email so that it can be sent together with the notification. I have managed to update the code to have a cool down period of 3 minutes, to reduce spam and also save the camera recording in the script folder but can't figure out a way send it, most of the approaches i have attempted have not been successful. Here's the code
import torch

import numpy as np
import cv2

import time

#from time import time
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

import supervision as sv

import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

from email_settings import password, from_email, to_email

create Server

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

##login credentials for sending the mail

server.login(from_email, password)

def send_email(to_email, from_email, people_detected = 1):
message = MIMEMultipart()
message["From"] = from_email
message["To"] = to_email
message["Subject"] = f"SECURITY ALERT"
##message body
message_body = f"ALERT - {people_detected} person has been detected!!"
message.attach(MIMEText(message_body, "plain"))
server.sendmail(from_email, to_email, message.as_string())

def record_video(cap, video_writer, duration=15):
start_time = time.time()
while time.time() - start_time < duration:
ret, frame = cap.read()
if not ret:
break
video_writer.write(frame)
video_writer.release()

class ObjectDetection:

def __init__(self, capture_index):
    self.capture_index = capture_index
    self.email_sent = False
    self.cooldown_period = 180
    self.last_email_time = time.time() - self.cooldown_period
    self.previous_detections = []

    
    #model info
    self.model = YOLO("yolov8n.pt")

    #Visual info
    self.annotator = None
    self.start_time = 0
    self.end_time = 0

    #Device info
    self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print("Using Device", self.device)
    

def predict(self, im0):
    """Run prediction using a YOLO model for the input image `im0`."""
    results = self.model(im0, conf = 0.7)
    return results

def display_fps(self, im0):
    """Displays the FPS on an image `im0` by calculating and overlaying as white text on a black rectangle."""
    self.end_time = time.time()
    fps = 1/ np.round(self.end_time - self.start_time, 2)
    text = f"FPS: {int(fps)}"
    text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 1.0, 2)[0]
    gap = 10
    cv2.rectangle(
        im0,
        (20 - gap, 70 - text_size[1] - gap),
        (20 + text_size[0] + gap, 70 + gap),
        (255, 255, 255),
        -1,
    )
    cv2.putText(im0, text, (20,70), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2)

    ##################################
def plot_bboxes(self, results, im0):
    """Plots bounding boxes on an image given detection results; returns annotated image and class IDs."""
    class_ids = []
    self.annotator = Annotator(im0, 3, results[0].names)
    boxes = results[0].boxes.xyxy.cpu()
    clss = results[0].boxes.cls.cpu().tolist()
    names = results[0].names

    #unique_detections = set()
    for box, cls in zip(boxes, clss):
        if int(cls) == 0:
            class_ids.append(cls)
            self.annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
    
    return im0, class_ids

def __call__(self):
    try:
        cap = cv2.VideoCapture(self.capture_index)
        assert cap.isOpened()
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
        video_writer = None
        video_start_time = 0

        while True:
            self.start_time = time.time()
            ret, im0 = cap.read()
            assert ret
            results = self.predict(im0)
            im0, class_ids = self.plot_bboxes(results, im0)

            # Check for unique detections and if enough time has passed to send another email
            current_time = time.time()
            if len(class_ids) > 0 and (current_time - self.last_email_time >= self.cooldown_period):
                send_email(to_email, from_email, len(class_ids))
                self.last_email_time = current_time

                # Start recording a 15-second video
                if video_writer is None:
                    video_writer = cv2.VideoWriter('detected_video.mp4', fourcc, 30.0, (640, 480))
                    video_start_time = current_time

            if video_writer is not None:
                video_writer.write(im0)
                if current_time - video_start_time >= 15:
                    video_writer.release()
                    video_writer = None

            self.display_fps(im0)
            cv2.imshow("YOLOv8 Detection", im0)

            if cv2.waitKey(5) & 0xFF == 27:
                break

    except Exception as e:
        print(f"Error: {e}")

    cap.release()
    if video_writer is not None:
        video_writer.release()
    cv2.destroyAllWindows()
    server.quit() 

detector = ObjectDetection(capture_index=0)
detector()

[glenn-jocher]

You're very welcome! 😊 I'm glad to hear the code is working perfectly for you. If you need any further assistance or have more questions, feel free to ask. The YOLO community and the Ultralytics team are always here to help!

For more detailed guidance on integrating YOLOv8 into your projects, you might find the Security Alarm System Project guide particularly useful. Happy coding! 🚀

[kipropcheruiyot]

Hello, i wanted to export the above model to onnx and include the following arguments: init8, nms, half. I added the following functions but wasn't successful:
def preprocess_image(image):
resized_image = cv2.resize(image, (640, 480))
processed_image = cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB)
processed_image = processed_image /255.0

    return processed_image

def postprocess_output(output):
return output

class ObjectDetection:

def __init__(self, capture_index):
    self.capture_index = capture_index
    self.email_sent = False
    self.cooldown_period = 180
    self.last_email_time = time.time() - self.cooldown_period
    self.previous_detections = []

    
    #model info
    self.model = YOLO("yolov8n.pt")

    #ONNX
    self.onnx_model_path = "yolov8n.onnx"
    self.onnx_session = None

    torch.onnx.export(self.model, torch.zeros(1, 3, 640, 480), self.onnx_model_path, verbose=True,
                      input_names=["input"], output_names=["output"],
                      #half = True, int8 = True, nms = True)
    )
    #onnx ort
def load_onnx_model(self, onnx_model_path):               
    self.onnx_session = ort.InferenceSession(onnx_model_path)
    
    #Visual info
    self.annotator = None
    self.start_time = 0
    self.end_time = 0

    #Device info
    self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print("Using Device", self.device)



def predict(self, im0):
    """Run prediction using a onnx for the input image `im0`."""
    input_data = preprocess_image(im0)

    #run inference using onnx
    ort_inputs = {self.onnx_session.get_inputs()[0].name: input_data}
    ort_outs = self.onnx_session.run(None, ort_inputs)

    return postprocess_output(ort_outs)

[glenn-jocher]

@kipropcheruiyot hello,

Thanks for reaching out! It looks like you're trying to export your model with specific configurations (int8, nms, half). Currently, the torch.onnx.export() function does not directly support int8 quantization or built-in nms during the export process. Here are a few suggestions:

1. Half Precision: You can convert your model to half precision before exporting by using:

   self.model.half()  # Convert model to half precision

2. INT8 Quantization: This is typically done post-export as part of the optimization process in the ONNX runtime or other inference engines that support INT8.

3. NMS: NMS is usually applied during the inference phase rather than during export. If you need NMS to be part of the ONNX graph, you might need to manually implement it as part of your network or use post-processing scripts after running the inference.

For exporting with half precision, you can modify your export line as follows:

self.model.half()  # Convert to half precision
torch.onnx.export(self.model, torch.zeros(1, 3, 640, 480).half(), self.onnx_model_path, verbose=True, input_names=["input"], output_names=["output"])

For more detailed guidance on handling these configurations, please refer to the ONNX and PyTorch documentation regarding model quantization and optimization.

If you have any more questions or need further assistance, feel free to ask!

[kipropcheruiyot]

okay, thank you for your help and insights on those configurations

[glenn-jocher]

@kipropcheruiyot you're welcome! I'm glad I could assist you. If you have any more questions or need further help as you continue with your project, feel free to reach out. Happy coding! 😊🚀

[yeongnamtan]

i would like to do detection of unattended baggage in a public area eg. on a train platform. Upon detection to send email alert to the control center. My problem is that an unattended baggage could be any object class. The question is : how do we decide if an item is considered "unattended" ? based on idle time in a region ?

[pderrenger]

Hi there!

Detecting unattended baggage in a public area is a fascinating and important use case. You're correct that determining if an item is "unattended" can be challenging since it could be any object class. One effective approach is to monitor the idle time of objects within a specific region.

Here's a high-level strategy to achieve this:

1. Object Detection: Use YOLOv8 to detect objects in the scene.
2. Tracking: Implement object tracking to follow the detected objects over time.
3. Idle Time Calculation: Measure the time each object remains stationary in a specific area.
4. Alert System: Trigger an alert if an object exceeds a predefined idle time threshold.

Below is a simplified example to get you started. This script integrates object detection, tracking, and an alert system:

import cv2
import time
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import smtplib

# Email setup
password = "your_app_password"
from_email = "your_email @yeongnamtan.com"
to_email = "receiver_email@gmail.com"

server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)

def send_email(to_email, from_email, object_detected=1):
    message = MIMEMultipart()
    message["From"] = from_email
    message["To"] = to_email
    message["Subject"] = "Security Alert"
    message_body = f"ALERT - {object_detected} objects have been detected!!"
    message.attach(MIMEText(message_body, "plain"))
    server.sendmail(from_email, to_email, message.as_string())

class ObjectDetection:
    def __init__(self, capture_index):
        self.capture_index = capture_index
        self.email_sent = False
        self.model = YOLO("yolov8n.pt")
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.idle_objects = {}

    def predict(self, im0):
        results = self.model(im0)
        return results

    def plot_bboxes(self, results, im0):
        class_ids = []
        annotator = Annotator(im0, 3, results[0].names)
        boxes = results[0].boxes.xyxy.cpu()
        clss = results[0].boxes.cls.cpu().tolist()
        names = results[0].names
        for box, cls in zip(boxes, clss):
            class_ids.append(cls)
            annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
        return im0, class_ids

    def __call__(self):
        cap = cv2.VideoCapture(self.capture_index)
        assert cap.isOpened()
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        while True:
            ret, im0 = cap.read()
            assert ret
            results = self.predict(im0)
            im0, class_ids = self.plot_bboxes(results, im0)

            # Update idle time for detected objects
            current_time = time.time()
            for cls in class_ids:
                if cls not in self.idle_objects:
                    self.idle_objects[cls] = current_time
                elif current_time - self.idle_objects[cls] > 60:  # 60 seconds threshold
                    if not self.email_sent:
                        send_email(to_email, from_email, len(class_ids))
                        self.email_sent = True
            else:
                self.email_sent = False

            cv2.imshow("YOLOv8 Detection", im0)
            if cv2.waitKey(5) & 0xFF == 27:
                break
        cap.release()
        cv2.destroyAllWindows()
        server.quit()

detector = ObjectDetection(capture_index=0)
detector()

This script initializes the YOLOv8 model, captures video frames, detects objects, and tracks their idle time. If an object remains stationary for more than 60 seconds, an email alert is sent.

For more detailed guidance, you can refer to our Security Alarm System Project.

Feel free to customize the code to fit your specific requirements. If you encounter any issues or have further questions, please provide a reproducible example, and ensure you are using the latest versions of the packages.

Best of luck with your project! 🚀