add MP3

MP3/Q1/Q1_starter.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Image Stitching (Python)\n",
+    "\n",
+    "## Usage\n",
+    "This code snippet provides an overall code structure and some interactive plot interfaces for the Stitching Pairs of Images section of MP 3. In main function, we outline the required functionalities step by step. Feel free to make modifications on the starter code if it's necessary.\n",
+    "\n",
+    "## Package installation\n",
+    "- `opencv`\n",
+    "- `numpy`\n",
+    "- `skimage`\n",
+    "- `scipy`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Common imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import skimage\n",
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.spatial import distance\n",
+    "import scipy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Helper functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def imread(fname):\n",
+    "    \"\"\"\n",
+    "    read image into np array from file\n",
+    "    \"\"\"\n",
+    "    return skimage.io.imread(fname)\n",
+    "\n",
+    "def imread_bw(fname):\n",
+    "    \"\"\"\n",
+    "    read image as gray scale format\n",
+    "    \"\"\"\n",
+    "    return cv2.cvtColor(imread(fname), cv2.COLOR_BGR2GRAY)\n",
+    "\n",
+    "def imshow(img):\n",
+    "    \"\"\"\n",
+    "    show image\n",
+    "    \"\"\"\n",
+    "    skimage.io.imshow(img)\n",
+    "    \n",
+    "def get_sift_data(img):\n",
+    "    \"\"\"\n",
+    "    detect the keypoints and compute their SIFT descriptors with opencv library\n",
+    "    \"\"\"\n",
+    "    sift = cv2.SIFT_create()\n",
+    "    kp, des = sift.detectAndCompute(img, None)\n",
+    "    return kp, des\n",
+    "\n",
+    "def plot_inlier_matches(ax, img1, img2, inliers):\n",
+    "    \"\"\"\n",
+    "    plot the match between two image according to the matched keypoints\n",
+    "    :param ax: plot handle\n",
+    "    :param img1: left image\n",
+    "    :param img2: right image\n",
+    "    :inliers: x,y in the first image and x,y in the second image (Nx4)\n",
+    "    \"\"\"\n",
+    "    res = np.hstack([img1, img2])\n",
+    "    ax.set_aspect('equal')\n",
+    "    ax.imshow(res, cmap='gray')\n",
+    "    \n",
+    "    ax.plot(inliers[:,0], inliers[:,1], '+r')\n",
+    "    ax.plot(inliers[:,2] + img1.shape[1], inliers[:,3], '+r')\n",
+    "    ax.plot([inliers[:,0], inliers[:,2] + img1.shape[1]],\n",
+    "            [inliers[:,1], inliers[:,3]], 'r', linewidth=0.4)\n",
+    "    ax.axis('off')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Your implementations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_best_matches(img1, img2, num_matches):\n",
+    "    kp1, des1 = get_sift_data(img1)\n",
+    "    kp2, des2 = get_sift_data(img2)\n",
+    "    kp1, kp2 = np.array(kp1), np.array(kp2)\n",
+    "    \n",
+    "    # Find distance between descriptors in images\n",
+    "    dist = scipy.spatial.distance.cdist(des1, des2, 'sqeuclidean')\n",
+    "    \n",
+    "    # Write your code to get the matches according to dist\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "def ransac(...):\n",
+    "    \"\"\"\n",
+    "    write your ransac code to find the best model, inliers, and residuals\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "def compute_homography(...):\n",
+    "    \"\"\"\n",
+    "    write your code to compute homography according to the matches\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "def warp_images(...):\n",
+    "    \"\"\"\n",
+    "    write your code to stitch images together according to the homography\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Main functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Load images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img1 = imread('./stitch/left.jpg')\n",
+    "img2 = imread('./stitch/right.jpg')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (3) compute and display the initial SIFT matching result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = get_best_matches(img1, img2, 300)\n",
+    "fig, ax = plt.subplots(figsize=(20,10))\n",
+    "plot_inlier_matches(ax, img1, img2, data)\n",
+    "fig.savefig('sift_match.pdf', bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (4) performn RANSAC to get the homography and inliers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# display the inlier matching, report the average residual\n",
+    "# <YOUR CODE>\n",
+    "# print(\"Average residual:\", np.average(best_model_errors))\n",
+    "# print(\"Inliers:\", max_inliers)\n",
+    "# fig.savefig('ransac_match.pdf', bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (5) warp images to stitch them together"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# display and report the stitching results\n",
+    "# <YOUR CODE>\n",
+    "# cv2.imwrite('stitched_images.jpg', im[:,:,::-1]*255., \n",
+    "#             [int(cv2.IMWRITE_JPEG_QUALITY), 90])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

