private float DuckPinchMetric(Leap.Hand hand)
{
Vector3 thumbDistal = hand.GetThumb().bones[3].PrevJoint.ToVector3();
Vector3 thumbTip = hand.GetThumb().TipPosition.ToVector3();
Vector3 indexMetacarpal = hand.GetIndex().bones[0].PrevJoint.ToVector3();
Vector3 indexProximal = hand.GetIndex().bones[1].PrevJoint.ToVector3();
Vector3 indexTip = hand.GetIndex().TipPosition.ToVector3();
Vector3 middleMetacarpal = hand.GetMiddle().bones[0].PrevJoint.ToVector3();
Vector3 middleTip = hand.GetMiddle().bones[3].PrevJoint.ToVector3();
Vector3 ringMetacarpal = hand.GetMiddle().bones[0].PrevJoint.ToVector3();
Vector3 ringTip = hand.GetRing().bones[3].PrevJoint.ToVector3();
// Project all except thumb onto a plane
Vector3 projectionPlane = Vector3.Cross(hand.GetIndex().bones[2].Direction.ToVector3(), hand.PalmarAxis()).normalized;
if (hand.IsRight)
{
// convert to left-handed-rule for Unity
projectionPlane *= -1f;
}
Vector3 planeOrigin = indexProximal;
indexProximal = Vector3.zero;
indexMetacarpal = Vector3.ProjectOnPlane(indexMetacarpal - planeOrigin, projectionPlane) + planeOrigin;
indexTip = Vector3.ProjectOnPlane(indexTip - planeOrigin, projectionPlane) + planeOrigin;
middleMetacarpal = Vector3.ProjectOnPlane(middleMetacarpal - planeOrigin, projectionPlane) + planeOrigin;
middleTip = Vector3.ProjectOnPlane(middleTip - planeOrigin, projectionPlane) + planeOrigin;
ringMetacarpal = Vector3.ProjectOnPlane(ringMetacarpal - planeOrigin, projectionPlane) + planeOrigin;
ringTip = Vector3.ProjectOnPlane(ringTip - planeOrigin, projectionPlane) + planeOrigin;
// Limit thumb positions
float thumbDistalOverlap = Vector3.Dot(thumbDistal - planeOrigin, projectionPlane);
if (thumbDistalOverlap < 0)
{
thumbDistal += thumbDistalOverlap * projectionPlane;
}
float thumbTipOverlap = Vector3.Dot(thumbTip - planeOrigin, projectionPlane);
if (thumbTipOverlap < 0)
{
thumbTip += thumbTipOverlap * projectionPlane;
}
float indexMetric = SegmentDisplacement.SegmentToSegmentDistance(indexMetacarpal, indexTip, thumbDistal, thumbTip);
float middleMetric = SegmentDisplacement.SegmentToSegmentDistance(middleMetacarpal, middleTip, thumbDistal, thumbTip);
float ringMetric = SegmentDisplacement.SegmentToSegmentDistance(ringMetacarpal, ringTip, thumbDistal, thumbTip);
float wipMetric = (indexMetric + middleMetric + ringMetric) / (3.0f);
metric = Mathf.Max(0f, wipMetric - 0.01f);
return(metric);
}
static Vector3 PinchSegmentToSegmentDisplacement(Leap.Hand hand)
{
Vector3 indexDistal = hand.GetIndex().bones[3].PrevJoint.ToVector3();
Vector3 indexTip = hand.GetIndex().TipPosition.ToVector3();
Vector3 thumbDistal = hand.GetThumb().bones[3].PrevJoint.ToVector3();
Vector3 thumbTip = hand.GetThumb().TipPosition.ToVector3();
return(SegmentToSegmentDisplacement(indexDistal, indexTip, thumbDistal, thumbTip));
}
//returns a true if a finger is pinching with the thumb, false if not
public bool checkPinchOfFinger(Leap.Hand hand, string finger)
{
switch (finger)
{
case "index":
if (getPinchDistance(hand.GetIndex(), hand.GetThumb()) < dist)
{
return(true);
}
break;
case "middle":
if (getPinchDistance(hand.GetMiddle(), hand.GetThumb()) < dist)
{
return(true);
}
break;
case "ring":
if (getPinchDistance(hand.GetRing(), hand.GetThumb()) < dist)
{
return(true);
}
break;
case "pinky":
if (getPinchDistance(hand.GetPinky(), hand.GetThumb()) < dist)
{
return(true);
}
break;
default:
break;
}
return(false);
}
bool CheckHandForActivation(Leap.Hand hand, bool wasEligibleLastCheck)
{
bool shouldActivate = false;
float latestPinchDistance = GetCustomPinchDistance(hand);
Vector3 palmDir = hand.PalmarAxis();
Vector3 middleDir = hand.GetMiddle().bones[1].Direction.ToVector3();
float signedMiddlePalmAngle = Vector3.SignedAngle(palmDir, middleDir, hand.RadialAxis());
if (hand.IsLeft)
{
signedMiddlePalmAngle *= -1f;
}
Vector3 ringDir = hand.GetRing().bones[1].Direction.ToVector3();
float signedRingPalmAngle = Vector3.SignedAngle(palmDir, ringDir, hand.RadialAxis());
if (hand.IsLeft)
{
signedRingPalmAngle *= -1f;
}
Vector3 indexDir = hand.GetIndex().bones[1].Direction.ToVector3();
float indexPalmAngle = Vector3.Angle(indexDir, palmDir);
Vector3 thumbDir = hand.GetThumb().bones[2].Direction.ToVector3();
float thumbPalmAngle = Vector3.Angle(thumbDir, palmDir);
// Eligibility checks-- necessary, but not sufficient conditions to start
// a pinch, suitable for e.g. visual feedback on whether the gesture is
// "able to occur" or "about to occur."
if (
((!wasEligibleLastCheck &&
signedMiddlePalmAngle >= minPalmMiddleAngle) ||
(wasEligibleLastCheck &&
signedMiddlePalmAngle >= minPalmMiddleAngle
* ringMiddleSafetyHysteresisMult) ||
!requireMiddleAndRingSafetyPinch)
&& ((!wasEligibleLastCheck &&
signedRingPalmAngle >= minPalmRingAngle) ||
(wasEligibleLastCheck &&
signedRingPalmAngle >= minPalmRingAngle
* ringMiddleSafetyHysteresisMult) ||
!requireMiddleAndRingSafetyPinch)
// Index angle (eligibility state only)
&& ((!wasEligibleLastCheck &&
indexPalmAngle < maxIndexAngleForEligibilityActivation) ||
(wasEligibleLastCheck &&
indexPalmAngle < maxIndexAngleForEligibilityDeactivation))
// Thumb angle (eligibility state only)
&& ((!wasEligibleLastCheck &&
thumbPalmAngle < maxThumbAngleForEligibilityActivation) ||
(wasEligibleLastCheck &&
thumbPalmAngle < maxThumbAngleForEligibilityDeactivation))
// Must cross pinch threshold from a non-pinching / non-fist pose.
&& (!requiresRepinch)
)
{
// Conceptually, this should be true when all but the most essential
// parameters for the gesture are satisfied, so the user can be notified
// that the gesture is imminent.
_isGestureEligible = true;
}
#region Update Pinch Strength
// Update global "pinch strength".
// If the gesture is eligible, we'll have a non-zero pinch strength.
if (_isGestureEligible)
{
_latestPinchStrength = latestPinchDistance.Map(0f, pinchActivateDistance,
1f, 0f);
}
else
{
_latestPinchStrength = 0f;
}
#endregion
#region Check: Pinch Distance
if (_isGestureEligible
// Absolute pinch strength.
&& (latestPinchDistance < pinchActivateDistance)
)
{
shouldActivate = true;
}
#endregion
#region Hysteresis for Failed Pinches
// "requiresRepinch" prevents a closed-finger configuration from beginning
// a pinch when the index and thumb never actually actively close from a
// valid position -- think, closed-fist to safety-pinch, as opposed to
// open-hand to safety-pinch -- without introducing any velocity-based
// requirement.
if (latestPinchDistance < pinchActivateDistance && !shouldActivate)
{
requiresRepinch = true;
}
if (requiresRepinch && latestPinchDistance > failedPinchResetDistance)
{
requiresRepinch = false;
}
#endregion
return(shouldActivate);
}
