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

#include <algorithm>
#include <vector>

/** \class  FrameGrabber 
 *  \brief  C++-class for grabbing both depth-images and RGB-images. Due to 
 *          the varying quality of Kinects depth-reconstruction, a desired 
 *          number of depth-frames can be taken an the mean of the valid 
 *          depth-values is used as the resulting depth-value. To prevent 
 *          outliers, the standard deviation is used as a threshold of valid 
 *          values.
 *  
 *  \author Daniel Wunderlich (d.wunderlich@stud.uni-heidelberg.de)
 *  \version 0.5
 *  \date   2011-01-26
 * 
 * \see         \ref framegrabber-section
 */
class FrameGrabber {
    
    public:

/** \brief Constructor of the FrameGrabber-class.
 *  
 *  \param  numberFrames    The number of depth-images (frames) should be taken.
 * 
 *  \param  sdThreshold     Threshold for the maximum standard deviation of the 
 *                          z-values in each frame. If the threshold is 
 *                          exceeded, the z-value is not valid.
 * 
 *  \see framegrabber-section
 */ 
        FrameGrabber(unsigned int numberFrames, unsigned int sdThreshold = 5.0);


/** \brief Destructor of the FrameGrabber-class.
 */ 
        ~FrameGrabber();
    
        
/** \brief Adds a Kinect depth-frame/image to the FrameGrabber-object.
 *  
 *  \param  depth   Depth-image of Microsoft's Kinect as used in the 
 *                  glview-example of OpenKinect.
 * 
 *  \return True, if the frame was added. False, if the number of desired frames 
 *          specified at the constructor was already added.
 */ 
        bool addFrame(uint16_t* depth);


/** \brief Adds a Kinect RGB-frame/image to the FrameGrabber-object.
 *  
 *  \param  rgb RGB-image of Microsoft's Kinect as used in the 
 *              glview-example of OpenKinect.
 */ 
        void addRgb(uint8_t* rgb);


/** \brief  Computes the z-values (depth-values) of the image as the mean of all 
 *          valid depth-values per pixel. Depth-values, which standard deviation 
 *          is higher than specified at the constructor are sorted out 
 *          additional.
 */ 
        void computeZValues();

/** \brief Get the z-values (depth-values).
 * 
 *  \return int-Pointer to the \f$640 \times 480\f$-dimensional depth-value
 *          array.
 */ 
        int* getZValues();

/** \brief Get the RGB-values.
 * 
 *  \return int-Pointer to the \f$640 \times 480\f$-dimensional RGB-value-array.
 */ 
        int* getRgbValues();

/** \brief Get the indicators of valid values.
 * 
 *  \return bool-Pointer to a \f$640 \times 480\f$-dimensional boolean-array, 
 *          which indicates, if the depth-value at corresponding index is valid.
 */ 
        bool* getValidValues();


/** \brief Get the total number of valid values.
 * 
 *  \return Number of valid values.
 */ 
        int getValidCount();
    
    private:
        unsigned int numberFrames;  /**< Number of frames, which should be captured of the depth-stream. */
        int countFrames;            /**< Counts the number of frames already added to the FrameGrabber. */
        int validCountTotal;        /**< Counts the total number of valid depth-values. */
        float sdThreshold;          /**< Standard deviation threshold of valid depth-values. */
        
        int zValues[640*480];       /**< z-values (depth-values) */
        int rgbValues[640*480*3];   /**< RGB-values */
        bool validValues[640*480];  /**< Valid values */
        int (* frames)[640*480];    /**< Buffer for all captured frames */


/** \brief  Computes the standard deviation of one pixel's depth-values over all 
 *          frames.
 * 
 *  \param  index       Index of the pixel.
 *  \param  zMean       Mean of the pixel's valid z-values (depth-values).
 *  \param  validCount  Number of the pixel's valid z-values.
 * 
 *  \return Number of valid values.
 */         
        float computeSD(int index, int zMean, int validCount);
};