camera_calibration_API

A repository containing the camera calibration API

Repository Overview:

camera_calibration.py:contains an API which tries to minic the MATLAB's camera calibration app functionality. This API is a thin wrapper around the opencv's camera calibration functionalities.

examples: A directory containing various examples

Camera_Calibration_API:

Introduction:

The Camera Calibration API is a wrapper around the opencv's camera calibration functionalities. This tries to mimic the MATLAB camera calibration app's functionality in python. The API supports all the 3 calibration patterns supported by opencv namely: Chessboards, Asymmetric circular grids and Symmetric circular grids. The API by default runs on 4 threads for speedup. The speed-up may not be marginal in the case of chessboard calibration because in most cases the bottle neck will be a single chessboard image (run on a single core) which the algorithm takes time to detect.

Dependencies:

• works in both python-3 and python-2
• opencv (Tested in version 3.3.0)
• numpy
• matplotlib
• pickle
• argparse
• glob
• pickle
• multiprocessing
• os
• pandas

Example:

Examples to use the Camera_Calibration_API() for calibration using chessboard, symmetric circular grids and asymmetric circular grids can be found in the example_notebooks folder

Features:

• Supports all the 3 calibration patterns supported by opencv : Chessboards, Asymmetric circular grids and Symmetric circular grids.
• Additionally a custom calibration pattern can also be implemented. (Look at the next section for how to calibrate using custom pattern.)
• Visualizes the Reprojection error plot
• Ability to Recalibrate the camera by neglecting the images with very high reprojection errors.
• Camera centric and Pattern centric views can be visualized using the visualize_calibration_boards method after calibration.
• Blob detection parameters for detecting asymmetric and symmetric circular grids can be accessed and modified via the Camera_Calibration_API's object prior to calling the calibrate_camera method
• Also has terminal support with minimal control on the variables. Use it as an importable module for better control over the variables
• Can also be easily extended to support other unimplemented calibration patterns

Using custom calibration board with the Camera_Calibration_API.

So you want to extend the API for a custom calibration pattern? Well... OK! Just follow the follow the steps below

• The calibrate_camera accepts two additional arguments called custom_world_points_function and custom_image_points_function.
• You must implement the above two custom methods and pass it as an argument to the calibrate_camera method

custom_world_points_function(pattern_rows,pattern_columns):

• This function is responsible for calculating the 3-D world points of the given custom calibration pattern.
• Should take in two keyword arguments in the following order: Number of rows in pattern(int), Number of columns in pattern(int)
• Must return only a single numpy array of shape (M,3) and type np.float32 or np.float64 with M being the number of control points of the custom calibration pattern. The last column of the array (z axis) should be an array of 0
• The distance_in_world_units is not multiplied in this case. Hence, account for that inside the function before returning
• The world points must be ordered in this specific order : row by row, left to right in every row

custom_image_points_function(img,pattern_rows,pattern_columns):

• This function is responsible for finding the 2-D image points from the custom calibration image.
• Should take in 3 keyword arguments in the following order: image(numpy array),Number of rows in pattern(int), Number of columns in pattern(int)
• This must return 2 variables: return_value, image_points
• The first one is a boolean Representing whether all the control points in the calibration images are found
• The second one is a numpy array of shape (N,2) of type np.float32 containing the pixel coordinates or the image points of the control points. where N is the number of control points.
• This function should return True only if all the control points are detected (M = N)
• If all the control points are not detected, fillup the 2-D numpy array with 0s entirely and return with bool == False.
• The custom image points must be ordered in this specific order: : row by row, left to right in every row

NOTE: 'Custom' pattern is not supported when accessed from terminal

Supported Calibration patterns (rows x columns) bydefault:

Chessboard or Checkerboard pattern (6 x 9):

Asymmetrical circular grid/pattern (4 x 11):

.

NOTE for calibrating using Asymmetric circular grid:

• The code assumes that each asymmetric circle is placed at half the distance_in_world_units in both (x,y) from each other.

• The distance_in_world_units is specified as the distance between 2 adjacent circle centers at the same y coordinate

• The above is a 4 x 11 (r x c) asymmetrical circular grid.

• If you are using the same orientation as the above, Then this orientation is termed as double_count_in_column which is by default set to True.

• If you are using an orientation which is 90deg to the above orientation 11 x 4 (r x c) then the double count is along the rows. In this case, set object.double_count_in_column = False prior to calling object.calibrate_camera method.

Symmetric circular grid/pattern (7 x 6):