MareArts ANPR V14 - Easy 3-Method Integration (File, OpenCV, PIL)

🚀 MareArts ANPR V14 - Getting Started in 3 Easy Ways

Welcome to MareArts ANPR V14! Today I'll show you how to process license plates using three different methods: from files, OpenCV, or PIL. Plus, the new multi-region switching feature that saves memory.

📦 Quick Setup

pip install marearts-anpr
ma-anpr config  # Enter your credentials

🎯 Basic Usage - Three Input Methods

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
from marearts_anpr import marearts_anpr_from_image_file, marearts_anpr_from_cv2, marearts_anpr_from_pil
import cv2
from PIL import Image

# Initialize detector and OCR (once)
detector = ma_anpr_detector_v14(
    "medium_640p_fp32",
    user_name, serial_key, signature,
    backend="cpu",
    conf_thres=0.25
)

ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Method 1: From file (easiest!)
result = marearts_anpr_from_image_file(detector, ocr, "plate.jpg")
print(result)

# Method 2: From OpenCV
img = cv2.imread("plate.jpg")
result = marearts_anpr_from_cv2(detector, ocr, img)
print(result)

# Method 3: From PIL
pil_img = Image.open("plate.jpg")
result = marearts_anpr_from_pil(detector, ocr, pil_img)
print(result)

🌍 NEW: Dynamic Region Switching (Saves 180MB!)

Previously, you needed separate OCR instances for each region. Now use set_region():

# Initialize once with any region
ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Switch regions instantly!
ocr.set_region('eup')   # European plates
result = marearts_anpr_from_image_file(detector, ocr, "eu-plate.jpg")

ocr.set_region('kr')    # Korean plates  
result = marearts_anpr_from_image_file(detector, ocr, "kr-plate.jpg")

ocr.set_region('na')    # North American plates
result = marearts_anpr_from_image_file(detector, ocr, "us-plate.jpg")

ocr.set_region('cn')    # Chinese plates
ocr.set_region('univ')  # Universal

Memory savings: Single instance vs multiple = ~180MB saved per additional region!

📊 Available Regions

• kr - Korean plates (123가4567)
• eup - European plates (EU standards)
• na - North American plates (USA, Canada, Mexico)
• cn - Chinese plates (京A·12345)
• univ - Universal (all regions, slightly lower accuracy)

🎨 Batch Processing

# Detect plates from multiple images
img1 = cv2.imread("plate1.jpg")
img2 = cv2.imread("plate2.jpg")

detections1 = detector.detector(img1)
detections2 = detector.detector(img2)

# Collect plate crops
plates = []
for det in detections1:
    bbox = det['bbox']
    crop = img1[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])]
    plates.append(Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)))

for det in detections2:
    bbox = det['bbox']
    crop = img2[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])]
    plates.append(Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)))

# Process all plates at once!
results = ocr.predict(plates)  # Pass list of images

for i, (text, conf) in enumerate(results):
    print(f"Plate {i+1}: {text} ({conf}%)")

🔧 Model Options

Detector models:

• pico_640p_fp32 - Smallest, fastest
• micro_640p_fp32
• small_640p_fp32
• medium_640p_fp32 - Recommended balance
• large_640p_fp32 - Most accurate

OCR models:

• pico_fp32 - Fastest
• micro_fp32
• small_fp32
• medium_fp32 - Recommended
• large_fp32 - Best accuracy

Backends:

• cpu - Works everywhere
• cuda - NVIDIA GPU (10-100x faster!)
• directml - Windows GPU

📝 Complete Example

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
from marearts_anpr import marearts_anpr_from_image_file
import os

# Load credentials
user_name = os.getenv('MAREARTS_ANPR_USERNAME')
serial_key = os.getenv('MAREARTS_ANPR_SERIAL_KEY')
signature = os.getenv('MAREARTS_ANPR_SIGNATURE')

