Python OpenCV Cheatsheet

The Python OpenCV cheatsheet provides the basic concepts for all its fundamental topics. OpenCV is an open-source computer vision library that allows computer programmers to process images or videos. By learning this cheat sheet, one can prepare for the interviews and exams. Go through this cheat sheet and learn the OpenCV.

Table of Content

1. Basics and Installation

OpenCV is the computer vision library that processes the images and video.

i. Installing OpenCV

To install OpenCV on your system, use the following command −

 pip install opencv-python

ii. Importing OpenCV

To import the OpenCV library, use the following line of code −

 import cv2

iii. Reading and Displaying an Image

To read and display the images from the file, below are a few lines of code to understand its usage −

 import cv2 # Read the image image = cv2.imread("image.jpg") # Show the image cv2.imshow("Image", image) # Wait for a key press cv2.waitKey(0) # Close the window cv2.destroyAllWindows()

iv. Writing and Saving an Image

In OpenCV, to write and save an image from a file, follow the below lines of code −

 import cv2 # Read the image image = cv2.imread("example_image.jpg") # Save the image cv2.imwrite("example_output.jpg", image)

v. Reading and Displaying a Video

In OpenCV, we can read a video file and play it frame by frame.

 import cv2 # Open video file cap = cv2.VideoCapture("video.mp4") while cap.isOpened(): ret, frame = cap.read() if not ret: break cv2.imshow("Video", frame) if cv2.waitKey(25) & 0xFF == ord("q"): break cap.release() cv2.destroyAllWindows()

vi. Capturing Video from Webcam

To capture video using a webcam and display it live, use the following steps of code −

 import cv2 # Open the webcam cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() if not ret: break cv2.imshow("Webcam", frame) if cv2.waitKey(1) & 0xFF == ord("q"): break cap.release() cv2.destroyAllWindows()

2. Image Processing and Manipulation

Image processing is the technique to improve the quality of an image or extract information.

i. Resizing an Image

We can resize an image to a specific size by specifying the width and height. The cv2.resize() function is used to perform this operation.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Resize the image to a specific size (width, height) resized_image = cv2.resize(image, (400, 300)) # Save the resized image cv2.imwrite('resized_image.jpg', resized_image)

ii. Converting Color Spaces

The color space define the conversion of an image from one color space to another. For references, you can convert a BGR image to grayscale using the cv2.cvtColor() function.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Convert the image to grayscale gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Save the grayscale image cv2.imwrite('gray_image.jpg', gray_image)

iii. Image Thresholding

Image thresholding is the process of segmenting an image into two regions based on pixel density.

 import cv2 # Load the image in grayscale image = cv2.imread('example_image.jpg', cv2.IMREAD_GRAYSCALE) # Apply simple thresholding _, thresh_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY) # Save the thresholded image cv2.imwrite('threshold_image.jpg', thresh_image) # Apply adaptive thresholding adaptive_thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2) # Save the adaptive threshold image cv2.imwrite('adaptive_thresh_image.jpg', adaptive_thresh)

iv. Blurring and Smoothing

To blur and smooth reduction noise from an image, use the function "cv2.GaussianBlur()" for the Gaussian filter and cv2.medianBlur() for the median filter.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Apply Gaussian Blur blurred_image = cv2.GaussianBlur(image, (5, 5), 0) # Save the blurred image cv2.imwrite('blurred_image.jpg', blurred_image) # Apply Median Blur median_blurred_image = cv2.medianBlur(image, 5) # Save the median blurred image cv2.imwrite('median_blurred_image.jpg', median_blurred_image)

v. Edge Detection

Edge detection is used to find boundaries from an image. The cv2.Canny() function is very common to use for detecting edges based on intensity gradients.

 import cv2 # Load the image in grayscale image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE) # Apply Canny edge detection edges = cv2.Canny(image, 100, 200) # Save the edge-detected image cv2.imwrite('edges_image.jpg', edges)

vi. Bitwise Operations

