（单/双目）图像标定全流程（C++/Opencv实现）---代码篇

拼搏现实的明天。 2022-04-13 04:20 1111阅读 1赞

代码分为几个部分，c++部分使用g++进行编译

### （1）双目摄像头标定图像数据集收集保存 ###

//image_save.cpp
    #include <iostream>
    #include <opencv2/opencv.hpp>
     
    using namespace std;
    using namespace cv;
     
     
    int main()
    { 
    
        cv::VideoCapture capl(0);
        cv::VideoCapture capr(1);
     
        int i = 0;
     
        cv::Mat cam_left;
        cv::Mat cam_right;
     
        char filename_l[15];
        char filename_r[15];
        while(capl.read(cam_left) && capr.read(cam_right))
        { 
            cv::imshow("cam_left", cam_left);
            cv::imshow("cam_right", cam_right);
    	
            char c = cv::waitKey(1);
            char s[40];
            
            if(c==' ') //按空格采集图像
            { 
    	        sprintf(filename_l, "left%d.jpg",i);
                imwrite(filename_l, cam_left);
    	        sprintf(filename_r, "right%d.jpg",i++);
                imwrite(filename_r, cam_right);
                //printf(s, "%s%d%s\n", "the ",i++,"th image");
                cout << "save the "<< i <<"th image\n"<< endl;
            }
            if(c=='q' || c=='Q') // 按q退出
            { 
                break;
            }
        }
     
        return 0;
    }

显示结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][20181127114541109.png]  
![在这里插入图片描述][20181127114606690.png]

### （2）单目标定 ###

