Skip to content

Stabilizer Class Usage Examples:

Stabilizer Class now includes a new zero-latency Kalman filter backend (StabilizerMode.KALMAN) in v0.3.6 for real-time stabilization of live streams. It stabilizes every frame immediately with no frame buffering. See the Kalman (Zero-Latency) tabs in the examples below, and its parameters ➶.

 

The stabilizer may not perform well against High-frequency jitter in video. Use at your own risk!

The stabilizer might be slower 🐌 for High-Quality/Resolution videos-frames.

It is advised to enable logging on the first run for easily identifying any runtime errors.

After going through Stabilizer Class Usage Examples, Checkout more of its advanced configurations here ➶

 

 

Bare-Minimum Usage with VideoCapture Gears

Following is the bare-minimum code you need to get started with Stabilizer Class and various VideoCapture Gears:

You can use any VideoCapture Gear instead of CamGear in the similar manner, as shown in this usage example.

Performance Improvement in v0.3.5

Starting from v0.3.5, the Stabilizer class has been refactored to bound the Average Sliding-Window (ASW) memory to O(smoothing_radius) and real-time streaming is now possible without memory issues.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# import required libraries
from vidgear.gears.stabilizer import Stabilizer
from vidgear.gears import CamGear
import cv2

# To open live video stream on webcam at first index(i.e. 0) device
stream = CamGear(source=0).start()

# initiate stabilizer object with default parameters
stab = Stabilizer()