# Initialize models
detector = ma_anpr_detector_v14(
    "medium_640p_fp32",
    user_name, serial_key, signature,
    backend="cpu",
    conf_thres=0.25,
    iou_thres=0.5
)

ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Process European plate
print("Processing European plate...")
result = marearts_anpr_from_image_file(detector, ocr, "eu-plate.jpg")
print(result)

# Switch to Korean region
ocr.set_region('kr')
print("\nProcessing Korean plate...")
result = marearts_anpr_from_image_file(detector, ocr, "kr-plate.jpg")
print(result)

💡 Key Takeaways

• ✅ Three input methods: file, OpenCV, PIL
• ✅ Dynamic region switching saves memory
• ✅ Batch processing for efficiency
• ✅ Multiple model sizes for different needs
• ✅ GPU acceleration available

🔗 Try It Free!

No license yet? Try the free API (1000 requests/day):

ma-anpr test-api your-plate.jpg --region eup

Happy coding! 🚗📸

---

Labels:

QR detector python code

 refer to code:

.

import cv2

#pip install pyzbar

from pyzbar.pyzbar import decode

def scan_qr_code():

# Start the webcam

cap = cv2.VideoCapture(0)

cap.set(3, 640) # Set the width of the window

cap.set(4, 480) # Set the height of the window

while True:

success, img = cap.read()

if not success:

print("Failed to grab frame")

break

# Decode the QR Code

for barcode in decode(img):

# Get the QR Code position

my_data = barcode.data.decode('utf-8')

pts = barcode.polygon

if len(pts) == 4: # If we have 4 points, then we have a QR code

pts2 = barcode.rect

cv2.putText(img, my_data, (pts2[0], pts2[1]), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 255), 2)

for point in pts:

cv2.circle(img, (point[0], point[1]), 5, (0, 255, 0), cv2.FILLED)

# Display the frame

cv2.imshow('QR Code Scanner', img)

if cv2.waitKey(1) & 0xFF == ord('q'): # Press 'q' to quit

break

cap.release()

cv2.destroyAllWindows()

if __name__ == "__main__":

scan_qr_code()

..

you need to install pyzbar

Thank you.

www.marearts.com

🙇🏻‍♂️

convert you opencv camera calibration yaml file to openSFM camera.json file

 refer to code:

.

from PIL import Image

import json

import yaml

import os

import argparse

def get_image_dimensions(image_path):

with Image.open(image_path) as img:

return img.size

def convert_yaml_to_opensfm_json(yaml_file, json_file, image_path):

image_width, image_height = get_image_dimensions(image_path)

with open(yaml_file, 'r') as f:

calibration_data = yaml.safe_load(f)

# Extract the camera matrix and distortion coefficients

camera_matrix = calibration_data['camera_matrix']

dist_coeff = calibration_data['dist_coeff']

# Compute the normalized focal length

focal_normalized = camera_matrix[0][0] / image_width

# Prepare the JSON data

json_data = {

f"custom_camera {image_width} {image_height} perspective 0.0": {

"projection_type": "perspective",

"width": image_width,

"height": image_height,

"focal": focal_normalized,

"k1": dist_coeff[0][0],

"k2": dist_coeff[0][1]

}

}

# Write the JSON data to file

with open(json_file, 'w') as f:

json.dump(json_data, f, indent=4)

def main():

yaml_file="calibration.yaml"

json_file="./camera_models.json"

image_path="IMG_5306.JPG"

convert_yaml_to_opensfm_json(yaml_file, json_file, image_path)

if __name__ == '__main__':

main()

..

reference :

https://github.com/mapillary/OpenSfM/issues/95

https://opensfm.org/docs/geometry.html#camera-models

Thank you.

www.marearts.com

🙇🏻‍♂️

OpenCV Camera Calibration source code

refer to code:

.

import numpy as np

import cv2

import glob

import yaml

from icecream import ic

import os

def calibrate_camera(images, chess_box_scale_mm):

# Termination criteria for refining the detected corners

criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