//calibration.cpp
    #include <iostream>
    #include <sstream>
    #include <time.h>
    #include <stdio.h>
    #include <fstream>
    
    #include <opencv2/core/core.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/calib3d/calib3d.hpp>
    #include <opencv2/highgui/highgui.hpp>
    
    using namespace cv;
    using namespace std;
    #define calibration
    
    int main()
    { 
    #ifdef calibration
    
    	ifstream fin("right_img.txt");             /* 标定所用图像文件的路径 */
    	ofstream fout("caliberation_result_right.txt");  /* 保存标定结果的文件 */
    
    	// 读取每一幅图像，从中提取出角点，然后对角点进行亚像素精确化
    	int image_count = 0;  /* 图像数量 */
    	Size image_size;      /* 图像的尺寸 */
    	Size board_size = Size(11,8);             /* 标定板上每行、列的角点数 */
    	vector<Point2f> image_points_buf;         /* 缓存每幅图像上检测到的角点 */
    	vector<vector<Point2f>> image_points_seq; /* 保存检测到的所有角点 */
    	string filename;      // 图片名
    	vector<string> filenames;
    
    	while (getline(fin, filename))
    	{ 
    		++image_count;
    		Mat imageInput = imread(filename);
    		filenames.push_back(filename);
    
    		// 读入第一张图片时获取图片大小
    		if (image_count == 1)
    		{ 
    			image_size.width = imageInput.cols;
    			image_size.height = imageInput.rows;
    		}
    
    		/* 提取角点 */
    		if (0 == findChessboardCorners(imageInput, board_size, image_points_buf))
    		{ 
    			//cout << "can not find chessboard corners!\n"; // 找不到角点
    			cout << "**" << filename << "** can not find chessboard corners!\n";
    			exit(1);
    		}
    		else
    		{ 
    			Mat view_gray;
    			cvtColor(imageInput, view_gray, CV_RGB2GRAY);  // 转灰度图
    
    			/* 亚像素精确化 */
    			// image_points_buf 初始的角点坐标向量，同时作为亚像素坐标位置的输出
    			// Size(5,5) 搜索窗口大小
    			// （-1，-1）表示没有死区
    			// TermCriteria 角点的迭代过程的终止条件, 可以为迭代次数和角点精度两者的组合
    			cornerSubPix(view_gray, image_points_buf, Size(5, 5), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
    
    			image_points_seq.push_back(image_points_buf);  // 保存亚像素角点
    
    			/* 在图像上显示角点位置 */
    			drawChessboardCorners(view_gray, board_size, image_points_buf, false); // 用于在图片中标记角点
    
    			imshow("Camera Calibration", view_gray);       // 显示图片
    
    			waitKey(500); //暂停0.5S 
    		}
    	}
    	int CornerNum = board_size.width * board_size.height;  // 每张图片上总的角点数
    
    	//-------------以下是摄像机标定------------------
    
    	/*棋盘三维信息*/
    	Size square_size = Size(60, 60);         /* 实际测量得到的标定板上每个棋盘格的大小 */
    	vector<vector<Point3f>> object_points;   /* 保存标定板上角点的三维坐标 */
    
    	/*内外参数*/
    	Mat cameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));  /* 摄像机内参数矩阵 */
    	vector<int> point_counts;   // 每幅图像中角点的数量
    	Mat distCoeffs = Mat(1, 5, CV_32FC1, Scalar::all(0));       /* 摄像机的5个畸变系数：k1,k2,p1,p2,k3 */
    	vector<Mat> tvecsMat;      /* 每幅图像的旋转向量 */
    	vector<Mat> rvecsMat;      /* 每幅图像的平移向量 */
    
    	/* 初始化标定板上角点的三维坐标 */
    	int i, j, t;
    	for (t = 0; t<image_count; t++)
    	{ 
    		vector<Point3f> tempPointSet;
    		for (i = 0; i<board_size.height; i++)
    		{ 
    			for (j = 0; j<board_size.width; j++)
    			{ 
    				Point3f realPoint;
    
    				/* 假设标定板放在世界坐标系中z=0的平面上 */
    				realPoint.x = i * square_size.width;
    				realPoint.y = j * square_size.height;
    				realPoint.z = 0;
    				tempPointSet.push_back(realPoint);
    			}
    		}
    		object_points.push_back(tempPointSet);
    	}
    
    	/* 初始化每幅图像中的角点数量，假定每幅图像中都可以看到完整的标定板 */
    	for (i = 0; i<image_count; i++)
    	{ 
    		point_counts.push_back(board_size.width * board_size.height);
    	}
    
    	/* 开始标定 */
    	// object_points 世界坐标系中的角点的三维坐标
    	// image_points_seq 每一个内角点对应的图像坐标点
    	// image_size 图像的像素尺寸大小
    	// cameraMatrix 输出，内参矩阵
    	// distCoeffs 输出，畸变系数
    	// rvecsMat 输出，旋转向量
    	// tvecsMat 输出，位移向量
    	// 0 标定时所采用的算法
    	calibrateCamera(object_points, image_points_seq, image_size, cameraMatrix, distCoeffs, rvecsMat, tvecsMat, 0);
    
    	//------------------------标定完成------------------------------------
    
    	// -------------------对标定结果进行评价------------------------------
    
    	double total_err = 0.0;         /* 所有图像的平均误差的总和 */
    	double err = 0.0;               /* 每幅图像的平均误差 */
    	vector<Point2f> image_points2;  /* 保存重新计算得到的投影点 */
    	fout << "每幅图像的标定误差：\n";
    
    	for (i = 0; i<image_count; i++)
    	{ 
    		vector<Point3f> tempPointSet = object_points[i];
    
    		/* 通过得到的摄像机内外参数，对空间的三维点进行重新投影计算，得到新的投影点 */
    		projectPoints(tempPointSet, rvecsMat[i], tvecsMat[i], cameraMatrix, distCoeffs, image_points2);
    
    		/* 计算新的投影点和旧的投影点之间的误差*/
    		vector<Point2f> tempImagePoint = image_points_seq[i];
    		Mat tempImagePointMat = Mat(1, tempImagePoint.size(), CV_32FC2);
    		Mat image_points2Mat = Mat(1, image_points2.size(), CV_32FC2);
    
    		for (int j = 0; j < tempImagePoint.size(); j++)
    		{ 
    			image_points2Mat.at<Vec2f>(0, j) = Vec2f(image_points2[j].x, image_points2[j].y);
    			tempImagePointMat.at<Vec2f>(0, j) = Vec2f(tempImagePoint[j].x, tempImagePoint[j].y);
    		}
    		err = norm(image_points2Mat, tempImagePointMat, NORM_L2);
    		total_err += err /= point_counts[i];
    		fout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
    	}
    	fout << "总体平均误差：" << total_err / image_count << "像素" << endl << endl;
    
    	//-------------------------评价完成---------------------------------------------
    
    	//-----------------------保存定标结果------------------------------------------- 
    	Mat rotation_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0));  /* 保存每幅图像的旋转矩阵 */
    	fout << "相机内参数矩阵：" << endl;
    	fout << cameraMatrix << endl << endl;
    	fout << "畸变系数：\n";
    	fout << distCoeffs << endl << endl << endl;
    	for (int i = 0; i<image_count; i++)
    	{ 
    		fout << "第" << i + 1 << "幅图像的旋转向量：" << endl;
    		fout << tvecsMat[i] << endl;
    
    		/* 将旋转向量转换为相对应的旋转矩阵 */
    		Rodrigues(tvecsMat[i], rotation_matrix);
    		fout << "第" << i + 1 << "幅图像的旋转矩阵：" << endl;
    		fout << rotation_matrix << endl;
    		fout << "第" << i + 1 << "幅图像的平移向量：" << endl;
    		fout << rvecsMat[i] << endl << endl;
    	}
    	fout << endl;
    
    	//--------------------标定结果保存结束-------------------------------
    
    	//----------------------显示定标结果--------------------------------
    
    	Mat mapx = Mat(image_size, CV_32FC1);
    	Mat mapy = Mat(image_size, CV_32FC1);
    	Mat R = Mat::eye(3, 3, CV_32F);
    	string imageFileName;
    	std::stringstream StrStm;
    	for (int i = 0; i != image_count; i++)
    	{ 
    		initUndistortRectifyMap(cameraMatrix, distCoeffs, R, cameraMatrix, image_size, CV_32FC1, mapx, mapy);
    		Mat imageSource = imread(filenames[i]);
    		Mat newimage = imageSource.clone();
    		remap(imageSource, newimage, mapx, mapy, INTER_LINEAR);
    		StrStm.clear();
    		imageFileName.clear();
    		StrStm << i + 1;
    		StrStm >> imageFileName;
    		imageFileName += "_d.jpg";
    		imwrite(imageFileName, newimage);
    	}
    
    	fin.close();
    	fout.close();
    
    #else 
    		/// 读取一副图片，不改变图片本身的颜色类型（该读取方式为DOS运行模式）
    		Mat src = imread("F:\\lane_line_detection\\left_img\\1.jpg");
    		Mat distortion = src.clone();
    		Mat camera_matrix = Mat(3, 3, CV_32FC1);
    		Mat distortion_coefficients;
    
    
    		//导入相机内参和畸变系数矩阵
    		FileStorage file_storage("F:\\lane_line_detection\\left_img\\Intrinsic.xml", FileStorage::READ);
    		file_storage["CameraMatrix"] >> camera_matrix;
    		file_storage["Dist"] >> distortion_coefficients;
    		file_storage.release();
    
    		//矫正
    		cv::undistort(src, distortion, camera_matrix, distortion_coefficients);
    
    		cv::imshow("img", src);
    		cv::imshow("undistort", distortion);
    		cv::imwrite("undistort.jpg", distortion);
    
    		cv::waitKey(0);
    #endif // DEBUG
    	return 0;
    }