In OpenCV, we can perform the bitwise operations such as AND, OR, and NOT that are used for masking and image combination. These operations change the individual pixels based on the binary values.

 import cv2 import numpy as np # Load two images image1 = cv2.imread('image1.jpg') image2 = cv2.imread('image2.jpg') # Bitwise AND operation and_image = cv2.bitwise_and(image1, image2) # Bitwise OR operation or_image = cv2.bitwise_or(image1, image2) # Bitwise NOT operation not_image = cv2.bitwise_not(image1) # Save the result images cv2.imwrite('and_image.jpg', and_image) cv2.imwrite('or_image.jpg', or_image) cv2.imwrite('not_image.jpg', not_image)

vii. Image Histograms

In OpenCV, a histogram visualizes the distribution of the pixel intensities from an image. So, cv2.calcHist() calculates the histogram, and cv2.equalizeHist() enhances image contrast by adjusting the histogram.

 import cv2 # Load the image in grayscale image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE) # Calculate the histogram of the image hist = cv2.calcHist([image], [0], None, [256], [0, 256]) # Equalize the histogram to improve the contrast equalized_image = cv2.equalizeHist(image) # Save the equalized image cv2.imwrite('equalized_image.jpg', equalized_image)

3. Geometric Transformations

In OpenCV, geometric transformation is the process of modifying the spatial properties of an image, such as position, size, or orientation.

i. Image Rotation

You can rotate an image from the center specified angle. Here, the cv2.getRotationMatrix2D() function creates a rotation matrix, while cv2.warpAffine() applies the rotation transformation.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Get the image dimensions height, width = image.shape[:2] # Get the rotation matrix center = (width / 2, height / 2) angle = 45 scale = 1.0 rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale) # Apply the rotation to the image rotated_image = cv2.warpAffine(image, rotation_matrix, (width, height)) # Save the rotated image cv2.imwrite('rotated_image.jpg', rotated_image)

ii. Image Translation

Translate an image by shifting it along the x and y axes. The cv2.warpAffine() function can be used to apply a translation matrix to move the image.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Get the image dimensions height, width = image.shape[:2] # Define the translation matrix translation_matrix = np.float32([[1, 0, 100], [0, 1, 50]]) # Apply the translation of the image translated_image = cv2.warpAffine(image, translation_matrix, (width, height)) # Save the translated image cv2.imwrite('translated_image.jpg', translated_image)

iii. Image Scaling

An image scaling means resizing the images by a factor or specifying size. Use cv2.resize() to perform scaling.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Scale the image by a factor of 0.5 (50%) scaled_image = cv2.resize(image, None, fx=0.5, fy=0.5) # Save the scaled image cv2.imwrite('scaled_image.jpg', scaled_image)

iv. Perspective Transformation

Theperspective transformation is used to change the view of an image.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Define points for perspective transformation # Four points from the original image and their corresponding points in the transformed image pts1 = np.float32([[50, 50], [200, 50], [50, 200], [200, 200]]) pts2 = np.float32([[10, 100], [210, 50], [50, 250], [220, 210]]) # Get the perspective transformation matrix matrix = cv2.getPerspectiveTransform(pts1, pts2) # Apply the perspective transformation perspective_image = cv2.warpPerspective(image, matrix, (image.shape[1], image.shape[0])) # Save the transformed image cv2.imwrite('perspective_image.jpg', perspective_image)

4. Drawing and Annotations

The drawing and annotations define the process of adding information to an image.

i. Drawing Shapes

While drawing basic shapes on an image, such as lines, circles, rectangles, and polygons. Use the functions like cv2.line(), cv2.circle(), cv2.rectangle(), and cv2.polylines().

 import cv2 import numpy as np # Create a blank white image image = np.ones((500, 500, 3), dtype=np.uint8) * 255 # Drawing a line cv2.line(image, (50, 50), (450, 450), (0, 0, 255), 5) # Drawing a circle cv2.circle(image, (250, 250), 100, (0, 255, 0), -1) # Drawing a rectangle cv2.rectangle(image, (100, 100), (400, 400), (255, 0, 0), 3) # Drawing a polygon (triangle) pts = np.array([[250, 50], [100, 400], [400, 400]], np.int32) pts = pts.reshape((-1, 1, 2)) cv2.polylines(image, [pts], isClosed=True, color=(255, 255, 0), thickness=4) # Save the image cv2.imwrite('shapes_image.jpg', image)

ii. Adding Text to an Image

