private void Start()
{
foreach (var hand in GetComponentsInChildren <HandPosition>(true))
{
if (hand.Hand == Hand.LEFT)
{
if (LeftHand != null)
{
Debug.LogError("Item {0} has more than one left hand! That's pretty wierd...".Form(name));
}
else
{
LeftHand = hand;
}
}
else if (hand.Hand == Hand.RIGHT)
{
if (RightHand != null)
{
Debug.LogError("Item {0} has more than one right hand! That's pretty wierd...".Form(name));
}
else
{
RightHand = hand;
}
}
}
// Allow gun to shoot instantly upon spawning.
shootTimer = shotInterval + 1f;
// Give full magazine upon spawning.
Ammo = Info.MagCapacity;
}
public void HandPosition_Orders_Lowest_And_Highest_Spans()
{
var first = new HandPosition(1, 5);
var reversed = new HandPosition(5, 1);
Assert.Equal(first, reversed);
}
public void Remove(HandPosition position)
{
for (int i = 0; i < Items.Count; i++)
{
if (Items[i].Position == position)
{
RemoveAt(i);
i--;
}
}
}
public void OnInitialize(MInputKinect.UserManager userManager)
{
this.userManager = userManager;
rightHandPosition = new HandPosition()
{
KinectGesture = this, HandIndex = 0
};
leftHandPosition = new HandPosition()
{
KinectGesture = this, HandIndex = 1
};
}
/// <summary>
/// Initializes a new instance of the <see cref="Gesture"/> structure.
/// </summary>
///
/// <param name="leftHand">Left hand's position.</param>
/// <param name="rightHand">Right hand's position.</param>
///
public Gesture( HandPosition leftHand, HandPosition rightHand )
{
LeftHand = leftHand;
RightHand = rightHand;
}
public HandInputEventArgs(RoutedEvent routedEvent, object source, HandPosition hand)
: base(routedEvent, source)
{
this.Hand = hand;
}
public static void ProcessRightHand(Skeleton skeleton)
{
Joint rightHand = skeleton.Joints[JointType.HandRight];
Joint rightShoulder = skeleton.Joints[JointType.ShoulderRight];
SkeletonPoint rightHandPoint = rightHand.Position;
SkeletonPoint rightShoulderPoint = rightShoulder.Position;
HandPosition previousRightHandUpDownPosition = (rightHandUpDownDictionary.ContainsKey(skeleton.TrackingId)) ? rightHandUpDownDictionary[skeleton.TrackingId] : HandPosition.Unknown;
HandPosition newRightHandUpDownPosition = HandPosition.Unknown;
HandPosition previousRightHandLeftRightPosition = (rightHandLeftRightDictionary.ContainsKey(skeleton.TrackingId)) ? rightHandLeftRightDictionary[skeleton.TrackingId] : HandPosition.Unknown;
HandPosition newRightHandLeftRightPosition = HandPosition.Unknown;
HandPosition previousRightHandBackForwardsPosition = (rightHandBackForwardsDictionary.ContainsKey(skeleton.TrackingId)) ? rightHandBackForwardsDictionary[skeleton.TrackingId] : HandPosition.Unknown;
HandPosition newRightHandBackForwardsPosition = HandPosition.Unknown;
if ((rightHand.TrackingState == JointTrackingState.NotTracked) || (rightShoulder.TrackingState == JointTrackingState.NotTracked))
{
newRightHandUpDownPosition = HandPosition.Unknown;
newRightHandLeftRightPosition = HandPosition.Unknown;
newRightHandBackForwardsPosition = HandPosition.Unknown;
}
else
{
// Up/Down
if (rightHandPoint.Y - rightShoulderPoint.Y > 0.2)
{
newRightHandUpDownPosition = HandPosition.Up;
}
else if (Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) > 0.2)
{
newRightHandUpDownPosition = HandPosition.Down;
}
else
{
newRightHandUpDownPosition = HandPosition.Center;
}
// Left/Right
if (rightHandPoint.X - rightShoulderPoint.X > 0.2)
{
newRightHandLeftRightPosition = HandPosition.Right;
}
else if (Math.Abs(rightHandPoint.X - rightShoulderPoint.X) > 0.2)
{
newRightHandLeftRightPosition = HandPosition.Left;
}
else
{
newRightHandLeftRightPosition = HandPosition.Center;
}
// Backwards/Forwards
if (rightShoulderPoint.Z - rightHandPoint.Z > 0.5)
{
newRightHandBackForwardsPosition = HandPosition.Forwards;
}
else if (rightShoulderPoint.Z - rightHandPoint.Z < 0.25)
{
newRightHandBackForwardsPosition = HandPosition.Backwards;
}
else
{
newRightHandBackForwardsPosition = HandPosition.Center;
}
}
if (previousRightHandUpDownPosition != newRightHandUpDownPosition)
{
rightHandUpDownDictionary[skeleton.TrackingId] = newRightHandUpDownPosition;
if (RightHandUpDownChanged != null)
{
RightHandUpDownChanged(skeleton, new HandPositionChangedArgs()
{
Position = newRightHandUpDownPosition
});
}
}
if (previousRightHandLeftRightPosition != newRightHandLeftRightPosition)
{
rightHandLeftRightDictionary[skeleton.TrackingId] = newRightHandLeftRightPosition;
if (RightHandLeftRightChanged != null)
{
RightHandLeftRightChanged(skeleton, new HandPositionChangedArgs()
{
Position = newRightHandLeftRightPosition
});
}
}
if (previousRightHandBackForwardsPosition != newRightHandBackForwardsPosition)
{
rightHandBackForwardsDictionary[skeleton.TrackingId] = newRightHandBackForwardsPosition;
if (RightHandBackForwardsChanged != null)
{
RightHandBackForwardsChanged(skeleton, new HandPositionChangedArgs()
{
Position = newRightHandBackForwardsPosition
});
}
}
}
public void HandPosition_Above_Position_Is_Not_Covered()
{
var first = new HandPosition(10, 14);
Assert.False(first.Covers(new FingerPosition(15, 1)));
}
public void HandPosition_Understands_Position_At_Maximum_Span()
{
var first = new HandPosition(1, 4);
Assert.True(first.Covers(new FingerPosition(4, 1)));
}
public void HandPosition_Understands_Position_Within_Its_Span()
{
var first = new HandPosition(1, 4);
Assert.True(first.Covers(new FingerPosition(2, 1)));
}
public static void ProcessRightHand(Body body)
{
//ulong bodyKey = body.TrackingId;
ulong bodyKey = 0;
Joint rightHand = body.Joints[JointType.HandRight];
Joint rightShoulder = body.Joints[JointType.ShoulderRight];
CameraSpacePoint rightHandPoint = rightHand.Position;
CameraSpacePoint rightShoulderPoint = rightShoulder.Position;
HandPosition previousRightHandUpDownPosition = (rightHandUpDownDictionary.ContainsKey(bodyKey)) ? rightHandUpDownDictionary[bodyKey] : HandPosition.Unknown;
HandPosition newRightHandUpDownPosition = HandPosition.Unknown;
HandPosition previousRightHandLeftRightPosition = (rightHandLeftRightDictionary.ContainsKey(bodyKey)) ? rightHandLeftRightDictionary[bodyKey] : HandPosition.Unknown;
HandPosition newRightHandLeftRightPosition = HandPosition.Unknown;
HandPosition previousRightHandBackForwardsPosition = (rightHandBackForwardsDictionary.ContainsKey(bodyKey)) ? rightHandBackForwardsDictionary[bodyKey] : HandPosition.Unknown;
HandPosition newRightHandBackForwardsPosition = HandPosition.Unknown;
MotionState newRightMotionState = MotionState.FreeControl;
if ((rightHand.TrackingState == TrackingState.NotTracked) || (rightShoulder.TrackingState == TrackingState.NotTracked))
{
newRightHandUpDownPosition = HandPosition.Unknown;
newRightHandLeftRightPosition = HandPosition.Unknown;
newRightHandBackForwardsPosition = HandPosition.Unknown;
}
else
{
if (body.HandRightState == HandState.Lasso)
{
newRightMotionState = MotionState.Animation;
}
else
{
newRightMotionState = MotionState.FreeControl;
}
// Up/Down
if (rightHandPoint.Y - rightShoulderPoint.Y > 0.2 &&
rightShoulderPoint.Z - rightHandPoint.Z < 0.3 &&
Math.Abs(rightHandPoint.X - rightShoulderPoint.X) < 0.2)
{
newRightHandUpDownPosition = HandPosition.Up;
}
else if (Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) > 0.2 &&
rightShoulderPoint.Z - rightHandPoint.Z < 0.3 &&
Math.Abs(rightHandPoint.X - rightShoulderPoint.X) < 0.2)
{
newRightHandUpDownPosition = HandPosition.Down;
}
else if (rightShoulderPoint.Z - rightHandPoint.Z < 0.3 &&
Math.Abs(rightHandPoint.X - rightShoulderPoint.X) < 0.2)
{
newRightHandUpDownPosition = HandPosition.Center;
}
// Left/Right
if (rightHandPoint.X - rightShoulderPoint.X > 0.2 &&
Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) < 0.2 &&
rightShoulderPoint.Z - rightHandPoint.Z < 0.3)
{
newRightHandLeftRightPosition = HandPosition.Right;
}
else if (Math.Abs(rightHandPoint.X - rightShoulderPoint.X) > 0.2 &&
Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) < 0.2 &&
rightShoulderPoint.Z - rightHandPoint.Z < 0.3)
{
newRightHandLeftRightPosition = HandPosition.Left;
}
else if (Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) < 0.2 &&
rightShoulderPoint.Z - rightHandPoint.Z < 0.3)
{
newRightHandLeftRightPosition = HandPosition.Center;
}
// Backwards/Forwards
if (rightShoulderPoint.Z - rightHandPoint.Z > 0.5 &&
Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) < 0.2 &&
Math.Abs(rightHandPoint.X - rightShoulderPoint.X) < 0.2)
{
newRightHandBackForwardsPosition = HandPosition.Forwards;
}
else if (rightShoulderPoint.Z - rightHandPoint.Z < 0.25 &&
Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) < 0.2 &&
Math.Abs(rightHandPoint.X - rightShoulderPoint.X) < 0.2)
{
newRightHandBackForwardsPosition = HandPosition.Backwards;
}
else if (Math.Abs(rightHandPoint.Y - rightShoulderPoint.Y) < 0.2 &&
Math.Abs(rightHandPoint.X - rightShoulderPoint.X) < 0.2)
{
newRightHandBackForwardsPosition = HandPosition.Center;
}
}
if (previousRightHandUpDownPosition != newRightHandUpDownPosition)
{
rightHandUpDownDictionary[bodyKey] = newRightHandUpDownPosition;
if (RightHandUpDownChanged != null)
{
//Console.WriteLine("RightHandUpDownChanged");
RightHandUpDownChanged(body, new HandPositionChangedArgs()
{
Position = newRightHandUpDownPosition, MotionState = newRightMotionState
});
}
}
if (previousRightHandLeftRightPosition != newRightHandLeftRightPosition)
{
rightHandLeftRightDictionary[bodyKey] = newRightHandLeftRightPosition;
if (RightHandLeftRightChanged != null)
{
//Console.WriteLine("RightHandLeftRightChanged");
RightHandLeftRightChanged(body, new HandPositionChangedArgs()
{
Position = newRightHandLeftRightPosition, MotionState = newRightMotionState
});
}
}
if (previousRightHandBackForwardsPosition != newRightHandBackForwardsPosition)
{
rightHandBackForwardsDictionary[bodyKey] = newRightHandBackForwardsPosition;
if (RightHandBackForwardsChanged != null)
{
//Console.WriteLine("RightHandBackForwardsChanged");
RightHandBackForwardsChanged(body, new HandPositionChangedArgs()
{
Position = newRightHandBackForwardsPosition, MotionState = newRightMotionState
});
}
}
}
// Update is called once per frame
void Update()
{
if (PlayerPrefs.GetInt("HandNow") == 0)
{
handNow = HandPosition.LeftHand;
}
else if (PlayerPrefs.GetInt("HandNow") == 1)
{
handNow = HandPosition.RightHand;
}
float movementX;
float movementZ;
float zoomingZ;
if (handNow == HandPosition.LeftHand)
{
movementX = Input.GetAxisRaw("PrimaryThumbstickHorizontal");
movementZ = -Input.GetAxisRaw("PrimaryThumbstickVertical");
zoomingZ = Input.GetAxisRaw("SecondaryThumbstickVertical");
}
else if (handNow == HandPosition.RightHand)
{
movementX = Input.GetAxisRaw("SecondaryThumbstickHorizontal");
movementZ = -Input.GetAxisRaw("SecondaryThumbstickVertical");
zoomingZ = Input.GetAxisRaw("PrimaryThumbstickVertical");
}
else
{
movementX = 0;
movementZ = 0;
zoomingZ = 0;
}
if (handNow != HandPosition.AI)
{
Vector3 movement = new Vector3(movementX, 0, movementZ);
movement = Vector3.ClampMagnitude(movement, speed);
Quaternion tmp = head.transform.rotation;
head.transform.eulerAngles = new Vector3(0, head.transform.eulerAngles.y, 0);
movement = head.transform.TransformDirection(movement);
head.transform.rotation = tmp;
//movement *= Time.deltaTime;
//movement = transform.TransformDirection(movement);
transform.Translate(movement);
if (movementX > 0 || movementZ > 0)
{
//Debug.Log("X : " + movementX);
//Debug.Log("Z : " + movementZ);
}
if (zoomingZ != 0)
{
if (zoomingZ > 0 && playerScale < 20f)
{
playerScale += zoomSpeed * Time.deltaTime;
ZoomMove(-zoomingZ);
}
else if (zoomingZ < 0 && playerScale > 1f)
{
playerScale -= zoomSpeed * Time.deltaTime;
ZoomMove(-zoomingZ);
}
this.transform.localScale = new Vector3(playerScale, playerScale, playerScale);
}
}
}
private void RemoveHand(HandPosition hand)
{
this.IsHoveredOver = false;
hand.IsInteracting = false;
hand.Magnetized = false;
// Stop active hover timer (if it exists) for this hand.
HandHoverTimer timer = this.trackedHandHovers.FirstOrDefault(h => h.Hand.Equals(hand));
if (timer != null)
{
timer.Stop();
this.trackedHandHovers.Remove(timer);
}
}
public TimeSpan GetTimeRemaining(HandPosition hand)
{
HandHoverTimer timer = this.trackedHandHovers.FirstOrDefault(h => h.Hand.Equals(hand));
if (timer != null)
{
return timer.TimeRemaining;
}
return TimeSpan.MaxValue;
}
public void InvokeHoverClick(HandPosition hand)
{
if (hand != null)
{
hand.IsInteracting = false;
HandHoverTimer timer = this.trackedHandHovers.FirstOrDefault(h => h.Hand.Equals(hand));
if (timer != null)
{
timer.Stop();
this.trackedHandHovers.Remove(timer);
}
}
this.IsSelected = true;
if (this.soundPlayerOnClick != null)
{
this.soundPlayerOnClick.Play();
}
var t = new DispatcherTimer();
t.Interval = TimeSpan.FromSeconds(0.6);
t.Tick += (o, s) =>
{
t.Stop();
var clickArgs = new HandInputEventArgs(HoverClickEvent, this, hand);
this.RaiseEvent(clickArgs);
this.IsSelected = false;
};
t.Start();
}
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
{
using (SkeletonFrame skeletonFrame=e.OpenSkeletonFrame())
{
if (skeletonFrame == null)
{
return;
}
inputmethod = W.inputmethod;
skeletonFrame.CopySkeletonDataTo(allSkeletons);
//get the first tracked skeleton
Skeleton first = (from s in allSkeletons
where s.TrackingState == SkeletonTrackingState.Tracked
select s).FirstOrDefault();
// skeleton data may not be available
if (first == null)
{
return;
}
// display skeleton on window
displaySkeleton(first);
// Selecting the input method
switch (inputmethod)
{
case 0: // input version 1
Angles angles1 = new Angles(first);
AxisAngles = angles1.getFinalAngles();
break;
case 2: // input version 2
HandPosition angles2 = new HandPosition(first);
AxisAngles = angles2.getFinalAngles();
break;
case 1: // input version 3
HandPositionLower angles3 = new HandPositionLower(first);
AxisAngles = angles3.getFinalAngles();
break;
default:
MessageBox.Show("Error !!!");
break;
}
AxisAngles = medians.getNextMedian(AxisAngles);
// Displaying on GUI
W.axis1.Content = AxisAngles[1].ToString();
W.axis2.Content = AxisAngles[2].ToString();
W.axis3.Content = AxisAngles[3].ToString();
W.axis4.Content = AxisAngles[4].ToString();
W.axis5.Content = AxisAngles[5].ToString();
W.axis6.Content = AxisAngles[6].ToString();
if (W.RoboticArmMovement)
MoveRoboticArm(AxisAngles);
}
}