获得的结果  
![在这里插入图片描述][20181127112900886.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70 1]  
**进行双目标定之前，先分别确定左右摄像头的内参和外参。**

### 双目标定 ###

//双目相机标定 stereo_calib.cpp
    #include <opencv2/core/core.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/calib3d/calib3d.hpp>
    #include <opencv2/highgui/highgui.hpp>
    
    #include <vector>
    #include <string>
    #include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    
    #include <opencv2/opencv.hpp>
    //#include <cv.h>
    //#include <cv.hpp>
    
    using namespace std;
    using namespace cv;
    //摄像头的分辨率
    const int imageWidth = 640;
    const int imageHeight = 480;
    //横向的角点数目
    const int boardWidth = 11;
    //纵向的角点数目
    const int boardHeight = 8;
    //总的角点数目
    const int boardCorner = boardWidth * boardHeight;
    //相机标定时需要采用的图像帧数
    const int frameNumber = 8;
    //标定板黑白格子的大小 单位是mm
    const int squareSize = 60;
    //标定板的总内角点
    const Size boardSize = Size(boardWidth, boardHeight);
    Size imageSize = Size(imageWidth, imageHeight);
    
    Mat R, T, E, F;
    //R旋转矢量 T平移矢量 E本征矩阵 F基础矩阵
    vector<Mat> rvecs; //R
    vector<Mat> tvecs; //T
    //左边摄像机所有照片角点的坐标集合
    vector<vector<Point2f>> imagePointL;
    //右边摄像机所有照片角点的坐标集合
    vector<vector<Point2f>> imagePointR;
    //各图像的角点的实际的物理坐标集合
    vector<vector<Point3f>> objRealPoint;
    //左边摄像机某一照片角点坐标集合
    vector<Point2f> cornerL;
    //右边摄像机某一照片角点坐标集合
    vector<Point2f> cornerR;
    
    Mat rgbImageL, grayImageL;
    Mat rgbImageR, grayImageR;
    
    Mat intrinsic;
    Mat distortion_coeff;
    //校正旋转矩阵R，投影矩阵P，重投影矩阵Q
    Mat Rl, Rr, Pl, Pr, Q;
    //映射表
    Mat mapLx, mapLy, mapRx, mapRy;
    Rect validROIL, validROIR;
    //图像校正之后，会对图像进行裁剪，其中，validROI裁剪之后的区域
    /*事先标定好的左相机的内参矩阵 fx 0 cx 0 fy cy 0 0 1 */
    Mat cameraMatrixL = (Mat_<double>(3,3) << 271.7792785637638, 0, 313.4559554347688,
    	0, 271.9513066781816, 232.7561625477742,
    	0, 0, 1);
    //获得的畸变参数
    Mat distCoeffL = (Mat_<double>(5,1) << -0.3271838086967946, 0.1326861805365006, -0.0008527407221595511, -0.0003398213328658643, -0.02847446149341753);
    /*事先标定好的右相机的内参矩阵 fx 0 cx 0 fy cy 0 0 1 */
    Mat cameraMatrixR = (Mat_<double>(3,3) << 268.4990780091891, 0, 325.75156647688,
    	0, 269.7906504513069, 212.5928387210573,
    	0, 0, 1);
    Mat distCoeffR = (Mat_<double>(5,1) << -0.321298212260166, 0.1215100334221875, -0.0007504391036193558, -1.732473939234179e-05, -0.02234659175488724);
    
    /*计算标定板上模块的实际物理坐标*/
    void calRealPoint(vector<vector<Point3f>>& obj, int boardWidth, int boardHeight, int imgNumber, int squareSize)
    { 
        vector<Point3f> imgpoint;
        for (int rowIndex = 0; rowIndex < boardHeight; rowIndex++)
        { 
            for (int colIndex = 0; colIndex < boardWidth; colIndex++)
            { 
                imgpoint.push_back(Point3f(rowIndex * squareSize, colIndex * squareSize, 0));
            }
        }
        for (int imgIndex = 0; imgIndex < imgNumber; imgIndex++)
        { 
            obj.push_back(imgpoint);
        }
    }
    
    
    
    void outputCameraParam(void)
    { 
    	/*保存数据*/
    	/*输出数据*/
    	FileStorage fs("intrisics.yml", FileStorage::WRITE);
    	if (fs.isOpened())
    	{ 
    		fs << "cameraMatrixL" << cameraMatrixL << "cameraDistcoeffL" << distCoeffL << "cameraMatrixR" << cameraMatrixR << "cameraDistcoeffR" << distCoeffR;
    		fs.release();
    		cout << "cameraMatrixL=:" << cameraMatrixL << endl << "cameraDistcoeffL=:" << distCoeffL << endl << "cameraMatrixR=:" << cameraMatrixR << endl << "cameraDistcoeffR=:" << distCoeffR << endl;
    	}
    	else
    	{ 
    		cout << "Error: can not save the intrinsics!!!!" << endl;
    	}
    
    	fs.open("extrinsics.yml", FileStorage::WRITE);
    	if (fs.isOpened())
    	{ 
    		fs << "R" << R << "T" << T << "Rl" << Rl << "Rr" << Rr << "Pl" << Pl << "Pr" << Pr << "Q" << Q;
    		cout << "R=" << R << endl << "T=" << T << endl << "Rl=" << Rl << endl << "Rr" << Rr << endl << "Pl" << Pl << endl << "Pr" << Pr << endl << "Q" << Q << endl;
    		fs.release();
    	}
    	else
    	{ 
    		cout << "Error: can not save the extrinsic parameters\n";
    	}
    
    }
    
    
    int main(int argc, char* argv[])
    { 
        Mat img;
        int goodFrameCount = 0;
        while (goodFrameCount < frameNumber)
        { 
            char filename[100];
            /*读取左边的图像*/
            sprintf(filename, "/home/crj/calibration/left_img/left%d.jpg", goodFrameCount + 1);
    		
            rgbImageL = imread(filename, CV_LOAD_IMAGE_COLOR);
    		imshow("chessboardL", rgbImageL);
            cvtColor(rgbImageL, grayImageL, CV_BGR2GRAY);
            /*读取右边的图像*/
            sprintf(filename, "/home/crj/calibration/right_img/right%d.jpg", goodFrameCount + 1);
            rgbImageR = imread(filename, CV_LOAD_IMAGE_COLOR);
            cvtColor(rgbImageR, grayImageR, CV_BGR2GRAY);
    
            bool isFindL, isFindR;
            isFindL = findChessboardCorners(rgbImageL, boardSize, cornerL);
            isFindR = findChessboardCorners(rgbImageR, boardSize, cornerR);
            if (isFindL == true && isFindR == true)
            { 
                cornerSubPix(grayImageL, cornerL, Size(5,5), Size(-1,1), TermCriteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 20, 0.1));
                drawChessboardCorners(rgbImageL, boardSize, cornerL, isFindL);
                imshow("chessboardL", rgbImageL);
                imagePointL.push_back(cornerL);
    
                cornerSubPix(grayImageR, cornerR, Size(5,5), Size(-1,-1), TermCriteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 20, 0.1));
                drawChessboardCorners(rgbImageR, boardSize, cornerR, isFindR);
                imshow("chessboardR", rgbImageR);
                imagePointR.push_back(cornerR);
    
                goodFrameCount++;
                cout << "the image" << goodFrameCount << " is good" << endl;
            }
            else
            { 
                cout << "the image is bad please try again" << endl;
            }
            if (waitKey(10) == 'q')
            { 
                break;
            }
        }
    
        //计算实际的校正点的三维坐标，根据实际标定格子的大小来设置
        calRealPoint(objRealPoint, boardWidth, boardHeight, frameNumber, squareSize);
        cout << "cal real successful" << endl;
    
        //标定摄像头
        double rms = stereoCalibrate(objRealPoint, imagePointL, imagePointR,
            cameraMatrixL, distCoeffL,
            cameraMatrixR, distCoeffR,
            Size(imageWidth, imageHeight), R, T, E, F, CALIB_USE_INTRINSIC_GUESS,
            TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, 1e-5));
    
        cout << "Stereo Calibration done with RMS error = " << rms << endl;
    
        stereoRectify(cameraMatrixL, distCoeffL, cameraMatrixR, distCoeffR, imageSize, R, T, Rl, 
            Rr, Pl, Pr, Q, CALIB_ZERO_DISPARITY, -1, imageSize, &validROIL,&validROIR);
        
    
        //摄像机校正映射
        initUndistortRectifyMap(cameraMatrixL, distCoeffL, Rl, Pl, imageSize, CV_32FC1, mapLx, mapLy);
        initUndistortRectifyMap(cameraMatrixR, distCoeffR, Rr, Pr, imageSize, CV_32FC1, mapRx, mapRy);
    
        Mat rectifyImageL, rectifyImageR;
        cvtColor(grayImageL, rectifyImageL, CV_GRAY2BGR);
        cvtColor(grayImageR, rectifyImageR, CV_GRAY2BGR);
    
        imshow("Recitify Before", rectifyImageL);
        cout << "按Q1退出..." << endl;
        //经过remap之后，左右相机的图像已经共面并且行对准了
        Mat rectifyImageL2, rectifyImageR2;
        remap(rectifyImageL, rectifyImageL2, mapLx, mapLy, INTER_LINEAR);
        remap(rectifyImageR, rectifyImageR2, mapRx, mapRy, INTER_LINEAR);
        cout << "按Q2退出..." << endl;
    
        imshow("rectifyImageL", rectifyImageL2);
        imshow("rectifyImageR", rectifyImageR2);
    
        outputCameraParam();
    
        //显示校正结果
        Mat canvas;
        double sf;
        int w,h;
        sf = 600. / MAX(imageSize.width, imageSize.height);
        w = cvRound(imageSize.width * sf);
        h = cvRound(imageSize.height * sf);
        canvas.create(h, w*2, CV_8UC3);
    
        //左图像画到画布上
        Mat canvasPart = canvas(Rect(0, 0, w, h));
        resize(rectifyImageL2, canvasPart, canvasPart.size(), 0, 0, INTER_AREA);
        Rect vroiL(cvRound(validROIL.x*sf), cvRound(validROIL.y*sf),
            cvRound(validROIL.width*sf), cvRound(validROIL.height*sf));
        rectangle(canvasPart, vroiL, Scalar(0, 0, 255), 3, 8);
    
        cout << "Painted ImageL" << endl;
    
        //右图像画到画布上
        canvasPart = canvas(Rect(w, 0, w, h));
        resize(rectifyImageR2, canvasPart, canvasPart.size(), 0, 0, INTER_LINEAR);
        Rect vroiR(cvRound(validROIR.x*sf), cvRound(validROIR.y*sf),
            cvRound(validROIR.width*sf), cvRound(validROIR.height*sf));
        rectangle(canvasPart, vroiR, Scalar(0, 255, 0), 3, 8);
    
        cout << "Painted ImageR" << endl;
    
        //画上对应的线条
        for (int i = 0; i < canvas.rows; i += 16)
            line(canvas, Point(0, i), Point(canvas.cols, i), Scalar(0, 255, 0), 1, 8);
        
        imshow("rectified", canvas);
        
        cout << "wait key" << endl;
        waitKey(0);
        return 0;
    }

结果展示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70 2]  
结果展示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70 3]  
代码较粗糙，后续会加以修改  
参考：  
https://blog.csdn.net/xiao\_\_run/article/details/78887362  
https://blog.csdn.net/hejingkui/article/details/80488763  
应用opencv参考代码的例子 https://blog.csdn.net/a864488081/article/details/78205519

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70]: /images/20220413/6e94b4bf67514ec9a64ba3862bbec359.png
[20181127114541109.png]: /images/20220413/98c7bdc910424977b4c1d250d12a38e7.png
[20181127114606690.png]: /images/20220413/e258157a102e489ea3fc3585ad4b5b53.png
[20181127112900886.png]: /images/20220413/ffe59d8486fc485f9128875329944d7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70 1]: /images/20220413/1cb83a8a84f84d138ebee45878970aba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70 2]: /images/20220413/65a5adda03234c579c78ff85e3ee2c71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4MDE5OTQ_size_16_color_FFFFFF_t_70 3]: /images/20220413/a1c8f389ccb7494c88b714e618d4f4bd.png