To add the text from an image, use the function cv2.putText(). Also, you can specify the text font, size, color, and position of the text on the image.

 import cv2 # Create a blank white image image = np.ones((500, 500, 3), dtype=np.uint8) * 255 # Add text to the image font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(image, 'Hello, OpenCV!', (100, 250), font, 1, (0, 0, 0), 2, cv2.LINE_AA) # Save the image with text cv2.imwrite('text_image.jpg', image)

5. Contours and Object Detection

The contour is a simple curve that joins all the continuous points.

i. Finding Contours

In OpenCV, contours are useful for detecting and analyzing objects in an image.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Convert the image to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Apply thresholding to get binary image _, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) # Find contours contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # Draw the contours on the image cv2.drawContours(image, contours, -1, (0, 255, 0), 3) # Green color, thickness = 3 # Save the image with contours cv2.imwrite('contours_image.jpg', image)

ii. Convex Hull and Contour Approximation

The convex hull is the smallest convex polygon that is surrounded by all the points of the contour. You can use the function like cv2.approxPolyDP() is used for approximating a polygonal curve.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Convert the image to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Apply thresholding to get binary image _, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) # Find contours contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # Get the convex hull for the first contour hull = cv2.convexHull(contours[0]) # Approximate the contour to a polygon epsilon = 0.02 * cv2.arcLength(contours[0], True) approx = cv2.approxPolyDP(contours[0], epsilon, True) # Draw the convex hull and the approximated polygon cv2.drawContours(image, [hull], 0, (255, 0, 0), 3) # Blue color for hull cv2.drawContours(image, [approx], 0, (0, 255, 0), 3) # Green color for approximation # Save the image cv2.imwrite('hull_approx_image.jpg', image)

iii. Hough Transform for Line and Circle Detection

The Hough transform is used for detecting lines and circles in an image. The cv2.HoughLines() is used for line detection, and cv2.HoughCircles() is used for circle detection.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detecting lines using Hough Line Transform edges = cv2.Canny(gray, 50, 150, apertureSize=3) lines = cv2.HoughLines(edges, 1, np.pi / 180, 100) for line in lines: rho, theta = line[0] x1 = int(rho * np.cos(theta) + 1000 * (-np.sin(theta))) y1 = int(rho * np.sin(theta) + 1000 * (np.cos(theta))) x2 = int(rho * np.cos(theta) - 1000 * (-np.sin(theta))) y2 = int(rho * np.sin(theta) - 1000 * (np.cos(theta))) cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2) # Red color for lines # Detecting circles using Hough Circle Transform circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1.2, minDist=30, param1=50, param2=30, minRadius=10, maxRadius=100) if circles is not None: circles = np.round(circles[0, :]).astype("int") for (x, y, r) in circles: # Green color for circles cv2.circle(image, (x, y), r, (0, 255, 0), 4) # Save the image with detected lines and circles cv2.imwrite('hough_transform_image.jpg', image)

iv. Object Detection with Haar Cascades

In OpenCV haar cascades are used for object detection, such as detecting faces or other objects in an image.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Load the pre-trained Haar Cascade Classifier for face detection face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect faces in the image faces = face_cascade.detectMultiScale(gray, 1.3, 5) # Draw rectangles around detected faces for (x, y, w, h) in faces: cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2) # Blue color for rectangle # Save the image with detected faces cv2.imwrite('haar_cascade_faces.jpg', image)

v. Face Detection using OpenCV

Face detection can be done using the pre-trained Haar cascades or DNN-based models in OpenCV. It is often used for real-time face recognition.

 import cv2 # Load the image image = cv2.imread('image.jpg') # Load the pre-trained Haar Cascade Classifier for face detection face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect faces in the image faces = face_cascade.detectMultiScale(gray, 1.1, 4) # Draw rectangles around detected faces for (x, y, w, h) in faces: # Blue color for rectangle cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2) # Save the image with detected faces cv2.imwrite('face_detection.jpg', image)

6. Feature Detection and Tracking

Feature detection and tracking are the processes to identify and follow objects in images or videos.

i. Corner Detection

