1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

import numpy as np
import cv2 as cv
import vvdutils as vv
# 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,6,0)
W_num = 7
H_num = 7
objp = np.zeros((W_num*H_num,3), np.float32)
objp[:,:2] = np.mgrid[0:W_num,0:H_num].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.
img = vv.cv_rgb_imread('undistort.png', 1)
another = img.copy()
# Find the chess board corners
ret, corners = cv.findChessboardCorners(img, (W_num,H_num), None)
# If found, add object points, image points (after refining them)
if ret == True:
    objpoints.append(objp)
    corners2 = cv.cornerSubPix(img,corners, (11,11), (-1,-1), criteria)
    imgpoints.append(corners2)
    # Draw and display the corners
    cv.drawChessboardCorners(img, (W_num, H_num), corners2, ret)
    vv.PIS(img)
ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera(objpoints, imgpoints, img.shape[::-1], None, None)
h,  w = img.shape[:2]
newcameramtx, roi = cv.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))
dst = cv.undistort(another, mtx, dist, None, newcameramtx)
# 也可以进行点映射
# dst=cv.undistortPoints(src, cameraMatrix, distCoeffs[, dst[, R[, P]]])
# build map matrix
map1, map2 = cv.initUndistortRectifyMap(mtx, dist, None, newcameramtx, img.shape[::-1], cv.CV_32FC1)
frame2 = cv.remap(another2, map1, map2, cv.INTER_LINEAR)
vv.PIS([another, 'origin'], [img, 'marked'], [dst, 'undistort'], row_num=1)
pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include<stdio.h>
#include<opencv2/opencv.hpp>
#include<vector>
using namespace std;
using namespace cv;
int main()
{
	Mat srcImage = imread("undistort.png");
	Mat another, another2;
	srcImage.copyTo(another);
	srcImage.copyTo(another2);
	int W_num(7), H_num(7);
	int width = srcImage.cols;
	int height = srcImage.rows;
	Mat corners;
	findChessboardCorners(srcImage, Size(W_num, H_num), corners);
	int corner_num = corners.rows;
	vector<vector<Point2f>> imagePoints;
	vector<Point2f> image_points;
	for (int index(0); index < corner_num; index++) {
		float x = corners.at<float>(index, 0);
		float y = corners.at<float>(index, 1);
		image_points.push_back(Point2f(x, y));
	}
		cv::TermCriteria criteria = cv::TermCriteria(
		cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS,
		30,
		0.001);
	Mat image_gray;
	cv::cvtColor(srcImage, image_gray, cv::COLOR_BGR2GRAY);
	cornerSubPix(image_gray, image_points, Size(30, 30), Size(-1, -1), criteria);
	imagePoints.push_back(image_points);
	vector<vector<Point3f>> objectPoints;
	vector<Point3f> objpoints;
	for (int index1(0); index1 < W_num; index1++)
	{
		for (int index2(0); index2 < H_num; index2++)
		{
			int index = index1 * H_num + index2;
			objpoints.push_back(Point3f(index2, index1, 0));
		}
	}
	objectPoints.push_back(objpoints);
	Size imageSize;
	imageSize = srcImage.size();
	Mat cameraMatrix, distCoeffs;
	vector<Mat> rvecs, tvecs;
	calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs);
		Mat newcameramatrix = getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize);
	Mat dst;
	undistort(another, dst, cameraMatrix, distCoeffs, newcameramatrix);
	Mat map1, map2, R;
	initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newcameramatrix, imageSize, CV_32FC1, map1, map2);
	Mat frame2;
	remap(another2, frame2, map1, map2, INTER_LINEAR);
	return 0;
}