/// <summary>
/// Attempt to get a frame & track bodies each frame
/// </summary>
private bool GetAndRefreshBodyData(BodyFrameArrivedEventArgs e, bool dataReceived)
{
// Represents a frame that contains all the computed real-time tracking information
// about people that are in view of the sensor.
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
// Not able to get a frame?
//if (bodyFrame == null) return !dataReceived;
//TODO: Can probably get rid of this
if (bodyFrame == null)
{
kinectState = KinectState.notTracked;
Debug.WriteLine("Cannot get Frame Reference");
}
// Able to get a frame, but bodies is currently null
if (bodyFrame != null && this.bodies == null)
{
this.bodies = new Body[bodyFrame.BodyCount];
// TODO: Determine the correct Kinect State
Debug.WriteLine("Current _body count: " + bodyFrame.BodyCount);
}
// Return current status of bodies to Kinect
bodyFrame?.GetAndRefreshBodyData(this.bodies);
kinectState = KinectState.bodyTrackedAndIsTracking;
}
return(false);
}
public Body Select(BodyFrame frame)
{
if (frame == null || frame.BodyCount == 0)
{
this.trackingId = 0;
return null;
}
var bodies = new Body[frame.BodyCount];
frame.GetAndRefreshBodyData(bodies);
var trackedBody = bodies.FirstOrDefault(b =>
b.TrackingId == this.trackingId &&
b.Joints[JointType.HandLeft].Position.Y > b.Joints[JointType.HipLeft].Position.Y + 0.05);
if (trackedBody != null)
{
return trackedBody;
}
var activeBody = bodies.FirstOrDefault(b =>
b.IsTracked &&
b.HandLeftState == HandState.Open &&
b.Joints[JointType.HandLeft].Position.Y > b.Joints[JointType.ShoulderLeft].Position.Y);
if (activeBody != null)
{
this.trackingId = activeBody.TrackingId;
return activeBody;
}
this.trackingId = 0;
return null;
}
/// <summary>
/// 骨架事件
/// </summary>
private void BodyFrameReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame == null)
{
return;
}
bodies = new Body[bodyFrame.BodyCount];
bodyFrame.GetAndRefreshBodyData(bodies);
Body body = bodies.Where(b => b.IsTracked).FirstOrDefault();
if (!_faceSource.IsTrackingIdValid)
{
if (body != null)
{
//Assign a tracking ID to the face source
_faceSource.TrackingId = body.TrackingId;
}
}
//判斷骨架，並傳入參數
for (int i = 0; i < bodies.Length; i++)
{
//如果骨架有追蹤到才能執行
if (bodies[i].IsTracked)
{
if (StopDetect != true)
{
//Body class ,posture_number ,face class
//poseture.Poseture_Detected(bodies[i], vocabulary.Give_Vocabulary(posture_number), face_result);
//如果是空就跳出
if (TaskWords == null)
{
return;
}
//把從句子中取得的字典單字拿出來給姿勢做偵測
for (int j = 0; j < TaskWords.Count; j++)
{
poseture.Poseture_Detected(bodies[i], TaskWords[j], face_result);
}
}
}
}
}
}
private void OnBodyFrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
// Get frame reference
BodyFrameReference refer = e.FrameReference;
if (refer == null)
{
return;
}
{
//Get body frame
BodyFrame frame = refer.AcquireFrame();
if (frame == null)
{
StatusText.Text = "BodyOff";
StatusText.Visibility = Visibility.Visible;
return;
}
else
{
StatusText.Text = "BodyOn";
StatusText.Visibility = Visibility.Visible;
}
//Process it
using (frame)
{
//Aquire body data
frame.GetAndRefreshBodyData(_bodies);
//Clear Skeleton Canvas
SkeletonCanvas.Children.Clear();
//Loop all bodies
foreach (Body body in _bodies)
{
//Only process tracked bodyie
if (body.IsTracked)
{
DrawBody(body);
}
}
}
}
}
/// <summary>
/// Handles the body frame data arriving from the sensor
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
if (this.bodies == null)
{
this.bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
if (dataReceived)
{
foreach (Body body in this.bodies)
{
if (body.IsTracked)
{
IReadOnlyDictionary <JointType, Joint> joints = body.Joints;
foreach (JointType jointType in joints.Keys)
{
// sometimes the depth(Z) of an inferred joint may show as negative
// clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity)
CameraSpacePoint position = joints[jointType].Position;
if (position.Z < 0)
{
position.Z = InferredZPositionClamp;
}
}
SetBodyFrameValues(body);
string data = "";
OnKinectDataReceived(new clsKinectArgs(e, data, DateTime.Now));
}
}
}
}
// Token: 0x060029E3 RID: 10723 RVA: 0x000D5564 File Offset: 0x000D3964
public void Refresh()
{
if (this._Reader != null)
{
BodyFrame bodyFrame = this._Reader.AcquireLatestFrame();
if (bodyFrame != null)
{
if (this._Data == null)
{
this._Data = new Body[this._Sensor.BodyFrameSource.BodyCount];
}
bodyFrame.GetAndRefreshBodyData(this._Data);
this.FloorClipPlane = bodyFrame.FloorClipPlane;
bodyFrame.Dispose();
}
}
}
private void ShowBodyJoints(BodyFrame bodyFrame)
{
Body[] bodies = new Body[
this.kinectSensor.BodyFrameSource.BodyCount];
bool dataReceived = false;
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(bodies);
dataReceived = true;
}
if (dataReceived)
{
this.bodiesManager.UpdateBodiesAndEdges(bodies);
}
}
/// <summary>
/// this method extracts a single InfraredFrame from the FrameReference in the event args,
/// checks that the frame is not null and its dimensions match the bitmap initialized
/// </summary>
// private void Reader_InfraredFrameArrived(object sender, InfraredFrameArrivedEventArgs e)
//{
// bool infraredFrameProcessed = false;
// // InfraredFrame is IDisposable
// using (InfraredFrame infraredFrame = e.FrameReference.AcquireFrame())
// {
// if (infraredFrame != null)
// {
// FrameDescription infraredFrameDescription = infraredFrame.FrameDescription;
// // verify data and write the new infrared frame data to the display bitmap
// if (((infraredFrameDescription.Width * infraredFrameDescription.Height) == this.infraredFrameData.Length) &&
// (infraredFrameDescription.Width == this.bitmap.PixelWidth) &&
// (infraredFrameDescription.Height == this.bitmap.PixelHeight))
// {
// // copy the infrared frame into the infraredFrameData array class variable which is used in the next stage
// infraredFrame.CopyFrameDataToArray(this.infraredFrameData);
// infraredFrameProcessed = true;
// }
// }
// }
// // if a frame is received successfully, convert and render
// if (infraredFrameProcessed)
// {
// ConvertInfraredDataToPixels();
// RenderPixelArray(this.infraredPixels);
// }
//}
private void Reader_MultiSourceFrameArrived(MultiSourceFrameReader sender, MultiSourceFrameArrivedEventArgs e)
{
MultiSourceFrame reference = e.FrameReference.AcquireFrame();
// If the Frame has expired by the time we process this event, return.
if (reference == null)
{
return;
}
ColorFrame colorFrame = null;
BodyFrame bodyFrame = null;
//InfraredFrame infraredFrame = null;
//BodyIndexFrame bodyIndexFrame = null;
//IBuffer bodyIndexFrameData = null;
// Open color frame
using (colorFrame = reference.ColorFrameReference.AcquireFrame())
{
if (colorFrame != null)
{
ShowColorFrame(colorFrame);
}
}
// Gesture detection and joints overlay=
using (bodyFrame = reference.BodyFrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
var bodies = new Body[bodyFrame.BodyCount];
bodyFrame.GetAndRefreshBodyData(bodies);
foreach (Body body in bodies)
{
if (body.IsTracked)
{
RegisterGesture(bodyFrame);
ShowBodyJoints(bodyFrame);
PrintJointAngles(bodyFrame);
}
}
}
}
}
private void Reader_BodyFrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame()) {
if (bodyFrame != null)
{
if (this.bodies == null)
{
// creates an array of 6 bodies, which is the max number of bodies that Kinect can track simultaneously
this.bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
if (dataReceived)
{
// we may have lost/acquired bodies, so update the corresponding gesture detectors
if (this.bodies != null)
{
// loop through all bodies to see if any of the gesture detectors need to be updated
int maxBodies = this.kinectSensor.BodyFrameSource.BodyCount;
for (int i = 0; i < maxBodies; ++i)
{
Body body = this.bodies[i];
ulong trackingId = body.TrackingId;
// if the current body TrackingId changed, update the corresponding gesture detector with the new value
if (trackingId != this.gestureDetectorList[i].TrackingId)
{
this.gestureDetectorList[i].TrackingId = trackingId;
// if the current body is tracked, unpause its detector to get VisualGestureBuilderFrameArrived events
// if the current body is not tracked, pause its detector so we don't waste resources trying to get invalid gesture results
this.gestureDetectorList[i].IsPaused = trackingId == 0;
}
}
}
}
}
/// <summary>
/// Handles the body frame data arriving from the sensor
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_BodyFrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
bool hasTrackedBody = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
if (dataReceived)
{
this.BeginBodiesUpdate();
// iterate through each body
for (int bodyIndex = 0; bodyIndex < this.bodies.Length; bodyIndex++)
{
Body body = this.bodies[bodyIndex];
if (body.IsTracked)
{
// check if this body clips an edge
this.UpdateClippedEdges(body, hasTrackedBody);
this.UpdateBody(body, bodyIndex);
hasTrackedBody = true;
}
else
{
// collapse this body from canvas as it goes out of view
this.ClearBody(bodyIndex);
}
}
if (!hasTrackedBody)
{
// clear clipped edges if no bodies are tracked
this.ClearClippedEdges();
}
}
}
// Update is called once per frame
void Update()
{
IsAvailable = _sensor.IsAvailable;
if (_bodyFrameReader != null)
{
BodyFrame frame = _bodyFrameReader.AcquireLatestFrame();
if (frame != null)
{
frame.GetAndRefreshBodyData(_bodies);
foreach (Body body in _bodies)
{
if (!body.IsTracked)
{
continue;
}
IsAvailable = true;
if (body.HandRightConfidence == TrackingConfidence.High && body.HandRightState == HandState.Lasso)
{
GameManager.instance.StartNewGame();
}
float x = 0.0f;
float y = 0.0f;
Windows.Kinect.Joint RightHand = body.Joints[JointType.HandRight];
x = RescalingToRangesB(-1, 1, -8, 8, RightHand.Position.X);
y = RescalingToRangesB(-1, 1, -8, 8, RightHand.Position.Y);
RightHandPos = new Vector3(x, y, 0);
Windows.Kinect.Joint LeftHand = body.Joints[JointType.HandLeft];
x = RescalingToRangesB(-1, 1, -8, 8, LeftHand.Position.X);
y = RescalingToRangesB(-1, 1, -8, 8, LeftHand.Position.Y);
LeftHandPos = new Vector3(x, y, 0);
}
frame.Dispose();
frame = null;
}
}
}
void lecteurBody_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
BodyFrameReference refer = e.FrameReference;
if (refer == null)
{
return;
}
// Obtenir body frame
BodyFrame frame = refer.AcquireFrame();
if (frame == null)
{
return;
}
using (frame)
{
// Obtenir les données des joueurs
frame.GetAndRefreshBodyData(bodies);
// Clear Skeleton Canvas
CanvasCameraPrincipale.Children.Clear();
// Loop all bodies
foreach (Body body in bodies)
{
// Only process tracked bodies and if the timer is over
if (body.IsTracked && tempsFini)
{
if (body.HandLeftState == HandState.Closed) //Si la main gauche est fermée on met l'image d'avant
{
indexPhoto--;
afficherPhoto();
}
else if (body.HandRightState == HandState.Closed) //Si la main droite est fermée on met l'image d'après
{
indexPhoto++;
afficherPhoto();
}
}
}
}
}
private void BodyFrameReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame == null)
{
return;
}
bodies = new Body[bodyFrame.BodyCount];
bodyFrame.GetAndRefreshBodyData(bodies);
Body body = bodies.Where(b => b.IsTracked).FirstOrDefault();
if (!_faceSource.IsTrackingIdValid)
{
if (body != null)
{
// 4) Assign a tracking ID to the face source
_faceSource.TrackingId = body.TrackingId;
}
}
//判斷骨架，並傳入參數
for (int i = 0; i < bodies.Length; i++)
{
if (bodies[i].IsTracked) //如果骨架有追蹤到才能執行
/*
* poseture.Poseture_Detected(
* bodies[i].Joints[JointType.Head],
* bodies[i].Joints[JointType.HandRight],
* bodies[i].Joints[JointType.ElbowRight],
* bodies[i].Joints[JointType.HandLeft],
* bodies[i].Joints[JointType.ElbowLeft],
* bodies[i].Joints[JointType.ShoulderRight],
* bodies[i].Joints[JointType.ShoulderLeft],
* bodies[i].Joints[JointType.SpineMid],
* posture_number,//posture_number 從伺服器收到的值，傳入判斷式
* face_result);//Face features 類別直接傳過去，讓他自己呼叫類別的屬性
*/
{
poseture.Poseture_Detected(bodies[i], vocabulary.Give_Vocabulary(posture_number), face_result);
}
}
}
}
/// <summary>
/// Handles the body frame data arriving from the sensor
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame()) {
if (bodyFrame != null)
{
if (this.bodies == null)
{
this.bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
if (dataReceived)
{
activeBodies = new List <Body>();
for (int i = 0; i < this.bodies.Length; i++)
{
Body body = this.bodies[i];
if (body.IsTracked)
{
/*Dictionary<JointType, Windows.Kinect.Joint> joints = body.Joints;
*
* foreach (JointType jointType in joints.Keys) {
* // sometimes the depth(Z) of an inferred joint may show as negative
* // clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity)
* CameraSpacePoint position = joints[jointType].Position;
* if (position.Z < 0) {
* position.Z = InferredZPositionClamp;
* }
* }*/
activeBodies.Add(body);
//Debug.Log(joints[JointType.HandLeft].Position.X + " " + joints[JointType.HandLeft].Position.Y + " " + joints[JointType.HandLeft].Position.Z);
}
}
}
}
/// <summary>
/// Handles the body frame data arriving from the sensor
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
if (this.bodies == null)
{
this.bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
if (dataReceived)
{
for (int i = 0; i < bodies.Length; i++)
{
Body body = bodies[i];
if (body.IsTracked && body.TrackingId == engagedBodyId)
{
if (engagedHandType == HandType.LEFT)
{
processHandState(body.HandLeftState);
}
else if (engagedHandType == HandType.RIGHT)
{
processHandState(body.HandRightState);
}
else
{
processHandStateClosed(false);
}
}
}
}
}
/// <summary>
/// Handle the new body frames
/// </summary>
private async void OnBodiesArrive(object sender, BodyFrameArrivedEventArgs e)
{
// Retrieve the body reference
BodyFrameReference bodyRef = e.FrameReference;
if (bodyRef == null)
{
return;
}
// Acquire the body frame
using (BodyFrame frame = bodyRef.AcquireFrame())
{
if (frame == null)
{
return;
}
// Create a new collection when required
if (_bodies == null || _bodies.Count() != frame.BodyCount)
{
_bodies = new Body[frame.BodyCount];
}
// Refresh the bodies
frame.GetAndRefreshBodyData(_bodies);
// Start tracking faces
foreach (Body body in _bodies)
{
if (body.IsTracked)
{
// Create a new tracker if required
if (!_trackers.ContainsKey(body.TrackingId))
{
FaceTracker tracker = new FaceTracker(body.TrackingId, _faceFrameFeatures, _kinect);
tracker.FaceAnalyticsAvailable += OnFaceAnalyticsAvailable;
// Add to dictionary
_trackers.Add(body.TrackingId, tracker);
}
}
}
}
}
void multiReader_MultiSourceFrameArrived(object sender,
MultiSourceFrameArrivedEventArgs e)
{
var multiFrame = e.FrameReference.AcquireFrame(); // マルチフレームを取得する
if (multiFrame == null)
{
return;
}
////////////////////////////////////////////////////各種データ取得////////////////////////////////////////////////////
UpdateColorFrame(multiFrame);
UpdateBodyIndexFrame(multiFrame);
UpdateDepthFrame(multiFrame);
UpdateBodyFrame(multiFrame);
if (BODY_CAPTURE != 0)
{
TextBlock7.Visibility = System.Windows.Visibility.Visible;
TextBlock7.Text = BODY_CAPTURE.ToString() + "人検出";
}
if (!gestureFrameSource.IsTrackingIdValid)
{
using (BodyFrame bodyFrame = multiFrame.BodyFrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(bodies);
foreach (var body in bodies)
{
if (body != null && body.IsTracked)
{
// ジェスチャー判定対象としてbodyを選択
gestureFrameSource.TrackingId = body.TrackingId;
// ジェスチャー判定開始
gestureFrameReader.IsPaused = false;
break;
}
}
}
}
}
draw();
}
// Update is called once per frame
void Update()
{
if (_bodyFrameReader != null)
{
using (BodyFrame frame = _bodyFrameReader.AcquireLatestFrame())
{
if (frame != null)
{
if (_bodyData == null)
{
_bodyData = new Body[_sensor.BodyFrameSource.BodyCount];
}
frame.GetAndRefreshBodyData(_bodyData);
}
}
}
}
private static void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
// get total number of bodies from BodyFrameSource
var bodies = new Body[(sender as BodyFrameReader).BodyFrameSource.BodyCount];
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(bodies);
if (bodies.ToList().Any(x => x.IsTracked))
{
var body = bodies.ToList().Where(x => x.IsTracked).First();
}
}
}
}
private void SkeletonReady(object sender, BodyFrameArrivedEventArgs e)
{
using (BodyFrame skeletonFrame = e.FrameReference.AcquireFrame())
{
if (skeletonFrame != null)
{
skeletonFrame.GetAndRefreshBodyData(this.lastframe);
bool found = false;
float minZ = float.MaxValue;
ulong cloestId = 0;
for (int i = 0; i < this.lastframe.Length; i++)
{
if (this.lastframe[i].IsTracked)
{
found = true;
var z = this.lastframe[i].Joints[JointType.Head].Position.Z;
if (z < minZ)
{
z = minZ;
cloestId = this.lastframe[i].TrackingId;
}
}
}
if (found)
{
this.faceFrameSource.TrackingId = cloestId;
this.FOuTrackingId[0] = this.faceFrameSource.TrackingId;
this.faceFrameReader.IsPaused = false;
}
else
{
this.faceFrameReader.IsPaused = true;
this.FOuTrackingId[0] = 0;
}
skeletonFrame.Dispose();
}
}
}
void myBodyReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
if (this.IsPaused)
{
return;
}
PreposeGesturesFrame retFrame = null;
PreposeGesturesFrameArrivedEventArgs upArgs = new PreposeGesturesFrameArrivedEventArgs();
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
// Perform the gesture matching on this frame
var z3body = new Z3Body();
bodyFrame.GetAndRefreshBodyData(this.bodies);
foreach (var body in this.bodies)
{
if (body.TrackingId == this.mySource.TrackingId)
{
// We are at the correct body - go ahead and feed it to the BodyMatcher
IReadOnlyDictionary <Microsoft.Kinect.JointType, Joint> joints = body.Joints;
z3body = Z3KinectConverter.CreateZ3Body(joints);
var result = this.PreposeGesturesFrameSource.myMatcher.TestBody(z3body);
// Fill in the gesture results for this frame
retFrame = new PreposeGesturesFrame();
retFrame.results = result;
break;
}
}
}
}
// TODO: revisit the way the PreposeGesturesFrameReference is implemented to avoid keeping around massive amounts of frames
PreposeGesturesFrameReference retFrameReference = new PreposeGesturesFrameReference(retFrame);
upArgs.FrameReference = retFrameReference;
// Signal that we have a new PreposeGesturesFrame arrived
FrameArrived(this, upArgs);
}
// Update is called once per frame
void Update()
{
// ensure the readers are valid
if (this.bodyFrameReader != null)
{
// process bodies
bool newBodyData = false;
using (BodyFrame bodyFrame = this.bodyFrameReader.AcquireLatestFrame())
{
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(this.bodies);
newBodyData = true;
}
}
if (newBodyData)
{
// update gesture detectors with the correct tracking id
for (int bodyIndex = 0; bodyIndex < this.bodyCount; bodyIndex++)
{
var body = this.bodies[bodyIndex];
if (body != null)
{
var trackingId = body.TrackingId;
// if the current body TrackingId changed, update the corresponding gesture detector with the new value
for (int gestureIndex = 0; gestureIndex < dataList.Count; gestureIndex++)///////////////////////////////////// not complate...
{
if (trackingId != this.gestureList[gestureIndex][bodyIndex].TrackingId)
{
this.gestureList[gestureIndex][bodyIndex].TrackingId = trackingId;
// if the current body is tracked, unpause its detector to get VisualGestureBuilderFrameArrived events
// if the current body is not tracked, pause its detector so we don't waste resources trying to get invalid gesture results
this.gestureList[gestureIndex][bodyIndex].IsPaused = (trackingId == 0);
this.gestureList[gestureIndex][bodyIndex].OnGestureDetected += CreateOnGestureHandler(bodyIndex, gestureList[gestureIndex][bodyIndex]);
}
}
}
}
}
}
}
/// <summary>
/// Process body frames
/// </summary>
private void OnBodyFrameReceived(object sender, BodyFrameArrivedEventArgs e)
{
// Get Frame ref
BodyFrameReference bodyRef = e.FrameReference;
if (bodyRef == null)
{
return;
}
// Get body frame
using (BodyFrame frame = bodyRef.AcquireFrame())
{
if (frame == null)
{
return;
}
// Allocate array when required
if (_bodies == null)
{
_bodies = new Body[frame.BodyCount];
}
// Refresh bodies
frame.GetAndRefreshBodyData(_bodies);
foreach (Body body in _bodies)
{
if (body.IsTracked && _faceSource == null)
{
// Create new sources with body TrackingId
_faceSource = new FaceFrameSource(_kinect, body.TrackingId, _faceFrameFeatures);
// Create new reader
_faceReader = _faceSource.OpenReader();
// Wire events
_faceReader.FrameArrived += OnFaceFrameArrived;
_faceSource.TrackingIdLost += OnTrackingIdLost;
}
}
}
}
/// <summary>
/// Write Body Frame
/// </summary>
/// <param name="multiFrame">MultiSourceFrame retrieved from Kinect.</param>
private void WriteBody(MultiSourceFrame multiFrame)
{
if (multiFrame == null)
{
return;
}
using (BodyFrame bodyFrame = multiFrame.BodyFrameReference.AcquireFrame())
{
if (bodyFrame == null)
{
return;
}
bodyFrame.GetAndRefreshBodyData(bodies);
string time = bodyFrame.RelativeTime.ToString();
//string time = this.time.ToString("yyyy/MM/dd HH:mm:ss.fff", CultureInfo.CurrentUICulture.DateTimeFormat);
foreach (Body body in bodies.Where(body => body != null))
{
if (!body.IsTracked)
{
continue;
}
csv.Write($"{time},{body.TrackingId}");
foreach (var joint in body.Joints)
{
if (joint.Value.TrackingState == TrackingState.Tracked)
{
csv.Write($",{joint.Value.Position.X}");
csv.Write($",{joint.Value.Position.Y}");
csv.Write($",{joint.Value.Position.Z}");
}
else
{
csv.Write(",,,");
}
}
csv.Write("\n");
}
}
}
/// <summary>
/// Handles the body frame data arriving from the sensor and updates the associated gesture detector object for each body
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void Reader_BodyFrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
if (bodies == null)
{
bodies = new List <Body>(new Body[bodyFrame.BodyCount].ToList());
}
bodyFrame.GetAndRefreshBodyData(bodies);
dataReceived = true;
}
}
if (dataReceived)
{
if (bodies != null)
{
int maxBodies = this.kinectRegion.KinectSensor.BodyFrameSource.BodyCount;
for (int i = 0; i < maxBodies; ++i)
{
if (i < bodies.Count)
{
Body body = this.bodies[i];
ulong trackingId = body.TrackingId;
if (maxBodies < this.gestureDetectorList.Count)
{
if (trackingId != this.gestureDetectorList[i].TrackingId)
{
gestureDetectorList[i].TrackingId = trackingId;
gestureDetectorList[i].IsPaused = trackingId == 0;
}
}
}
}
}
}
}
void reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
BodyFrameReference BFReference = e.FrameReference;
try
{
BodyFrame frame = BFReference.AcquireFrame();
if (frame != null)
{
using (frame)
{
using (DrawingContext dc = SkeletonDrawing.Open())
{
dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, DisplayWidth, DisplayHeight));
if (Bodies == null)
{
Bodies = new Body[frame.BodyCount];
}
frame.GetAndRefreshBodyData(Bodies);
foreach (Body b in Bodies)
{
if (b.IsTracked)
{
this.DrawClippedEdges(b, dc);
IReadOnlyDictionary <JointType, Joint> joints = b.Joints;
Dictionary <JointType, Point> jointsPoints = new Dictionary <JointType, Point>();
foreach (JointType jt in joints.Keys)
{
DepthSpacePoint dsp = CordMapper.MapCameraPointToDepthSpace(joints[jt].Position);
jointsPoints[jt] = new Point(dsp.X, dsp.Y);
}
this.DrawBody(joints, jointsPoints, dc);
DrawHand(b.HandLeftState, jointsPoints[JointType.HandLeft], dc);
DrawHand(b.HandRightState, jointsPoints[JointType.HandRight], dc);
}
this.SkeletonDrawing.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, DisplayWidth, DisplayHeight));
}
}
}
}
}
catch (Exception) { }
}
// Update is called once per frame
void Update()
{
if (_reader != null)
{
BodyFrame frame = _reader.AcquireLatestFrame();
if (frame != null)
{
if (_data == null)
{
_data = new Body[_sensor.BodyFrameSource.BodyCount];
}
frame.GetAndRefreshBodyData(_data);
frame.Dispose();
frame = null;
}
}
}
private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e)
{
bool dataReceived = false;
using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
if (this.bodies == null)
{
bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
if (dataReceived)
{
var trackedBodies = bodies.Where(b => b.IsTracked == true);
if (trackedBodies == null || trackedBodies.Count() == 0)
{
return;
}
var activeBody = trackedBodies.OrderBy(b => b.Joints[JointType.FootLeft].Position.Z).First();
if (activeBody != null)
{
_gestureController.UpdateAllGestures(activeBody);
}
//foreach (Body body in this.bodies)
//{
// if (body.IsTracked)
// {
// //LogHelper.GetInstance().ShowMsg(body.Joints[JointType.HandLeft].Position.X + "," + body.Joints[JointType.ElbowLeft].Position.X);
// _gestureController.UpdateAllGestures(body);
// }
//}
}
}
private void multiFrameReader_MultiSourceFrameArrived(object sender, MultiSourceFrameArrivedEventArgs e)
{
MultiSourceFrame multiFrame = e.FrameReference.AcquireFrame();
// Colorの取得と表示
using (var colorFrame = multiFrame.ColorFrameReference.AcquireFrame())
{
if (colorFrame == null)
{
return;
}
// RGB画像の表示
colorBuffer = new byte[colorFrameDescription.Width * colorFrameDescription.Height * colorFrameDescription.BytesPerPixel];
colorFrame.CopyConvertedFrameDataToArray(colorBuffer, ColorImageFormat.Bgra);
ImageColor.Source = BitmapSource.Create(colorFrameDescription.Width, colorFrameDescription.Height, 96, 96,
PixelFormats.Bgra32, null, colorBuffer, colorFrameDescription.Width * (int)colorFrameDescription.BytesPerPixel);
}
// Bodyを１つ探し、ジェスチャー取得の対象として設定
if (!gestureFrameSource.IsTrackingIdValid)
{
using (BodyFrame bodyFrame = multiFrame.BodyFrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(bodies);
foreach (var body in bodies)
{
if (body != null && body.IsTracked)
{
// ジェスチャー判定対象としてbodyを選択
gestureFrameSource.TrackingId = body.TrackingId;
// ジェスチャー判定開始
gestureFrameReader.IsPaused = false;
}
}
}
}
}
}
/// <summary>
/// Capture des corps
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void bodyReader_FrameArrived(BodyFrameReader sender, BodyFrameArrivedEventArgs args)
{
CoreWindow c = Window.Current.CoreWindow;
Debug.WriteLine(DateTime.Now + " IS Body FRame NUll ");
if (args.FrameReference != null)
{
using (BodyFrame bodyFrame = args.FrameReference.AcquireFrame())
{
if (bodyFrame != null)
{
this.bodies = new Body[bodyFrame.BodyCount];
bodyFrame.GetAndRefreshBodyData(this.bodies);
foreach (Body body in this.bodies)
{
if (body.IsTracked)
{
if (app.kinectRegion.KinectEngagementManager != null && app.kinectRegion.KinectEngagementManager.KinectManualEngagedHands != null)
{
Debug.WriteLine(app.kinectRegion.KinectEngagementManager.KinectManualEngagedHands);
}
else
{
Debug.WriteLine("IS NULL --- KINECT REGION");
}
if (body.HandRightState == HandState.Open)
{
btnColor.Background = new SolidColorBrush(Colors.Red);
}
else if (body.HandRightState == HandState.Closed)
{
btnColor.Background = new SolidColorBrush(Colors.Blue);
}
}
}
}
}
}
}
private void AcquireBodyFrames()
{
MultiSourceFrame multiFrame = this.m_MultiSourceFrameReader.AcquireLatestFrame();
if (multiFrame == null)
{
return;
}
using (BodyFrame bodyFrame = multiFrame.BodyFrameReference.AcquireFrame())
{
if (bodyFrame != null && bodyFrame.RelativeTime > this.m_RelativeTime)
{
bodyFrame.GetAndRefreshBodyData(this.m_Bodies);
this.m_BodyCount = 0;
// Count tracked bodies and move them to the
// start of the array.
for (int i = 0, j = this.m_Bodies.Length - 1; i < this.m_Bodies.Length && i < j; ++i)
{
if (this.m_Bodies[i] == null || !this.m_Bodies[i].GetIsTrackedFast())
{
var temp = this.m_Bodies[i];
this.m_Bodies[i--] = this.m_Bodies[j];
this.m_Bodies[j--] = temp;
continue;
}
++this.m_BodyCount;
}
this.m_RelativeTime = bodyFrame.RelativeTime;
this.m_FloorClipPlane = bodyFrame.FloorClipPlane;
++this.m_Frame;
}
}
// In the documentation the MultiSourceFrame implements IDisposable
// but this is not true for the provided scripts. Instead the finalizer
// needs to be called to cleanup the resources.
multiFrame = null;
}
void BodyFrameReady(BodyFrame frame)
{
frame.GetAndRefreshBodyData(m_bodies);
// now update the player-index-to-body mapping
for (int i = 0; i < PlayerCount; i++) {
UpdatePlayerMapping(i);
}
for (int i = 0; i < PlayerCount; i++) {
if (m_eventSinkArray[i] != null)
{
// Update the bodies with the latest pose state. This may fire events and state machine actions.
m_holofunkBodies[i].Update(this,
m_eventSinkArray[i].OnLeftHand,
m_eventSinkArray[i].OnLeftArm,
m_eventSinkArray[i].OnRightHand,
m_eventSinkArray[i].OnRightArm);
}
}
if (m_bodyFrameUpdateAction != null) {
m_bodyFrameUpdateAction(this);
}
}
/// <summary>
/// Finds the closest body from the sensor if any
/// </summary>
/// <param name="bodyFrame">A body frame</param>
/// <returns>Closest body, null of none</returns>
private static Body FindClosestBody(BodyFrame bodyFrame)
{
Body result = null;
double closestBodyDistance = double.MaxValue;
Body[] bodies = new Body[bodyFrame.BodyCount];
bodyFrame.GetAndRefreshBodyData(bodies);
foreach (var body in bodies)
{
if (body.IsTracked)
{
var currentLocation = body.Joints[JointType.SpineBase].Position;
var currentDistance = VectorLength(currentLocation);
if (result == null || currentDistance < closestBodyDistance)
{
result = body;
closestBodyDistance = currentDistance;
}
}
}
return result;
}
/// <summary>
/// Find if there is a body tracked with the given trackingId
/// </summary>
/// <param name="bodyFrame">A body frame</param>
/// <param name="trackingId">The tracking Id</param>
/// <returns>The body object, null of none</returns>
private static Body FindBodyWithTrackingId(BodyFrame bodyFrame, ulong trackingId)
{
Body result = null;
Body[] bodies = new Body[bodyFrame.BodyCount];
bodyFrame.GetAndRefreshBodyData(bodies);
foreach (var body in bodies)
{
if (body.IsTracked)
{
if (body.TrackingId == trackingId)
{
result = body;
break;
}
}
}
return result;
}
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
}
}
private void ShowBodyJoints(BodyFrame bodyFrame)
{
Body[] bodies = new Body[this.kinectSensor.BodyFrameSource.BodyCount];
bool dataReceived = false;
if (bodyFrame != null)
{
bodyFrame.GetAndRefreshBodyData(bodies);
dataReceived = true;
}
if (dataReceived)
{
this.bodiesManager.UpdateBodiesAndEdges(bodies);
}
}
private void updateBodies(BodyFrame frame)
{
if (this.bodies == null)
{
this.bodies = new Body[frame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
frame.GetAndRefreshBodyData(this.bodies);
}
private void RenderBodyFrame(BodyFrame bodyFrame)
{
bool dataReceived = false;
Body[] bodies = null;
if (bodyFrame != null)
{
if (bodies == null)
{
bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(bodies);
dataReceived = true;
}
if (dataReceived)
{
using (DrawingContext dc = this.drawingGroup.Open())
{
// Draw a transparent background to set the render size
dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, Instance._displayWidth, Instance._displayHeight));
int penIndex = 0;
foreach (Body body in bodies)
{
Pen drawPen = this.bodyColors[penIndex++];
if (body.IsTracked)
{
IReadOnlyDictionary<JointType, Joint> joints = body.Joints;
// convert the joint points to depth (display) space
Dictionary<JointType, Point> jointPoints = new Dictionary<JointType, Point>();
foreach (JointType jointType in joints.Keys)
{
// sometimes the depth(Z) of an inferred joint may show as negative
// clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity)
CameraSpacePoint position = joints[jointType].Position;
if (position.Z < 0)
{
position.Z = InferredZPositionClamp;
}
DepthSpacePoint depthSpacePoint = this.coordinateMapper.MapCameraPointToDepthSpace(position);
jointPoints[jointType] = new Point(depthSpacePoint.X, depthSpacePoint.Y);
}
this.DrawBody(joints, jointPoints, dc, drawPen, body.JointOrientations);
if (Instance.DrawOrientationVectors == true)
{
this.DrawLocalCoordinates(body.JointOrientations, joints, jointPoints, dc);
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, Instance._displayWidth, Instance._displayHeight));
}
}
}
public void processBodyFrame(BodyFrame frame)
{
frame.GetAndRefreshBodyData(bodies);
foreach (var body in Bodies)
{
if (!eManager.users.ContainsKey(body.TrackingId))
{
eManager.users[body.TrackingId] = new MyHuman(body);
eManager.holdTime[body.TrackingId] = 0;
}
// Multithreading maybe
drawer.currentCanvasName = "body";
drawer.drawSkeleton(body);
}
}
private void ShowInfraredFrame(InfraredFrame infraredFrame, BodyFrame bodyFrame)
{
bool infraredFrameProcessed = false;
if (infraredFrame != null)
{
FrameDescription infraredFrameDescription = infraredFrame.FrameDescription;
// verify data and write the new infrared frame data to the display bitmap
if (((infraredFrameDescription.Width * infraredFrameDescription.Height)
== this.infraredFrameData.Length) &&
(infraredFrameDescription.Width == this.bitmap.PixelWidth) &&
(infraredFrameDescription.Height == this.bitmap.PixelHeight))
{
//Debug.WriteLine("Width is " + infraredFrameDescription.Width);
//Debug.WriteLine("Height is " + infraredFrameDescription.Height);
infraredWidth = infraredFrameDescription.Width;
infraredHeight = infraredFrameDescription.Height;
// Copy the pixel data from the image to a temporary array
infraredFrame.CopyFrameDataToArray(this.infraredFrameData);
infraredFrameProcessed = true;
}
}
if (bodyFrame != null && bodyFrame.BodyCount > 0)
{
myBodies = new Body[this.kinectSensor.BodyFrameSource.BodyCount];
bodyFrame.GetAndRefreshBodyData(myBodies);
}
// we got a frame, convert and render
if (infraredFrameProcessed)
{
this.ConvertInfraredDataToPixels(myBodies);
this.RenderPixelArray(this.infraredPixels);
}
}
private void processBodyFrame(BodyFrame bodyFrame, bool showSkeleton, bool showHandStates)
{
if (this.bodies == null)
{
this.bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
players[0] = null;
players[1] = null;
Body[] tempBodies = new Body[2];
int playerCount = 0;
foreach (Body body in this.bodies)
{
if (body.IsTracked && playerCount < 2)
{
tempBodies[playerCount++] = body;
}
}
if (playerCount == 2)
{
CameraSpacePoint player0Pos = tempBodies[0].Joints[JointType.SpineMid].Position;
CameraSpacePoint player1Pos = tempBodies[1].Joints[JointType.SpineMid].Position;
if (player0Pos.X < player1Pos.X)
{
players[0] = new Player(tempBodies[0]);
players[1] = new Player(tempBodies[1]);
}
else
{
players[1] = new Player(tempBodies[0]);
players[0] = new Player(tempBodies[1]);
}
}
using (DrawingContext dc = this.drawingGroup.Open())
{
// Draw a transparent background to set the render size
dc.DrawRectangle(Brushes.Transparent, null, new Rect(0.0, 0.0, this.displayWidth, this.displayHeight));
int penIndex = 0;
foreach (Player player in players)
{
if (player == null) continue;
Body body = player.body;
Pen drawPen = this.bodyColors[penIndex++];
if (body.IsTracked)
{
//this.DrawClippedEdges(body, dc);
IReadOnlyDictionary<JointType, Joint> joints = body.Joints;
// convert the joint points to depth (display) space
Dictionary<JointType, Point> jointPoints = new Dictionary<JointType, Point>();
Dictionary<JointType, float> jointPointDepths = new Dictionary<JointType, float>();
foreach (JointType jointType in joints.Keys)
{
// sometimes the depth(Z) of an inferred joint may show as negative
// clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity)
CameraSpacePoint position = joints[jointType].Position;
if (position.Z < 0)
{
position.Z = InferredZPositionClamp;
}
ColorSpacePoint colorSpacePoint = this.coordinateMapper.MapCameraPointToColorSpace(position);
jointPoints[jointType] = new Point(colorSpacePoint.X, colorSpacePoint.Y);
jointPointDepths[jointType] = position.Z;
}
// Maps the actual joint points to the player
player.jointPoints = jointPoints;
player.jointPointDepths = jointPointDepths;
if (showSkeleton)
{
this.DrawBody(joints, jointPoints, dc, drawPen);
}
if (showHandStates)
{
this.DrawHand(body.HandLeftState, jointPoints[JointType.HandLeft], dc);
this.DrawHand(body.HandRightState, jointPoints[JointType.HandRight], dc);
}
// THIS IS WHERE THE UPDATES GO. CAN'T MOVE IT BECAUSE OF THE GC OF DRAWING CONTEXT
/*
this.targetCircleL.update(
body.HandLeftState,
body.HandRightState,
jointPoints[JointType.HandLeft],
jointPoints[JointType.HandRight],
jointPointDepths[JointType.HandLeft],
jointPointDepths[JointType.HandLeft]
);
this.targetCircleL.draw(dc);
*/
//basketballManager.update(player[0], player[1]);
//basketballManager.draw(dc);
//processBasketballManager(players[0], players[1], dc);
}
}
if (players[0] != null && players[1] != null)
processBasketballManager(players[0], players[1], dc);
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, this.displayWidth, this.displayHeight));
}
bodyFrame.Dispose();
}
private void ShowBody( BodyFrame bodyFrame )
{
frameCount++;
if ( sw.ElapsedMilliseconds >= 1000 ) {
scratch.AddSensorValue( "FrameCount", frameCount.ToString() );
sw.Restart();
frameCount = 0;
}
var mapper = kinect.CoordinateMapper;
CanvasBody.Children.Clear();
bodyFrame.GetAndRefreshBodyData( bodies );
var trackedBody = bodies.FirstOrDefault( b => b.IsTracked );
if ( trackedBody != null ) {
var body = trackedBody;
foreach ( var jointType in body.Joints.Keys ) {
var joint = body.Joints[jointType];
if ( joint.TrackingState != TrackingState.NotTracked ) {
ShowJoint( mapper, joint );
int scale = 200;
AddSensorValue( jointType, "X", (int)(joint.Position.X * scale) );
AddSensorValue( jointType, "Y", (int)(joint.Position.Y * scale) );
}
}
if ( body.HandLeftConfidence == TrackingConfidence.High ) {
AddSensorValue( "HandLeftState", body.HandLeftState.ToString() );
}
else {
AddSensorValue( "HandLeftState", HandState.Unknown.ToString() );
}
if ( body.HandRightConfidence == TrackingConfidence.High ) {
AddSensorValue( "HandRightState", body.HandRightState.ToString() );
}
else {
AddSensorValue( "HandRightState", HandState.Unknown.ToString() );
}
}
else {
foreach ( JointType jointType in Enum.GetValues(typeof(JointType) ) ) {
AddSensorValue( jointType, "X", 0 );
AddSensorValue( jointType, "Y", 0 );
}
AddSensorValue( "HandLeftState", HandState.Unknown.ToString() );
AddSensorValue( "HandRightState", HandState.Unknown.ToString() );
}
scratch.UpdateSensor();
}
void DoThingsWithBodyFrame(BodyFrame frame)
{
canvas.Children.Clear();
bodies = new Body[frame.BodyFrameSource.BodyCount];
frame.GetAndRefreshBodyData(bodies);
foreach (Body body in bodies)
{
if (body != null)
{
//Console.WriteLine("Body not null");
//canvas.DrawBody(body);
if (body.IsTracked)
{
Joint[] joints = {
body.Joints[JointType.ThumbLeft],
body.Joints[JointType.ThumbRight],
body.Joints[JointType.HandLeft],
body.Joints[JointType.HandRight]
};
foreach (Joint joint in joints)
{
CameraSpacePoint jointPosition = joint.Position;
Point point = new Point();
if (joint.TrackingState == TrackingState.Tracked)
{
ColorSpacePoint colorPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(jointPosition);
point.X = float.IsInfinity(colorPoint.X) ? 0 : colorPoint.X;
point.Y = float.IsInfinity(colorPoint.Y) ? 0 : colorPoint.Y;
}
Ellipse ellipse = new Ellipse
{
Fill = Brushes.IndianRed,
Width = 15,
Height = 15
};
Canvas.SetLeft(ellipse, point.X - ellipse.Width / 2);
Canvas.SetTop(ellipse, point.Y - ellipse.Height / 2);
canvas.Children.Add(ellipse);
}
}
#region oldTest
//if (body.IsTracked)
//{
// Joint handRight = body.Joints[JointType.HandRight];
// CameraSpacePoint camHandRight = handRight.Position;
// ColorSpacePoint hrPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(camHandRight);
// Joint thumbRight = body.Joints[JointType.ThumbRight];
// CameraSpacePoint camThumbRight = thumbRight.Position;
// ColorSpacePoint trPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(camThumbRight);
// Joint handLeft = body.Joints[JointType.HandLeft];
// CameraSpacePoint camHandLeft = handLeft.Position;
// ColorSpacePoint hlPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(camHandLeft);
// Joint thumbLeft = body.Joints[JointType.ThumbLeft];
// CameraSpacePoint camThumbLeft = thumbLeft.Position;
// ColorSpacePoint tlPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(camThumbLeft);
// if (handLeft.TrackingState != TrackingState.Tracked) return;
// if (handRight.TrackingState != TrackingState.Tracked) return;
// if (thumbLeft.TrackingState != TrackingState.Tracked) return;
// if (thumbRight.TrackingState != TrackingState.Tracked) return;
// canvas.DrawPoint(hrPoint, 0);
// canvas.DrawPoint(trPoint, 1);
// canvas.DrawPoint(hlPoint, 0);
// canvas.DrawPoint(tlPoint, 1);
//}
#endregion
}
}
}
//lab 13
private void RegisterGesture(BodyFrame bodyFrame)
{
bool dataReceived = false;
Body[] bodies = null;
if (bodyFrame != null)
{
if (bodies == null)
{
// Creates an array of 6 bodies, which is the max number of bodies that Kinect can track simultaneously
bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(bodies);
dataReceived = true;
}
if (dataReceived)
{
// We may have lost/acquired bodies, so update the corresponding gesture detectors
if (bodies != null)
{
// Loop through all bodies to see if any of the gesture detectors need to be updated
for (int i = 0; i < bodyFrame.BodyCount; ++i)
{
Body body = bodies[i];
ulong trackingId = body.TrackingId;
// If the current body TrackingId changed, update the corresponding gesture detector with the new value
if (trackingId != this.gestureDetectorList[i].TrackingId)
{
this.gestureDetectorList[i].TrackingId = trackingId;
// If the current body is tracked, unpause its detector to get VisualGestureBuilderFrameArrived events
// If the current body is not tracked, pause its detector so we don't waste resources trying to get invalid gesture results
this.gestureDetectorList[i].IsPaused = trackingId == 0;
}
}
}
}
}
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();
}
private void RegisterGesture(BodyFrame bodyFrame)
{
bool dataReceived = false;
Body[] bodies = null;
if (bodyFrame != null)
{
if (bodies == null)
{
bodies = new Body[bodyFrame.BodyCount];
}
bodyFrame.GetAndRefreshBodyData(bodies);
dataReceived = true;
}
if (dataReceived)
{
if (bodies != null)
{
for (int i = 0; i < bodyFrame.BodyCount; i++)
{
Body body = bodies[i];
ulong trackingId = body.TrackingId;
if (trackingId != gestureDetectorList[i].TrackingId)
{
gestureDetectorList[i].TrackingId = trackingId;
gestureDetectorList[i].IsPaused = trackingId == 0;
}
}
}
}
}
// Reads in the bodyFrame (if it contains bodies)
private void GetBodyJoints(BodyFrame bodyFrame)
{
//Makes sure the bodyFrame contains bodies, and if so, puts the data in bodies
if(bodyFrame != null)
{
if (this.bodies == null)
{
bodies = new Body[bodyFrame.BodyCount];
}
// The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array.
// As long as those body objects are not disposed and not set to null in the array,
// those body objects will be re-used.
bodyFrame.GetAndRefreshBodyData(this.bodies);
dataReceived = true;
}
}
