def _exact_pose(gray, mtx, dist): """Return a pair (rotation, translation) vectors describing what we think is the pose of the 3d model. For the chessboard, this uses corner location and PNP matching to get a high-accuracy pose. """ ret, corners = cv2.findChessboardCorners(gray, (5, 8), None) if ret is True: # refine corner locations criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) objp = np.zeros((5 * 8, 3), np.float32) objp[:, :2] = np.mgrid[0:5, 0:8].T.reshape(-1, 2) # Find the rotation and translation vectors. _, rotation_vec, translation_vec, inliers = cv2.solvePnPRansac( objp, corners2, mtx, dist) return rotation_vec, translation_vec else: # If no frame is found, guess the pose return np.array([0.1, 0.1, 0.1]), np.array([0.0, 0.0, 10.0])
def calibrate(): criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) Nx_cor = 9 Ny_cor = 6 objp = np.zeros((Nx_cor * Ny_cor, 3), np.float32) objp[:, :2] = np.mgrid[0:Nx_cor, 0:Ny_cor].T.reshape(-1, 2) objpoints = [] # 3d points in real world space imgpoints = [] # 2d points in image plane. count = 0 # count 用来标志成功检测到的棋盘格画面数量 while (True): ret, frame = cap.read() if cv2.waitKey(1) & 0xFF == ord(' '): # Our operations on the frame come here gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, (Nx_cor, Ny_cor), None) # Find the corners # If found, add object points, image points if ret == True: corners = cv2.cornerSubPix(gray, corners, (5, 5), (-1, -1), criteria) objpoints.append(objp) imgpoints.append(corners) cv2.drawChessboardCorners(frame, (Nx_cor, Ny_cor), corners, ret) count += 1 if count > 20: break # Display the resulting frame cv2.imshow('frame', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break global mtx, dist ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None) print(mtx, dist) mean_error = 0 for i in range(len(objpoints)): imgpoints2, _ = cv2.projectPoints(objpoints[i], rvecs[i], tvecs[i], mtx, dist) error = cv2.norm(imgpoints[i], imgpoints2, cv2.NORM_L2) / len(imgpoints2) mean_error += error print("total error: ", mean_error / len(objpoints)) # # When everything done, release the capture np.savez('calibrate.npz', mtx=mtx, dist=dist[0:4])
def calibrateOne(img_path, cameraParam): criteria = (cv2.TERM_CRITERIA_MAX_ITER | cv2.TERM_CRITERIA_EPS, 30, 0.001) #设置寻找亚像素角点的参数,采用的停止准则是最大循环次数30和最大误差容限0.001 #获取标定板角点的位置 objp = np.zeros((4 * 7, 3), np.float32) objp[:, :2] = np.mgrid[0:7, 0:4].T.reshape(-1, 2) #将世界坐标系建在标定板上 obj_points = [] #3D points img_points = [] #2D points images = glob.glob(img_path) i = 0 for fname in images: img = cv2.imread(fname) #print(fname) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) size = gray.shape[::-1] h, w = gray.shape[:2] ret, corners = cv2.findChessboardCorners(gray, (7, 4), None) if ret: obj_points.append(objp) corners2 = cv2.cornerSubPix(gray, corners, (5, 5), (-1, -1), criteria) #在原角点的基础上寻找亚像素点 #print(corners2) if [corners2]: img_points.append(corners2) else: img_points.append(corners) cv2.drawChessboardCorners(img, (7, 4), corners, ret) i += 1 ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, size, None, None, criteria) #dist——>dist coffients(就是k、p的值) newcameramtx, roi = cv2.getOptimalNewCameraMatrix( mtx, dist, (w, h), 1, (w, h)) #显示更大范围的图片(正常重映射之后会删掉一部分图像) #将fx,fy(世界坐标系的焦距)投射到fu,fv(图像坐标系的焦距)上,立体矫正时会用 #dst = cv2.undistort(img,mtx,dist,None,newcameramtx) #x,y,w,h = roi cameraParam['ret'] = ret cameraParam['mtx'] = mtx cameraParam['dist'] = dist cameraParam['rvecs'] = rvecs cameraParam['tvecs'] = tvecs cameraParam['img_points'] = img_points cameraParam['obj_points'] = obj_points cameraParam['size'] = size cameraParam['newmtx'] = newcameramtx print("Calibrate One Camera Success")
def augmentation3d(self): plt.close('all') with np.load('output.npz') as X: mtx, dist, _, _ = [ X[i] for i in ('arr_0', 'arr_1', 'arr_2', 'arr_3') ] criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001) objp = np.zeros((11 * 8, 3), np.float32) objp[:, :2] = np.mgrid[0:11, 0:8].T.reshape(-1, 2) axis = np.float32([[1, 1, 0], [5, 1, 0], [3, 5, 0], [3, 3, -3]]) filepath = list() for i in range(5): path = os.path.join('Datasets/Q3_Image', str(i + 1) + '.bmp') filepath.append(path) ims = list() fig = plt.figure('augumentation3d') for fname in filepath: img = cv.imread(fname) gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) ret, corners = cv.findChessboardCorners(gray, (11, 8), None) if ret == True: corners2 = cv.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) # Find the rotation and translation vectors. _, rvecs, tvecs, _ = cv.solvePnPRansac(objp, corners2, mtx, dist) # project 3D points to image plane imgpts, _ = cv.projectPoints(axis, rvecs, tvecs, mtx, dist) img = self.draw(img, corners2, imgpts) plt_img = img[:, :, ::-1] im = plt.imshow(plt_img, animated=True) ims.append([im]) _ = animation.ArtistAnimation(fig, ims, interval=500, blit=True, repeat_delay=500) plt.show()
def calculate_camera_matrix_and_distortion_coefficients(camera_model_name): # termination criteria criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(7,5,0) object_points = np.zeros((6 * 8, 3), np.float32) object_points[:, :2] = np.mgrid[0:8, 0:6].T.reshape(-1, 2) # Arrays to store object points and image points from all the images. real_world_points = [] # 3d point in real world space image_points = [] # 2d points in image plane. image_paths = glob.glob("calibration_images/*.png") for path_to_image in image_paths: img = cv2.imread(path_to_image) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Find the chess board corners chess_board_successfully_detected, corners = cv2.findChessboardCorners( gray, (8, 6), None) print("Found chess board in: " + path_to_image + " : " + str(chess_board_successfully_detected)) # If found, add object points, image points (after refining them) if chess_board_successfully_detected: real_world_points.append(object_points) refined_corners = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) image_points.append(refined_corners) # Draw and display the corners # img = cv2.drawChessboardCorners(img, (7, 6), refined_corners, chess_board_successfully_detected) # cv2.imshow('img', resize_image(img, (1920, 1080))) # cv2.waitKey() cv2.destroyAllWindows() ret, camera_matrix, distortion_coeffs, rvecs, tvecs = cv2.calibrateCamera( real_world_points, image_points, gray.shape[::-1], None, None) h, w = gray.shape[:2] camera_matrix_with_crop, roi = cv2.getOptimalNewCameraMatrix( camera_matrix, distortion_coeffs, (w, h), 1, (w, h)) file_name = f"camera_calibration_{camera_model_name}.npz" np.savez(file_name, camera_matrix=camera_matrix, distortion_coeffs=distortion_coeffs, camera_matrix_with_crop=camera_matrix_with_crop)
def findCorners(num=14): imgNum = 0 for img in range(1, num + 1): corners = [] readpath = '/home/tamarar/Desktop/novo/Camera_calibration/calibration/images_calibration/Pic_' image = cv2.imread(readpath + str(img) + '.jpg') gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) ret, corner = cv2.findChessboardCorners(gray, (9, 6), None) if ret == True: corners.append(corner) imgNum += 1 print("imgNum = ", imgNum) return corners
def find_corners(images, windows, chessboard): """Display chessboard corners on input images.""" retvals = [[False] for __ in range(len(images))] corners = [[None] for __ in range(len(images))] for i, (image, window) in enumerate(zip(images, windows)): image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) retvals[i], corners[i] = cv2.findChessboardCorners( image, chessboard.dims) cv2.drawChessboardCorners(image, chessboard.dims, corners[i], retvals[i]) cv2.imshow(window, image) return retvals, corners
def find_calibration_matrix(images): # Prepare real world points rwp = np.zeros((7 * 9, 3), np.float32) rwp[:, :2] = np.mgrid[0:7, 0:9].T.reshape(-1, 2) # Arrays to store 3D points in the real world and 2D points in image plane rw_points = [] image_points = [] for image in images: img = cv2.imread(image) img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Take in a 8-bit grayscale image and the number of internal corners of chessboard and flags. # CLAIB_CV_FAST_CHECK = check quickly for corners and end if none to save time found, corners = cv2.findChessboardCorners( img_gray, (7, 9), flags=cv2.CALIB_CB_FAST_CHECK ) if found: rw_points.append(rwp) # Needs accuracy below pixel level corners = cv2.cornerSubPix( img_gray, corners, (11, 11), (-1, -1), (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001), ) image_points.append(corners) # Draws the corners on picture # cv2.drawChessboardCorners(img, (7, 9), cornersnew, retval) # cv2.imshow('img', img) # cv2.waitKey() else: print("no corners found in " + image, file=sys.stderr) cv2.destroyAllWindows() _, cameramatrix, distortioncoefficients, _, _ = cv2.calibrateCamera( rw_points, image_points, img_gray.shape[::-1], None, None ) return cameramatrix, distortioncoefficients
def get_callibration_stuff(): criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) cap = cv2.VideoCapture('pictures/ChessboardPattern/11.mp4') nx, ny = 8, 6 objp = np.zeros((8 * 6, 3), np.float32) objp[:, :2] = np.mgrid[0:8, 0:6].T.reshape(-1, 2) objpoints = [] # 3d point in real world space imgpoints = [] # 2d points in image plane. fps = get_fps(cap) num_frames = get_frames(cap) frames_with_corners = 0 def skip_frame(video): ret2, frame2 = video.read() if ret2: curr_frame = video.get(cv2.CAP_PROP_POS_FRAMES) if curr_frame <= num_frames: cap.set(cv2.CAP_PROP_POS_FRAMES, curr_frame + 0.5 * fps) return frame2 while (cap.isOpened()): ret, frame = cap.read() if ret == True: frame = skip_frame(cap) r_frame_bw = get_resized_and_bw(frame, 40) found_corners, corners = cv2.findChessboardCorners( r_frame_bw, (nx, ny), None) if found_corners: frames_with_corners += 1 objpoints.append(objp) corners2 = cv2.cornerSubPix(r_frame_bw, corners, (11, 11), (-1, -1), criteria) imgpoints.append(corners2) if frames_with_corners == 16: break cap.release() cv2.destroyAllWindows() ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, r_frame_bw.shape[::-1], None, None) return ret, mtx, dist, rvecs, tvecs
def AxisAndBox(): # 读取相机参数 with open(path2+'//calibration_parameters.yaml') as file: documents = yaml.full_load(file) data = list(documents.values()) mtx = np.asarray(data[2]) #dist = np.asarray(data[1]) criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) objp = np.zeros((13 * 6, 3), np.float32) objp[:, :2] = np.mgrid[0:13, 0:6].T.reshape(-1, 2) axis = np.float32([[0, 0, 0], [0, 3, 0], [3, 3, 0], [3, 0, 0], [0, 0, -3], [0, 3, -3], [3, 3, -3], [3, 0, -3]]) axis2 = np.float32([[4, 0, 0], [0, 4, 0], [0, 0, -4]]).reshape(-1, 3) num = 0 # 计数器 images2 = glob.glob(path2+'//tianyi_gao_undistorted*.jpg') for fname in images2: num = num+1 img = cv2.imread(fname) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, (13, 6), None) if ret is True: corners2 = cv2.cornerSubPix( gray, corners, (11, 11), (-1, -1), criteria) # 计算外参,估计相机位姿 _, rvecs, tvecs = cv2.solvePnP(objp, corners2, mtx, None) # 将3-D点投影到像平面 imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs, mtx, None) imgpts2, jac2 = cv2.projectPoints(axis2, rvecs, tvecs, mtx, None) img = drawBox(img, corners2, imgpts) img = drawAxis(img, corners2, imgpts2) cv2.imwrite(path2+"//tianyi_gao_"+str(num)+".jpg", img) if len(images2) < 16: # 图片过多时,不在UI中展示 cv2.namedWindow('press any key to continue', cv2.WINDOW_NORMAL) cv2.imshow('press any key to continue', img) cv2.waitKey(0) print('Draw Done') cv2.destroyAllWindows() return num, path2#返回处理图片数和结果存储路径
def calibrate(images, grid=(9, 6)): """ Parameter: images: a image grid: Return: object_points: img_points: """ object_points = [] img_points = [] for img in images: object_point = np.zeros((grid[0]*grid[1], 3), np.float32) object_point[:, :2] = np.mgrid[0:grid[0], 0:grid[1]].T.reshape(-1, 2) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, grid, None) if ret: object_points.append(object_point) img_points.append(corners) return object_points, img_points
def _update_img_obj_points(self, index: int, original_image: np.ndarray, gray_scale_img: np.ndarray, is_dev: bool): found_corners, corners = cv2.findChessboardCorners( gray_scale_img, self.pattern_size, None) calibrated_image = copy.copy(original_image) if found_corners is True: self._objpoints.append(self._objp) self._imgpoints.append(corners) cv2.drawChessboardCorners(calibrated_image, self.pattern_size, corners, found_corners) cv2.imwrite('camera_cal_output/calibrated-' + str(index) + '.jpg', calibrated_image) if is_dev is True: _, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10)) ax1.set_title('Original Image') ax1.imshow(original_image) ax2.set_title('Image clibration') ax2.imshow(calibrated_image)
def findcorners(self): plt.close('all') # termination criteria criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001) # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0) objp = np.zeros((11 * 8, 3), np.float32) objp[:, :2] = np.mgrid[0:11, 0:8].T.reshape(-1, 2) # Arrays to store object points and image points from all the images. objpoints = [] # 3d point in real world space imgpoints = [] # 2d points in image plane. for i in range(1, 16): img_name = str(i) + '.bmp' fname = os.path.join('Datasets/Q2_Image', img_name) img = cv.imread(fname) gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) # Find the chess board corners ret, corners = cv.findChessboardCorners(gray, (11, 8), None) # If found, add object points, image points (after refining them) if ret == True: objpoints.append(objp) corners2 = cv.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) imgpoints.append(corners) # Draw and display the corners cv.drawChessboardCorners(img, (11, 8), corners2, ret) plt_img = img[:, :, ::-1] plt.figure(fname) plt.imshow(plt_img) ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera( objpoints, imgpoints, gray.shape[::-1], None, None) np.savez('output.npz', mtx, dist, rvecs, tvecs) np.savez('img_obj_points.npz', imgpoints, objpoints) plt.show()
def calib(imgpath,camroot,nx,ny): # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0) objp = np.zeros((ny * nx, 3), np.float32) objp[:,:2] = np.mgrid[0:nx, 0:ny].T.reshape(-1,2)*290 # Arrays to store object points and image points from all the images. objpoints = [] # 3d points in real world space imgpoints = [] # 2d points in image plane. images = glob(imgpath+'/*.jpg') if len(images) > 0: print("images num for calibration : ", len(images)) else: print("No image for calibration.") return ret_count = 0 for _, fname in enumerate(images): img = cv2.imread(fname) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) img_size = (img.shape[1], img.shape[0]) # Find the chessboard corners ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None) #cv2.drawChessboardCorners(img,(nx,ny),corners,ret) # If found, add object points, image points if ret == True: ret_count += 1 objpoints.append(objp) imgpoints.append(corners) print("read image:",ret_count) if len(objpoints)==0: print("failed to find corners") return ret, cameraMatrix, distCoeffs, _, _ = cv2.calibrateCamera(objpoints, imgpoints,img_size, None, None) print('Do calibration successfully') np.savetxt(camroot+"cameraMatrix.txt",cameraMatrix,fmt="%.18f",delimiter=',') np.savetxt(camroot+"distCoeffs.txt",distCoeffs,fmt="%.18f",delimiter=',') return ret,cameraMatrix, distCoeffs
criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001) # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0) objp = np.zeros((11 * 8, 3), np.float32) objp[:, :2] = np.mgrid[0:11, 0:8].T.reshape(-1, 2) # Arrays to store object points and image points from all the images. objpoints = [] # 3d point in real world space imgpoints = [] # 2d points in image plane. for i in range(1, 2): img_name = str(i) + '.bmp' fname = os.path.join('Datasets/Q2_Image', img_name) img = cv.imread(fname) gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) # Find the chess board corners ret, corners = cv.findChessboardCorners(gray, (11, 8), None) # If found, add object points, image points (after refining them) if ret == True: objpoints.append(objp) corners2 = cv.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) imgpoints.append(corners) # Draw and display the corners cv.drawChessboardCorners(img, (11, 8), corners2, ret) ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera( objpoints, imgpoints, gray.shape[::-1], None, None) h, w = img.shape[:2] newcameramtx, roi = cv.getOptimalNewCameraMatrix( mtx, dist, (w, h), 1, (w, h)) # print(roi)
objp[:,:2] = np.mgrid[0:chessboard_size[0], 0:chessboard_size[1]].T.reshape(-1,2) #read images calibration_paths = glob.glob('./calibration_images/*') #Iterate over images to find intrinsic matrix for image_path in tqdm(calibration_paths): #Load image image = cv2.imread(image_path) gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) print("Image loaded, Analyzing...") #find chessboard corners ret,corners = cv2.findChessboardCorners(gray_image, chessboard_size, None) if ret == True: print("Chessboard detected!") print(image_path) #define criteria for subpixel accuracy criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) #refine corner location (to subpixel accuracy) based on criteria. cv2.cornerSubPix(gray_image, corners, (5,5), (-1,-1), criteria) obj_points.append(objp) img_points.append(corners) #Calibrate camera ret, K, dist, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points,gray_image.shape[::-1], None, None) #Save parameters into numpy file
objpoints = [] # 在世界坐标系中的三维点 imgpoints = [] # 在图像平面的二维点 #加载pic文件夹下所有的jpg图像 images = glob.glob('D:\\CODE\\Python\\a\\*.jpg') # 拍摄的十几张棋盘图片所在目录 i=0 for fname in images: img = cv2.imread(fname) # 获取画面中心点 #获取图像的长宽 h1, w1 = img.shape[0], img.shape[1] gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) u, v = img.shape[:2] # 找到棋盘格角点 ret, corners = cv2.findChessboardCorners(gray, (w,h),None) # 如果找到足够点对,将其存储起来 if ret == True: print("i:", i) i = i+1 # 在原角点的基础上寻找亚像素角点 cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria) #追加进入世界三维点和平面二维点中 objpoints.append(objp) imgpoints.append(corners) # 将角点在图像上显示 cv2.drawChessboardCorners(img, (w,h), corners, ret) cv2.namedWindow('findCorners', cv2.WINDOW_NORMAL) cv2.resizeWindow('findCorners', 640, 480) cv2.imshow('findCorners',img) cv2.waitKey(200)
print("Hit n to accept the image, hit q to ignore it") # Call all saved images for i in range( LOWER_INDEX, UPPER_INDEX ): # Put the amount of pictures you have taken for the calibration inbetween range(0,?) wenn starting from the image number 0 t = str(i) print(t) originL = cv2.imread(PATH_CALIBRATION_IMAGE_CAM1 + t + '.png') originR = cv2.imread(PATH_CALIBRATION_IMAGE_CAM2 + t + '.png') ChessImaL = cv2.imread(PATH_CALIBRATION_IMAGE_CAM1 + t + '.png', 0) # Left side ChessImaR = cv2.imread(PATH_CALIBRATION_IMAGE_CAM2 + t + '.png', 0) # Right side retR, cornersR = cv2.findChessboardCorners( ChessImaR, (ChessWidth, ChessHeight), None) # Define the number of chees corners we are looking for retL, cornersL = cv2.findChessboardCorners(ChessImaL, (ChessWidth, ChessHeight), None) # Left side cv2.drawChessboardCorners(originR, (ChessWidth, ChessHeight), cornersR, retR) cv2.drawChessboardCorners(originL, (ChessWidth, ChessHeight), cornersL, retL) while True: cv2.imshow('Corner', np.hstack((originL, originR))) if (cv2.waitKey(1) & 0xFF == ord('n')): print("Couple with " + t + " has been added") if (True == retR) & (True == retL): objpoints.append(objp)
def calibrate(): #棋盘角点数col*row col = 13 row = 6 criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) objp = np.zeros((row * col, 3), np.float32) # 用于标定的棋盘每个方格边长为22mm objp[:, :2] = 22*np.mgrid[0:col, 0:row].T.reshape(-1, 2) objpoints = [] # 世界坐标系下的点坐标 imgpoints = [] # 像素平面坐标系下的点坐标 print("请选择标定用到的照片所在的文件夹", "\n") root = tkinter.Tk() root.withdraw() global path # 用于标定的照片所在目录 path = tkinter.filedialog.askdirectory( title="选择标定用到的照片所在的文件夹") # 选择标定用到的照片所在的文件夹 images = glob.glob(path+"/*.jpg") found = 0 # 记录用于标定的图像数目 for k, fname in enumerate(images): img = cv2.imread(fname) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, (col, row), None) # 角点检测 if ret is True: print("读取", fname) objpoints.append(objp) # 角点检测精度会影响标定的精度 corners2 = cv2.cornerSubPix( gray, corners, (11, 11), (-1, -1), criteria)#亚像素角点位置 # corners2=corners #_,corners2=cv2.find4QuadCornerSubpix(gray, corners, (11, 11)) imgpoints.append(corners2) img = cv2.drawChessboardCorners(img, (col, row), corners2, ret)#标记角点 found += 1 if len(images) < 16: # 图片过多时,不在UI中展示,避免弹窗过多 cv2.namedWindow('press any key to continue', cv2.WINDOW_NORMAL) cv2.imshow('press any key to continue', img) cv2.waitKey(0) #image_name = path2 + "//corner"+str(found) + '.png' #cv2.imwrite(image_name, img) #存储已标出角点的照片 global path2 # 存放结果的目录(含记录相机参数的文件,和畸变矫正后的照片,3-D box照片) path2 = tkinter.filedialog.askdirectory( title="选择结果存放的文件夹(应与用于标定的照片所在的文件夹不同)") # 选择结果存放的文件夹 print("Number of images used for calibration: ", found) # 相机标定 ret2, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None) print("reprojection error:", ret2) print("内参矩阵:", mtx) print("畸变系数:", dist) print("旋转向量:", rvecs) print("平移向量:", tvecs) images = glob.glob(path+"//*.jpg") for i, fname in enumerate(images): img = cv2.imread(fname) if img is None: continue h, w = img.shape[:2] newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w, h), 1, (w, h)) dst = cv2.undistort(img, mtx, dist, None, newcameramtx) # 矫正畸变 x, y, w, h = roi dst = dst[y:y + h, x:x + w]#裁剪 outpath = path2+"//tianyi_gao_undistorted" + str(i + 1) + ".jpg" cv2.imwrite(outpath, dst) print("新内参矩阵:", newcameramtx) data = { 'camera_matrix': np.asarray(mtx).tolist(), 'dist_coeff': np.asarray(dist).tolist(), 'new_camera_matrix': np.asarray(newcameramtx).tolist(), 'rvecs': np.asarray(rvecs).tolist(), 'tvecs': np.asarray(tvecs).tolist(), 'reprojection_error': np.asarray(ret2).tolist() } # 存储相机参数(yaml) with open(path2+"//calibration_parameters.yaml", "w") as f: yaml.dump(data, f) # 存储相机参数(txt) with open(path2+"//tianyi_gao_cam.txt", "w") as f2: name = list(data.keys()) value = list(data.values()) for i in range(len(name)): f2.write(name[i] + ":" + "\n" + str(value[i]) + "\n") print('Calibrate Done') cv2.destroyAllWindows() return mtx, dist, rvecs, tvecs, ret2, path2
# Start calibration from the camera print('Starting calibration for the 2 cameras... ') print(PATH_CALIBRATION_IMAGE_CAM1) print("Hit n to accept the image, hit q to ignore it") # Call all saved images for i in range( LOWER_INDEX, UPPER_INDEX ): # Put the amount of pictures you have taken for the calibration inbetween range(0,?) wenn starting from the image number 0 t = str(i) print(t) originL = cv2.imread(PATH_CALIBRATION_IMAGE_CAM1 + t + '.png') ChessImaL = cv2.imread(PATH_CALIBRATION_IMAGE_CAM1 + t + '.png', 0) # Left side retL, cornersL = cv2.findChessboardCorners(ChessImaL, (ChessWidth, ChessHeight), None) # Left side cv2.drawChessboardCorners(originL, (ChessWidth, ChessHeight), cornersL, retL) while True: cv2.imshow('Corner', originL) if (cv2.waitKey(1) & 0xFF == ord('n')): print("Couple with " + t + " has been added") if (True == retL): objpoints.append(objp) cv2.cornerSubPix(ChessImaL, cornersL, (11, 11), (-1, -1), criteria) imgpointsL.append(cornersL) break elif (cv2.waitKey(2) & 0xFF == ord('q')):
def calibration(images): # termination criteria criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001) # prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0) objp = np.zeros((7 * 10, 3), np.float32) objp[:, :2] = np.mgrid[0:7, 0:10].T.reshape(-1, 2) # Arrays to store object points and image points from all the images. objpoints = [] # 3d point in real world space imgpoints = [] # 2d points in image plane. for fname in images: img = cv.imread(fname) gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) # Find the chess board corners ret, corners = cv.findChessboardCorners(gray, (7, 10), None) # If found, add object points, image points (after refining them) if ret == True: objpoints.append(objp) corners2 = cv.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) imgpoints.append(corners) # Draw and display the corners cv.drawChessboardCorners(img, (7, 10), corners2, ret) img_resized = cv.resize(img, (1400, 700)) cv.imshow('img', img_resized) cv.waitKey(10) cv.destroyAllWindows() ret, K, dist, rvecs, tvecs, std_int, std_ext, pVE = \ cv.calibrateCameraExtended(objpoints, imgpoints, gray.shape[::-1], None, None) mean_error = [] error_vecs = np.zeros( (70 * len(images), 2)) # vertical stack of [x, y] errors for all points in all pictures for i in range(len(objpoints)): # calculating errors imgpoints2, _ = cv.projectPoints(objpoints[i], rvecs[i], tvecs[i], K, dist) error = cv.norm(imgpoints[i], imgpoints2, cv.NORM_L2) / len(imgpoints2) mean_error.append(error) imgpoints2 = np.array(imgpoints2) imgpoints2 = imgpoints2[:, 0, :] imgpoints1 = np.array(imgpoints[i]) imgpoints1 = imgpoints1[:, 0, :] error_vecs[i * 70:(i + 1) * 70, :] = imgpoints1 - imgpoints2 fig = plt.figure(1) # mean reprojection error plot img_nr = [f"{i+1}" for i in range(len(images))] plt.bar(img_nr, mean_error) plt.ylabel("mean reprojection error") plt.xlabel("image number") plt.savefig("Calibration_errors") plt.show() fig2 = plt.figure(2) plt.scatter(error_vecs[:, 0], error_vecs[:, 1]) plt.ylabel("y error") plt.xlabel("x error") plt.savefig("Reprojection_scatter") plt.show() print('Standard errors') print('Focal length and principal point') print('--------------------------------') print('fx: %g +/- %g' % (K[0, 0], std_int[0])) print('fy: %g +/- %g' % (K[1, 1], std_int[1])) print('cx: %g +/- %g' % (K[0, 2], std_int[2])) print('cy: %g +/- %g' % (K[1, 2], std_int[3])) print('Distortion coefficients') print('--------------------------------') print('k1: %g +/- %g' % (dist[0, 0], std_int[4])) print('k2: %g +/- %g' % (dist[0, 1], std_int[5])) print('p1: %g +/- %g' % (dist[0, 2], std_int[6])) print('p2: %g +/- %g' % (dist[0, 3], std_int[7])) print('k3: %g +/- %g' % (dist[0, 4], std_int[8])) np.savetxt('cam_matrix.txt', K) np.savetxt('dist.txt', dist) np.savetxt('stdInt.txt', std_int) np.savetxt('stdExt.txt', std_ext)
ret2, frame2 = video.read() if ret2: curr_frame = video.get(cv2.CAP_PROP_POS_FRAMES) if curr_frame <= num_frames: cap.set(cv2.CAP_PROP_POS_FRAMES, curr_frame + 0.5 * fps) return frame2 while (cap.isOpened()): ret, frame = cap.read() if ret == True: frame = skip_frame(cap) r_frame = cv2_helpers.get_resized(frame, 40) r_frame_bw = cv2_helpers.get_resized_and_bw(frame, 40) cv2.imshow("something", r_frame) found_corners, corners = cv2.findChessboardCorners( r_frame_bw, (nx, ny), None) if found_corners: frames_with_corners += 1 objpoints.append(objp) corners2 = cv2.cornerSubPix(r_frame_bw, corners, (11, 11), (-1, -1), criteria) imgpoints.append(corners2) new_img = cv2.drawChessboardCorners(r_frame, (nx, ny), corners, ret) cv2.imshow("test", new_img) if frames_with_corners == 16: break cap.release() cv2.destroyAllWindows()