private void RaiseHandStateChanged(KinectBody body, HandType handType, HandState previousState) { if (this.HandStateChanged != null) { this.HandStateChanged(this, new KinectHandStateEventArgs(body, handType, previousState)); } }
public void TestTrackingLostRaised() { List <ulong> found = new List <ulong>(); BodyTrackingProcessor processor = new BodyTrackingProcessor(); ulong lostBodyId = 256; var firstFrame = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(lostBodyId, true), FakeBodies.FakeRandomBody(32, false) }; processor.Next(firstFrame); //Register to event now processor.BodyTrackingLost += (s, e) => found.Add(e.Body.TrackingId); ulong newBodyId = 17; var secondFrame = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(newBodyId, true), }; processor.Next(secondFrame); Assert.AreEqual(found.Count, 1); Assert.AreEqual(found.Contains(lostBodyId), true); }
public void TestMultipleClosest() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10, true, new CameraSpacePoint() { Z = 0.2f }), FakeBodies.FakeSpineBody(20, true, new CameraSpacePoint() { Z = 0.02f }), FakeBodies.FakeSpineBody(30, true, new CameraSpacePoint() { Z = 0.02f }), FakeBodies.FakeSpineBody(40, true, new CameraSpacePoint() { Z = 0.7f }) }; var closest = bodies.ClosestBodies().ToArray(); Assert.AreEqual(closest.Length, 2); Assert.AreEqual(closest.Contains(bodies[1]), true); Assert.AreEqual(closest.Contains(bodies[2]), true); }
private void OnBodyEnter(KinectBody body) { if (EventBodyEnter != null) { EventBodyEnter(body); } }
public Body Merge(KinectBody body, string sourceId) { var result = new Body { BodyType = Body.EBodyType.Skeleton }; var kinectPosition = _adapterTracker.Locate(sourceId); Logger.Debug("OptiTrack KinectPos X: {0}", kinectPosition.Location.X); Logger.Debug("OptiTrack KinectPos Y: {0}", kinectPosition.Location.Y); Logger.Debug("OptiTrack KinectPos Z: {0}", kinectPosition.Location.Z); foreach (var point in body.Points) { var globalPosition = _transformator.GetGlobalPosition(kinectPosition, point.Position); var resultPoint = new Point(globalPosition) { Name = point.Name, State = point.State }; result.Points.Add(resultPoint); } Logger.Debug("Result After Transform {0}", result); return(result); }
public void TestSingleCenter() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10, true, new CameraSpacePoint() { X = 0.2f, }), FakeBodies.FakeSpineBody(20, true, new CameraSpacePoint() { X = 0.1f, }), FakeBodies.FakeSpineBody(30, true, new CameraSpacePoint() { X = 0.01f, }), FakeBodies.FakeSpineBody(40, true, new CameraSpacePoint() { X = 0.7f }) }; var closest = bodies.CenterBodies().ToArray(); Assert.AreEqual(closest.Length, 1); Assert.AreEqual(closest[0], bodies[2]); }
public void TestMultipleCenter() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10, true, new CameraSpacePoint() { X = 0.2f }), FakeBodies.FakeSpineBody(20, true, new CameraSpacePoint() { X = -0.02f //Center is an absolute value, so 1 and 2 should be same distance }), FakeBodies.FakeSpineBody(30, true, new CameraSpacePoint() { X = 0.02f }), FakeBodies.FakeSpineBody(40, true, new CameraSpacePoint() { X = 0.7f }) }; var closest = bodies.CenterBodies().ToArray(); Assert.AreEqual(closest.Length, 2); Assert.AreEqual(closest.Contains(bodies[1]), true); Assert.AreEqual(closest.Contains(bodies[2]), true); }
public void TestSerialize() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10, true, new CameraSpacePoint() { X = 0.2f }), FakeBodies.FakeSpineBody(20, true, new CameraSpacePoint() { X = -0.02f //Center is an absolute value, so 1 and 2 should be same distance }), FakeBodies.FakeSpineBody(30, true, new CameraSpacePoint() { X = 0.02f }), FakeBodies.FakeSpineBody(40, true, new CameraSpacePoint() { X = 0.7f }) }; string json = JsonSerializer.ToJson(bodies); var deserialize = JsonSerializer.FromJson(json); Assert.AreEqual(deserialize.Count(), 4); }
public void TestSecondFrameNewBody() { List<ulong> found = new List<ulong>(); BodyTrackingProcessor processor = new BodyTrackingProcessor(); var firstFrame = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(256, true), FakeBodies.FakeRandomBody(32, false) }; processor.Next(firstFrame); //Register to event now processor.BodyTrackingStarted += (s, e) => found.Add(e.Body.TrackingId); ulong newBodyId = 17; var secondFrame = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(newBodyId, true), }; processor.Next(secondFrame); Assert.AreEqual(found.Count, 1); Assert.AreEqual(found.Contains(newBodyId), true); }
private void RaiseBodyTrackingStarted(KinectBody body) { if (this.BodyTrackingStarted != null) { this.BodyTrackingStarted(this, new KinectBodyEventArgs(body)); } }
public void TestSerialize() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10,true, new CameraSpacePoint() { X = 0.2f }), FakeBodies.FakeSpineBody(20,true, new CameraSpacePoint() { X = -0.02f //Center is an absolute value, so 1 and 2 should be same distance }), FakeBodies.FakeSpineBody(30,true, new CameraSpacePoint() { X = 0.02f }), FakeBodies.FakeSpineBody(40,true, new CameraSpacePoint() { X = 0.7f }) }; string json = JsonSerializer.ToJson(bodies); var deserialize = JsonSerializer.FromJson(json); Assert.AreEqual(deserialize.Count(), 4); }
private void RaiseBodyTrackingLost(KinectBody body) { if (this.BodyTrackingLost != null) { this.BodyTrackingLost(this, new KinectBodyEventArgs(body)); } }
public void TestUploadEmpty() { using (BodyCameraPositionBuffer buffer = new BodyCameraPositionBuffer(device)) { KinectBody[] empty = new KinectBody[0]; buffer.Copy(device.ImmediateContext, empty); } }
public void TestUploadEmpty() { using (BodyJointStatusBuffer buffer = new BodyJointStatusBuffer(device)) { KinectBody[] empty = new KinectBody[0]; buffer.Copy(device.ImmediateContext, empty); } }
public void TestValidLeftOpen() { KinectBody body = FakeBodies.FakeRandomBody(128, true); var args = new KinectHandStateEventArgs(body, HandType.Left, Microsoft.Kinect.HandState.Open); Assert.AreEqual(body, args.Body); Assert.AreEqual(HandType.Left, args.HandType); Assert.AreEqual(Microsoft.Kinect.HandState.Open, args.PreviousHandState); }
public void TestValidRightClosed() { KinectBody body = FakeBodies.FakeRandomBody(128, true); var args = new KinectHandStateEventArgs(body, HandType.Right, Microsoft.Kinect.HandState.Closed); Assert.AreEqual(body, args.Body); Assert.AreEqual(HandType.Right, args.HandType); Assert.AreEqual(Microsoft.Kinect.HandState.Closed, args.PreviousHandState); }
/// <summary> /// Returns camera space matching for left hand, if in tracked state for each KinectBody /// </summary> /// <param name="body1">First body</param> /// <param name="body2">Second Body</param> /// <param name="jointType">Joint type to check</param> /// <returns>Camera to camera point, or empty enumeration if hand is not tracked</returns> public static IEnumerable <CameraToCameraPoint> YieldIfTracked(KinectBody body1, KinectBody body2, JointType jointType) { var j1 = body1.Joints[jointType]; var j2 = body2.Joints[jointType]; if (j1.TrackingState == TrackingState.Tracked && j2.TrackingState == TrackingState.Tracked) { yield return(new CameraToCameraPoint(j1.Position.ToVector3(), j2.Position.ToVector3())); } }
/// <summary> /// Returns camera space matching for left hand, if in tracked state for each KinectBody /// </summary> /// <param name="body1">First body</param> /// <param name="body2">Second Body</param> /// <param name="jointType">Joint type to check</param> /// <returns>Camera to camera point, or empty enumeration if hand is not tracked</returns> public static IEnumerable<CameraToCameraPoint> YieldIfTracked(KinectBody body1, KinectBody body2, JointType jointType) { var j1 = body1.Joints[jointType]; var j2 = body2.Joints[jointType]; if (j1.TrackingState == TrackingState.Tracked && j2.TrackingState == TrackingState.Tracked) { yield return new CameraToCameraPoint(j1.Position.ToVector3(), j2.Position.ToVector3()); } }
void UpdateBodies() { for (int i = 0; i < MaxNumPlayers; i++) { GameObject g = GameObject.Find("player_" + KinectBodyContainers[i].id[0]); if (g) { KinectBody kb = g.GetComponent <KinectBody>(); if (kb) { kb.Copy(KinectBodyContainers[i]); kb.UpdateJoints(); } } //if we didn't find it, lets make a new game object else { if (KinectBodyContainers[i].id[0] != 0) { g = new GameObject("player_" + KinectBodyContainers[i].id[0]); g.transform.parent = this.transform; //reset tranforms? g.transform.localPosition = new Vector3(0, 0, 0); g.transform.localRotation = new Quaternion(); g.transform.localScale = new Vector3(1, 1, 1); KinectBody kb = g.AddComponent <KinectBody>(); kb.SetupBody(this); Players.Add(g); } } } //now cleanup Transform[] allChildren = this.GetComponentsInChildren <Transform>(); foreach (Transform child in allChildren) { GameObject g = child.gameObject; if (g) { KinectBody kb = g.GetComponent <KinectBody>(); if (kb) { // Debug.Log(g.name + ":" + (Time.time - kb.updateTime)); if (Time.time - kb.updateTime > RemovalTime) { Destroy(g); } } } } }
public void TestDuplicateHead() { KinectBodyInternal body = FakeInternalBodies.DuplicateHead(); try { KinectBody kb = new KinectBody(body); Assert.Fail(); //Fail if no exception is raised } catch (DuplicateJointException ex) { Assert.AreEqual(ex.Joint, JointType.Head); } }
public void KinectBodyTestValid() { KinectBody[] data = new KinectBody[] { Fakes.FakeBodies.FakeRandomBody(128, true), Fakes.FakeBodies.FakeRandomBody(129, true) }; KinectBodyFrameDataEventArgs args = new KinectBodyFrameDataEventArgs(data); Assert.AreEqual(args.FrameData[0], data[0]); Assert.AreEqual(args.FrameData[1], data[1]); }
public void Copy(KinectBody k) { id[0] = k.id[0]; Buffer.BlockCopy(k.jointPos, 0, jointPos, 0, sizeof(float) * NumJoints * 4); Buffer.BlockCopy(k.jointRots, 0, jointRots, 0, sizeof(float) * NumJoints * 4); Buffer.BlockCopy(k.hands, 0, hands, 0, sizeof(int) * 2); //set the update time updateTime = Time.time; //now set the data to be invalid as we have already copied it in k.id[0] = 0; }
void ParseBodies() { //Debug.Log("KinectAPI: Parsing bodies " + parseStream.Length); using (BinaryReader reader = new BinaryReader(parseStream, Encoding.Default)) { // parse bodies Bodies.Clear(); BodyCount = reader.ReadUInt16(); for (int i = 0; i < 6; i++) { UInt64 trackingId = reader.ReadUInt64(); TrackingIds[i] = trackingId; } // read in joint positions for (int b = 0; b < 6; b++) { KinectBody body = new KinectBody(); for (int j = 0; j < 25; j++) { body.JointPositions.Add( new Vector3( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle())); } Bodies.Add(body); } // read in hand states for (int b = 0; b < 6; b++) { Bodies[b].LeftHandState = (HandState)reader.ReadByte(); Bodies[b].RightHandState = (HandState)reader.ReadByte(); } // read in joint orientations for (int b = 0; b < 6; b++) { for (int j = 0; j < 25; j++) { Bodies[b].JointOrientations.Add( new Vector4( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle())); } } } }
/// <summary> /// Acquires a face processor for a Kinect body /// </summary> /// <param name="body">Kinect body</param> /// <remarks>For now we only allow one processor per kinect body id</remarks> /// <returns>Face processor</returns> public SingleHdFaceProcessor Acquire(KinectBody body) { if (this.idleProcessors.Count == 0) throw new Exception("Pool is empty"); if (this.activeProcessors.ContainsKey(body.TrackingId)) throw new ArgumentException("body", "processor has already been allocated for this body tracking id"); var processor = this.idleProcessors[this.idleProcessors.Count - 1]; processor.AssignBody(body); this.idleProcessors.RemoveAt(this.idleProcessors.Count - 1); this.activeProcessors.Add(body.TrackingId, processor); return processor; }
/// <summary> /// Maps the information received for a Body from the Kinect to a /// KinectBody we can serialize and send over the wire. /// </summary> /// <param name="body">Body to map</param> /// <param name="sensorId">Sensor ID, or any other value being used as the device connection Id</param> /// <returns>Mapped KinectBody containing the body information, /// an identifier, and othe processed data</returns> private static KinectBody MapBody(Body body, string sensorId) { var d = new KinectBody(sensorId, body.TrackingId); // All six bodies are fully tracked. Wee! var jointCount = Enum.GetNames(typeof(KinectJointType)).Length; d.Joints = new KinectJoint[jointCount]; for (var i = 0; i < jointCount; i++) { var nativeJoint = body.Joints[(JointType)i]; var orientation = body.JointOrientations[(JointType)i].Orientation; var joint = new KinectJoint { TrackingState = ((KinectTrackingState)(int)nativeJoint.TrackingState), Position = new KinectVector3 { X = nativeJoint.Position.X, Y = nativeJoint.Position.Y, Z = nativeJoint.Position.Z }, JointType = ((KinectJointType)(int)nativeJoint.JointType), Orientation = new KinectVector4 { W = orientation.W, X = orientation.X, Y = orientation.Y, Z = orientation.Z } }; d.Joints[i] = joint; } d.Lean = new KinectPoint { X = body.Lean.X, Y = body.Lean.Y }; d.LeanTrackingState = (KinectTrackingState)(int)body.LeanTrackingState; // Record hand states d.HandLeftState = (KinectHandState)(int)body.HandLeftState; d.HandRightState = (KinectHandState)(int)body.HandRightState; // Record hand confidence. Initially we'll just convert the enum to an int, // but we could do some exponential smoothing between their {0,1} values. d.HandLeftConfidence = (int)body.HandLeftConfidence; d.HandRightConfidence = (int)body.HandRightConfidence; return(d); }
public 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); // Copy skeelton data to the array List <VinteR.Model.Point> jointList = new List <VinteR.Model.Point>(); MocapFrame frame = new MocapFrame(adapter.Config.Name, adapter.Config.AdapterType); // loop through all skeltons foreach (Skeleton skeleton in skeletons) { if (this._config.SkeletonTrackingStateFilter) { if (!(skeleton.TrackingState == SkeletonTrackingState.Tracked)) // if the skeleton is not tracked skip { continue; } } foreach (Microsoft.Kinect.Joint joint in skeleton.Joints) { // Create a Point Vector3 position = new Vector3(joint.Position.X, joint.Position.Y, joint.Position.Z) * MillimetersMultiplier; VinteR.Model.Point currentPointModel = new VinteR.Model.Point(position); currentPointModel.Name = joint.JointType.ToString(); currentPointModel.State = joint.TrackingState.ToString(); // Add the Point to the List of all captured skeleton points jointList.Add(currentPointModel); } // Create and append the frame Body body = new KinectBody(jointList, Body.EBodyType.Skeleton); body.Name = skeleton.TrackingId.ToString(); frame.AddBody(ref body); } this.adapter.OnFrameAvailable(frame); // publish MocapFrame } } }
public void TestFindByIdFalse() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeRandomBody(10,true), FakeBodies.FakeRandomBody(20,true), FakeBodies.FakeRandomBody(30,false), FakeBodies.FakeRandomBody(40,true), FakeBodies.FakeRandomBody(50,true), FakeBodies.FakeRandomBody(60,false), }; var nomatch = FakeBodies.FakeRandomBody(128, false); Assert.AreEqual(nomatch.FindById(bodies), null); }
public void TestFindById() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeRandomBody(10,true), FakeBodies.FakeRandomBody(20,true), FakeBodies.FakeRandomBody(30,false), FakeBodies.FakeRandomBody(40,true), FakeBodies.FakeRandomBody(50,true), FakeBodies.FakeRandomBody(60,false), }; var match0 = FakeBodies.FakeRandomBody(30, false); Assert.AreEqual(match0.FindById(bodies), bodies[2]); }
public void TestTrackingFirstRaised() { bool isRaised = false; BodyTrackingProcessor processor = new BodyTrackingProcessor(); processor.BodyTrackingStarted += (s, e) => isRaised = true; var dataSet = new KinectBody[] { FakeBodies.FakeRandomBody(128, true) }; processor.Next(dataSet); Assert.AreEqual(isRaised, true); }
public void TestFindById() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeRandomBody(10, true), FakeBodies.FakeRandomBody(20, true), FakeBodies.FakeRandomBody(30, false), FakeBodies.FakeRandomBody(40, true), FakeBodies.FakeRandomBody(50, true), FakeBodies.FakeRandomBody(60, false), }; var match0 = FakeBodies.FakeRandomBody(30, false); Assert.AreEqual(match0.FindById(bodies), bodies[2]); }
public void TestValid() { KinectBodyInternal body = FakeInternalBodies.SimpleValidBody(); KinectBody kb = new KinectBody(body); Assert.AreEqual(body.ClippedEdges, kb.ClippedEdges); Assert.AreEqual(body.HandLeftConfidence, kb.HandLeftConfidence); Assert.AreEqual(body.HandLeftState, kb.HandLeftState); Assert.AreEqual(body.HandRightConfidence, kb.HandRightConfidence); Assert.AreEqual(body.HandRightState, kb.HandRightState); Assert.AreEqual(body.IsRestricted, kb.IsRestricted); Assert.AreEqual(body.IsTracked, kb.IsTracked); Assert.AreEqual(body.Lean, kb.Lean); Assert.AreEqual(body.LeanTrackingState, kb.LeanTrackingState); Assert.AreEqual(body.TrackingId, kb.TrackingId); }
public void TestFindByIdFalse() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeRandomBody(10, true), FakeBodies.FakeRandomBody(20, true), FakeBodies.FakeRandomBody(30, false), FakeBodies.FakeRandomBody(40, true), FakeBodies.FakeRandomBody(50, true), FakeBodies.FakeRandomBody(60, false), }; var nomatch = FakeBodies.FakeRandomBody(128, false); Assert.AreEqual(nomatch.FindById(bodies), null); }
public void TestContainsId() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeRandomBody(10,true), FakeBodies.FakeRandomBody(20,true), FakeBodies.FakeRandomBody(30,false), FakeBodies.FakeRandomBody(40,true), FakeBodies.FakeRandomBody(50,true), FakeBodies.FakeRandomBody(60,false), }; var match0 = FakeBodies.FakeRandomBody(10, false); Assert.AreEqual(match0.ContainsId(bodies), true); var match1 = FakeBodies.FakeRandomBody(40, false); Assert.AreEqual(match1.ContainsId(bodies), true); }
/// <summary> /// Acquires a face processor for a Kinect body /// </summary> /// <param name="body">Kinect body</param> /// <remarks>For now we only allow one processor per kinect body id</remarks> /// <returns>Face processor</returns> public SingleHdFaceProcessor Acquire(KinectBody body) { if (this.idleProcessors.Count == 0) { throw new Exception("Pool is empty"); } if (this.activeProcessors.ContainsKey(body.TrackingId)) { throw new ArgumentException("body", "processor has already been allocated for this body tracking id"); } var processor = this.idleProcessors[this.idleProcessors.Count - 1]; processor.AssignBody(body); this.idleProcessors.RemoveAt(this.idleProcessors.Count - 1); this.activeProcessors.Add(body.TrackingId, processor); return(processor); }
/// <summary> /// Converts body to it's internal representation /// </summary> /// <param name="body">Body to convert</param> /// <returns>Converted body</returns> public static KinectBodyInternal Convert(KinectBody body) { KinectBodyInternal result = new KinectBodyInternal() { ClippedEdges = body.ClippedEdges, HandLeftConfidence = body.HandLeftConfidence, HandLeftState = body.HandLeftState, HandRightConfidence = body.HandRightConfidence, HandRightState = body.HandRightState, IsRestricted = body.IsRestricted, IsTracked = body.IsTracked, JointOrientations = body.JointOrientations.Select(kvp => kvp.Value).ToArray(), Joints = body.Joints.Select(kvp => kvp.Value).ToArray(), Lean = body.Lean, LeanTrackingState = body.LeanTrackingState, TrackingId = body.TrackingId }; return result; }
protected override bool ProcessBody(KinectBody body) { // If at least three of the arm joints are inferred, as assume there's no arm var inferredCount = body.Joints.Count(x => x.TrackingState == KinectTrackingState.Inferred && (x.JointType == KinectJointType.ElbowLeft || x.JointType == KinectJointType.WristLeft || x.JointType == KinectJointType.HandLeft || x.JointType == KinectJointType.HandTipLeft || x.JointType == KinectJointType.ThumbLeft)); var isMissing = inferredCount >= 4; if (isMissing) { body.Tags.Add("LeftArmMissing"); } return(isMissing); }
private void RefreshBodyObject(KinectBody body, GameObject bodyObject) { for (int j = 0; j < 25; j++) { Vector3 sourceJoint = body.JointPositions[j]; Vector3?targetJoint = null; if (_BoneMap.ContainsKey(j)) { targetJoint = body.JointPositions[_BoneMap[j]]; } Transform jointObj = bodyObject.transform.FindChild("jt" + j); //Debug.Log("BodyView: RefreshBodyObject: " + sourceJoint); jointObj.localPosition = sourceJoint * 10.0f; LineRenderer lr = jointObj.GetComponent <LineRenderer>(); if (targetJoint.HasValue) { lr.SetPosition(0, jointObj.localPosition); lr.SetPosition(1, targetJoint.Value * 10.0f); lr.SetColors(Color.red, Color.red); Debug.Log(body.LeftHandState + ", " + body.RightHandState); if (j == 7 && body.LeftHandState == HandState.HandState_Closed) { jointObj.localScale = new Vector3(2, 2, 2); } else if (j == 11 && body.RightHandState == HandState.HandState_Closed) { jointObj.localScale = new Vector3(2, 2, 2); } else { jointObj.localScale = new Vector3(0.3f, 0.3f, 0.3f); } } else { lr.enabled = false; } } }
public void TestTrackingLeftHandClose() { var initial = new KinectBody[] { FakeBodies.BodyWithLeftHandState(128, TrackingConfidence.High, HandState.Open) }; var next = new KinectBody[] { FakeBodies.BodyWithLeftHandState(128, TrackingConfidence.High, HandState.Closed) }; bool pass = false; HandStateTrackingProcessor processor = new HandStateTrackingProcessor(); processor.Next(initial); processor.HandStateChanged += (sender, args) => pass = args.Body == next[0] && args.HandType == HandType.Left && args.PreviousHandState == HandState.Open; processor.Next(next); Assert.AreEqual(pass, true); }
/// <summary> /// Converts body to it's internal representation /// </summary> /// <param name="body">Body to convert</param> /// <returns>Converted body</returns> public static KinectBodyInternal Convert(KinectBody body) { KinectBodyInternal result = new KinectBodyInternal() { ClippedEdges = body.ClippedEdges, HandLeftConfidence = body.HandLeftConfidence, HandLeftState = body.HandLeftState, HandRightConfidence = body.HandRightConfidence, HandRightState = body.HandRightState, IsRestricted = body.IsRestricted, IsTracked = body.IsTracked, JointOrientations = body.JointOrientations.Select(kvp => kvp.Value).ToArray(), Joints = body.Joints.Select(kvp => kvp.Value).ToArray(), Lean = body.Lean, LeanTrackingState = body.LeanTrackingState, TrackingId = body.TrackingId }; return(result); }
public void TestFirstFrame2in1out() { List<ulong> found = new List<ulong>(); BodyTrackingProcessor processor = new BodyTrackingProcessor(); processor.BodyTrackingStarted += (s, e) => found.Add(e.Body.TrackingId); var dataSet = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(256, true), FakeBodies.FakeRandomBody(32, false) }; processor.Next(dataSet); Assert.AreEqual(found.Count, 2); Assert.AreEqual(found.Contains(128), true); Assert.AreEqual(found.Contains(256), true); }
public void NewBodyDontRaiseEvent() { var initial = new KinectBody[] { FakeBodies.BodyWithRightHandState(128, TrackingConfidence.High, HandState.Open) }; var next = new KinectBody[] { FakeBodies.BodyWithRightHandState(142, TrackingConfidence.High, HandState.Closed) }; bool pass = true; HandStateTrackingProcessor processor = new HandStateTrackingProcessor(); processor.Next(initial); processor.HandStateChanged += (sender, args) => pass = false; processor.Next(next); Assert.AreEqual(pass, true); }
public void TestTrackingLeftHandNoChange() { var initial = new KinectBody[] { FakeBodies.BodyWithLeftHandState(128, TrackingConfidence.High, HandState.Open) }; var next = new KinectBody[] { FakeBodies.BodyWithLeftHandState(128, TrackingConfidence.High, HandState.Open) }; bool pass = true; HandStateTrackingProcessor processor = new HandStateTrackingProcessor(); processor.Next(initial); processor.HandStateChanged += (sender, args) => pass = false; processor.Next(next); Assert.AreEqual(pass, true); }
public void TestNullOrientations() { KinectBodyInternal body = FakeInternalBodies.NullOrientationsBody(); KinectBody kb = new KinectBody(body); }
public void TestMultipleClosest() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10,true, new CameraSpacePoint() { Z = 0.2f }), FakeBodies.FakeSpineBody(20,true, new CameraSpacePoint() { Z = 0.02f }), FakeBodies.FakeSpineBody(30,true, new CameraSpacePoint() { Z = 0.02f }), FakeBodies.FakeSpineBody(40,true, new CameraSpacePoint() { Z = 0.7f }) }; var closest = bodies.ClosestBodies().ToArray(); Assert.AreEqual(closest.Length, 2); Assert.AreEqual(closest.Contains(bodies[1]), true); Assert.AreEqual(closest.Contains(bodies[2]), true); }
public void TestTrackedOnly() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeRandomBody(10,true), FakeBodies.FakeRandomBody(20,true), FakeBodies.FakeRandomBody(30,false), FakeBodies.FakeRandomBody(40,true), FakeBodies.FakeRandomBody(50,true), FakeBodies.FakeRandomBody(60,false), }; var filtered = bodies.TrackedOnly().ToArray(); Assert.AreEqual(filtered.Length, 4); Assert.AreEqual(filtered.Contains(bodies[0]), true); Assert.AreEqual(filtered.Contains(bodies[1]), true); Assert.AreEqual(filtered.Contains(bodies[3]), true); Assert.AreEqual(filtered.Contains(bodies[4]), true); }
public void TestSingleClosest() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10,true, new CameraSpacePoint() { Z = 0.2f }), FakeBodies.FakeSpineBody(20,true, new CameraSpacePoint() { Z = 0.02f }), FakeBodies.FakeSpineBody(30,true, new CameraSpacePoint() { Z = 0.25f }), FakeBodies.FakeSpineBody(40,true, new CameraSpacePoint() { Z = 0.7f }) }; var closest = bodies.ClosestBodies().ToArray(); Assert.AreEqual(closest.Length, 1); Assert.AreEqual(closest[0], bodies[1]); }
public void TestDuplicateJointCount() { KinectBodyInternal body = FakeInternalBodies.DuplicateJoints(); KinectBody kb = new KinectBody(body); }
public void TestMultipleCenter() { KinectBody[] bodies = new KinectBody[] { FakeBodies.FakeSpineBody(10,true, new CameraSpacePoint() { X = 0.2f }), FakeBodies.FakeSpineBody(20,true, new CameraSpacePoint() { X = -0.02f //Center is an absolute value, so 1 and 2 should be same distance }), FakeBodies.FakeSpineBody(30,true, new CameraSpacePoint() { X = 0.02f }), FakeBodies.FakeSpineBody(40,true, new CameraSpacePoint() { X = 0.7f }) }; var closest = bodies.CenterBodies().ToArray(); Assert.AreEqual(closest.Length, 2); Assert.AreEqual(closest.Contains(bodies[1]), true); Assert.AreEqual(closest.Contains(bodies[2]), true); }
public void TestTrackingLostRaisedSetFalse() { List<ulong> found = new List<ulong>(); BodyTrackingProcessor processor = new BodyTrackingProcessor(); ulong lostBodyId = 256; var firstFrame = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(lostBodyId, true), FakeBodies.FakeRandomBody(32, false) }; processor.Next(firstFrame); //Register to event now processor.BodyTrackingLost += (s, e) => found.Add(e.Body.TrackingId); ulong newBodyId = 17; var secondFrame = new KinectBody[] { FakeBodies.FakeRandomBody(128, true), FakeBodies.FakeRandomBody(lostBodyId, false), //Set tracking state to false here FakeBodies.FakeRandomBody(newBodyId, true), }; processor.Next(secondFrame); Assert.AreEqual(found.Count, 1); Assert.AreEqual(found.Contains(lostBodyId), true); }
public void TestNullJoints() { KinectBodyInternal body = FakeInternalBodies.NullJointsBody(); KinectBody kb = new KinectBody(body); }
/// <summary> /// Returns camera space matching for right hand, if in tracked state for each KinectBody /// </summary> /// <param name="body1">First body</param> /// <param name="body2">Second Body</param> /// <returns>Camera to camera point, or empty enumeration if hand is not tracked</returns> public static IEnumerable<CameraToCameraPoint> HandRight(KinectBody body1, KinectBody body2) { return YieldIfTracked(body1, body2, JointType.HandRight); }
/// <summary> /// Builds a list of all tracked joints for two Kinect bodies /// </summary> /// <param name="body1">First body</param> /// <param name="body2">Second Body</param> /// <returns>Camera to camera point list</returns> public static IEnumerable<CameraToCameraPoint> AllTrackedJoints(KinectBody body1, KinectBody body2) { return body1.Joints.Where(j => j.Value.TrackingState == TrackingState.Tracked && body2.Joints[j.Key].TrackingState == TrackingState.Tracked) .Select(kvp => new CameraToCameraPoint(kvp.Value.Position.ToVector3(), body2.Joints[kvp.Key].Position.ToVector3())); }
public void TestWrongJointsOrientationCount() { KinectBodyInternal body = FakeInternalBodies.WrongJointOrientationCount(); KinectBody kb = new KinectBody(body); }
/// <summary> /// Assigns a kinect body for face tracking /// </summary> /// <param name="body">Body to assign</param> public void AssignBody(KinectBody body) { this.frameSource.TrackingId = body.TrackingId; this.framereader.IsPaused = false; }
public void KinectBodyTestValid() { KinectBody[] data = new KinectBody[] { Fakes.FakeBodies.FakeRandomBody(128,true), Fakes.FakeBodies.FakeRandomBody(129,true) }; KinectBodyFrameDataEventArgs args = new KinectBodyFrameDataEventArgs(data); Assert.AreEqual(args.FrameData[0], data[0]); Assert.AreEqual(args.FrameData[1], data[1]); }