├── MVGlab02_single-view-metrology-main ├── images │ ├── line.jpg │ ├── line'.jpg │ ├── plane.jpg │ ├── chessboard.jpg │ ├── intersection.jpg │ └── chessboard_3D''.png ├── readme.md ├── single_view_metrology.ipynb └── labelme_data │ └── chessboard_plane.json ├── MVGlab03_FandH-estimation-main ├── images │ ├── DSC_0480.JPG │ └── DSC_0481.JPG ├── readme.md └── FandH_estimation.ipynb ├── MVGlab01_camera-calibration-master ├── images │ └── Jietu20200301-091513.jpg ├── readme.md └── camera_calibration.ipynb └── requirements.md /MVGlab02_single-view-metrology-main/images/line.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab02_single-view-metrology-main/images/line.jpg -------------------------------------------------------------------------------- /MVGlab03_FandH-estimation-main/images/DSC_0480.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab03_FandH-estimation-main/images/DSC_0480.JPG -------------------------------------------------------------------------------- /MVGlab03_FandH-estimation-main/images/DSC_0481.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab03_FandH-estimation-main/images/DSC_0481.JPG -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/images/line'.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab02_single-view-metrology-main/images/line'.jpg -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/images/plane.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab02_single-view-metrology-main/images/plane.jpg -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/images/chessboard.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab02_single-view-metrology-main/images/chessboard.jpg -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/images/intersection.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab02_single-view-metrology-main/images/intersection.jpg -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/images/chessboard_3D''.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab02_single-view-metrology-main/images/chessboard_3D''.png -------------------------------------------------------------------------------- /MVGlab01_camera-calibration-master/images/Jietu20200301-091513.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CV-xueba/Total3DExercises/main/MVGlab01_camera-calibration-master/images/Jietu20200301-091513.jpg -------------------------------------------------------------------------------- /requirements.md: -------------------------------------------------------------------------------- 1 | # 《计算机视觉之三维重建篇》 作业代码 2 | 3 | ## 作业内容 4 | 5 | - 作业一：摄像机标定 6 | - 作业二：单视图重建 7 | - 作业三：基础矩阵和单映矩阵估计 8 | 9 | ## 代码测试环境 10 | 11 | > **python == 3.8.11** 12 | > numpy == 1.20.3 13 | > labelme == 4.5.13 14 | > matplotlib == 3.4.3 15 | > open3d == 0.13.0 16 | > scipy == 1.7.1 17 | > ExifRead == 2.3.2 18 | > opencv_python == 4.5.4.58 19 | -------------------------------------------------------------------------------- /MVGlab03_FandH-estimation-main/readme.md: -------------------------------------------------------------------------------- 1 | # Exercise 03. 基础矩阵估计、单应矩阵估计 2 | 3 | ## 实验内容 4 | 5 | 根据所给的函数所求的特征点对应关系，根据归一化八点法求取基本矩阵，根据四点法求取单应矩阵。 6 | 7 | ## 实验提交结果 8 | 9 | 1. 设计文档，包括任务陈述，算法流程说明，实验环境和代码运行方法，实验结果，实验结果分析。 10 | 2. 代码源文件（要求代码注释清晰，可以顺利运行）。 11 | 12 | ## 评分标准 13 | 14 | 1. 设计文档（50分） 15 | - 任务称述清晰——（4 分） 16 | - 算法流程描述清晰——（8 分） 17 | - 实验环境描述清晰——（3 分） 18 | - 实验结果及验证合理——（20 分） 19 | - 实验结果分析合理——（15 分） 20 | 21 | 2. 代码（50分） 22 | - 按照所描述的实验环境可以顺利运行——（10 分） 23 | - 核心函数实现正确——（25 分） 24 | - 注释清晰、代码规范——（15 分） -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/readme.md: -------------------------------------------------------------------------------- 1 | # Exercise 02. 单视图重建 2 | 3 | ## 实验内容 4 | 5 | 根据所提供的符合单视重构要求的单张图片完成单视图重建任务。 6 | 7 | 1. 加载使用 Labelme 工具标注产生的 json 数据，得到标记的平行线、平面交点、垂直面掩模。 8 | 2. 据所标记的平行线在图像上的交点（通过计算得到），估算隐消点和场景中各个平面的隐消线。 9 | 3. 根据由三组正交平行线得到的影消点，计算摄像机参数矩阵（标定）。 10 | 4. 根据三个垂直面对应的隐消线和摄像机矩阵，计算场景平面的法方向（法向量）。 11 | 5. 将平面交线的公共点代入具未知参数 d 的平面方程（设深度 λ=1），计算出各个场景平面到摄像机中心的距离 d。 12 | 6. 将掩模区域中所有 2D 点坐标代入各点对应的场景平面方程（已知 d），计算出 3D 坐标，保存为 ply 文件，即单视图重建完成。 13 | 14 | ## 实验提交结果 15 | 16 | 1. 设计文档，包括任务陈述，算法流程说明，实验环境和代码运行方法，实验结果（其中要包括单视图重构的结果展示截图），实验结果分析。 17 | 2. 代码源文件（要求代码注释清晰，可以顺利运行）。 18 | 19 | ## 评分标准 20 | 21 | 1. 设计文档（50分） 22 | - 任务称述清晰——（4 分） 23 | - 算法流程描述清晰——（8 分） 24 | - 实验环境描述清晰——（3 分） 25 | - 实验结果及验证合理——（20 分） 26 | - 实验结果分析合理——（15 分） 27 | 28 | 2. 代码（50分） 29 | - 按照所描述的实验环境可以顺利运行——（10 分） 30 | - 核心函数实现正确——（25 分） 31 | - 注释清晰、代码规范——（15 分） -------------------------------------------------------------------------------- /MVGlab01_camera-calibration-master/readme.md: -------------------------------------------------------------------------------- 1 | # Exercise 01. 摄像机标定 2 | 3 | ## 实验内容 4 | 5 | 通过 3D 摄像机标定物的单张图像进行摄像机标定。 6 | 7 | 1. 该示例选取网络上的一个立体标定物图片，虽然没有真正的摄像机标定装置，但是可以假设每个小方块的长度和宽度都是单位长度。这与摄像机标定原理并不违背。 8 | 2. 用 Labelme（或具有类似功能的任何其他应用程序）标记一些交叉点，并在世界坐标系中记录对应点的世界坐标。在此示例中，选择三个平面的交线作为世界坐标系的 x，y 和 z 轴，该坐标系遵循右手系。（如 *Jietu20200301-091513.jpg* 中所示）在此示例中，选择了12个点。尽管理论上6个点就足够了，但更多点有助于提高摄像机标定的精确度。在图像中，三个四边形用 Labelme 标记，只有它们的顶点才有用，因为 labelme 只会记录顶点的像素坐标。世界系统中的对应值以粉红色记录在图像中。箭头的方向表示坐标记录的顺序。 9 | 3. 使用选定的点通过课上的方法算出M，K，R，t。 10 | 11 | ## 实验提交结果 12 | 13 | 1. 设计文档，包括任务陈述，算法流程说明，实验环境和代码运行方法，实验结果（使用选定的点通过课上的方法算出M，K，R，t并使用适当的方法对结果进行验证和校准），实验结果分析。 14 | 2. 代码源文件（要求代码注释清晰，可以顺利运行）。 15 | 16 | ## 评分标准 17 | 18 | 1. 设计文档（50分） 19 | - 任务称述清晰——（4 分） 20 | - 算法流程描述清晰——（8 分） 21 | - 实验环境描述清晰——（3 分） 22 | - 实验结果及验证合理——（20 分） 23 | - 实验结果分析合理——（15 分） 24 | 25 | 2. 代码（50分） 26 | - 按照所描述的实验环境可以顺利运行——（10 分） 27 | - 核心函数实现正确——（25 分） 28 | - 注释清晰、代码规范——（15 分） -------------------------------------------------------------------------------- /MVGlab03_FandH-estimation-main/FandH_estimation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第三次课程作业——基础矩阵、单应矩阵估计 " 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 任务 \n", 15 | "\n", 16 | "- 根据归一化八点法求取基本矩阵\n", 17 | "- 根据四点法求取单应矩阵\n", 18 | "- 以 images 文件夹里的 **SDC_0480.JPG** 和 **DSC_0481.JPG** 两幅图片为例\n", 19 | "\n", 20 | "
\n", 21 | "\n", 22 | "\n", 23 | "
" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "## 示例代码" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "- **图像信息提取函数（SIFT特征点和EXIF信息）**" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 1, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "class FeatureProcess:\n", 47 | " \"\"\"\n", 48 | " Simple SIFT feature process\n", 49 | " \"\"\"\n", 50 | "\n", 51 | " def __init__(self, image):\n", 52 | " \"\"\"\n", 53 | " Init\n", 54 | " :param image: (np.ndarray): Image in RGB\n", 55 | " \"\"\"\n", 56 | " self.image = image\n", 57 | " self.gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)\n", 58 | " self.keypoints = None\n", 59 | " self.descriptors = None\n", 60 | "\n", 61 | " def extract_features(self):\n", 62 | " \"\"\"\n", 63 | " Extract SIFT features in image.\n", 64 | " :return: (list, np.ndarray): keypoints, descriptors in image\n", 65 | " \"\"\"\n", 66 | " sift = cv2.SIFT_create()\n", 67 | " keypoints, descriptors = sift.detectAndCompute(self.gray, None)\n", 68 | "\n", 69 | " if len(keypoints) <= 20:\n", 70 | " return None, None\n", 71 | " else:\n", 72 | " self.keypoints = keypoints\n", 73 | " self.descriptors = descriptors\n", 74 | " return keypoints, descriptors\n", 75 | "\n", 76 | "class PhotoExifInfo:\n", 77 | " \"\"\"\n", 78 | " Extract photo exif info\n", 79 | " \"\"\"\n", 80 | "\n", 81 | " def __init__(self, photo_path):\n", 82 | " \"\"\"\n", 83 | " init\n", 84 | " :param photo_path: (str): photo path\n", 85 | " \"\"\"\n", 86 | " self.photo_path = photo_path\n", 87 | " self.focal_length = None\n", 88 | " self.image_width = None\n", 89 | " self.image_length = None\n", 90 | " self.sensor_pixel_size = None\n", 91 | "\n", 92 | " def get_tags(self):\n", 93 | " \"\"\"\n", 94 | " Get tags with interested info\n", 95 | " :return: None\n", 96 | " \"\"\"\n", 97 | " image_content = open(self.photo_path, 'rb')\n", 98 | " tags = exifread.process_file(image_content)\n", 99 | " self.focal_length = float(\n", 100 | " tags['EXIF FocalLength'].values[0].num) / float(tags['EXIF FocalLength'].values[0].den)\n", 101 | " self.image_width = float(tags['EXIF ExifImageWidth'].values[0])\n", 102 | " self.image_length = float(tags['EXIF ExifImageLength'].values[0])\n", 103 | " self.sensor_pixel_size = tags['MakerNote SensorPixelSize']\n", 104 | "\n", 105 | " def get_intrinsic_matrix(self):\n", 106 | " \"\"\"\n", 107 | " Get intrinsic matrix of photo's camera\n", 108 | " :return: (np.ndarray): intrinsic matrix K\n", 109 | " \"\"\"\n", 110 | " K = np.zeros([3, 3])\n", 111 | " dx = self.sensor_pixel_size.values[0].num / self.sensor_pixel_size.values[0].den / self.image_width\n", 112 | " dy = self.sensor_pixel_size.values[1].num / self.sensor_pixel_size.values[1].den / self.image_length\n", 113 | " fu = self.focal_length / dx\n", 114 | " fv = self.focal_length / dy\n", 115 | " u0 = self.image_width / 2\n", 116 | " v0 = self.image_length / 2\n", 117 | " K[0][0] = fu\n", 118 | " K[1][1] = fv\n", 119 | " K[0][2] = u0\n", 120 | " K[1][2] = v0\n", 121 | " K[2][2] = 1\n", 122 | " return K\n", 123 | "\n", 124 | " def get_area(self):\n", 125 | " \"\"\"\n", 126 | " Get area of photo\n", 127 | " :return: (int): area\n", 128 | " \"\"\"\n", 129 | " return int(self.image_width * self.image_length)\n", 130 | "\n", 131 | " def get_diam(self):\n", 132 | " \"\"\"\n", 133 | " Get diam of photo\n", 134 | " :return: (int): diam\n", 135 | " \"\"\"\n", 136 | " return int(max(self.image_width, self.image_length))\n", 137 | "\n", 138 | "def build_img_info(img_root):\n", 139 | " \"\"\"\n", 140 | " Get info(img,feat,K) from img\n", 141 | " :param img_root: (str): images root\n", 142 | " :return: (list[np.ndarray], list[dict], list[np.ndarray]): info from img\n", 143 | " \"\"\"\n", 144 | " imgs = []\n", 145 | " feats = []\n", 146 | " K = []\n", 147 | " for i, name in enumerate(os.listdir(img_root)):\n", 148 | " if '.jpg' in name or '.JPG' in name:\n", 149 | " path = os.path.join(img_root, name)\n", 150 | " img = cv2.imread(path)\n", 151 | " imgs.append(img)\n", 152 | " feature_process = FeatureProcess(img)\n", 153 | " kpt, des = feature_process.extract_features()\n", 154 | " photo_info = PhotoExifInfo(path)\n", 155 | " photo_info.get_tags()\n", 156 | " K.append(photo_info.get_intrinsic_matrix())\n", 157 | " A = photo_info.get_area()\n", 158 | " D = photo_info.get_diam()\n", 159 | " feats.append({'kpt': kpt, 'des': des, 'A': A, 'D': D})\n", 160 | " return imgs, feats, K" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "- **归一化八点法和四点法（基本矩阵和单应矩阵）**" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 2, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "def get_matches(des_query, des_train):\n", 177 | " \"\"\"\n", 178 | " Match features between query and train\n", 179 | " :param des_query: (np.ndarray): query descriptors\n", 180 | " :param des_train: (np.ndarray): train descriptors\n", 181 | " :return: (list[cv2.DMatch]): Match info\n", 182 | " \"\"\"\n", 183 | " bf = cv2.BFMatcher(cv2.NORM_L2)\n", 184 | " matches = bf.knnMatch(des_query, des_train, k=2)\n", 185 | "\n", 186 | " good = []\n", 187 | " for m, m_ in matches:\n", 188 | " # Ratio is 0.6 ,which to remain enough features\n", 189 | " if m.distance < 0.6 * m_.distance:\n", 190 | " good.append(m)\n", 191 | " return good\n", 192 | "\n", 193 | "def get_match_point(p, p_, matches):\n", 194 | " \"\"\"\n", 195 | " Find matched keypoints\n", 196 | " :param p: (list[cv2.KeyPoint]): query keypoints\n", 197 | " :param p_: (list[cv2.KeyPoint]): train keypoints\n", 198 | " :param matches: (list[cv2.DMatch]): match info between query and train\n", 199 | " :return: (np.ndarray, np.ndarray): matched keypoints between query and train\n", 200 | " \"\"\"\n", 201 | " points_query = np.asarray([p[m.queryIdx].pt for m in matches])\n", 202 | " points_train = np.asarray([p_[m.trainIdx].pt for m in matches])\n", 203 | " return points_query, points_train\n", 204 | "\n", 205 | "def normalize(pts, T=None):\n", 206 | " \"\"\"\n", 207 | " normalize points\n", 208 | " :param pts: (np.ndarray): points to be normalized\n", 209 | " :param T: (np.ndarray): IS None means we need to computer T\n", 210 | " :return: (np.ndarray, np.ndarray): normalized points and T\n", 211 | " \"\"\"\n", 212 | " if T is None:\n", 213 | " u = np.mean(pts, 0)\n", 214 | " d = np.sum(np.sqrt(np.sum(np.power(pts, 2), 1)))\n", 215 | " T = np.array([\n", 216 | " [np.sqrt(2) / d, 0, -(np.sqrt(2) / d * u[0])],\n", 217 | " [0, np.sqrt(2) / d, -(np.sqrt(2) / d * u[1])],\n", 218 | " [0, 0, 1]\n", 219 | " ])\n", 220 | " return homoco_pts_2_euco_pts(np.matmul(T, euco_pts_2_homoco_pts(pts).T).T), T\n", 221 | "\n", 222 | "def homoco_pts_2_euco_pts(pts):\n", 223 | " \"\"\"\n", 224 | " Homogeneous coordinate to Euclidean coordinates\n", 225 | " :param pts: (np.ndarray): Homogeneous coordinate\n", 226 | " :return: (np.ndarray): Euclidean coordinates\n", 227 | " \"\"\"\n", 228 | " if len(pts.shape) == 1:\n", 229 | " pts = pts.reshape(1, -1)\n", 230 | " res = pts / pts[:, -1, None]\n", 231 | " return res[:, :-1].squeeze()\n", 232 | "\n", 233 | "def euco_pts_2_homoco_pts(pts):\n", 234 | " \"\"\"\n", 235 | " Euclidean coordinate to Homogeneous coordinates\n", 236 | " :param pts: (np.ndarray): Euclidean coordinate\n", 237 | " :return: (np.ndarray): Homogeneous coordinates\n", 238 | " \"\"\"\n", 239 | " if len(pts.shape) == 1:\n", 240 | " pts = pts.reshape(1, -1)\n", 241 | " one = np.ones(pts.shape[0])\n", 242 | " res = np.c_[pts, one]\n", 243 | " return res.squeeze()\n", 244 | "\n", 245 | "def estimate_fundamental(pts1, pts2, num_sample=8):\n", 246 | " n = pts1.shape[0]\n", 247 | " pts_index = range(n)\n", 248 | " sample_index = random.sample(pts_index, num_sample)\n", 249 | " p1 = pts1[sample_index, :]\n", 250 | " p2 = pts2[sample_index, :]\n", 251 | " n = len(sample_index)\n", 252 | " p1_norm, T1 = normalize(p1, None)\n", 253 | " p2_norm, T2 = normalize(p2, None)\n", 254 | " w = np.zeros((n, 9))\n", 255 | " for i in range(n):\n", 256 | " w[i, 0] = p1_norm[i, 0] * p2_norm[i, 0]\n", 257 | " w[i, 1] = p1_norm[i, 1] * p2_norm[i, 0]\n", 258 | " w[i, 2] = p2_norm[i, 0]\n", 259 | " w[i, 3] = p1_norm[i, 0] * p2_norm[i, 1]\n", 260 | " w[i, 4] = p1_norm[i, 1] * p2_norm[i, 1]\n", 261 | " w[i, 5] = p2_norm[i, 1]\n", 262 | " w[i, 6] = p1_norm[i, 0]\n", 263 | " w[i, 7] = p1_norm[i, 1]\n", 264 | " w[i, 8] = 1\n", 265 | "\n", 266 | " U, sigma, VT = np.linalg.svd(w)\n", 267 | " f = VT[-1, :].reshape(3, 3)\n", 268 | " U, sigma, VT = np.linalg.svd(f)\n", 269 | " sigma[2] = 0\n", 270 | " f = U.dot(np.diag(sigma)).dot(VT)\n", 271 | " f = T2.T.dot(f).dot(T1)\n", 272 | " return f\n", 273 | "\n", 274 | "def estimate_homo(pts1, pts2, num_sample=4):\n", 275 | " n = pts1.shape[0]\n", 276 | " pts_index = range(n)\n", 277 | " sample_index = random.sample(pts_index, num_sample)\n", 278 | " p1 = pts1[sample_index, :]\n", 279 | " p2 = pts2[sample_index, :]\n", 280 | " n = len(sample_index)\n", 281 | " w = np.zeros((n * 2, 9))\n", 282 | " for i in range(n):\n", 283 | " w[2 * i, 0] = p1[i, 0]\n", 284 | " w[2 * i, 1] = p1[i, 1]\n", 285 | " w[2 * i, 2] = 1\n", 286 | " w[2 * i, 3] = 0\n", 287 | " w[2 * i, 4] = 0\n", 288 | " w[2 * i, 5] = 0\n", 289 | " w[2 * i, 6] = -p1[i, 0] * p2[i, 0]\n", 290 | " w[2 * i, 7] = -p1[i, 1] * p2[i, 0]\n", 291 | " w[2 * i, 8] = -p2[i, 0]\n", 292 | " w[2 * i + 1, 0] = 0\n", 293 | " w[2 * i + 1, 1] = 0\n", 294 | " w[2 * i + 1, 2] = 0\n", 295 | " w[2 * i + 1, 3] = p1[i, 0]\n", 296 | " w[2 * i + 1, 4] = p1[i, 1]\n", 297 | " w[2 * i + 1, 5] = 1\n", 298 | " w[2 * i + 1, 6] = -p1[i, 0] * p2[i, 1]\n", 299 | " w[2 * i + 1, 7] = -p1[i, 1] * p2[i, 1]\n", 300 | " w[2 * i + 1, 8] = -p2[i, 1]\n", 301 | " U, sigma, VT = np.linalg.svd(w)\n", 302 | " h = VT[-1, :].reshape(3, 3)\n", 303 | " return h" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 3, 309 | "metadata": {}, 310 | "outputs": [], 311 | "source": [ 312 | "def build_F_H_pair_match(feats):\n", 313 | " \"\"\"\n", 314 | " Build F, H, pair and match\n", 315 | " :param feats: (list[dict]): feat of imgs\n", 316 | " :return: (np.ndarray, np.ndarray, dict, dict): F, H, pair of imgs, match of pairs\n", 317 | " \"\"\"\n", 318 | "\n", 319 | "\n", 320 | " pair = dict()\n", 321 | " match = dict()\n", 322 | "\n", 323 | " for i in range(len(feats)):\n", 324 | " for j in range(i + 1, len(feats)):\n", 325 | " print(i, j)\n", 326 | " matches = get_matches(\n", 327 | " feats[i]['des'], feats[j]['des'])\n", 328 | " pts1, pts2 = get_match_point(\n", 329 | " feats[i]['kpt'], feats[j]['kpt'], matches)\n", 330 | " assert pts1.shape == pts2.shape\n", 331 | " # Need 8 points to estimate models\n", 332 | " if pts1.shape[0] < 8:\n", 333 | " continue\n", 334 | "\n", 335 | " F_single = estimate_fundamental(pts1, pts2)\n", 336 | " H_single = estimate_homo(pts1, pts2)\n", 337 | "\n", 338 | " if pts1.shape[0] < 8:\n", 339 | " continue\n", 340 | "\n", 341 | " pair.update({(i, j): {'pts1': pts1, 'pts2': pts2}})\n", 342 | " match.update({(i, j): {'match': matches}})\n", 343 | "\n", 344 | "\n", 345 | " return F_single, H_single, pair, match" 346 | ] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": {}, 351 | "source": [ 352 | "## 结果测试" 353 | ] 354 | }, 355 | { 356 | "cell_type": "markdown", 357 | "metadata": {}, 358 | "source": [ 359 | "- **导入所需模块**" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": 4, 365 | "metadata": {}, 366 | "outputs": [], 367 | "source": [ 368 | "import numpy as np\n", 369 | "import cv2\n", 370 | "import random\n", 371 | "import os\n", 372 | "import exifread" 373 | ] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": {}, 378 | "source": [ 379 | "- **读取图像、提取特征点并计算基础矩阵和单应矩阵**" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 6, 385 | "metadata": {}, 386 | "outputs": [ 387 | { 388 | "name": "stdout", 389 | "output_type": "stream", 390 | "text": [ 391 | "0 1\n", 392 | "The Fundamental Matrix is:\n", 393 | " [[ 2.04145376e-10 2.36540296e-08 -1.73467054e-05]\n", 394 | " [-2.17166341e-08 6.62880899e-10 -8.21073367e-05]\n", 395 | " [ 1.74208105e-05 7.92261019e-05 4.78852145e-03]]\n", 396 | "The Homography Matrix is:\n", 397 | " [[ 1.13554423e-02 -9.44761813e-05 -1.53000794e-01]\n", 398 | " [-4.50809624e-04 1.12960107e-02 9.88028524e-01]\n", 399 | " [-5.55802425e-07 1.25720789e-07 1.15600657e-02]]\n" 400 | ] 401 | } 402 | ], 403 | "source": [ 404 | "img_root = 'images/'\n", 405 | "imgs, feats, K = build_img_info(img_root)\n", 406 | "F, H, pair, match = build_F_H_pair_match(feats)\n", 407 | "print(\"The Fundamental Matrix is:\\n\", F)\n", 408 | "print(\"The Homography Matrix is:\\n\", H)" 409 | ] 410 | } 411 | ], 412 | "metadata": { 413 | "interpreter": { 414 | "hash": "2fd6ff00ff4a419d324d5b7e4b1b0789b8ee895e93e15d812a34184c59464f6c" 415 | }, 416 | "kernelspec": { 417 | "display_name": "Python 3.8.11 64-bit ('MyCV': conda)", 418 | "name": "python3" 419 | }, 420 | "language_info": { 421 | "codemirror_mode": { 422 | "name": "ipython", 423 | "version": 3 424 | }, 425 | "file_extension": ".py", 426 | "mimetype": "text/x-python", 427 | "name": "python", 428 | "nbconvert_exporter": "python", 429 | "pygments_lexer": "ipython3", 430 | "version": "3.8.11" 431 | }, 432 | "orig_nbformat": 4 433 | }, 434 | "nbformat": 4, 435 | "nbformat_minor": 2 436 | } 437 | -------------------------------------------------------------------------------- /MVGlab01_camera-calibration-master/camera_calibration.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第一次课程作业——摄像机标定" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 任务 \n", 15 | "\n", 16 | "- 通过3D摄像机标定物的单张图像进行摄像机标定\n", 17 | "- 以 imgages 文件夹中的 **Jietu20200301-091513.jpg** 图片为例，该示例中选择了三个平面的交线作为世界坐标系的 x、y 和 z 轴，其中共选择了 12 个点（三个四边形的顶点）。\n", 18 | "- 通过选定的点进行相机标定，算出 M、K、R、T。\n", 19 | "- 验证结果，从世界坐标系中引入一些点，并检查它们是否可以通过 M 映射到相应的像素。" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "
" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## 示例代码" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 21, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "class SingleCamera:\n", 43 | "\n", 44 | " def __init__(self, world_coor, pixel_coor, n):\n", 45 | "\n", 46 | " self.__world_coor = world_coor\n", 47 | " self.__pixel_coor = pixel_coor\n", 48 | " self.__point_num = n\n", 49 | "\n", 50 | " '''\n", 51 | " 0. P is the appropriate form when Pm=0\n", 52 | " 1. SVD-solved M is known up to scale, \n", 53 | " which means that the true values of the camera matrix are some scalar multiple of M,\n", 54 | " recorded as __roM\n", 55 | " 2. __M can be represented as form [A b], where A is a 3x3 matrix and b is with shape 3x1\n", 56 | " 3. __K is the intrisic Camera Matrix \n", 57 | " 4. __R and __t for rotation and translation\n", 58 | " \n", 59 | " '''\n", 60 | " self.__P = np.empty([self.__point_num, 12], dtype=float)\n", 61 | " self.__roM = np.empty([3, 4], dtype=float)\n", 62 | " self.__A = np.empty([3, 3], dtype=float)\n", 63 | " self.__b = np.empty([3, 1], dtype=float)\n", 64 | " self.__K = np.empty([3, 3], dtype=float)\n", 65 | " self.__R = np.empty([3, 3], dtype=float)\n", 66 | " self.__t = np.empty([3, 1], dtype=float)\n", 67 | "\n", 68 | " def returnAb(self):\n", 69 | " return self.__A, self.__b\n", 70 | "\n", 71 | " def returnKRT(self):\n", 72 | " return self.__K, self.__R, self.__t\n", 73 | "\n", 74 | " def returnM(self):\n", 75 | " return self.__roM\n", 76 | "\n", 77 | " def myReadFile(filePath):\n", 78 | " pass\n", 79 | "\n", 80 | " def changeHomo(no_homo):\n", 81 | " pass\n", 82 | "\n", 83 | " # to compose P in right form s.t. we can get Pm=0\n", 84 | " def composeP(self):\n", 85 | " i = 0\n", 86 | " P = np.empty([self.__point_num, 12], dtype=float)\n", 87 | " # print(P.shape)\n", 88 | " while i < self.__point_num:\n", 89 | " c = i // 2\n", 90 | " p1 = self.__world_coor[c]\n", 91 | " p2 = np.array([0, 0, 0, 0])\n", 92 | " if i % 2 == 0:\n", 93 | " p3 = -p1 * self.__pixel_coor[c][0]\n", 94 | " #print(p3)\n", 95 | " P[i] = np.hstack((p1, p2, p3))\n", 96 | "\n", 97 | " elif i % 2 == 1:\n", 98 | " p3 = -p1 * self.__pixel_coor[c][1]\n", 99 | " #print(p3)\n", 100 | " P[i] = np.hstack((p2, p1, p3))\n", 101 | " # M = P[i]\n", 102 | " # print(M)\n", 103 | " i = i + 1\n", 104 | " print(\"Now P is with form of :\")\n", 105 | " print(P)\n", 106 | " print('\\n')\n", 107 | " self.__P = P\n", 108 | "\n", 109 | " # svd to P，return A,b, where M=[A b]\n", 110 | " def svdP(self):\n", 111 | " U, sigma, VT = LA.svd(self.__P)\n", 112 | " # print(VT.shape)\n", 113 | " V = np.transpose(VT)\n", 114 | " preM = V[:, -1]\n", 115 | " roM = preM.reshape(3, 4)\n", 116 | " print(\"some scalar multiple of M,recorded as roM:\")\n", 117 | " print(roM)\n", 118 | " print('\\n')\n", 119 | " A = roM[0:3, 0:3].copy()\n", 120 | " b = roM[0:3, 3:4].copy()\n", 121 | " print(\"M can be written in form of [A b], where A is 3x3 and b is 3x1, as following:\")\n", 122 | " print(A)\n", 123 | " print(b)\n", 124 | " print('\\n')\n", 125 | " self.__roM = roM\n", 126 | " self.__A = A\n", 127 | " self.__b = b\n", 128 | "\n", 129 | " # solve the intrinsics and extrisics\n", 130 | " def workInAndOut(self):\n", 131 | " # compute ro, where ro=1/|a3|, ro may be positive or negative,\n", 132 | " # we choose the positive ro and name it ro01\n", 133 | " a3T = self.__A[2]\n", 134 | " # print(a3T)\n", 135 | " under = LA.norm(a3T)\n", 136 | " # print(under)\n", 137 | " ro01 = 1 / under\n", 138 | " print(\"The ro is %f \\n\" % ro01)\n", 139 | "\n", 140 | " # comput cx and cy\n", 141 | " a1T = self.__A[0]\n", 142 | " a2T = self.__A[1]\n", 143 | " cx = ro01 * ro01 * (np.dot(a1T, a3T))\n", 144 | " cy = ro01 * ro01 * (np.dot(a2T, a3T))\n", 145 | " print(\"cx=%f,cy=%f \\n\" % (cx, cy))\n", 146 | "\n", 147 | " # compute theta\n", 148 | " a_cross13 = np.cross(a1T, a3T)\n", 149 | " a_cross23 = np.cross(a2T, a3T)\n", 150 | " theta = np.arccos((-1) * np.dot(a_cross13, a_cross23) / (LA.norm(a_cross13) * LA.norm(a_cross23)))\n", 151 | " print(\"theta is: %f \\n\" % theta)\n", 152 | "\n", 153 | " # compute alpha and beta\n", 154 | " alpha = ro01 * ro01 * LA.norm(a_cross13) * np.sin(theta)\n", 155 | " beta = ro01 * ro01 * LA.norm(a_cross23) * np.sin(theta)\n", 156 | " print(\"alpha:%f, beta:%f \\n\" % (alpha,beta))\n", 157 | "\n", 158 | " # compute K\n", 159 | " K = np.array([alpha, -alpha * (1 / np.tan(theta)), cx, 0, beta / (np.sin(theta)), cy, 0, 0, 1])\n", 160 | " K = K.reshape(3, 3)\n", 161 | " print(\"We can get K accordingly: \")\n", 162 | " print(K)\n", 163 | " print('\\n')\n", 164 | " self.__K = K\n", 165 | "\n", 166 | " # compute R\n", 167 | " r1 = a_cross23 / LA.norm(a_cross23)\n", 168 | " r301 = ro01 * a3T\n", 169 | " r2 = np.cross(r301, r1)\n", 170 | " #print(r1, r2, r301)\n", 171 | " R = np.hstack((r1, r2, r301))\n", 172 | " R = R.reshape(3,3)\n", 173 | " print(\"we can get R:\")\n", 174 | " print(R)\n", 175 | " print('\\n')\n", 176 | " self.__R = R\n", 177 | "\n", 178 | " # compute T\n", 179 | " T = ro01 * np.dot(LA.inv(K), self.__b)\n", 180 | " print(\"we can get t:\")\n", 181 | " print(T)\n", 182 | " print('\\n')\n", 183 | " self.__t = T\n", 184 | "\n", 185 | " def selfcheck(self, w_check, c_check):\n", 186 | " my_size = c_check.shape[0]\n", 187 | " my_err = np.empty([my_size])\n", 188 | " for i in range(my_size) :\n", 189 | " test_pix = np.dot(self.__roM, w_check[i])\n", 190 | " u = test_pix[0] / test_pix[2]\n", 191 | " v = test_pix[1] / test_pix[2]\n", 192 | " u_c = c_check[i][0]\n", 193 | " v_c = c_check[i][1]\n", 194 | " print(\"you get test point %d with result (%f,%f)\" % (i, u, v))\n", 195 | " print(\"the correct result is (%f,%f)\" % (u_c,v_c))\n", 196 | " my_err[i] = (abs(u-u_c)/u_c+abs(v-v_c)/v_c)/2\n", 197 | " average_err = my_err.sum()/my_size\n", 198 | " print(\"The average error is %f ,\" % average_err)\n", 199 | " if average_err > 0.1:\n", 200 | " print(\"which is more than 0.1\")\n", 201 | " else:\n", 202 | " print(\"which is smaller than 0.1, the M is acceptable\")" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "## 结果测试" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "- **导入相关模块**" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": 22, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [ 225 | "import numpy as np\n", 226 | "from numpy import linalg as LA" 227 | ] 228 | }, 229 | { 230 | "cell_type": "markdown", 231 | "metadata": {}, 232 | "source": [ 233 | "- **写入所有点的世界坐标，像素坐标，设置测试点**" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 23, 239 | "metadata": {}, 240 | "outputs": [], 241 | "source": [ 242 | "# The homogeneous world coodinate\n", 243 | "\n", 244 | "# Although it would be more appropriate to write a function to read the coordinates, \n", 245 | "# we've simplified it by listing the coordinates directly in array.\n", 246 | "\n", 247 | "# world corrdinate\n", 248 | "# points: (8, 0, 9), (8, 0, 1), (6, 0, 1), (6, 0, 9)\n", 249 | "w_xz = np.array([8, 0, 9, 1, 8, 0, 1, 1, 6, 0, 1, 1, 6, 0, 9, 1])\n", 250 | "w_xz = w_xz.reshape(4, 4)\n", 251 | "# points: (5, 1, 0), (5, 9, 0), (4, 9, 0), (4, 1, 0)\n", 252 | "w_xy = np.array([5, 1, 0, 1, 5, 9, 0, 1, 4, 9, 0, 1, 4, 1, 0, 1])\n", 253 | "w_xy = w_xy.reshape(4, 4)\n", 254 | "# points: (0, 4, 7), (0, 4, 3), (0, 8, 3), (0, 8, 7)\n", 255 | "w_yz = np.array([0, 4, 7, 1, 0, 4, 3, 1, 0, 8, 3, 1, 0, 8, 7, 1])\n", 256 | "w_yz = w_yz.reshape(4, 4)\n", 257 | "w_coor = np.vstack((w_xz, w_xy, w_yz))\n", 258 | "#print(w_coor)\n", 259 | "# pixel coordinate\n", 260 | "c_xz = np.array([275, 142, 312, 454, 382, 436, 357, 134])\n", 261 | "c_xz = c_xz.reshape(4, 2)\n", 262 | "c_xy = np.array([432, 473, 612, 623, 647, 606, 464, 465])\n", 263 | "c_xy = c_xy.reshape(4, 2)\n", 264 | "c_yz = np.array([654, 216, 644, 368, 761, 420, 781, 246])\n", 265 | "c_yz = c_yz.reshape(4, 2)\n", 266 | "c_coor = np.vstack((c_xz, c_xy, c_yz))\n", 267 | "#print(c_coor)\n", 268 | "# coordinate for validation whether the M is correct or not\n", 269 | "w_check = np.array([6, 0, 5, 1, 3, 3, 0, 1, 0, 4, 0, 1, 0, 4, 4, 1, 0, 0, 7, 1])\n", 270 | "w_check = w_check.reshape(5, 4)\n", 271 | "c_check = np.array([369, 297, 531, 484, 640, 468, 646, 333, 556, 194])\n", 272 | "c_check = c_check.reshape(5, 2)" 273 | ] 274 | }, 275 | { 276 | "cell_type": "markdown", 277 | "metadata": {}, 278 | "source": [ 279 | "- **计算相机参数，测试投影矩阵**" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": 24, 285 | "metadata": {}, 286 | "outputs": [ 287 | { 288 | "name": "stdout", 289 | "output_type": "stream", 290 | "text": [ 291 | "Now P is with form of :\n", 292 | "[[ 8.000e+00 0.000e+00 9.000e+00 1.000e+00 0.000e+00 0.000e+00\n", 293 | " 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00]\n", 294 | " [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 8.000e+00 0.000e+00\n", 295 | " 9.000e+00 1.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00]\n", 296 | " [ 8.000e+00 0.000e+00 1.000e+00 1.000e+00 0.000e+00 0.000e+00\n", 297 | " 0.000e+00 0.000e+00 -2.496e+03 0.000e+00 -3.120e+02 -3.120e+02]\n", 298 | " [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 8.000e+00 0.000e+00\n", 299 | " 1.000e+00 1.000e+00 -3.632e+03 0.000e+00 -4.540e+02 -4.540e+02]\n", 300 | " [ 6.000e+00 0.000e+00 1.000e+00 1.000e+00 0.000e+00 0.000e+00\n", 301 | " 0.000e+00 0.000e+00 -2.292e+03 0.000e+00 -3.820e+02 -3.820e+02]\n", 302 | " [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 6.000e+00 0.000e+00\n", 303 | " 1.000e+00 1.000e+00 -2.616e+03 0.000e+00 -4.360e+02 -4.360e+02]\n", 304 | " [ 6.000e+00 0.000e+00 9.000e+00 1.000e+00 0.000e+00 0.000e+00\n", 305 | " 0.000e+00 0.000e+00 -2.142e+03 0.000e+00 -3.213e+03 -3.570e+02]\n", 306 | " [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 6.000e+00 0.000e+00\n", 307 | " 9.000e+00 1.000e+00 -8.040e+02 0.000e+00 -1.206e+03 -1.340e+02]\n", 308 | " [ 5.000e+00 1.000e+00 0.000e+00 1.000e+00 0.000e+00 0.000e+00\n", 309 | " 0.000e+00 0.000e+00 -2.160e+03 -4.320e+02 0.000e+00 -4.320e+02]\n", 310 | " [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 5.000e+00 1.000e+00\n", 311 | " 0.000e+00 1.000e+00 -2.365e+03 -4.730e+02 0.000e+00 -4.730e+02]\n", 312 | " [ 5.000e+00 9.000e+00 0.000e+00 1.000e+00 0.000e+00 0.000e+00\n", 313 | " 0.000e+00 0.000e+00 -3.060e+03 -5.508e+03 0.000e+00 -6.120e+02]\n", 314 | " [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 5.000e+00 9.000e+00\n", 315 | " 0.000e+00 1.000e+00 -3.115e+03 -5.607e+03 0.000e+00 -6.230e+02]]\n", 316 | "\n", 317 | "\n", 318 | "some scalar multiple of M,recorded as roM:\n", 319 | "[[ 5.40654233e-02 -5.48011712e-02 3.61180175e-02 -7.58221552e-01]\n", 320 | " [ 2.11829207e-02 -5.15006002e-02 5.25908724e-02 -6.41872412e-01]\n", 321 | " [ 6.18927969e-05 -4.42791434e-05 9.30771716e-05 -1.51459919e-03]]\n", 322 | "\n", 323 | "\n", 324 | "M can be written in form of [A b], where A is 3x3 and b is 3x1, as following:\n", 325 | "[[ 5.40654233e-02 -5.48011712e-02 3.61180175e-02]\n", 326 | " [ 2.11829207e-02 -5.15006002e-02 5.25908724e-02]\n", 327 | " [ 6.18927969e-05 -4.42791434e-05 9.30771716e-05]]\n", 328 | "[[-0.75822155]\n", 329 | " [-0.64187241]\n", 330 | " [-0.0015146 ]]\n", 331 | "\n", 332 | "\n", 333 | "The ro is 8317.544777 \n", 334 | "\n", 335 | "cx=631.943866,cy=587.108010 \n", 336 | "\n", 337 | "theta is: 2.030709 \n", 338 | "\n", 339 | "alpha:284.615004, beta:221.645270 \n", 340 | "\n", 341 | "We can get K accordingly: \n", 342 | "[[284.61500426 140.98127115 631.94386599]\n", 343 | " [ 0. 247.34678466 587.10801031]\n", 344 | " [ 0. 0. 1. ]]\n", 345 | "\n", 346 | "\n", 347 | "we can get R:\n", 348 | "[[-0.68940554 0.35894597 0.62918819]\n", 349 | " [-0.50961256 -0.85762317 -0.06911977]\n", 350 | " [ 0.51479611 -0.36829376 0.77417354]]\n", 351 | "\n", 352 | "\n", 353 | "we can get t:\n", 354 | "[[ 1.69296063]\n", 355 | " [ 8.31801962]\n", 356 | " [-12.59774659]]\n", 357 | "\n", 358 | "\n", 359 | "you get test point 0 with result (373.587780,371.495304)\n", 360 | "the correct result is (369.000000,297.000000)\n", 361 | "you get test point 1 with result (520.215162,501.331503)\n", 362 | "the correct result is (531.000000,484.000000)\n", 363 | "you get test point 2 with result (577.772139,501.192239)\n", 364 | "the correct result is (640.000000,468.000000)\n", 365 | "you get test point 3 with result (631.309457,483.180160)\n", 366 | "the correct result is (646.000000,333.000000)\n", 367 | "you get test point 4 with result (585.586194,317.169867)\n", 368 | "the correct result is (556.000000,194.000000)\n", 369 | "The average error is 0.164937 ,\n", 370 | "which is more than 0.1\n" 371 | ] 372 | } 373 | ], 374 | "source": [ 375 | "aCamera = SingleCamera(w_coor, c_coor, 12) # 12 points in total are used\n", 376 | "aCamera.composeP()\n", 377 | "aCamera.svdP()\n", 378 | "aCamera.workInAndOut() # print computed result\n", 379 | "aCamera.selfcheck(w_check,c_check) # test 5 points and verify M" 380 | ] 381 | } 382 | ], 383 | "metadata": { 384 | "interpreter": { 385 | "hash": "2fd6ff00ff4a419d324d5b7e4b1b0789b8ee895e93e15d812a34184c59464f6c" 386 | }, 387 | "kernelspec": { 388 | "display_name": "Python 3.8.11 64-bit ('MyCV': conda)", 389 | "name": "python3" 390 | }, 391 | "language_info": { 392 | "codemirror_mode": { 393 | "name": "ipython", 394 | "version": 3 395 | }, 396 | "file_extension": ".py", 397 | "mimetype": "text/x-python", 398 | "name": "python", 399 | "nbconvert_exporter": "python", 400 | "pygments_lexer": "ipython3", 401 | "version": "3.8.11" 402 | }, 403 | "orig_nbformat": 4 404 | }, 405 | "nbformat": 4, 406 | "nbformat_minor": 2 407 | } 408 | -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/single_view_metrology.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第二次课程作业——单视图重建" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 任务 \n", 15 | "\n", 16 | "- 根据所提供的符合单视重构要求的单张图片完成单视图重建任务。\n", 17 | "\n", 18 | "1. 加载使用 LABEL ME 工具标注产生的 json 数据，得到标记的平行线、平面交点、垂直面掩模。\n", 19 | "2. 据所标记的平行线在图像上的交点（通过计算得到），估算隐消点和场景中各个平面的隐消线。\n", 20 | "3. 根据由三组正交平行线得到的影消点，计算摄像机参数矩阵（标定）。\n", 21 | "4. 根据三个垂直面对应的隐消线和摄像机矩阵，计算场景平面的法方向（法向量）。\n", 22 | "5. 将平面交线的公共点代入具未知参数 d 的平面方程（设深度入=1），计算出各个场景平面到摄像机中心的距离 d。\n", 23 | "6. 将掩模区域中所有 2D 点坐标代入各点对应的场景平面方程（已知 d），计算出 3D 坐标，保存为 ply 文件，即单视图重建完成。" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "## 预处理 \n", 31 | "\n", 32 | "- 以 images 文件里的 **chessboard.jpg** 图片为例，使用标注工具 labelme 对该图像进行标注，标记产生的 json 数据放在 **labelme_data** 文件夹中。首先在每个垂直面上标出若干条平行线，并确保三个平面上的平行线相互垂直。 \n", 33 | "
\n", 34 | "\n", 35 | "- 同上，再次在三个平面上标注相互垂直的平行线，并与上一步所标注的平行线方向不同（示例图为垂直）。 \n", 36 | "
\n", 37 | "\n", 38 | "- 标出平面交线的公共点\n", 39 | "
\n", 40 | "\n", 41 | "- 标出最终进行三维重建效果展示的区域（掩模）\n", 42 | "
" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "## 示例代码" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 6, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "def solution(A): \n", 59 | "\n", 60 | " \"\"\"Solves homogenous linear equations.\"\"\"\n", 61 | "\n", 62 | " ## Ax = 0\n", 63 | "\n", 64 | " # SVD\n", 65 | " u, e, v = svd(A)\n", 66 | " x = v.T[:, -1] # min column of right singular vector\n", 67 | "\n", 68 | " \"\"\" \n", 69 | " ## Other Methods\n", 70 | " # find the eigenvalues and eigenvector of A.T * A -- right singular \n", 71 | " e_vals, e_vecs = np.linalg.eig(np.dot(A.T, A)) \n", 72 | " # extract the eigenvector (column) associated with the minimum eigenvalue \n", 73 | " x = np.array(e_vecs[:, np.argmin(np.abs(e_vals))])\n", 74 | " \"\"\"\n", 75 | "\n", 76 | " # np.set_printoptions(suppress=True)\n", 77 | " # print(A, x, np.dot(A, x.reshape(4, 1)))\n", 78 | "\n", 79 | " return x\n", 80 | "\n", 81 | "def get_label(img, data_line, data_plane):\n", 82 | "\n", 83 | " \"\"\"Gets parallel lines and vertical planes from label json.\"\"\"\n", 84 | "\n", 85 | " ## get parallel lines \n", 86 | " \n", 87 | " # print(data_line['shapes'])\n", 88 | " line2points = defaultdict(list) # store 2 points on each parallel line \n", 89 | " line_names = [\"XZ_line\", \"YZ_line\", \"XY_line\", \"XZ_line'\", \"YZ_line'\", \"XY_line'\",]\n", 90 | " intersect = [] # common point of plane intersection line\n", 91 | " for each_shape in data_line['shapes']:\n", 92 | " for each_line in line_names:\n", 93 | " if each_shape['label'] == each_line:\n", 94 | " # print(each_shape['points'])\n", 95 | " # print([list(reversed(each_shape['points'][0])), list(reversed(each_shape['points'][1]))])\n", 96 | " line2points[each_line].append([list(reversed(each_shape['points'][0])), list(reversed(each_shape['points'][1]))])\n", 97 | " elif each_shape['label'] == \"intersection\": # common point of plane intersection line\n", 98 | " intersect = list(reversed(each_shape['points'][0])) + [1]\n", 99 | " # print(line2points)\n", 100 | "\n", 101 | " ## get vertical planes\n", 102 | "\n", 103 | " lbl, lbl_names = utils.labelme_shapes_to_label(img.shape, data_plane['shapes']) \n", 104 | "\n", 105 | " # lbl：binary array in: 1 out: 0\n", 106 | " # lbl_names ：dict _background_：0 other labels: positive\n", 107 | " # print(lbl_names)\n", 108 | " mask = [] # for 3 verticle planes\n", 109 | " for i in range(1, len(lbl_names)): # ignore background\n", 110 | " mask.append((lbl == i).astype(np.uint8)) \n", 111 | "\n", 112 | " # captions = ['%d: %s' % (l, name) for l, name in enumerate(lbl_names)]\n", 113 | " # lbl_viz = utils.draw_label(lbl, img, captions)\n", 114 | " # plt.imshow(lbl_viz)\n", 115 | " # plt.show()\n", 116 | "\n", 117 | " return line2points, intersect, mask\n", 118 | "\n", 119 | "def cal_vanish(line2points):\n", 120 | "\n", 121 | " \"\"\"Calculates vanishing points and horizon lines.\"\"\"\n", 122 | " \n", 123 | " ## calculate vanishing points\n", 124 | " vanish_points = defaultdict(list) # for pairs of parallel lines \n", 125 | " for each_line, points in line2points.items(): # dict\n", 126 | " # print(each_line, len(points))\n", 127 | " line = [] # for each pair of parallel lines, store several line equations\n", 128 | " for each_point in points: # points array\n", 129 | " # cross product -- calculate line equation\n", 130 | " # line.append(np.cross(each_point[0] + [1], each_point[1] + [1])) # homogenous coordinates\n", 131 | " line.append(solution(np.array([each_point[0] + [1], each_point[1] + [1]])))\n", 132 | " # print(line)\n", 133 | " # p = np.cross(line[0], line[1]) # homogenous -- up to a scale\n", 134 | " p = solution(np.array(line)) \n", 135 | " vanish_points[each_line] = p / p[-1]\n", 136 | " # print(vanish_points)\n", 137 | "\n", 138 | " ## calculate vanishing lines\n", 139 | " \"\"\"\n", 140 | " horizs = np.array([np.cross(vanish_points[\"XZ_line\"], vanish_points[\"XZ_line'\"]), \n", 141 | " np.cross(vanish_points[\"YZ_line\"], vanish_points[\"YZ_line'\"]),\n", 142 | " np.cross(vanish_points[\"XY_line\"], vanish_points[\"XY_line'\"])]).T \n", 143 | " \"\"\"\n", 144 | " horizs = np.array([solution(np.array([vanish_points[\"XZ_line\"], vanish_points[\"XZ_line'\"]])), \n", 145 | " solution(np.array([vanish_points[\"YZ_line\"], vanish_points[\"YZ_line'\"]])), \n", 146 | " solution(np.array([vanish_points[\"XY_line\"], vanish_points[\"XY_line'\"]]))]).T\n", 147 | " # print(horizs)\n", 148 | "\n", 149 | " return vanish_points, horizs\n", 150 | "\n", 151 | "def calibrate(vanish_points):\n", 152 | " \n", 153 | " \"\"\"Calibrates the camera (square pixels & no skew).\"\"\" \n", 154 | "\n", 155 | " # W = [[w1 w2 w4] [w2 w3 w5] [w4 w5 w6]]\n", 156 | " # (square pixels: w2 = 0 no skew: w1 = w3)\n", 157 | "\n", 158 | " # θ = 90° -- v1.T * W * v2 = 0 ; v2.T * W * v3 = 0 ; v1.T * W * v4 = 0\n", 159 | " # (a1a2 + b1b2)w1 + (c1a2 + a1c2)w4 + (c1b2 + b1c2)w5 + c1c2w6 = 0\n", 160 | " # (a1a3 + b1b3)w1 + (c1a3 + a1c3)w4 + (c1b3 + b1c3)w5 + c1c3w6 = 0\n", 161 | " # (a2a3 + b2b3)w1 + (c2a3 + a2c3)w4 + (c2b3 + b2c3)w5 + c2c3w6 = 0 \n", 162 | "\n", 163 | " a1, b1, c1 = vanish_points[\"XZ_line\"]\n", 164 | " a2, b2, c2 = vanish_points[\"YZ_line\"]\n", 165 | " a3, b3, c3 = vanish_points[\"XY_line\"]\n", 166 | "\n", 167 | " param = np.array([[a1 * a2 + b1 * b2, c1 * a2 + a1 * c2, c1 * b2 + b1 * c2, c1 * c2], \n", 168 | " [a1 * a3 + b1 * b3, c1 * a3 + a1 * c3, c1 * b3 + b1 * c3, c1 * c3],\n", 169 | " [a2 * a3 + b2 * b3, c2 * a3 + a2 * c3, c2 * b3 + b2 * c3, c2 * c3]]) # parameter matrix \n", 170 | "\n", 171 | " # print(np.linalg.matrix_rank(param)) # rank < 4 -- non-zero solution\n", 172 | " \n", 173 | " w1, w4, w5, w6 = solution(param) # solve w1, w4, w5, w6 -- up to a scale\n", 174 | " W = np.array([[w1, 0, w4], [0, w1, w5], [w4, w5, w6]])\n", 175 | " W /= W[-1, -1]\n", 176 | " \n", 177 | " ### Once W is calculated, we get camera matrix K: \n", 178 | "\n", 179 | " ## Cholesky factorization -- W = (K.inv).T * (K.inv)\n", 180 | " # e_vals, e_vecs = np.linalg.eig(W) \n", 181 | " # print(e_vals) # all e_vals > 0 -- positive denifite\n", 182 | " L = cholesky(W, lower=False) # W = L.T * L, L is upper trianguler matrix \n", 183 | " K = np.linalg.inv(L) # K is upper trianguler matrix \n", 184 | " K /= K[-1][-1]\n", 185 | " # print(K)\n", 186 | "\n", 187 | " \"\"\"\n", 188 | " ### Other Methods\n", 189 | " ## directly -- W = (K * K.T).inv\n", 190 | " # K = [[f 0 u0] [0 f v0] [0 0 1]] (square pixels & no skew)\n", 191 | " # K * K.T = [[f^2 + u0^2 u0v0 u0] [u0v0 f^2 + v0^2 v0] [u0 v0 1]]\n", 192 | " W_inv = np.linalg.inv(W) \n", 193 | " dot = W_inv / W_inv[-1][-1]\n", 194 | " # print(W, W_inv, dot)\n", 195 | " u0 = dot[-1][0]\n", 196 | " v0 = dot[-1][1]\n", 197 | " # assert u0 * v0 == dot[-1][0] * dot[-1][1]\n", 198 | " # assert abs((u0 * u0 - v0 * v0) - (dot[0][0] - dot[1][1])) < 1e-3\n", 199 | " f = np.sqrt(dot[1][1] - v0 * v0)\n", 200 | " K = np.array([[f, 0, u0], [0, f, v0], [0, 0, 1]])\n", 201 | " # print(K)\n", 202 | " \"\"\"\n", 203 | " \n", 204 | " return K\n", 205 | "\n", 206 | "def cal_3D(K, p_2D_H):\n", 207 | "\n", 208 | " \"\"\"Calculates unit 3D pos without taking projective depth into account.\"\"\"\n", 209 | "\n", 210 | " p_3D = np.dot(np.linalg.inv(K), p_2D_H)\n", 211 | " p_3D /= np.linalg.norm(p_3D) # p / || p ||\n", 212 | "\n", 213 | " return p_3D\n", 214 | "\n", 215 | "def cal_scene(K, horizs, intersect):\n", 216 | "\n", 217 | " \"\"\"Calculates scene plane equations.\"\"\"\n", 218 | "\n", 219 | " # X_H.T * Pi = 0 (homogenous) -- Pi = (unit_n.T, d).T\n", 220 | " # unit_n.T * X + d = 0\n", 221 | "\n", 222 | " ## calculate scene plane orientations -- normal vector\n", 223 | " \n", 224 | " # n = K.T * l_horiz\n", 225 | " N = np.dot(K.T, horizs)\n", 226 | " # unit_n = n / || n ||\n", 227 | " unit_N = N / np.linalg.norm(N, axis=0)\n", 228 | " # print(unit_N)\n", 229 | "\n", 230 | " ## calculate distance between plane and camera center\n", 231 | "\n", 232 | " # common point of plane intersection lines in 3D \n", 233 | " # X_H = (λ * K.inv * x / || K.inv * x ||, 1) -- suppose projective depth λ is 1\n", 234 | " intersect_3D = cal_3D(K, intersect).reshape((3,1))\n", 235 | " # print(intersect_3D)\n", 236 | " # intersect_3D_H = np.append(intersect_3D, 1)\n", 237 | "\n", 238 | " # substitute the common point into plane equations\n", 239 | " D = -1 * np.dot(unit_N.T, intersect_3D)\n", 240 | " # print(D)\n", 241 | "\n", 242 | " # unit_N.T * X + D = 0 -- X_H * Pi = 0\n", 243 | " Pi = np.concatenate((unit_N, D.T), axis=0) # (4, 3)\n", 244 | "\n", 245 | " return Pi\n", 246 | "\n", 247 | "def reconstruction(K, Pi, img, masks):\n", 248 | "\n", 249 | " \"\"\"Reconstructs 3D points in masked image for 3 verticle planes.\"\"\"\n", 250 | "\n", 251 | " assert img.shape[:-1] == np.array(masks).shape[1:]\n", 252 | "\n", 253 | " pos = [] # position in 3D\n", 254 | " rgb = [] # pixel in original image\n", 255 | " for axis, each_mask in enumerate(masks): # plane XZ; YZ; XY\n", 256 | " for i in range(img.shape[0]):\n", 257 | " for j in range(img.shape[1]):\n", 258 | " if each_mask[i, j] == 1:\n", 259 | " # X_H * Pi = 0 -- X * Pi[:-1] + Pi[-1] = 0\n", 260 | " # X_H = (λ * K.inv * x / || K.inv * x ||, 1) -- solve λ\n", 261 | " point = cal_3D(K, [i, j, 1]).reshape((3,1))\n", 262 | " lambd = -Pi[-1, axis] / np.dot(Pi[:-1, axis], point)\n", 263 | " pos.append(lambd * point)\n", 264 | " rgb.append(img[i, j])\n", 265 | "\n", 266 | " return pos, rgb\n", 267 | "\n", 268 | "def create_output(vertices, colors, filename):\n", 269 | "\n", 270 | " \"\"\"Creates point cloud file.\"\"\"\n", 271 | "\n", 272 | " vertices = np.hstack([np.array(vertices).reshape(-1, 3), np.array(colors).reshape(-1, 3)])\n", 273 | " np.savetxt(filename, vertices, fmt='%f %f %f %d %d %d') \n", 274 | " ply_header = '''ply\\nformat ascii 1.0\\nelement vertex %(vert_num)d\\nproperty float x\\nproperty float y\\nproperty float z\\nproperty uchar red\\nproperty uchar green\\nproperty uchar blue\\nend_header\\n'''\n", 275 | " with open(filename, 'r+') as f:\n", 276 | " old = f.read()\n", 277 | " f.seek(0)\n", 278 | " f.write(ply_header % dict(vert_num=len(vertices)))\n", 279 | " f.write(old)" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "## 结果测试" 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "- **导入相关模块**" 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": 7, 299 | "metadata": {}, 300 | "outputs": [], 301 | "source": [ 302 | "import json\n", 303 | "import matplotlib.image as mpimg\n", 304 | "import matplotlib.pyplot as plt\n", 305 | "import numpy as np\n", 306 | "\n", 307 | "from labelme import utils\n", 308 | "from collections import defaultdict\n", 309 | "from scipy.linalg import svd, cholesky, qr\n", 310 | "import open3d as o3d\n", 311 | "from open3d import web_visualizer" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "- **加载 json 文件中的标记数据**" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": 8, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "# load data\n", 328 | "\n", 329 | "json_file_line = r'labelme_data\\chessboard_line.json' # label the parallel lines\n", 330 | "json_file_plane = r'labelme_data\\chessboard_plane.json' # label the vertical planes\n", 331 | "data_line = json.load(open(json_file_line))\n", 332 | "data_plane = json.load(open(json_file_plane))\n", 333 | "# img = utils.img_b64_to_arr(data_plane['imageData']) # png: 4 channels\n", 334 | "img = mpimg.imread(r'images\\chessboard.jpg')" 335 | ] 336 | }, 337 | { 338 | "cell_type": "markdown", 339 | "metadata": {}, 340 | "source": [ 341 | "- **单视图标定与重构，并保存 3D 模型**" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 9, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "name": "stderr", 351 | "output_type": "stream", 352 | "text": [ 353 | "[WARNING] shape:labelme_shapes_to_label:79 - labelme_shapes_to_label is deprecated, so please use shapes_to_label.\n" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "line2points, intersect, masks = get_label(img, data_line, data_plane)\n", 359 | "\n", 360 | "# calculate points and lines at infinity from labeled parallel lines\n", 361 | "\n", 362 | "vanish_points, vanish_lines = cal_vanish(line2points)\n", 363 | "\n", 364 | "# according to intersection points of 3 pairs parallel lines which are mutually orthogonal,\n", 365 | "# calculate camera matrix\n", 366 | "\n", 367 | "K = calibrate(vanish_points)\n", 368 | "\n", 369 | "# according to lines at infinity of 3 vertical planes and camera matrix, \n", 370 | "# calculate scene plane orientations (normal vectors);\n", 371 | "# substitute the common point(assuming projective depth) of plane intersection lines into plane equations, \n", 372 | "# calculate distance between each plane and camera center\n", 373 | "\n", 374 | "Pi = cal_scene(K, vanish_lines, intersect)\n", 375 | "\n", 376 | "# substituting 2D points into corresponding plane equation,\n", 377 | "# calculate 3D positions for masked image (up to a unknown scale)\n", 378 | "\n", 379 | "pos, rgb = reconstruction(K, Pi, img, masks)\n", 380 | "\n", 381 | "# save as ply file\n", 382 | "\n", 383 | "create_output(pos, rgb, r'chessboard_3D.ply')" 384 | ] 385 | }, 386 | { 387 | "cell_type": "markdown", 388 | "metadata": {}, 389 | "source": [ 390 | "- **可视化 3D 模型**" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": 10, 396 | "metadata": {}, 397 | "outputs": [ 398 | { 399 | "data": { 400 | "application/vnd.jupyter.widget-view+json": { 401 | "model_id": "5aaa2b66541d464d84dbd60dcf73d768", 402 | "version_major": 2, 403 | "version_minor": 0 404 | }, 405 | "text/plain": [ 406 | "WebVisualizer(window_uid='window_1')" 407 | ] 408 | }, 409 | "metadata": {}, 410 | "output_type": "display_data" 411 | } 412 | ], 413 | "source": [ 414 | "# visualization of point clouds.\n", 415 | "pcd = o3d.io.read_point_cloud('chessboard_3D.ply')\n", 416 | "# o3d.visualization.draw_geometries([pcd])\n", 417 | "web_visualizer.draw(pcd)" 418 | ] 419 | } 420 | ], 421 | "metadata": { 422 | "interpreter": { 423 | "hash": "2fd6ff00ff4a419d324d5b7e4b1b0789b8ee895e93e15d812a34184c59464f6c" 424 | }, 425 | "kernelspec": { 426 | "display_name": "Python 3.8.11 64-bit ('MyCV': conda)", 427 | "name": "python3" 428 | }, 429 | "language_info": { 430 | "codemirror_mode": { 431 | "name": "ipython", 432 | "version": 3 433 | }, 434 | "file_extension": ".py", 435 | "mimetype": "text/x-python", 436 | "name": "python", 437 | "nbconvert_exporter": "python", 438 | "pygments_lexer": "ipython3", 439 | "version": "3.8.11" 440 | }, 441 | "orig_nbformat": 4 442 | }, 443 | "nbformat": 4, 444 | "nbformat_minor": 2 445 | } 446 | -------------------------------------------------------------------------------- /MVGlab02_single-view-metrology-main/labelme_data/chessboard_plane.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "3.16.7", 3 | "flags": {}, 4 | "shapes": [ 5 | { 6 | "label": "XZ", 7 | "line_color": null, 8 | "fill_color": null, 9 | "points": [ 10 | [ 11 | 15.15384615384616, 12 | 41.452991452991455 13 | ], 14 | [ 15 | 176.69230769230774, 16 | 25.213675213675216 17 | ], 18 | [ 19 | 175.4102564102564, 20 | 240.17094017094018 21 | ], 22 | [ 23 | 33.52991452991455, 24 | 279.0598290598291 25 | ] 26 | ], 27 | "shape_type": "polygon", 28 | "flags": {} 29 | }, 30 | { 31 | "label": "YZ", 32 | "line_color": null, 33 | "fill_color": null, 34 | "points": [ 35 | [ 36 | 176.69230769230774, 37 | 25.213675213675216 38 | ], 39 | [ 40 | 365.1538461538462, 41 | 56.83760683760684 42 | ], 43 | [ 44 | 333.957264957265, 45 | 331.19658119658123 46 | ], 47 | [ 48 | 175.83760683760687, 49 | 241.45299145299145 50 | ] 51 | ], 52 | "shape_type": "polygon", 53 | "flags": {} 54 | }, 55 | { 56 | "label": "XY", 57 | "line_color": null, 58 | "fill_color": null, 59 | "points": [ 60 | [ 61 | 33.957264957264954, 62 | 279.4871794871795 63 | ], 64 | [ 65 | 164.29914529914532, 66 | 397.86324786324786 67 | ], 68 | [ 69 | 333.52991452991455, 70 | 330.34188034188037 71 | ], 72 | [ 73 | 174.982905982906, 74 | 241.02564102564105 75 | ] 76 | ], 77 | "shape_type": "polygon", 78 | "flags": {} 79 | } 80 | ], 81 | "lineColor": [ 82 | 0, 83 | 255, 84 | 0, 85 | 128 86 | ], 87 | "fillColor": [ 88 | 255, 89 | 0, 90 | 0, 91 | 128 92 | ], 93 | "imagePath": "chessboard_plane.png", 94 | "imageData": "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", 95 | "imageHeight": 404, 96 | "imageWidth": 404 97 | } --------------------------------------------------------------------------------