Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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]);
        }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
0
        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 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);
        }
        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);
        }
Ejemplo n.º 8
0
        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);
        }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 10
0
        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]);
        }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
        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);
        }
Ejemplo n.º 15
0
        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);
        }
Ejemplo n.º 16
0
        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);
        }