MP3/Q2/Q2_starter.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fundamental Matrix Estimation, Camera Calibration, Triangulation (Python)\n",
+    "## Usage\n",
+    "This code snippet provides an overall code structure and some interactive plot interfaces for the Fundamental Matrix Estimation, Camera Calibration, Triangulation section of MP 3. We outline the required functionalities step by step. Feel free to make modifications on the starter code if it's necessary.\n",
+    "\n",
+    "## Package installation\n",
+    "- You will need [GUI backend](https://matplotlib.org/faq/usage_faq.html#what-is-a-backend) to enable interactive plots in `matplotlib`.\n",
+    "- `numpy`\n",
+    "- `PIL`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Common imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_residual(F, p1, p2):\n",
+    "    \"\"\"\n",
+    "    Function to compute the residual average residual on frame 2\n",
+    "    param: F (3x3): fundamental matrix: (pt in frame 2).T * F * (pt in frame 1) = 0\n",
+    "    param: p1 (Nx2): 2d points on frame 1\n",
+    "    param: p2 (Nx2): 2d points on frame 2\n",
+    "    \"\"\"\n",
+    "    P1 = np.c_[p1, np.ones((p1.shape[0],1))].transpose()\n",
+    "    P2 = np.c_[p2, np.ones((p2.shape[0],1))].transpose()\n",
+    "    L2 = np.matmul(F, P1).transpose()\n",
+    "    L2_norm = np.sqrt(L2[:,0]**2 + L2[:,1]**2)\n",
+    "    L2 = L2 / L2_norm[:,np.newaxis]\n",
+    "    pt_line_dist = np.multiply(L2, P2.T).sum(axis = 1)\n",
+    "    return np.mean(np.square(pt_line_dist))\n",
+    "\n",
+    "def plot_fundamental(ax, F, p1, p2, I):\n",
+    "    \"\"\"\n",
+    "    Function to display epipolar lines and corresponding points\n",
+    "    param: F (3x3): fundamental matrix: (pt in frame 2).T * F * (pt in frame 1) = 0\n",
+    "    param: p1 (Nx2): 2d points on frame 1\n",
+    "    param: p2 (Nx2): 2d points on frame 2\n",
+    "    param: I: frame 2\n",
+    "    \"\"\"\n",
+    "    N = p1.shape[0]\n",
+    "    P1 = np.c_[p1, np.ones((N,1))].transpose()\n",
+    "    P2 = np.c_[p2, np.ones((N,1))].transpose()\n",
+    "    L2 = np.matmul(F, P1).transpose() # transform points from \n",
+    "\n",
+    "    # the first image to get epipolar lines in the second image\n",
+    "    L2_norm = np.sqrt(L2[:,0]**2 + L2[:,1]**2)\n",
+    "    L2 = L2 / L2_norm[:,np.newaxis]\n",
+    "    pt_line_dist = np.multiply(L2, P2.T).sum(axis=1)\n",
+    "    closest_pt = p2 - (L2[:,0:2]*pt_line_dist[:,np.newaxis])\n",
+    "\n",
+    "    # Find endpoints of segment on epipolar line (for display purposes).\n",
+    "    # offset from the closest point is 10 pixels\n",
+    "    pt1 = closest_pt - np.c_[L2[:,1], -L2[:,0]]*10 \n",
+    "    pt2 = closest_pt + np.c_[L2[:,1], -L2[:,0]]*10\n",
+    "\n",
+    "    # Display points and segments of corresponding epipolar lines.\n",
+    "    # You will see points in red corsses, epipolar lines in green \n",
+    "    # and a short cyan line that denotes the shortest distance between\n",
+    "    # the epipolar line and the corresponding point.\n",
+    "    ax.set_aspect('equal')\n",
+    "    ax.imshow(np.array(I))\n",
+    "    ax.plot(p2[:,0],p2[:,1],  '+r')\n",
+    "    ax.plot([p2[:,0], closest_pt[:,0]],[p2[:,1], closest_pt[:,1]], 'r')\n",
+    "    ax.plot([pt1[:,0], pt2[:,0]],[pt1[:,1], pt2[:,1]], 'g')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write your code here for part estimating essential matrices\n",
+    "def fit_fundamental(...):\n",
+    "    \"\"\"\n",
+    "    Solves for the fundamental matrix using the matches with unnormalized method.\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "def fit_fundamental_normalized(...):\n",
+    "    \"\"\"\n",
+    "    Solve for the fundamental matrix using the matches with normalized method.\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fundamental matrix estimation\n",
+    "name = 'library' \n",
+    "# You also need to report results for name = 'lab'\n",
+    "# name = 'lab'\n",
+    "\n",
+    "I1 = Image.open('./{:s}1.jpg'.format(name))\n",
+    "I2 = Image.open('./{:s}2.jpg'.format(name))\n",
+    "matches = np.loadtxt('./{:s}_matches.txt'.format(name))\n",
+    "N = len(matches);\n",
+    "\n",
+    "## Display two images side-by-side with matches\n",
+    "## this code is to help you visualize the matches, you don't need\n",
+    "## to use it to produce the results for the assignment\n",
+    "I3 = np.zeros((I1.size[1],I1.size[0]*2,3))\n",
+    "I3[:,:I1.size[0],:] = I1;\n",
+    "I3[:,I1.size[0]:,:] = I2;\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.set_aspect('equal')\n",
+    "ax.plot(matches[:,0],matches[:,1],  '+r')\n",
+    "ax.plot( matches[:,2]+I1.size[0],matches[:,3], '+r')\n",
+    "ax.plot([matches[:,0], matches[:,2]+I1.size[0]],[matches[:,1], matches[:,3]], 'r')\n",
+    "ax.imshow(np.array(I3).astype(np.uint8))\n",
+    "\n",
+    "# non-normalized method\n",
+    "F = fit_fundamental(...) # <YOUR CODE>\n",
+    "pt1_2d = matches[:, :2]\n",
+    "pt2_2d = matches[:, 2:]\n",
+    "v2 = get_residual(F, pt1_2d, pt2_2d)\n",
+    "v1 = get_residual(F.T, pt2_2d, pt1_2d)\n",
+    "print('{:s}: residual in frame 2 (non-normalized method) = '.format(name), v2)\n",
+    "print('{:s}: residual in frame 1 (non-normalized method) = '.format(name), v1)\n",
+    "print('{:s}: residual combined   (non-normalized method) = '.format(name), (v1+v2)/2)\n",
+    "# Plot epipolar lines in image I2\n",
+    "fig, ax = plt.subplots()\n",
+    "plot_fundamental(ax, F, pt1_2d, pt2_2d, I2)\n",
+    "# Plot epipolar lines in image I1\n",
+    "fig, ax = plt.subplots()\n",
+    "plot_fundamental(ax, F.T, pt2_2d, pt1_2d, I1)\n",
+    "\n",
+    "# normalized method\n",
+    "F = fit_fundamental_normalized(...) # <YOUR CODE>\n",
+    "pt1_2d = matches[:, :2]\n",
+    "pt2_2d = matches[:, 2:]\n",
+    "v2 = get_residual(F, pt1_2d, pt2_2d)\n",
+    "v1 = get_residual(F.T, pt2_2d, pt1_2d)\n",
+    "print('{:s}: residual in frame 2 (normalized method) = '.format(name), v2)\n",
+    "print('{:s}: residual in frame 1 (normalized method) = '.format(name), v1)\n",
+    "print('{:s}: residual combined   (normalized method) = '.format(name), (v1+v2)/2)\n",
+    "# Plot epipolar lines in image I2\n",
+    "fig, ax = plt.subplots()\n",
+    "plot_fundamental(ax, F, pt1_2d, pt2_2d, I2)\n",
+    "# Plot epipolar lines in image I1\n",
+    "fig, ax = plt.subplots()\n",
+    "plot_fundamental(ax, F.T, pt2_2d, pt1_2d, I1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate_points(M, points_2d, points_3d):\n",
+    "    \"\"\"\n",
+    "    Visualize the actual 2D points and the projected 2D points calculated from\n",
+    "    the projection matrix\n",
+    "    You do not need to modify anything in this function, although you can if you\n",
+    "    want to\n",
+    "    :param M: projection matrix 3 x 4\n",
+    "    :param points_2d: 2D points N x 2\n",
+    "    :param points_3d: 3D points N x 3\n",
+    "    :return:\n",
+    "    \"\"\"\n",
+    "    N = len(points_3d)\n",
+    "    points_3d = np.hstack((points_3d, np.ones((N, 1))))\n",
+    "    points_3d_proj = np.dot(M, points_3d.T).T\n",
+    "    u = points_3d_proj[:, 0] / points_3d_proj[:, 2]\n",
+    "    v = points_3d_proj[:, 1] / points_3d_proj[:, 2]\n",
+    "    residual = np.sum(np.hypot(u-points_2d[:, 0], v-points_2d[:, 1]))\n",
+    "    points_3d_proj = np.hstack((u[:, np.newaxis], v[:, np.newaxis]))\n",
+    "    return points_3d_proj, residual\n",
+    "\n",
+    "# Write your code here for camera calibration (lab)\n",
+    "def camera_calibration(...):\n",
+    "    \"\"\"\n",
+    "    write your code to compute camera matrix\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "# Load 3D points, and their corresponding locations in \n",
+    "# the two images.\n",
+    "pts_3d = np.loadtxt('./lab_3d.txt')\n",
+    "matches = np.loadtxt('./lab_matches.txt')\n",
+    "\n",
+    "# <YOUR CODE> print lab camera projection matrices:\n",
+    "lab1_proj = camera_calibration(...)\n",
+    "lab2_proj = camera_calibration(...)\n",
+    "print('lab 1 camera projection')\n",
+    "print(lab1_proj)\n",
+    "\n",
+    "print('')\n",
+    "print('lab 2 camera projection')\n",
+    "print(lab2_proj)\n",
+    "\n",
+    "# <YOUR CODE> evaluate the residuals for both estimated cameras\n",
+    "_, lab1_res = evaluate_points(...)\n",
+    "print('residuals between the observed 2D points and the projected 3D points:')\n",
+    "print('residual in lab1:', lab1_res)\n",
+    "_, lab2_res = evaluate_points(...)\n",
+    "print('residual in lab2:', lab2_res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lib1_proj = np.loadtxt('./library1_camera.txt')\n",
+    "lib2_proj = np.loadtxt('./library2_camera.txt')\n",
+    "print('library1 camera projection')\n",
+    "print(lib1_proj)\n",
+    "print('library2 camera projection')\n",
+    "print(lib2_proj)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write your code here for computing camera centers\n",
+    "def calc_camera_center(...):\n",
+    "    \"\"\"\n",
+    "    write your code to get camera center in the world \n",
+    "    from the projection matrix\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "# <YOUR CODE> compute the camera centers using \n",
+    "# the projection matrices\n",
+    "lab1_c = calc_camera_center(...)\n",
+    "lab2_c = calc_camera_center(...)\n",
+    "print('lab1 camera center', lab1_c)\n",
+    "print('lab2 camera center', lab2_c)\n",
+    "\n",
+    "# <YOUR CODE> compute the camera centers with the projection matrices\n",
+    "lib1_c = calc_camera_center(...)\n",
+    "lib2_c = calc_camera_center(...)\n",
+    "print('library1 camera center', lib1_c)\n",
+    "print('library2 camera center', lib2_c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Part (4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write your code here for triangulation\n",
+    "from mpl_toolkits.mplot3d import Axes3D\n",
+    "def triangulation(...):\n",
+    "    \"\"\"\n",
+    "    write your code to triangulate the points in 3D\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "def evaluate_points_3d(...):\n",
+    "    \"\"\"\n",
+    "    write your code to evaluate the triangulated 3D points\n",
+    "    \"\"\"\n",
+    "    # <YOUR CODE>\n",
+    "    pass\n",
+    "\n",
+    "# triangulate the 3D point cloud for the lab data \n",
+    "matches_lab = np.loadtxt('./lab_matches.txt')\n",
+    "points_3d_gt = np.loadtxt('./lab_3d.txt')\n",
+    "points_3d_lab = triangulation(...) # <YOUR CODE>\n",
+    "res_3d_lab = evaluate_points_3d(...) # <YOUR CODE>\n",
+    "print('Mean 3D reconstuction error for the lab data: ', round(np.mean(res_3d_lab), 5))\n",
+    "_, res_2d_lab1 = evaluate_points(lab1_proj, lab_pt1, points_3d_lab)\n",
+    "_, res_2d_lab2 = evaluate_points(lab2_proj, lab_pt2, points_3d_lab)\n",
+    "print('2D reprojection error for the lab 1 data: ', np.mean(res_2d_lab1))\n",
+    "print('2D reprojection error for the lab 2 data: ', np.mean(res_2d_lab2))\n",
+    "# visualization of lab point cloud\n",
+    "camera_centers = np.vstack((lab1_c, lab2_c))\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "ax.scatter(points_3d_lab[:, 0], points_3d_lab[:, 1], points_3d_lab[:, 2], c='b', label='Points')\n",
+    "ax.scatter(camera_centers[:, 0], camera_centers[:, 1], camera_centers[:, 2], c='g', s=50, marker='^', label='Camera Centers')\n",
+    "ax.legend(loc='best')\n",
+    "\n",
+    "# triangulate the 3D point cloud for the library data\n",
+    "matches_lib = np.loadtxt('./library_matches.txt')\n",
+    "points_3d_lib = triangulation(...) # <YOUR CODE>\n",
+    "_, res_2d_lib1 = evaluate_points(lib1_proj, lib_pt1, points_3d_lib)\n",
+    "_, res_2d_lib2 = evaluate_points(lib2_proj, lib_pt2, points_3d_lib)\n",
+    "print('2D reprojection error for the library 1 data: ', np.mean(res_2d_lib1))\n",
+    "print('2D reprojection error for the library 2 data: ', np.mean(res_2d_lib2))\n",
+    "# visualization of library point cloud\n",
+    "camera_centers_library = np.vstack((lib1_c, lib2_c))\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "ax.scatter(points_3d_lib[:, 0], points_3d_lib[:, 1], points_3d_lib[:, 2], c='b', label='Points')\n",
+    "ax.scatter(camera_centers_library[:, 0], camera_centers_library[:, 1], \n",
+    "           camera_centers_library[:, 2], c='g', s=90, \n",
+    "           marker='^', label='Camera Centers')\n",
+    "ax.view_init(azim=-45, elev=45)\n",
+    "ax.legend(loc='best')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

