void kinectRuntime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame skeletonFrame = e.SkeletonFrame;
foreach (SkeletonData data in skeletonFrame.Skeletons)
{
if (data.TrackingState != SkeletonTrackingState.Tracked)
continue;
barycenterHelper.Add(data.Position.ToVector3(),data.TrackingID);
if (!barycenterHelper.IsStable(data.TrackingID))
continue;
foreach (Joint joint in data.Joints)
{
if (joint.Position.W < 0.8f || joint.TrackingState != JointTrackingState.Tracked)
continue;
if (joint.ID == JointID.HandRight)
{
rightHandGestureRecognizer.Add(joint.Position, kinectRuntime.SkeletonEngine);
Trace.WriteLine(Gesture.Content = "HandRight.Add");
}
}
// ポーズの検出
postureRecognizer.TrackPostures(data);
}
// スケルトンの描画
skeletonDisplayManager.Draw(e.SkeletonFrame);
labelPose.Content = "Pose: " + postureRecognizer.CurrentPosture.ToString();
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void runtime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame skeletonSet = e.SkeletonFrame;
SkeletonData data = (from s in skeletonSet.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
SetEllipsePosition(head, data.Joints[JointID.Head]);
SetEllipsePosition(leftHand, data.Joints[JointID.HandLeft]);
SetEllipsePosition(rightHand, data.Joints[JointID.HandRight]);
// draw joints
Joint headjoint = data.Joints[JointID.Head];
Joint leftShoulderJoint = data.Joints[JointID.ShoulderLeft];
Joint centerShoulderJoint = data.Joints[JointID.ShoulderCenter];
Joint rightShoulderJoint = data.Joints[JointID.ShoulderRight];
Joint spineJoint = data.Joints[JointID.Spine];
Joint leftWristJoint = data.Joints[JointID.WristLeft];
Joint rightWristJoint = data.Joints[JointID.WristRight];
Joint leftHandJoint = data.Joints[JointID.HandLeft];
Joint rightHandJoint = data.Joints[JointID.HandRight];
// draw skeleton
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
//get the first tracked skeleton
SkeletonData skeleton = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
if (skeleton != null)
{
this._skel = skeleton;
Joint head = skeleton.Joints[JointID.Head];
HumanSkeleton hs = new HumanSkeleton(skeleton.Joints);
NaoSkeleton ns = new NaoSkeleton(hs);
UpdateTextBoxes(ns, hs);
controller.update(ns);
SetLineAngle(RightArmTopDown, Util.radToDeg(hs.RightShoulderYaw));
SetLineAngle(LeftArmTopDown, Util.radToDeg(hs.LeftShoulderYaw));
SetLineAngle(RightArmFront, Util.radToDeg(-hs.RightShoulderPitch) + 90);
SetLineAngle(LeftArmFront, Util.radToDeg(hs.LeftShoulderPitch) - 90);
SetLineAngle(RightArm, Util.radToDeg(-hs.RightShoulderRoll) + 90);
SetLineAngle(LeftArm, Util.radToDeg(hs.LeftShoulderRoll) - 90);
}
}
public void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
if (!IsRecording) return;
lock (RecordStream)
{
SkeletonFrame skeletonFrame = e.SkeletonFrame;
int iSkeleton = 0;
foreach (SkeletonData data in skeletonFrame.Skeletons)
{
if (SkeletonTrackingState.Tracked == data.TrackingState)
{
//Recording for longer than a day will cause the timer to roll over. Who would record 24+ hours of Kinect data anyways?
TimeSpan elapsedTime = DateTime.Now - StartTime;
RecordStream.Write(elapsedTime.Hours.ToString() + ":" + elapsedTime.Minutes.ToString() + ":" + elapsedTime.Seconds.ToString() + ":" + elapsedTime.Milliseconds.ToString() + ",");
foreach (Joint joint in data.Joints)
{
RecordStream.Write(joint.ID.ToString() + "," + (joint.Position.X * 1000).ToString() + "," + (joint.Position.Y * 1000) + "," + (joint.Position.Z * 1000)+",");
}
RecordStream.WriteLine("");
}
iSkeleton++;
} // for each skeleton
}
}
void xtion_SkeletonFrameReady( object sender, SkeletonFrameReadyEventArgs e )
{
this.Dispatcher.BeginInvoke( DispatcherPriority.Background, new Action( () =>
{
canvas1.Children.Clear();
foreach ( var u in e.Users ) {
if ( !e.Skeleton.IsTracking( u ) ) {
continue;
}
foreach ( SkeletonJoint s in Enum.GetValues( typeof( SkeletonJoint ) ) ) {
if ( !e.Skeleton.IsJointAvailable( s ) || !e.Skeleton.IsJointActive( s ) ) {
continue;
}
var joint = e.Skeleton.GetSkeletonJoint( u, s );
var point = e.DepthGenerator.ConvertRealWorldToProjective( joint.Position.Position );
point = point.ScaleTo( e.DepthGenerator, 320, 240 );
const int dimeter = 10;
const int r = dimeter / 2;
canvas1.Children.Add( new Ellipse()
{
Fill = Brushes.Red,
Margin = new Thickness( point.X - r, point.Y - r, point.X + r, point.Y + r ),
Height = dimeter,
Width = dimeter,
} );
}
}
} ) );
}
private void kinectRuntime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
if (e.SkeletonFrame == null)
return;
if (!e.SkeletonFrame.Skeletons.Any(s => s.TrackingState != SkeletonTrackingState.NotTracked))
return;
ProcessFrame(e.SkeletonFrame);
}
private void KinectRuntime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
// Get the first tracked skeleton.
skeleton.SkeletonData = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
}
void runtime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
var skeleton = e.SkeletonFrame.Skeletons.Where(s => s.TrackingState == SkeletonTrackingState.Tracked).FirstOrDefault();
if (skeleton != null && this.SkeletonUpdated != null)
{
this.SkeletonUpdated(this,
new SkeletonUpdatedEventArgs() { HandRightJoint = skeleton.Joints[JointID.HandRight] });
}
}
void kinectRuntime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
if (recorder != null)
recorder.Record(e.SkeletonFrame);
if (e.SkeletonFrame.Skeletons.Where(s => s.TrackingState != SkeletonTrackingState.NotTracked).Count() == 0)
return;
ProcessFrame(e.SkeletonFrame);
}
public void kinectSensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Console.WriteLine("Hey, listen");
SkeletonFrame skeletonFrame = e.SkeletonFrame;
Boolean player1 = true;
foreach (SkeletonData data in skeletonFrame.Skeletons)
{
if (data.TrackingState == SkeletonTrackingState.Tracked)
Console.WriteLine("Im watching you");
{
if (player1)
{
foreach (Joint joint in data.Joints)
{
if (joint.ID == JointID.HandLeft)
{
player1LeftHand = joint.Position.ToVector2();
}
else if (joint.ID == JointID.ElbowLeft)
{
player1LeftElbow = joint.Position.ToVector2();
}
}
player1Theta = (float)Math.Atan(((player1LeftHand.Y - player1LeftElbow.Y) / (player1LeftHand.X - player1LeftElbow.X)));
player1Theta = (player1Theta * 180) / (float)Math.PI;
Console.WriteLine(player1Theta + "Is my angle");
thisGameIsAwesome.screenManager.input.myArmAngle = player1Theta;
}
else
{
foreach (Joint joint in data.Joints)
{
if (joint.ID == JointID.HandRight)
{
player2RightHand = joint.Position.ToVector2();
}
else if (joint.ID == JointID.ElbowRight)
{
player2RightElbow = joint.Position.ToVector2();
}
}
player2Theta = (float)Math.Atan(((player2RightHand.Y - player2RightElbow.Y) / (player2RightHand.X - player2RightElbow.X)));
}
}
//player1 = !player1;
return;
}
}
private void kinectSensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
foreach (SkeletonData s in e.SkeletonFrame.Skeletons)
{
if (s.TrackingState == SkeletonTrackingState.Tracked)
{
resolution = new Vector2(640, 480);
skeleton = s;
rightHandJoint = skeleton.Joints[JointID.HandRight];
position = new Vector2((((0.5f * rightHandJoint.Position.X) + 0.5f) * (resolution.X)), (((-0.5f * rightHandJoint.Position.Y) + 0.5f) * (resolution.Y)));
}
}
}
private void KinectRuntime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
SkeletonData skeleton = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
if (skeleton != null)
{
DrawSkeleton(skeleton);
}
}
void Nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
canvas.Children.Clear();
foreach (SkeletonData user in e.SkeletonFrame.Skeletons)
{
if (user.TrackingState == SkeletonTrackingState.Tracked)
{
foreach (Joint joint in user.Joints)
{
DrawPoint(joint, Colors.Blue);
}
}
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
//get the first tracked skeleton
SkeletonData skeleton = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
if(skeleton != null)
{
gestureController.processSkeletonFrame(skeleton);
}
}
/// <summary>
/// the event handler for the skeleton frame ready event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allskeletons = e.SkeletonFrame;
SkeletonData skeleton = (from s in allskeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
setpositionellipse(ellipse1,skeleton.Joints[JointID.Head]);
setpositionellipse(ellipse2, skeleton.Joints[JointID.HandLeft]);
setpositionellipse(ellipse3, skeleton.Joints[JointID.HandRight]);
setpositionellipse(ellipse4, skeleton.Joints[JointID.FootLeft]);
setpositionellipse(ellipse5, skeleton.Joints[JointID.FootRight]);
getCoordinates_Playsound(skeleton.Joints[JointID.HandLeft]);
}
void runtime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
var skeleton =
e.SkeletonFrame.Skeletons
.Where(s => s.TrackingState == SkeletonTrackingState.Tracked)
.FirstOrDefault();
if (skeleton == null)
{
return;
}
var position = skeleton.Joints[JointID.HandRight].Position;
if (this.SkeletonUpdated != null)
{
this.SkeletonUpdated(this, new SkeletonEventArgs() { RightHandPosition = position });
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
foreach (SkeletonData data in e.SkeletonFrame.Skeletons)
{
Gesture.updateJoints(data);
foreach (Gesture gesture in gestures)
{
if (gesture.timeDelayHasPassed()) //check for time delay.
{
if (gesture.isDoingGesture()) //check to see if the gesture is being performed.
{
//hey, the gesture is being performed. Go do some thing with it in your program...
MessageBox.Show(gesture.getDescription()); //In this example I just print the Gesture's description.
gesture.updateGesture();
}
}
}
}
}
void runtime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
foreach (SkeletonData data in e.SkeletonFrame.Skeletons)
{
if (data.TrackingState == SkeletonTrackingState.Tracked)
{
Joint joint = data.Joints[JointID.HandLeft];
if (joint.TrackingState != JointTrackingState.Tracked)
break;
int handY = (int) joint.ScaleTo(kGameWidth, kGameHeight - kPaddleHeight, 0.6f, 0.4f).Position.Y;
handY = Math.Max(handY, 0);
handY = Math.Min(handY, kGameHeight - kPaddleHeight);
ourPaddleRect.Y = handY;
break;
}
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
//get the first tracked skeleton
SkeletonData skeleton = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
if(skeleton != null)
{
//set positions on our joints of interest (already defined as Ellipse objects in the xaml)
SetEllipsePosition(headEllipse, skeleton.Joints[JointID.Head]);
SetEllipsePosition(leftEllipse, skeleton.Joints[JointID.HandLeft]);
SetEllipsePosition(rightEllipse, skeleton.Joints[JointID.HandRight]);
SetEllipsePosition(shoulderCenter, skeleton.Joints[JointID.ShoulderCenter]);
SetEllipsePosition(shoulderRight, skeleton.Joints[JointID.ShoulderRight]);
SetEllipsePosition(shoulderLeft, skeleton.Joints[JointID.ShoulderLeft]);
SetEllipsePosition(ankleRight, skeleton.Joints[JointID.AnkleRight]);
SetEllipsePosition(ankleLeft, skeleton.Joints[JointID.AnkleLeft]);
SetEllipsePosition(footLeft, skeleton.Joints[JointID.FootLeft]);
SetEllipsePosition(footRight, skeleton.Joints[JointID.FootRight]);
SetEllipsePosition(wristLeft, skeleton.Joints[JointID.WristLeft]);
SetEllipsePosition(wristRight, skeleton.Joints[JointID.WristRight]);
SetEllipsePosition(elbowLeft, skeleton.Joints[JointID.ElbowLeft]);
SetEllipsePosition(elbowRight, skeleton.Joints[JointID.ElbowRight]);
SetEllipsePosition(ankleLeft, skeleton.Joints[JointID.AnkleLeft]);
SetEllipsePosition(footLeft, skeleton.Joints[JointID.FootLeft]);
SetEllipsePosition(footRight, skeleton.Joints[JointID.FootRight]);
SetEllipsePosition(wristLeft, skeleton.Joints[JointID.WristLeft]);
SetEllipsePosition(wristRight, skeleton.Joints[JointID.WristRight]);
SetEllipsePosition(kneeLeft, skeleton.Joints[JointID.KneeLeft]);
SetEllipsePosition(kneeRight, skeleton.Joints[JointID.KneeRight]);
SetEllipsePosition(hipCenter, skeleton.Joints[JointID.HipCenter]);
currentController.processSkeletonFrame(skeleton, targets);
}
}
void runtime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
var skeleton = e.SkeletonFrame.Skeletons
.Where(s => s.TrackingState == SkeletonTrackingState.Tracked)
.FirstOrDefault();
if (skeleton != null)
{
if (this.SkeletonUpdated != null)
{
this.swipe.AddSwipePoint(skeleton.Joints[JointID.HandRight].Position);
this.SkeletonUpdated(this,
new SkeletonUpdatedEventArgs()
{
HandRight = skeleton.Joints[JointID.HandRight],
HipRight = skeleton.Joints[JointID.HipRight],
ShoulderRight = skeleton.Joints[JointID.ShoulderRight],
Head = skeleton.Joints[JointID.Head]
});
}
}
}
void SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
if (isRecorder)
{
recorder.Record(allSkeletons);
}
// Get the first tracked skeleton
SkeletonData skeleton = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
if (skeleton != null)
{
// Set positions on our joints of interest
Head = GetScaledPosition(skeleton.Joints[JointID.Head]);
HandLeft = GetScaledPosition(skeleton.Joints[JointID.HandLeft]);
HandRight = GetScaledPosition(skeleton.Joints[JointID.HandRight]);
ShoulderCenter = GetScaledPosition(skeleton.Joints[JointID.ShoulderCenter]);
ShoulderRight = GetScaledPosition(skeleton.Joints[JointID.ShoulderRight]);
ShoulderLeft = GetScaledPosition(skeleton.Joints[JointID.ShoulderLeft]);
AnkleRight = GetScaledPosition(skeleton.Joints[JointID.AnkleRight]);
AnkleLeft = GetScaledPosition(skeleton.Joints[JointID.AnkleLeft]);
FootLeft = GetScaledPosition(skeleton.Joints[JointID.FootLeft]);
FootRight = GetScaledPosition(skeleton.Joints[JointID.FootRight]);
WristLeft = GetScaledPosition(skeleton.Joints[JointID.WristLeft]);
WristRight = GetScaledPosition(skeleton.Joints[JointID.WristRight]);
ElbowLeft = GetScaledPosition(skeleton.Joints[JointID.ElbowLeft]);
ElbowRight = GetScaledPosition(skeleton.Joints[JointID.ElbowRight]);
KneeLeft = GetScaledPosition(skeleton.Joints[JointID.KneeLeft]);
KneeRight = GetScaledPosition(skeleton.Joints[JointID.KneeRight]);
HipCenter = GetScaledPosition(skeleton.Joints[JointID.HipCenter]);
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
foreach (SkeletonData data in e.SkeletonFrame.Skeletons)
{
Gesture.updateJoints(data);
foreach (TelemetryGesture gesture in gestures)
{
if (gesture.timeDelayHasPassed()) //check for time delay.
{
if (gesture.isDoingGesture()) //check to see if the gesture is being performed.
{
short val = gesture.getAdditionalData();
if (val == TelemetryGesture.NO_ONE_CARES)
{
GlobalStuff.SendData(gesture.getID());
}
else
{
GlobalStuff.SendData(gesture.getID(), val);
}
gesture.updateGesture();
const string line = "\n=======================================";
richTextBox1.Text += line;
richTextBox1.Text += "Performing:\t" + gesture.getDescription();
richTextBox1.Text += "\nSending Command:\t" + gesture.getID();
richTextBox1.Text += "\nRobot Functionality:\t " + gesture.getRobotDescription();
if (gesture.getAdditionalData() != TelemetryGesture.NO_ONE_CARES)
{
richTextBox1.Text += "\nAdditional Robot Data:\t" + gesture.getAdditionalData();
}
}
}
}
}
}
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[1]; //Declaramos el array del esqueleto
//Abre un objeto SkeletonFrame, que contiene un marco de datos de esqueleto.
using (SkeletonFrame skeletonframe = e.OpenSkeletonFrame())
{
if (skeletonframe != null)//Compruebe si el marco está abierto
{
skeletons = new Skeleton[skeletonframe.SkeletonArrayLength];
//Copia los datos del esqueleto a una serie de esqueletos, donde cada esqueleto contiene una colección de las articulaciones.
skeletonframe.CopySkeletonDataTo(skeletons);
//dibujar el esqueleto basado en el modo predeterminado (de pie), "sentado"
if (miKinect.SkeletonStream.TrackingMode == SkeletonTrackingMode.Default)
{
DrawStandingSkeletons(skeletons);
}
else if (miKinect.SkeletonStream.TrackingMode == SkeletonTrackingMode.Seated)
{
//Dibuja un esqueleto sentado con 10 articulaciones
DrawStandingSkeletons(skeletons);
}
}
}
}
private void kinect_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (SkeletonFrame skelFrame = e.OpenSkeletonFrame())
{
if (skelFrame != null && masterSettings.kinectOptionsList.Count > kinectID && (masterKinectSettings.mergeSkeletons || masterKinectSettings.sendRawSkeletons))
{
DateTime now = DateTime.UtcNow;
Skeleton[] skeletons = new Skeleton[skelFrame.SkeletonArrayLength];
skelFrame.CopySkeletonDataTo(skeletons);
EigenWrapper.Matrix predAccel = new EigenWrapper.Matrix(3, 1);
predAccel[2, 0] = 1;
if (accelFilterStarted)
{
predAccel = accelerationFilter.PredictAndDiscard(0);
}
if (interactStream != null)
{
Vector4 filteredAccel = new Vector4();
filteredAccel.W = 0;
filteredAccel.X = (float)predAccel[0, 0];
filteredAccel.Y = (float)predAccel[1, 0];
filteredAccel.Z = (float)predAccel[2, 0];
interactStream.ProcessSkeleton(skeletons, filteredAccel, skelFrame.Timestamp);
//System.Diagnostics.Trace.WriteLine("[" + filteredAccel.X + ", " + filteredAccel.Y + ", " + filteredAccel.Z + "]");
}
//Generate the transformation matrix for the skeletons
double kinectYaw = masterKinectSettings.kinectYaw;
Point3D kinectPosition = masterKinectSettings.kinectPosition;
Matrix3D gravityBasedKinectRotation = findRotation(new Vector3D(predAccel[0, 0], predAccel[1, 0], predAccel[2, 0]), new Vector3D(0, -1, 0));
AxisAngleRotation3D yawRotation = new AxisAngleRotation3D(new Vector3D(0, 1, 0), -kinectYaw);
RotateTransform3D tempYawTrans = new RotateTransform3D(yawRotation);
TranslateTransform3D transTrans = new TranslateTransform3D((Vector3D)kinectPosition);
Matrix3D rotationOnlyMatrix = Matrix3D.Multiply(tempYawTrans.Value, gravityBasedKinectRotation);
Matrix3D masterMatrix = Matrix3D.Multiply(rotationOnlyMatrix, transTrans.Value);
skeletonTransformation = masterMatrix;
skeletonRotQuaternion = KinectBase.HelperMethods.MatrixToQuaternion(rotationOnlyMatrix);
//Convert from Kinect v1 skeletons to KVR skeletons
KinectBase.KinectSkeleton[] kvrSkeletons = new KinectBase.KinectSkeleton[skeletons.Length];
for (int i = 0; i < kvrSkeletons.Length; i++)
{
//Set the tracking ID numbers for the hand grab data
int grabID = -1;
for (int j = 0; j < skeletonHandGrabData.Count; j++)
{
if (skeletonHandGrabData[j].skeletonTrackingID == skeletons[i].TrackingId)
{
grabID = j;
break;
}
}
if (grabID < 0)
{
skeletonHandGrabData.Add(new HandGrabInfo(skeletons[i].TrackingId));
grabID = skeletonHandGrabData.Count - 1;
}
kvrSkeletons[i] = new KinectBase.KinectSkeleton();
kvrSkeletons[i].Position = new Point3D(skeletons[i].Position.X, skeletons[i].Position.Y, skeletons[i].Position.Z);
kvrSkeletons[i].SkeletonTrackingState = convertTrackingState(skeletons[i].TrackingState);
kvrSkeletons[i].TrackingId = skeletons[i].TrackingId;
//kvrSkeletons[i].utcSampleTime = DateTime.UtcNow;
kvrSkeletons[i].sourceKinectID = kinectID;
for (int j = 0; j < skeletons[i].Joints.Count; j++)
{
KinectBase.Joint newJoint = new KinectBase.Joint();
newJoint.Confidence = KinectBase.TrackingConfidence.Unknown; //The Kinect 1 doesn't support the confidence property
newJoint.JointType = convertJointType(skeletons[i].Joints[(JointType)j].JointType);
Vector4 tempQuat = skeletons[i].BoneOrientations[(JointType)j].AbsoluteRotation.Quaternion;
newJoint.Orientation.orientationQuaternion = new Quaternion(tempQuat.X, tempQuat.Y, tempQuat.Z, tempQuat.W);
Matrix4 tempMat = skeletons[i].BoneOrientations[(JointType)j].AbsoluteRotation.Matrix;
newJoint.Orientation.orientationMatrix = new Matrix3D(tempMat.M11, tempMat.M12, tempMat.M13, tempMat.M14,
tempMat.M21, tempMat.M22, tempMat.M23, tempMat.M24,
tempMat.M31, tempMat.M32, tempMat.M33, tempMat.M34,
tempMat.M41, tempMat.M42, tempMat.M43, tempMat.M44);
SkeletonPoint tempPos = skeletons[i].Joints[(JointType)j].Position;
newJoint.Position = new Point3D(tempPos.X, tempPos.Y, tempPos.Z);
newJoint.TrackingState = convertTrackingState(skeletons[i].Joints[(JointType)j].TrackingState);
newJoint.spatialErrorStdDev = getJointError(newJoint.Position, newJoint.TrackingState);
newJoint.utcTime = now;
kvrSkeletons[i].skeleton[newJoint.JointType] = newJoint; //Skeleton doesn't need to be initialized because it is done in the KinectSkeleton constructor
}
//Get the hand states from the hand grab data array
kvrSkeletons[i].rightHandClosed = skeletonHandGrabData[grabID].rightHandClosed;
kvrSkeletons[i].leftHandClosed = skeletonHandGrabData[grabID].leftHandClosed;
}
//Add the skeleton data to the event handler and throw the event
KinectBase.SkeletonEventArgs skelE = new KinectBase.SkeletonEventArgs();
skelE.skeletons = kvrSkeletons;
skelE.kinectID = kinectID;
OnSkeletonChanged(skelE);
}
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame skeletonFrame = e.SkeletonFrame;
int iSkeleton = 0;
Brush[] brushes = new Brush[6];
brushes[0] = new SolidColorBrush(Color.FromRgb(255, 0, 0));
brushes[1] = new SolidColorBrush(Color.FromRgb(0, 255, 0));
brushes[2] = new SolidColorBrush(Color.FromRgb(64, 255, 255));
brushes[3] = new SolidColorBrush(Color.FromRgb(255, 255, 64));
brushes[4] = new SolidColorBrush(Color.FromRgb(255, 64, 255));
brushes[5] = new SolidColorBrush(Color.FromRgb(128, 128, 255));
skeleton.Children.Clear();
foreach (SkeletonData data in skeletonFrame.Skeletons)
{
if (SkeletonTrackingState.Tracked == data.TrackingState)
{
// Draw bones
Brush brush = brushes[iSkeleton % brushes.Length];
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.Spine, JointID.ShoulderCenter, JointID.Head));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.ShoulderCenter, JointID.ShoulderLeft, JointID.ElbowLeft, JointID.WristLeft, JointID.HandLeft));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.ShoulderCenter, JointID.ShoulderRight, JointID.ElbowRight, JointID.WristRight, JointID.HandRight));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.HipLeft, JointID.KneeLeft, JointID.AnkleLeft, JointID.FootLeft));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.HipRight, JointID.KneeRight, JointID.AnkleRight, JointID.FootRight));
// Draw joints
//motion = 0;
foreach (Joint joint in data.Joints)
{
Point jointPos = getDisplayPosition(joint);
Line jointLine = new Line();
jointLine.X1 = jointPos.X - 3;
jointLine.X2 = jointLine.X1 + 6;
jointLine.Y1 = jointLine.Y2 = jointPos.Y;
jointLine.Stroke = jointColors[joint.ID];
jointLine.StrokeThickness = 6;
skeleton.Children.Add(jointLine);
// TEAM 16_2011
// POPULATE DATA
// Here populate programming variables with the data processed
if (joint.ID == JointID.WristRight)
{
r_wrist.x = joint.Position.X;
r_wrist.y = joint.Position.Y;
r_wrist.z = joint.Position.Z;
}
if (joint.ID == JointID.ElbowRight)
{
r_elbow.x = joint.Position.X;
r_elbow.y = joint.Position.Y;
r_elbow.z = joint.Position.Z;
}
if (joint.ID == JointID.ShoulderRight)
{
r_shldr.x = joint.Position.X;
r_shldr.y = joint.Position.Y;
r_shldr.z = joint.Position.Z;
}
if (joint.ID == JointID.HandRight)
{
r_hand.x = joint.Position.X;
r_hand.y = joint.Position.Y;
r_hand.z = joint.Position.Z;
}
if (joint.ID == JointID.ShoulderLeft)
{
l_shldr.x = joint.Position.X;
l_shldr.y = joint.Position.Y;
l_shldr.z = joint.Position.Z;
}
if (joint.ID == JointID.WristLeft)
{
l_wrist.x = joint.Position.X;
l_wrist.y = joint.Position.Y;
l_wrist.z = joint.Position.Z;
}
if (joint.ID == JointID.ElbowLeft)
{
l_elbow.x = joint.Position.X;
l_elbow.y = joint.Position.Y;
l_elbow.z = joint.Position.Z;
}
if (joint.ID == JointID.HandLeft)
{
l_hand.x = joint.Position.X;
l_hand.y = joint.Position.Y;
l_hand.z = joint.Position.Z;
}
if (joint.ID == JointID.ShoulderCenter)
{
shldr_center.x = joint.Position.X;
shldr_center.y = joint.Position.Y;
shldr_center.z = joint.Position.Z;
}
if (joint.ID == JointID.HipCenter)
{
hip_center.x = joint.Position.X;
hip_center.y = joint.Position.Y;
hip_center.z = joint.Position.Z;
}
}
}
iSkeleton++;
} // for each skeleton
}
void _sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
this.Dispatcher.Invoke(new Action(delegate()
{
_skeletonRenderer = new SkeletonRenderer(skeletonImage, e, _sensor);
}));
#region WalkingInPlace Update
Skeleton [] wipSkeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(wipSkeletons);
if (wipSkeletons.Length != 0)
{
Skeleton wipUser = null;
float AbsoluteDistance = 50000f;
foreach (Skeleton wipSkel in wipSkeletons)
{
if (wipSkel.TrackingState == SkeletonTrackingState.Tracked)
{
float skelDistance = wipSkel.Joints[JointType.HipCenter].Position.Z;
if (skelDistance < AbsoluteDistance)
{
AbsoluteDistance = skelDistance;
wipUser = wipSkel;
}
}
}
if (wipUser != null)
{
float head = wipUser.Joints[JointType.Head].Position.Y;
float rightHand = wipUser.Joints[JointType.HandRight].Position.Y;
float leftHand = wipUser.Joints[JointType.HandLeft].Position.Y;
Joint leftHip = wipUser.Joints[JointType.HipLeft];
Joint rightHip = wipUser.Joints[JointType.HipRight];
float leftHipAngle = (float)Math.Atan(leftHip.Position.X / leftHip.Position.Z);
float rightHipAngle = (float)Math.Atan(rightHip.Position.X / rightHip.Position.Z);
float newAngle = (leftHipAngle + rightHipAngle) / 2;
if (WipActiveState == 0 && leftHand > head && rightHand > head)
{
WipActiveState = 1;
WipActive = !WipActive;
_wip.setUserHeight((float)userHeight(wipUser));
}
if (WipActiveState == 1 && leftHand < head && rightHand < head)
{
WipActiveState = 0;
}
if (_lastUserID > 0)
{
if (_lastUserID != wipUser.TrackingId)
{
WipActiveState = 0;
WipActive = false;
}
}
_lastUserID = wipUser.TrackingId;
float footLeft = wipUser.Joints[JointType.FootLeft].Position.Y;
float footRight = wipUser.Joints[JointType.FootRight].Position.Y;
float ankleLeft = wipUser.Joints[JointType.AnkleLeft].Position.Y;
float ankleRight = wipUser.Joints[JointType.AnkleRight].Position.Y;
float kneeLeft = wipUser.Joints[JointType.KneeLeft].Position.Y;
float kneeRight = wipUser.Joints[JointType.KneeRight].Position.Y;
Vector4 hipCenterOrientationQuaternionAbsolute = wipUser.BoneOrientations[JointType.HipCenter].AbsoluteRotation.Quaternion;
Vector4 hipCenterOrientationQuaternionHierarchical = wipUser.BoneOrientations[JointType.HipCenter].HierarchicalRotation.Quaternion;
float[] hipCenterOrientationEulerAbsolute = QuaternionToEuler.toEuler(hipCenterOrientationQuaternionAbsolute);
float[] hipCenterOrientationEulerHierarchical = QuaternionToEuler.toEuler(hipCenterOrientationQuaternionHierarchical);
Vector4 spineCenterOrientationQuaternionAbsolute = wipUser.BoneOrientations[JointType.Spine].AbsoluteRotation.Quaternion;
Vector4 spineCenterOrientationQuaternionHierarchical = wipUser.BoneOrientations[JointType.Spine].HierarchicalRotation.Quaternion;
float[] spineCenterOrientationEulerAbsolute = QuaternionToEuler.toEuler(spineCenterOrientationQuaternionAbsolute);
float[] spineCenterOrientationEulerHierarchical = QuaternionToEuler.toEuler(spineCenterOrientationQuaternionHierarchical);
Vector4 shoulderCenterOrientationQuaternionAbsolute = wipUser.BoneOrientations[JointType.ShoulderCenter].AbsoluteRotation.Quaternion;
Vector4 shoulderCenterOrientationQuaternionHierarchical = wipUser.BoneOrientations[JointType.ShoulderCenter].HierarchicalRotation.Quaternion;
float[] shoulderCenterOrientationEulerAbsolute = QuaternionToEuler.toEuler(shoulderCenterOrientationQuaternionAbsolute);
float[] shoulderCenterOrientationEulerHierarchical = QuaternionToEuler.toEuler(shoulderCenterOrientationQuaternionHierarchical);
float rightDiff = 0f;
float leftDiff = 0f;
if (kneeLeft > kneeRight)
{
leftDiff = kneeLeft - kneeRight;
}
else
{
rightDiff = kneeRight - kneeLeft;
}
float _userHeight = (float)userHeight(wipUser);
_wip.update(rightDiff, leftDiff, hipCenterOrientationEulerAbsolute[1]);
dashboardLeftFootHeight.Text = "" + Math.Round(leftDiff, 3);
dashboardRightFootHeight.Text = "" + Math.Round(rightDiff, 3);
}
}
#endregion
}
}
}
public override void OnSkeletonFrameReady(
object sender, SkeletonFrameReadyEventArgs e
)
{
if (!Finished)
{
using (SkeletonFrame s = e.OpenSkeletonFrame())
{
if (s != null)
{
Skeleton[] skels = new Skeleton[s.SkeletonArrayLength];
s.CopySkeletonDataTo(skels);
foreach (Skeleton data in skels)
{
if (
data.TrackingState == SkeletonTrackingState.Tracked
)
{
Point3d leftHip =
PointFromVector(
data.Joints[JointType.HipLeft].Position, false
);
Point3d leftHand =
PointFromVector(
data.Joints[JointType.HandLeft].Position, false
);
Point3d rightHand =
PointFromVector(
data.Joints[JointType.HandRight].Position, false
);
if (leftHand.Z < leftHip.Z && rightHand.Z < leftHip.Z)
{
if (switchm == 0)
{
switchm = 1;
}
else if (switchm == 1)
{
switchm = 0;
}
}
if (
leftHand.DistanceTo(Point3d.Origin) > 0 &&
rightHand.DistanceTo(Point3d.Origin) > 0 &&
leftHand.DistanceTo(rightHand) < 0.03)
{
// Hands are less than 3cm from each other
_drawing = false;
_resizing = false;
Finished = true;
}
else
{
// Hands are within 10cm of each other vertically
// and both hands are above the waist, so we resize
// the profile radius
_resizing =
(leftHand.Z > leftHip.Z &&
rightHand.Z > leftHip.Z &&
Math.Abs(leftHand.Z - rightHand.Z) < 0.5);
// If the left hand is below the waist, we draw
_drawing = (leftHand.Z < leftHip.Z);
}
if (_resizing)
{
// If resizing, set some data to help draw
// a sphere where we're resizing
Vector3d vec = (leftHand - rightHand) / 2;
_resizeLocation = rightHand + vec;
_profSide = vec.Length / (Math.Sqrt(3));
}
if (_drawing)
{
// If we have at least one prior vertex...
if (_vertices.Count > 0)
{
// ... check whether we're a certain distance
// away from the last one before adding it (this
// smooths off the jitters of adding every point)
Point3d lastVert =
_vertices[_vertices.Count - 1];
if (
lastVert.DistanceTo(rightHand) > _profSide * 4
)
{
// Add the new vertex to our list
_vertices.Add(rightHand);
}
}
else
{
// Add the first vertex to our list
_vertices.Add(rightHand);
}
}
break;
}
}
}
}
}
}
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (var skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame == null)
{
return;
}
if (skeletons == null ||
skeletons.Length != skeletonFrame.SkeletonArrayLength)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
}
// decide to identify only one skeleton at a time, choose the closest
skeletonFrame.CopySkeletonDataTo(skeletons);
Skeleton closestSkeleton = skeletons.Where(s => s.TrackingState == SkeletonTrackingState.Tracked)
.OrderBy(s => s.Position.Z * Math.Abs(s.Position.X))
.FirstOrDefault();
if (closestSkeleton == null)
{
return;
}
if (closestSkeleton.Joints[JointType.Spine].Position.Z < minVal)
{
textBox1.Text = ("Skeleton Tracking disabled (too near)");
closestSkeleton.TrackingState = SkeletonTrackingState.NotTracked;
}
else if (closestSkeleton.Joints[JointType.Spine].Position.Z > maxVal)
{
textBox1.Text = ("Skeleton Tracking disabled (too far)");
closestSkeleton.TrackingState = SkeletonTrackingState.NotTracked;
}
// The points that kinect track
var head = closestSkeleton.Joints[JointType.Head];
var rightHand = closestSkeleton.Joints[JointType.HandRight];
var leftHand = closestSkeleton.Joints[JointType.HandLeft];
var centerShoulder = closestSkeleton.Joints[JointType.ShoulderCenter];
var leftShoulder = closestSkeleton.Joints[JointType.ShoulderLeft];
var rightShoulder = closestSkeleton.Joints[JointType.ShoulderRight];
var centerHip = closestSkeleton.Joints[JointType.HipCenter];
if (head.TrackingState == JointTrackingState.NotTracked ||
rightHand.TrackingState == JointTrackingState.NotTracked ||
leftHand.TrackingState == JointTrackingState.NotTracked ||
centerHip.TrackingState == JointTrackingState.NotTracked ||
centerShoulder.TrackingState == JointTrackingState.NotTracked ||
leftShoulder.TrackingState == JointTrackingState.NotTracked ||
rightShoulder.TrackingState == JointTrackingState.NotTracked)
{
//Don't have a good read on the joints so we cannot process gestures
return;
}
//SetEllipsePosition is the method to color canvas element
SetEllipsePosition(ellipseHead, head, false);
SetEllipsePosition(ellipseLeftHand, leftHand, isBackGestureActive);
SetEllipsePosition(ellipseRightHand, rightHand, isForwardGestureActive);
if (isStartGestureActive)
{
SetEllipsePosition(ellipseLeftHand, leftHand, isStartGestureActive);
SetEllipsePosition(ellipseRightHand, rightHand, isStartGestureActive);
}
else if (isExitGestureActive)
{
SetEllipsePosition(ellipseLeftHand, leftHand, isExitGestureActive);
SetEllipsePosition(ellipseRightHand, rightHand, isExitGestureActive);
}
ProcessForwardBackGesture(head, rightHand, leftHand, centerShoulder, rightShoulder, leftShoulder, centerHip);
}
}
/// <summary>
/// Event handler for Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
Skeleton skel = new Skeleton();
if (skeletons.Length != 0)
{
foreach (Skeleton skele in skeletons)
{
if (skele.TrackingState == SkeletonTrackingState.Tracked)
{
skel = skele;
}
}
}
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
int pos = ejercicio.CompruebaMovimiento(skel);
if (pos == 0)
{
//this.Joints(skel);
}
else if (pos == 1)
{
this.borPos1.Background = Brushes.Green;
//Brush color = Brushes.Red;
//this.Joints(skel, color);
}
else if (pos == 2)
{
this.borPos1.Background = Brushes.Purple;
this.borPos2.Background = Brushes.Green;
}
else if (pos == 3)
{
this.borPos2.Background = Brushes.Purple;
this.borPos3.Background = Brushes.Green;
}
else if (pos == 4)
{
this.borPos3.Background = Brushes.Purple;
this.borPos4.Background = Brushes.Green;
}
else if (pos == 5)
{
this.borPos4.Background = Brushes.Purple;
this.borPos5.Background = Brushes.Green;
}
else if (pos == 6)
{
this.borPos5.Background = Brushes.Purple;
this.borPos6.Background = Brushes.Green;
}
else if (pos == 7)
{
this.borPos6.Background = Brushes.Purple;
this.borPos7.Background = Brushes.Green;
}
else if (pos == 8)
{
this.borPos7.Background = Brushes.Purple;
this.borPos8.Background = Brushes.Green;
}
if (pos == 9)
{
this.borPos1.Background = Brushes.Purple;
this.borPos2.Background = Brushes.Purple;
this.borPos3.Background = Brushes.Purple;
this.borPos4.Background = Brushes.Purple;
this.borPos5.Background = Brushes.Purple;
this.borPos6.Background = Brushes.Purple;
this.borPos7.Background = Brushes.Purple;
this.borPos8.Background = Brushes.Purple;
}
else if (pos == -1)
{
this.borPos1.Background = Brushes.Red;
this.borPos2.Background = Brushes.Red;
this.borPos3.Background = Brushes.Red;
this.borPos4.Background = Brushes.Red;
this.borPos5.Background = Brushes.Red;
this.borPos6.Background = Brushes.Red;
this.borPos7.Background = Brushes.Red;
this.borPos8.Background = Brushes.Red;
}
}
}
}
}
void newsensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
if (this.skeletons == null)
{
this.skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
}
skeletonFrame.CopySkeletonDataTo(this.skeletons);
Skeleton skeleton = this.skeletons.Where(s => s.TrackingState == SkeletonTrackingState.Tracked).FirstOrDefault();
/*// saving the images captured
* RenderTargetBitmap bmp = new RenderTargetBitmap(800, 600, 96, 96, PixelFormats.Pbgra32);
* //bmp.Render(window.image);
*
* JpegBitmapEncoder encoder = new JpegBitmapEncoder();
* // create frame from the writable bitmap and add to encoder
*
* encoder.Frames.Add(BitmapFrame.Create(bmp));
* string myPhotos = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
* string path = skeletonFrame.Timestamp + ".jpg";
* using (FileStream fs = new FileStream(path, FileMode.Create))
* {
* encoder.Save(fs);
* if (fs.Length > 1024)
* {
* fs.Close();
*
* }
*
* }*/
/* if (skeleton != null)
* {
* // Calculate height.
* double height = Math.Round(skeleton.Height(), 2);
*
* // Draw skeleton joints.
* foreach (JointType joint in Enum.GetValues(typeof(JointType)))
* {
* DrawJoint(skeleton.Joints[joint].ScaleTo(640, 480));
* }
*
* // Display height.
* tblHeight.Text = "Height: " + height.ToString() + "m";
*
*
*
*/
/*if (skeleton != null)
* {
* // Calculate height.
* // double height = Math.Round(skeleton.Height(), 2);
*
* }*/
/*
*
* if (skeleton != null)
* {
* // DrawingContext drawing;
*
* SetEllipsePosition(HipCenter, skeleton.Joints[JointType.HipCenter]);
*
* //DrawText(new FormattedText("Hipcenter", CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface("Verdana"), 12, System.Windows.Media.Brushes.Black), new System.Windows.Point(200, 116));
*
* SetEllipsePosition(Spine, skeleton.Joints[JointType.Spine]);
*
* SetEllipsePosition(ShoulderCenter, skeleton.Joints[JointType.ShoulderCenter]);
* SetEllipsePosition(Head, skeleton.Joints[JointType.Head]);
* SetEllipsePosition(ShoulderLeft, skeleton.Joints[JointType.ShoulderLeft]);
* SetEllipsePosition(ElbowLeft, skeleton.Joints[JointType.ElbowLeft]);
* SetEllipsePosition(WristLeft, skeleton.Joints[JointType.WristLeft]);
* SetEllipsePosition(HandLeft, skeleton.Joints[JointType.HandLeft]);
* SetEllipsePosition(ShoulderRight, skeleton.Joints[JointType.ShoulderRight]);
* SetEllipsePosition(ElbowRight, skeleton.Joints[JointType.ElbowRight]);
* SetEllipsePosition(WristRight, skeleton.Joints[JointType.WristRight]);
* SetEllipsePosition(HandRight, skeleton.Joints[JointType.HandRight]);
* SetEllipsePosition(HipLeft, skeleton.Joints[JointType.HipLeft]);
* SetEllipsePosition(KneeLeft, skeleton.Joints[JointType.KneeLeft]);
* SetEllipsePosition(AnkleLeft, skeleton.Joints[JointType.AnkleLeft]);
* SetEllipsePosition(FootLeft, skeleton.Joints[JointType.FootLeft]);
* SetEllipsePosition(HipRight, skeleton.Joints[JointType.HipRight]);
* SetEllipsePosition(KneeRight, skeleton.Joints[JointType.KneeRight]);
* SetEllipsePosition(AnkleRight, skeleton.Joints[JointType.AnkleRight]);
* SetEllipsePosition(FootRight, skeleton.Joints[JointType.FootRight]);
*
*
* }
*/
if (skeleton != null)
{
Joint hipcenter = skeleton.Joints[JointType.HipCenter];
Joint hipright = skeleton.Joints[JointType.HipRight];
Joint kneeright = skeleton.Joints[JointType.KneeRight];
Joint ankleright = skeleton.Joints[JointType.AnkleRight];
Joint footright = skeleton.Joints[JointType.FootRight];
Joint hipleft = skeleton.Joints[JointType.HipLeft];
Joint kneeleft = skeleton.Joints[JointType.KneeLeft];
Joint ankleleft = skeleton.Joints[JointType.AnkleLeft];
Joint footleft = skeleton.Joints[JointType.FootLeft];
Time = DateTime.Now;
//Joint j2 = skeleton.Joints[JointType.KneeLeft];
//writer.Writeline("X Y z");
/*
*
* if (hipcenter.TrackingState == JointTrackingState.Tracked )//|| hipcenter.TrackingState== JointTrackingState.Inferred || hipcenter.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("hipcenter:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
* else
*
*
* writer.Write("hipcenter:\t NA \t NA \t NA \t");
*
* if (hipright.TrackingState == JointTrackingState.Tracked)// || hipright.TrackingState == JointTrackingState.Inferred || hipright.TrackingState==JointTrackingState.NotTracked)
*
* writer.Write("hipright:\t " + hipright.Position.X + "\t" + hipright.Position.Y + "\t" + hipright.Position.Z + "\t");
* else
*
* writer.Write("hipright:\t NA \t NA \t NA \t");
*
*
* if (kneeright.TrackingState == JointTrackingState.Tracked )//|| kneeright.TrackingState==JointTrackingState.Inferred || kneeright.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("kneeright:\t " + kneeright.Position.X + "\t" + kneeright.Position.Y + "\t" + kneeright.Position.Z + "\t");
* else
*
* writer.Write("kneeright:\t NA \t NA \t NA \t");
*
*
* if (ankleright.TrackingState == JointTrackingState.Tracked )//|| ankleright.TrackingState==JointTrackingState.Inferred || ankleright.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("ankleright:\t " + ankleright.Position.X + "\t" + ankleleft.Position.Y + "\t" + ankleright.Position.Z + "\t");
* else
*
* writer.Write("ankleright:\t NA \t NA \t NA \t");
*
*
* if (footright.TrackingState == JointTrackingState.Tracked )//|| footright.TrackingState == JointTrackingState.Inferred || footright.TrackingState ==JointTrackingState.NotTracked)
*
* writer.Write("footright:\t " + footright.Position.X + "\t" + footright.Position.Y + "\t" + footright.Position.Z + "\t");
* else
*
* writer.Write("footright:\t NA \t NA \t NA \t");
*
*
*
* if (hipleft.TrackingState == JointTrackingState.Tracked )//|| hipleft.TrackingState == JointTrackingState.Inferred || hipright.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("hip left:\t " + hipleft.Position.X + "\t" + hipleft.Position.Y + "\t" + hipleft.Position.Z + "\t");
* else
*
* writer.Write("hipleft:\t NA \t NA \t NA \t");
*
*
* if (kneeleft.TrackingState == JointTrackingState.Tracked )//|| kneeleft.TrackingState==JointTrackingState.Inferred || kneeleft.TrackingState== JointTrackingState.NotTracked )
*
* writer.Write("knee left:\t " + kneeleft.Position.X + "\t" + kneeleft.Position.Y + "\t" + kneeleft.Position.Z + "\t");
* else
*
* writer.Write("kneeleft:\t NA \t NA \t NA \t ");
*
* if (ankleleft.TrackingState == JointTrackingState.Tracked )//|| ankleleft.TrackingState == JointTrackingState.Inferred || ankleleft.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("ankleleft:\t " + ankleleft.Position.X + "\t" + ankleleft.Position.Y + "\t" + ankleleft.Position.Z + "\t");
* else
*
* writer.Write("ankleleft:\t NA \t NA \t NA \t ");
*
*
* if (footleft.TrackingState == JointTrackingState.Tracked)// || footleft.TrackingState == JointTrackingState.Inferred || footleft.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("footleft:\t " + footleft.Position.X + "\t" + footleft.Position.Y + "\t" + footleft.Position.Z + "\t");
* else
*
* writer.Write("footleft:\t NA \t NA \t NA \t ");
*
*
* writer.WriteLine("TIME:\t" + DateTime.Now + "\t"); */
if (hipcenter.TrackingState == JointTrackingState.Tracked)
{
writer.Write("hipcenter:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
}
else
if (hipcenter.TrackingState == JointTrackingState.Inferred)
{
writer.Write("hipcenter/INF/:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
}
else
if (hipcenter.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("hipcenter/[NT/]:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
}
else
{
writer.Write("hipcenter/[" + hipcenter.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (hipright.TrackingState == JointTrackingState.Tracked)
{
writer.Write("hipright:\t " + hipright.Position.X + "\t" + hipright.Position.Y + "\t" + hipright.Position.Z + "\t ");
}
else
if (hipright.TrackingState == JointTrackingState.Inferred)
{
writer.Write("hipright/INF/:\t " + hipright.Position.X + "\t" + hipright.Position.Y + "\t" + hipright.Position.Z + "\t ");
}
else
if (hipright.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("hipright/NT/:\t " + hipright.Position.X + "\t" + hipright.Position.Y + "\t" + hipright.Position.Z + "\t ");
}
else
{
writer.Write("hipright/[" + hipright.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (kneeright.TrackingState == JointTrackingState.Tracked)
{
writer.Write("kneeright:\t " + kneeright.Position.X + "\t" + kneeright.Position.Y + "\t" + kneeright.Position.Z + "\t ");
}
else
if (kneeright.TrackingState == JointTrackingState.Inferred)
{
writer.Write("kneeright/INF/:\t " + kneeright.Position.X + "\t" + kneeright.Position.Y + "\t" + kneeright.Position.Z + "\t ");
}
else
if (kneeright.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("kneeright/NT/:\t " + kneeright.Position.X + "\t" + kneeright.Position.Y + "\t" + kneeright.Position.Z + "\t ");
}
else
{
writer.Write("kneeright/[" + kneeright.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (ankleright.TrackingState == JointTrackingState.Tracked)
{
writer.Write("ankleright:\t " + ankleright.Position.X + "\t" + ankleright.Position.Y + "\t" + ankleright.Position.Z + "\t ");
}
else
if (ankleright.TrackingState == JointTrackingState.Inferred)
{
writer.Write("ankleright/INF/:\t " + ankleright.Position.X + "\t" + ankleright.Position.Y + "\t" + ankleright.Position.Z + "\t ");
}
else
if (ankleright.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("ankleright/NT/:\t " + ankleright.Position.X + "\t" + ankleright.Position.Y + "\t" + ankleright.Position.Z + "\t ");
}
else
{
writer.Write("ankleright/[" + ankleright.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (footright.TrackingState == JointTrackingState.Tracked)
{
writer.Write("footright:\t " + footright.Position.X + "\t" + footright.Position.Y + "\t" + footright.Position.Z + "\t ");
}
else
if (footright.TrackingState == JointTrackingState.Inferred)
{
writer.Write("footright/INF/:\t " + footright.Position.X + "\t" + footright.Position.Y + "\t" + footright.Position.Z + "\t ");
}
else
if (footright.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("footright/NT/:\t " + footright.Position.X + "\t" + footright.Position.Y + "\t" + footright.Position.Z + "\t ");
}
else
{
writer.Write("footright/[" + footright.TrackingState + "/]:\t NA \t NA \t NA ");
}
/****************************************************************************************************/
// for left side
if (hipcenter.TrackingState == JointTrackingState.Tracked)
{
writer.Write("hipcenter:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
}
else
if (hipcenter.TrackingState == JointTrackingState.Inferred)
{
writer.Write("hipcenter/INF/:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
}
else
if (hipcenter.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("hipcenter/[NT/]:\t " + hipcenter.Position.X + "\t" + hipcenter.Position.Y + "\t" + hipcenter.Position.Z + "\t ");
}
else
{
writer.Write("hipcenter/[" + hipcenter.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (hipleft.TrackingState == JointTrackingState.Tracked)
{
writer.Write("hipleft:\t " + hipleft.Position.X + "\t" + hipleft.Position.Y + "\t" + hipleft.Position.Z + "\t ");
}
else
if (hipleft.TrackingState == JointTrackingState.Inferred)
{
writer.Write("hipleft/INF/:\t " + hipleft.Position.X + "\t" + hipleft.Position.Y + "\t" + hipleft.Position.Z + "\t ");
}
else
if (hipleft.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("hipleft/NT/:\t " + hipleft.Position.X + "\t" + hipleft.Position.Y + "\t" + hipleft.Position.Z + "\t ");
}
else
{
writer.Write("hipleft/[" + hipleft.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (kneeleft.TrackingState == JointTrackingState.Tracked)
{
writer.Write("kneeleft:\t " + kneeleft.Position.X + "\t" + kneeleft.Position.Y + "\t" + kneeleft.Position.Z + "\t ");
}
else
if (kneeleft.TrackingState == JointTrackingState.Inferred)
{
writer.Write("kneeleft/INF/:\t " + kneeleft.Position.X + "\t" + kneeleft.Position.Y + "\t" + kneeleft.Position.Z + "\t ");
}
else
if (kneeleft.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("kneeleft/NT/:\t " + kneeleft.Position.X + "\t" + kneeleft.Position.Y + "\t" + kneeleft.Position.Z + "\t ");
}
else
{
writer.Write("kneeleft/[" + kneeleft.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (ankleleft.TrackingState == JointTrackingState.Tracked)
{
writer.Write("ankleleft:\t " + ankleleft.Position.X + "\t" + ankleleft.Position.Y + "\t" + ankleleft.Position.Z + "\t ");
}
else
if (ankleleft.TrackingState == JointTrackingState.Inferred)
{
writer.Write("ankleleft/INF/:\t " + ankleleft.Position.X + "\t" + ankleleft.Position.Y + "\t" + ankleleft.Position.Z + "\t ");
}
else
if (ankleleft.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("ankleleft/NT/:\t " + ankleleft.Position.X + "\t" + ankleleft.Position.Y + "\t" + ankleleft.Position.Z + "\t ");
}
else
{
writer.Write("ankleleft/[" + ankleleft.TrackingState + "/]:\t NA \t NA \t NA ");
}
if (footleft.TrackingState == JointTrackingState.Tracked)
{
writer.Write("footleft:\t " + footleft.Position.X + "\t" + footleft.Position.Y + "\t" + footleft.Position.Z + "\t ");
}
else
if (footleft.TrackingState == JointTrackingState.Inferred)
{
writer.Write("footleft/INF/:\t " + footleft.Position.X + "\t" + footleft.Position.Y + "\t" + footleft.Position.Z + "\t ");
}
else
if (footleft.TrackingState == JointTrackingState.NotTracked)
{
writer.Write("footleft/NT/:\t " + footleft.Position.X + "\t" + footleft.Position.Y + "\t" + footleft.Position.Z + "\t ");
}
else
{
writer.Write("footleft/[" + footleft.TrackingState + "/]:\t NA \t NA \t NA ");
}
/*
*
* if (hipleft.TrackingState == JointTrackingState.Tracked || hipleft.TrackingState == JointTrackingState.Inferred || hipleft.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("hip left:\t " + hipleft.Position.X + "\t" + hipleft.Position.Y + "\t" + hipleft.Position.Z + "\t");
* else
*
* writer.Write("hipleft:\t NA \t NA \t NA ");
*
*
* if (kneeleft.TrackingState == JointTrackingState.Tracked || kneeleft.TrackingState == JointTrackingState.Inferred || kneeleft.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("knee left:\t " + kneeleft.Position.X + "\t" + kneeleft.Position.Y + "\t" + kneeleft.Position.Z + "\t");
* else
*
* writer.Write("kneeleft:\t NA \t NA \t NA ");
*
* if (ankleleft.TrackingState == JointTrackingState.Tracked || ankleleft.TrackingState == JointTrackingState.Inferred || ankleleft.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("ankleleft:\t " + ankleleft.Position.X + "\t" + ankleleft.Position.Y + "\t" + ankleleft.Position.Z + "\t");
* else
*
* writer.Write("ankleleft:\t NA \t NA \t NA ");
*
*
* if (footleft.TrackingState == JointTrackingState.Tracked || footleft.TrackingState == JointTrackingState.Inferred || footleft.TrackingState == JointTrackingState.NotTracked)
*
* writer.Write("footleft:\t " + footleft.Position.X + "\t" + footleft.Position.Y + "\t" + footleft.Position.Z + "\t");
* else
*
* writer.Write("footleft:\t NA \t NA \t NA ");*/
writer.WriteLine("TIME:\t" + DateTime.Now + "\t");
/*
* if (hipcenter.TrackingState == JointTrackingState.Tracked
* && hipright.TrackingState == JointTrackingState.Tracked
* && kneeright.TrackingState == JointTrackingState.Tracked
* && ankleright.TrackingState == JointTrackingState.Tracked
* && footright.TrackingState == JointTrackingState.Tracked
* && hipleft.TrackingState == JointTrackingState.Tracked
* && kneeleft.TrackingState == JointTrackingState.Tracked
* && ankleleft.TrackingState == JointTrackingState.Tracked
* && footleft.TrackingState == JointTrackingState.Tracked)*/
/*{
*
*
* //StreamWriter writer = new StreamWriter("myfile.txt", false);
*
*
* //writer.Write();
*
* //Console.WriteLine("The output of X Y Z coordinates");
*
*
*
* writer.WriteLine("hipcenter: " + hipcenter.Position.X + "," + hipcenter.Position.Y + "," + hipcenter.Position.Z + "\t"
+ "hipright: " + hipright.Position.X + "," + hipright.Position.Y + "," + hipright.Position.Z + "\t"
+ "kneeright: " + kneeright.Position.X + "," + kneeright.Position.Y + "," + kneeright.Position.Z +"\t"
+ "ankleright: " + ankleright.Position.X + "," + ankleright.Position.Y + "," + ankleright.Position.Z +"\t"
+ "footright: " + footright.Position.X + "," + footright.Position.Y + "," + footright.Position.Z + "\t"
+"hipleft: " + hipleft.Position.X + "," + hipleft.Position.Y + "," + hipleft.Position.Z +"\t"
+ "kneeleftleft: " + kneeleft.Position.X + "," + kneeleft.Position.Y + "," + kneeleft.Position.Z + "\t"
+ "ankleleft: " + ankleleft.Position.X + "," + ankleleft.Position.Y + "," + ankleleft.Position.Z +"\t"
+ "footleft: " + footleft.Position.X + "," + footleft.Position.Y + "," + footleft.Position.Z +"\t"
+"TIME" + DateTime.Now);
+ //writer.WriteLine(DateTime.Now);
+
+
+
+ //StreamWriter writer = new StreamWriter("myfile.txt");
+ // FileStream fs = new FileStream("myfile.txt", FileMode.Create);
+ // First, save the standard output.
+ //TextWriter tmp = Console.Out;
+ //StreamWriter sw = new StreamWriter(fs);
+
+
+ //writer.Close();
+ }*/
//writer.Close();
}
/* if (skeleton != null)
* {
* Joint j = skeleton.Joints[JointType.KneeLeft];
*
* if (j.TrackingState == JointTrackingState.Tracked)
* {
* Console.WriteLine("The output of X Y Z coordinates");
*
* Console.WriteLine("Head: X AXIS" + j.Position.X + ",Y AXIS \t " + j.Position.Y + ",Z AXIS\t " + j.Position.Z);
* }
* }*/
}
}
}
/// <summary>
/// Event handler for Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
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, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
if (skel.Joints[JointType.HandRight].TrackingState == JointTrackingState.Tracked)
{
jpr = skel.Joints[JointType.HandRight]; //右手
}
if (skel.Joints[JointType.WristRight].TrackingState == JointTrackingState.Tracked)
{
jprw = skel.Joints[JointType.WristRight];//右腕关节
}
if (skel.Joints[JointType.ElbowRight].TrackingState == JointTrackingState.Tracked)
{
jpre = skel.Joints[JointType.ElbowRight];//右肘关节
}
if (skel.Joints[JointType.ShoulderRight].TrackingState == JointTrackingState.Tracked)
{
jprs = skel.Joints[JointType.ShoulderRight];//右肩关节
}
if (skel.Joints[JointType.ShoulderCenter].TrackingState == JointTrackingState.Tracked)
{
jpsc = skel.Joints[JointType.ShoulderCenter];//两肩中心
}
if (skel.Joints[JointType.ShoulderLeft].TrackingState == JointTrackingState.Tracked)
{
jpls = skel.Joints[JointType.ShoulderLeft];//左肩关节
}
if (skel.Joints[JointType.ElbowLeft].TrackingState == JointTrackingState.Tracked)
{
jple = skel.Joints[JointType.ElbowLeft];//左肩关节
}
if (skel.Joints[JointType.Spine].TrackingState == JointTrackingState.Tracked)
{
jpspine = skel.Joints[JointType.Spine];//脊柱关节
}
if (skel.Joints[JointType.Head].TrackingState == JointTrackingState.Tracked)
{
head = skel.Joints[JointType.Head];//头
}
if (skel.Joints[JointType.WristLeft].TrackingState == JointTrackingState.Tracked)
{
jplw = skel.Joints[JointType.WristLeft];//头
}
rightWristAngle = CalculateWristAngleForWrist(jpr, jprw, jpre);
rightElbowAngle = CalculateAngleForElbow(jprw, jpre, jprs);
leftElbowAngle = CalculateAngleForElbow(jplw, jple, jpls);
rightshouderAngle = CalculateAngleForShouder(jpre, jprs, jpsc, jpspine);
waistturnAngle = CalculateAngleForShouder(jpre, jprs, jpls);
leftshouderAngle = CalculateAngleForShouder(jple, jpls, jpsc, jpspine);
rightheaddir = CalculateAngleForShouder(head, jpsc, jprs);
label7.Content = rightheaddir;
if (switchMode) //swith mode || rightheaddir < 50
{
//rightWristAngle = AmplitudeLimiterFilter(rightWristAngle, rightWristAngle2);
//rightElbowAngle = AmplitudeLimiterFilter(rightElbowAngle, rightElbowAngle2);
//rightshouderAngle = AmplitudeLimiterFilter(rightshouderAngle, rightshouderAngle2);
//waistturnAngle = AmplitudeLimiterFilter(waistturnAngle, waistturnAngle2);
//leftshouderAngle = AmplitudeLimiterFilter(leftshouderAngle, leftshouderAngle2);
//long endTime2 = DateTime.Now.Ticks;
//while (DateTime.Now.Ticks - endTime2 < 2000) ;
endTime = DateTime.Now.Ticks;
if (endTime - beginTime > 2000) //delay 2s
{
if (temp == 0) //value last time
{
rightWristAngle2 = rightWristAngle;
leftElbowAngle2 = leftElbowAngle;
rightElbowAngle2 = rightElbowAngle;
rightshouderAngle2 = rightshouderAngle;
waistturnAngle2 = waistturnAngle;
leftshouderAngle2 = leftshouderAngle;
rightheaddir2 = rightheaddir;
temp++;
}
else
{
rightWristAngle = (float)(rightWristAngle * 0.7 + rightWristAngle2 * 0.3);
rightElbowAngle = (float)(rightElbowAngle * 0.7 + rightElbowAngle2 * 0.3);
leftElbowAngle = (float)(leftElbowAngle * 0.7 + leftElbowAngle2 * 0.3);
rightshouderAngle = (float)(rightshouderAngle * 0.7 + rightshouderAngle2 * 0.3);
waistturnAngle = (float)(waistturnAngle * 0.7 + waistturnAngle2 * 0.3);
leftshouderAngle = (float)(leftshouderAngle * 0.7 + leftshouderAngle2 * 0.3);
rightheaddir = (float)(rightheaddir * 0.7 + rightheaddir2 * 0.3);
//rightWristAngle = (rightWristAngle + rightWristAngle2) / 2;
//rightElbowAngle = (rightElbowAngle + rightElbowAngle2) / 2;
//rightshouderAngle = (rightshouderAngle + rightshouderAngle2) / 2;
//waistturnAngle = (waistturnAngle + waistturnAngle2) / 2;
//leftshouderAngle = (leftshouderAngle + leftshouderAngle2) / 2;
textBox1.Text = Convert.ToString(leftshouderAngle);//rightWristAngle replaced by left arm
textBox2.Text = Convert.ToString(rightElbowAngle);
textBox3.Text = Convert.ToString(leftElbowAngle);
textBox5.Text = Convert.ToString(rightshouderAngle);
//textBox3.Text = Convert.ToString(leftshouderAngle);
try
{
scrollBar1.Value = leftshouderAngle;//rightWristAngle replaced by left arm
byte[] data1 = { 0xFF, 0X01, 0X01, Convert.ToByte(scrollBar1.Value), 0XFF };
//stream.Write(data1, 0, data1.Length);
if (leftElbowAngle > 60 && leftElbowAngle < 120)
{
scrollBar3.Value = 150;
byte[] data3 = { 0xFF, 0X01, 0X03, Convert.ToByte(scrollBar3.Value), 0XFF };
//stream.Write(data3, 0, data3.Length);
}
else
{
scrollBar3.Value = 30;
byte[] data3 = { 0xFF, 0X01, 0X03, Convert.ToByte(scrollBar3.Value), 0XFF };
//stream.Write(data3, 0, data3.Length);
}
//scrollBar3.Value = leftElbowAngle;
//byte[] data3 = { 0xFF, 0X01, 0X03, Convert.ToByte(scrollBar3.Value), 0XFF };
//stream.Write(data3, 0, data3.Length);
scrollBar2.Value = rightElbowAngle;
byte[] data2 = { 0xFF, 0X01, 0X02, Convert.ToByte(scrollBar2.Value), 0XFF };
//stream.Write(data2, 0, data2.Length);
scrollBar5.Value = rightshouderAngle;
byte[] data5 = { 0xFF, 0X01, 0X05, Convert.ToByte(scrollBar5.Value), 0XFF };
//stream.Write(data5, 0, data5.Length);
scrollBar6.Value = waistturnAngle;
byte[] data6 = { 0xFF, 0X01, 0X06, Convert.ToByte(scrollBar6.Value), 0XFF };
//stream.Write(data6, 0, data6.Length);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
rightWristAngle2 = rightWristAngle;
rightElbowAngle2 = rightElbowAngle;
leftElbowAngle2 = leftElbowAngle;
rightshouderAngle2 = rightshouderAngle;
waistturnAngle2 = waistturnAngle;
leftshouderAngle2 = leftshouderAngle;
rightheaddir2 = rightheaddir;
}
beginTime = endTime;
}
}
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
void runtime_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame skeletonSet = e.SkeletonFrame;
SkeletonData data = (from s in skeletonSet.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
vlcHipCentre.Visibility = data.TrackingState == SkeletonTrackingState.NotTracked ?
System.Windows.Visibility.Hidden : System.Windows.Visibility.Visible;
var head = data.Joints[JointID.Head];
var rightHand = data.Joints[JointID.HandRight];
var leftHand = data.Joints[JointID.HandLeft];
var shoulderCentre = data.Joints[JointID.ShoulderCenter];
var hipcentre = data.Joints[JointID.HipCenter];
SetEllipsePosition(ellipseHead, head, isBowGesture);
SetEllipsePosition(ellipseShoulderCentre, shoulderCentre, false);
ShowVLCHipCentre(vlcHipCentre, hipcentre);
SetEllipsePosition(ellipseLeftHand, leftHand, isForwardGestureActive || isBackGestureActive || isBackUpGestureActive);
SetEllipsePosition(ellipseRightHand, rightHand, isBackGestureActive || isForwardGestureActive || isForwardUpGestureActive);
ProcessGestures(head,shoulderCentre, hipcentre, rightHand, leftHand);
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
ticksToNextEventAllowed--;
SkeletonFrame skeletonFrame = e.SkeletonFrame;
int iSkeleton = 0;
Brush[] brushes = new Brush[6];
brushes[0] = new SolidColorBrush(Color.FromRgb(255, 0, 0));
brushes[1] = new SolidColorBrush(Color.FromRgb(0, 255, 0));
brushes[2] = new SolidColorBrush(Color.FromRgb(64, 255, 255));
brushes[3] = new SolidColorBrush(Color.FromRgb(255, 255, 64));
brushes[4] = new SolidColorBrush(Color.FromRgb(255, 64, 255));
brushes[5] = new SolidColorBrush(Color.FromRgb(128, 128, 255));
skeleton.Children.Clear();
foreach (SkeletonData data in skeletonFrame.Skeletons)
{
if (SkeletonTrackingState.Tracked == data.TrackingState)
{
// Draw bones
Brush brush = brushes[iSkeleton % brushes.Length];
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.Spine, JointID.ShoulderCenter, JointID.Head));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.ShoulderCenter, JointID.ShoulderLeft, JointID.ElbowLeft, JointID.WristLeft, JointID.HandLeft));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.ShoulderCenter, JointID.ShoulderRight, JointID.ElbowRight, JointID.WristRight, JointID.HandRight));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.HipLeft, JointID.KneeLeft, JointID.AnkleLeft, JointID.FootLeft));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.HipRight, JointID.KneeRight, JointID.AnkleRight, JointID.FootRight));
if (ticksToNextEventAllowed <= 0)
{
if (
data.Joints[JointID.HandLeft].Position.X < -0.6
&& data.Joints[JointID.HandRight].Position.X < -0.6
)
{
this.SendKeysOnce("Welcome to my new tech meeting format!\n");
}
else if (data.Joints[JointID.HandLeft].Position.X > 0.6
&& data.Joints[JointID.HandRight].Position.X > 0.6
)
{
this.SendKeysOnce("U MAD, bros?\n");
}
else if (
data.Joints[JointID.HandLeft].Position.X < -0.5
&&
data.Joints[JointID.HandRight].Position.X > 0.5
/*(data.Joints[JointID.HandLeft].Position.X - data.Joints[JointID.HandRight].Position.X < 0.2)
&&
(data.Joints[JointID.HandLeft].Position.Y < data.Joints[JointID.HandRight].Position.Y)
&&
(data.Joints[JointID.HandLeft].Position.X > -0.25 && data.Joints[JointID.HandLeft].Position.X < 0.25) // in the center section
* */
)
{
this.SendKeysOnce("COME AT ME, BROS!");
}
}
// Draw joints
foreach (Joint joint in data.Joints)
{
Point jointPos = getDisplayPosition(joint);
Line jointLine = new Line();
jointLine.X1 = jointPos.X - 3;
jointLine.X2 = jointLine.X1 + 6;
jointLine.Y1 = jointLine.Y2 = jointPos.Y;
jointLine.Stroke = jointColors[joint.ID];
jointLine.StrokeThickness = 6;
skeleton.Children.Add(jointLine);
}
}
iSkeleton++;
} // for each skeleton
}
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame == null)
{
return;
}
inputmethod = W.inputmethod;
skeletonFrame.CopySkeletonDataTo(allSkeletons);
//get the first tracked skeleton
Skeleton first = (from s in allSkeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
// skeleton data may not be available
if (first == null)
{
return;
}
// display skeleton on window
displaySkeleton(first);
// Selecting the input method
switch (inputmethod)
{
case 0: // input version 1
Angles angles1 = new Angles(first);
AxisAngles = angles1.getFinalAngles();
break;
case 2: // input version 2
HandPosition angles2 = new HandPosition(first);
AxisAngles = angles2.getFinalAngles();
break;
case 1: // input version 3
HandPositionLower angles3 = new HandPositionLower(first);
AxisAngles = angles3.getFinalAngles();
break;
default:
MessageBox.Show("Error !!!");
break;
}
AxisAngles = medians.getNextMedian(AxisAngles);
// Displaying on GUI
W.axis1.Content = AxisAngles[1].ToString();
W.axis2.Content = AxisAngles[2].ToString();
W.axis3.Content = AxisAngles[3].ToString();
W.axis4.Content = AxisAngles[4].ToString();
W.axis5.Content = AxisAngles[5].ToString();
W.axis6.Content = AxisAngles[6].ToString();
if (W.RoboticArmMovement)
{
MoveRoboticArm(AxisAngles);
}
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame skeletonFrame = e.SkeletonFrame;
int iSkeleton = 0;
Brush[] brushes = new Brush[6];
brushes[0] = new SolidColorBrush(Color.FromRgb(255, 0, 0));
brushes[1] = new SolidColorBrush(Color.FromRgb(0, 255, 0));
brushes[2] = new SolidColorBrush(Color.FromRgb(64, 255, 255));
brushes[3] = new SolidColorBrush(Color.FromRgb(255, 255, 64));
brushes[4] = new SolidColorBrush(Color.FromRgb(255, 64, 255));
brushes[5] = new SolidColorBrush(Color.FromRgb(128, 128, 255));
skeleton.Children.Clear();
foreach (SkeletonData data in skeletonFrame.Skeletons)
{
if (SkeletonTrackingState.Tracked == data.TrackingState)
{
// Draw bones
Brush brush = brushes[iSkeleton % brushes.Length];
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.Spine, JointID.ShoulderCenter, JointID.Head));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.ShoulderCenter, JointID.ShoulderLeft, JointID.ElbowLeft, JointID.WristLeft, JointID.HandLeft));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.ShoulderCenter, JointID.ShoulderRight, JointID.ElbowRight, JointID.WristRight, JointID.HandRight));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.HipLeft, JointID.KneeLeft, JointID.AnkleLeft, JointID.FootLeft));
skeleton.Children.Add(getBodySegment(data.Joints, brush, JointID.HipCenter, JointID.HipRight, JointID.KneeRight, JointID.AnkleRight, JointID.FootRight));
// Draw joints
foreach (Joint joint in data.Joints)
{
Point jointPos = getDisplayPosition(joint);
Line jointLine = new Line();
jointLine.X1 = jointPos.X - 3;
jointLine.X2 = jointLine.X1 + 6;
jointLine.Y1 = jointLine.Y2 = jointPos.Y;
jointLine.Stroke = jointColors[joint.ID];
jointLine.StrokeThickness = 6;
skeleton.Children.Add(jointLine);
}
}
iSkeleton++;
} // for each skeleton
}
/// <summary>
/// Event handler for Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
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, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
textBoxMensaje.Clear();
textBoxTiempo.Clear();
textBoxInfo.Clear();
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
//RenderClippedEdges(newSkel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
//CREATE A NEW SKELETON TO RECEIVE PROJECTED POINTS
//DrawRect(skel, mov.projectedWristL, trackedBonePen, dc);
//if the correct movement is tracked then color the skeleton bones with green
if (mov.deteccion(skel) || mov.deteccion5 == 5)
{
trackedBonePen = new Pen(Brushes.Green, 6);
DrawRect(skel, mov.projectedWristL, trackedBonePen, dc);
DrawRect(skel, mov.projectedWristR, trackedBonePen, dc);
DrawRect(skel, mov.projectedAnkR, trackedBonePen, dc);
DrawRect(skel, mov.projectedAnkL, trackedBonePen, dc);
}
//if the incorrect movement is tracked then color skeleton bones with red
else
{
trackedBonePen = new Pen(Brushes.Red, 6);
//paintRect(skel, mov.projectedWristL, inferredBonePen, dc);
DrawRect(skel, mov.projectedWristL, trackedBonePen, dc);
DrawRect(skel, mov.projectedWristR, trackedBonePen, dc);
DrawRect(skel, mov.projectedAnkR, trackedBonePen, dc);
DrawRect(skel, mov.projectedAnkL, trackedBonePen, dc);
}
//solucionP.Content = mov.getEstado();
//send messages of Correct or Incorrect movement
textBoxMensaje.AppendText(mov.getEstado() + "\n");
//textBoxMensaje.AppendText(this.SkeletonPointToScreen(mov.projectedWristL) + "\n");
//send message time span to the correct movement to be tracked
textBoxTiempo.AppendText(mov.contador + "\n");
//send message of the next movement to be tracked
textBoxInfo.AppendText(mov.proxMov + "\n");
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
textBoxMensaje.AppendText("Inicie el movimiento" + "\n");
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
static void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
// We only use the frame if the timer reset (this is to limit the frame rate)
if (reset)
{
Debug("Next Frame Ready");
// Here we get all 6 skeletons (even if they are not all being used)
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
// Get the skeleton we want
Skeleton ourSkel = null;
Skeleton ourOtherSkel = null;
foreach (Skeleton skel in skeletons)
{
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
if (ourSkel == null)
{
ourSkel = skel;
}
else
{
ourOtherSkel = skel;
}
}
}
if (ourSkel == null)
{
Debug("No tracked skeleton.");
reset = true;//try to find a skeleton again
return;
}
else
{
Debug("skeleton state = " + ourSkel.TrackingState);
}
// Get the joints we want
Joint left = ourSkel.Joints[JointType.ShoulderLeft];
Joint head = ourSkel.Joints[JointType.Head];
Joint right = ourSkel.Joints[JointType.ShoulderRight];
Joint center = ourSkel.Joints[JointType.ShoulderCenter];
// We then set the previousFrame and currentFrame
if (currentFrame[0] == null)
{
// If this is the first frame, then we can't set the previousFrame
currentFrame[0] = left.Position;
currentFrame[1] = right.Position;
currentFrame[2] = head.Position;
currentFrame[3] = center.Position;
// We will wait until the next frame so we have a previous frame
return;
}
previousFrame[0] = currentFrame[0];
previousFrame[1] = currentFrame[1];
previousFrame[2] = currentFrame[2];
previousFrame[3] = currentFrame[3];
currentFrame[0] = left.Position;
currentFrame[1] = right.Position;
currentFrame[2] = head.Position;
currentFrame[3] = center.Position;
// What we do with the skeleton data is determined by the state the program is in
switch (state)
{
// If the program is calibrating, we will get the calibration data from this frame
case State.Calibrate:
float totalDist = 0; //use distance formulas to get real distances between joints
totalDist += Distance(previousFrame[0], currentFrame[0]);
totalDist += Distance(previousFrame[1], currentFrame[1]);
totalDist += Distance(previousFrame[2], currentFrame[2]);
totalDist += Distance(previousFrame[3], currentFrame[3]);
Debug("Total dist: " + totalDist);
if (totalDist < .0075f) //this determines if the person has mooved too much or not
{
if (calibrated < 3)
{
Debug("Calibration frame: " + (calibrated + 1) + "/3");
calibrationPoints[calibrated, 0] = left.Position;
calibrationPoints[calibrated, 1] = right.Position;
calibrationPoints[calibrated, 2] = head.Position;
calibrationPoints[calibrated, 3] = center.Position;
calibrated++;
}
if (calibrated == 3)
{
calibration[0] = Center(calibrationPoints[0, 0], calibrationPoints[1, 0], calibrationPoints[2, 0]); //normalize points here
calibration[1] = Center(calibrationPoints[0, 1], calibrationPoints[1, 1], calibrationPoints[2, 1]);
calibration[2] = Center(calibrationPoints[0, 2], calibrationPoints[1, 2], calibrationPoints[2, 2]);
calibration[3] = Center(calibrationPoints[0, 3], calibrationPoints[1, 3], calibrationPoints[2, 3]);
currentFrame[0] = calibration[0];
currentFrame[1] = calibration[1];
currentFrame[2] = calibration[2];
currentFrame[3] = calibration[3];
normalize();
normalizedCalibration = normalized;
state = State.Run;
timer.Interval = 1000;
Console.WriteLine("Calibration complete.");
state = State.Run;
}
}
else
{
calibrated = 0;
}
break;
// If the program is running, we will determin if the user has good or bad posture
case State.Run:
normalize();
classify();
break;
// This state is for testing. Here we put whatever we want and it will not interfere with the rest of the program.
// Use this state by setting state = State.Testing where it is declared.
case State.Test:
Console.WriteLine(skeletons.Length.ToString() + " skeleton frames:");
foreach (Skeleton skel in skeletons)
{
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
//Console.WriteLine("tracked");
Console.WriteLine(head.Position.X.ToString() + head.Position.Y.ToString() + head.Position.Z.ToString());
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
Console.WriteLine("position only");
}
else
{
Console.WriteLine("Not tracked");
}
}
break;
default:
break;
}
reset = false;
}
}
// eventhandler voor skeletonframe
private void Sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
this.Skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame()) //skelet openen
{
if (skeletonFrame != null) // checken of een frame beschikbaar is
{
canvas.Children.Clear();
this.Skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(this.Skeletons); // skelet informatie van het frame bemachtigen
foreach (Skeleton skel in Skeletons)
{
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
Dictionary <string, Point> dictionary = new Dictionary <string, Point>();
foreach (Joint joint in skel.Joints)
{
//3D coordinaten in meter
SkeletonPoint skeletonPoint = joint.Position;
// 2D coordinaten in pixels
Point point = new Point();
// Skelet naar color mapping
ColorImagePoint colorPoint = Sensor.CoordinateMapper.MapSkeletonPointToColorPoint(skeletonPoint, ColorImageFormat.RgbResolution640x480Fps30);
point.X = colorPoint.X;
point.Y = colorPoint.Y;
string type = joint.JointType.ToString();
Point point2 = point;
dictionary.Add(type, point2);
Ellipse ellipse = new Ellipse
{
Fill = Brushes.Red,
Width = 10,
Height = 10
};
Canvas.SetLeft(ellipse, point.X - ellipse.Width / 2);
Canvas.SetTop(ellipse, point.Y - ellipse.Height / 2);
canvas.Children.Add(ellipse);
}
DrawBones(dictionary);
}
}
}
}
}
/// <summary>
/// Event handler for Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void SensorSkeletonFrameReady(SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
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, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
Skeleton user = null;
float distance = 50000f;
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
//this.DrawBonesAndJoints(skel, dc);
float skelDistance = skel.Joints[JointType.HipCenter].Position.Z;
if (skelDistance < distance)
{
distance = skelDistance;
user = skel;
}
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
//dc.DrawEllipse(
//this.centerPointBrush,
//null,
//this.SkeletonPointToScreen(skel.Position),
//BodyCenterThickness,
//BodyCenterThickness);
}
}
if (user != null)
{
this.DrawBonesAndJoints(user, dc);
}
// float ankleRight = user.Joints[JointType.AnkleRight].Position.Y;
// float ankleLeft = user.Joints[JointType.AnkleLeft].Position.Y;
// float rightDiff = 0f;
// float leftDiff = 0;
// if (ankleLeft > ankleRight)
// {
// leftDiff = ankleLeft - ankleRight;
// }
// else
// {
// rightDiff = ankleRight - ankleLeft;
// }
// System.Diagnostics.Debug.WriteLine("\n\n[USER] " + user.TrackingId);
// System.Diagnostics.Debug.WriteLine("\n[ABSOLUTE ORIENTATION] " + user.BoneOrientations[JointType.HipCenter].AbsoluteRotation.Quaternion.X);
// System.Diagnostics.Debug.WriteLine("\n[RIGHT FOOT] " + (rightDiff*100));
// System.Diagnostics.Debug.WriteLine("\n[LEFT FOOT] " + (leftDiff*100));
//}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
throw new NotImplementedException();
}
private void SkeletonsReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
int skeletonSlot = 0;
if ((this.skeletonData == null) || (this.skeletonData.Length != skeletonFrame.SkeletonArrayLength))
{
this.skeletonData = new Skeleton[skeletonFrame.SkeletonArrayLength];
}
skeletonFrame.CopySkeletonDataTo(this.skeletonData);
foreach (Skeleton skeleton in this.skeletonData)
{
if (SkeletonTrackingState.Tracked == skeleton.TrackingState)
{
Player player;
if (this.players.ContainsKey(skeletonSlot))
{
player = this.players[skeletonSlot];
}
else
{
player = new Player(skeletonSlot);
player.SetBounds(this.playerBounds);
this.players.Add(skeletonSlot, player);
}
player.LastUpdated = DateTime.Now;
// Update player's bone and joint positions
if (skeleton.Joints.Count > 0)
{
player.IsAlive = true;
// Head, hands, feet (hit testing happens in order here)
player.UpdateJointPosition(skeleton.Joints, JointType.Head);
player.UpdateJointPosition(skeleton.Joints, JointType.HandLeft);
player.UpdateJointPosition(skeleton.Joints, JointType.HandRight);
player.UpdateJointPosition(skeleton.Joints, JointType.FootLeft);
player.UpdateJointPosition(skeleton.Joints, JointType.FootRight);
// Hands and arms
player.UpdateBonePosition(skeleton.Joints, JointType.HandRight, JointType.WristRight);
player.UpdateBonePosition(skeleton.Joints, JointType.WristRight, JointType.ElbowRight);
player.UpdateBonePosition(skeleton.Joints, JointType.ElbowRight, JointType.ShoulderRight);
player.UpdateBonePosition(skeleton.Joints, JointType.HandLeft, JointType.WristLeft);
player.UpdateBonePosition(skeleton.Joints, JointType.WristLeft, JointType.ElbowLeft);
player.UpdateBonePosition(skeleton.Joints, JointType.ElbowLeft, JointType.ShoulderLeft);
// Head and Shoulders
player.UpdateBonePosition(skeleton.Joints, JointType.ShoulderCenter, JointType.Head);
player.UpdateBonePosition(skeleton.Joints, JointType.ShoulderLeft, JointType.ShoulderCenter);
player.UpdateBonePosition(skeleton.Joints, JointType.ShoulderCenter, JointType.ShoulderRight);
// Legs
player.UpdateBonePosition(skeleton.Joints, JointType.HipLeft, JointType.KneeLeft);
player.UpdateBonePosition(skeleton.Joints, JointType.KneeLeft, JointType.AnkleLeft);
player.UpdateBonePosition(skeleton.Joints, JointType.AnkleLeft, JointType.FootLeft);
player.UpdateBonePosition(skeleton.Joints, JointType.HipRight, JointType.KneeRight);
player.UpdateBonePosition(skeleton.Joints, JointType.KneeRight, JointType.AnkleRight);
player.UpdateBonePosition(skeleton.Joints, JointType.AnkleRight, JointType.FootRight);
player.UpdateBonePosition(skeleton.Joints, JointType.HipLeft, JointType.HipCenter);
player.UpdateBonePosition(skeleton.Joints, JointType.HipCenter, JointType.HipRight);
// Spine
player.UpdateBonePosition(skeleton.Joints, JointType.HipCenter, JointType.ShoulderCenter);
}
}
skeletonSlot++;
}
}
}
}
private void Sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
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, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
int track = 0;
bool isperson = false;
foreach (Skeleton S in skeletons)
{
if (S.TrackingState == SkeletonTrackingState.Tracked)
{
isperson = true;
break;
}
track++;
}
if (!firsttime && isperson)
{
// J1 = skeletons[track].Joints[JointType.KneeLeft].Position.Y;
// J2 = skeletons[track].Joints[JointType.KneeRight].Position.Y;
firsttime = true;
WalkingSetting.SetFirstThreshold(skeletons[track]);
ANGLES.FirstTime(skeletons[track]);
}
if (isperson)
{
//string Walking=prevwalk;
///if (((Math.Abs((skeletons[track].Joints[JointType.KneeLeft].Position.Y -J1 )) >= 0.05) || (Math.Abs(skeletons[track].Joints[JointType.KneeRight].Position.Y - J2) >= 0.05)))
/// {
///
/// J1 = skeletons[track].Joints[JointType.KneeLeft].Position.Y;
/// J2 = skeletons[track].Joints[JointType.KneeRight].Position.Y;
/// if (prevwalk == "0")
/// {
/// Walking = "1";
/// prevwalk = Walking;
/// }
///
/// else if (prevwalk=="1")
/// {
/// Walking = "2";
/// }
///
/// counter = 0;
/// }
/// else
/// {
/// if (counter >= 12)
/// {
/// Walking = "0";
/// prevwalk=Walking;
/// counter = 0;
/// }
/// else
/// {
/// * counter++;
/// * }
/// *}
/// */
ANGLES.SetJoints(skeletons[track]);
WalkingSetting.CheckStatus(skeletons[track]);
///string TEXT = "1 " + RShoulderPitch+" " +RShoulderRoll + " " +Relbowroll+" "+"3" + " " +LShoulderPitch + " " +LShoulderRoll + " " + LElbowRoll + " " + Walking;
/// string ASJAD = "1" + " "+RElbowRoll;
///TEXT="1 "+ + " " + RightShoulderRoll() + " " + RightElbowRoll() + " " + RightElbowYaw() + " "+ LeftShoulderPitch() + " " + LeftShoulderRoll() + " " + LeftElbowRoll();
string TEXT = "1 " + ANGLES.GetAllAngles() + " " + WalkingSetting.GetStatus();
System.IO.File.WriteAllText(@"D:\fyp\test\movement.txt", TEXT);
}
else
{
string text = "0";
try
{
System.IO.File.WriteAllText(@"D:\fyp\test\movement.txt", text);
}
catch
{
}
//Ye If Statement Hata k Check Krni hai
if (!isperson)
{
firsttime = false;
}
}
}
private void MyKinect_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
try {
/*canvSkel.Children.Clear();*/
//string msg = "";
//string msgC = "";
Skeleton[] skels = null;
using (SkeletonFrame frameSkeleton = e.OpenSkeletonFrame())
{
if (frameSkeleton != null)
{
skels = new Skeleton[frameSkeleton.SkeletonArrayLength];
frameSkeleton.CopySkeletonDataTo(skels);
}
}
if (skels == null)
{
return;
}
/*
* Color[] skelcol = new Color[16];
* skelcol[0] = Colors.Blue;
* skelcol[1] = Colors.Green;
* skelcol[2] = Colors.Red;
* skelcol[3] = Colors.Yellow;
* skelcol[4] = Colors.Pink;
* skelcol[5] = Colors.Blue;
* skelcol[6] = Colors.Green;
* skelcol[7] = Colors.Red;
* skelcol[8] = Colors.Yellow;
* skelcol[9] = Colors.Pink;
* skelcol[10] = Colors.Blue;
* skelcol[11] = Colors.Green;
* skelcol[12] = Colors.Red;
* skelcol[13] = Colors.Yellow;
* skelcol[14] = Colors.Pink;
* skelcol[15] = Colors.Blue;
*/
int sk_indx = 0;
int sk_indx1 = 0;
int sk_cl = 0;
foreach (Skeleton skel in skels)
{
sk_indx = sk_indx + 1;
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
sk_indx1 = sk_indx1 + 1;
if (skel.ClippedEdges == 0)
{
sk_cl = 0;
}
else
{
sk_cl = 1;
}
//Joint[] jsp = new Joint[4];
//jsp[0] = skel.Joints[JointType.Head];
if (sk_indx1 == 1)
{
OnKinect1?.Invoke(sk_indx, sk_cl, skel);
}
else if (sk_indx1 == 2)
{
OnKinect2?.Invoke(sk_indx, sk_cl, skel);
}
else if (sk_indx1 == 3)
{
OnKinect3?.Invoke(sk_indx, sk_cl, skel);
}
else if (sk_indx1 == 4)
{
OnKinect4?.Invoke(sk_indx, sk_cl, skel);
}
}
}
} catch (Exception ex) {
OnKinectInitError("Error " + ex.Message);
}
}
private void KinectSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
if (responseReceived == true)
{
var skeletons = new Skeleton[0];
using (var skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
if (skeletons.Length == 0)
{
return;
}
var skel = skeletons.FirstOrDefault(x => x.TrackingState == SkeletonTrackingState.Tracked);
if (skel == null)
{
return;
}
var leftHand = skel.Joints[JointType.WristLeft]; // 1
var rightHand = skel.Joints[JointType.WristRight]; // 2
var leftElbow = skel.Joints[JointType.ElbowLeft]; // 3
var rightElbow = skel.Joints[JointType.ElbowRight]; // 4
var leftKnee = skel.Joints[JointType.KneeLeft]; // 5
var rightKnee = skel.Joints[JointType.KneeRight]; // 6
var leftAnkle = skel.Joints[JointType.AnkleLeft]; // 7
var rightAnkle = skel.Joints[JointType.AnkleRight]; // 8
var centreHip = skel.Joints[JointType.HipCenter];
var centreShoulder = skel.Joints[JointType.ShoulderCenter];
var allJoints = new[] { leftHand, rightHand, leftElbow, rightElbow, leftAnkle, leftKnee, rightAnkle, rightKnee };
//XValueRight.Text = rightHand.Position.X.ToString(CultureInfo.InvariantCulture);
// YValueRight.Text = rightHand.Position.Y.ToString(CultureInfo.InvariantCulture);
// ZValueRight.Text = rightHand.Position.Z.ToString(CultureInfo.InvariantCulture);
// XValueLeft.Text = leftHand.Position.X.ToString(CultureInfo.InvariantCulture);
// YValueLeft.Text = leftHand.Position.Y.ToString(CultureInfo.InvariantCulture);
// ZValueLeft.Text = leftHand.Position.Z.ToString(CultureInfo.InvariantCulture);
int jointcnt = 0;
string res = "";
foreach (var joint in allJoints)
{
jointcnt++;
int angle = 0;
if (jointcnt == 1) // lefthand, relative to leftElbow
{
double radians = Math.Atan((joint.Position.Y - leftElbow.Position.Y) / (joint.Position.X - leftElbow.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 2) // righthand
{ // righthand
double radians = Math.Atan((joint.Position.Y - rightElbow.Position.Y) / (joint.Position.X - rightElbow.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 3) // leftelbow, relative to centreShoulder
{
double radians = Math.Atan((joint.Position.Y - centreShoulder.Position.Y) / (joint.Position.X - centreShoulder.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 4) // right elbow
{
double radians = Math.Atan((joint.Position.Y - centreShoulder.Position.Y) / (joint.Position.X - centreShoulder.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 5)
{
double radians = Math.Atan((joint.Position.Y - leftKnee.Position.Y) / (joint.Position.X - leftKnee.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 6)
{
double radians = Math.Atan((joint.Position.Y - centreHip.Position.Y) / (joint.Position.X - centreHip.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 7)
{
double radians = Math.Atan((joint.Position.Y - rightKnee.Position.Y) / (joint.Position.X - rightKnee.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
if (jointcnt == 8)
{
double radians = Math.Atan((joint.Position.Y - centreHip.Position.Y) / (joint.Position.X - centreHip.Position.X));
angle = (int)(radians * (180 / Math.PI) + 90); // 90 is the default angle(horizontal)
}
res = res + jointcnt.ToString() + ',' + angle.ToString() + ',';
}
lenSent = res.Length;
port.WriteLine(res); // 1,90
System.Diagnostics.Debug.WriteLine("sending.." + res);
SerialMonitor.Text += " sent:" + res + Environment.NewLine;
responseReceived = false;
}
}
// Skeleton Stream Actions
private void Sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
// Initialise skeleton array to store available skeletons (maximum 6)
Skeleton[] skeletons = new Skeleton[0];
// Store skeletons from available skeleton frame to the array
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame == null)
{
return;
}
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
// Choose the first/nearest skeleton as the main skeleton
Skeleton skel = (from trackskeleton in skeletons
where trackskeleton.TrackingState == SkeletonTrackingState.Tracked
select trackskeleton).FirstOrDefault();
// Code to go ahead if any skeletons are available
if (skel == null)
{
return;
}
//Draw Skeleton
using (DrawingContext dc = drawingGroup.Open())
{
// Draw a transparent background to set the render size
dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, RenderWidth, RenderHeight));
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
DrawBonesAndJoints(skel, dc);
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(centerPointBrush, null, SkeletonPointToScreen(skel.Position), BodyCenterThickness, BodyCenterThickness);
}
// prevent drawing outside of our render area
drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
// If skeletons are being tracked in real time in synchronisation, process angles
if (skel.Joints[JointType.ShoulderRight].TrackingState == JointTrackingState.Tracked &&
skel.Joints[JointType.ElbowRight].TrackingState == JointTrackingState.Tracked &&
skel.Joints[JointType.WristRight].TrackingState == JointTrackingState.Tracked &&
skel.Joints[JointType.ShoulderLeft].TrackingState == JointTrackingState.Tracked &&
skel.Joints[JointType.ElbowLeft].TrackingState == JointTrackingState.Tracked &&
skel.Joints[JointType.WristLeft].TrackingState == JointTrackingState.Tracked)
{
// Print angles on the WPF application's labels
int[] ang = PrintAngles(skel);
ls1.Content = ang[0];
rs1.Content = ang[1];
ls2.Content = ang[2];
rs2.Content = ang[3];
le.Content = ang[4];
re.Content = ang[5];
lh.Content = ang[6];
rh.Content = ang[7];
lk.Content = ang[8];
rk.Content = ang[9];
// Print angles on the serial port
string toSend = "";
for (int i = 0; i < 6; i++)
{
toSend += (i + "." + ang[i] + ":");
}
Console.WriteLine(toSend);
if (first)
{
lastTime = DateTime.UtcNow;
port.WriteLine(toSend);
return;
}
TimeSpan difference = lastTime.Subtract(DateTime.UtcNow);
if (difference.Seconds > 4)
{
port.WriteLine(toSend);
lastTime = DateTime.UtcNow;
}
}
}
private void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
// If controller was deactivated less than one second before, it won't track any thing
if (justDeactivated == true)
{
return;
}
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
// if the frame has data then copy to skeletons array
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
// if skeletons array is null then go out
if (skeletons == null)
{
return;
}
// if a skeleton is already given control then ignore others
if (skeletonSelected)
{
foreach (Skeleton skeleton in skeletons)
{
// set the activeSkeleton as the one that holds the skeletonId stored previously
if (skeleton.TrackingId == skeletonId)
{
activeSkeleton = skeleton;
}
}
// if the skeleton went out of range then they will lose his status as active
if (activeSkeleton.Position.X < minX || activeSkeleton.Position.X > maxX ||
activeSkeleton.Position.Z < minZ || activeSkeleton.Position.Z > maxZ)
{
deactivateActions();
return;
}
leftHandPoint = this.ScalePosition(activeSkeleton.Joints[JointType.HandLeft].Position);
leftElbowPoint = this.ScalePosition(activeSkeleton.Joints[JointType.ElbowLeft].Position);
rightHandPoint = this.ScalePosition(activeSkeleton.Joints[JointType.HandRight].Position);
// move mouse
actionWhenTracked();
// This is to deal with the event of someone crossing in front of the sensor when you are using
if (activeSkeleton.TrackingState == SkeletonTrackingState.NotTracked ||
activeSkeleton.Joints[JointType.Spine].TrackingState == JointTrackingState.NotTracked)
{
deactivateActions();
// if I wanted not to close the window when someone crosses
//someoneCrossedInFrontOfUser = true;
}
if (activeSkeleton == null)
{
deactivateActions();
}
}
// if no user is active then go through all skeletons to detect new users
else
{
foreach (Skeleton skeleton in skeletons)
{
// skeleton not tracked then do nothing
if (skeleton.TrackingState == SkeletonTrackingState.NotTracked)
{
;
}
// skeleton not in a specific range in terms of x and z, then ignore user and return
else if (skeleton.Position.X < minX || skeleton.Position.X > maxX ||
skeleton.Position.Z < minZ || skeleton.Position.Z > maxZ)
{
skeleton.TrackingState = SkeletonTrackingState.PositionOnly;
}
else
{
// if you reach this point, the person is standing a certain distance from the Kinect.
// Not too close, not too far away and he is also in front of sensor.
// mark him as a tracked skeleton to be detected and interacted with
skeleton.TrackingState = SkeletonTrackingState.Tracked;
//// Automatic activation as long as you are in the activation position
skeletonSelected = true;
skeletonId = skeleton.TrackingId;
activateActions();
}
}
}
}
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
var trackedSkeletons = from s in e.SkeletonFrame.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s;
trackedSkeletonsCount = trackedSkeletons.Count();
skeletons = new SkeletonData[trackedSkeletonsCount];
for (int i = 0; i < trackedSkeletonsCount; i++)
{
skeletons[i] = trackedSkeletons.ElementAt(i);
}
// If a skeleton was recognized, get the first one to work with
if (skeletons.Length > 0 && skeletons[0] != null)
{
// Grab the left hand coordinates and scale them to the canvas
var leftHand = skeletons[0].Joints[JointID.HandLeft];
var scaledLeftHand = leftHand.ScaleTo((int)canvasKinect.ActualWidth, (int)canvasKinect.ActualHeight, 1f, 1f);
float leftX = scaledLeftHand.Position.X;
float leftY = scaledLeftHand.Position.Y;
float leftZ = scaledLeftHand.Position.Z;
// Grab the right hand coordinates and scale them to the canvas
var rightHand = skeletons[0].Joints[JointID.HandRight];
var scaledRightHand = rightHand.ScaleTo((int) canvasKinect.ActualWidth, (int) canvasKinect.ActualHeight, 1f, 1f);
float rightX = scaledRightHand.Position.X;
float rightY = scaledRightHand.Position.Y;
float rightZ = scaledRightHand.Position.Z;
draw(leftX, leftY, rightX, rightY);
// Stretch phase logic
if (phase == "stretch" && !box1.isStretching)
{
bool isLeftOnLeft = isOnLeftSide(leftX, leftY);
bool isLeftOnTop = isOnTopSide(leftX, leftY);
bool isLeftOnBottom = isOnBottomSide(leftX, leftY);
bool isRightOnRight = isOnRightSide(rightX, rightY);
bool isRightOnTop = isOnTopSide(rightX, rightY);
bool isRightOnBottom = isOnBottomSide(rightX, rightY);
if ((isLeftOnLeft && isRightOnRight)
|| (isLeftOnTop && isRightOnBottom)
|| (isLeftOnBottom && isRightOnTop))
{
box1.isStretching = true;
}
}
else if (phase == "stretch" && box1.isStretching)
{
// If the left hand was on the left side and the right hand was on the right side
if (isOnLeftSide(leftX, leftY) && isOnRightSide(rightX, rightY))
{
box1.Left = leftX;
box1.BoxRect.Width += prevLeftX - leftX;
box1.BoxRect.Width += rightX - prevRightX;
}
// If the left hand was on the bottom and the right hand was on the right top
else if (isOnBottomSide(leftX, leftY) && isOnTopSide(rightX, rightY))
{
box1.Top = rightY;
box1.BoxRect.Height += prevRightY - rightY;
box1.BoxRect.Height += leftY - prevLeftY;
}
// If the left hand was on the top and the right hand was on the bottom
else if (isOnTopSide(leftX, leftY) && isOnBottomSide(rightX, rightY))
{
box1.Top = leftY;
box1.BoxRect.Height += prevLeftY - leftY;
box1.BoxRect.Height += rightY - prevRightY;
}
}
// Transport phase logic
if (phase == "transport" && !box1.isMoving)
{
// If the left hand was on the left side and the right hand was on the right side
bool leftValid = isOnLeftSide(leftX, leftY);
bool rightValid = isOnRightSide(rightX, rightY);
if (leftValid && rightValid)
{
box1.isMoving = true;
}
}
else if (phase == "transport" && box1.isMoving)
{
double centerX = (rightX + leftX) / 2;
double centerY = (rightY + leftY) / 2;
box1.Left = centerX - box1.BoxRect.Width / 2;
box1.Top = centerY - box1.BoxRect.Height / 2;
}
// Scale phase logic
if (phase == "scale" && !box1.isScaling)
{
bool isLeftOnLeft = isOnLeftSide(leftX, leftY);
bool isLeftOnTop = isOnTopSide(leftX, leftY);
bool isLeftOnBottom = isOnBottomSide(leftX, leftY);
bool isRightOnRight = isOnRightSide(rightX, rightY);
bool isRightOnTop = isOnTopSide(rightX, rightY);
bool isRightOnBottom = isOnBottomSide(rightX, rightY);
// If the left hand was on the left side and the right hand was on the right side
// or if the left hand was on the bottom and the right hand was on the right top
// or if the left hand was on the top and the right hand was on the bottom
if ((isLeftOnLeft && isRightOnRight)
|| (isLeftOnTop && isRightOnBottom)
|| (isLeftOnBottom && isRightOnTop))
{
box1.isScaling = true;
}
}
else if (phase == "scale" && box1.isScaling)
{
// If the left hand was on the left side and the right hand was on the right side
if (isOnLeftSide(leftX, leftY) && isOnRightSide(rightX, rightY))
{
double newWidth = box1.BoxRect.Width;
double newHeight = box1.BoxRect.Height;
box1.Left = leftX;
newWidth += prevLeftX - leftX;
newWidth += rightX - prevRightX;
box1.Top -= (prevLeftX - leftX) / box1.AspectRatio;
box1.Top -= (rightX - prevRightX) / box1.AspectRatio;
newHeight += (prevLeftX - leftX) / box1.AspectRatio;
newHeight += (rightX - prevRightX) / box1.AspectRatio;
box1.BoxRect.Width = newWidth;
box1.BoxRect.Height = newHeight;
}
// If the left hand was on the bottom and the right hand was on the right top
else if (isOnBottomSide(leftX, leftY) && isOnTopSide(rightX, rightY))
{
double newWidth = box1.BoxRect.Width;
double newHeight = box1.BoxRect.Height;
box1.Top = rightY;
newHeight += prevRightY - rightY;
newHeight += leftY - prevLeftY;
box1.Left -= (leftY - prevLeftY) * box1.AspectRatio;
box1.Left -= (prevRightY - rightY) * box1.AspectRatio;
newWidth += (leftY - prevLeftY) * box1.AspectRatio;
newWidth += (prevRightY - rightY) * box1.AspectRatio;
box1.BoxRect.Width = newWidth;
box1.BoxRect.Height = newHeight;
}
// If the left hand was on the top and the right hand was on the bottom
else if (isOnTopSide(leftX, leftY) && isOnBottomSide(rightX, rightY))
{
double newWidth = box1.BoxRect.Width;
double newHeight = box1.BoxRect.Height;
box1.Top = leftY;
newHeight += prevLeftY - leftY;
newHeight += rightY - prevRightY;
box1.Left -= (prevLeftY - leftY) * box1.AspectRatio;
box1.Left -= (rightY - prevRightY) * box1.AspectRatio;
newWidth += (rightY - prevRightY) * box1.AspectRatio;
newWidth += (prevLeftY - leftY) * box1.AspectRatio;
box1.BoxRect.Width = newWidth;
box1.BoxRect.Height = newHeight;
}
}
prevLeftX = leftX;
prevLeftY = leftY;
prevRightX = rightX;
prevRightY = rightY;
}
}
private void kinectSensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
if (pause)
{
return;
}
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
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, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
index++;
if (actionState)
{
BitmapSource colorFrame = (BitmapSource)this.colorImageElement.Source;
//BitmapSource skeletonFrame = (BitmapSource)this.skeletonImageElement.Source;
actionData.add(colorFrame, null, skel);
}
if (index == 30)
{
index = 0;
Posture posture = PostureRecognition.computePosture(skel, PostureType.Both);
Text_PostureData.Text = posture.toJsonString();
}
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
private void ShowSkeleton(SkeletonFrameReadyEventArgs e)
{
canvasSkeleton.Children.Clear();
SkeletonFrame skeletonFrame = e.OpenSkeletonFrame();
if (skeletonFrame != null)
{
Skeleton[] skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
foreach (Skeleton skeleton in skeletons)
{
if (skeleton.TrackingState == SkeletonTrackingState.Tracked)
{
this.skeletonPoing_HandRight = skeleton.Joints[JointType.HandRight].Position;
//xdepth.Text = string.Format("{0}mm", skeletonPoing_HandRight.X);
//ydepth.Text = string.Format("{0}mm", skeletonPoing_HandRight.Y);
if (skeletonPoing_HandRight.Z > 0.90 && skeletonPoing_HandRight.Z < 1.00)
{
zdepth.Foreground = new SolidColorBrush(Colors.Red);
zdepth.Text = string.Format("{0}m", skeletonPoing_HandRight.Z);
}
else
{
zdepth.Foreground = new SolidColorBrush(Colors.Black);
zdepth.Text = string.Format("{0}m", skeletonPoing_HandRight.Z);
}
//this.writer.WriteLine(
// (double)(sw.ElapsedMilliseconds) / 1000
// + "," +
// skeleton.Joints[JointType.HandRight].Position.X
// + ","
// + skeleton.Joints[JointType.HandRight].Position.Y
// + ","
// + skeleton.Joints[JointType.HandRight].Position.Z
// );
ColorImagePoint handpoint = kinect.CoordinateMapper.MapSkeletonPointToColorPoint(skeletonPoing_HandRight, kinect.ColorStream.Format);
this.writer.WriteLine((double)(sw.ElapsedMilliseconds) / 1000 + "," + handpoint.X + "," + handpoint.Y + "," + skeletonPoing_HandRight.Z);
xdepth.Text = string.Format("{0}pixel", handpoint.X);
ydepth.Text = string.Format("{0}pixel", handpoint.Y);
foreach (Joint joint in skeleton.Joints)
{
const int R = 4;
//ColorImagePoint point = kinect.CoordinateMapper.MapSkeletonPointToColorPoint(joint.Position, kinect.ColorStream.Format);
ColorImagePoint point = kinect.CoordinateMapper.MapSkeletonPointToColorPoint(skeletonPoing_HandRight, kinect.ColorStream.Format);
point.X = (int)ScaleTo(point.X, kinect.ColorStream.FrameWidth, canvasSkeleton.Width);
point.Y = (int)ScaleTo(point.Y, kinect.ColorStream.FrameHeight, canvasSkeleton.Height);
canvasSkeleton.Children.Add(new Ellipse()
{
Fill = new SolidColorBrush(Colors.Red),
Margin = new Thickness(point.X - R, point.Y, 0, 0),
Width = R * 2,
Height = R * 2,
});
}
}
}
skeletonFrame.Dispose();
}
}
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
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, RenderWidth, RenderHeight));
dc.DrawImage(this.colorBitmap, new Rect(0.0, 0.0, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
}
// Toma de Mediciones
Joint handRight = skel.Joints[JointType.HandRight];
Joint handLeft = skel.Joints[JointType.HandLeft];
Joint shoulderCenter = skel.Joints[JointType.ShoulderCenter];
Joint elbowLeft = skel.Joints[JointType.ElbowLeft];
if ((handLeft.TrackingState == JointTrackingState.Tracked) &&
(handRight.TrackingState == JointTrackingState.Tracked))
{
dc.DrawLine(this.HandHandPen, this.SkeletonPointToScreen(handRight.Position), this.SkeletonPointToScreen(handLeft.Position));
//DistanceHelper.Angulos(handLeft, shoulderCenter, handRight);
string distance = DistanceHelper.ObtenerDistancia(handLeft, handRight).ToString();
FormattedText formattedText = new FormattedText(distance, CultureInfo.CurrentCulture, FlowDirection.LeftToRight
, new Typeface("Verdana"), 50, Brushes.Red);
double x = ((handLeft.Position.X + handRight.Position.X) / 2) * 320;
double y = 240 - (((handLeft.Position.Y + handRight.Position.Y) / 2) * 240);
//double x = 320;
//double y = 240;
//640x480
dc.DrawText(formattedText, new Point(x, y));
Console.WriteLine("x" + x.ToString());
Console.WriteLine("y" + y.ToString());
}
string setDistanceHands;
setDistanceHands = "" + DistanceHelper.ObtenerDistancia(handLeft, handRight);
if (setDistanceHands != "0")
{
DistanceHandHand.Text = setDistanceHands;
}
Console.WriteLine("La distancia es:" + setDistanceHands);
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
void kinectDevice_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
foreach (SkeletonData skeleton in e.SkeletonFrame.Skeletons)
{
//make sure he's just the first players
if (skeleton.TrackingState == SkeletonTrackingState.Tracked)
{
foreach (Joint joint in skeleton.Joints)
{
if (joint.ID == JointID.HandRight)
{
float depthX, depthY;
kinectDevice.SkeletonEngine.SkeletonToDepthImage(joint.Position, out depthX, out depthY);
depthX = Math.Max(0, Math.Min(depthX * 320, 320));
depthY = Math.Max(0, Math.Min(depthY * 240, 240));
int colorX, colorY;
kinectDevice.NuiCamera.GetColorPixelCoordinatesFromDepthPixel(ImageResolution.Resolution640x480, new ImageViewArea(), (int)depthX, (int)depthY, (short)0, out colorX, out colorY);
player.UpdateHand(new Vector2((float)(800 * (colorX) / 640.0), (float)(600 * (colorY) / 480.0)));
}
}
}
}
}
/// <summary>
/// Event handler for Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
//Fetching the first skeleton from the skeleton array in the sensor data
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
// fire event to button to check
Skeleton tracked = null;
foreach (Skeleton s in skeletons)
{
if (s.TrackingState == SkeletonTrackingState.Tracked)
{
tracked = s;
break;
}
}
if (tracked != null)
{
SkeletonPoint relativePoint = tracked.Joints[JointType.HandRight].Position;
Point absolutePoint = SkeletonPointToScreen(relativePoint);
if (this.SendRightHandPointToButton != null)
{
this.SendRightHandPointToButton(this, new RightHandEventArgs(absolutePoint));
}
}
}
}
using (DrawingContext dc = this.drawingGroup.Open())
{
// Draw a transparent background to set the render size
//dc.DrawRectangle(Brushes.White, null, new Rect(0.0, 0.0, RenderWidth, RenderHeight));
//This is where the magic happens. The video image from the kinect is moved to the screen here
//dc.DrawImage(colorBitmap, new Rect(0.0, 0.0, RenderWidth, RenderHeight));
//This is where the spooky skeleton dark magic happens. Bones happen and get drawn to the screen and stuff I guess
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
/// <summary>
/// Handler for the Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="skeletonFrameReadyEventArgs">event arguments</param>
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs skeletonFrameReadyEventArgs)
{
// Even though we un-register all our event handlers when the sensor
// changes, there may still be an event for the old sensor in the queue
// due to the way the KinectSensor delivers events. So check again here.
if (this.KinectSensor != sender)
{
return;
}
using (SkeletonFrame skeletonFrame = skeletonFrameReadyEventArgs.OpenSkeletonFrame())
{
if (null != skeletonFrame)
{
try
{
// Copy the skeleton data from the frame to an array used for temporary storage
skeletonFrame.CopySkeletonDataTo(this.skeletons);
var accelerometerReading = this.KinectSensor.AccelerometerGetCurrentReading();
// Hand data to Interaction framework to be processed
this.interactionStream.ProcessSkeleton(this.skeletons, accelerometerReading, skeletonFrame.Timestamp);
}
catch (InvalidOperationException)
{
// SkeletonFrame functions may throw when the sensor gets
// into a bad state. Ignore the frame in that case.
}
}
}
}
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (var skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame == null)
{
return;
}
if (skeletons == null ||
skeletons.Length != skeletonFrame.SkeletonArrayLength)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
}
skeletonFrame.CopySkeletonDataTo(skeletons);
}
Skeleton closestSkeleton = skeletons.Where(s => s.TrackingState == SkeletonTrackingState.Tracked)
.OrderBy(s => s.Position.Z * Math.Abs(s.Position.X))
.FirstOrDefault();
if (closestSkeleton == null)
{
return;
}
var rightElbow = closestSkeleton.Joints[JointType.ElbowRight];
var leftKnee = closestSkeleton.Joints[JointType.KneeLeft];
var rightKnee = closestSkeleton.Joints[JointType.KneeRight];
var rightLeg = closestSkeleton.Joints[JointType.FootRight];
var leftLeg = closestSkeleton.Joints[JointType.FootLeft];
var head = closestSkeleton.Joints[JointType.Head];
var rightHand = closestSkeleton.Joints[JointType.HandRight];
var leftHand = closestSkeleton.Joints[JointType.HandLeft];
var hip = closestSkeleton.Joints[JointType.HipCenter];
if (head.TrackingState == JointTrackingState.NotTracked ||
rightHand.TrackingState == JointTrackingState.NotTracked ||
leftHand.TrackingState == JointTrackingState.NotTracked)
{
////// Action robot STOP
//Don't have a good read on the joints so we cannot process gestures
return;
}
SetEllipsePosition(ellipseRightLeg, rightLeg, isStop);
// SetEllipsePosition(ellipseRightElbow, rightElbow, isStop);
SetEllipsePosition(ellipseHip, hip, false);
SetEllipsePosition(ellipseLeftKnee, leftKnee, isBackGestureActive);
SetEllipsePosition(ellipseRightKnee, rightKnee, isForwardGestureActive);
SetEllipsePosition(ellipseHead, head, false);
SetEllipsePosition(ellipseLeftHand, leftHand, isTurnLeft);
SetEllipsePosition(ellipseRightHand, rightHand, isTurnRight);
/*
*
* bool isTurnRight = false;
* bool isTurnLeft = false;
* bool isStop = false;
* bool isForwardGestureActive = false;
* bool isBackGestureActive = false;
* */
ProcessForwardBackGesture(head, rightHand, leftHand, hip, rightKnee, leftKnee, rightElbow, rightLeg);
}
void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame allSkeletons = e.SkeletonFrame;
//get the first tracked skeleton
SkeletonData skeleton = (from s in allSkeletons.Skeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
#region Set Positions
//set position
SetEllipsePosition(RHand, skeleton.Joints[JointID.HandRight]);
var scaledJoint = skeleton.Joints[JointID.HandRight].ScaleTo(640, 480, .5f, .5f);
rightHandX = scaledJoint.Position.X;
rightHandY = scaledJoint.Position.Y;
SetEllipsePosition(LHand, skeleton.Joints[JointID.HandLeft]);
scaledJoint = skeleton.Joints[JointID.HandLeft].ScaleTo(640, 480, .5f, .5f);
leftHandX = scaledJoint.Position.X;
leftHandY = scaledJoint.Position.Y;
if (target.Visibility == Visibility.Visible)
{
if (Math.Sqrt((rightHandX - targetX) * (rightHandX - targetX) + (rightHandY - targetY) * (rightHandY - targetY)) < 50 ||
Math.Sqrt((leftHandX - targetX) * (leftHandX - targetX) + (leftHandY - targetY) * (leftHandY - targetY)) < 50)
{
int currScore = int.Parse((string)ScoreNumber.Content);
currScore++;
ScoreNumber.Content = currScore + "";
targetX = (float)(rand.Next(540) + 50);
targetY = (float)(rand.Next(230) + 100);
while (Math.Sqrt((rightHandX - targetX) * (rightHandX - targetX) + (rightHandY - targetY) * (rightHandY - targetY)) < 50 ||
Math.Sqrt((leftHandX - targetX) * (leftHandX - targetX) + (leftHandY - targetY) * (leftHandY - targetY)) < 50)
{
targetX = (float)(rand.Next(540) + 50);
targetY = (float)(rand.Next(230) + 100);
}
Canvas.SetLeft(target, targetX - 100);
Canvas.SetTop(target, targetY - 100);
}
}
#endregion
#region Check Inferred
if (!tracking || skeleton.Joints[JointID.HandRight].TrackingState == JointTrackingState.NotTracked)
{
Canvas.SetLeft(RHand, -100);
Canvas.SetTop(RHand, -100);
}
if (!tracking || skeleton.Joints[JointID.HandLeft].TrackingState == JointTrackingState.NotTracked)
{
Canvas.SetLeft(LHand, -100);
Canvas.SetTop(LHand, -100);
}
#endregion
//set position
#region recordData
string[] stuff = new string[(int)JointID.Count * 4];
for (int i = 0; i < (int)JointID.Count; i++)
{
if (skeleton.Joints[(JointID)i].TrackingState == JointTrackingState.Tracked)
{
stuff[4 * i] = skeleton.Joints[(JointID)i].ID.ToString();
stuff[4 * i + 1] = skeleton.Joints[(JointID)i].Position.X.ToString();
stuff[4 * i + 2] = skeleton.Joints[(JointID)i].Position.Y.ToString();
stuff[4 * i + 3] = skeleton.Joints[(JointID)i].Position.Z.ToString();
}
else
{
stuff[4 * i] = skeleton.Joints[(JointID)i].ID.ToString();
stuff[4 * i + 1] = "Not Found X";
stuff[4 * i + 2] = "Not Found Y";
stuff[4 * i + 3] = "Not Found Z";
}
}
try
{
System.IO.File.WriteAllLines(@"C:\Users\Alexander Ramirez\Desktop\Kinect E87\SkeletalTracking\Data.txt", stuff);
}
catch (Exception ex) { }
#endregion
}
/// <summary>
/// Event handler for Kinect sensor's SkeletonFrameReady event
/// </summary>
/// <param name="sender">object sending the event</param>
/// <param name="e">event arguments</param>
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
DateTime jointTime;
DateTime jointTime2;
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
jointTime = DateTime.Now;
jointTime2 = DateTime.Now.AddSeconds(10);
//get the time ex 10 second. every 10 second get the skeleton from the list an calculate the angles then compare
TimeSpan timeSpan = jointTime2.Subtract(jointTime);
//Debug.WriteLine(jointTime);
if (timeSpan.Equals(10))
{
List <Skeleton> _savedSkeletons = new List <Skeleton>();
foreach (var skeleton in skeletons)
{
if (skeleton.TrackingState != SkeletonTrackingState.Tracked)
{
continue;
}
_savedSkeletons.Add(skeleton);
}
}
}
}
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, RenderWidth, RenderHeight));
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc);
}
else if (skel.TrackingState == SkeletonTrackingState.PositionOnly)
{
dc.DrawEllipse(
this.centerPointBrush,
null,
this.SkeletonPointToScreen(skel.Position),
BodyCenterThickness,
BodyCenterThickness);
}
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
void SkeletonsReady(object sender, SkeletonFrameReadyEventArgs e)
{
SkeletonFrame skeletonFrame = e.SkeletonFrame;
SkeletonData skeleton = (from aFrame in skeletonFrame.Skeletons where aFrame.TrackingState == SkeletonTrackingState.Tracked select aFrame).FirstOrDefault();
if (kinectPlayerSkeleton == null)
{
kinectPlayerSkeleton = new SkeletonProcessing(skeleton, 1f);
}
else
{
kinectPlayerSkeleton.SetSkeletonData(skeleton);
}
}
private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
Skeleton[] skeletons = new Skeleton[0];
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame != null)
{
skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
skeletonFrame.CopySkeletonDataTo(skeletons);
}
}
using (DrawingContext dc = this.drawingGroup.Open())
{
// Draw a transparent background to set the render size
dc.DrawRectangle(System.Windows.Media.Brushes.Black, null, new Rect(0.0, 0.0, RenderWidth, RenderHeight));
for (int i = 0; i < balls.Length; i++)
{
if (balls[i].getColor() == 'g')
{
dc.DrawEllipse(System.Windows.Media.Brushes.Lime, null, balls[i].getPosition(), balls[i].getRadius(), balls[i].getRadius());
}
else if (balls[i].getColor() == 'r')
{
dc.DrawEllipse(System.Windows.Media.Brushes.Red, null, balls[i].getPosition(), balls[i].getRadius(), balls[i].getRadius());
}
else if (balls[i].getColor() == 'b')
{
dc.DrawEllipse(System.Windows.Media.Brushes.DeepSkyBlue, null, balls[i].getPosition(), balls[i].getRadius(), balls[i].getRadius());
}
else if (balls[i].getColor() == 'y')
{
dc.DrawEllipse(System.Windows.Media.Brushes.Yellow, null, balls[i].getPosition(), balls[i].getRadius(), balls[i].getRadius());
}
else if (balls[i].getColor() == 'p')
{
dc.DrawEllipse(System.Windows.Media.Brushes.MediumVioletRed, null, balls[i].getPosition(), balls[i].getRadius(), balls[i].getRadius());
}
else if (balls[i].getColor() == 'o')
{
dc.DrawEllipse(System.Windows.Media.Brushes.Orange, null, balls[i].getPosition(), balls[i].getRadius(), balls[i].getRadius());
}
//dc.DrawEllipse(System.Windows.Media.Brushes.Black, null, balls[i].getPosition(), balls[i].getRadius()-2, balls[i].getRadius()-2);
balls[i].update();
}
for (int i = 0; i < balls.Length; i++)
{
for (int j = 0; j < balls.Length; j++)
{
if (i != j)
{
balls[i].checkBallCollision(balls[j]);
}
}
}
MrSpooks spooks = new MrSpooks();
if (skeletons.Length != 0)
{
foreach (Skeleton skel in skeletons)
{
//RenderClippedEdges(skel, dc);
if (skel.TrackingState == SkeletonTrackingState.Tracked)
{
this.DrawBonesAndJoints(skel, dc, spooks);
spooks.newId();
}
}
}
//Fixes Disapearing Ball Glitch
for (int i = 0; i < balls.Length; i++)
{
if (Double.IsNaN(balls[i].getPosition().X) || Double.IsNaN(balls[i].getPosition().Y))
{
System.Windows.Point ErrorPoint = new System.Windows.Point();
ErrorPoint.X = (float)ran.Next((int)RenderWidth);
ErrorPoint.Y = (float)ran.Next((int)RenderHeight);
balls[i].position = ErrorPoint;
balls[i].dX = 0;
balls[i].dY = 0;
balls[i].ax = 0;
balls[i].ay = 0;
}
}
// prevent drawing outside of our render area
this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight));
}
}
void skeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
canvas1.Children.Clear();
advanceThingPosition();
canvas1.Children.Add(thing.Shape);
using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
{
if (skeletonFrame == null)
{
return;
}
skeletonFrame.CopySkeletonDataTo(totalSkeleton);
skeleton = (from trackskeleton in totalSkeleton
where trackskeleton.TrackingState == SkeletonTrackingState.Tracked
select trackskeleton).FirstOrDefault();
if (skeleton == null)
{
return;
}
if (skeleton != null && this.currentSkeletonID != skeleton.TrackingId)
{
this.currentSkeletonID = skeleton.TrackingId;
int totalTrackedJoints = skeleton.Joints.Where(item => item.TrackingState == JointTrackingState.Tracked).Count();
string TrackedTime = DateTime.Now.ToString("hh:mm:ss");
string status = "Skeleton Id: " + this.currentSkeletonID + ", total tracked joints: " + totalTrackedJoints + ", TrackTime: " + TrackedTime + "\n";
this.textBlock1.Text += status;
}
DrawSkeleton(skeleton);
}
Point handPt = ScalePosition(skeleton.Joints[JointType.HandRight].Position);
if (thing.Hit(handPt))
{
//this.thing.YVelocity = -1.0 * this.thing.YVelocity;
//this.thing.XVelocity = -1.0 * this.thing.YVelocity;
this.thing.YVelocity = (-2.0) * this.thing.YVelocity *
Math.Abs(thing.Center.Y - handPt.Y) / (Math.Abs(thing.Center.Y - handPt.Y) + Math.Abs(thing.Center.X - handPt.X));
this.thing.XVelocity = (-2.0) * this.thing.YVelocity *
Math.Abs(thing.Center.X - handPt.X) / (Math.Abs(thing.Center.Y - handPt.Y) + Math.Abs(thing.Center.X - handPt.X));
if (flag_release == 0)
{
count = count + 1;
flag_release = 1;
}
this.textBlock_count.Text = count.ToString();
}
Point handPtLeft = ScalePosition(skeleton.Joints[JointType.HandLeft].Position);
if (thing.Hit(handPtLeft))
{
//this.thing.YVelocity = -1.0 * this.thing.YVelocity;
//this.thing.XVelocity = -1.0 * this.thing.YVelocity;
this.thing.YVelocity = (-2.0) * this.thing.YVelocity *
Math.Abs(thing.Center.Y - handPtLeft.Y) / (Math.Abs(thing.Center.Y - handPtLeft.Y) + Math.Abs(thing.Center.X - handPtLeft.X));
this.thing.XVelocity = (-2.0) * this.thing.YVelocity *
Math.Abs(thing.Center.X - handPtLeft.X) / (Math.Abs(thing.Center.Y - handPtLeft.Y) + Math.Abs(thing.Center.X - handPtLeft.X));
if (flag_release == 0)
{
count = count + 1;
flag_release = 1;
}
this.textBlock_count.Text = count.ToString();
}
Point joint1 = this.ScalePosition(skeleton.Joints[JointType.WristRight].Position);
if (thing.Center.Y - joint1.Y < -50)
{
flag_release = 0;
}
}
//骨架追踪
void kinectSensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
bool receivedData = false;
using (SkeletonFrame SFrame = e.OpenSkeletonFrame())
{
if (SFrame == null)
{
Console.WriteLine("Skeleton Frame null");
// The image processing took too long. More than 2 frames behind.
}
else
{
//Console.WriteLine("Skeleton Frame Exist");
frameSkeletons = new Skeleton[SFrame.SkeletonArrayLength];
SFrame.CopySkeletonDataTo(frameSkeletons);
receivedData = true;
Polyline figure;
Brush userBrush;
Skeleton skeleton;
LayoutRoot.Children.Clear();
SFrame.CopySkeletonDataTo(this.frameSkeletons);
for (int i = 0; i < this.frameSkeletons.Length; i++)
{
skeleton = this.frameSkeletons[i];
if (skeleton.TrackingState == SkeletonTrackingState.Tracked)
{
userBrush = this.skeletonBrushes[i % this.skeletonBrushes.Length];
//绘制头和躯干
figure = CreateFigure(skeleton, userBrush, new[] { JointType.Head, JointType.ShoulderCenter,
JointType.ShoulderLeft, JointType.Spine,
JointType.ShoulderRight, JointType.ShoulderCenter,
JointType.HipCenter });
LayoutRoot.Children.Add(figure);
figure = CreateFigure(skeleton, userBrush, new[] { JointType.HipLeft, JointType.HipRight });
LayoutRoot.Children.Add(figure);
//绘制作腿
figure = CreateFigure(skeleton, userBrush, new[] { JointType.HipCenter, JointType.HipLeft,
JointType.KneeLeft, JointType.AnkleLeft, JointType.FootLeft });
LayoutRoot.Children.Add(figure);
//绘制右腿
figure = CreateFigure(skeleton, userBrush, new[] { JointType.HipCenter, JointType.HipRight,
JointType.KneeRight, JointType.AnkleRight, JointType.FootRight });
LayoutRoot.Children.Add(figure);
//绘制左臂
figure = CreateFigure(skeleton, userBrush, new[] { JointType.ShoulderLeft, JointType.ElbowLeft,
JointType.WristLeft, JointType.HandLeft });
LayoutRoot.Children.Add(figure);
//绘制右臂
figure = CreateFigure(skeleton, userBrush, new[] { JointType.ShoulderRight, JointType.ElbowRight,
JointType.WristRight, JointType.HandRight });
LayoutRoot.Children.Add(figure);
}
}
}
}
Polyline CreateFigure(Skeleton skeleton, Brush brush, JointType[] joints)
{
Polyline figure = new Polyline();
figure.StrokeThickness = 8;
figure.Stroke = brush;
for (int i = 0; i < joints.Length; i++)
{
figure.Points.Add(GetJointPoint(skeleton.Joints[joints[i]]));
}
return(figure);
}
Point GetJointPoint(Joint joint)
{
ColorImagePoint point = this.sensor.CoordinateMapper.MapSkeletonPointToColorPoint(joint.Position, this.sensor.ColorStream.Format);
point.X *= (int)this.LayoutRoot.ActualWidth / sensor.DepthStream.FrameWidth;
point.Y *= (int)this.LayoutRoot.ActualHeight / sensor.DepthStream.FrameHeight;
return(new Point(point.X, point.Y));
}
if (receivedData)
{
Skeleton currentSkeleton = (from s in frameSkeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
if (currentSkeleton != null)
{
//Console.WriteLine("检测到骨架");
//获取关节点
Joint jointRight = currentSkeleton.Joints[JointType.HandRight];
Joint jointLeft = currentSkeleton.Joints[JointType.HandLeft];
Joint jointElbowRight = currentSkeleton.Joints[JointType.ElbowRight];
Joint jointElbowLeft = currentSkeleton.Joints[JointType.ElbowLeft];
Joint jointShoulderRight = currentSkeleton.Joints[JointType.ShoulderRight];
Joint jointShoulderLeft = currentSkeleton.Joints[JointType.ShoulderLeft];
Joint jointHead = currentSkeleton.Joints[JointType.Head];
Joint jointSpine = currentSkeleton.Joints[JointType.Spine];
Joint jointFootRight = currentSkeleton.Joints[JointType.FootRight];
Joint jointFootLeft = currentSkeleton.Joints[JointType.FootLeft];
//控制键盘---多次点击
//if (jointRight.Position.Y > 0.7)
//{
// System.Windows.Forms.SendKeys.SendWait("b");
//}
//控制键盘---持续点击
if (flag == 1)
{
bool Know = jointLeft.Position.Z - jointShoulderLeft.Position.Z < -0.45;
if (Know && !Klast)
{
keybd_event(75, 0, 0, 0);
}
if (!Know && Klast)
{
keybd_event(75, 0, 2, 0);
}
Klast = Know;
bool Bnow = jointRight.Position.Y > 0.7;
if (Bnow && !Blast)
{
keybd_event(66, 0, 0, 0);
}
if (!Bnow && Blast)
{
keybd_event(66, 0, 2, 0);
}
Blast = Bnow;
bool Jnow = jointRight.Position.Z - jointShoulderRight.Position.Z < -0.45;
if (Jnow && !Jlast)
{
keybd_event(74, 0, 0, 0);
}
if (!Jnow && Jlast)
{
keybd_event(74, 0, 2, 0);
}
Jlast = Jnow;
bool Wnow = jointLeft.Position.Y > 0.5;
if (Wnow && !Wlast)
{
keybd_event(87, 0, 0, 0);
}
if (!Wnow && Wlast)
{
keybd_event(87, 0, 2, 0);
}
Wlast = Wnow;
bool Snow = jointLeft.Position.Y < 0;
if (Snow && !Slast)
{
keybd_event(83, 0, 0, 0);
}
if (!Snow && Slast)
{
keybd_event(83, 0, 2, 0);
}
Slast = Snow;
bool Dnow = jointLeft.Position.X - jointSpine.Position.X > -0.2;
if (Dnow && !Dlast)
{
keybd_event(68, 0, 0, 0);
}
if (!Dnow && Dlast)
{
keybd_event(68, 0, 2, 0);
}
Dlast = Dnow;
bool Anow = jointLeft.Position.X - jointSpine.Position.X < -0.5;
if (Anow && !Alast)
{
keybd_event(65, 0, 0, 0);
}
if (!Anow && Alast)
{
keybd_event(65, 0, 2, 0);
}
Alast = Anow;
}
else if (flag == 2)
{
bool Onow = (jointLeft.Position.Y > 0.7) && (jointRight.Position.Y > 0.7);
if (Onow && !Olast)
{
keybd_event(79, 0, 0, 0);
}
if (!Onow && Olast)
{
keybd_event(79, 0, 2, 0);
}
Olast = Onow;
bool Unow = jointLeft.Position.X - jointSpine.Position.X < -0.5;
if (Unow && !Ulast)
{
keybd_event(85, 0, 0, 0);
}
if (!Unow && Ulast)
{
keybd_event(85, 0, 2, 0);
}
Ulast = Unow;
bool Inow = jointFootLeft.Position.Z - jointSpine.Position.Z < -0.6;
if (Inow && !Ilast)
{
keybd_event(73, 0, 0, 0);
}
if (!Inow && Ilast)
{
keybd_event(73, 0, 2, 0);
}
Ilast = Inow;
bool Know = jointFootRight.Position.Z - jointSpine.Position.Z < -0.6;
if (Know && !Klast)
{
keybd_event(75, 0, 0, 0);
}
if (!Know && Klast)
{
keybd_event(75, 0, 2, 0);
}
Klast = Know;
bool Jnow = jointRight.Position.X - jointSpine.Position.X > 0.5;
if (Jnow && !Jlast)
{
keybd_event(74, 0, 0, 0);
}
if (!Jnow && Jlast)
{
keybd_event(74, 0, 2, 0);
}
Jlast = Jnow;
bool Wnow = ((jointSpine.Position.Y - SpineY) * 100 > 1) && (jointSpine.Position.Y > 0);
if (Wnow && !Wlast)
{
keybd_event(87, 0, 0, 0);
}
if (!Wnow && Wlast)
{
keybd_event(87, 0, 2, 0);
}
Wlast = Wnow;
bool Snow = ((jointSpine.Position.Y - SpineY) * 100 < -1);
if (Snow && !Slast)
{
keybd_event(83, 0, 0, 0);
}
if (!Snow && Slast)
{
keybd_event(83, 0, 2, 0);
}
Slast = Snow;
SpineY = jointSpine.Position.Y;
bool Dnow = (jointSpine.Position.X - SpineX) * 100 > 1;
if (Dnow && !Dlast)
{
keybd_event(68, 0, 0, 0);
}
if (!Dnow && Dlast)
{
keybd_event(68, 0, 2, 0);
}
Dlast = Dnow;
bool Anow = (jointSpine.Position.X - SpineX) * 100 < -1;
if (Anow && !Alast)
{
keybd_event(65, 0, 0, 0);
}
if (!Anow && Alast)
{
keybd_event(65, 0, 2, 0);
}
Alast = Anow;
SpineX = jointSpine.Position.X;
}
}
else
{
//Console.WriteLine("未检测到骨架");
}
}
}
