Make C++ and Python examples consistent

Author: sunglok

.gitignore

@@ -1,5 +1,6 @@
-build
+data/KITTI07/image_0
 slides
+build
 
 x64
 Debug

examples/3d_rotation_conversion.py

@@ -2,17 +2,17 @@
 from scipy.spatial.transform import Rotation
 
 # The given 3D rotation
-euler = (45, 30, 60) # Unit: [deg] in XYZ-order
+euler = (45, 30, 60) # Unit: [deg] in the XYZ-order
 
 # Generate 3D rotation object
 robj = Rotation.from_euler('zyx', euler[::-1], degrees=True)
 
 # Print other representations
 print('\n## Euler Angle (ZYX)')
-print(np.rad2deg(robj.as_euler('zyx'))) # [60, 30, 45] [deg]
+print(np.rad2deg(robj.as_euler('zyx'))) # [60, 30, 45] [deg] in the ZYX-order
 print('\n## Rotation Matrix')
 print(robj.as_matrix())
 print('\n## Rotation Vector')
 print(robj.as_rotvec())                 # [0.97, 0.05, 1.17]
-print('\n## Quaternion (XYZW)')         # [0.44, 0.02, 0.53, 0.72]
-print(robj.as_quat())
+print('\n## Quaternion (XYZW)')
+print(robj.as_quat())                   # [0.44, 0.02, 0.53, 0.72]

examples/affine_estimation_implement.py

@@ -1,5 +1,5 @@
-import cv2 as cv
 import numpy as np
+import cv2 as cv
 
 def getAffineTransform(src, dst):
     if len(src) == len(dst):
@@ -12,7 +12,7 @@ def getAffineTransform(src, dst):
             b.append(q[1])
         x = np.linalg.pinv(A) @ b
 
-        # Reorganize 'H'
+        # Reorganize `x` as a matrix
         H = np.array([[x[0], x[1], x[4]], [x[2], x[3], x[5]]])
         return H
 

examples/camera_calibration.cpp

@@ -1,16 +1,16 @@
 #include "opencv2/opencv.hpp"
-#include "fstream"
+#include "iostream"
 
 int main()
 {
-    const char* input = "data/chessboard.avi";
+    const char* video_file = "../data/chessboard.avi";
     cv::Size board_pattern(10, 7);
     float board_cellsize = 0.025f;
     bool select_images = true;
 
     // Open a video
     cv::VideoCapture video;
-    if (!video.open(input)) return -1;
+    if (!video.open(video_file)) return -1;
 
     // Select images
     std::vector<cv::Mat> images;
@@ -24,20 +24,19 @@ int main()
         if (select_images)
         {
             // Show the image and keep it if selected
-            cv::imshow("3DV Tutorial: Camera Calibration", image);
+            cv::imshow("Camera Calibration", image);
             int key = cv::waitKey(1);
-            if (key == 27) break;                               // 'ESC' key: Exit
-            else if (key == 32)                                 // 'Space' key: Pause
+            if (key == 32)                              // Space: Pause and show corners
             {
                 std::vector<cv::Point2f> pts;
                 bool complete = cv::findChessboardCorners(image, board_pattern, pts);
                 cv::Mat display = image.clone();
                 cv::drawChessboardCorners(display, board_pattern, pts, complete);
-                cv::imshow("3DV Tutorial: Camera Calibration", display);
+                cv::imshow("Camera Calibration", display);
                 key = cv::waitKey();
-                if (key == 27) break;                           // 'ESC' key: Exit
-                else if (key == 13) images.push_back(image);    // 'Enter' key: Select
+                if (key == 13) images.push_back(image); // Enter: Select the image
             }
+            if (key == 27) break;                       // ESC: Exit (Complete image selection)
         }
         else images.push_back(image);
     }
@@ -67,14 +66,11 @@ int main()
     std::vector<cv::Mat> rvecs, tvecs;
     double rms = cv::calibrateCamera(obj_points, img_points, images[0].size(), K, dist_coeff, rvecs, tvecs);
 