MP3/Q2/lab_3d.txt

+312.747 309.140 30.086
+305.796 311.649 30.356
+307.694 312.358 30.418
+310.149 307.186 29.298
+311.937 310.105 29.216
+311.202 307.572 30.682
+307.106 306.876 28.660
+309.317 312.490 30.230
+307.435 310.151 29.318
+308.253 306.300 28.881
+306.650 309.301 28.905
+308.069 306.831 29.189
+309.671 308.834 29.029
+308.255 309.955 29.267
+307.546 308.613 28.963
+311.036 309.206 28.913
+307.518 308.175 29.069
+309.950 311.262 29.990
+312.160 310.772 29.080
+311.988 312.709 30.514

MP3/Q2/lab_matches.txt

+8.800000000000000000e+02 2.140000000000000000e+02 7.310000000000000000e+02 2.380000000000000000e+02
+4.300000000000000000e+01 2.030000000000000000e+02 2.200000000000000000e+01 2.480000000000000000e+02
+2.700000000000000000e+02 1.970000000000000000e+02 2.040000000000000000e+02 2.300000000000000000e+02
+8.860000000000000000e+02 3.470000000000000000e+02 9.030000000000000000e+02 3.420000000000000000e+02
+7.450000000000000000e+02 3.020000000000000000e+02 6.350000000000000000e+02 3.160000000000000000e+02
+9.430000000000000000e+02 1.280000000000000000e+02 8.670000000000000000e+02 1.770000000000000000e+02
+4.760000000000000000e+02 5.900000000000000000e+02 9.580000000000000000e+02 5.720000000000000000e+02
+4.190000000000000000e+02 2.140000000000000000e+02 3.280000000000000000e+02 2.440000000000000000e+02
+3.170000000000000000e+02 3.350000000000000000e+02 4.260000000000000000e+02 3.860000000000000000e+02
+7.830000000000000000e+02 5.210000000000000000e+02 1.064000000000000000e+03 4.700000000000000000e+02
+2.350000000000000000e+02 4.270000000000000000e+02 4.800000000000000000e+02 4.950000000000000000e+02
+6.650000000000000000e+02 4.290000000000000000e+02 9.640000000000000000e+02 4.190000000000000000e+02
+6.550000000000000000e+02 3.620000000000000000e+02 6.950000000000000000e+02 3.740000000000000000e+02
+4.270000000000000000e+02 3.330000000000000000e+02 5.050000000000000000e+02 3.720000000000000000e+02
+4.120000000000000000e+02 4.150000000000000000e+02 6.450000000000000000e+02 4.520000000000000000e+02
+7.460000000000000000e+02 3.510000000000000000e+02 6.920000000000000000e+02 3.590000000000000000e+02
+4.340000000000000000e+02 4.150000000000000000e+02 7.120000000000000000e+02 4.440000000000000000e+02
+5.250000000000000000e+02 2.340000000000000000e+02 4.650000000000000000e+02 2.630000000000000000e+02
+7.160000000000000000e+02 3.080000000000000000e+02 5.910000000000000000e+02 3.240000000000000000e+02
+6.020000000000000000e+02 1.870000000000000000e+02 4.470000000000000000e+02 2.130000000000000000e+02