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, "[email protected]", msg)

Make sure to replace "[email protected]" 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! 😊

[nextgenai-research]

Hello there! Can you please share the code snippet of taking the snapshot of the frame when the person is detected and attach the same in the email?

[glenn-jocher]

@nextgenai-research hey there! 🎉 I'm thrilled to hear you're excited about integrating YOLOv8 into your app.

For taking a snapshot when a person is detected and emailing it, you can use the provided ObjectDetection class. Just ensure you have the SMTP setup correctly for the send_email function.

Here's a brief example to integrate the snapshot feature within plot_bboxes:

    def plot_bboxes(self, results, im0):
        ...
        for box, cls in zip(boxes, clss):
            if names[int(cls)] == 'person':
                cv2.imwrite('person_detected.jpg', im0)  # Save the snapshot
                send_email(to_email, from_email, subject="Person Detected!", attachment='person_detected.jpg')  # Send email
        ...

And your send_email might look like this:

from email.mime.image import MIMEImage

def send_email(to_email, from_email, subject, attachment=None):
    ...
    if attachment:
        with open(attachment, 'rb') as f:
            img = MIMEImage(f.read(), name=os.path.basename(attachment))
            message.attach(img)
    ...
    server.send_message(message)

Make sure you tailor this for your SMTP config and attachment handling. Happy coding, and feel free to reach out if you have more questions! 🚀

[nextgenai-research]

Hello @glenn-jocher, thank you!! It works flawlessly. I am wondering how to take short video clip (3 - 5 secs). Can you please advise?

[glenn-jocher]

Hey there! 🎉 I'm glad things are working well for you. To take a short video when a person is detected, you could alter the code to start recording once a person is identified and stop after a specific duration.

Here's a quick example of how you could approach this:

1. Start Recording: When a person is detected, check if you're not already recording. If not, start recording.
2. Stop Recording: After 3-5 seconds, stop recording. You might use a simple time check for this.

You'd integrate this logic into the detection loop where you process each frame. Unfortunately, the exact code snippet for this process would depend heavily on the specifics of your application and the libraries you're using for video handling (like OpenCV).

For OpenCV, it would look somewhat like this inside your detection and alert sending logic:

import cv2
from time import time

# Initialize video writer
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640,480))
recording_start_time = None

def record_video(frame):
    global recording_start_time
    if recording_start_time is None:
        recording_start_time = time()  # Mark start time
    out.write(frame)  # Write frame to video file
    if time() - recording_start_time > 5:  # Stop after 5 seconds
        out.release()  # Stop recording
        recording_start_time = None  # Reset for next time

Remember to initiate cv2.VideoWriter with the correct parameters matching your frame size and desired FPS. Also, adjust the above code as necessary to fit within your specific detection handling.

Best of luck with your application, and feel free to reach out if you have more questions! 😊

[nextgenai-research]

Hello there! Thank you so much for your assistance. Last couple of days, I am trying to fix the error but in vain. Can you please advise?

[ WARN:[email protected]] global /private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f6tvh9615u/croot/opencv-suite_1691620375715/work/modules/videoio/src/cap_gstreamer.cpp (2180) open OpenCV | GStreamer warning: cannot link elements
[ERROR:[email protected]] global /private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f6tvh9615u/croot/opencv-suite_1691620375715/work/modules/videoio/src/cap.cpp (597) open VIDEOIO(CV_IMAGES): raised OpenCV exception:

OpenCV(4.6.0) /private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f6tvh9615u/croot/opencv-suite_1691620375715/work/modules/videoio/src/cap_images.cpp:253: error: (-5:Bad argument) CAP_IMAGES: can't find starting number (in the name of file): output.avi in function 'icvExtractPattern'

Here is the code snippet

import torch
import numpy as np
import cv2
import supervision as sv
import os
import smtplib
from time import time

Initialize video writer

fourcc = cv2.VideoWriter_fourcc(*'XVID')
print("self.fourcc******** ", fourcc)
#out = cv2.VideoWriter('output.avi', fourcc, 1.0, (640,480))
recording_start_time = None