-    // Report calibration results
-    std::ofstream report("camera_calibration.txt");
-    if (!report.is_open()) return -1;
-    report << "## Camera Calibration Results" << std::endl;
-    report << "* The number of applied images = " << img_points.size() << std::endl;
-    report << "* RMS error = " << rms << std::endl;
-    report << "* Camera matrix (K) = " << std::endl << "  " << K.row(0) << K.row(1) << K.row(2) << std::endl;
-    report << "* Distortion coefficient (k1, k2, p1, p2, k3, ...) = " << std::endl << "  " << dist_coeff.t() << std::endl;
-    report.close();
+    // Print calibration results
+    std::cout << "## Camera Calibration Results" << std::endl;
+    std::cout << "* The number of applied images = " << img_points.size() << std::endl;
+    std::cout << "* RMS error = " << rms << std::endl;
+    std::cout << "* Camera matrix (K) = " << std::endl << "  " << K.row(0) << K.row(1) << K.row(2) << std::endl;
+    std::cout << "* Distortion coefficient (k1, k2, p1, p2, k3, ...) = " << std::endl << "  " << dist_coeff.t() << std::endl;
     return 0;
 }

examples/camera_calibration.py

@@ -1,10 +1,10 @@
 import numpy as np
 import cv2 as cv
 
-def select_img_from_video(input_file, board_pattern, select_all=False, wait_msec=10):
+def select_img_from_video(video_file, board_pattern, select_all=False, wait_msec=10, wnd_name='Camera Calibration'):
     # Open a video
-    video = cv.VideoCapture(input_file)
-    assert video.isOpened(), 'Cannot read the given input, ' + input_file
+    video = cv.VideoCapture(video_file)
+    assert video.isOpened()
 
     # Select images
     img_select = []
