Merge pull request #497 from kaustubh-sadekar/master

Added files for lens distortion post.

Author: vikasgupta-github

CameraCalibration/CMakeLists.txt

@@ -14,3 +14,4 @@ MACRO(add_example name)
 ENDMACRO()
 
 add_example(cameraCalibration)
+add_example(cameraCalibrationWithUndistortion)

CameraCalibration/README.md

@@ -4,22 +4,32 @@ Calibrate your camera using OpenCV.
 
 ## Using the C++ code
 ### Compilation
-To compile the `cameraCalibration.cpp` code, use the following:
+To compile the `cameraCalibration.cpp`  and `cameraCalibrationWithUndistortion.cpp` code files, use the following:
 ```shell
 mkdir build
 cd build
 cmake ..
 cmake --build . --config Release
 ```
-### Usage
-Refer to the following to use the compiled file:
-`./build/cameraCalibration`
+## Usage
 
-## Using the python code
-### Usage
-Refer to the following to use the `cameraCalibration.py` file:
-`python3 cameraCalibration.py`
+### Using the C++ code
 
+Refer to the following to use the compiled files:
+
+```shell
+./build/cameraCalibration
+./build/cameraCalibrationWithUndistortion
+```
+
+### Using the python code
+
+Refer to the following to use the `cameraCalibration.py` and `cameraCalibrationWithUndistortion.py` files respectively:
+
+```shell
+python3 cameraCalibration.py
+python3 cameraCalibrationWithUndistortion.py
+```
 
 # AI Courses by OpenCV
 

CameraCalibration/cameraCalibrationWithUndistortion.cpp

@@ -0,0 +1,114 @@
+#include <opencv2/opencv.hpp>
+#include <opencv2/calib3d/calib3d.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <stdio.h>
+#include <iostream>
+
+// Defining the dimensions of checkerboard
+int CHECKERBOARD[2]{6,9}; 
+
+int main()
+{
+  // Creating vector to store vectors of 3D points for each checkerboard image
+  std::vector<std::vector<cv::Point3f> > objpoints;
+
+  // Creating vector to store vectors of 2D points for each checkerboard image
+  std::vector<std::vector<cv::Point2f> > imgpoints;
+
+  // Defining the world coordinates for 3D points
+  std::vector<cv::Point3f> objp;
+  for(int i{0}; i<CHECKERBOARD[1]; i++)
+  {
+    for(int j{0}; j<CHECKERBOARD[0]; j++)
+      objp.push_back(cv::Point3f(j,i,0));
+  }
+
+
+  // Extracting path of individual image stored in a given directory
+  std::vector<cv::String> images;
+  // Path of the folder containing checkerboard images
+  std::string path = "./images/*.jpg";
+
+  cv::glob(path, images);
+
+  cv::Mat frame, gray;
+  // vector to store the pixel coordinates of detected checker board corners 
+  std::vector<cv::Point2f> corner_pts;
+  bool success;
+
+  // Looping over all the images in the directory
+  for(int i{0}; i<images.size(); i++)
+  {
+    frame = cv::imread(images[i]);
+    cv::cvtColor(frame,gray,cv::COLOR_BGR2GRAY);
+
+    // Finding checker board corners
+    // If desired number of corners are found in the image then success = true  
+    success = cv::findChessboardCorners(gray,cv::Size(CHECKERBOARD[0],CHECKERBOARD[1]), corner_pts, cv::CALIB_CB_ADAPTIVE_THRESH | cv::CALIB_CB_FAST_CHECK | cv::CALIB_CB_NORMALIZE_IMAGE);
+
+    /*
+     * If desired number of corner are detected,
+     * we refine the pixel coordinates and display 
+     * them on the images of checker board
+    */
+    if(success)
+    {
+      cv::TermCriteria criteria(cv::TermCriteria::EPS | cv::TermCriteria::MAX_ITER, 30, 0.001);
+
+      // refining pixel coordinates for given 2d points.
+      cv::cornerSubPix(gray,corner_pts,cv::Size(11,11), cv::Size(-1,-1),criteria);
+
+      // Displaying the detected corner points on the checker board
+      cv::drawChessboardCorners(frame, cv::Size(CHECKERBOARD[0],CHECKERBOARD[1]), corner_pts,success);
+
+      objpoints.push_back(objp);
+      imgpoints.push_back(corner_pts);
+    }
+
+    cv::imshow("Image",frame);
+    cv::waitKey(0);
+  }
+
+  cv::destroyAllWindows();
+
+  cv::Mat cameraMatrix,distCoeffs,R,T;
+
+  /*
+   * Performing camera calibration by 
+   * passing the value of known 3D points (objpoints)
+   * and corresponding pixel coordinates of the 
+   * detected corners (imgpoints)
+  */
+  cv::calibrateCamera(objpoints, imgpoints,cv::Size(gray.rows,gray.cols),cameraMatrix,distCoeffs,R,T);
+
+  std::cout << "cameraMatrix : " << cameraMatrix << std::endl;
+  std::cout << "distCoeffs : " << distCoeffs << std::endl;
+  std::cout << "Rotation vector : " << R << std::endl;
+  std::cout << "Translation vector : " << T << std::endl;
+
+
+  // Trying to undistort the image using the camera parameters obtained from calibration
+  
+  cv::Mat image;
+  image = cv::imread(images[0]);
+  cv::Mat dst, map1, map2,new_camera_matrix;
+  cv::Size imageSize(cv::Size(image.cols,image.rows));
+
+  // Refining the camera matrix using parameters obtained by calibration
+  new_camera_matrix = cv::getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0);
+
+  // Method 1 to undistort the image
+  cv::undistort( frame, dst, new_camera_matrix, distCoeffs, new_camera_matrix );
+
+  // Method 2 to undistort the image
+  cv::initUndistortRectifyMap(cameraMatrix, distCoeffs, cv::Mat(),cv::getOptimalNewCameraMatrix(cameraMatrix, distCoeffs,   imageSize, 1, imageSize, 0),imageSize, CV_16SC2, map1, map2);
+
+  cv::remap(frame, dst, map1, map2, cv::INTER_LINEAR);
+
+  //Displaying the undistorted image
+  cv::imshow("undistorted image",dst);
+  cv::waitKey(0);
+
+  return 0;
+}

