[GSoC 2017]Photometric Calibration.

modules/photometric_calib/CMakeLists.txt

@@ -0,0 +1,2 @@
+set(the_description "Photometric Calibration")
+ocv_define_module(photometric_calib opencv_core opencv_aruco opencv_calib3d opencv_highgui WRAP python)

modules/photometric_calib/README.md

@@ -0,0 +1,8 @@
+Photometric Calibration
+================================================
+
+Implementation of non-parametric photometric calibration algorithm proposed by J. Engel et al.:
+
+1. Camera Response Function Calibration
+2. Vignette Calibration
+3. Photometric Distortion Remover

modules/photometric_calib/doc/photometric_calib.bib

@@ -0,0 +1,9 @@
+@InProceedings{engel2016monodataset,
+  author = "J. Engel and V. Usenko and D. Cremers",
+  title = "A Photometrically Calibrated Benchmark For Monocular Visual Odometry",
+  booktitle = "arXiv:1607.02555",
+  arXiv = " arXiv:1607.02555",
+  year = "2016",
+  month = "July",
+  keywords={mono-ds,dso}
+}

modules/photometric_calib/include/opencv2/photometric_calib.hpp

@@ -0,0 +1,28 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_PHOTOMETRIC_CALIB_HPP__
+#define __OPENCV_PHOTOMETRIC_CALIB_HPP__
+
+#include "opencv2/photometric_calib/Reader.hpp"
+#include "opencv2/photometric_calib/GammaRemover.hpp"
+#include "opencv2/photometric_calib/VignetteRemover.hpp"
+#include "opencv2/photometric_calib/ResponseCalib.hpp"
+#include "opencv2/photometric_calib/VignetteCalib.hpp"
+
+/**
+ * @defgroup photometric_calib Photometric Calibration
+ * The photometric_calib contains photomeric calibration algorithm proposed by Jakob Engel. \n
+ * The implementation is totally based on the paper \cite engel2016monodataset. \n
+ * Photometric calibration aimed at removing the camera response function and vitnetting artefact,
+ * by which the tracking and image alignment algorithms based on direct methods can be improved significantly. \n
+ * For details please refer to \cite engel2016monodataset.
+ */
+
+namespace cv {
+namespace photometric_calib {
+} // namespace photometric_calib
+} // namespace cv
+
+#endif

modules/photometric_calib/include/opencv2/photometric_calib/GammaRemover.hpp

@@ -0,0 +1,80 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _OPENCV_GAMMAREMOVER_HPP
+#define _OPENCV_GAMMAREMOVER_HPP
+
+#include "opencv2/core.hpp"
+
+namespace cv {
+namespace photometric_calib {
+
+//! @addtogroup photometric_calib
+//! @{
+
+/*!
+ * @brief Class for removing the camera response function (mostly gamma function) when provided with pcalib file.
+ *
+ */
+
+class CV_EXPORTS GammaRemover
+{
+public:
+    /*!
+     * @brief Constructor
+     * @param gammaPath the path of pcalib file of which the format should be .yaml or .yml
+     * @param w_ the width of input image
+     * @param h_ the height of input image
+     */
+    GammaRemover(const std::string &gammaPath, int w_, int h_);
+
+    /*!
+     * @brief get irradiance image in the form of cv::Mat. Convenient for display, etc.
+     * @param inputIm
+     * @return
+     */
+    Mat getUnGammaImageMat(Mat inputIm);
+
+    /*!
+     * @brief get irradiance image in the form of std::vector<float>. Convenient for optimization or SLAM.
+     * @param inputIm
+     * @param outImVec
+     */
+    void getUnGammaImageVec(Mat inputIm, std::vector<float> &outImVec);
+
+    /*!
+     * @brief get gamma function.
+     * @return
+     */
+    inline float *getG()
+    {
+        if (!validGamma)
+        { return 0; }
+        else
+        { return G; }
+    };
+
+    /*!
+     * @brief get inverse gamma function
+     * @return
+     */
+    inline float *getGInv()
+    {
+        if (!validGamma)
+        { return 0; }
+        else
+        { return GInv; }
+    };
+
+private:
+    float G[256];
+    float GInv[256];
+    int w, h;
+    bool validGamma;
+};
+
+} // namespace photometric_calib
+} // namespace cv
+
+#endif //_OPENCV__GAMMAREMOVER_HPP

modules/photometric_calib/include/opencv2/photometric_calib/Reader.hpp

