Python OpenCV cv2.calcOpticalFlowPyrLK() Guide

Optical flow is a key concept in computer vision. It tracks the movement of objects between consecutive frames in a video. OpenCV provides the cv2.calcOpticalFlowPyrLK() function for this purpose.

This article will guide you through using cv2.calcOpticalFlowPyrLK(). You will learn how to implement it in Python with examples. Let's dive in!

What is cv2.calcOpticalFlowPyrLK()?

The cv2.calcOpticalFlowPyrLK() function is used to track feature points in a video. It uses the Lucas-Kanade method with pyramids. This method is efficient and works well for small motions.

It takes two consecutive frames and a set of points to track. It returns the new positions of these points in the next frame. This is useful for motion tracking and object detection.

How to Use cv2.calcOpticalFlowPyrLK()

To use cv2.calcOpticalFlowPyrLK(), you need two consecutive frames. You also need a set of points to track. These points are usually detected using cv2.goodFeaturesToTrack().

Here is a step-by-step guide:

1. Capture video frames using cv2.VideoCapture().
2. Detect feature points in the first frame.
3. Pass these points and the next frame to cv2.calcOpticalFlowPyrLK().
4. Draw the tracked points on the frames.

Example Code

Below is an example of how to use cv2.calcOpticalFlowPyrLK() in Python:

import cv2
import numpy as np

# Initialize video capture
cap = cv2.VideoCapture('video.mp4')

# Parameters for ShiTomasi corner detection
feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7)

# Parameters for Lucas-Kanade optical flow
lk_params = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))

# Read the first frame
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)

# Detect feature points
p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)

# Create a mask image for drawing purposes
mask = np.zeros_like(old_frame)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Calculate optical flow
    p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)

    # Select good points
    good_new = p1[st == 1]
    good_old = p0[st == 1]

    # Draw the tracks
    for i, (new, old) in enumerate(zip(good_new, good_old)):
        a, b = new.ravel()
        c, d = old.ravel()
        mask = cv2.line(mask, (int(a), int(b)), (int(c), int(d)), (0, 255, 0), 2)
        frame = cv2.circle(frame, (int(a), int(b)), 5, (0, 0, 255), -1)
    img = cv2.add(frame, mask)

    # Display the result
    cv2.imshow('Optical Flow', img)
    if cv2.waitKey(30) & 0xFF == 27:
        break

    # Update the previous frame and points
    old_gray = frame_gray.copy()
    p0 = good_new.reshape(-1, 1, 2)

cv2.destroyAllWindows()
cap.release()

Explanation of the Code

The code captures video frames using cv2.VideoCapture(). It then detects feature points in the first frame using cv2.goodFeaturesToTrack().

These points are passed to cv2.calcOpticalFlowPyrLK() along with the next frame. The function returns the new positions of the points. The code then draws the tracked points and lines on the frame.

Finally, the result is displayed using cv2.imshow(). The process repeats for each frame in the video.

Output

The output is a video with tracked points and lines. These represent the movement of objects between frames. The result is displayed in a window titled "Optical Flow".

# Output will be a video window showing optical flow tracking.

Conclusion

Using cv2.calcOpticalFlowPyrLK() is a powerful way to track motion in videos. It is efficient and works well for small movements. This guide has shown you how to implement it in Python.

For more on video processing, check out our guides on cv2.VideoCapture() and cv2.VideoWriter().

Start experimenting with optical flow today. It opens up many possibilities in computer vision!