/home/wu/Desktop/kiretu-0.8/YMLParser.h

Go to the documentation of this file.

/* This file is part of the Kiretu, a Kinect reconstruction tutor.
 * 
 * http://pille.iwr.uni-heidelberg.de/~kinect01/
 * 
 * The code ist licensed to you under the terms of the GNU General Public 
 * License, version 2.0. See the GPL2 file for the text of the license or the 
 * following URL:
 * 
 * http://www.gnu.org/licenses/gpl-2.0.txt
 * 
 * If you redistribute this file in source form, modified or unmodified, you
 * have to leave this header intact and distribute it under the same terms with 
 * the GPL2 file.
 * 
 * Binary distributions must follow the binary distribution requirements of
 * the License.
 * 
 */
 
 /** \file YMLParser.h
 * 
 * Header file of the YMLParser-class.
 * 
 * \author      Daniel Wunderlich (d.wunderlich@stud.uni-heidelberg.de)
 * \version     0.8
 * \date        2011-01-26
 *  
 * \see     \ref YMLParser
 */

#include <vector>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>

#include "Util.h"

/** \brief  Parameter-types of the Kinect.
 */
enum KinectParam
{
    RGB_INTRINSICS,     /**< Intrinsics of the RGB-camera */
    RGB_DISTORTION,     /**< Distortion-parameters of the RGB-camera */
    DEPTH_INTRINSICS,   /**< Intrinsics of the depth-camera */
    DEPTH_DISTORTION,   /**< Distortion-parameters of the depth-camera */
    ROT,                /**< Rotation-matrix R */
    TRANS,              /**< Translation-vector t */
    PARAM_END           /**< Dummy parameter for recognize the end of enum */
};

/** \class  YMLParser 
 *  \brief  C++-class for read in a Kinect yml calibration file and extract the 
 *          intrinsic and extrisic parameters of the Kinect.
 *  
 *  \author Daniel Wunderlich (d.wunderlich@stud.uni-heidelberg.de)
 *  \version 0.8
 *  \date   2011-01-26
 *  
 *  \see    \ref reconstruction and \ref calibration
 */
class YMLParser {
    
    public:

/** \brief Constructor of the YMLParser-class.
 *  
 *  \param  filename    /Path/to/calibrationfile.yml
 */ 
        YMLParser(const std::string filename);

/** \brief Deconstructor of the YMLParser-class.
 */ 
        ~YMLParser();

/** \brief  Reads and parses the yml-file specified at the constructor and saves 
 *          the calibration parameters in the equivalent member variables of the 
 *          class.
 */         
        void parseFile();
        
        
        // Getter
/** \brief  Get the intrinsics of the rgb-camera.
 * 
 * \return  A camera-matrix containing the intrinsic parameters of the 
 *          RGB-camera:
 *          \f[
 *              \mathbf{C} = 
 *              \begin{pmatrix}
 *                  f_x & 0 & c_x \\
 *                  0 & f_y & c_y \\
 *                  0 & 0 & 1
 *              \end{pmatrix}
 *          \f]
 */
        std::vector< std::vector<float> > getRgbCam();
        

/** \brief  Get the distortion coefficients of the RGB-camera.
 * 
 * \return  A vector containing the distortion coefficients of the RGB-camera.
 */
        std::vector<float> getRgbDist();
        

/** \brief  Get the intrinsics of the depth-camera.
 * 
 * \return  A camera-matrix containing the intrinsic parameters of the 
 *          depth-camera:
 *          \f[
 *              \mathbf{C} = 
 *              \begin{pmatrix}
 *                  f_x & 0 & c_x \\
 *                  0 & f_y & c_y \\
 *                  0 & 0 & 1
 *              \end{pmatrix}
 *          \f]
 */
        std::vector< std::vector<float> > getDepthCam();
        

/** \brief  Get the distortion coefficients of the depth-camera.
 * 
 * \return  A vector containing the distortion coefficients of the depth-camera.
 */
        std::vector<float> getDepthDist();
        
        
/** \brief  Get the rotation-matrix of the Kinect.
 * 
 * \return  Rotation-matrix of the Kinect:
 *          \f[
 *              \mathbf{T} =
 *              \begin{pmatrix}
 *                  r_{11} & r_{12} & r_{13}\\
 *                  r_{21} & r_{22} & r_{23}\\
 *                  r_{31} & r_{32} & r_{33}
 *              \end{pmatrix}
 *          \f]
 */
        std::vector< std::vector<float> > getRot();
        

/** \brief  Get the translation-vector of the Kinect.
 * 
 * \return  Translation-vector of the Kinect:
 *          \f[
 *              \mathbf{T} =
 *              \begin{pmatrix}
 *                  t_1 \\
 *                  t_2 \\
 *                  t_3
 *              \end{pmatrix}
 *          \f]
 */
        std::vector<float> getTrans();
    
    private:
        std::string filename;       /**< Path and filename of the yml file */
        std::string text;           /**< Content of the yml file */
        
        // RGB-camera intrinsics
        std::vector<std::vector<float> > rgbCam;    /**< Intrinsics of the RGB-camera. Saved as 3x3-matrix. */
        
        // RGB-camera distortion
        std::vector<float> rgbDist;                 /**< Distortion parameters of the RGB-camera. Saved as 5-dimensional vector. */
        
        // Depth-camera intrinsics
        std::vector<std::vector<float> > depthCam;  /**< Intrinsics of the depth-camera. Saved as 3x3-matrix. */
        
        // Depth-camera distortion
        std::vector<float> depthDist;               /**< Distortion parameters of the depth-camera. Saved as 5-dimensional vector. */
        
        // Rotation-matrix R
        std::vector<std::vector<float> > rot;       /**< Rotation-matrix (3x3) of the extrinsic camera-parameters */
        
        // Translation-vector t
        std::vector<float> trans;                   /**< Translation-vector (3-dimensional) of the extrinsic camera-parameters */
        
/** \brief Reads in the calibration-file.
 */ 
        void readFile();

/** \brief  Extracts the given KinectParam from the read in yml-file and stores 
 *          them in the equivalent member variables.
 *  
 *  \param  param   Parameter to extract.
 */ 
        void findParam(KinectParam param);
        
/** \brief  Splits up a string of comma separated values as used in the yml file 
 *          and stores it in the given vector.
 *  
 *  \param  str         String of comma separated values: 
 *                      value1,value2,...,valueN. Notice that there should be no 
 *                      whitespace and no comma after the last value.
 *      
 *  \param  vec         The vector the parameters should be stored to. It is 
 *                      important that the vecor is initialized with the 
 *                      corresponding size/length.
 */ 
        void csvToVector(std::string str, std::vector<float> &vec); 
            
/** \brief  Splits up a string of comma separated values as used in the yml file 
 *          and stores it in the given matrix.
 *  
 *  \param  str         String of comma separated values: 
 *                      value1,value2,...,valueN. Notice that there should be no 
 *                      whitespace and no comma after the last value.
 *      
 *  \param  mat         The matrix the parameters should be stored to. It is 
 *                      important that the matrix is initialized with the 
 *                      corresponding size/length.
 */ 
        void csvToMatrix(std::string str, std::vector< std::vector<float> > &mat);

};