In OpenCV, corner detection is used to identify the image where there is a significant change in the image gradient.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect corners using goodFeaturesToTrack corners = cv2.goodFeaturesToTrack(gray, 100, 0.01, 10) # Convert corners to integer corners = np.int0(corners) # Draw corners on the image for corner in corners: x, y = corner.ravel() cv2.circle(image, (x, y), 3, 255, -1) # Save the image with corners cv2.imwrite('corners_image.jpg', image)

ii. Feature Detection (ORB, SIFT, SURF)

Feature detection methods such as ORB, SIFT, and SURF are used to detect key points and features in an image.

 import cv2 # Loading image image = cv2.imread('image.jpg') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Initialize ORB detector orb = cv2.ORB_create() # Detect keypoints and descriptors using ORB keypoints, descriptors = orb.detectAndCompute(gray, None) # Draw keypoints on the image image_with_keypoints = cv2.drawKeypoints(image, keypoints, None, (0, 255, 0), flags=cv2.DrawMatchesFlags_DRAW_RICH_KEYPOINTS) # Save the image with keypoints cv2.imwrite('orb_keypoints.jpg', image_with_keypoints)

iii. Optical Flow

Optical flow tracks object motion between two frames using movement patterns.

 import cv2 import numpy as np # Load the image sequence (two consecutive frames) frame1 = cv2.imread('frame1.jpg') frame2 = cv2.imread('frame2.jpg') # Convert to grayscale gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY) # Calculate optical flow flow = cv2.calcOpticalFlowFarneback(gray1, gray2, None, 0.5, 3, 15, 3, 5, 1.2, 0) # Visualize the optical flow hsv = np.zeros_like(frame1) hsv[..., 1] = 255 mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1]) hsv[..., 0] = ang * 180 / np.pi / 2 hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX) flow_rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) # Save the optical flow image cv2.imwrite('optical_flow.jpg', flow_rgb)

iv. Real-time Object Tracking

Real−time object tracking methods such as CSRT and KCF are used to track a selected object across frames in a video stream.

 import cv2 # Load video cap = cv2.VideoCapture('video.mp4') # Initialize the tracker tracker = cv2.TrackerCSRT_create() # Read the first frame and select the region of interest (ROI) for tracking ret, frame = cap.read() bbox = cv2.selectROI("Tracking", frame, fromCenter=False, showCrosshair=True) tracker.init(frame, bbox) while True: ret, frame = cap.read() if not ret: break # Update tracker and get the new bounding box ret, bbox = tracker.update(frame) # Draw bounding box if ret: p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (0, 255, 0), 2) else: cv2.putText(frame, "Tracking Failed", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2) # Display the result cv2.imshow("Tracking", frame) # Exit if 'q' is pressed if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

7. Advanced Image Segmentation and Processing

Image segmentation is the computer vision technique that divides the images into separate regions or similar pixels.

i. Watershed Algorithm

The watershed algorithm segments images by flooding pixel topography.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Thresholding to get binary image _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU) # Applying distance transform and normalizing dist_transform = cv2.distanceTransform(thresh, cv2.DIST_L2, 5) _, sure_fg = cv2.threshold(dist_transform, 0.7 * dist_transform.max(), 255, 0) # Applying watershed sure_bg = cv2.dilate(thresh, None, iterations=3) unknown = cv2.subtract(sure_bg, sure_fg) markers = np.zeros_like(gray) markers[sure_fg == 255] = 1 markers[sure_bg == 255] = 2 cv2.watershed(image, markers) image[markers == -1] = [0, 0, 255] # Save the segmented image cv2.imwrite('watershed_image.jpg', image)

ii. GrabCut Algorithm

The GrabCut algorithm separates the foreground from the background. It uses a graph-based model and works iteratively for better segmentation.

 import cv2 import numpy as np # Load the image image = cv2.imread('image.jpg') # Create an initial mask mask = np.zeros(image.shape[:2], np.uint8) # Define the foreground and background models bgd_model = np.zeros((1, 65), np.float64) fgd_model = np.zeros((1, 65), np.float64) # Define the rectangle that contains the foreground object rect = (50, 50, 450, 290) # Apply the GrabCut algorithm cv2.grabCut(image, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT) # Modify the mask mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8') # Save the segmented image image = image * mask2[:, :, np.newaxis] cv2.imwrite('grabcut_image.jpg', image)

iii. Background Subtraction

