Ask Your Question
0

cv2.stereoCalibrate: objectPoints-error (-210:Unsupported format or combination of formats)

asked 2020-08-26 03:07:04 -0500

Hey guys! I'm trying to get a disparity images from a stereo camera but I'm getting this error message in cv2.stereoCalibrate:

error: OpenCV(3.4.2) /opt/concourse/worker/volumes/live/9523d527-1b9e-48e0-7ed0-a36adde286f0/volume/opencv-suite_1535558719691/work/modules/calib3d/src/calibration.cpp:3139: error: (-210:Unsupported format or combination of formats) objectPoints should contain vector of vectors of points of type Point3f in function 'collectCalibrationData'

[EDIT] Regarding this error i've seen this answer: https://stackoverflow.com/questions/4... but it didn't solve my problem, because object_points and image_points are in the correct manner.

Image_points: [[2433.414 819.80554] [2436.264 1117.3773 ] ... [ 956.29877 2928.8433 ] [ 955.77747 3234.6638 ]]

Object_points: [[ 0. 0. 0. ] [ 3.6 0. 0. ] ... [25.199999 18. 0. ] [28.8 18. 0. ]]

This is the code i've got so far, but i must admit its mostly from this example: https://stackoverflow.com/questions/2...

I changed a few things to make it compatible with openCV 3.4.2.

import cv2
import numpy as np
import matplotlib.pyplot as plt

calib_l = cv2.imread("Bilder/Calib1.jpg", cv2.IMREAD_GRAYSCALE)
calib_r = cv2.imread("Bilder/Calib2.jpg", cv2.IMREAD_GRAYSCALE)
imgL = cv2.imread("Bilder/Stereo1.jpg", cv2.IMREAD_GRAYSCALE)
imgR = cv2.imread("Bilder/Stereo2.jpg", cv2.IMREAD_GRAYSCALE)

image_size = calib_l.shape[:2]

pattern_size = 9, 6
object_points = np.zeros((np.prod(pattern_size), 3), np.float32)
object_points[:, :2] = np.indices(pattern_size).T.reshape(-1, 2)

object_points *= 3.6
image_points = {}

#chessboard
ret, corners_l = cv2.findChessboardCorners(calib_l, pattern_size, True)
cv2.cornerSubPix(calib_l, corners_l,
                 (11, 11), (-1, -1),
                 (cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS,
                  30, 0.01))
corners_l = np.float32(corners_l)
image_points["left"] = corners_l.reshape(-1, 2)

ret, corners_r = cv2.findChessboardCorners(calib_r, pattern_size, True)
cv2.cornerSubPix(calib_r, corners_r,
                 (11, 11), (-1, -1),
                 (cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS,
                  30, 0.01))
corners_r = np.float32(corners_r)
image_points["right"] = corners_r.reshape(-1, 2)

#calibrate
(rect_trans, proj_mats, valid_boxes,
 undistortion_maps, rectification_maps) = {}, {}, {}, {}, {}
criteria = (cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS,
            100, 1e-5)
flags = (cv2.CALIB_FIX_ASPECT_RATIO + cv2.CALIB_ZERO_TANGENT_DIST + cv2.CALIB_SAME_FOCAL_LENGTH)

cam_mats = {"left": None, "right": None}
dist_coefs = {"left": None, "right": None}
rot_mat = None
trans_vec = None
e_mat = None
f_mat = None
(ret, cam_mats["left"], dist_coefs["left"], cam_mats["right"],
 dist_coefs["right"], rot_mat, trans_vec, e_mat,
 f_mat) = cv2.stereoCalibrate(object_points,
                              image_points["left"], image_points["right"],
                              image_size, cam_mats["left"],dist_coefs["left"],cam_mats["right"], dist_coefs["right"],rot_mat,
                              trans_vec, e_mat, f_mat, criteria=criteria, flags=flags)

(rect_trans["left"], rect_trans["right"],
 proj_mats["left"], proj_mats["right"],
 disp_to_depth_mat, valid_boxes["left"],
 valid_boxes["right"]) = cv2.stereoRectify(cam_mats["left"],
                                           dist_coefs["left"],
                                           cam_mats["right"],
                                           dist_coefs["right"],
                                           image_size,
                                           rot_mat, trans_vec, flags=0)
for side in ("left", "right"):
    (undistortion_maps[side], rectification_maps[side]) = cv2.initUndistortRectifyMap(cam_mats[side],
                                                           dist_coefs[side],
                                                           rect_trans[side],
                                                           proj_mats[side],
                                                           image_size,
                                                           cv2.CV_32FC1)

# disparity map
rectified_l = cv2.remap(imgL, undistortion_maps["left"],
                        rectification_maps["left"],
                        cv2.INTER_NEAREST)
rectified_r = cv2.remap(imgR, undistortion_maps["right"],
                        rectification_maps["right"],
                        cv2.INTER_NEAREST)
cv2.imshow("left", rectified_l)
cv2.imshow("right", rectified_r)
stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET, 0, 5)
disparity = stereo.compute(rectified_l, rectified_r, disptype=cv2.CV_32F)

plt.subplot(121).imshow(imgL)
plt.subplot(122).imshow(disparity)
plt.show()

Whats the problem here?

Thanks a lot in advance!!

edit retag flag offensive close merge delete

1 answer

Sort by ยป oldest newest most voted
0

answered 2020-08-26 04:53:59 -0500

berak gravatar image

updated 2020-08-26 05:00:44 -0500

stereo calibration needs several image pairs, it does not work with a single pair.

objectPoints should contain vector of vectors of points of type Point3f

so, for each pair of chessboard images, you need to append a list of points for both object and imagepts.

(tl;dr: you need another pair of [] around it)

then:

  • you need more image pairs, variation in pose and distance. make sure to have the corners of the view covered, bc. lens distortion is largest there.
  • you must check the ret value from findChessboardCorners()and discard the whole pair, if it did not find all the corners in both images
edit flag offensive delete link more
Login/Signup to Answer

Question Tools

1 follower

Stats

Asked: 2020-08-26 03:07:04 -0500

Seen: 40 times

Last updated: Aug 26