def record_video(self, frame):

    global recording_start_time
    if recording_start_time is None:
        recording_start_time = time()  # Mark start time
    out.write(frame)  # Write frame to video file
    if time() - recording_start_time > 5:  # Stop after 5 seconds
        out.release()  # Stop recording
        recording_start_time = None  # Reset for next time


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)

    frame_count = 0

    while True:

        start_time = time()
        ret, frame = cap.read()
        assert ret
        print('ret =', ret, 'W =', frame.shape[1], 'H =', frame.shape[0], 'channel =', frame.shape[2])
        results = self.predict(frame)
        frame, class_ids = self.plot_bboxes(results, frame)
        #cv2.imwrite('detected_person.jpg', frame)  # Save frame
        self.record_video(frame)

        if len(class_ids) > 0:
            if not self.email_sent:
                send_email(to_email, from_email, len(class_ids), attachment='output.avi')
                self.email_sent = True #Set the flag to True after sending the email
            else:
                self.email_sent = False # Reset the flag when no person is detected


        end_time = time()
        fps = 1 / np.round(end_time - start_time, 2)
        
        cv2.putText(frame, f'FPS: {int(fps)}', (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 1.5,(125, 246, 55),2)
        
        cv2.imshow('Person Detection', frame)

        frame_count += 1

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

            break

    cap.release()
    cv2.destroyAllWindows()
    server.quit()

[glenn-jocher]

@nextgenai-research hey there, thanks for reaching out and sharing the error details! It looks like there's an issue with your OpenCV GStreamer configuration or the way OpenCV is trying to handle your video file.

From the error, it seems like cv2.VideoCapture() is failing to correctly parse 'output.avi'. If you're sure the file path and name are correct, consider checking if you have the necessary codecs installed or if there's an issue with the file itself. Here is a simplified check you can add before entering your main loop to verify if the capture device is initialized properly:

if not cap.isOpened():
    print("Error opening the video file. Please check the file path and format.")
else:
    while True:
        ret, frame = cap.read()
        if not ret:
            print("Can't receive frame (stream end?). Exiting ...")
            break
        # process the frame

This snippet will help catch and understand the error more dynamically, giving you a specific message if something is wrong with your video file opening or processing! If the problem persists, please make sure the video "output.avi" exists at the specified location and that it is not corrupted. 😊

Let me know if this helps or if you need more assistance!

[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!

[nextgenai-research]

Hello @glenn-jocher - I am planning to incorporate Yolov8 model in my security camera system. Can you please advise on the below?

1. How can we handle multiple security camera feeds?
2. Please suggest the best hardware device to run medium size model? Factoring multiple camera feeds for security monitoring. Ex: 4 - 6 camera feeds streaming in 1080.

[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 = "[email protected]"

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! 🚀

[yqsl123]

Hi! How do I modify the program to display the detected category names in my email?

[yqsl123]

I realized the function I wanted, thank you for your answer!

[yeongnamtan]

@glenn-jocher

I followed your code but the email I get still doesn't show the category ...

"""

save output to mp4

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
import torch # Import PyTorch library

Email setup

password = "cubg olsr afwj fapo"
from_email = "[email protected]" # must match the email used to generate the password
to_email = "[email protected]" # receiver email

Server Creation and Authentication

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

def send_email(to_email, from_email, object_detected=1, category_names=None):
"""Sends an email notification indicating the number of objects detected and their categories."""
message = MIMEMultipart()
message["From"] = from_email
message["To"] = to_email
message["Subject"] = "Security Alert"

# Create the message body
if category_names:
    categories = ', '.join(category_names)
    message_body = f"ALERT - {object_detected} objects detected: {categories}."
else:
    message_body = f"ALERT - {object_detected} objects detected!!"

message.attach(MIMEText(message_body, "plain"))
server.sendmail(from_email, to_email, message.as_string())

class ObjectDetection:
def init(self, capture_source):
self.capture_source = capture_source
self.email_sent = False
self.model = YOLO("/content/best_abandonedbag.pt") # model weights
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_source)  # Use the capture source (video file path or webcam index)
    assert cap.isOpened()
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

    # Initialize video writer
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (640, 480))

    while True:
        ret, im0 = cap.read()
        if not ret:  # If no frame is returned, break the loop
            break
        results = self.predict(im0)
        im0, class_ids = self.plot_bboxes(results, im0)

        # Write the frame to the video file
        out.write(im0)

        # Update idle time for detected objects
        current_time = time.time()
        if class_ids:  # If objects are detected
            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:  # If no objects are detected
            self.email_sent = False

        cv2_imshow(im0)  # Pass only the image to cv2_imshow
        if cv2.waitKey(5) & 0xFF == 27:
            break
    cap.release()
    out.release()  # Release the video writer
    cv2.destroyAllWindows()
    server.quit()

detector = ObjectDetection(capture_source="unattendedbag3.mp4")
detector()
"""
email:
ALERT - 1 objects detected!!

[glenn-jocher]

Hi @yeongnamtan,

Thank you for sharing your code! It looks like you're almost there. The issue seems to be with how the category names are being passed to the send_email function. Let's make sure the category names are correctly extracted and passed.

Here's a small adjustment to ensure the category names are included in your email:

Update the plot_bboxes Method

Ensure that plot_bboxes returns the category names along with the class IDs:

def plot_bboxes(self, results, im0):
    """Plots bounding boxes on an image given detection results; returns annotated image and class names."""
    class_names = []
    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_names.append(names[int(cls)])
        annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
    return im0, class_names

Update the __call__ Method

Pass the category names to the send_email function:

def __call__(self):
    cap = cv2.VideoCapture(self.capture_source)  # Use the capture source (video file path or webcam index)
    assert cap.isOpened()
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

    # Initialize video writer
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (640, 480))

    while True:
        ret, im0 = cap.read()
        if not ret:  # If no frame is returned, break the loop
            break
        results = self.predict(im0)
        im0, class_names = self.plot_bboxes(results, im0)

        # Write the frame to the video file
        out.write(im0)

        # Update idle time for detected objects
        current_time = time.time()
        if class_names:  # If objects are detected
            if not self.email_sent:
                send_email(to_email, from_email, len(class_names), category_names=class_names)
                self.email_sent = True
        else:  # If no objects are detected
            self.email_sent = False

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

With these changes, your email should now include the detected category names. If you continue to experience issues, please ensure you are using the latest version of the Ultralytics YOLOv8 package. You can update it using:

pip install --upgrade ultralytics

Feel free to reach out if you have any further questions. Happy coding! 😊

[yqsl123]

How can I improve this code to display the category name and the corresponding number of categories in the emali, and how can I display the confidence in the camera's shot.

password = ""
from_email = ""  # must match the email used to generate the password
to_email = ""  # receiver email

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


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


def send_email(to_email, from_email, object_detected=1, category_names=None):
    """Sends an email notification indicating the number of objects detected; defaults to 1 object."""
    message = MIMEMultipart()
    message["From"] = from_email
    message["To"] = to_email
    message["Subject"] = "Security Alert"
    # Create the message body
    if category_names:
        categories = ', '.join(category_names)
        message_body = f"ALERT - {object_detected} objects detected: {categories}."
    else:
        message_body = f"ALERT - {object_detected} objects detected!!"

    message.attach(MIMEText(message_body, "plain"))
    server.sendmail(from_email, to_email, message.as_string())

from time import time
import cv2
import torch
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors


class ObjectDetection:
    def __init__(self, capture_index):
        """Initializes an ObjectDetection instance with a given camera index."""
        self.capture_index = capture_index
        self.email_sent = False

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

        # visual information
        self.annotator = None
        self.start_time = 0
        self.end_time = 0

        # device information
        self.device = "cuda" if torch.cuda.is_available() else "cpu"

    def predict(self, im0):
        """Run prediction using a YOLO model for the input image `im0`."""
        results = self.model(im0)
        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()
        fps = 1 / 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 names."""
        class_names = []
        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
        for box, cls in zip(boxes, clss):
            class_names.append(names[int(cls)])
            self.annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
        return im0, class_names

    def __call__(self):
        """Run object detection on video frames from a camera stream, plotting and showing the results."""
        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)
        frame_count = 0
        while True:
            self.start_time = time()
            ret, im0 = cap.read()
            assert ret
            results = self.predict(im0)
            im0, class_names = self.plot_bboxes(results, im0)

            if len(class_names) > 0:  # Only send email if not sent before
                if not self.email_sent:
                    send_email(to_email, from_email, len(class_names), category_names=class_names)
                    self.email_sent = True
            else:
                self.email_sent = False

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

detector = ObjectDetection(capture_index=0)
detector()

[glenn-jocher]

Hi @yqsl123,

Thank you for sharing your code! To enhance your email notifications by including both the category names and the corresponding number of categories, as well as displaying the confidence scores in the camera's shot, you can make the following adjustments:

Update the send_email Function

Modify the send_email function to include the number of each detected category and their confidence scores:

def send_email(to_email, from_email, object_detected=1, category_details=None):
    """Sends an email notification indicating the number of objects detected and their categories with confidence scores."""
    message = MIMEMultipart()
    message["From"] = from_email
    message["To"] = to_email
    message["Subject"] = "Security Alert"
    
    # Create the message body
    if category_details:
        details = '\n'.join([f"{name}: {count} (Confidence: {conf:.2f})" for name, count, conf in category_details])
        message_body = f"ALERT - {object_detected} objects detected:\n{details}."
    else:
        message_body = f"ALERT - {object_detected} objects detected!!"
    
    message.attach(MIMEText(message_body, "plain"))
    server.sendmail(from_email, to_email, message.as_string())

Update the plot_bboxes Method

Ensure that plot_bboxes returns the category details (names, counts, and confidence scores):

def plot_bboxes(self, results, im0):
    """Plots bounding boxes on an image given detection results; returns annotated image and category details."""
    category_details = []
    self.annotator = Annotator(im0, 3, results[0].names)
    boxes = results[0].boxes.xyxy.cpu()
    clss = results[0].boxes.cls.cpu().tolist()
    confs = results[0].boxes.conf.cpu().tolist()
    names = results[0].names
    for box, cls, conf in zip(boxes, clss, confs):
        category_details.append((names[int(cls)], 1, conf))
        self.annotator.box_label(box, label=f"{names[int(cls)]} {conf:.2f}", color=colors(int(cls), True))
    return im0, category_details

Update the __call__ Method

Pass the category details to the send_email function:

def __call__(self):
    cap = cv2.VideoCapture(self.capture_source)  # Use the capture source (video file path or webcam index)
    assert cap.isOpened()
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

    # Initialize video writer
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (640, 480))

    while True:
        ret, im0 = cap.read()
        if not ret:  # If no frame is returned, break the loop
            break
        results = self.predict(im0)
        im0, category_details = self.plot_bboxes(results, im0)

        # Write the frame to the video file
        out.write(im0)

        # Update idle time for detected objects
        current_time = time.time()
        if category_details:  # If objects are detected
            if not self.email_sent:
                send_email(to_email, from_email, len(category_details), category_details=category_details)
                self.email_sent = True
        else:  # If no objects are detected
            self.email_sent = False

        self.display_fps(im0)
        cv2.imshow("YOLOv8 Detection", im0)
        if cv2.waitKey(5) & 0xFF == 27:
            break
    cap.release()
    out.release()  # Release the video writer
    cv2.destroyAllWindows()
    server.quit()

With these changes, your email notifications will now include the detected category names, their counts, and confidence scores. If you need further assistance, feel free to check out our Security Alarm System Project Guide. Happy coding! 😊

[Cheikh-Ahmedand]

Hey there Yolov Staff!

1- when I run yolov models for inference and prediction, the models detect all objects it sees through my laptop camera, even though the default object of Security Alarm System is 0, which is person. So, how can i make the model predict and sees persons only, not all objected it was trained on?

2- The model uses my laptop camera instead of My Webcam, how can I change that?

Who can help me, pls ?

Sincerely yours!

[glenn-jocher]

@Cheikh-Ahmedand to detect only persons, set the classes argument to [0] in your prediction call. For using your webcam instead of the laptop camera, change the capture_index to the appropriate device ID (usually 1 for external webcams). Here's a quick example:

results = model.predict(source=0, classes=[0])  # For laptop camera
results = model.predict(source=1, classes=[0])  # For external webcam

For more details, please refer to the Security Alarm System Project guide.

[Cheikh-Ahmedand]

Thanks! Glenn Jocher for your good response,

I run the codse on annconda jupiternotebook.

• Security alarm system code default class id is 0, which is person, unfortunately my camera detects all objects.
  please look below for the yolo code to let me know how to make the model detects only persons.

Sincerely Yours!

[Cheikh-Ahmedand]

from time import time

import cv2
import torch

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

class ObjectDetection:
def init(self, capture_index):
"""Initializes an ObjectDetection instance with a given camera index."""
self.capture_index = capture_index
self.email_sent = False

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

    # visual information
    self.annotator = None
    self.start_time = 0
    self.end_time = 0

    # device information
    self.device = "cuda" if torch.cuda.is_available() else "cpu"

def predict(self, im0):
    """Run prediction using a YOLO model for the input image `im0`."""
    results = self.model(im0)
    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()
    fps = 1 / 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
    for box, cls in zip(boxes, clss):
        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):
    """Run object detection on video frames from a camera stream, plotting and showing the results."""
    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)
    frame_count = 0
    while True:
        self.start_time = time()
        ret, im0 = cap.read()
        assert ret
        results = self.predict(im0)
        im0, class_ids = self.plot_bboxes(results, im0)

        if len(class_ids) > 0:  # Only send email If not sent before
            if not self.email_sent:
                send_email(to_email, from_email, len(class_ids))
                self.email_sent = True
        else:
            self.email_sent = False

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

so, this is the code

[glenn-jocher]

To ensure your model detects only persons, modify the predict method to include the classes argument set to [0]. Here's the updated method:

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

For using your external webcam, change the capture_index to 1:

detector = ObjectDetection(capture_index=1)
detector()

This should address your issues. If you need further assistance, please refer to the Security Alarm System Project guide.

[Cheikh-Ahmedand]

To: The respectful Staff of ULTRALYTICS

I have two questions

1 - Can I use multiple external cameras on one Laptop or one PC to detect objects using the below code:

detector = ObjectDetection(capture_index=1)
detector()

2- How to let yolov9 detect more than one classs, example: person,cat and vehicle, using the below code:
def predict(self, im0):
"""Run prediction using a YOLO model for the input image im0."""
results = self.model(im0, classes=[0])
return results

Any from the Staff or others would be appreciated!

[Cheikh-Ahmedand]

(glenn-jocher
4 minutes ago
@Cheikh-Ahmedand 1. Yes, you can use multiple cameras by initializing separate ObjectDetection instances with different capture_index values for each camera.)

Would you please, glenn-jocher give an example to illustrate more for us?

[Cheikh-Ahmedand]

Suppose you have 3 camera indexes.

Camera Index number: 1
1
Camera index number: 2
3
Camera index number: 3
5

So, shell I do the following for example:

detector = ObjectDetection(capture_index=[1,3,5])
detector()

[glenn-jocher]

To use multiple cameras, create separate ObjectDetection instances for each camera index. For example:

detector1 = ObjectDetection(capture_index=1)
detector2 = ObjectDetection(capture_index=3)
detector3 = ObjectDetection(capture_index=5)

detector1()
detector2()
detector3()

Each instance will handle a different camera.

[Cheikh-Ahmedand]

Hello there!

Thanks glenn-jocher for your nice response!

How can I know a capture_index number of each multiple cameras in windows Laptop or PC ??

Sincerely Yours!

[glenn-jocher]

To find the camera index numbers on a Windows PC, you can use the cv2.VideoCapture method in a loop to check which indices are available. Here's a simple example:

import cv2

for i in range(10):  # Check the first 10 indices
    cap = cv2.VideoCapture(i)
    if cap.isOpened():
        print(f"Camera index {i} is available.")
    cap.release()

This will help you identify which indices correspond to your connected cameras.

[Cheikh-Ahmedand]

To: Hello The Respectful Staff !

How can I know a capture_index number of a camera or multiple cameras in windows Laptop or PC ??

Any help either from the Respectful Staff or others would be so appreciated !!

[glenn-jocher]

To find the capture_index for a camera on a Windows laptop or PC, you can try different indices starting from 0 until the camera opens successfully using cv2.VideoCapture(index). This will help you identify the correct index for each camera connected to your system.

[Cheikh-Ahmedand]

Hello there the Respectful Staff!

detector1 = ObjectDetection(capture_index=0)
detector2 = ObjectDetection(capture_index=1)
detector1()
detector2()

I have my laptop camera and my Webcam in my Laptop.
When I run the above code, only detector1 camera works, detector2 doesn't work. I want them to turn on and work together, not only the detector1, rather detector2, detector3,...etc

Any help would be so appreciated!!

[glenn-jocher]

@Cheikh-Ahmedand to run multiple cameras simultaneously, ensure each ObjectDetection instance runs in a separate thread or process. This allows both cameras to operate concurrently without blocking each other. Consider using Python's threading or multiprocessing modules for implementation.

[Cheikh-Ahmedand]

Hello there!

Part of your good answer is
"Consider using Python's threading or multiprocessing modules for implementation."

Would you please provide us with how to implement python's threading with the code below:

detector1 = ObjectDetection(capture_index=1)
detector2 = ObjectDetection(capture_index=3)
detector1()
detector2()

Any help would be very appreciated!!

[glenn-jocher]

To run both cameras simultaneously, use Python's threading module. Here's a minimal example:

import threading

detector1 = ObjectDetection(capture_index=0)
detector2 = ObjectDetection(capture_index=1)

thread1 = threading.Thread(target=detector1)
thread2 = threading.Thread(target=detector2)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

This will allow both detectors to operate concurrently.

[Cheikh-Ahmedand]

Hey!
The respectful Staff!

I am regretted to inform you that the above code couldn't manage to let my Laptop camera and webcam work simultaneously. Do you think the problem is due to my Laptop itself.
My Laptop information is below:

General System Information

Windows Edition:

Windows 10 Pro

© 2020 Microsoft Corporation. All rights reserved.

System

Processor: Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz 2.40 GHz

Installed Memory (RAM): 8.00 GB (7.41 GB usable)

System Type: 64-bit operating system, x64 processor

Pen and Touch: Touch and pen input functionality is not available on this display.

From your view, how to fix the issue?

Any help would be so appreciated!!

[glenn-jocher]

@Cheikh-Ahmedand it seems like the issue might be related to how the cameras are being accessed. Ensure each camera is correctly indexed and try running them in separate threads to avoid conflicts. If the problem persists, it might be hardware-related.

[Cheikh-Ahmedand]

Hey, the Respectful Staff!

Does yolov Security alarm webcam System consumes laptop/pc RAM overtime?
If yes, what should I do in that case?

Does Yolo Security alarm webcam system exhausts laptop or PC's Computer Processor Unit (cpu) overtime?
If yes, what should I do in that case?

Any help either from the Respectful Staff or others would be so appreciated!!

[glenn-jocher]

@Cheikh-Ahmedand the YOLO11 Security Alarm System can consume RAM and CPU resources over time, especially during continuous video processing. To manage this, ensure your system meets the recommended hardware specifications and consider optimizing the model or reducing the frame rate. For more details, you can refer to our Security Alarm System guide.

[glenn-jocher]

@Rafapoeta it seems you're facing issues with email integration due to Google's updated policies. For sending alerts via Telegram, consider using the python-telegram-bot library to send messages or videos. For integrating an ultrasonic sensor, you'll need to read the sensor data and display it alongside your video feed. If you need further guidance, please refer to the Security Alarm System guide.

[Cheikh-Ahmedand]

Hey!

How to integrate Digital video recorder(Surveillance Camera) with my Laptop while using yolov8 instead of webcam?

Best regards!

[glenn-jocher]

To integrate a Digital Video Recorder with YOLOv8, use the video stream URL or device ID in place of the webcam in your code. For detailed guidance, refer to the Security Alarm System Project.

[Cheikh-Ahmedand]

Hello there, Glenn-jocher!

How to integrate Digital video recorder(Surveillance Camera) with my Laptop while using yolov8 instead of webcam?

Any help would be appreciated!

[glenn-jocher]

@Cheikh-Ahmedand to integrate a Digital Video Recorder with YOLOv8 on your laptop, use the OpenCV cv2.VideoCapture function with the DVR's stream URL or device index. For more details, please refer to our Security Alarm System guide.

[boukosho]

Hey there, the RespectfulStaff !

Do all anaconda pre-installed and installed liberaries need manual updates? Or they are automatically updated?

Any help would be appreciated!

Sincerely Yours!

[glenn-jocher]

@boukosho hello! Anaconda libraries typically require manual updates. You can use conda update --all to update them. Let me know if you have any other questions!

[boukosho]

Hello there, the Respectful Staff!

Thanks to yolov Security alarm system, how can I receive an IMAGE of the detected person in my Gmail?

Any help would be so appreciated!

Sincerely Yours!

[glenn-jocher]

@boukosho to receive an image of the detected person via Gmail, you can modify the email function to attach the image. For detailed guidance, please refer to the Security Alarm System documentation at https://docs.ultralytics.com/guides/security-alarm-system/.

[boukosho]

Thanks for your response!

Would you please give an example of how to modify the below email function to receive an IMAGE of detected person/object ?

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

def send_email(to_email, from_email, object_detected=1):
"""Sends an email notification indicating the number of objects detected; defaults to 1 object."""
message = MIMEMultipart()
message["From"] = from_email
message["To"] = to_email
message["Subject"] = "Security Alert"
# Add in the message body
message_body = f"ALERT - {object_detected} objects has been detected!!"

message.attach(MIMEText(message_body, "plain"))
server.sendmail(from_email, to_email, message.as_string())

[glenn-jocher]

@boukosho to attach an image to your email, you can use the MIMEImage class. Here's a minimal example:

from email.mime.image import MIMEImage

def send_email(to_email, from_email, image_path, 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"))

    with open(image_path, 'rb') as img_file:
        img = MIMEImage(img_file.read())
        message.attach(img)

    server.sendmail(from_email, to_email, message.as_string())

Ensure image_path points to the saved image file.

[boukosho]

Hey!

How can I modify the below email function of Security Alarm System code so as to attach the IMAGE of the detected person/object via Gmail?

Would you please give an example?

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

def send_email(to_email, from_email, object_detected=1):
"""Sends an email notification indicating the number of objects detected; defaults to 1 object."""
message = MIMEMultipart()
message["From"] = from_email
message["To"] = to_email
message["Subject"] = "Security Alert"
# Add in the message body
message_body = f"ALERT - {object_detected} objects has been detected!!"

message.attach(MIMEText(message_body, "plain"))
server.sendmail(from_email, to_email, message.as_string())

[glenn-jocher]

@boukosho to attach an image to your email, you can use the MIMEImage class. Here's a minimal example:

from email.mime.image import MIMEImage

def send_email(to_email, from_email, image_path, 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"))

    with open(image_path, 'rb') as img_file:
        img = MIMEImage(img_file.read())
        message.attach(img)

    server.sendmail(from_email, to_email, message.as_string())

For more details, please visit the Security Alarm System guide.

[Cheikh-Ahmedand]

Hey there, the Respectful Staff!

when I tried to send an IMAGE of the detected person via Security Aalarm System to my Gmail using the below code:

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage

def send_email(to_email, from_email, image_path, 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"))

with open(image_path, 'rb') as img_file:
    img = MIMEImage(img_file.read())
    message.attach(img)

server.sendmail(from_email, to_email, message.as_string())

an error Message was raised,
"ValueError: ( f"IPython won't let you open fd={file} by default " as it is likely to crash IPython. If you know what you are doing", "you can use builtins' open").

What should I do?

Best Regards!

[glenn-jocher]

@Cheikh-Ahmedand it seems the issue is related to IPython's file handling. Try using the built-in open function as suggested in the error message. For more details on setting up the Security Alarm System, please refer to our guide at https://docs.ultralytics.com/guides/security-alarm-system/.

[boukosho]

Hey!

Suppose you have yolov11 Security alarm system on your Laptop and your Webcam detected a stranger or thief inside your house, can the system sends an image of the detected thief or stranger with the text message to your Gmail? Or is it able to only send a text message?

If the security alarm system can send an image of the detected stranger or thief with the message, please let me know how( with example).

The below is yolov11 Security Alarm System code:

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

def send_email(to_email, from_email, object_detected=1):
"""Sends an email notification indicating the number of objects detected; defaults to 1 object."""
message = MIMEMultipart()
message["From"] = from_email
message["To"] = to_email
message["Subject"] = "Security Alert"
# Add in the message body
message_body = f"ALERT - {object_detected} objects has been detected!!"

message.attach(MIMEText(message_body, "plain"))
server.sendmail(from_email, to_email, message.as_string())

Any help would be too appreciated!!

[glenn-jocher]

To save detected images, you can use cv2.imwrite() within the detection loop. After plotting bounding boxes, save the frame with a unique filename, then use this path in your email function. If you need further assistance, please refer to the Security Alarm System guide.

[boukosho]

Hello there!

For saving detected images, you kindly suggest:

1. Using cv2.imwrite() within the detected loop.
2. Saving the frame with a unique file name, then using the this path in the email function.

Would you please give an example ?

The Code:

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
for box, cls in zip(boxes, clss):
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):
    """Run object detection on video frames from a camera stream, plotting and showing the results."""
    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)
    frame_count = 0
    while True:
        self.start_time = time()
        ret, im0 = cap.read()
        assert ret
        results = self.predict(im0)
        im0, class_ids = self.plot_bboxes(results, im0)

        if len(class_ids) > 0:  # Only send email If not sent before
            if not self.email_sent:
                send_email(to_email, from_email, len(class_ids))
                self.email_sent = True
        else:
            self.email_sent = False

        self.display_fps(im0)
        cv2.imshow("YOLO11 Detection", im0)
        frame_count += 1
        if cv2.waitKey(5) & 0xFF == 27:
            break
    cap.release()

Best Regards!

[glenn-jocher]

@boukosho to save detected images, you can modify the __call__ method to include cv2.imwrite(). Here's a minimal example:

if len(class_ids) > 0:
    image_path = f"detected_frame_{frame_count}.jpg"
    cv2.imwrite(image_path, im0)
    if not self.email_sent:
        send_email(to_email, from_email, image_path, len(class_ids))
        self.email_sent = True

This saves the frame with detections and uses the path in the email function.

[boukosho]

Hello there !

When I used the below code you kindly suggest for saving detected images, an error message pop-up:

UnboundLocalError: cannot access local variable 'image_path' where it is not associated with a value.

The original code is below :

if len(class_ids) > 0:
image_path = f"detected_frame_{frame_count}.jpg"
cv2.imwrite(image_path, im0)
if not self.email_sent:
send_email(to_email, from_email, i
mage_path, len(class_ids))
self.email_sent = True

Any help, please?

Sincerely Yours!

[glenn-jocher]

It seems the image_path variable is not defined in the scope where you're trying to access it. Ensure image_path is set before it's used in the send_email function. If the issue persists, please verify the logic flow in your code.

[boukosho]

Hello there!
can I link Security alarm system of yolo of DVR or NVR cameras( camera of surveillance), using the below code:

detector = ObjectDetection(capture_index=0)
detector()

if yes, how ? please give an example!

[glenn-jocher]

@boukosho to integrate YOLO with DVR or NVR cameras, you need to ensure the camera stream is accessible via a compatible capture index or URL. The provided code initializes detection on a local camera (index 0). For DVR/NVR, replace capture_index=0 with the appropriate stream URL or index. For more details, refer to our security alarm system guide at https://docs.ultralytics.com/guides/security-alarm-system/.

[boukosho]

Hey!

Is there a code or way to detect a compatible capture index or URL of a DVR/NVR camera stream ?

Would you please give an example ?

[boukosho]

Hey

You kindly suggest using OpenCV's cv2.VideoCapture() to test different indices or URLs.
Is there a code for that, with example, please?

Best Regards!!

[Cheikh-Ahmedand]

Hey

You kindly suggest using OpenCV's cv2.VideoCapture() to test different indices or URLs.
Is there a code for that, with example, please?

Best Regards!!

[glenn-jocher]

To detect a compatible capture index or URL for a DVR/NVR camera stream using OpenCV, you can iterate through potential indices or URLs and check if a stream opens successfully. Here's a minimal example:

import cv2

def find_valid_stream():
    for index in range(10):  # Test indices 0 to 9
        cap = cv2.VideoCapture(index)
        if cap.isOpened():
            print(f"Valid capture index found: {index}")
            cap.release()
            break
    else:
        print("No valid capture index found.")

find_valid_stream()

This script attempts to open video streams for indices 0 to 9 and prints the first valid index it finds. Adjust the range or add URLs as needed for your setup.

[Cheikh-Ahmedand]

hello there!

import cv2

def find_valid_stream():
for index in range(10): # Test indices 0 to 9
cap = cv2.VideoCapture(index)
if cap.isOpened():
print(f"Valid capture index found: {index}")
cap.release()
break
else:
print("No valid capture index found.")

find_valid_stream()

I used the above code , as you suggested, to detect my home 's DVR/NV R Security camera indices . Unfortunately the code managed to only detect 0 for my laptop camera index and 1 for my webcam, so no DVR/NVR camera index could be reached or shown up.

What do you suggest for me, instead?

Thanks so much!!

[glenn-jocher]

@Cheikh-Ahmedand if the code only detects local cameras, you might need to use the RTSP URL format for your DVR/NVR streams. Check your DVR/NVR documentation for the correct URL format and credentials needed to access the stream.

[boukosho]

hey!

Yesterday, my friend disclosed his camera surveillance info to me, so as my yolov11 Security Alarm System can detect it.

He showed me the two below info:

His camera IP address : 192xxxxxxxxxx

His Camera code: m53xxxxxxxxx

But none of the above have been detected by the function below:

detector = ObjectDetection(capture_index=0)
detector()
I'm not sure if the above IP address and code are the correct format of DVR/NVR camera stream index of my friend's camera, or whether or not his DVR/NVR camera has another index code that yolov11 can work with?

So would you please show us an example of the normal format of a DVR/NVR camera stream index so as to help us find a correct index of any DVR/NVR ?

Best Regards!!

[boukosho]

Hey!

Does house/home light, darkness and webcam quality can affect yolo 11 predictions?

I asked the question because I noticed a False positive of person (0) while using yolo 11 model. So I don't know whether or not one of the above mentioned conditions caused the False positive prediction?

Best Regards!

[glenn-jocher]

Yes, lighting conditions, darkness, and webcam quality can impact YOLO11 predictions and may contribute to false positives. Ensure optimal lighting, a high-quality camera, and fine-tune your model with diverse data to improve detection accuracy. For further tuning guidance, consult this guide.

[boukosho]

So, how to make yolo11 predict precisely? How to prevent it from predicting false positive of persons[0]?

[boukosho]

Hey!

You write:

" fine-tune your model with diverse data to improve detection accuracy"
I want yolo11 to only predict persons [0] , this means that you you recommend to retrain the model on new persons images for better accuracy? If yes, how ? With example, please!

[glenn-jocher]

@boukosho to have YOLO11 predict only "persons [0]" accurately, you should fine-tune or retrain the model on a custom dataset with images exclusively annotated for the "person" class. Here's an example:

from ultralytics import YOLO

# Initialize the model
model = YOLO("yolo11n.pt")

# Train the model on a custom dataset
model.train(data="data.yaml", epochs=50, imgsz=640)

Make sure your data.yaml is configured with a single class (person) and that the dataset includes diverse person images to reduce false positives. Refer to the training guide for detailed instructions.