Gain insights into using Python to read and write optical labels, explore 1D and 2D barcodes, and fiduciary markers for augmented reality, and discover relevant Python libraries and applications.

Reading _ Writing Machine-Readable Optical Labels with Python .jpg

g.tar.gz

Course

Gradio

Gradio-2

Gradio-3

Machine-readable optical labels are visual representations of data that machines can read and interpret. These labels, often composed of simple geometric shapes or lines, are designed to encode various kinds of information, such as product details or reference numbers.

In this course, you’ll be introduced to Python-based reading and writing of 1D and 2D barcodes and fiduciary markers. You’ll then learn the practical applications of barcodes and fiduciary markers in augmented reality and the creation of user interfaces for reading barcodes. Next, you’ll learn about different Python libraries and their usage to process different optical labels.

By the end of the course, you’ll be proficient in using Python for handling barcodes and fiduciary markers. You’ll also have hands-on experience installing and using different Python libraries to manipulate optical labels.

Using Python for Reading and Writing Optical Labels

The first piece of the code below loads an image with ArUco markers, detects the ArUco markers in the image, and then calculates the distances from each marker to the camera's center.

The second Python code will calculate the pairwise distances between detected ArUco markers in the image. 

We’ll use an image that contains two Aruco markers. The centers of these markers are at a distance of approximately 19 cm from each other, and the camera was held approximately 60 cm away.

# Calculating the distance from the camera to some markers

Here we'll show an example of how to calculate the distance from a camera to some markers.

import cv2
import numpy as np

def postprocessDistToCam(ids, tvec):
    if ids is not None:
        for i, tvec in enumerate(tvecs):
            marker_id = ids[i][0]
            distance = np.linalg.norm(tvec)
            print(f"Distance from marker {marker_id} to camera center: {distance:.2f} meters")

image_file = './resources/marker_images_dist/calibrate_20230704_134548.png'
image = cv2.imread(image_file)
calibration_data_file = "./resources/calibration_data.npz"
camera_matrix, distortion_coeffs = loadCalibrationData(calibration_data_file)

height, width = image.shape[:2]
new_camera_matrix, _ = cv2.getOptimalNewCameraMatrix(camera_matrix, distortion_coeffs, (width, height), 0, (width, height))
image = cv2.undistort(image, camera_matrix, distortion_coeffs, None, new_camera_matrix)
  
processed_image = preprocessImage(image)

marker_dict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_5X5_250)
detector_params = cv2.aruco.DetectorParameters_create()
detections, ids = detectMarkers(processed_image, marker_dict, detector_params)

marker_length = .05 #in meters
rvecs, tvecs = poseEstimation(detections, marker_length, camera_matrix, distortion_coeffs)

postprocessDistToCam(ids, tvecs)

result = visualization(image, detections, ids, camera_matrix, distortion_coeffs, rvecs, tvecs, marker_length)

#cv2.imwrite(f"./output/marker_detection.png", result)

**Lines 1–2:** First, we import `cv2` (OpenCV), `numpy`, and `pandas`. OpenCV is a library for computer vision, `numpy` is a package for scientific computing, and `pandas` is a data analysis and manipulation tool.

**Lines 4–9:** We define helper functions: The code defines several functions for specific tasks:


* `postprocessDistToCam()`: This calculates the distance from each detected marker to the camera center. The distance is calculated as the Frobenius norm (length) of the translation vector (`tvec`) for each marker. The **Frobenius norm**, which is also known as the Euclidean norm, is a measure of the magnitude (or length) of a matrix or vector. It is calculated as the square root of the sum of the absolute squares of its elements. 

* The other helper functions used in the code example are the same as in the previous lesson.


**Lines 11–14:** To start out, we load an image from the specified path and calibration data from the  `calibration_data.npz` file.

**Line 17:** Next, the loaded calibration data is used to create a `new_camera_matrix` that minimizes distortion in the image. The image is then undistorted using the original `camera_matrix`, `distortion_coeffs`, and `new_camera_matrix`.

**Line 20:** Then, the undistorted image is preprocessed (converted to grayscale) using `preprocessImage()`.

**Lines 22–24:** We then create an ArUco dictionary and detector parameters. The `cv2.aruco.detectMarkers()` function is used to detect the markers in the preprocessed image.

**Line 27:** Then, the `poseEstimation()` function is used to estimate the pose of each detected marker. 

**Line 29:** We’ll use the `postprocessDistToCam()` helper function to calculate and print the distance from each detected marker to the camera center.

**Line 31:** Finally, the `visualization()` function is used to draw the detected markers and their estimated pose onto the undistorted image. The resulting image is saved to the output directory. 

**Line 33:** To see the visualized result, the last line needs to be uncommented.

In addition, note that the calculated distances are printed to the console.

Learn how to find the distance between the camera and multiple markers.

Introduction to Machine-Readable Optical Labels

An Overview of Barcodes

Reading and Writing 1D Barcodes With Python

Reading and Writing 2D Barcodes With Python

Creating Fiduciary Markers With Python

Reading Fiduciary Markers With Python

Fiduciary Marker Use Cases

Build a User Interface With Gradio For Reading Barcodes

Build a Barcode Writing Application with Python

Roundup

Appendix

Find Distances Between the Camera and Markers