Draw.cpp file

        <b>Source files:</b> Click the following link to view the source code file:
            - Draw.cpp

    This file contains the code for displaying the frames from the OpenNI generator nodes.

    @section draw_cpp_glb_decls Global Type Declarations for Capture.cpp

        There are no OpenNI specific golbal declarations.

    @section draw_cpp_fns_getpoweroftwo_to_setErrorState Functions GetPowerOfTwo() to setErrorState()

        There are no OpenNI specific operations in these functions.

    @section draw_cpp_drawcropstream Function: drawCropStream() - Draws a Cropped Map from the Generator nodes

        This function draws a cropped map from each of the generator nodes.

        <b>Parameters:</b>

            <code>pGenerator</code>: Specifies one of the three map generator nodes: DepthGenerator, ImageGenerator node, or ImageGenerator node.

        First of all this function calls @ref xn::Generator::IsCapabilitySupported() to check whether this OpenNI installation supports a cropping capability.
        @code
            if (!pGenerator->IsCapabilitySupported(XN_CAPABILITY_CROPPING))
            {
                return;
            }
        @endcode

        This function calls @ref xn::MapGenerator::GetMapOutputMode() to get the Generator node's map output mode, which contains the node's current frame dimensions. the map output mode is obtaiend as an @ref xn::XnMapOutputMode "XnMapOutputMode" structure. The frame dimensions are needed for drawing the map on the graphic display.
        @code
            XnMapOutputMode Mode;
            pGenerator->GetMapOutputMode(Mode);
        @endcode

        An OpenNI @ref xn::XnCropping structure is used for containing the cropping location. Its fields are shown in the code block below.
        @code
            XnCropping cropping;
            cropping.bEnabled = TRUE;
            cropping.nXOffset = cropRect.uLeft;
            cropping.nYOffset = cropRect.uBottom;
            cropping.nXSize = cropRect.uRight - cropRect.uLeft;
            cropping.nYSize = cropRect.uTop - cropRect.uBottom;

            if ((cropping.nXOffset % dividedBy) != 0)
                cropping.nXOffset -= (cropping.nXOffset % dividedBy);
            if ((cropping.nXSize % dividedBy) != 0)
                cropping.nXSize += dividedBy - (cropping.nXSize
        @endcode

        Finally, the function assigns the cropping setting to the Generator node. To do this it calls
        @ref device_cpp_setStreamCropping "<code>setStreamCropping()</code>", which si defined in the <code>Device.cpp</code> file of this sample program.

    @section draw_cpp_drawSelectionChanged Function: drawSelectionChanged() - Callback invoked when Draw Selection has Changed

        This callback is invoked when the draw selection has been changed.

        This callback calls the @ref draw_cpp_drawcropstream function defined above for each valid Generator node. For example:
        @code
            if (getDepthGenerator() != NULL && g_DrawConfig.Streams.Depth.Coloring != DEPTH_OFF)
            {
                drawCropStream(getDepthGenerator(), g_DrawConfig.DepthLocation, selection, 2);
            }
        @endcode

    @section draw_cpp_calculateHistogram Function: calculateHistogram() - Calculates Depth Histogram

        This function uses the depth values to build an accumulative histogram of frequency of occurrence of each depth value. The *pDepth pointer accesses each value in the depth buffer. It then uses the value as an index into the g_pDepthHist histogram array.

    @section draw_cpp_YUV422ToRGB888 Function: YUV422ToRGB888() - Converts Formats

        There are no OpenNI operations in this function.
        @code
            // --------------------------------
            // Drawing
            // --------------------------------
            #if (XN_PLATFORM == XN_PLATFORM_WIN32)

            void YUV422ToRGB888(const XnUInt8* pYUVImage, XnUInt8* pRGBAImage, XnUInt32 nYUVSize, XnUInt32 nRGBSize)
            {
                ...
                ...

        @endcode

    @section draw_cpp_drawClosedStream Function: drawClosedStream() - Converts Formats

        There are no OpenNI operations in this function.

    @section draw_cpp_drawColorImage Function: drawColorImage() - Draws the Color Image Map

        This function draws the color image map for either the ImageGenerator map or the IRGenerator node.

        This function gets saved @ref glos_frame_object "frame objects", assigning them to <code>pImageMD</code> and draws them to the graphic display. The frame object is a snapshot of the generated data, saved as a metadata object, at a certain point in time. The @ref xn::OutputMetaData::Data() method gets a pointer to the data frame of the frame object saved in the metadata.
        @code
            if (isImageOn())
            {
                pImageMD = getImageMetaData();
                pImage = getImageMetaData()->Data();
            }
            else if (isIROn())
            {
                pImageMD = getIRMetaData();
                pImage = (const XnUInt8*)getIRMetaData()->Data();
            }
            else
                return;
        @endcode

        The code block above gets a pointer to the data frame of the frame object saved in the metadata. The frame object is a snapshot of the generated data at a certain point in time.

        The main draw operations are controlled by the following for-loop.
        @code
            for (XnUInt16 nY = pImageMD->YOffset(); nY < pImageMD->YRes() + pImageMD->YOffset(); nY++)
            {
                XnUInt8* pTexture = TextureMapGetLine(&g_texImage, nY) + pImageMD->XOffset()*4;
                ...
                ...
        @endcode

        The above loop provides the y indexes to access each pixel in the <code>DepthMap</code>. The @ref xn::DepthMap::YRes "YRes()" method returns the Y dimension -- height -- of the data frame.

        The following code uses the FullXRes() to calculate the scaling factor between the depth map and the GL window. FullXRes() gets the full frame resolution, i.e., the entire field-of-view, ignoring cropping of the FOV in the scene.
        @code
            if (pDepthMetaData != NULL)
            {
                XnDouble dRealX = (nX + pImageMD->XOffset()) / (XnDouble)pImageMD->FullXRes();
                XnDouble dRealY = nY / (XnDouble)pImageMD->FullYRes();

                XnUInt32 nDepthX = dRealX * pDepthMetaData->FullXRes() - pDepthMetaData->XOffset();
                XnUInt32 nDepthY = dRealY * pDepthMetaData->FullYRes() - pDepthMetaData->YOffset();

                if (nDepthX >= pDepthMetaData->XRes() || nDepthY >= pDepthMetaData->YRes())
                {
                    nDepthIndex = -1;
                }
                else
                {
                    nDepthIndex = nDepthY*pDepthMetaData->XRes() + nDepthX;
                }
            }
        @endcode

    @section draw_cpp_drawDepth Function: drawDepth() - Draws the Depth Map

        This function is implemented in a way similar to that of the draw_cpp_drawColorImage function above.

        Of note is the <><code>++pDepth</code> term in the code block below.
        @code
            for (XnUInt16 nY = pDepthMD->YOffset(); nY < pDepthMD->YRes() + pDepthMD->YOffset(); nY++)
            {
                XnUInt8* pTexture = TextureMapGetLine(&g_texDepth, nY) + pDepthMD->XOffset()*4;
                for (XnUInt16 nX = 0; nX < pDepthMD->XRes(); nX++, pDepth++, pTexture+=4)
        @endcode

        <b><code>++pDepth</code>:</b>  This pointer is incremented by 1 for each inner loop. So it steps through all the pixels in the Depth map. Thus the program can get each pixel's depth value.