# Prepare object points: (0,0,0), (1,0,0), (2,0,0), ..., (9,6,0)

objp = np.zeros((9*6,3), np.float32)

objp[:,:2] = np.mgrid[0:6, 0:9].T.reshape(-1,2) * chess_box_scale_mm# Scale by 7.5mm or 17.5mm or 25mm

# Arrays to store object and image points from all the images

objpoints = [] # 3d point in real world space

imgpoints = [] # 2d points in image plane

if not images:

raise Exception("No images found in the calibration directory.")

for fname in images:

ic(fname)

img = cv2.imread(fname)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Find the chessboard corners

ret, corners = cv2.findChessboardCorners(gray, (6,9), None)

ic(ret)

# If found, add object points and image points

if ret == True:

objpoints.append(objp)

corners2 = cv2.cornerSubPix(gray, corners, (11,11), (-1,-1), criteria)

imgpoints.append(corners2)

# Draw and display the corners

cv2.drawChessboardCorners(img, (6,9), corners2, ret)

# Save the image with corners in the same directory but with a .png extension

base_name = os.path.basename(fname)

file_root, file_ext = os.path.splitext(base_name)

save_path = os.path.join(os.path.dirname(fname), f"{file_root}.png")

cv2.imwrite(save_path, img)

cv2.imshow('img', img)

cv2.waitKey(500)

cv2.destroyAllWindows()

if not objpoints or not imgpoints:

raise Exception("Chessboard corners not found in any images.")

# Calibrate the camera using the last value of gray from the loop

ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

return ret, mtx, dist, rvecs, tvecs

def main():

path = "./path/to/images/"

images = glob.glob(f'{path}/*.JPG')

ret, mtx, dist, rvecs, tvecs = calibrate_camera(images, 7.5) #chess_box_scale_mm is 7.5 mm

print("Camera matrix: \n", mtx)

print("Distortion coefficients: \n", dist)

# Save to YAML file

data = {'camera_matrix': np.asarray(mtx).tolist(), 'dist_coeff': np.asarray(dist).tolist()}

with open(f"{path}/calibration.yaml", "w") as f:

yaml.dump(data, f)

# Display one of the images after undistortion

img = cv2.imread(images[0]) # Replace with an image from your calibration set

h, w = img.shape[:2]

newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))

# Undistort

dst = cv2.undistort(img, mtx, dist, None, newcameramtx)

# Crop the image

x, y, w, h = roi

dst = dst[y:y+h, x:x+w]

cv2.imshow('origin Image', img)

cv2.imshow('Undistorted Image', dst)

cv2.waitKey(0)

cv2.destroyAllWindows()

if __name__ == "__main__":

main()

.. 

Here is chess board which has 10x7.

png files in same folder are that images succeed for finding pattern.

yaml file will be generated in image folder for camera intrinsic params.

Thank you.

www.marearts.com

🙇🏻‍♂️

python opencv canny edge source code

 refer to code:

.

import cv2

# Load an image

img = cv2.imread('input_image.jpg', cv2.IMREAD_GRAYSCALE)

# Apply Canny edge detection algorithm

edges = cv2.Canny(img, 100, 200)

# Display the input image and the edge map

cv2.imshow('Input Image', img)

cv2.imshow('Canny Edges', edges)

cv2.waitKey(0)

cv2.destroyAllWindows()

..

Thank you.

🙇🏻‍♂️

Combine Two Videos Side by Side with OpenCV python

 refer to code:

.

import cv2

# Open the two video files

video1 = cv2.VideoCapture('video1.mp4')

video2 = cv2.VideoCapture('video2.mp4')

# Get video properties

width1 = int(video1.get(cv2.CAP_PROP_FRAME_WIDTH))

height1 = int(video1.get(cv2.CAP_PROP_FRAME_HEIGHT))

fps1 = video1.get(cv2.CAP_PROP_FPS)

width2 = int(video2.get(cv2.CAP_PROP_FRAME_WIDTH))

