public byte MapDepthToColorImagePoint(string[] args)
{
try
{
verifArgs(6, args);
getKinectSensor(int.Parse(args[0]));
DepthImageFormat depthImageFormat = (DepthImageFormat)int.Parse(args[1]);
int depthX = int.Parse(args[2]);
int depthY = int.Parse(args[3]);
short depthPixelValue = short.Parse(args[4]);
ColorImageFormat colorImageFormat = (ColorImageFormat)int.Parse(args[5]);
ColorImagePoint point = sensor.MapDepthToColorImagePoint(
depthImageFormat,
depthX,
depthY,
depthPixelValue,
colorImageFormat);
rData = point.X + "||" + point.Y;
return(KSuccess.QueryOk);
}
catch (KActionException e)
{
rData = e.Message;
return(e.exceptionNumber);
}
}
private void RenderScreen(DepthImageFrame depthFrame, ColorImageFrame colorFrame)
{
if (sensor != null && colorFrame != null && depthFrame != null)
{
int count = 0; //所有捕获的点的个数
double avgPosition = 0; //深度平均中心（决定人物方框的位置）
int depthPixelIndex;
int playerIndex;
int colorPixelIndex;
int playerImageIndex = 0;
int colorStride = colorFrame.BytesPerPixel * colorFrame.Width; //5120
int bytesPerPixel = 4;
byte[] playerImage = new byte[sensor.DepthStream.FrameHeight * depthImageStride]; //1 228 800
ColorImagePoint colorPoint;
depthFrame.CopyPixelDataTo(depthPixelData); //307200
colorFrame.CopyPixelDataTo(colorPixelData); //4 915 200
for (int depthY = 0; depthY < depthFrame.Height; depthY++)
{
for (int depthX = 0; depthX < depthFrame.Width; depthX++, playerImageIndex += bytesPerPixel)
{
depthPixelIndex = depthX + (depthY * depthFrame.Width);
playerIndex = depthPixelData[depthPixelIndex] & DepthImageFrame.PlayerIndexBitmask;
if (playerIndex != 0)
{
colorPoint = sensor.MapDepthToColorImagePoint(depthFrame.Format, depthX, depthY, depthPixelData[depthPixelIndex], colorFrame.Format);
colorPixelIndex = (colorPoint.X * colorFrame.BytesPerPixel) + (colorPoint.Y * colorStride);
if (colorPixelIndex < sensor.ColorStream.FramePixelDataLength)
{
avgPosition = avgPosition * count + depthX;
count++;
avgPosition /= count;
playerImage[playerImageIndex] = colorPixelData[colorPixelIndex]; //Blue
playerImage[playerImageIndex + 1] = colorPixelData[colorPixelIndex + 1]; //Green
playerImage[playerImageIndex + 2] = colorPixelData[colorPixelIndex + 2]; //Red
playerImage[playerImageIndex + 3] = 0xFF; //Alpha
}
}
}
}
BitmapData bmapdata = depthImageBitmap.LockBits(depthImageBitmapRect, ImageLockMode.WriteOnly, depthImageBitmap.PixelFormat);
IntPtr ptr = bmapdata.Scan0;
System.Runtime.InteropServices.Marshal.Copy(playerImage, 0, ptr, playerImage.Length);
depthImageBitmap.UnlockBits(bmapdata);
manImage.Image = depthImageBitmap;//depthImageBitmap;
//map to panel
avgPosition = (avgPosition) * (manImageWidth / depthFrame.Width);// - manImage.Height / depthFrame.Height);
avgPosition = avgPosition * ((double)manPanel.Width / manImage.Width) - manImage.Width / 2.0;
manImage.Location = new Point((int)(avgPosition + manPanel.Location.X), manPanel.Height - manImage.Height);
}
}
private void ColorImageProcessing(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.ScreenImageStride];
int playerImageIndex = 0;
depthFrame.CopyPixelDataTo(this.depthPixelData);
colorFrame.CopyPixelDataTo(this.colorPixelData);
//get data
imageProcesser.SetImageFrame(depthPixelData, colorPixelData);
//debug view
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;
if (playerIndex != 0)
{
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; //Alpha
}
}
}
this.screenImageBitmap.WritePixels(this._GreenScreenImageRect, playerImage, this.ScreenImageStride, 0);
}
}
private void RenderGreenScreen(KinectSensor kinectDevice, ColorImageFrame colorFrame, DepthImageFrame depthFrame)
{
if (kinectDevice != null && depthFrame != null && colorFrame != null)
{
int depthPixelIndex;
int playerIndex;
int colorPixelIndex;
ColorImagePoint colorPoint;
//DepthImagePoint depthPoint = new DepthImagePoint();
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;
if (playerIndex != 0)
{
//depthPoint.X = depthX;
//depthPoint.Y = depthY;
//colorPoint = kinectDevice.CoordinateMapper.MapDepthPointToColorPoint(depthFrame.Format, depthPoint, colorFrame.Format);
#pragma warning disable CS0618
colorPoint = kinectDevice.MapDepthToColorImagePoint(depthFrame.Format, depthX, depthY, this._DepthPixelData[depthPixelIndex], colorFrame.Format);
#pragma warning restore CS0618
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; //Alpha
}
}
}
this._GreenScreenImage.WritePixels(this._GreenScreenImageRect, playerImage, this._GreenScreenImageStride, 0);
}
}
//处理数据并保存
private void SetImageShot(KinectSensor kinectDevice, short[] depthPixelData, byte[] colorPixelData)//, ColorImageFrame colorFrame, DepthImageFrame depthFrame)
{
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);
}
}
// 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 &&
vec.Y> _ext.Value.MinPoint.Y &&
vec.Y <_ext.Value.MaxPoint.Y &&
vec.Z> _ext.Value.MinPoint.Z &&
vec.Z < _ext.Value.MaxPoint.Z
select vec;
// Convert our IEnumerable<> into a List<>
res = vecSet.ToList <ColoredPoint3d>();
}
return(res);
}
void myKinect_AllFramesReady(object sender, AllFramesReadyEventArgs e)
{
#if SREENSHOT_PAUSE
if (trackCount == trackLimit)
{
return;
}
#endif
#region Video image
// Puts a copy of the video image into the kinect video texture
using (ColorImageFrame colorFrame = e.OpenColorImageFrame())
{
if (colorFrame == null)
{
return;
}
if (colorData == null)
{
colorData = new byte[colorFrame.Width * colorFrame.Height * 4];
}
colorFrame.CopyPixelDataTo(colorData);
kinectVideoTexture = new Texture2D(GraphicsDevice, colorFrame.Width, colorFrame.Height);
Color[] bitmap = new Color[colorFrame.Width * colorFrame.Height];
int sourceOffset = 0;
for (int i = 0; i < bitmap.Length; i++)
{
bitmap[i] = new Color(colorData[sourceOffset + 2],
colorData[sourceOffset + 1], colorData[sourceOffset], 255);
sourceOffset += 4;
}
kinectVideoTexture.SetData(bitmap);
}
#endregion
#region Skeleton
// Finds the currently active skeleton
using (SkeletonFrame frame = e.OpenSkeletonFrame())
{
if (frame == null)
{
return;
}
else
{
skeletons = new Skeleton[frame.SkeletonArrayLength];
frame.CopySkeletonDataTo(skeletons);
}
}
activeSkeletonNumber = 0;
for (int i = 0; i < skeletons.Length; i++)
{
if (skeletons[i].TrackingState == SkeletonTrackingState.Tracked)
{
activeSkeletonNumber = i + 1;
activeSkeleton = skeletons[i];
break;
}
}
#endregion
#region Depth image
// Creates a game background image with transparent regions
// where the player is displayed
using (DepthImageFrame depthFrame = e.OpenDepthImageFrame())
{
// Get the depth data
if (depthFrame == null)
{
return;
}
if (depthData == null)
{
depthData = new short[depthFrame.Width * depthFrame.Height];
}
depthFrame.CopyPixelDataTo(depthData);
// Create the mask from the background image
gameImageTexture.GetData(maskImageColors);
if (activeSkeletonNumber != 0)
{
for (int depthPos = 0; depthPos < depthData.Length; depthPos++)
{
// find a player to mask - split off bottom bits
int playerNo = depthData[depthPos] & 0x07;
if (playerNo == activeSkeletonNumber)
{
// We have a player to mask
// find the X and Y positions of the depth point
int x = depthPos % depthFrame.Width;
int y = depthPos / depthFrame.Width;
// get the X and Y positions in the video feed
ColorImagePoint playerPoint = myKinect.MapDepthToColorImagePoint(
DepthImageFormat.Resolution320x240Fps30, x, y, depthData[depthPos], ColorImageFormat.RgbResolution640x480Fps30);
// Map the player coordinates into our lower resolution background
// Have to do this because the lowest resultion for the color camera is 640x480
playerPoint.X /= 2;
playerPoint.Y /= 2;
// convert this into an offset into the mask color data
int gameImagePos = (playerPoint.X + (playerPoint.Y * depthFrame.Width));
if (gameImagePos < maskImageColors.Length)
{
// make this point in the mask transparent
maskImageColors[gameImagePos] = Color.FromNonPremultiplied(0, 0, 0, 0);
}
}
}
}
gameMaskTexture = new Texture2D(GraphicsDevice, depthFrame.Width, depthFrame.Height);
gameMaskTexture.SetData(maskImageColors);
}
#endregion
}