@@ -20,21 +20,19 @@ def select_img_from_video(input_file, board_pattern, select_all=False, wait_msec
             # Show the image
             display = img.copy()
             cv.putText(display, f'NSelect: {len(img_select)}', (10, 25), cv.FONT_HERSHEY_DUPLEX, 0.6, (0, 255, 0))
-            cv.imshow('Camera Calibration', display)
+            cv.imshow(wnd_name, display)
 
             # Process the key event
             key = cv.waitKey(wait_msec)
-            if key == 27:                  # 'ESC' key: Exit (Complete image selection)
-                break
-            elif key == ord(' '):          # 'Space' key: Pause and show corners
+            if key == ord(' '):             # Space: Pause and show corners
                 complete, pts = cv.findChessboardCorners(img, board_pattern)
                 cv.drawChessboardCorners(display, board_pattern, pts, complete)
-                cv.imshow('Camera Calibration', display)
+                cv.imshow(wnd_name, display)
                 key = cv.waitKey()
-                if key == 27: # ESC
-                    break
-                elif key == ord('\r'):
-                    img_select.append(img) # 'Enter' key: Select the image
+                if key == ord('\r'):
+                    img_select.append(img) # Enter: Select the image
+            if key == 27:                  # ESC: Exit (Complete image selection)
+                break
 
     cv.destroyAllWindows()
     return img_select
@@ -47,23 +45,21 @@ def calib_camera_from_chessboard(images, board_pattern, board_cellsize, K=None,
         complete, pts = cv.findChessboardCorners(gray, board_pattern)
         if complete:
             img_points.append(pts)
-    assert len(img_points) > 0, 'There is no set of complete chessboard points!'
+    assert len(img_points) > 0
 
     # Prepare 3D points of the chess board
     obj_pts = [[c, r, 0] for r in range(board_pattern[1]) for c in range(board_pattern[0])]
-    obj_points = [np.array(obj_pts, dtype=np.float32) * board_cellsize] * len(img_points) # Must be 'np.float32'
+    obj_points = [np.array(obj_pts, dtype=np.float32) * board_cellsize] * len(img_points) # Must be `np.float32`
 
     # Calibrate the camera
     return cv.calibrateCamera(obj_points, img_points, gray.shape[::-1], K, dist_coeff, flags=calib_flags)
 
-
-
 if __name__ == '__main__':
-    input_file = '../data/chessboard.avi'
+    video_file = '../data/chessboard.avi'
     board_pattern = (10, 7)
     board_cellsize = 0.025
 
-    img_select = select_img_from_video(input_file, board_pattern)
+    img_select = select_img_from_video(video_file, board_pattern)
     assert len(img_select) > 0, 'There is no selected images!'
     rms, K, dist_coeff, rvecs, tvecs = calib_camera_from_chessboard(img_select, board_pattern, board_cellsize)
 

examples/camera_calibration_implement.py

@@ -26,13 +26,13 @@ def calibrateCamera(obj_pts, img_pts, img_size):
 
 if __name__ == '__main__':
     img_size = (640, 480)
-    img_files = ['../bin/data/image_formation1.xyz', '../bin/data/image_formation2.xyz']
+    img_files = ['../data/image_formation1.xyz', '../data/image_formation2.xyz']
     img_pts = []
     for file in img_files:
-        pts = np.loadtxt('../bin/data/image_formation1.xyz', dtype=np.float32)
+        pts = np.loadtxt(file, dtype=np.float32)
         img_pts.append(pts[:,:2])
 
-    pts = np.loadtxt('../bin/data/box.xyz', dtype=np.float32)
+    pts = np.loadtxt('../data/box.xyz', dtype=np.float32)
     obj_pts = [pts] * len(img_pts) # Copy the object point as much as the number of image observation
 
     # Calibrate the camera

examples/distortion_correction.cpp

@@ -2,25 +2,28 @@
 
 int main()
 {
-    const char* input = "data/chessboard.avi";
-    cv::Matx33d K(432.7390364738057, 0, 476.0614994349778, 0, 431.2395555913084, 288.7602152621297, 0, 0, 1);
+    // The given video and calibration data
+    const char* video_file = "../data/chessboard.avi";
+    cv::Matx33d K(432.7390364738057, 0, 476.0614994349778,
+                  0, 431.2395555913084, 288.7602152621297,
+                  0, 0, 1); // Derived from `calibrate_camera.py`
     std::vector<double> dist_coeff = { -0.2852754904152874, 0.1016466459919075, -0.0004420196146339175, 0.0001149909868437517, -0.01803978785585194 };
 
     // Open a video
     cv::VideoCapture video;
-    if (!video.open(input)) return -1;
+    if (!video.open(video_file)) return -1;
 
     // Run distortion correction
     bool show_rectify = true;
     cv::Mat map1, map2;
     while (true)
     {
-        // Grab an image from the video
+        // Read an image from the video
         cv::Mat image;
         video >> image;
         if (image.empty()) break;
 
-        // Rectify geometric distortion (c.f. 'cv::undistort()' can be applied for one-time remapping.)
+        // Rectify geometric distortion (Alternative: `cv.undistort()`)
         cv::String info = "Original";
         if (show_rectify)
         {
@@ -32,16 +35,11 @@ int main()
         cv::putText(image, info, cv::Point(5, 15), cv::FONT_HERSHEY_PLAIN, 1, cv::Vec3b(0, 255, 0));
 
         // Show the image
-        cv::imshow("3DV Tutorial: Distortion Correction", image);
-        int key = cv::waitKey(1);
-        if (key == 27) break;                                   // 'ESC' key: Exit
-        else if (key == 9) show_rectify = !show_rectify;        // 'Tab' key: Toggle rectification
-        else if (key == 32)                                     // 'Space' key: Pause
-        {
-            key = cv::waitKey();
-            if (key == 27) break;                               // 'ESC' key: Exit
-            else if (key == 9) show_rectify = !show_rectify;    // 'Tab' key: Toggle rectification
-        }
+        cv::imshow("Geometric Distortion Correction", image);
+        int key = cv::waitKey(10);
+        if (key == 32) key = cv::waitKey();                 // Space: Pause
+        if (key == 27) break;                               // ESC: Exit
+        else if (key == 9) show_rectify = !show_rectify;    // Tab: Toggle the mode
     }
 
     video.release();

examples/distortion_correction.py

@@ -2,15 +2,15 @@
 import cv2 as cv
 
 # The given video and calibration data
-input_file = '../data/chessboard.avi'
+video_file = '../data/chessboard.avi'
 K = np.array([[432.7390364738057, 0, 476.0614994349778],
               [0, 431.2395555913084, 288.7602152621297],
-              [0, 0, 1]])
+              [0, 0, 1]]) # Derived from `calibrate_camera.py`
 dist_coeff = np.array([-0.2852754904152874, 0.1016466459919075, -0.0004420196146339175, 0.0001149909868437517, -0.01803978785585194])
 
 # Open a video
-video = cv.VideoCapture(input_file)
-assert video.isOpened(), 'Cannot read the given input, ' + input_file
+video = cv.VideoCapture(video_file)
+assert video.isOpened(), 'Cannot read the given input, ' + video_file
 
 # Run distortion correction
 show_rectify = True
@@ -21,7 +21,7 @@
     if not valid:
         break
 
-    # Rectify geometric distortion (Alternative: cv.undistort())
+    # Rectify geometric distortion (Alternative: `cv.undistort()`)
     info = "Original"
     if show_rectify:
         if map1 is None or map2 is None:
@@ -31,13 +31,13 @@
     cv.putText(img, info, (10, 25), cv.FONT_HERSHEY_DUPLEX, 0.6, (0, 255, 0))
 
     # Show the image and process the key event
-    cv.imshow("Distortion Correction", img)
+    cv.imshow("Geometric Distortion Correction", img)
     key = cv.waitKey(10)
-    if key == ord(' '):
+    if key == ord(' '):     # Space: Pause
         key = cv.waitKey()
-    if key == 27: # ESC
+    if key == 27:           # ESC: Exit
         break
-    elif key == ord('\t'):
+    elif key == ord('\t'):  # Tab: Toggle the mode
         show_rectify = not show_rectify
 
 video.release()

examples/distortion_visualization.py

@@ -34,7 +34,7 @@
     merge = np.hstack((img_vector, img_grid))
     info = f'Focal: {K[0, 0]:.0f}, k1: {dist_coeff[0]:.2f}, k2: {dist_coeff[1]:.2f}, p1: {dist_coeff[2]:.2f}, p2: {dist_coeff[3]:.2f}'
     cv.putText(merge, info, (10, 25), cv.FONT_HERSHEY_DUPLEX, 0.6, (0, 0, 0))
-    cv.imshow('Distortion Visualization: Vectors | Grids', merge)
+    cv.imshow('Geometric Distortion Visualization: Vectors | Grids', merge)
     key = cv.waitKey()
     if key == 27: # ESC
         break

examples/fundamental_mat_estimation_implement.py

@@ -1,5 +1,5 @@
-import cv2 as cv
 import numpy as np
+import cv2 as cv
 
 def findFundamentalMat(pts1, pts2):
     if len(pts1) == len(pts2):
@@ -16,16 +16,16 @@ def findFundamentalMat(pts1, pts2):
         _, _, Vt = np.linalg.svd(A, full_matrices=True)
         x = Vt[-1]
 
-        # Reorganize 'F' and enforce 'rank(F) = 2'
+        # Reorganize `x` as `F` and enforce 'rank(F) = 2'
         F = x.reshape(3, -1)
         U, S, Vt = np.linalg.svd(F)
         S[-1] = 0
         F = U @ np.diag(S) @ Vt
         return F / F[-1,-1] # Normalize the last element as 1
 
 if __name__ == '__main__':
-    pts0 = np.loadtxt('../bin/data/image_formation0.xyz')
-    pts1 = np.loadtxt('../bin/data/image_formation1.xyz')
+    pts0 = np.loadtxt('../data/image_formation0.xyz')
+    pts1 = np.loadtxt('../data/image_formation1.xyz')
 
     my_F = findFundamentalMat(pts0, pts1)
     cv_F, _ = cv.findFundamentalMat(pts0, pts1, cv.FM_8POINT)