height2 = int(video2.get(cv2.CAP_PROP_FRAME_HEIGHT))

fps2 = video2.get(cv2.CAP_PROP_FPS)

# Check if videos have the same FPS and height

assert fps1 == fps2, "Videos should have the same FPS"

assert height1 == height2, "Videos should have the same height"

# Create a VideoWriter object to save the combined video

fourcc = cv2.VideoWriter_fourcc(*'mp4v')

out = cv2.VideoWriter('output.mp4', fourcc, fps1, (width1 + width2, height1))

while video1.isOpened() and video2.isOpened():

ret1, frame1 = video1.read()

ret2, frame2 = video2.read()

if not ret1 or not ret2:

break

# Concatenate the frames side by side

combined_frame = cv2.hconcat([frame1, frame2])

# Write the combined frame to the output video

out.write(combined_frame)

# Display the combined frame

cv2.imshow('Combined Video', combined_frame)

# Press 'q' to stop the process and close the window

if cv2.waitKey(1) & 0xFF == ord('q'):

break

# Release the video files and the output video

video1.release()

video2.release()

out.release()

cv2.destroyAllWindows()

..

Thank you.

www.marearts.com

🙇🏻‍♂️

How to Install OpenCV 4.7 with CUDA, cuDNN, TBB, CUDA Video Codec, and Extra Modules in Linux

 

refer to bash code

.

#!/bin/bash

# Install dependencies

sudo apt-get update

sudo apt-get install build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev

sudo apt-get install libtbb2 libtbb-dev libjpeg-dev libpng-dev libtiff-dev libdc1394-22-dev

sudo apt-get install libcanberra-gtk-module libcanberra-gtk3-module

# Install CUDA 11

wget https://developer.download.nvidia.com/compute/cuda/11.4.0/local_installers/cuda_11.4.0_470.57.02_linux.run

sudo sh cuda_11.4.0_470.57.02_linux.run --silent --toolkit --override

echo 'export PATH=/usr/local/cuda-11.4/bin:$PATH' >> ~/.bashrc

echo 'export LD_LIBRARY_PATH=/usr/local/cuda-11.4/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc

source ~/.bashrc

# Download and extract TBB

wget https://github.com/oneapi-src/oneTBB/releases/download/v2022.0.0/oneapi-tbb-2022.0.0-lin.tgz

tar -xf oneapi-tbb-2022.0.0-lin.tgz