# loop over
while True:

    # read frames from stream
    frame = stream.read()

    # check for frame if Nonetype
    if frame is None:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # wait for stabilizer which still be initializing
    if stabilized_frame is None:
        continue

    # {do something with the stabilized frame here}

    # Show output window
    cv2.imshow("Output Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.stop()
New in v0.3.6

The Kalman backend (StabilizerMode.KALMAN) was added in v0.3.6.

Kalman backend never buffers frames, so stabilize() returns a stabilized frame on every call. No warm-up None check is needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# import required libraries
from vidgear.gears.stabilizer import Stabilizer, StabilizerMode
from vidgear.gears import CamGear
import cv2

# To open live video stream on webcam at first index(i.e. 0) device
stream = CamGear(source=0).start()

# initiate zero-latency Kalman stabilizer object with default parameters
stab = Stabilizer(mode=StabilizerMode.KALMAN)

# loop over
while True:

    # read frames from stream
    frame = stream.read()

    # check for frame if Nonetype
    if frame is None:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # {do something with the stabilized frame here}

    # Show output window
    cv2.imshow("Output Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.stop()

 

Bare-Minimum Usage with OpenCV

The VidGear's stabilizer class can also work standalone easily with any Computer Vision library such as OpenCV itself. Following is the bare-minimum code you need to get started with Stabilizer Class and OpenCV:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# import required libraries
from vidgear.gears.stabilizer import Stabilizer
import cv2

# Open suitable video stream, such as webcam on first index(i.e. 0)
stream = cv2.VideoCapture(0)

# initiate stabilizer object with default parameters
stab = Stabilizer()

# loop over
while True:

    # read frames from stream
    (grabbed, frame) = stream.read()

    # check for frame if not grabbed
    if not grabbed:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # wait for stabilizer which still be initializing
    if stabilized_frame is None:
        continue

    # {do something with the stabilized frame here}

    # Show output window
    cv2.imshow("Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.release()
New in v0.3.6

The Kalman backend (StabilizerMode.KALMAN) was added in v0.3.6.

Kalman backend never buffers frames, so stabilize() returns a stabilized frame on every call. No warm-up None check is needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# import required libraries
from vidgear.gears.stabilizer import Stabilizer, StabilizerMode
import cv2

# Open suitable video stream, such as webcam on first index(i.e. 0)
stream = cv2.VideoCapture(0)

# initiate zero-latency Kalman stabilizer object with default parameters
stab = Stabilizer(mode=StabilizerMode.KALMAN)

# loop over
while True:

    # read frames from stream
    (grabbed, frame) = stream.read()

    # check for frame if not grabbed
    if not grabbed:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # {do something with the stabilized frame here}

    # Show output window
    cv2.imshow("Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.release()

 

Using Stabilizer with Variable Parameters

Stabilizer class provide certain parameters which you can use to tweak its internal properties. The complete usage example is as follows:

New in v0.3.5

The mode parameter and the StabilizerMode enum were added in v0.3.5. Existing code that does not pass mode keeps working - defaults to StabilizerMode.ASW.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# import required libraries
from vidgear.gears.stabilizer import Stabilizer, StabilizerMode
from vidgear.gears import CamGear
import cv2

# To open live video stream on webcam at first index(i.e. 0) device
stream = CamGear(source=0).start()

# initiate stabilizer object with defined parameters
stab = Stabilizer(
    mode=StabilizerMode.ASW,
    smoothing_radius=30,
    crop_n_zoom=True,
    border_size=5,
    logging=True,
)

# loop over
while True:

    # read frames from stream
    frame = stream.read()

    # check for frame if Nonetype
    if frame is None:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # wait for stabilizer which still be initializing
    if stabilized_frame is None:
        continue

    # {do something with the stabilized frame here}

    # Show output window
    cv2.imshow("Output Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.stop()
New in v0.3.6

The Kalman backend (StabilizerMode.KALMAN) was added in v0.3.6.

Kalman backend never buffers frames, so stabilize() returns a stabilized frame on every call. No warm-up None check is needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# import required libraries
from vidgear.gears.stabilizer import Stabilizer, StabilizerMode
from vidgear.gears import CamGear
import cv2

# To open live video stream on webcam at first index(i.e. 0) device
stream = CamGear(source=0).start()

# initiate stabilizer object with defined parameters
stab = Stabilizer(
    mode=StabilizerMode.KALMAN,
    process_noise=4e-3,
    measurement_noise=0.25,
    crop_n_zoom=True,
    border_size=5,
    logging=True,
)

# loop over
while True:

    # read frames from stream
    frame = stream.read()

    # check for frame if Nonetype
    if frame is None:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # {do something with the stabilized frame here}

    # Show output window
    cv2.imshow("Output Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.stop()

 

Using Stabilizer with WriteGear

VideoGear's stabilizer can be used in conjunction with WriteGear API directly without any compatibility issues. The complete usage example is as follows:

You can also add live audio input to WriteGear pipeline. See this bonus example ➶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# import required libraries
from vidgear.gears.stabilizer import Stabilizer
from vidgear.gears import CamGear
from vidgear.gears import WriteGear
import cv2

# Open suitable video stream
stream = CamGear(source="unstabilized_stream.mp4").start()

# initiate stabilizer object with default parameters
stab = Stabilizer()

# Define writer with default parameters and suitable output filename for e.g. `Output.mp4`
writer = WriteGear(output="Output.mp4")

# loop over
while True:

    # read frames from stream
    frame = stream.read()

    # check for frame if not None-type
    if frame is None:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # wait for stabilizer which still be initializing
    if stabilized_frame is None:
        continue

    # {do something with the stabilized frame here}

    # write stabilized frame to writer
    writer.write(stabilized_frame)

    # Show output window
    cv2.imshow("Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.stop()

# safely close writer
writer.close()
New in v0.3.6

The Kalman backend (StabilizerMode.KALMAN) was added in v0.3.6.

Kalman backend never buffers frames, so stabilize() returns a stabilized frame on every call. No warm-up None check is needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# import required libraries
from vidgear.gears.stabilizer import Stabilizer, StabilizerMode
from vidgear.gears import CamGear
from vidgear.gears import WriteGear
import cv2

# Open suitable video stream
stream = CamGear(source="unstabilized_stream.mp4").start()

# initiate zero-latency Kalman stabilizer object with default parameters
stab = Stabilizer(mode=StabilizerMode.KALMAN)

# Define writer with default parameters and suitable output filename for e.g. `Output.mp4`
writer = WriteGear(output="Output.mp4")

# loop over
while True:

    # read frames from stream
    frame = stream.read()

    # check for frame if not None-type
    if frame is None:
        break

    # send current frame to stabilizer for processing
    stabilized_frame = stab.stabilize(frame)

    # {do something with the stabilized frame here}

    # write stabilized frame to writer
    writer.write(stabilized_frame)

    # Show output window
    cv2.imshow("Stabilized Frame", stabilized_frame)

    # check for 'q' key if pressed
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

# close output window
cv2.destroyAllWindows()

# clear stabilizer resources
stab.clean()

# safely close video stream
stream.stop()

# safely close writer
writer.close()

 

Using VideoGear with Stabilizer backend

VideoGear API provides a special internal wrapper around Stabilizer class that enables easy stabilization for various video-streams (real-time or not) with minimum effort and writing way fewer lines of code.

The complete usage example can be found here ➶