Background subtraction detects motion by removing the background from a video frame.

 import cv2 # Create background subtractor fgbg = cv2.createBackgroundSubtractorMOG2() # Open video cap = cv2.VideoCapture('video.mp4') while True: ret, frame = cap.read() if not ret: break # Apply background subtractor fgmask = fgbg.apply(frame) # Display the result cv2.imshow('Foreground Mask', fgmask) # Exit if 'q' is pressed if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

8. Machine Learning and Deep Learning in OpenCV

Below are the two points that demonstrate the model explaination in short −

i. Using Pre-trained DNN Models

In OpenCV, DNN Models is pre-trained that allows user to use deep learning model for various tasks such as object detection, classification, and segmentation.

 import cv2 # Load a pre-trained deep learning model net = cv2.dnn.readNetFromCaffe('deploy.prototxt', 'mobilenet.caffemodel') # Load image and prepare for prediction image = cv2.imread('image.jpg') blob = cv2.dnn.blobFromImage(image, 1, (224, 224), (104, 117, 123)) # Perform forward pass and get predictions net.setInput(blob) predictions = net.forward() # Save the prediction result cv2.imwrite('dnn_prediction.jpg', image)

ii. Handwritten Digit Recognition

Handwritten digit recognition can be done using machine learning models such as SVM, KNN, or deep learning models on datasets like MNIST.

 import cv2 import numpy as np from sklearn import datasets, svm # Load the MNIST dataset (using sklearn for simplicity) digits = datasets.load_digits() # Use SVM for handwritten digit recognition clf = svm.SVC(gamma=0.001, C=100) clf.fit(digits.data, digits.target) # Test with a sample image sample = digits.images[0] predicted_digit = clf.predict([sample.flatten()]) # Save the result print(f'Predicted digit: {predicted_digit}')

9. 3D Vision and Depth Estimation

3D vision estimates depth by calculating distances from a 2D image.

i. Pose Estimation (cv2.solvePnP())

Pose estimation is the process of determining the position and orientation of a 3D object in space, based on a set of 2D image points and corresponding 3D object points.

 import cv2 import numpy as np # Define 3D object points (e.g., coordinates of the object in 3D space) object_points = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], dtype=np.float32) # Define corresponding 2D image points image_points = np.array([[200, 300], [300, 300], [300, 400], [200, 400]], dtype=np.float32) # Camera matrix (intrinsic parameters of the camera) focal_length = 1 center = (0, 0) camera_matrix = np.array([[focal_length, 0, center[0]], [0, focal_length, center[1]], [0, 0, 1]]) # Distortion coefficients (no distortion in this case) dist_coeffs = np.zeros((4, 1)) # Solve for the rotation and translation vectors using solvePnP success, rotation_vector, translation_vector = cv2.solvePnP(object_points, image_points, camera_matrix, dist_coeffs) # Print the results print("Rotation Vector: \n", rotation_vector) print("Translation Vector: \n", translation_vector)

ii. Stereo Vision and Depth Mapping

Stereo vision uses two cameras to capture images from different angles and calculates their differences to estimate depth.

 import cv2 import numpy as np # Load left and right stereo images left_image = cv2.imread('left_image.jpg', 0) right_image = cv2.imread('right_image.jpg', 0) # Create a stereo block matching object stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15) # Compute disparity map disparity = stereo.compute(left_image, right_image) # Normalize the disparity map for better visualization disparity_normalized = cv2.normalize(disparity, None, 0, 255, cv2.NORM_MINMAX) # Display the disparity map cv2.imshow("Disparity Map", disparity_normalized) cv2.waitKey(0) cv2.destroyAllWindows()

iii. Image Stitching

The image stitching is the process to merge multiple images into a single, wider image with an extended field of view.

 import cv2 import numpy as np # Load images to be stitched images = [cv2.imread('image1.jpg'), cv2.imread('image2.jpg'), cv2.imread('image3.jpg')] # Create a Stitcher object stitcher = cv2.createStitcher() # Perform the stitching status, stitched_image = stitcher.stitch(images) if status == cv2.Stitcher_OK: # Display the stitched panorama cv2.imshow("Panorama", stitched_image) cv2.waitKey(0) else: print("Error during stitching, status code:", status)

Print Page