public override bool IsFingerBent(Hand handId, Finger fingerId)
{
#if VRTK_DEFINE_SDK_LEAP_MOTION
Leap.Hand currentHand = GetLeapHand(handId);
if (currentHand == null)
{
return(false);
}
Leap.Finger.FingerType leapFingerType = VirtuosoFingerToLeapFinger(fingerId);
foreach (Leap.Finger finger in currentHand.Fingers)
{
if (finger.Type == leapFingerType)
{
return(!finger.IsExtended);
}
}
// finger not found; therefor no
return(false);
#else
throw new System.NotImplementedException();
#endif
}
//public bool isExtended; bRoke for now
public fingerData(RiggedFinger riggedFinger /*, Finger finger*/)
{
this.type = riggedFinger.fingerType;
this.pointRay = riggedFinger.GetRay();
this.tipPosition = pointRay.origin;
this.pointDirection = pointRay.direction;
//this.isExtended = finger.IsExtended;
}
public double FingerFlexoExtensionIF(Leap.Finger.FingerType finger)
{
Frame frame = LeapService.GetFrame();
if (frame.Hands.Count != 0)
{
Vector start = frame.Hands[0].Fingers[(int)finger].Bone(Bone.BoneType.TYPE_PROXIMAL).PrevJoint;
Vector middle = frame.Hands[0].Fingers[(int)finger].Bone(Bone.BoneType.TYPE_PROXIMAL).NextJoint;
Vector end = frame.Hands[0].Fingers[(int)finger].Bone(Bone.BoneType.TYPE_INTERMEDIATE).NextJoint;
return(180 - LeapUtils.getAngleJoints(start, middle, end));
}
else
{
return(0);
}
}
public Transform GetMetaCarpal(Leap.Finger.FingerType type)
{
switch (type)
{
case Finger.FingerType.TYPE_THUMB:
return(thumbMetaCarpal);
case Finger.FingerType.TYPE_INDEX:
return(indexMetaCarpal);
case Finger.FingerType.TYPE_MIDDLE:
return(middleMetaCarpal);
case Finger.FingerType.TYPE_RING:
return(ringMetaCarpal);
case Finger.FingerType.TYPE_PINKY:
return(pinkyMetaCarpal);
default:
return(null);
}
}
/// <summary>
/// Converts a FingerFilter enum type to a Leap.Finger.FingerType enum.
///
/// There is only one possible failure state: being fed an enum as an integer that is out of range.
///
/// Upon failure, the method will throw a System.NotSupported exception with details about the failure.
/// </summary>
/// <param name="fingerType">FingerType to convert.</param>
/// <returns></returns>
public static FingerFilter FingerFilterFromFingerType(Leap.Finger.FingerType fingerType)
{
switch (fingerType)
{
case Finger.FingerType.TYPE_INDEX:
return(FingerFilter.index);
case Finger.FingerType.TYPE_MIDDLE:
return(FingerFilter.middle);
case Finger.FingerType.TYPE_PINKY:
return(FingerFilter.pinky);
case Finger.FingerType.TYPE_RING:
return(FingerFilter.ring);
case Finger.FingerType.TYPE_THUMB:
return(FingerFilter.thumb);
default:
throw new System.NotSupportedException("Error in HandProperties.cs: An out of bounds enum value " + ((int)fingerType).ToString() + " was supplied.");
return(FingerFilter.thumb);
}
}
void SetHandData(Hand hand, int frameID)
{
for (int fingerIndex = 0; fingerIndex < hand.Fingers.Count; fingerIndex++)
{
Leap.Finger.FingerType fingerType = (Leap.Finger.FingerType)fingerIndex;
float _fingerWidth = fingerWidth * MM_TO_M;
Transform metaCarpalTransform = null;
switch (fingerType)
{
case Finger.FingerType.TYPE_THUMB:
metaCarpalTransform = thumbMetaCarpal;
break;
case Finger.FingerType.TYPE_INDEX:
metaCarpalTransform = indexMetaCarpal;
break;
case Finger.FingerType.TYPE_MIDDLE:
metaCarpalTransform = middleMetaCarpal;
break;
case Finger.FingerType.TYPE_RING:
metaCarpalTransform = ringMetaCarpal;
break;
case Finger.FingerType.TYPE_PINKY:
metaCarpalTransform = pinkyMetaCarpal;
break;
default:
Debug.LogError("Invalid finger type for finger index: " + fingerIndex);
break;
}
// NOTE: if our type is thumb, our 'meta carpal transform' is actually our proximal,
// and we'll need to generate a zero-length metacarpal for it
Transform proximalTransform = (fingerType == Finger.FingerType.TYPE_THUMB) ? metaCarpalTransform : metaCarpalTransform.GetChild(0);
Transform intermediateTransform = proximalTransform.GetChild(0);
Transform distalTransform = intermediateTransform.GetChild(0);
Transform tip = distalTransform.GetChild(0);
Finger finger = hand.Fingers[fingerIndex];
SetBone(ref finger.bones[(int)Bone.BoneType.TYPE_METACARPAL], metaCarpalTransform, proximalTransform, Bone.BoneType.TYPE_METACARPAL, _fingerWidth);
SetBone(ref finger.bones[(int)Bone.BoneType.TYPE_PROXIMAL], proximalTransform, intermediateTransform, Bone.BoneType.TYPE_PROXIMAL, _fingerWidth);
SetBone(ref finger.bones[(int)Bone.BoneType.TYPE_INTERMEDIATE], intermediateTransform, distalTransform, Bone.BoneType.TYPE_INTERMEDIATE, _fingerWidth);
SetBone(ref finger.bones[(int)Bone.BoneType.TYPE_DISTAL], distalTransform, tip, Bone.BoneType.TYPE_DISTAL, _fingerWidth);
// update the rest of the finger values.
Vector tipPosition = tip.transform.position.ToVector();
Vector direction = new Vector(0, 0, 0);
float fingerLength =
Vector3.Distance(proximalTransform.position, intermediateTransform.position) +
Vector3.Distance(intermediateTransform.position, distalTransform.position) +
Vector3.Distance(distalTransform.position, tip.position); // add up joint lengths for this
hand.Fingers[fingerIndex].Id = (int)fingerType;
hand.Fingers[fingerIndex].HandId = handID;
hand.Fingers[fingerIndex].TipPosition = tipPosition;
hand.Fingers[fingerIndex].Direction = direction;
hand.Fingers[fingerIndex].Length = fingerLength;
}
// fill out rest of hand
// forearm length is 0.27
// forearm width is 0.09
Vector forearmStart, forearmEnd;
forearmStart = GetForearmStart().ToVector();
forearmEnd = GetForearmEnd().ToVector();
Quaternion forearmRotation = GetForearmRotation();
// might be possible to create this as a bone? Not sure what magic the constructor does.
/*Arm arm = new Arm(forearmStart, forearmEnd, (forearmStart + forearmEnd) * 0.5f,
* (forearmEnd - forearmStart).Normalized, forearmLength, 0.09f,
* forearmRotation.ToLeapQuaternion());*/
hand.Arm.PrevJoint = forearmStart;
hand.Arm.NextJoint = forearmEnd;
hand.Arm.Center = (forearmStart + forearmEnd) * 0.5f;
hand.Arm.Direction = (forearmEnd - forearmStart).Normalized;
hand.Arm.Length = forearmLength;
hand.Arm.Width = 0.09f;
hand.Arm.Rotation = forearmRotation.ToLeapQuaternion();
Vector palmPosition = GetPalmPosition().ToVector();
Vector palmNormal = GetPalmNormal().ToVector();
Vector palmVelocity = new Vector(0, 0, 0);
//palmWidth = 85f * MM_TO_M;
LeapQuaternion rotation = GetHandRotation().ToLeapQuaternion();
hand.FrameId = frameID;
hand.PalmPosition = palmPosition;
hand.PalmVelocity = palmVelocity;
hand.PalmNormal = palmNormal;
hand.Direction = wrist.TransformDirection(modelPalmFacing).ToVector();
hand.Rotation = rotation;
hand.PalmWidth = palmWidth;
hand.StabilizedPalmPosition = palmPosition;
hand.WristPosition = wrist.position.ToVector();
hand.TimeVisible = timeVisible;
}
void SetHandData(Hand hand, int frameID)
{
// fill out palm and hand
// forearm length is 0.27
// forearm width is 0.09
Vector forearmStart, forearmEnd;
forearmStart = GetForearmStart().ToVector();
forearmEnd = GetForearmEnd().ToVector();
Quaternion forearmRotation = GetForearmRotation();
arm.PrevJoint = forearmStart;
arm.NextJoint = forearmEnd;
arm.Center = (forearmStart + forearmEnd) * 0.5f;
arm.Direction = (forearmEnd - forearmStart).Normalized;
arm.Length = forearmLength;
arm.Width = 0.09f;
arm.Rotation = forearmRotation.ToLeapQuaternion();
Vector palmPosition = GetPalmPosition().ToVector();
Vector palmNormal = GetPalmNormal().ToVector();
Vector palmVelocity = (visibleTime != 0 &&
(visibleTime - previousHand.TimeVisible != 0)) ? (previousHand.PalmPosition - palmPosition).Normalized / (visibleTime - previousHand.TimeVisible) :
new Vector(0, 0, 0);
Vector handDirection = wrist.TransformDirection(modelFingerPointing).ToVector();
LeapQuaternion rotation = GetHandRotation().ToLeapQuaternion();
fingers = hand.Fingers;
// fingers
for (int fingerIndex = 0; fingerIndex < 5; fingerIndex++)
{
Leap.Finger.FingerType fingerType = (Leap.Finger.FingerType)fingerIndex;
Transform metaCarpalTransform = null;
// set up our bones
Bone[] bones = null;
switch (fingerType)
{
case Finger.FingerType.TYPE_THUMB:
metaCarpalTransform = thumbMetaCarpal;
bones = thumbBones;
break;
case Finger.FingerType.TYPE_INDEX:
metaCarpalTransform = indexMetaCarpal;
bones = indexBones;
break;
case Finger.FingerType.TYPE_MIDDLE:
metaCarpalTransform = middleMetaCarpal;
bones = middleBones;
break;
case Finger.FingerType.TYPE_RING:
metaCarpalTransform = ringMetaCarpal;
bones = ringBones;
break;
case Finger.FingerType.TYPE_PINKY:
metaCarpalTransform = pinkyMetaCarpal;
bones = pinkyBones;
break;
default:
Debug.LogError("Invalid finger type for finger index: " + fingerIndex);
break;
}
// NOTE: if our type is thumb, our 'meta carpal transform' is actually our proximal,
// and we'll need to generate a zero-length metacarpal for it
Transform proximalTransform = (fingerType == Finger.FingerType.TYPE_THUMB) ? metaCarpalTransform : metaCarpalTransform.GetChild(0);
Transform intermediateTransform = proximalTransform.GetChild(0);
Transform distalTransform = intermediateTransform.GetChild(0);
Transform tip = distalTransform.GetChild(0);
Vector tipPosition = tip.transform.position.ToVector();
Vector direction = distalTransform.TransformVector(modelFingerPointing).ToVector();
float fingerLength =
Vector3.Distance(proximalTransform.position, intermediateTransform.position) +
Vector3.Distance(intermediateTransform.position, distalTransform.position) +
Vector3.Distance(distalTransform.position, tip.position); // add up joint lengths for this
float fingerDot = Vector3.Dot(direction.ToVector3(), handDirection.ToVector3());
fingerDots[fingerIndex] = fingerDot;
bool isExtended = fingerDot > 0.5f;
SetBone(bones[(int)Bone.BoneType.TYPE_METACARPAL], metaCarpalTransform, proximalTransform, Bone.BoneType.TYPE_METACARPAL, fingerWidth[fingerIndex]);
SetBone(bones[(int)Bone.BoneType.TYPE_PROXIMAL], proximalTransform, intermediateTransform, Bone.BoneType.TYPE_PROXIMAL, fingerWidth[fingerIndex]);
SetBone(bones[(int)Bone.BoneType.TYPE_INTERMEDIATE], intermediateTransform, distalTransform, Bone.BoneType.TYPE_INTERMEDIATE, fingerWidth[fingerIndex]);
SetBone(bones[(int)Bone.BoneType.TYPE_DISTAL], distalTransform, tip, Bone.BoneType.TYPE_DISTAL, fingerWidth[fingerIndex]);
fingers[fingerIndex].bones = bones;
fingers[fingerIndex].HandId = handID;
fingers[fingerIndex].TimeVisible = visibleTime;
fingers[fingerIndex].TipPosition = tipPosition;
fingers[fingerIndex].Direction = direction;
fingers[fingerIndex].Width = fingerWidth[fingerIndex];
fingers[fingerIndex].Length = fingerLength;
fingers[fingerIndex].IsExtended = isExtended;
fingers[fingerIndex].Type = (Finger.FingerType)fingerIndex;
fingers[fingerIndex].Id = fingerIndex;
fingers[fingerIndex].HandId = handID;
}
hand.FrameId = frameID;
hand.PalmPosition = palmPosition;
hand.PalmVelocity = palmVelocity;
hand.PalmNormal = palmNormal;
hand.Direction = handDirection;
hand.Rotation = rotation;
hand.PalmWidth = palmWidth;
hand.StabilizedPalmPosition = palmPosition;
hand.WristPosition = wrist.position.ToVector();
hand.GrabAngle = 0;
hand.GrabStrength = gripStrength;
hand.TimeVisible = visibleTime;
hand.Confidence = confidence;
hand.PinchStrength = pinchStrength;
hand.PinchDistance = (fingers[(int)Finger.FingerType.TYPE_INDEX].TipPosition.ToVector3() -
fingers[(int)Finger.FingerType.TYPE_THUMB].TipPosition.ToVector3()).magnitude;
hand.Arm = arm;
hand.Fingers = fingers;
hand.IsLeft = isLeft;
}
