/home/wu/Desktop/kiretu-0.8/CloudWriter.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 CloudWriter.h
 * 
 * Header file of the CloudWriter-class.
 * 
 * \author      Daniel Wunderlich (d.wunderlich@stud.uni-heidelberg.de)
 * \version     0.8
 * \date        2011-01-26
 */

#include <vector>
#include <string>
#include <cstring>
#include <fstream>
#include <iostream>
#include <ctime>


/** \class  CloudWriter 
 *  \brief  C++-class which saves a point-cloud of Microsoft's Kinect to a 
 *          ply-file. It supports per-vertex-color and the ability of mirroring 
 *          the cloud along x-, y- and z-axis. It is also possible to export 
 *          the points which don't have an corresponding color at the RGB-image 
 *          in a custom color.
 *  
 *  \author     Daniel Wunderlich (d.wunderlich@stud.uni-heidelberg.de)
 *  \version    0.8
 *  \date       2011-01-26
 */
class CloudWriter {
    
    public:

/** \brief Constructor of the CloudWriter-class.
 *  
 *  \param  filenamePrefix  Prefix of filename.
 */ 
        CloudWriter(const std::string filenamePrefix);
        
/** \brief Destructor of the CloudWriter-class.
 */ 
        ~CloudWriter();
        
        
/** \brief  Mirror-possibilities of CloudWriter. 
 */
        enum CloudMirror
        {
            MIRROR_X,       /**< Mirror along x-axis */
            MIRROR_Y,       /**< Mirror along y-axis */
            MIRROR_Z        /**< Mirror along z-axis */
        };
        
        
/** \brief  Adds a point-cloud to the CloudWriter. This cloud should be computed 
 *          by KinectCloud before.
 *  
 *  \param  cloud   Vector of \f$640 \times 480\f$ 3-dimensional points.
 * 
 */ 
        void addCloud(std::vector< std::vector<float> > cloud);
        
        
/** \brief  Adds a vector of RGB-colors to the CloudWriter.This vector should 
 *          be computed by KinectCloud before.
 *  
 *  \param  cloudRgb    Vector of \f$640 \times 480\f$ colors. Each color is 
 *                      specified in \f$R\f$-, \f$G\f$- and \f$B\f$-values with 
 *                      \f$R, G, B \in [1, 255]\f$.
 */ 
        void addCloudRgb(std::vector< std::vector<int> > cloudRgb);


/** \brief  Adds a vector of depth-RGB-mapping values to the CloudWriter. These 
 *          values should be computed by 
 *          KinectCloud::computeRgbMapping(std::vector< std::vector<float> > rgbCam) 
 *          before.
 *  
 *  \param  cloudRgbMapping Vector of \f$640 \times 480\f$ 2-dimensional 
 *                          mapping-values.
 */ 
        void addCloudRgbMapping(std::vector< std::vector<int> > cloudRgbMapping);
        
        //~ void addNormals(std::vector< std::vector<float> > normals);


/** \brief  Adds a vector of valid-points-flags to the CloudWriter. Get 
 *          these points with KinectCloud::getValidValues().
 *  
 *  \param  validValues Vector of \f$640 \times 480\f$ booleans which indicate, 
 *                      if the corresponding vector is valid 
 *                      (\f$depth < 2047\f$).
 */ 
        void addValidValues(std::vector<bool> validValues);
        

/** \brief  Adds a vector of reconstruction-steps-flags to the CloudWriter. 
 *          Get these points with KinectCloud::getReconstructionSteps().
 *  
 *  \param  reconstructionSteps Vector of 5 booleans which indicate, if the 
 *                              equivalent reconstruction-step was done.
 * 
 *  \see    KinectCloud::getReconstructionSteps()
 */ 
        void addReconstructionSteps(std::vector<bool> reconstructionSteps);
        
        
/** \brief  Sets if points of the point-cloud, which don't have an equivalent 
 *          color at the RGB-image should be added to the final point-cloud. 
 *          They will be added with a custom color, specified with 
 *          setUndefinedColor(int color[3]).
 *  
 *  \param  printUndefined  True, if points with undefined color should 
 *                          be added to the exported file. False, if not.
 */ 
        void setUndefined(bool printUndefined);
        
        
/** \brief  Sets the color of points with undefined color.
 *  
 *  \param  color   RGB-color with \f$R, G, B \in [1, 255]\f$.
 */
        void setUndefinedColor(int color[3]);
        
        
/** \brief  Mirrors the point-cloud along the given axis. Multiple calls 
 *          possible.
 *  
 *  \param  mirror  The mirror-axis.
 */
        void setMirror(CloudMirror mirror);
        
        
/** \brief  Writes the cloud to the ply-file.
 */
        void writeCloud();
            
    private:
        std::string filenamePrefix;                         /**< Filename prefix */
        std::string filename;                               /**< Resulting filename (Filename prefix + datetime + reconstruction-steps) */
        std::vector< std::vector<float> > cloud;            /**< Point-cloud */
        std::vector< std::vector<int> > cloudRgb;           /**< RGB-values */
        std::vector< std::vector<int> > cloudRgbMapping;    /**< Coordinates of a point's corresponding color at the RGB-image */
        //~ std::vector< std::vector<float> > normals;
        std::vector<bool> validValues;                      /**< Valid flags for each point */
        std::vector<bool> reconstructionSteps;              /**< Reconstruction flags */
        std::vector< std::vector<float> > cloudOutput;      /**< Final ply-output */
        
        bool printUndefined;            /**< Flag for printing points without a corresponding color */
        bool reconstructionStepsAdded;  /**< Indicates, if the reconstruction-steps were added */
        int undefinedColor[3];          /**< Color for points with undefined colors at the RGB-image */
        int mirrorX;                    /**< Help-variable for mirroring along x-axis */
        int mirrorY;                    /**< Help-variable for mirroring along y-axis */
        int mirrorZ;                    /**< Help-variable for mirroring along z-axis */
        
        void createOutput();            /**< Generates the ply-output */
        void createFilename();          /**< Generates the filename */
};