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);
}
private void RaiseHandStateChanged(KinectBody body, HandType handType, HandState previousState)
{
if (this.HandStateChanged != null)
{
this.HandStateChanged(this, new KinectHandStateEventArgs(body, handType, previousState));
}
}
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()));
}
}
}
}
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);
}
}
/// <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 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 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 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]);
}