sudo cp -r oneapi-tbb-2022.0.0/lib/* /usr/local/lib/

echo 'export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH' >> ~/.bashrc

source ~/.bashrc

# Download and extract OpenCV 4.7 and OpenCV extra modules

wget https://github.com/opencv/opencv/archive/4.7.0.zip

unzip 4.7.0.zip

cd opencv-4.7.0

wget https://github.com/opencv/opencv_contrib/archive/4.7.0.zip

unzip 4.7.0.zip

# Build and install OpenCV 4.7 with CUDA, cuDNN, TBB, CUDA video codec, and OpenCV extra modules

mkdir build

cd build

cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-4.7.0/modules -D WITH_CUDA=ON -D WITH_TBB=ON -D WITH_NVCUVID=ON -D WITH_GSTREAMER=ON -D WITH_GSTREAMER_0_10=OFF -D WITH_LIBV4L=ON -D WITH_CUDNN=ON -D CUDA_ARCH_BIN=7.5 ..

make -j$(nproc)

sudo make install

echo 'export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH' >> ~/.bashrc

source ~/.bashrc

# Compile and run the sample code

cd ../../

wget https://raw.githubusercontent.com/spmallick/learnopencv/master/Averaging4kVideo/Averaging4kVideo.cpp

g++ Averaging4kVideo.cpp -o Averaging4kVideo `pkg-config --cflags --libs opencv4`

./Averaging4kVideo

..

thank you.

🙇🏻‍♂️

www.marearts.com

example code in Python using OpenCV and scikit-learn to build a dataset for video classification

refer to code.

..

import cv2

import os

from sklearn.model_selection import train_test_split

# Define the classes for classification

classes = ['class1', 'class2', 'class3']

# Create a list to store the image paths and labels

data = []

# Loop through the videos and extract frames

for cls in classes:

video_dir = f'data/{cls}/'

for filename in os.listdir(video_dir):

video_path = os.path.join(video_dir, filename)

cap = cv2.VideoCapture(video_path)

while cap.isOpened():

ret, frame = cap.read()

if not ret:

break

frame_path = f'frames/{cls}/{filename}_{cap.get(cv2.CAP_PROP_POS_FRAMES)}.jpg'

cv2.imwrite(frame_path, frame)

data.append((frame_path, cls))

cap.release()

# Split the data into training, validation, and test sets

train_val_data, test_data = train_test_split(data, test_size=0.2, stratify=[x[1] for x in data])

train_data, val_data = train_test_split(train_val_data, test_size=0.2, stratify=[x[1] for x in train_val_data])

# Preprocess the images

def preprocess_image(image):

# Resize the image to (224, 224) and normalize the pixel values

image = cv2.resize(image, (224, 224))

image = image.astype('float32') / 255.0

return image

# Load the images and labels into memory

X_train = []

y_train = []

for image_path, label in train_data:

image = cv2.imread(image_path)

image = preprocess_image(image)

X_train.append(image)

y_train.append(label)

X_val = []

y_val = []

for image_path, label in val_data:

image = cv2.imread(image_path)

image = preprocess_image(image)

X_val.append(image)

y_val.append(label)

X_test = []

y_test = []

for image_path, label in test_data:

image = cv2.imread(image_path)

image = preprocess_image(image)

X_test.append(image)

y_test.append(label)

# Train and evaluate the model

# ...

..

In this example, we first define the classes for classification (in this case, 'class1', 'class2', and 'class3'). We then loop through the videos for each class, extract frames from each video, and store the frame paths and labels in a list called data.

Next, we split the data into training, validation, and test sets using train_test_split() from scikit-learn. We stratify the splits to ensure that each set has a proportional number of frames from each class.

We then define a function called preprocess_image() to resize the images to (224, 224) and normalize the pixel values. We load the images and labels into memory for each set using OpenCV, preprocess them using this function, and store them in lists called X_train, y_train, X_val, y_val, X_test, and y_test.

Finally, we can train and evaluate a video classification model using the preprocessed data. The specific code for this step will depend on the model architecture and training strategy you choose to use.

Thank you.

Optical Flow Estimation, How might you calculate the velocity/speed of an object from a ".flo" output

refer to code 

..

import cv2

import numpy as np

# Load the .flo file using OpenCV

flow = cv2.readOpticalFlow('path/to/flow_file.flo')

# Convert displacement vectors to velocity vectors

time_interval = 1.0 # Time interval between frames in seconds

velocity = flow / time_interval

# Load the corresponding frames of the video

frame1 = cv2.imread('path/to/frame1.jpg')

frame2 = cv2.imread('path/to/frame2.jpg')

# Identify object pixels using object detection or segmentation

object_mask = np.zeros(frame1.shape[:2], dtype=np.uint8)

object_mask[...] = 255 # Example: assume the entire frame is the object

# Compute the magnitude of the velocity vector at each object pixel

object_velocity = np.sqrt(np.square(velocity[..., 0]) + np.square(velocity[..., 1])) * object_mask

# Calculate the average speed of the object

object_speed = np.mean(object_velocity[object_mask != 0])

print('Object speed:', object_speed, 'pixels per second')

..

In this example, we first load the .flo file using the cv2.readOpticalFlow() function from OpenCV. We then convert the displacement vectors in the .flo file to velocity vectors by dividing them by the time interval between the two frames. We assume a time interval of 1 second in this example.

Next, we load the corresponding frames of the video and identify the object pixels using a mask. In this example, we assume that the entire frame is the object for simplicity.

We then compute the magnitude of the velocity vector at each object pixel using the np.sqrt() and np.square() functions from NumPy. We apply the object mask to exclude pixels that do not belong to the object.

Finally, we calculate the average speed of the object by averaging the magnitudes of the velocity vectors over all the pixels corresponding to the object using the np.mean() function.

Note that the units of the speed will be in pixels per second, which can be converted to other units (e.g., meters per second) depending on the scale of the video frames. Also, this is just a simple example and you may need to modify it depending on the specific requirements of your application.

Thank you.

opencv c++ gpumat mat(cpu) memory share

refer to code:

..

size_t frameByteSize = initMat.step[0] * initMat.rows;

#ifndef USE_UNIFIED_MEM

    /* Pinned memory. No cache */

    std::cout << "Using pinned memory" << std::endl;

    void* device_ptr, * host_ptr;

    cudaSetDeviceFlags(cudaDeviceMapHost);

    cudaHostAlloc((void**)&host_ptr, frameByteSize, cudaHostAllocMapped);

    cudaHostGetDevicePointer((void**)&device_ptr, (void*)host_ptr, 0);

    cv::Mat frame_out(height, width, CV_8UC3, host_ptr);

    cv::cuda::GpuMat d_frame_out(height, width, CV_8UC3, device_ptr);