@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _OPENCV_READER_HPP
+#define _OPENCV_READER_HPP
+
+#include "opencv2/core.hpp"
+
+#include <vector>
+#include <string>
+
+namespace cv {
+namespace photometric_calib {
+
+//! @addtogroup photometric_calib
+//! @{
+
+/*!
+ * @brief Class for reading the sequence used for photometric calibration. Both the folder path of the sequence
+ * and the path of time file should be provided. The images of the sequence should be of format CV_8U. The time
+ * file should be .yaml or .yml. In the time file, the timestamps and exposure duration of the corresponding images
+ * of the sequence should be provided.
+ *
+ * The image paths are stored in std::vector<String> images, timestamps are stored in std::vector<double> timeStamps,
+ * exposure duration is stored in std::vector<float> exposureTimes
+ */
+
+class CV_EXPORTS Reader
+{
+public:
+    /*!
+     * @brief Constructor
+     * @param folderPath the path of folder which contains the images
+     * @param imageExt the format of the input images, e.g., jpg or png.
+     * @param timesPath the path of time file
+     */
+    Reader(const std::string &folderPath, const std::string &imageExt, const std::string &timesPath);
+
+    /*!
+     * @return the amount of images loaded
+     */
+    unsigned long getNumImages() const;
+
+
+    /*!
+     * @brief Given the id of the image and return the image. id is in fact just the index of the image in the
+     * vector contains all the images.
+     * @param id
+     * @return Mat of the id^th image.
+     */
+    Mat getImage(unsigned long id) const;
+
+    /*!
+     * @brief Given the id of the image and return its timestamp value. id is in fact just the index of the image in the
+     * vector contains all the images.
+     * @param id
+     * @return timestamp of the id^th image.
+     */
+    double getTimestamp(unsigned long id) const;
+
+    /*!
+     * @brief Given the id of the image and return its exposure duration when is was taken.
+     * @param id
+     * @return exposure duration of the image.
+     */
+    float getExposureDuration(unsigned long id) const;
+
+    int getWidth() const;
+
+    int getHeight() const;
+
+    const std::string &getFolderPath() const;
+
+    const std::string &getTimeFilePath() const;
+
+private:
+    /*!
+     * @brief Load timestamps and exposure duration.
+     * @param timesFile
+     */
+    inline void loadTimestamps(const std::string &timesFile);
+
+    std::vector<String> images; //All the names/paths of images
+    std::vector<double> timeStamps; //All the Unix Time Stamps of images
+    std::vector<float> exposureDurations;//All the exposure duration for images
+
+    int _width, _height;//The image width and height. All the images should be of the same size.
+
+    std::string _folderPath;
+    std::string _timeFilePath;
+};
+
+//! @}
+
+} // namespace photometric_calib
+} // namespace cv
+
+#endif //_OPENCV_READER_HPP

modules/photometric_calib/include/opencv2/photometric_calib/ResponseCalib.hpp

@@ -0,0 +1,52 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _OPENCV_RESPONSECALIB_HPP
+#define _OPENCV_RESPONSECALIB_HPP
+
+#include "opencv2/photometric_calib/Reader.hpp"
+
+namespace cv {
+namespace photometric_calib {
+
+class CV_EXPORTS ResponseCalib
+{
+public:
+    ResponseCalib(std::string folderPath, std::string timePath, std::string imageFormat);
+
+    ResponseCalib(std::string folderPath, std::string timePath, int leakPadding, int nIts, int skipFrames,
+                  std::string imageFormat);
+
+    void plotE(const double *E, int w, int h, const std::string &saveTo);
+
+    Vec2d rmse(const double *G, const double *E, const std::vector<double> &exposureVec,
+               const std::vector<unsigned char *> &dataVec, int wh);
+
+    void plotG(const double *G, const std::string &saveTo);
+
+    void calib(bool debug);
+
+    inline const std::string &getImageFolderPath() const
+    {
+        CV_Assert(imageReader);
+        return imageReader->getFolderPath();
+    }
+
+    inline const std::string &getTimeFilePath() const
+    {
+        CV_Assert(imageReader);
+        return imageReader->getTimeFilePath();
+    }
+
+private:
+    int _leakPadding;
+    int _nIts;
+    int _skipFrames;
+    Reader *imageReader;
+};
+
+} // namespace photometric_calib
+} // namespace cv
+
+#endif //_OPENCV_RESPONSECALIB_HPP

modules/photometric_calib/include/opencv2/photometric_calib/VignetteCalib.hpp

@@ -0,0 +1,73 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _OPENCV_VIGNETTECALIB_HPP
+#define _OPENCV_VIGNETTECALIB_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/photometric_calib/Reader.hpp"
+#include "opencv2/photometric_calib/GammaRemover.hpp"
+
+namespace cv {
+namespace photometric_calib {
+
+
+class CV_EXPORTS VignetteCalib
+{
+public:
+    VignetteCalib(std::string folderPath, std::string timePath, std::string cameraFile, std::string gammaFile,
+                  std::string imageFormat);
+
+    VignetteCalib(std::string folderPath, std::string timePath, std::string cameraFile, std::string gammaFile,
+                  std::string imageFormat, int imageSkip, int maxIterations, int outlierTh,
+                  int gridWidth, int gridHeight, float facW, float facH, int maxAbsGrad);
+
+    virtual ~VignetteCalib();
+
+    //EIGEN_ALWAYS_INLINE float getInterpolatedElement(const float* const mat, const float x, const float y, const int width)
+    float getInterpolatedElement(const float *const mat, const float x, const float y, const int width);
+
+    float calMeanExposureTime();
+
+    void displayImage(float *I, int w, int h, std::string name);
+
+    void displayImageV(float *I, int w, int h, std::string name);
+
+    bool preCalib(unsigned long id, float *&image, float *&plane2imgX, float *&plane2imgY, bool debug);
+
+    void calib(bool debug);
+
+    void calibFast(bool debug);
+
+private:
+    int _imageSkip;
+    int _maxIterations;
+    int _outlierTh;
+
+    // grid width for template image.
+    int _gridWidth;
+    int _gridHeight;
+
+    // width of grid relative to marker (fac times marker size)
+    float _facW;
+    float _facH;
+
+    // remove pixel with absolute gradient larger than this from the optimization.
+    int _maxAbsGrad;
+
+    Mat _cameraMatrix;
+    Mat _distCoeffs;
+    Matx33f _K_p2idx;
+    Matx33f _K_p2idx_inverse;
+
+    Reader *imageReader;
+    GammaRemover *gammaRemover;
+
+    float _meanExposure;
+};
+
+} // namespace photometric_calib
+} // namespace cv
+
+#endif //_OPENCV_VIGNETTECALIB_HPP