Enhancing computer vision applications with visualizations

Step 1: Setting up the environment

Once you’ve chosen your preferred environment, the next step is to set it up for running predictions and visualizing the results. You can use any of the environments mentioned above, depending on what you're most comfortable with.

If you're working in Google Colab, keep in mind that it uses a CPU by default, which can slow down performance. To speed things up, switch to a GPU by going to the "Runtime" menu, selecting "Change runtime type," and setting the hardware accelerator to GPU (ideally a T4).

To get your environment ready, you’ll need to install the Ultralytics Python package using the command mentioned below. In notebook-based tools like Colab or Jupyter, be sure to add an exclamation mark (!) before the command.

pip install ultralytics

‍

Step 2: Downloading a video file

Next, we’ll need a video to work with. You can easily download one from a free stock site like Pexels. Make sure to choose a video that includes objects YOLO11 can detect. Since the model is pretrained on the COCO dataset, it can recognize common objects such as people, cars, and bicycles. 

For this tutorial, we’ll use a video of baggage handling in a busy airport terminal. You can use the same video or choose a different one that fits your project.

‍

Step 3: Importing packages

Next, we can import the necessary libraries and load the input video.

We’ll start by importing OpenCV (cv2), which is a widely used library for working with images and video in computer vision. We'll also import the Ultralytics library, which helps us run object detection and generate analytics from the video.

Then, we’ll try to open the video file by specifying its path. Make sure to replace "path/to/video.mp4" with the actual location of your downloaded video file. 

Also, the code snippet below includes a simple check to make sure the video loads correctly. If the path is wrong or the file is corrupted, the program will stop and show an error message: "Error reading video file."

import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error reading video file"

‍

Step 4: Preparing the video writer

Then, we’ll set up a video writer to save the output. When we run the analytics, this part of the code will create a new video file that records the updated graphs generated from each frame of the original video.

In the code snippet below, we first extract key properties from the input video - its width, height, and frames per second (fps). These values are taken directly from the video and converted to integers to ensure they’re in the correct format for writing the output.

Next, we use the cv2.VideoWriter function to create a new video file, named "analytics_output.avi" (you can rename it as needed). The video is saved using the MJPG format, which is a common video compression method. The output resolution is set to 1280×720 pixels, regardless of the original video's size.

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
out = cv2.VideoWriter(
    "analytics_output.avi",
    cv2.VideoWriter_fourcc(*"MJPG"),
    fps,
    (1280, 720), 
)

‍

Step 5: Setting up the Ultralytics Analytics solution

Now, we’ll set up the Ultralytics Analytics solution to generate graphs from the video. You can choose how the data is displayed, such as a line, pie, area, or bar chart, and which YOLO model to use. In this example, we’ll use the lightweight "yolo11n.pt" model and show the results as a area graph.

analytics = solutions.Analytics(
    show=True, 
    analytics_type="area", 
    model="yolo11n.pt",   
)

‍

Step 6: Processing the input video

The final part of the code runs a loop that processes the video one frame at a time. Each frame is passed to the analytics tool, which updates the graph in real time. The updated graph is then written to the output video. If a frame can’t be read, the loop stops. After all frames are processed, the video is saved and any open windows are closed.

frame_count = 0
while cap.isOpened():
    success, im0 = cap.read()
    if success:
        frame_count += 1
        results = analytics(im0, frame_count) 

        out.write(results.plot_im) 
    else:
        break
cap.release()
out.release()
cv2.destroyAllWindows() 

‍

Step 7: Putting it all together

Finally, let’s put everything together. With just a few extra lines of code, we can generate two output videos: one showing the YOLO11 object detection results with bounding boxes and labels, and another showing the real-time analytics graphs.

To do this, we’ll set up two VideoWriter instances - one for saving the prediction video and another for the analytics. This version of the code includes both object tracking and graph generation, so you can see detection results alongside the visual insights.

Here’s is the comprehensive code along with examples of both the prediction and analytics outputs.

import cv2
from ultralytics import YOLO, solutions

# Load model and video
model = YOLO('yolo11n.pt')
cap = cv2.VideoCapture('path/to/video.mp4')
assert cap.isOpened(), "Error opening video"

# Get properties
w, h = int(cap.get(3)), int(cap.get(4))
fps = cap.get(5)
analytics_res = (1280, 720)

# Writers for prediction and analytics videos
out_pred = cv2.VideoWriter('output_predictions.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, (w, h))
out_ana = cv2.VideoWriter('output_analytics.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, analytics_res)

# Analytics setup
analytics = solutions.Analytics(show=True, analytics_type="area", model='yolo11n.pt')

# Process frames
frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    frame_count += 1
    pred_frame = model.track(frame, persist=True)[0].plot()
    out_pred.write(pred_frame)

    resized = cv2.resize(pred_frame, analytics_res)
    out_ana.write(analytics(resized, frame_count).plot_im)

cap.release(), out_pred.release(), out_ana.release(), cv2.destroyAllWindows()

‍

When the code above runs successfully, it will generate two output videos. The file “output_predictions.avi” will show the object detection results with bounding boxes and labels, while “output_analytics.avi” will display the real-time analytics graphs based on the detections.

‍

Here is a frame from the analytics output based on the predictions. Using the area chart, we can gain insights like fluctuations in suitcase counts over time, such as a spike around frame 268, indicating suitcase movement or activity in that part of the video.

‍