/// <summary>
 /// Checks the provided IavaSkeleton object to see if it completes a gesture
 /// </summary>
 /// <param name="skeleton">IavaSkeleton to check for gesture match</param>
 public void CheckForGesture(IavaSkeleton skeleton)
 {
     // Check to see if this skeleton completes one of our supported gestures
     foreach (IavaGesture gesture in SupportedGestures) {
         gesture.CheckGesture(skeleton);
     }
 }
        public void EqualityTest()
        {
            try {
                IavaSkeleton[] skeletons = new IavaSkeleton[] { new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton(),
                                                                new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton() };

                IavaSkeletonFrame_Accessor accessor1 = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = Tuple.Create(1.0f, 2.0f, 3.0f, 4.0f),
                    FrameNumber = 14,
                    Skeletons = skeletons,
                    Timestamp = 123456789
                };

                IavaSkeletonFrame_Accessor accessor2 = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = Tuple.Create(1.0f, 2.0f, 3.0f, 4.0f),
                    FrameNumber = 14,
                    Skeletons = skeletons,
                    Timestamp = 123456789
                };

                IavaSkeletonFrame_Accessor accessor3 = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = Tuple.Create(4.0f, 3.0f, 2.0f, 1.0f),
                    FrameNumber = 18,
                    Skeletons = skeletons,
                    Timestamp = 123456789
                };

                IavaSkeletonFrameReadyEventArgs eventArgs1 = new IavaSkeletonFrameReadyEventArgs((IavaSkeletonFrame)accessor1.Target);
                IavaSkeletonFrameReadyEventArgs eventArgs2 = new IavaSkeletonFrameReadyEventArgs((IavaSkeletonFrame)accessor2.Target);
                IavaSkeletonFrameReadyEventArgs eventArgs3 = new IavaSkeletonFrameReadyEventArgs((IavaSkeletonFrame)accessor3.Target);
                IavaSkeletonFrameReadyEventArgs eventArgs4 = new IavaSkeletonFrameReadyEventArgs((IavaSkeletonFrame)null);
                IavaSkeletonFrameReadyEventArgs eventArgs5 = new IavaSkeletonFrameReadyEventArgs((IavaSkeletonFrame)null);

                // Make sure eventArgs1 does not equal null
                Assert.IsFalse(eventArgs1 == null);

                // Make sure null does not equal eventArgs1
                Assert.IsFalse(null == eventArgs1);

                // Make sure eventArgs1 and eventArgs3 are not equal
                Assert.IsFalse(eventArgs1 == eventArgs3);

                // Make sure eventArgs1 and eventArgs2 are equal
                Assert.IsTrue(eventArgs1 == eventArgs2);

                // Make sure eventArgs4 and eventArgs5 are equal
                Assert.IsTrue(eventArgs4 == eventArgs5);

                // Make sure eventArgs1 equals itself
                Assert.IsTrue(eventArgs1 == eventArgs1);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void EqualityTest()
        {
            try {
                // Define once to populate the various objects
                IavaSkeleton[] skeletonArray = new IavaSkeleton[] { new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton(),
                                                                    new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton()};

                IavaSkeletonFrame_Accessor accessor1 = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = new Tuple<float, float, float, float>(1.0f, 2.0f, 2.5f, 0.3f),
                    FrameNumber = 456,
                    Skeletons = skeletonArray,
                    Timestamp = 123456789
                };

                IavaSkeletonFrame_Accessor accessor2 = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = new Tuple<float, float, float, float>(1.0f, 2.0f, 2.5f, 0.3f),
                    FrameNumber = 456,
                    Skeletons = skeletonArray,
                    Timestamp = 123456789
                };

                IavaSkeletonFrame_Accessor accessor3 = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = new Tuple<float, float, float, float>(7.0f, 2.1f, 2.5f, 0.3f),
                    FrameNumber = 487,
                    Skeletons = skeletonArray,
                    Timestamp = 123456789
                };

                IavaSkeletonFrame frame1 = (IavaSkeletonFrame)accessor1.Target;
                IavaSkeletonFrame frame2 = (IavaSkeletonFrame)accessor2.Target;
                IavaSkeletonFrame frame3 = (IavaSkeletonFrame)accessor3.Target;

                // Make sure eventArgs1 does not equal null
                Assert.IsFalse(frame1 == null);

                // Make sure null does not equal eventArgs1
                Assert.IsFalse(null == frame1);

                // Make sure eventArgs1 and eventArgs3 are not equal
                Assert.IsFalse(frame1 == frame3);

                // Make sure eventArgs1 and eventArgs2 are equal
                Assert.IsTrue(frame1 == frame2);

                // Make sure eventArgs1 equals itself
                Assert.IsTrue(frame1 == frame1);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        /// <summary>
        /// Creates a IavaSnapshot defined by the provided Skeleton object.
        /// </summary>
        /// <param name="skeleton">Skeleton defining the joint states of the IavaSnapshot</param>
        public IavaSnapshot(IavaSkeleton skeleton)
        {
            if (skeleton == null) { return; }

            // ROFL, I didn't even know this was allowed...
            for (IavaJointType i = 0; i < IavaJointType.Count; i++) {
                BodyParts.Add(new IavaBodyPart(i, skeleton.Joints[i].Position));
            }

            // Set the body part positions
            foreach (IavaJoint joint in skeleton.Joints) {
                BodyParts.Where(x => x.JointID == joint.JointType).Single().Position = joint.Position;
            }
        }
        public void ClippedEdgesTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton();

                // Set the ClippedEdges
                skeleton.ClippedEdges = IavaFrameEdges.Bottom;

                // Make sure the property set correctly
                Assert.AreEqual(IavaFrameEdges.Bottom, skeleton.ClippedEdges);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        /// <summary>
        /// Checks each IavaSkeletonJoint to see if it falls within the expected bounds defining this gesture snapshot
        /// </summary>
        /// <param name="skeleton">Skeleton object being checked</param>
        /// <param name="fudgeFactor">Area around the expected point, that constitutes a hit</param>
        /// <returns>TRUE if the skeleton satisfies the gesture IavaSnapshot, else FALSE</returns>
        public bool CheckSnapshot(IavaSkeleton skeleton, double fudgeFactor)
        {
            List<bool> results = new List<bool>();

            foreach (IavaBodyPart bodyPart in BodyParts) {

                if (bodyPart.Tracking) {
                    results.Add(Geometry.Magnitude2D(bodyPart.Position, skeleton.Joints[bodyPart.JointID].Position) <= fudgeFactor);
                }
            }

            // We aren't tracking any joints, impossible to match
            if (results.Count == 0) { return false; }

            return results.TrueForAll(x => x == true);
        }
        public void EqualityTest()
        {
            try {
                IavaSkeleton skeleton1 = new IavaSkeleton()
                {
                    ClippedEdges = IavaFrameEdges.Left,
                    Position = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 51,
                    TrackingState = IavaSkeletonTrackingState.PositionOnly
                };

                IavaSkeleton skeleton2 = new IavaSkeleton()
                {
                    ClippedEdges = IavaFrameEdges.Left,
                    Position = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 51,
                    TrackingState = IavaSkeletonTrackingState.PositionOnly
                };

                IavaSkeleton skeleton3 = new IavaSkeleton()
                {
                    ClippedEdges = IavaFrameEdges.Right,
                    Position = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 48,
                    TrackingState = IavaSkeletonTrackingState.Tracked
                };

                // Make sure skeleton1 does not equal null
                Assert.IsFalse(skeleton1 == null);

                // Make sure skeleton1 and skeleton3 are not equal
                Assert.IsFalse(skeleton1 == skeleton3);

                // Make sure skeleton1 and skeleton2 are equal
                Assert.IsTrue(skeleton1 == skeleton2);

                // Make sure skeleton1 equals itself
                Assert.IsTrue(skeleton1 == skeleton1);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void ConstructorTest1()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton()
                {
                    ClippedEdges = IavaFrameEdges.Left,
                    Position = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 531,
                    TrackingState = IavaSkeletonTrackingState.Tracked
                };

                // Create the object
                IavaSkeletonEventArgs iavaEventArgs = new IavaSkeletonEventArgs(skeleton);

                // Make sure the property set correctly
                Assert.AreEqual(skeleton, iavaEventArgs.Skeleton);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
 /// <summary>
 /// Checks the provided IavaSkeleton object to see if it completes the Sync gesture
 /// </summary>
 /// <param name="skeleton">IavaSkeleton to check for gesture match</param>
 public void CheckForSyncGesture(IavaSkeleton skeleton)
 {
     // Check to see if the skeleton completes our sync gesture
     SyncGesture.CheckGesture(skeleton);
 }
        public void SkeletonTest()
        {
            try {
                IavaSkeletonEventArgs_Accessor iavaEventArgs = new IavaSkeletonEventArgs_Accessor(new IavaSkeleton());

                IavaSkeleton skeleton = new IavaSkeleton()
                {
                    ClippedEdges = IavaFrameEdges.Left,
                    Position = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 531,
                    TrackingState = IavaSkeletonTrackingState.Tracked
                };

                // Set the ImageFrame
                iavaEventArgs.Skeleton = skeleton;

                // Make sure the property set correctly
                Assert.AreEqual(skeleton, iavaEventArgs.Skeleton);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void GetActiveSkeletonTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton() { Position = new Iava.Core.Math.IavaSkeletonPoint() { X = 1.0, Y = 1.0, Z = 1.0 } };

                // Define once to populate the various objects
                IavaSkeleton[] skeletonArray = new IavaSkeleton[] { new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton(),
                                                                    new IavaSkeleton(), new IavaSkeleton(), skeleton };

                IavaSkeletonFrame_Accessor accessor = new IavaSkeletonFrame_Accessor()
                {
                    FloorClipPlane = new Tuple<float, float, float, float>(1.0f, 2.0f, 2.5f, 0.3f),
                    FrameNumber = 456,
                    Skeletons = skeletonArray,
                    Timestamp = 123456789
                };

                // Make sure the ActiveSkeleton is our skeleton
                Assert.AreEqual(skeleton, accessor.GetActiveSkeleton());

                // Make sure the property calls the correct method
                Assert.AreEqual(skeleton, accessor.ActiveSkeleton);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        /// <summary>
        /// Handles the job of initializing a IavaSkeletonFrame that can be used by the Unit Tests
        /// </summary>
        /// <returns></returns>
        IavaSkeletonFrame CreateSkeletonFrame()
        {
            IavaSkeleton[] skeletons = new IavaSkeleton[] { new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton(),
                                                            new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton() };

            IavaSkeletonFrame_Accessor accessor = new IavaSkeletonFrame_Accessor()
            {
                FloorClipPlane = Tuple.Create(1.0f, 2.0f, 3.0f, 4.0f),
                FrameNumber = 14,
                Skeletons = skeletons,
                Timestamp = 123456789
            };

            return (IavaSkeletonFrame)accessor.Target;
        }
        public void TrackingStateTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton();

                // Set the TrackingState
                skeleton.TrackingState = IavaSkeletonTrackingState.NotTracked;

                // Make sure the property set correctly
                Assert.AreEqual(IavaSkeletonTrackingState.NotTracked, skeleton.TrackingState);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void TrackingIdTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton();

                // Set the TrackingId
                skeleton.TrackingId = 405;

                // Make sure the property set correctly
                Assert.AreEqual(405, skeleton.TrackingId);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void PositionTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton();

                IavaSkeletonPoint point = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f };

                // Set the Position
                skeleton.Position = point;

                // Make sure the property set correctly
                Assert.AreEqual(point, skeleton.Position);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void SkeletonsTest()
        {
            try {
                IavaSkeletonFrame_Accessor iavaFrame = new IavaSkeletonFrame_Accessor();

                IavaSkeleton[] skeletonArray = new IavaSkeleton[] { new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton(),
                                                                    new IavaSkeleton(), new IavaSkeleton(), new IavaSkeleton()};

                // Set the Skeletons
                iavaFrame.Skeletons = skeletonArray;

                // Make sure the property set correctly
                Assert.IsTrue(iavaFrame.Skeletons.SequenceEqual(skeletonArray));
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void IavaSkeletonConstructorTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton();

                // Verify the joints are initialized properly
                for (IavaJointType joint = 0; joint < IavaJointType.Count; joint++) {
                    Assert.AreEqual(joint, skeleton.Joints[joint].JointType);
                }
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        public void ExplicitCastTest()
        {
            try {
                Skeleton kinectSkeleton = new Skeleton()
                {
                    ClippedEdges = FrameEdges.Left,
                    Position = new SkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 51,
                    TrackingState = SkeletonTrackingState.PositionOnly
                };

                IavaSkeleton iavaSkeleton = new IavaSkeleton()
                {
                    ClippedEdges = IavaFrameEdges.Left,
                    Position = new IavaSkeletonPoint() { X = 1.0f, Y = 2.0f, Z = 3.0f },
                    TrackingId = 51,
                    TrackingState = IavaSkeletonTrackingState.PositionOnly
                };

                // Test object as a whole
                Assert.AreEqual(iavaSkeleton, (IavaSkeleton)kinectSkeleton);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
 /// <summary>
 /// Creates an IavaSkeletonEventArgs containing the supplied IavaSkeleton
 /// </summary>
 /// <param name="skeleton">IavaSkeleton to be contained in the IavaSkeletonEventArgs</param>
 public IavaSkeletonEventArgs(IavaSkeleton skeleton)
 {
     this.Skeleton = skeleton;
 }
        public void JointsTest()
        {
            try {
                IavaSkeleton skeleton = new IavaSkeleton();

                IavaJointCollection jointCollection = new IavaJointCollection();
                jointCollection[IavaJointType.ElbowLeft] = new IavaJoint() { TrackingState = IavaJointTrackingState.NotTracked };
                jointCollection[IavaJointType.FootRight] = new IavaJoint() { TrackingState = IavaJointTrackingState.Tracked };
                jointCollection[IavaJointType.Head] = new IavaJoint() { TrackingState = IavaJointTrackingState.NotTracked };
                jointCollection[IavaJointType.KneeLeft] = new IavaJoint() { TrackingState = IavaJointTrackingState.Inferred };

                // Set the Joints
                skeleton.Joints = jointCollection;

                // Make sure the property set correctly
                Assert.AreEqual(jointCollection, skeleton.Joints);
            }
            catch (Exception ex) {
                Assert.Fail(ex.Message);
            }
        }
        /// <summary>
        /// Checks the skeleton position to see if the gesture has been performed
        /// </summary>
        /// <param name="skeleton">IavaSkeleton to inspect for gesture</param>
        public void CheckGesture(IavaSkeleton skeleton)
        {
            // For now hard code Fudgefactor
            //FudgeFactor = 0.3;

            // Check to see if the skeleton data matches our snapshot
            if (Snapshots[_currentGestureSegment].CheckSnapshot(skeleton, FudgeFactor)) {
                _currentGestureSegment++;

                // We have detected an entire gesture
                if (_currentGestureSegment == Snapshots.Count) {
                    // Throw the event
                    if (GestureRecognized != null) { GestureRecognized(null, new GestureEventArgs(Name)); }

                    // Reset the gesture state
                    Reset();
                }

                // We have only detected part of a gesture, prepare to look for the next snapshot
                else { _frameCount = 0; }
            }

            else {
                // We've timed out, start over on detecting the gesture
                if (_frameCount >= 40) {
                    _currentGestureSegment = 0;
                    _frameCount = 0;
                }

                else { _frameCount++; }
            }
        }