#else

    /* Unified memory */

    std::cout << "Using unified memory" << std::endl;

    void* unified_ptr;

    cudaMallocManaged(&unified_ptr, frameByteSize);

    cv::Mat frame_out(height, width, CV_8UC3, unified_ptr);

    cv::cuda::GpuMat d_frame_out(height, width, CV_8UC3, unified_ptr);

#endif

..

another example

..

void* m_device_ptr = NULL;

void* m_host_ptr = NULL;

//memory share frame -> cuda_frame

cudaSetDeviceFlags(cudaDeviceMapHost);

size_t frameByteSize = initMat.step[0] * initMat.rows;

cudaHostAlloc((void**)&m_host_ptr, frameByteSize, cudaHostAllocMapped);

cudaHostGetDevicePointer((void**)&m_device_ptr, (void*)m_host_ptr, 0);

cv::Mat m_frame = cv::Mat(initMat.rows, initMat.cols, CV_8UC3, m_host_ptr);

cv::cuda::GpuMat m_cuda_frame = cv::cuda::GpuMat(initMat.rows, initMat.cols, CV_8UC3, m_device_ptr);

//initiation

iframes.copyTo(m_frame);

..

Opencv Mat <-> UMat , convert Mat to UMat, UMat to Mat

Mat to UMat 

c++

UMat umat;

mat.copyTo(umat);

Python

UMat umat = mat.getUMat( flag );

UMat to Mat

C++

Mat mat = umat.getMat( flag );

Python

mat = cv2.UMat.get(umat)

opencv c++ resizeWindow example

 Original image size [5120x2188], but you can imshow as 300x300 and resizable.

..

#include "opencv2/opencv.hpp"
#include "opencv2/highgui/highgui.hpp"  
#include <iostream>
#include <chrono>
 
#pragma comment(lib, "opencv_highgui453.lib")
#pragma comment(lib, "opencv_imgcodecs453.lib")
#pragma comment(lib, "opencv_core453.lib")
 
int main() {
	//read image
	cv::Mat oImg = cv::imread("Resized_Blackpink_PUBG_210321.jpg");
	cv::namedWindow("oimg", cv::WINDOW_NORMAL);
	cv::resizeWindow("oimg", 300, 300);
	cv::imshow("oimg", oImg);
	cv::waitKey(0);
}

..

Thank you.

opencv Vector CameraParams save(yaml file store) and load(yaml file restore ) using FileNode, FileNodeIterator

Refer to load & save function.

..

std::vector<cv::detail::CameraParams> params;

