public static ImageSource ToBitmap(this BodyIndexFrame frame) { int width = frame.FrameDescription.Width; int height = frame.FrameDescription.Height; PixelFormat format = PixelFormats.Bgr32; byte[] frameData = new byte[width * height]; byte[] pixels = new byte[width * height * (format.BitsPerPixel + 7) / 8]; //frame.CopyFrameDataToArray(frameData); frame.CopyFrameDataToArray(frameData); int colorIndex = 0; for (int depthIndex = 0; depthIndex < frameData.Length; ++depthIndex) { ushort depth = frameData[depthIndex]; byte intensity = (byte)(0); pixels[colorIndex++] = intensity; // Blue pixels[colorIndex++] = intensity; // Green pixels[colorIndex++] = intensity; // Red ++colorIndex; } int stride = width * format.BitsPerPixel / 8; return(BitmapSource.Create(width, height, 96, 96, format, null, pixels, stride)); }
private void IndexToBitmap(BodyIndexFrame frame) { int width = frame.FrameDescription.Width; int height = frame.FrameDescription.Height; frame.CopyFrameDataToArray(indexData); int colorIndex = 0; for (int i = 0; i < indexData.Length; ++i) { byte intensity = 0; if (indexData[i] < 6) { intensity = 255; } indexBuffer[colorIndex++] = intensity; // Blue indexBuffer[colorIndex++] = intensity; // Green indexBuffer[colorIndex++] = intensity; // Red ++colorIndex; } int stride = width * PixelFormats.Bgr32.BitsPerPixel / 8; this.indexBitmap.WritePixels(new Int32Rect(0, 0, width, height), indexBuffer, stride, 0); }
private void Reader_BodyIndexFrameArrived(object sender, BodyIndexFrameArrivedEventArgs e) { using (BodyIndexFrame bodyIndexFrame = e.FrameReference.AcquireFrame()) { if (bodyIndexFrame != null) { bodyIndexFrame.CopyFrameDataToArray(bodyIndexPixels); } for (int i = 0; i < bodyIndexPixels.Length; ++i) { if (bodyIndexPixels[i] != 255) { var color = bodyIndexColors[bodyIndexPixels[i]]; bitmapPixels[i * 4 + 0] = color.B; bitmapPixels[i * 4 + 1] = color.G; bitmapPixels[i * 4 + 2] = color.R; bitmapPixels[i * 4 + 3] = 255; } else { bitmapPixels[i * 4 + 0] = 0; bitmapPixels[i * 4 + 1] = 0; bitmapPixels[i * 4 + 2] = 0; bitmapPixels[i * 4 + 3] = 255; } } bodyIndexBitmap.WritePixels(new Int32Rect(0, 0, bodyIndexBitmap.PixelWidth, bodyIndexBitmap.PixelHeight), bitmapPixels, bodyIndexBitmap.PixelWidth * 4, 0); } }
public BodyMetaData(BodyIndexFrame myframeBodyIndex) { pixels = new byte[DepthMetaData.XDepthMaxKinect * DepthMetaData.YDepthMaxKinect]; bodyIndexWidth = myframeBodyIndex.FrameDescription.Width; bodyIndexHeight = myframeBodyIndex.FrameDescription.Height; myframeBodyIndex.CopyFrameDataToArray(Pixels); }
public unsafe void Update(BodyIndexFrame frame) { if (bodyIdx == null) { bodyIdx = new byte[DepthWidth * DepthHeight]; } frame.CopyFrameDataToArray(bodyIdx); }
/// <summary> /// Converts a depth frame to the corresponding System.Windows.Media.Imaging.BitmapSource with the players highlighted. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> /// <returns>The corresponding System.Windows.Media.Imaging.BitmapSource representation of the depth frame.</returns> public static BitmapSource ToBitmap(this DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { ushort minDepth = depthFrame.DepthMinReliableDistance; ushort maxDepth = depthFrame.DepthMaxReliableDistance; if (_bodyData == null) { _width = depthFrame.FrameDescription.Width; _height = depthFrame.FrameDescription.Height; _depthData = new ushort[_width * _height]; _bodyData = new byte[_width * _height]; _pixels = new byte[_width * _height * Constants.BYTES_PER_PIXEL]; _bitmap = new WriteableBitmap(_width, _height, Constants.DPI, Constants.DPI, Constants.FORMAT, null); } depthFrame.CopyFrameDataToArray(_depthData); bodyIndexFrame.CopyFrameDataToArray(_bodyData); // Convert the depth to RGB for (int depthIndex = 0, colorPixelIndex = 0; depthIndex < _depthData.Length && colorPixelIndex < _pixels.Length; depthIndex++, colorPixelIndex += 4) { // Get the depth for this pixel ushort depth = _depthData[depthIndex]; byte player = _bodyData[depthIndex]; // To convert to a byte, we're discarding the most-significant // rather than least-significant bits. // We're preserving detail, although the intensity will "wrap." // Values outside the reliable depth range are mapped to 0 (black). byte intensity = (byte)(depth >= minDepth && depth <= maxDepth ? depth : 0); if (player != 0xff) { // Color player gold. _pixels[colorPixelIndex + 0] = Colors.Gold.B; // B _pixels[colorPixelIndex + 1] = Colors.Gold.G; // G _pixels[colorPixelIndex + 2] = Colors.Gold.R; // R } else { // Color the rest of the image in grayscale. _pixels[colorPixelIndex + 0] = intensity; // B _pixels[colorPixelIndex + 1] = intensity; // G _pixels[colorPixelIndex + 2] = intensity; // R } } _bitmap.Lock(); Marshal.Copy(_pixels, 0, _bitmap.BackBuffer, _pixels.Length); _bitmap.AddDirtyRect(new Int32Rect(0, 0, _width, _height)); _bitmap.Unlock(); return(_bitmap); }
/// <summary> /// Handles the body index frame data arriving from the sensor /// </summary> /// <param name="sender">object sending the event</param> /// <param name="e">event arguments</param> private void Reader_BodyIndexFrameArrived(object sender, BodyIndexFrameArrivedEventArgs e) { using (BodyIndexFrame bodyIndexFrame = e.FrameReference.AcquireFrame()) { if (bodyIndexFrame != null) { bodyIndexFrame.CopyFrameDataToArray(bodyIndexDataArray); } } }
// ************************************************************************************************************************* bool RefreshFrame(MultiSourceFrame _frame) //updateframe to our array { if (_frame == null) { return(false); } try{ bodyframe = _frame.BodyFrameReference.AcquireFrame(); depthFrame = _frame.DepthFrameReference.AcquireFrame(); colorFrame = _frame.ColorFrameReference.AcquireFrame(); bodyIndexFrame = _frame.BodyIndexFrameReference.AcquireFrame(); // If any frame has expired by the time we process this event, return. // The "finally" statement will Dispose any that are not null. if ((depthFrame == null) || (colorFrame == null) || (bodyIndexFrame == null || bodyframe == null)) { return(false); } else { if (BodyData == null) { BodyData = new Body[_Sensor.BodyFrameSource.BodyCount]; } // update all the array and points bodyframe.GetAndRefreshBodyData(BodyData); colorFrame.CopyConvertedFrameDataToArray(colorData, ColorImageFormat.Rgba); depthFrame.CopyFrameDataToArray(depthData); bodyIndexFrame.CopyFrameDataToArray(bodyIndexData); // update all the array and points _frame = null; return(true); } } finally { if (bodyframe != null) { bodyframe.Dispose(); } if (depthFrame != null) { depthFrame.Dispose(); } if (colorFrame != null) { colorFrame.Dispose(); } if (bodyIndexFrame != null) { bodyIndexFrame.Dispose(); } } }
public ushort[,] depthFrameToPixelsData(DepthFrame depth_Frame, BodyIndexFrame bodyIndex_Frame) { ushort[,] darray = new ushort[424, 512]; if (depth_Frame != null && bodyIndex_Frame != null) { int width = depth_Frame.FrameDescription.Width; int height = depth_Frame.FrameDescription.Height; byte[] _bodyData = new byte[width * height]; bodyIndex_Frame.CopyFrameDataToArray(_bodyData); //Console.WriteLine("Width" + width); //Console.WriteLine("Height" + height); PixelFormat format = PixelFormats.Bgr32; stride = width * ((format.BitsPerPixel + 7) / 8); ushort minDepth = depth_Frame.DepthMinReliableDistance; ushort maxDepth = depth_Frame.DepthMaxReliableDistance; ushort[] pixelData = new ushort[width * height]; byte[] pixels = new byte[width * height * (format.BitsPerPixel + 7) / 8]; depth_Frame.CopyFrameDataToArray(pixelData); int j = 0, k = 0; for (int i = 0; i < (424 * 512) && j < 424; i++) { if (_bodyData[i] != 0xff) { darray[j, k] = pixelData[i]; } else { darray[j, k] = 0; } k++; if (k % 512 == 0) { k = 0; j++; } } } return(darray); }
/// <summary> /// Updates the bitmap with new frame data and highlights the players. /// </summary> /// <param name="depthFrame">The specified Kinect depth frame.</param> /// <param name="bodyIndexFrame">The specified Kinect body index frame.</param> public void Update(DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { ushort minDepth = depthFrame.DepthMinReliableDistance; ushort maxDepth = depthFrame.DepthMaxReliableDistance; if (BodyData == null) { Width = depthFrame.FrameDescription.Width; Height = depthFrame.FrameDescription.Height; DepthData = new ushort[Width * Height]; BodyData = new byte[Width * Height]; HighlightedPixels = new byte[Width * Height * Constants.BYTES_PER_PIXEL]; HighlightedBitmap = new Bitmap(Width, Height, Constants.FORMAT); } depthFrame.CopyFrameDataToArray(DepthData); bodyIndexFrame.CopyFrameDataToArray(BodyData); // Convert the depth to RGB for (int depthIndex = 0, colorPixelIndex = 0; depthIndex < DepthData.Length && colorPixelIndex < HighlightedPixels.Length; depthIndex++, colorPixelIndex += 4) { // Get the depth for this pixel ushort depth = DepthData[depthIndex]; byte player = BodyData[depthIndex]; // To convert to a byte, we're discarding the most-significant // rather than least-significant bits. // We're preserving detail, although the intensity will "wrap." // Values outside the reliable depth range are mapped to 0 (black). byte intensity = (byte)(depth >= minDepth && depth <= maxDepth ? depth : 0); if (player != 0xff) { // Color player gold. HighlightedPixels[colorPixelIndex + 0] = Color.Gold.B; // B HighlightedPixels[colorPixelIndex + 1] = Color.Gold.G; // G HighlightedPixels[colorPixelIndex + 2] = Color.Gold.R; // R } else { // Color the rest of the image in grayscale. HighlightedPixels[colorPixelIndex + 0] = intensity; // B HighlightedPixels[colorPixelIndex + 1] = intensity; // G HighlightedPixels[colorPixelIndex + 2] = intensity; // R } } BitmapData bitmapData = HighlightedBitmap.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadWrite, HighlightedBitmap.PixelFormat); Marshal.Copy(HighlightedPixels, 0, bitmapData.Scan0, HighlightedPixels.Length); HighlightedBitmap.UnlockBits(bitmapData); }
public void Reader_FrameArrived(object sender, BodyIndexFrameArrivedEventArgs e) { using (BodyIndexFrame bodyindexFrame = e.FrameReference.AcquireFrame()) { if (bodyindexFrame != null) { byte[] bodyindexData = new byte[depthFrameWidth * depthFrameHeight]; bodyindexFrame.CopyFrameDataToArray(bodyindexData); bodyindexframes.Add(bodyindexData); } } }
/// <summary> /// Updates the bitmap with new frame data and highlights the players. /// </summary> /// <param name="depthFrame">The specified Kinect depth frame.</param> /// <param name="bodyIndexFrame">The specified Kinect body index frame.</param> public void Update(DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { ushort minDepth = depthFrame.DepthMinReliableDistance; ushort maxDepth = depthFrame.DepthMaxReliableDistance; if (BodyData == null) { Width = depthFrame.FrameDescription.Width; Height = depthFrame.FrameDescription.Height; DepthData = new ushort[Width * Height]; BodyData = new byte[Width * Height]; HighlightedPixels = new byte[Width * Height * Constants.BYTES_PER_PIXEL]; HighlightedBitmap = new WriteableBitmap(Width, Height); HighlightedStream = HighlightedBitmap.PixelBuffer.AsStream(); } depthFrame.CopyFrameDataToArray(DepthData); bodyIndexFrame.CopyFrameDataToArray(BodyData); // Convert the depth to RGB for (int depthIndex = 0, colorPixelIndex = 0; depthIndex < DepthData.Length && colorPixelIndex < HighlightedPixels.Length; depthIndex++, colorPixelIndex += 4) { // Get the depth for this pixel ushort depth = DepthData[depthIndex]; byte player = BodyData[depthIndex]; // To convert to a byte, we're discarding the most-significant // rather than least-significant bits. // We're preserving detail, although the intensity will "wrap." // Values outside the reliable depth range are mapped to 0 (black). byte intensity = (byte)(depth >= minDepth && depth <= maxDepth ? depth : 0); if (player != 0xff) { // Color player gold. HighlightedPixels[colorPixelIndex + 0] = Colors.Gold.B; // B HighlightedPixels[colorPixelIndex + 1] = Colors.Gold.G; // G HighlightedPixels[colorPixelIndex + 2] = Colors.Gold.R; // R } else { // Color the rest of the image in grayscale. HighlightedPixels[colorPixelIndex + 0] = intensity; // B HighlightedPixels[colorPixelIndex + 1] = intensity; // G HighlightedPixels[colorPixelIndex + 2] = intensity; // R } } HighlightedStream.Seek(0, SeekOrigin.Begin); HighlightedStream.Write(HighlightedPixels, 0, HighlightedPixels.Length); HighlightedBitmap.Invalidate(); }
public Tuple <BitmapSource, TimeSpan> CaptureBodyIndexFrameBitmap(LiveFrame frame, byte[] buffer) { BodyIndexFrame bodyIndexFrame = frame.NativeBodyIndexFrame; int width = bodyIndexFrame.FrameDescription.Width; int height = bodyIndexFrame.FrameDescription.Height; bodyIndexFrame.CopyFrameDataToArray(_teenyBuffer); BitmapSource result = BufferCaptureBitmapHelper(_teenyBuffer, width, height, 1, buffer); return(new Tuple <BitmapSource, TimeSpan>(result, bodyIndexFrame.RelativeTime)); }
//frame取得時のイベント public void BodyIndexFrame_Arrived(object sender, BodyIndexFrameArrivedEventArgs e) #region { BodyIndexFrame bodyIndexFrame = e.FrameReference.AcquireFrame(); if (bodyIndexFrame == null) { return; } bodyIndexFrame.CopyFrameDataToArray(bodyIndexBuffer); //人がいないところ0xff いるところ0-6? this.KinectImagetoMat(this.kinectImage, this.bodyIndexBuffer); //this._showImageEvent(); bodyIndexFrame.Dispose(); }
void reader_MultiSourceFrameArrived(MultiSourceFrameReader sender, MultiSourceFrameArrivedEventArgs args) { using (MultiSourceFrame frame = args.FrameReference.AcquireFrame()) { if (frame != null) { //Récupération des images using (BodyFrame bodyFrame = frame.BodyFrameReference.AcquireFrame()) //################# BODYFRAME using (BodyIndexFrame bodyIndexFrame = frame.BodyIndexFrameReference.AcquireFrame()) //################# BODY INDEX using (ColorFrame colorFrame = frame.ColorFrameReference.AcquireFrame()) //################# COLOR { if (bodyIndexFrame != null && bodyFrame != null && colorFrame != null) { //Initilisation et mise à jour du tableau de body if (this.bodies == null) { this.bodies = new Body[bodyFrame.BodyCount]; } bodyFrame.GetAndRefreshBodyData(this.bodies); //WriteableBitmap bitmap = (WriteableBitmap)this.kinectImage.Source; //Tableau contenant les données bodyIndex byte[] bodyIndexArray = new byte[bodyIndexFrame.FrameDescription.LengthInPixels * bodyIndexFrame.FrameDescription.BytesPerPixel]; bodyIndexFrame.CopyFrameDataToArray(bodyIndexArray); colorFrame.CopyConvertedFrameDataToBuffer(bitmap.PixelBuffer, ColorImageFormat.Bgra); foreach (Body b in this.bodies) { ColorSpacePoint[] colorPoint = new ColorSpacePoint[1]; kinect.CoordinateMapper.MapCameraPointsToColorSpace(new CameraSpacePoint[] { b.Joints[JointType.HandLeft].Position }, colorPoint); try { Canvas.SetLeft(ellipse, colorPoint[0].X); Canvas.SetTop(ellipse, colorPoint[0].Y); }catch (Exception e) { } } } } } } }
private void DepthFrameReady(object sender, BodyIndexFrameArrivedEventArgs e) { BodyIndexFrame frame = e.FrameReference.AcquireFrame(); if (frame != null) { this.FInvalidate = true; this.frameindex = frame.RelativeTime.Ticks; lock (m_lock) { frame.CopyFrameDataToArray(this.rawdepth); } frame.Dispose(); } }
internal static void CopyToFrameToPixelArray(this BodyIndexFrame bodyIndexFrame, ref byte[] frameData, ref byte[] pixels) { var pixelIndex = 0; bodyIndexFrame.CopyFrameDataToArray(frameData); for (int i = 0; i < frameData.Length; ++i) { var color = BodyIndexColor.GetColorFromBodyIndex(frameData[i]); pixels[pixelIndex++] = color.B; pixels[pixelIndex++] = color.G; pixels[pixelIndex++] = color.R; pixels[pixelIndex++] = color.A; } }
private void ProcessBodyIndexFrame(BodyIndexFrame bodyIndexFrame) { if (bodyIndexFrame != null) { byte[] outBuffer = _displayableBuffers[SourceType.BODY_INDEX]; bodyIndexFrame.CopyFrameDataToArray(_rawBodyIndexPixels); bodyIndexFrame.Dispose(); int outIndex = 0; for (int inIndex = 0; inIndex < _rawBodyIndexPixels.Length; ++inIndex) { int bodyIndex = _rawBodyIndexPixels[inIndex]; UInt32 thisColor = 0; _bodyIndexToColorMap.TryGetValue(bodyIndex, out thisColor); outBuffer[outIndex++] = (byte)((thisColor & 0xFF000000) >> 32); // Blue channel outBuffer[outIndex++] = (byte)((thisColor & 0x00FF0000) >> 16); // Green channel outBuffer[outIndex++] = (byte)((thisColor & 0x0000FF00) >> 8); // Red channel outBuffer[outIndex++] = (byte)((thisColor & 0x000000FF)); // Alpha channel } } }
/* * The pixel values in this frame are 8-bit unsigned integers, where 0-5 map directly to the BodyData index in the BodyFrame. * Values greater than the value obtained from BodyCount indicate the pixel is part of the background, not associated with a tracked body. * This frame is useful for green screening applications, or any scenario where you want to display the silhouette of the user. * It also provides a good starting bounds for custom depth algorithms. */ private void updateBodyIndexEvent(object sender, BodyIndexFrameArrivedEventArgs e) { using (BodyIndexFrame frame = e.FrameReference.AcquireFrame()) { if (frame != null) { FrameDescription frameDescription = frame.FrameDescription; // verify data and write the data to the display bitmap if ((frameDescription.Width * frameDescription.Height) == 424 * 512) { WriteableBitmap Bitmap = BitmapFactory.New(frameDescription.Width, frameDescription.Height); byte[] frameData = new byte[frameDescription.Width * frameDescription.Height]; frame.CopyFrameDataToArray(frameData); for (int y = 0; y < frameDescription.Height; y++) { for (int x = 0; x < frameDescription.Width; x++) { int index = y * frameDescription.Width + x; if (frameData[index] != 0xff) { myColor.HSB hsb = new myColor.HSB(); hsb.H = x / frameDescription.Height * 255; hsb.S = Numbers.ConvertToRange(y, 0, frameDescription.Height / 2, 0, 1, true); hsb.B = Numbers.ConvertToRange(y, frameDescription.Height / 2, frameDescription.Height, 1, 0, true); System.Drawing.Color color = myColor.FromHSB(hsb); // make a dynamic image, also there can be up to 6 images so we need them to be a little different Bitmap.SetPixel(x, y, color.A, color.R, color.G, color.B); } else { Bitmap.SetPixel(x, y, 255, 0, 255, 0); // green } } } SendImage(Bitmap, "kinectbodyindex"); } } } }
private void DepthFrameReady(object sender, BodyIndexFrameArrivedEventArgs e) { BodyIndexFrame frame = e.FrameReference.AcquireFrame(); int bg = this.backcolor; if (frame != null) { this.FInvalidate = true; this.frameindex = frame.RelativeTime.Ticks; lock (m_lock) { frame.CopyFrameDataToArray(this.rawdepth); for (int i16 = 0; i16 < 512 * 424; i16++) { byte player = rawdepth[i16]; this.playerimage[i16] = player == 255 ? bg : this.colors[player % 6]; } } frame.Dispose(); } }
private void Reader_MultiSourceFrameArrived(object sender, MultiSourceFrameArrivedEventArgs e) { // All frame counter this.frameCount++; if (this.frameCount % this.framesToCapture != 0) { return; } ColorFrame colorFrame = null; DepthFrame depthFrame = null; BodyFrame bodyFrame = null; BodyIndexFrame bodyIndexFrame = null; Body body = null; SkeletonOfBody skel_up = new SkeletonOfBody(Constants.SKEL_UP_TOTAL_JOINTS); try { var frameReference = e.FrameReference.AcquireFrame(); colorFrame = frameReference.ColorFrameReference.AcquireFrame(); depthFrame = frameReference.DepthFrameReference.AcquireFrame(); bodyFrame = frameReference.BodyFrameReference.AcquireFrame(); bodyIndexFrame = frameReference.BodyIndexFrameReference.AcquireFrame(); if (colorFrame == null || depthFrame == null || bodyFrame == null || bodyIndexFrame == null) { return; } //-------------------------------------------- // Get the color frame //-------------------------------------------- using (KinectBuffer colorBuffer = colorFrame.LockRawImageBuffer()) { colorFrame.CopyConvertedFrameDataToArray(this.buffColor32, ColorImageFormat.Bgra); } //End ColorFrame //-------------------------------------------- // Get the depth frame //-------------------------------------------- using (KinectBuffer depthBuffer = depthFrame.LockImageBuffer()) { depthFrame.CopyFrameDataToArray(this.buffDepth16); //depthFrame.CopyFrameDataToArray(this.buffDepth16Copy); // Multiplication by 20 only to turn the depth visually more perceptible //int i = 0; //Array.ForEach(this.buffDepth16Copy, (x) => { this.buffDepth16Copy[i++] = (ushort)(x * 20); }); } //End DepthFrame //-------------------------------------------- // Get the body index frame //-------------------------------------------- using (KinectBuffer bodyIndexBuffer = bodyIndexFrame.LockImageBuffer()) { bodyIndexFrame.CopyFrameDataToArray(this.buffBodyIndex8); } //-------------------------------------------- // Get the body frame //-------------------------------------------- bodyFrame.GetAndRefreshBodyData(this.listBodies); //bodyFrame.FloorClipPlane. //-------------------------------------------- // Map the depth frame to it color frame //-------------------------------------------- { Array.Clear(this.buffColorSpacePoints, 0, this.buffColorSpacePoints.Length); Array.Clear(this.buffMapDepthToColor32, 0, this.buffMapDepthToColor32.Length); // Coordinate mapping this.coordinateMapper.MapDepthFrameToColorSpace(this.buffDepth16, this.buffColorSpacePoints); unsafe { fixed(ColorSpacePoint *depthMappedToColorPointsPointer = buffColorSpacePoints) { // Loop over each row and column of the color image // Zero out any pixels that don't correspond to a body index for (int idxDepth = 0; idxDepth < buffColorSpacePoints.Length; ++idxDepth) { float depthMappedToColorX = depthMappedToColorPointsPointer[idxDepth].X; float depthMappedToColorY = depthMappedToColorPointsPointer[idxDepth].Y; // The sentinel value is -inf, -inf, meaning that no depth pixel corresponds to this color pixel. if (!float.IsNegativeInfinity(depthMappedToColorX) && !float.IsNegativeInfinity(depthMappedToColorY)) { // Make sure the depth pixel maps to a valid point in color space int colorX = (int)(depthMappedToColorX + 0.5f); int colorY = (int)(depthMappedToColorY + 0.5f); // If the point is not valid, there is no body index there. if ((colorX >= 0) && (colorX < this.colorImageSize.Width) && (colorY >= 0) && (colorY < this.colorImageSize.Height)) { int idxColor = (colorY * this.colorImageSize.Width) + colorX; // If we are tracking a body for the current pixel, save the depth data if (this.buffBodyIndex8[idxDepth] != 0xff) { this.buffMapDepthToColor32[idxDepth * 4] = this.buffColor32[idxColor * 4]; // B this.buffMapDepthToColor32[idxDepth * 4 + 1] = this.buffColor32[idxColor * 4 + 1]; // G this.buffMapDepthToColor32[idxDepth * 4 + 2] = this.buffColor32[idxColor * 4 + 2]; // R } } } } } } //End Unsafe } //End Mapping //-------------------------------------------- // Process the face of the default body //-------------------------------------------- // Variable to save the detected face paramenters this.faceData = new FaceData(new BoxFace(0, 0, 0, 0), new BoxFace(0, 0, 0, 0)); #if FACE_DETECTION // Get the default body // Body body = this.listBodies.Where(b => b.IsTracked).FirstOrDefault(); if (this.faceFrameSource.IsActive) { // In our experiment we get the closest body body = Util.GetClosestBody(this.listBodies); if (body != null && body.IsTracked) { // Get the first skeleton skel_up = Util.GetSkeletonUpperBody(this.Mapper, body); // Draw skeleton joints if (this.drawingDepthMarkups) { Util.WriteSkeletonOverFrame(this, VisTypes.Depth, skel_up, 2, ref this.buffMapDepthToColor32); //Util.WriteSkeletonOverFrame(this, VisTypes.Depth, skeleton, 2, ref this.buffDepth16); } // Assign a tracking ID to the face source this.faceFrameSource.TrackingId = body.TrackingId; if (this.faceFrameResults != null) { var boxColor = this.faceFrameResults.FaceBoundingBoxInColorSpace; var boxDepth = this.faceFrameResults.FaceBoundingBoxInInfraredSpace; // If there are face results, then save data // We save in a format of rectangle [x, y, width, height] this.faceData.boxColor = new BoxFace(boxColor.Left, boxColor.Top, (boxColor.Right - boxColor.Left), (boxColor.Bottom - boxColor.Top)); this.faceData.boxDepth = new BoxFace(boxDepth.Left, boxDepth.Top, (boxDepth.Right - boxDepth.Left), (boxDepth.Bottom - boxDepth.Top)); // Draw the face if (this.drawingDepthMarkups) { Util.WriteFaceOverFrame(this, VisTypes.Depth, faceData.boxDepth, 1, ref this.buffMapDepthToColor32); //Util.WriteFaceOverFrame(this, VisTypes.Depth, faceData.boxDepth, 1, ref this.buffDepth16); } //End Drawing } //End FaceResult } //End Body } #endif // Update the data handler this.frameHandler( this.buffColor32, this.buffDepth16, this.buffBodyIndex8, this.buffMapDepthToColor32, this.listBodies, this.faceData ); // Recording state ture byte[] _colorData = null; ushort[] _depthData = null; byte[] _bodyIndexData = null; IList <Body> _bodies = null; //-------------------------------------------- // Record the data //-------------------------------------------- if (this.stateOfRecording) { // 25-09-15 // Discard frames where the hand is not corrected tracked (i.e., the hand has a zero coordinate) // To discard failures in hand tracking if (skel_up.jointDepthSpace[(int)JointUpType.HandLeft].X == 0 || skel_up.jointDepthSpace[(int)JointUpType.HandLeft].Y == 0 || skel_up.jointDepthSpace[(int)JointUpType.HandRight].X == 0 || skel_up.jointDepthSpace[(int)JointUpType.HandRight].Y == 0) { Console.WriteLine("Neglect frame {0}", this.recordedFrames); return; } // Storage data; _colorData = new byte[this.buffColor32.Length]; _depthData = new ushort[this.buffDepth16.Length]; _bodyIndexData = new byte[this.buffBodyIndex8.Length]; _bodies = new Body[this.listBodies.Count]; colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); depthFrame.CopyFrameDataToArray(_depthData); bodyIndexFrame.CopyFrameDataToArray(_bodyIndexData); bodyFrame.GetAndRefreshBodyData(_bodies); // Increase the counter this.recordedFrames++; this.dataContainer.AddColor = _colorData; this.dataContainer.AddDepth = _depthData; this.dataContainer.AddBodyIndex = _bodyIndexData; this.dataContainer.AddListOfBodies = _bodies; this.dataContainer.AddFaceData = this.faceData; // If the user only require to save a fixed number of frames if (this.fixedFrames == this.recordedFrames) { this.stateOfRecording = false; } } // Notice: // Array.Copy() --> how many elements to copy // Buffer.BlockCopy --> how many of bytes to copy // Update Frame Rate UpdateGrabberFrameRate(); } finally { if (this.frameCount > 100000000) { this.frameCount = 0; } if (colorFrame != null) { colorFrame.Dispose(); } if (depthFrame != null) { depthFrame.Dispose(); } if (bodyFrame != null) { bodyFrame.Dispose(); } if (bodyIndexFrame != null) { bodyIndexFrame.Dispose(); } } }
/// <summary> /// Converts a depth frame to the corresponding System.Windows.Media.Imaging.BitmapSource and removes the background (green-screen effect). /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> /// <returns>The corresponding System.Windows.Media.Imaging.BitmapSource representation of image.</returns> public Bitmap GreenScreen(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth * depthHeight]; _bodyData = new byte[depthWidth * depthHeight]; _colorData = new byte[colorWidth * colorHeight * Constants.BYTES_PER_PIXEL]; _displayPixels = new byte[depthWidth * depthHeight * Constants.BYTES_PER_PIXEL]; _colorPoints = new ColorSpacePoint[depthWidth * depthHeight]; _bitmap = new Bitmap(depthWidth, depthHeight, Constants.FORMAT); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; byte player = _bodyData[depthIndex]; if (player != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * Constants.BYTES_PER_PIXEL; int displayIndex = depthIndex * Constants.BYTES_PER_PIXEL; _displayPixels[displayIndex + 0] = _colorData[colorIndex]; _displayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _displayPixels[displayIndex + 2] = _colorData[colorIndex + 2]; _displayPixels[displayIndex + 3] = 0xff; } } } } BitmapData bitmapData = _bitmap.LockBits(new Rectangle(0, 0, depthWidth, depthHeight), ImageLockMode.ReadWrite, _bitmap.PixelFormat); Marshal.Copy(_displayPixels, 0, bitmapData.Scan0, _displayPixels.Length); _bitmap.UnlockBits(bitmapData); } return(_bitmap); }
/// <summary> /// 人が映った画素領域だけを映した BitmapSource を取得します。 /// </summary> /// <param name="colorFrame"> /// カラー画像フレーム。 /// </param> /// <param name="depthFrame"> /// 深度フレーム。 /// </param> /// <param name="bodyIndexFrame"> /// BodyIndex フレーム。 /// </param> /// <returns> /// 人が映った画素領域だけを映した BitmapSource。 /// </returns> BitmapSource GetUserMaskImage(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { byte[] colors = new byte[this.colorFrameDescription.Width * this.colorFrameDescription.Height * this.colorFrameDescription.BytesPerPixel]; colorFrame.CopyConvertedFrameDataToArray(colors, this.colorImageFormat); ushort[] depths = new ushort[this.depthFrameDescription.Width * this.depthFrameDescription.Height]; depthFrame.CopyFrameDataToArray(depths); byte[] bodyIndexes = new byte[this.bodyIndexFrameDescription.Width * this.bodyIndexFrameDescription.Height]; bodyIndexFrame.CopyFrameDataToArray(bodyIndexes); //人が映っているだけの画像を表す byte 配列を用意して 0 で初期化する。 byte[] bodyColors = new byte[this.bodyIndexFrameDescription.Width * this.bodyIndexFrameDescription.Height * this.colorFrameDescription.BytesPerPixel]; Array.Clear(bodyColors, 0, bodyColors.Length); //カラー画像と深度画像の座標を対応させる(= マッピングする)必要がある。 //ColorSpacePoint はカラー画像の座標を示す構造体。 ColorSpacePoint[] colorSpacePoints = new ColorSpacePoint[this.bodyIndexFrameDescription.Width * this.bodyIndexFrameDescription.Height]; this.kinect.CoordinateMapper.MapDepthFrameToColorSpace(depths, colorSpacePoints); for (int y = 0; y < this.depthFrameDescription.Height; y++) { for (int x = 0; x < this.depthFrameDescription.Width; x++) { int depthsIndex = y * this.depthFrameDescription.Width + x; if (bodyIndexes[depthsIndex] != 255) { //対応するカラー画像の座標を取得し、 //カラー画像座標系の範囲内に収まるかを判定する。 ColorSpacePoint colorSpacePoint = colorSpacePoints[depthsIndex]; int colorX = (int)colorSpacePoint.X; int colorY = (int)colorSpacePoint.Y; if ((colorSpacePoint.X >= 0) && (colorSpacePoint.X < this.colorFrameDescription.Width) && (colorSpacePoint.Y >= 0) && (colorSpacePoint.Y < this.colorFrameDescription.Height)) { //対応するカラー画像の画素から色情報を取得して、 //新しいカラー画像のデータに与える。 int colorsIndex = (colorY * this.colorFrameDescription.Width + colorX) * 4; int bodyColorsIndex = depthsIndex * 4; bodyColors[bodyColorsIndex] = colors[colorsIndex]; bodyColors[bodyColorsIndex + 1] = colors[colorsIndex + 1]; bodyColors[bodyColorsIndex + 2] = colors[colorsIndex + 2]; bodyColors[bodyColorsIndex + 3] = 255; } } } } BitmapSource bitmapSource = BitmapSource.Create(depthFrameDescription.Width, depthFrameDescription.Height, 96, 96, PixelFormats.Bgra32, null, bodyColors, depthFrameDescription.Width * 4); return(bitmapSource); }
/// <summary> /// Updates the bitmap with new frame data. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> override public void Update(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (Bitmap == null) { InitBuffers(colorFrame.FrameDescription, depthFrame.FrameDescription, bodyIndexFrame.FrameDescription); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == Pixels.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(Pixels); } else { colorFrame.CopyConvertedFrameDataToArray(Pixels, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapColorFrameToDepthSpace(_depthData, _depthPoints); // Loop over each row and column of the color image // Zero out any pixels that don't correspond to a body index for (int i = 0, ci = 0; i < _depthPoints.Length; ++i, ci += Constants.BYTES_PER_PIXEL) { float colorToDepthX = _depthPoints[i].X; float colorToDepthY = _depthPoints[i].Y; // The sentinel value is -inf, -inf, meaning that no depth pixel corresponds to this color pixel. if (!float.IsNegativeInfinity(colorToDepthX) && !float.IsNegativeInfinity(colorToDepthY)) { // Make sure the depth pixel maps to a valid point in color space int depthX = (int)(colorToDepthX + 0.5f); int depthY = (int)(colorToDepthY + 0.5f); // If the point is not valid, there is no body index there. if ((depthX >= 0) && (depthX < depthWidth) && (depthY >= 0) && (depthY < depthHeight)) { int depthIndex = (depthY * depthWidth) + depthX; // If we are tracking a body for the current pixel, do not zero out the pixel if (_bodyData[depthIndex] != 0xff) { continue; } } } for (int b = 0; b < Constants.BYTES_PER_PIXEL; ++b) { Pixels[ci + b] = 0; } } UpdateBitmap(); } }
/// <summary> /// Converts a depth frame to the corresponding System.Windows.Media.Imaging.BitmapSource and removes the background (green-screen effect). /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> /// <returns>The corresponding System.Windows.Media.Imaging.BitmapSource representation of image.</returns> public WriteableBitmap GreenScreen(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth * depthHeight]; _bodyData = new byte[depthWidth * depthHeight]; _colorData = new byte[colorWidth * colorHeight * Constants.BYTES_PER_PIXEL]; _displayPixels = new byte[depthWidth * depthHeight * Constants.BYTES_PER_PIXEL]; _colorPoints = new ColorSpacePoint[depthWidth * depthHeight]; _bitmap = new WriteableBitmap(depthWidth, depthHeight); _stream = _bitmap.PixelBuffer.AsStream(); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; byte player = _bodyData[depthIndex]; if (player != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * Constants.BYTES_PER_PIXEL; int displayIndex = depthIndex * Constants.BYTES_PER_PIXEL; _displayPixels[displayIndex + 0] = _colorData[colorIndex]; _displayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _displayPixels[displayIndex + 2] = _colorData[colorIndex + 2]; _displayPixels[displayIndex + 3] = 0xff; } } } } _stream.Seek(0, SeekOrigin.Begin); _stream.Write(_displayPixels, 0, _displayPixels.Length); _bitmap.Invalidate(); } return _bitmap; }
private void ProcessFrames(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame, BodyFrame bodyFrame, byte [] psBytes0, byte [] psBytes1) { // create multiframe to process long ticksCopyData = DateTime.Now.Ticks; MultiFrame multiFrame = new MultiFrame(); multiFrame.FrameNb = Interlocked.Increment(ref frameNb); // color long ticksCreateColorData = DateTime.Now.Ticks; byte[] colorData = new byte[colorByteSize]; Utils.UpdateTimer("CreateColorData", ticksCreateColorData); long ticksCopyColorData = DateTime.Now.Ticks; colorFrame.CopyConvertedFrameDataToArray(colorData, ColorImageFormat.Bgra); Utils.UpdateTimer("CopyColorData", ticksCopyColorData); // depth long ticksCreateDepthData = DateTime.Now.Ticks; ushort[] depthData = new ushort[depthPixelSize]; depthFrame.CopyFrameDataToArray(depthData); Utils.UpdateTimer("CreateDepthData", ticksCreateDepthData); // body index long ticksCreateBodyIndexData = DateTime.Now.Ticks; byte[] bodyIndexData = new byte[depthPixelSize]; bodyIndexFrame.CopyFrameDataToArray(bodyIndexData); Utils.UpdateTimer("CreateBodyIndexData", ticksCreateBodyIndexData); // bodies long ticksCreateBodiesData = DateTime.Now.Ticks; Body[] bodies = new Body[bodyFrame.BodyCount]; bodyFrame.GetAndRefreshBodyData(bodies); Utils.UpdateTimer("CreateBodiesData", ticksCreateBodiesData); // ps3eye byte[] psBytes = null; if (psBytes0 != null && psBytes1 != null) { long ticksCreatePS3EyeData = DateTime.Now.Ticks; psBytes = new byte[psByteSize * 2]; Utils.UpdateTimer("CreatePS3EyeData", ticksCreatePS3EyeData); long ticksCopyPS3EyeData = DateTime.Now.Ticks; CopyPS3EyeDataMirror(psBytes, psBytes0, psBytes1); Utils.UpdateTimer("CopyPS3EyeData", ticksCopyPS3EyeData); } // multiFrame long ticksMultiFrame = DateTime.Now.Ticks; multiFrame.DepthData = depthData; multiFrame.ColorData = colorData; multiFrame.BodyIndexData = bodyIndexData; multiFrame.Bodies = bodies; multiFrame.PS3EyeData = psBytes; multiFrame.HasKinectData = true; multiFrame.HasPS3EyeData = psBytes != null ? true : false; Utils.UpdateTimer("MultiFrame", ticksMultiFrame); long ticksEnqueue = DateTime.Now.Ticks; ProcessingManager.Instance.EnqueueMultiFrame(multiFrame); Utils.UpdateTimer("Enqueue", ticksEnqueue); Utils.UpdateTimer("CopyFramesData", ticksCopyData); // display timers & queues Context.GUI.DisplayPerformance(); }
/// <summary> /// Updates the bitmap with new frame data. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> override public void Update(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (Bitmap == null) { InitBuffers(colorFrame.FrameDescription, depthFrame.FrameDescription, bodyIndexFrame.FrameDescription); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(Pixels, 0, Pixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; if (_bodyData[depthIndex] != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)(colorPoint.X + 0.5); int colorY = (int)(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * Constants.BYTES_PER_PIXEL; int displayIndex = depthIndex * Constants.BYTES_PER_PIXEL; for (int b = 0; b < Constants.BYTES_PER_PIXEL; ++b) { Pixels[displayIndex + b] = _colorData[colorIndex + b]; } } } } } UpdateBitmap(); } }
/// <summary> /// Updates the bitmap with new frame data. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> override public void Update(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (Bitmap == null) { InitBuffers(colorFrame.FrameDescription, depthFrame.FrameDescription, bodyIndexFrame.FrameDescription); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == Pixels.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(Pixels); } else { colorFrame.CopyConvertedFrameDataToArray(Pixels, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapColorFrameToDepthSpace(_depthData, _depthPoints); // Loop over each row and column of the color image // Zero out any pixels that don't correspond to a body index for (int i = 0, ci = 0; i < _depthPoints.Length; ++i, ci += Constants.BYTES_PER_PIXEL) { float colorToDepthX = _depthPoints[i].X; float colorToDepthY = _depthPoints[i].Y; // The sentinel value is -inf, -inf, meaning that no depth pixel corresponds to this color pixel. if (!float.IsNegativeInfinity(colorToDepthX) && !float.IsNegativeInfinity(colorToDepthY)) { // Make sure the depth pixel maps to a valid point in color space int depthX = (int)(colorToDepthX + 0.5f); int depthY = (int)(colorToDepthY + 0.5f); // If the point is not valid, there is no body index there. if ((depthX >= 0) && (depthX < depthWidth) && (depthY >= 0) && (depthY < depthHeight)) { int depthIndex = (depthY * depthWidth) + depthX; // If we are tracking a body for the current pixel, do not zero out the pixel if (_bodyData[depthIndex] != 0xff) { continue; } } } for (int b = 0; b < Constants.BYTES_PER_PIXEL; ++b) { Pixels[ci + b] = 0; } } UpdateBitmap(); } }
public ColorPointCloud(ColorFrame iColorFrame, DepthFrame iDepthFrame, BodyIndexFrame iBodyIndexFrame, CoordinateMapper iCoordinateMapper) { TimeStamp = DateTime.Now; Width = iDepthFrame.FrameDescription.Width; Height = iDepthFrame.FrameDescription.Height; var depthData = new ushort[Width * Height]; //BodyData = new int[Width * Height]; iDepthFrame.CopyFrameDataToArray(depthData); var bodyData = new byte[Width * Height]; iBodyIndexFrame.CopyFrameDataToArray(bodyData); var colorWidth = iColorFrame.FrameDescription.Width; var colorHeight = iColorFrame.FrameDescription.Height; var colorData = new byte[colorWidth * colorHeight * KinectConstants.BYTES_PER_PIXEL]; if (iColorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { iColorFrame.CopyRawFrameDataToArray(colorData); } else { iColorFrame.CopyConvertedFrameDataToArray(colorData, ColorImageFormat.Bgra); } var colorPoints = new ColorSpacePoint[Width * Height]; iCoordinateMapper.MapDepthFrameToColorSpace(depthData, colorPoints); var displayPixels = new byte[Width * Height * KinectConstants.BYTES_PER_PIXEL]; Array.Clear(displayPixels, 0, displayPixels.Length); var bodyDataBool = new bool[Width * Height]; var colorDataWithoutAlpha = new byte[Width * Height * 3]; for (var y = 0; y < Height; ++y) { for (var x = 0; x < Width; ++x) { var depthIndex = (y * Width) + x; var player = bodyData[depthIndex]; if (player != 0xff) { bodyDataBool[depthIndex] = true; var colorPoint = colorPoints[depthIndex]; var colorX = (int)Math.Floor(colorPoint.X + 0.5); var colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { var colorIndex = ((colorY * colorWidth) + colorX) * KinectConstants.BYTES_PER_PIXEL; var displayIndex = depthIndex * KinectConstants.BYTES_PER_PIXEL; displayPixels[displayIndex + 0] = colorData[colorIndex]; // B displayPixels[displayIndex + 1] = colorData[colorIndex + 1]; // G displayPixels[displayIndex + 2] = colorData[colorIndex + 2]; // R displayPixels[displayIndex + 3] = 0xff; // Alpha var colorDataIndex = depthIndex * 3; colorDataWithoutAlpha[colorDataIndex + 0] = colorData[colorIndex + 0]; colorDataWithoutAlpha[colorDataIndex + 1] = colorData[colorIndex + 1]; colorDataWithoutAlpha[colorDataIndex + 2] = colorData[colorIndex + 2]; } } } } DisplayPixels = displayPixels; BodyData = bodyDataBool; DepthData = depthData; ColorData = colorDataWithoutAlpha; }
/// <summary> /// Converts a depth frame to the corresponding System.Windows.Media.Imaging.BitmapSource and removes the background (green-screen effect). /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> /// <returns>The corresponding System.Windows.Media.Imaging.BitmapSource representation of image.</returns> public Bitmap GreenScreen(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth * depthHeight]; _bodyData = new byte[depthWidth * depthHeight]; _colorData = new byte[colorWidth * colorHeight * Constants.BYTES_PER_PIXEL]; _displayPixels = new byte[depthWidth * depthHeight * Constants.BYTES_PER_PIXEL]; _colorPoints = new ColorSpacePoint[depthWidth * depthHeight]; _bitmap = new Bitmap(depthWidth, depthHeight, Constants.FORMAT); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; byte player = _bodyData[depthIndex]; if (player != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * Constants.BYTES_PER_PIXEL; int displayIndex = depthIndex * Constants.BYTES_PER_PIXEL; _displayPixels[displayIndex + 0] = _colorData[colorIndex]; _displayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _displayPixels[displayIndex + 2] = _colorData[colorIndex + 2]; _displayPixels[displayIndex + 3] = 0xff; } } } } BitmapData bitmapData = _bitmap.LockBits(new Rectangle(0, 0, depthWidth, depthHeight), ImageLockMode.ReadWrite, _bitmap.PixelFormat); Marshal.Copy(_displayPixels, 0, bitmapData.Scan0, _displayPixels.Length); _bitmap.UnlockBits(bitmapData); } return _bitmap; }
/// <summary> /// Converts a depth frame to the corresponding System.Windows.Media.Imaging.BitmapSource and removes the background (green-screen effect). /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> /// <returns>The corresponding System.Windows.Media.Imaging.BitmapSource representation of image.</returns> public BitmapSource GreenScreen(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth * depthHeight]; _bodyData = new byte[depthWidth * depthHeight]; _colorData = new byte[colorWidth * colorHeight * BYTES_PER_PIXEL]; _displayPixels = new byte[depthWidth * depthHeight * BYTES_PER_PIXEL]; _colorPoints = new ColorSpacePoint[depthWidth * depthHeight]; _bitmap = new WriteableBitmap(depthWidth, depthHeight, DPI, DPI, FORMAT, null); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); _coordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; byte player = _bodyData[depthIndex]; if (player != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * BYTES_PER_PIXEL; int displayIndex = depthIndex * BYTES_PER_PIXEL; _displayPixels[displayIndex + 0] = 255; _displayPixels[displayIndex + 1] = 255; _displayPixels[displayIndex + 2] = 255; _displayPixels[displayIndex + 3] = 127; // 79 195 247 } } } } _bitmap.Lock(); Marshal.Copy(_displayPixels, 0, _bitmap.BackBuffer, _displayPixels.Length); _bitmap.AddDirtyRect(new Int32Rect(0, 0, depthWidth, depthHeight)); _bitmap.Unlock(); } return _bitmap; }
private void Reader_MultiSourceFrameArrived(object sender, MultiSourceFrameArrivedEventArgs e) { int depthWidth = 0; int depthHeight = 0; int colorWidth = 0; int colorHeight = 0; int bodyIndexWidth = 0; int bodyIndexHeight = 0; bool multiSourceFrameProcessed = false; bool colorFrameProcessed = false; bool depthFrameProcessed = false; bool bodyIndexFrameProcessed = false; MultiSourceFrame multiSourceFrame = e.FrameReference.AcquireFrame(); if (multiSourceFrame != null) { // Frame Acquisition should always occur first when using multiSourceFrameReader using (DepthFrame depthFrame = multiSourceFrame.DepthFrameReference.AcquireFrame()) { using (ColorFrame colorFrame = multiSourceFrame.ColorFrameReference.AcquireFrame()) { using (BodyIndexFrame bodyIndexFrame = multiSourceFrame.BodyIndexFrameReference.AcquireFrame()) { if (depthFrame != null) { FrameDescription depthFrameDescription = depthFrame.FrameDescription; depthWidth = depthFrameDescription.Width; depthHeight = depthFrameDescription.Height; if ((depthWidth * depthHeight) == depthFrameData.Length) { depthFrame.CopyFrameDataToArray(depthFrameData); depthFrameProcessed = true; } } if (colorFrame != null) { FrameDescription colorFrameDescription = colorFrame.FrameDescription; colorWidth = colorFrameDescription.Width; colorHeight = colorFrameDescription.Height; if ((colorWidth * colorHeight * bytesPerPixel) == colorFrameData.Length) { if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(colorFrameData); } else { colorFrame.CopyConvertedFrameDataToArray(colorFrameData, ColorImageFormat.Bgra); } colorFrameProcessed = true; } } if (bodyIndexFrame != null) { FrameDescription bodyIndexFrameDescription = bodyIndexFrame.FrameDescription; bodyIndexWidth = bodyIndexFrameDescription.Width; bodyIndexHeight = bodyIndexFrameDescription.Height; if ((bodyIndexWidth * bodyIndexHeight) == bodyIndexFrameData.Length) { bodyIndexFrame.CopyFrameDataToArray(bodyIndexFrameData); bodyIndexFrameProcessed = true; } } multiSourceFrameProcessed = true; } } } } // we got all frames if (multiSourceFrameProcessed && depthFrameProcessed && colorFrameProcessed && bodyIndexFrameProcessed) { coordinateMapper.MapDepthFrameToColorSpace(depthFrameData, colorPoints); Array.Clear(displayPixels, 0, displayPixels.Length); // loop over each row and column of the depth for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { // calculate index into depth array int depthIndex = (y * depthWidth) + x; byte player = bodyIndexFrameData[depthIndex]; // if we're tracking a player for the current pixel, sets its color and alpha to full if (player != 0xff) { // retrieve the depth to color mapping for the current depth pixel ColorSpacePoint colorPoint = colorPoints[depthIndex]; // make sure the depth pixel maps to a valid point in color space int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { // calculate index into color array int colorIndex = ((colorY * colorWidth) + colorX) * bytesPerPixel; // set source for copy to the color pixel int displayIndex = depthIndex * bytesPerPixel; // write out blue byte this.displayPixels[displayIndex++] = colorFrameData[colorIndex++]; // write out green byte this.displayPixels[displayIndex++] = colorFrameData[colorIndex++]; // write out red byte this.displayPixels[displayIndex++] = colorFrameData[colorIndex]; // write out alpha byte this.displayPixels[displayIndex] = 0xff; } } } } RenderColorPixels(); } }
private void ProcessFrames(DepthFrame depthFrame, ColorFrame colorFrame, BodyIndexFrame bodyIndexFrame, BodyFrame bodyFrame) { FrameDescription depthFrameDescription = depthFrame.FrameDescription; FrameDescription colorFrameDescription = colorFrame.FrameDescription; FrameDescription bodyIndexFrameDescription = bodyIndexFrame.FrameDescription; int bodyIndexWidth = bodyIndexFrameDescription.Width; int bodyIndexHeight = bodyIndexFrameDescription.Height; // The ImageModel object is used to transfer Kinect data into the DataFlow rotunies. ImageModel imageModel = new ImageModel() { DepthWidth = depthFrameDescription.Width, DepthHeight = depthFrameDescription.Height, ColorWidth = colorFrameDescription.Width, ColorHeight = colorFrameDescription.Height, ShowTrails = _vm.LeaveTrails, PersonFill = _vm.PersonFill, MaxDistance = _vm.BackgroundDistance }; imageModel.ColorFrameData = new byte[imageModel.ColorWidth * imageModel.ColorHeight * this.bytesPerPixel]; imageModel.DisplayPixels = new byte[_PreviousFrameDisplayPixels.Length]; imageModel.BodyIndexFrameData = new byte[imageModel.DepthWidth * imageModel.DepthHeight]; imageModel.ColorPoints = new ColorSpacePoint[imageModel.DepthWidth * imageModel.DepthHeight]; imageModel.BytesPerPixel = bytesPerPixel; imageModel.Bodies = new Body[this.kinectSensor.BodyFrameSource.BodyCount]; bodyFrame.GetAndRefreshBodyData(imageModel.Bodies); imageModel.DepthData = new ushort[imageModel.DepthWidth * imageModel.DepthHeight]; depthFrame.CopyFrameDataToArray(imageModel.DepthData); depthFrame.CopyFrameDataToArray(this.DepthFrameData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(imageModel.ColorFrameData); } else { colorFrame.CopyConvertedFrameDataToArray(imageModel.ColorFrameData, ColorImageFormat.Bgra); } imageModel.PixelFormat = PixelFormats.Bgra32; _ColorBitmap.WritePixels(new Int32Rect(0, 0, imageModel.ColorWidth, imageModel.ColorHeight), imageModel.ColorFrameData, imageModel.ColorWidth * imageModel.BytesPerPixel, 0); //RenderTargetBitmap renderBitmap = new RenderTargetBitmap((int)CompositeImage.ActualWidth, (int)CompositeImage.ActualHeight, 96.0, 96.0, PixelFormats.Pbgra32); //DrawingVisual dv = new DrawingVisual(); //VisualBrush brush = new VisualBrush(CompositeImage); //foreach(Body body in _bodies) //{ // if (body.IsTracked) // { // Joint joint = body.Joints[JointType.HandRight]; // using (DrawingContext dc = dv.RenderOpen()) // { // dc.DrawRectangle(brush, null, new Rect(new Point(), new Size(CompositeImage.ActualWidth, CompositeImage.ActualHeight))); // ImageBrush brush2 = new ImageBrush(_pointerBitmap); // brush2.Opacity = 1.0; // dc.DrawRectangle(brush2, null, new Rect(new Point(0, CompositeImage.ActualHeight - _Overlay.Height), new Size(_pointerBitmap.Width, _pointerBitmap.Height))); // } // } //} //ConvertIRDataToByte(); ImagePreview.Source = _ColorBitmap; bodyIndexFrame.CopyFrameDataToArray(imageModel.BodyIndexFrameData); this.coordinateMapper.MapDepthFrameToColorSpace(DepthFrameData, imageModel.ColorPoints); if (_vm.LeaveTrails) { Array.Copy(this._PreviousFrameDisplayPixels, imageModel.DisplayPixels, this._PreviousFrameDisplayPixels.Length); } try { //Send the imageModel to the DataFlow transformer _ImageTransformer.Post(imageModel); } catch (Exception ex) { #if DEBUG Console.WriteLine(ex); #endif } }
/// <summary> /// Updates the bitmap with new frame data. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> public void Update(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth * depthHeight]; _bodyData = new byte[depthWidth * depthHeight]; _colorData = new byte[colorWidth * colorHeight * Constants.BYTES_PER_PIXEL]; _displayPixels = new byte[depthWidth * depthHeight * Constants.BYTES_PER_PIXEL]; _colorPoints = new ColorSpacePoint[depthWidth * depthHeight]; Bitmap = new WriteableBitmap(depthWidth, depthHeight, Constants.DPI, Constants.DPI, Constants.FORMAT, null); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; byte player = _bodyData[depthIndex]; if (player != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * Constants.BYTES_PER_PIXEL; int displayIndex = depthIndex * Constants.BYTES_PER_PIXEL; _displayPixels[displayIndex + 0] = _colorData[colorIndex]; _displayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _displayPixels[displayIndex + 2] = _colorData[colorIndex + 2]; _displayPixels[displayIndex + 3] = 0xff; } } } } Bitmap.Lock(); Marshal.Copy(Pixels, 0, Bitmap.BackBuffer, _displayPixels.Length); Bitmap.AddDirtyRect(new Int32Rect(0, 0, Width, Height)); Bitmap.Unlock(); } }
public BitmapSource GreenScreenCustom(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { // ushort[] _depthData = null; byte[] _bodyData = null; byte[] _colorData = null; byte[] _displayPixels = null; ColorSpacePoint[] _colorPoints = null; CoordinateMapper _coordinateMapper = _sensor.CoordinateMapper; int BYTES_PER_PIXEL = (PixelFormats.Bgr32.BitsPerPixel + 7) / 8; PixelFormat FORMAT = PixelFormats.Bgra32; double DPI = 96.0; WriteableBitmap _bitmap = null; // int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth * depthHeight]; _bodyData = new byte[depthWidth * depthHeight]; _colorData = new byte[colorWidth * colorHeight * BYTES_PER_PIXEL]; _displayPixels = new byte[depthWidth * depthHeight * BYTES_PER_PIXEL]; _colorPoints = new ColorSpacePoint[depthWidth * depthHeight]; _bitmap = new WriteableBitmap(depthWidth, depthHeight, DPI, DPI, FORMAT, null); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); _coordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); Array.Clear(rarray_final, 0, rarray_final.Length); Array.Clear(garray_final, 0, rarray_final.Length); Array.Clear(barray_final, 0, rarray_final.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; byte player = _bodyData[depthIndex]; if (player != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)Math.Floor(colorPoint.X + 0.5); int colorY = (int)Math.Floor(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * BYTES_PER_PIXEL; int displayIndex = depthIndex * BYTES_PER_PIXEL; _displayPixels[displayIndex + 0] = _colorData[colorIndex]; _displayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _displayPixels[displayIndex + 2] = _colorData[colorIndex + 2]; _displayPixels[displayIndex + 3] = 0xff; barray_final[y, x] = _colorData[colorIndex]; garray_final[y, x] = _colorData[colorIndex + 1]; rarray_final[y, x] = _colorData[colorIndex + 2]; // For ROS _finaldisplayPixels[displayIndex + 0] = _colorData[colorIndex + 2]; _finaldisplayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _finaldisplayPixels[displayIndex + 2] = _colorData[colorIndex]; _finaldisplayPixels[displayIndex + 3] = 0xff; } } } } _bitmap.Lock(); Marshal.Copy(_displayPixels, 0, _bitmap.BackBuffer, _displayPixels.Length); _bitmap.AddDirtyRect(new Int32Rect(0, 0, depthWidth, depthHeight)); _bitmap.Unlock(); } return(_bitmap); }
static unsafe void BodyIndexFrameReady(BodyIndexFrame frame) { frame.CopyFrameDataToArray(sensorBodyIndexFrameData); }
public void GreenScreen(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) //from https://github.com/Vangos/kinect-2-background-removal { var colorWidth = colorFrame.FrameDescription.Width; var colorHeight = colorFrame.FrameDescription.Height; var depthWidth = depthFrame.FrameDescription.Width; var depthHeight = depthFrame.FrameDescription.Height; var bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; var bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (_displayPixels == null) { _depthData = new ushort[depthWidth*depthHeight]; _bodyData = new byte[depthWidth*depthHeight]; _colorData = new byte[colorWidth*colorHeight*_bytesPerPixel]; _displayPixels = new byte[depthWidth*depthHeight*_bytesPerPixel]; _colorPoints = new ColorSpacePoint[depthWidth*depthHeight]; } if (((depthWidth*depthHeight) != _depthData.Length) || ((colorWidth*colorHeight*_bytesPerPixel) != _colorData.Length) || ((bodyIndexWidth*bodyIndexHeight) != _bodyData.Length)) return; depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); _coordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(_displayPixels, 0, _displayPixels.Length); for (var y = 0; y < depthHeight; ++y) { for (var x = 0; x < depthWidth; ++x) { var depthIndex = (y*depthWidth) + x; var player = _bodyData[depthIndex]; if (player == 0xff) continue; var colorPoint = _colorPoints[depthIndex]; var colorX = (int) Math.Floor(colorPoint.X + 0.5); var colorY = (int) Math.Floor(colorPoint.Y + 0.5); if ((colorX < 0) || (colorX >= colorWidth) || (colorY < 0) || (colorY >= colorHeight)) continue; var colorIndex = ((colorY*colorWidth) + colorX)*_bytesPerPixel; var displayIndex = depthIndex*_bytesPerPixel; _displayPixels[displayIndex + 0] = _colorData[colorIndex]; _displayPixels[displayIndex + 1] = _colorData[colorIndex + 1]; _displayPixels[displayIndex + 2] = _colorData[colorIndex + 2]; _displayPixels[displayIndex + 3] = 0xff; } } Array.Clear(BufBytes, 0, BufBytes.Length); //Zerofill array for (var d = 0; d < _displayPixels.Count(); d++) { if (_displayPixels[d] != 0) { BufBytes[d] = MainWindow.InfraPixels[d]; } } }
/// <summary> /// Updates the bitmap with new frame data. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="colorFrame">The specified color frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> override public void Update(ColorFrame colorFrame, DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { int colorWidth = colorFrame.FrameDescription.Width; int colorHeight = colorFrame.FrameDescription.Height; int depthWidth = depthFrame.FrameDescription.Width; int depthHeight = depthFrame.FrameDescription.Height; int bodyIndexWidth = bodyIndexFrame.FrameDescription.Width; int bodyIndexHeight = bodyIndexFrame.FrameDescription.Height; if (Bitmap == null) { InitBuffers(colorFrame.FrameDescription, depthFrame.FrameDescription, bodyIndexFrame.FrameDescription); } if (((depthWidth * depthHeight) == _depthData.Length) && ((colorWidth * colorHeight * Constants.BYTES_PER_PIXEL) == _colorData.Length) && ((bodyIndexWidth * bodyIndexHeight) == _bodyData.Length)) { depthFrame.CopyFrameDataToArray(_depthData); if (colorFrame.RawColorImageFormat == ColorImageFormat.Bgra) { colorFrame.CopyRawFrameDataToArray(_colorData); } else { colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra); } bodyIndexFrame.CopyFrameDataToArray(_bodyData); CoordinateMapper.MapDepthFrameToColorSpace(_depthData, _colorPoints); Array.Clear(Pixels, 0, Pixels.Length); for (int y = 0; y < depthHeight; ++y) { for (int x = 0; x < depthWidth; ++x) { int depthIndex = (y * depthWidth) + x; if (_bodyData[depthIndex] != 0xff) { ColorSpacePoint colorPoint = _colorPoints[depthIndex]; int colorX = (int)(colorPoint.X + 0.5); int colorY = (int)(colorPoint.Y + 0.5); if ((colorX >= 0) && (colorX < colorWidth) && (colorY >= 0) && (colorY < colorHeight)) { int colorIndex = ((colorY * colorWidth) + colorX) * Constants.BYTES_PER_PIXEL; int displayIndex = depthIndex * Constants.BYTES_PER_PIXEL; for (int b = 0; b < Constants.BYTES_PER_PIXEL; ++b) { Pixels[displayIndex + b] = _colorData[colorIndex + b]; } } } } } UpdateBitmap(); } }
/// <summary> /// Converts a depth frame to the corresponding System.Windows.Media.Imaging.BitmapSource with the players highlighted. /// </summary> /// <param name="depthFrame">The specified depth frame.</param> /// <param name="bodyIndexFrame">The specified body index frame.</param> /// <returns>The corresponding System.Windows.Media.Imaging.BitmapSource representation of the depth frame.</returns> public static BitmapSource ToBitmap(this DepthFrame depthFrame, BodyIndexFrame bodyIndexFrame) { ushort minDepth = depthFrame.DepthMinReliableDistance; ushort maxDepth = depthFrame.DepthMaxReliableDistance; if (_bodyData == null) { _width = depthFrame.FrameDescription.Width; _height = depthFrame.FrameDescription.Height; _depthData = new ushort[_width * _height]; _bodyData = new byte[_width * _height]; _pixels = new byte[_width * _height * Constants.BYTES_PER_PIXEL]; _bitmap = new WriteableBitmap(_width, _height, Constants.DPI, Constants.DPI, Constants.FORMAT, null); } depthFrame.CopyFrameDataToArray(_depthData); bodyIndexFrame.CopyFrameDataToArray(_bodyData); // Convert the depth to RGB for (int depthIndex = 0, colorPixelIndex = 0; depthIndex < _depthData.Length && colorPixelIndex < _pixels.Length; depthIndex++, colorPixelIndex += 4) { // Get the depth for this pixel ushort depth = _depthData[depthIndex]; byte player = _bodyData[depthIndex]; // To convert to a byte, we're discarding the most-significant // rather than least-significant bits. // We're preserving detail, although the intensity will "wrap." // Values outside the reliable depth range are mapped to 0 (black). byte intensity = (byte)(depth >= minDepth && depth <= maxDepth ? depth : 0); if (player != 0xff) { // Color player gold. _pixels[colorPixelIndex + 0] = Colors.Gold.B; // B _pixels[colorPixelIndex + 1] = Colors.Gold.G; // G _pixels[colorPixelIndex + 2] = Colors.Gold.R; // R } else { // Color the rest of the image in grayscale. _pixels[colorPixelIndex + 0] = intensity; // B _pixels[colorPixelIndex + 1] = intensity; // G _pixels[colorPixelIndex + 2] = intensity; // R } } _bitmap.Lock(); Marshal.Copy(_pixels, 0, _bitmap.BackBuffer, _pixels.Length); _bitmap.AddDirtyRect(new Int32Rect(0, 0, _width, _height)); _bitmap.Unlock(); return _bitmap; }