CameraCalibration/cameraCalibrationWithUndistortion.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+
+import cv2
+import numpy as np
+import os
+import glob
+
+# Defining the dimensions of checkerboard
+CHECKERBOARD = (6,9)
+criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+
+# Creating vector to store vectors of 3D points for each checkerboard image
+objpoints = []
+# Creating vector to store vectors of 2D points for each checkerboard image
+imgpoints = [] 
+
+
+# Defining the world coordinates for 3D points
+objp = np.zeros((1, CHECKERBOARD[0]*CHECKERBOARD[1], 3), np.float32)
+objp[0,:,:2] = np.mgrid[0:CHECKERBOARD[0], 0:CHECKERBOARD[1]].T.reshape(-1, 2)
+prev_img_shape = None
+
+# Extracting path of individual image stored in a given directory
+images = glob.glob('./images/*.jpg')
+for fname in images:
+    img = cv2.imread(fname)
+    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+    # Find the chess board corners
+    # If desired number of corners are found in the image then ret = true
+    ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, cv2.CALIB_CB_ADAPTIVE_THRESH+
+    	cv2.CALIB_CB_FAST_CHECK+cv2.CALIB_CB_NORMALIZE_IMAGE)
+    
+    """
+    If desired number of corner are detected,
+    we refine the pixel coordinates and display 
+    them on the images of checker board
+    """
+    if ret == True:
+        objpoints.append(objp)
+        # refining pixel coordinates for given 2d points.
+        corners2 = cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)
+        
+        imgpoints.append(corners2)
+
+        # Draw and display the corners
+        img = cv2.drawChessboardCorners(img, CHECKERBOARD, corners2,ret)
+    
+    cv2.imshow('img',img)
+    cv2.waitKey(0)
+
+cv2.destroyAllWindows()
+
+h,w = img.shape[:2]
+
+"""
+Performing camera calibration by 
+passing the value of known 3D points (objpoints)
+and corresponding pixel coordinates of the 
+detected corners (imgpoints)
+"""
+ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1],None,None)
+
+print("Camera matrix : \n")
+print(mtx)
+print("dist : \n")
+print(dist)
+print("rvecs : \n")
+print(rvecs)
+print("tvecs : \n")
+print(tvecs)
+
+# Using the derived camera parameters to undistort the image
+
+img = cv2.imread(images[0])
+# Refining the camera matrix using parameters obtained by calibration
+newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))
+
+# Method 1 to undistort the image
+dst = cv2.undistort(img, mtx, dist, None, newcameramtx)
+
+# Method 2 to undistort the image
+mapx,mapy=cv2.initUndistortRectifyMap(mtx,dist,None,newcameramtx,(w,h),5)
+
+dst = cv2.remap(img,mapx,mapy,cv2.INTER_LINEAR)
+
+# Displaying the undistorted image
+cv2.imshow("undistorted image",dst)
+cv2.waitKey(0)

UnderstandingLensDistortion/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+set(CMAKE_CXX_STANDARD 14)
+
+PROJECT(cameracalib)
+
+find_package( OpenCV REQUIRED )
+
+include_directories( ${OpenCV_INCLUDE_DIRS})
+
+MACRO(add_example name)
+  ADD_EXECUTABLE(${name} ${name}.cpp)
+  TARGET_LINK_LIBRARIES(${name} ${OpenCV_LIBS})
+ENDMACRO()
+
+add_example(Undistort)

UnderstandingLensDistortion/README.md

@@ -0,0 +1,40 @@
+# Understanding Lens Distortion
+
+Understanding lens distortion using OpenCV.
+
+## Using the C++ code
+### Compilation
+To compile the `Undistort.cpp` code file, use the following:
+```shell
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+```
+## Usage
+
+### Using the C++ code
+
+Refer to the following to use the compiled file:
+
+```shell
+./build/Undistort
+```
+
+### Using the python code
+
+Refer to the following to use the `Undistort.py` file:
+
+```shell
+python3 Undistort.py
+```
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start. 
+
+<a href="https://opencv.org/courses/">
+<p align="center"> 
+<img src="https://www.learnopencv.com/wp-content/uploads/2020/04/AI-Courses-By-OpenCV-Github.png">
+</p>
+</a>