bool loadCameraParams(std::string fileName){

cv::FileStorage fs(fileName+".yaml", cv::FileStorage::READ);

if(!fs.isOpened())

return false;

/////

int nObjects= 0;

fs["NC"] >> nObjects;

params.clear();

params.resize(nObjects);

/////

cv::FileNode fn = fs["cameras"];

int id=0;

for (cv::FileNodeIterator it = fn.begin(); it != fn.end(); it++,id++)

{

cv::FileNode item = *it;

cv::Mat K, R, t;

double ppx, ppy, focal, aspect;

item["K"] >> K;

item["R"] >> R;

item["t"] >> t;

item["ppx"] >> ppx;

item["ppy"] >> ppy;

item["focal"] >> focal;

item["aspect"] >> aspect;

mg_params[id].K() = (cv::Mat)K;

mg_params[id].R = R;

mg_params[id].t = t;

mg_params[id].ppx = (double)ppx;

mg_params[id].ppy = (double)ppy;

mg_params[id].focal = (double)focal;

mg_params[id].aspect = (double)aspect;

}

return true;

}

bool saveCameraParams(std::string fileName){

cv::FileStorage fs(fileName+".yaml", cv::FileStorage::WRITE);

cv::detail::CameraParams cameras = mg_params[0];

fs << "NC" << int(params.size());

fs << "cameras" << "[";

for (const auto& param : mg_params)

{

fs << "{";

fs << "K" << param.K();

fs << "R" << param.R;

fs << "t" << param.t;

fs << "ppx" << param.ppx;

fs << "ppy" << param.ppy;

fs << "focal" << param.focal;

fs << "aspect" << param.aspect;

fs << "}";

}

fs << "]";

fs.release();

return true;

}

..

Thank you!!

☕️

Build OpenCV 4.5.2 + Ubuntu 20.4 + CUDA 11.2

Build OpenCV 4.5.2 + Ubuntu 20.4 + CUDA 11.2
Youtube Video:

Reference:
https://www.marearts.com/0-OpenCV-Build-Ubuntu-20-04-OpenCV-4-5-2-CUDA-11-2-4c876d664e84442e82ebec13c23586b3

Thank you.

Importerror: libgl.so.1: cannot open shared object file: no such file or directory opencv error

Try this one first:

pip install opencv-python--headless

or 

install follow in case centos or aws linux docker

RUN yum install whatprovides libGL.so.1 -y

install follow in case linux docker

ENV TZ=Europe/Minsk

RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

RUN apt-get install libgtk2.0-dev -y

 

Thank you, Good luck!

Python OpenCV Image to byte string for json transfer

code :

import cv2

import base64

import json

import numpy as np

######################################################

#read image

img = cv2.imread('./code_backup/test_img.jpg')

#cv2 to string

image_string = cv2.imencode('.jpg', img)[1]

image_string = base64.b64encode(image_string).decode()

#make string image dict

dict = {'img':image_string}

#save dict to json file

with open('./code_backup/cv2string.json', 'w') as fp:

json.dump(dict, fp, indent=5)

######################################################

######################################################

#read json

response = json.loads(open('./code_backup/cv2string.json', 'r').read())

#get image string

string = response['img']

#convert string to image

jpg_original = base64.b64decode(string)

jpg_as_np = np.frombuffer(jpg_original, dtype=np.uint8)

img = cv2.imdecode(jpg_as_np, flags=1)

#show image

cv2.imshow('show image', img)

cv2.waitKey(0)

######################################################

..

this is input image

this is summarised json file

{ "img": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYGBwkIBgcJBwYGCAsICQoKCgoKBggLDAsKDAkKCgr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wAARCAFoAeADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD2BP8Ag34/4JIE4P7I4/8AC617/wCTqsJ/wb4/8EiTx/wyR/5fWv8A/wAnV9nPH2x+FSwx14/t6vc+i+r4f+Q+Mk/4N7P+CQ+P+TRx/wC ........."

}