C# KinectSensor.MapDepthToColorImagePoint方法代码示例

    // Generate a point cloud from depth and RGB data

    internal List<ColoredPoint3d> GeneratePointCloud(
      KinectSensor kinect, short[] depth, byte[] color,
      int sampling, bool withColor = false
    )
    {
      if (depth == null || color == null)
        return null;

      int depWidth = 640;

      // We will return a list of our ColoredPoint3d objects

      List<ColoredPoint3d> res = new List<ColoredPoint3d>();

      // Loop through the depth information - we process two
      // bytes at a time

      for (int i = 0; i < depth.Length; i += sampling)
      {
        // The x and y positions can be calculated using modulus
        // division from the array index

        int x = i % depWidth;
        int y = i / depWidth;

        SkeletonPoint p =
          kinect.MapDepthToSkeletonPoint(
            DepthImageFormat.Resolution640x480Fps30,
            x, y, depth[i]
          );

        // A zero value for Z means there is no usable depth for
        // that pixel

        if (p.Z > 0)
        {
          // Create a ColoredPoint3d to store our XYZ and RGB info
          // for a pixel

          ColoredPoint3d cv = new ColoredPoint3d();
          cv.X = p.X;
          cv.Y = p.Z;
          cv.Z = p.Y;

          // Only calculate the colour when it's needed (as it's
          // now more expensive, albeit more accurate)

          if (withColor)
          {
            // Get the colour indices for that particular depth
            // pixel

            ColorImagePoint cip =
              kinect.MapDepthToColorImagePoint(
                DepthImageFormat.Resolution640x480Fps30,
                x, y, depth[i],
                ColorImageFormat.RgbResolution640x480Fps30
              );

            // Extract the RGB data from the appropriate place
            // in the colour data

            int colIndex = 4 * (cip.X + (cip.Y * depWidth));
            if (colIndex <= color.GetUpperBound(0) - 2)
            {
                cv.B = (byte)(color[colIndex + 0]);
                cv.G = (byte)(color[colIndex + 1]);
                cv.R = (byte)(color[colIndex + 2]);
            }
          }
          else
          {
            // If we don't need colour information, just set each
            // pixel to white

            cv.B = 255;
            cv.G = 255;
            cv.R = 255;
          }

          // Add our pixel data to the list to return

          res.Add(cv);
        }
      }

      // Apply a bounding box filter, if one is defined

      if (_ext.HasValue)
      {
        // Use LINQ to get the points within the
        // bounding box

        var vecSet =
          from ColoredPoint3d vec in res
          where
            vec.X > _ext.Value.MinPoint.X &&
            vec.X < _ext.Value.MaxPoint.X &&
//.........这里部分代码省略.........

        private void RenderGreenScreen(KinectSensor kinectDevice, ColorImageFrame colorFrame, DepthImageFrame depthFrame)
        {
            if (kinectDevice != null && depthFrame != null && colorFrame != null)
            {
                int depthPixelIndex;
                int playerIndex;
                int colorPixelIndex;
                ColorImagePoint colorPoint;
                int colorStride = colorFrame.BytesPerPixel * colorFrame.Width;
                int bytesPerPixel = 4;
                byte[] playerImage = new byte[depthFrame.Height * this._GreenScreenImageStride];
                int playerImageIndex = 0;

                depthFrame.CopyPixelDataTo(this._DepthPixelData);
                colorFrame.CopyPixelDataTo(this._ColorPixelData);

                for (int depthY = 0; depthY < depthFrame.Height; depthY++)
                {
                    for (int depthX = 0; depthX < depthFrame.Width; depthX++, playerImageIndex += bytesPerPixel)
                    {
                        depthPixelIndex = depthX + (depthY * depthFrame.Width);
                        playerIndex = this._DepthPixelData[depthPixelIndex] & DepthImageFrame.PlayerIndexBitmask;

                            colorPoint = kinectDevice.MapDepthToColorImagePoint(depthFrame.Format, depthX, depthY, this._DepthPixelData[depthPixelIndex], colorFrame.Format);
                            colorPixelIndex = (colorPoint.X * colorFrame.BytesPerPixel) + (colorPoint.Y * colorStride);

                            playerImage[playerImageIndex] = this._ColorPixelData[colorPixelIndex];         //Blue
                            playerImage[playerImageIndex + 1] = this._ColorPixelData[colorPixelIndex + 1];     //Green
                            playerImage[playerImageIndex + 2] = this._ColorPixelData[colorPixelIndex + 2];     //Red
                            playerImage[playerImageIndex + 3] = 0xFF;
                    }
                }

                this._GreenScreenImage.WritePixels(this._GreenScreenImageRect, playerImage, this._GreenScreenImageStride, 0);
            }
        }

        //, ColorImageFrame colorFrame, DepthImageFrame depthFrame)
        //处理数据并保存
        private void SetImageShot(KinectSensor kinectDevice, short[] depthPixelData, byte[] colorPixelData)
        {
            int depthPixelIndex = 0;
            int playerIndex = 0;
            int colorPixelIndex = 0;
            ColorImagePoint colorPoint;
            byte[] playerImage = new byte[depthFrameHeight * depthFrameStride];
            int playerImageIndex = 0;

            bool isSomeoneHere = false;

            for (int depthY = 0; depthY < depthFrameHeight; depthY++)
            {
                for (int depthX = 0; depthX < colorFrameWidth; depthX++, playerImageIndex += BytesPerPixel)
                {
                    depthPixelIndex = depthX + (depthY * colorFrameWidth);
                    playerIndex = depthPixelData[depthPixelIndex] & DepthImageFrame.PlayerIndexBitmask;

                    if (playerIndex != 0)
                    {

                        //
                        isSomeoneHere = true;

                        //
                        colorPoint = kinectDevice.MapDepthToColorImagePoint(depthImageFormat, depthX, depthY, depthPixelData[depthPixelIndex], colorImageFormat);
                        colorPixelIndex = (colorPoint.X * BytesPerPixel) + (colorPoint.Y * colorFrameStride);

                        playerImage[playerImageIndex] = colorPixelData[colorPixelIndex];         //Blue
                        playerImage[playerImageIndex + 1] = colorPixelData[colorPixelIndex + 1];     //Green
                        playerImage[playerImageIndex + 2] = colorPixelData[colorPixelIndex + 2];     //Red
                        playerImage[playerImageIndex + 3] = 0xFF;                                          //Alpha
                    }
                }
            }

            //
            if (isSomeoneHere)
            {
                SaveFunction(playerImage);
            }
        }