private float GetAngle(Leap.Hand hand)
    {
        Vector3 proximalAxis = hand.DistalAxis() * -1f;
        Vector3 radialAxis   = hand.RadialAxis();

        if (hand.IsLeft)
        {
            radialAxis *= -1f;
        }

        List <float> fingerAngles = new List <float>
        {
            Vector3.SignedAngle(proximalAxis, hand.GetIndex().Direction.ToVector3(), radialAxis),
            Vector3.SignedAngle(proximalAxis, hand.GetMiddle().Direction.ToVector3(), radialAxis),
            Vector3.SignedAngle(proximalAxis, hand.GetRing().Direction.ToVector3(), radialAxis),
            Vector3.SignedAngle(proximalAxis, hand.GetPinky().Direction.ToVector3(), radialAxis)
        };

        List <float> fingerAnglesShifted = new List <float>();

        foreach (float angle in fingerAngles)
        {
            float shiftedAngle = angle;
            if (angle < -90f)
            {
                shiftedAngle += 360f;
            }
            fingerAnglesShifted.Add(shiftedAngle);
        }


        angle = 0.25f * (fingerAnglesShifted[0] + fingerAnglesShifted[1] + fingerAnglesShifted[2] + fingerAnglesShifted[3]);

        return(angle);
    }
Beispiel #2
0
    //Determines if the fingers are extended and the palm is facing up
    public bool IsFlatHand(Leap.Hand hand)
    {
        float angle = Vector3.Angle(hand.PalmNormal.ToVector3(), Vector3.up);

        //Debug.Log(angle);
        return((hand.GrabAngle <= 1f) && (angle < 120f));
    }
Beispiel #3
0
    //Check pinch and grab pose
    public bool IsPinching(Leap.Hand hand)
    {
        if (Hands.GetIndex(hand).IsExtended)
        {
            return(false);
        }
        //return hand.PinchStrength > .9f;
        //first and foremost we need the index to be pinched, if it it is we have a true
        bool pinch = checkPinchOfFinger(hand, "index");

        //if we are in pinch with index check to see if other fingers are not.
        if (pinch)
        {
            string[] fings = { "ring", "pinky" };
            foreach (string f in fings)
            {
                //If any other finger is in pinch return false
                if (checkPinchOfFinger(hand, f))
                {
                    return(false);
                }
            }
        }
        return(pinch);
    }
 private static SerializableHand ToSerializableHand(Hand leapHand)
 {
     var hand = new SerializableHand
     {
         id = leapHand.Id,
         frameID = leapHand.FrameId,
         confidence = leapHand.Confidence,
         grabStrength = leapHand.GrabStrength,
         grabAngle = leapHand.GrabAngle,
         pinchStrength = leapHand.PinchStrength,
         pinchDistance = leapHand.PinchDistance,
         palmWidth = leapHand.PalmWidth,
         isLeft = leapHand.IsLeft,
         timeVisible = leapHand.TimeVisible,
         arm = ToSerializableArm(leapHand.Arm),
         fingers = leapHand.Fingers.Select(ToSerializableFinger).ToList(),
         palmPosition = ToSerializableVector(leapHand.PalmPosition),
         stabilizedPalmPosition = ToSerializableVector(leapHand.StabilizedPalmPosition),
         palmVelocity = ToSerializableVector(leapHand.PalmVelocity),
         palmNormal = ToSerializableVector(leapHand.PalmNormal),
         direction = ToSerializableVector(leapHand.Direction),
         wristPosition = ToSerializableVector(leapHand.WristPosition)
     };
     return hand;
 }
Beispiel #5
0
    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);
    }
    bool ShouldGestureDeactivate(Leap.Hand hand)
    {
        bool shouldDeactivate = false;

        _latestPinchStrength = 1f;

        if (minDeactivateTimer > MIN_DEACTIVATE_TIME)
        {
            var pinchDistance = GetCustomPinchDistance(hand);

            if (pinchDistance > pinchDeactivateDistance)
            {
                shouldDeactivate = true;
            }
        }
        else
        {
            minDeactivateTimer += 1;
        }
        if (shouldDeactivate)
        {
            minReactivateTimer = 0;
        }
        return(shouldDeactivate);
    }
Beispiel #7
0
    //Recognise current gesture function
    public string Recognise(Leap.Hand cur_hand)
    {
        //Initially assuming no gesture
        string gesture = "NONE";
        //If palm faces camera
        bool result = checkPalmFacingCamera(cur_hand);

        if (result)
        {
            //Was going to be used for UI
            gesture = "UI";
        }
        //If making fist
        bool result_fist = checkFist(cur_hand);

        if (result_fist)
        {
            //Used for shooting
            gesture = "FIST";
        }


        //Return gesture here
        return(gesture);

        //There is a gesture hierarchy of sorts,
        //If the user is making a fist, we can ignore UI for example
    }
    // Update is called once per frame
    void Update()
    {
        Leap.Hand          left = null, right = null;
        List <Leap.Finger> leftFingers = null, rightFingers = null;

        controller.CurrentFrame.Hands.ForEach(delegate(Leap.Hand hand)
        {
            if (hand.IsLeft)
            {
                left        = hand;
                leftFingers = hand.Fingers;
            }
            else if (hand.IsRight)
            {
                right        = hand;
                rightFingers = hand.Fingers;
            }
        });

        if (left != null)
        {
            if (Vector3.Angle(leftFingers[1].Direction.ToVector3(), left.Direction.ToVector3()) > 120)
            {
                transform.position += new Vector3(0, 0, -1);
            }
            else if (Vector3.Angle(leftFingers[1].Direction.ToVector3(), left.Direction.ToVector3()) < 50)
            {
                transform.position += new Vector3(0, 0, 1);
            }
        }
    }
Beispiel #9
0
    public bool checkPinch()
    {
        //Determine which hand.
        if (handedness == "Right")
        {
            hand = Hands.Right;
        }
        else
        {
            hand = Hands.Left;
        }
        //Check if hand exists
        if (hand == null)
        {
            return(false);
        }
        //Get position and value of Pinch
        bool detected = util.IsPinching(hand);

        if (detected)
        {
            position = util.weightedPos(hand);
        }
        return(detected);
    }
    List <float> HandToFloatArray(Leap.Hand h)
    {
        List <float> FloatArray = new List <float>();

        for (int i = 0; i < 5; i++)
        {
            Finger f = h.Fingers[i];
            // Debug.Log("PRST : " + f.ToString() + "indeks: " + i);

            for (int j = 0; j < 4; j++)
            {
                // Debug.Log("Kost broj :" + j);
                Bone   b      = f.Bone((Bone.BoneType)j);
                Vector pJoint = b.PrevJoint;
                Vector nJoint = b.NextJoint;

                FloatArray.Add(pJoint.x);
                FloatArray.Add(pJoint.y);
                FloatArray.Add(pJoint.z);

                FloatArray.Add(nJoint.x);
                FloatArray.Add(nJoint.y);
                FloatArray.Add(nJoint.z);
            }
        }
        return(FloatArray);
    }
 private Node AddChildBone(string fingerType, string boneType, Hand hand, Node parentNode)
 {
     Node boneNode = new Node();
     boneNode.Name = GetNodeBoneName(fingerType, boneType, hand);
     parentNode.Children.Add(boneNode);
     return (boneNode);
 }
        /// <summary>
        /// Add a new frame Animation channel
        /// </summary>
        private void AddNewFrame(Hand hand, Animation anim)
        {
            NodeAnimationChannel nodeChannelHand = AssimpUtil.FindNodeAnim(anim, GetNodeHandName(hand.Id.ToString()));

            var assimpNodeAnimHand = VectorToNode(hand.PalmPosition, anim.DurationInTicks);
            nodeChannelHand.PositionKeys.Add(assimpNodeAnimHand.Item1);
            nodeChannelHand.RotationKeys.Add(assimpNodeAnimHand.Item2);
            
            foreach (Finger finger in hand.Fingers)
            {
                Leap.Bone bone;
                foreach (Leap.Bone.BoneType boneType in (Leap.Bone.BoneType[])Enum.GetValues(typeof(Leap.Bone.BoneType)))
                {
                    bone = finger.Bone(boneType);

                    //Fetch the NodeAnim corresponding to the Bone
                    NodeAnimationChannel nodeChannel = AssimpUtil.FindNodeAnim(anim,
                        GetNodeBoneName(finger.Type.ToString(), boneType.ToString(), hand));

                    var assimpNodeAnim = VectorToNode(bone.NextJoint - bone.PrevJoint, anim.DurationInTicks); //BoneToNode(bone);
                    nodeChannel.PositionKeys.Add(assimpNodeAnim.Item1);
                    nodeChannel.RotationKeys.Add(assimpNodeAnim.Item2);
                }
            }
        }
    public Hand makeHand(ref LEAP_HAND hand, Frame owningFrame)
    {
      Arm newArm = makeArm(ref hand.arm);

      Hand newHand = new Hand(
        (int)owningFrame.Id,
        (int)hand.id,
        hand.confidence,
        hand.grab_strength,
        hand.grab_angle,
        hand.pinch_strength,
        hand.pinch_distance,
        hand.palm.width,
        hand.type == eLeapHandType.eLeapHandType_Left,
        hand.visible_time,
        newArm,
        new List<Finger>(5),
        new Vector(hand.palm.position.x, hand.palm.position.y, hand.palm.position.z),
        new Vector(hand.palm.stabilized_position.x, hand.palm.stabilized_position.y, hand.palm.stabilized_position.z),
        new Vector(hand.palm.velocity.x, hand.palm.velocity.y, hand.palm.velocity.z),
        new Vector(hand.palm.normal.x, hand.palm.normal.y, hand.palm.normal.z),
        new Vector(hand.palm.direction.x, hand.palm.direction.y, hand.palm.direction.z),
        newArm.NextJoint //wrist position
      );
      newHand.Fingers.Insert(0, makeFinger(owningFrame, ref hand, ref hand.thumb, Finger.FingerType.TYPE_THUMB));
      newHand.Fingers.Insert(1, makeFinger(owningFrame, ref hand, ref hand.index, Finger.FingerType.TYPE_INDEX));
      newHand.Fingers.Insert(2, makeFinger(owningFrame, ref hand, ref hand.middle, Finger.FingerType.TYPE_MIDDLE));
      newHand.Fingers.Insert(3, makeFinger(owningFrame, ref hand, ref hand.ring, Finger.FingerType.TYPE_RING));
      newHand.Fingers.Insert(4, makeFinger(owningFrame, ref hand, ref hand.pinky, Finger.FingerType.TYPE_PINKY));

      return newHand;
    }
 // Update is called once per frame
 void Update()
 {
     if (placed)
     {
         return;
     }
     frame = leapcontroller.Frame();
     lHand = Hands.Left;
     // if there are hands visible in the view.
     if (lHand != null)
     {
         if (util.IsFlatHand(lHand))
         {
             HUDObject.SetActive(true);
         }
         else
         {
             HUDObject.SetActive(false);
         }
     }
     else
     {
         // if no hands are visible in the view, set the HUD inactive
         HUDObject.SetActive(false);
     }
 }
        //Update the hand
        public void UpdateHand(Leap.Hand hand)
        {
            if (!hand.IsValid)
            {
                return;
            }

            //Refresh leap hand data
            this.hand = hand;

            //Set handObject position
            //Reverse z coordinate
            handObject.transform.position = new Vector3(hand.PalmPosition.x, hand.PalmPosition.y, -hand.PalmPosition.z);

            //Set last hand position
            lastPosition = position;

            //Set hand position
            position = handObject.transform.position;

            //Set last hand speed
            lastSpeed = speed;

            //Set hand speed
            speed = new Vector3(hand.PalmVelocity.x, hand.PalmVelocity.y, -hand.PalmVelocity.z);

            //Refresh leap finger data
            UpdateFingers();
        }
Beispiel #16
0
    private char DoASLTest_B(Leap.Hand hand)
    {
        float fingerThreshold = 1400;

        Leap.FingerList fingers = hand.Fingers;

        Leap.Finger pinky  = fingers[(int)Leap.Finger.FingerType.TYPE_PINKY];
        Leap.Finger ring   = fingers[(int)Leap.Finger.FingerType.TYPE_RING];
        Leap.Finger middle = fingers[(int)Leap.Finger.FingerType.TYPE_MIDDLE];
        Leap.Finger index  = fingers[(int)Leap.Finger.FingerType.TYPE_INDEX];
        Leap.Finger thumb  = fingers[(int)Leap.Finger.FingerType.TYPE_THUMB];

        Vector3 pinkyPos  = ToVector3(pinky.Bone(Leap.Bone.BoneType.TYPE_INTERMEDIATE).NextJoint);
        Vector3 ringPos   = ToVector3(ring.Bone(Leap.Bone.BoneType.TYPE_INTERMEDIATE).NextJoint);
        Vector3 middlePos = ToVector3(middle.Bone(Leap.Bone.BoneType.TYPE_INTERMEDIATE).NextJoint);
        Vector3 indexPos  = ToVector3(index.Bone(Leap.Bone.BoneType.TYPE_INTERMEDIATE).NextJoint);

        if ((pinkyPos - ringPos).sqrMagnitude < fingerThreshold &&
            (ringPos - middlePos).sqrMagnitude < fingerThreshold &&
            (middlePos - indexPos).sqrMagnitude < fingerThreshold)
        {
            return('B');
        }
        return(INVALID_ASL_LETTER);
    }
Beispiel #17
0
 //Test the final posture of the hand to end the gesture
 protected override void TestEndGesture(Hand hand)
 {
     if (hand.PalmPosition.y-InitialPosition >= 150)
     {
         FinishGesture();
     }
 }
Beispiel #18
0
        private static IJoint BuildHand(Hand hand, IJoint wrist, int side)
        {
            var handJoint = new OrientedJoint();

            if (hand.IsValid)
            {
                var palmNormal = hand.PalmNormal;
                var handPosition = hand.PalmPosition;

                handJoint.Orientation = new Vector4(10 * palmNormal.x, 10 * palmNormal.y, 10 * palmNormal.z, 0);
                handJoint.Point = new Vector3(0, 0, -100);

                var fingers = hand.Fingers;
                foreach (var t in fingers)
                {
                    var normal = t.Direction;
                    var position = t.TipPosition - handPosition;

                    handJoint.AddChild(CreateFinger(position, normal, FingerType2JointType(t.Type(), side)));
                }
                handJoint.Valid = true;
            }

            return handJoint;
        }
Beispiel #19
0
 //Needs tested. Checks for a thumbs up pose.
 public bool checkThumbsUp(Leap.Hand hand)
 {
     foreach (Leap.Finger f in hand.Fingers)
     {
         if (f.Type == Leap.Finger.FingerType.TYPE_THUMB)
         {
             if (f.IsExtended && checkDirectionUp(f))
             {
                 continue;
             }
             else
             {
                 return(false);
             }
         }
         else
         {
             if (f.IsExtended && checkDirectionUp(f))
             {
                 return(false);
             }
             else
             {
                 continue;
             }
         }
     }
     return(true);
 }
Beispiel #20
0
    //Checks to see if a swipe has occured recently.
    //Uses recent frame information and the users hand
    public bool isSwiping(Leap.Hand hand, Queue <FrameInformation> framesQueue)
    {
        if (framesQueue.Count < 50)
        {
            return(false);
        }
        FrameInformation[] frames   = framesQueue.ToArray();
        List <float>       accelMag = new List <float>();

        //if not enough fingers extended no swipe
        if (Extended(hand.Fingers) >= 4)
        {
            //Fetch the accel magnitude of recent and current frames
            Vector3 accel = (hand.PalmVelocity.ToVector3() - frames[frames.Length - 2].hand.palmVelocity);
            accelMag.Add(Vector3.Project(accel, hand.PalmNormal.ToVector3()).magnitude);
            accelMag[0] *= Mathf.Sign(Vector3.Dot(accel, hand.PalmNormal.ToVector3()));
            for (int i = frames.Length - 1; i > frames.Length - 7; --i)
            {
                accel = (frames[i].hand.palmVelocity - frames[frames.Length - 2].hand.palmVelocity);
                accelMag.Add(Vector3.Project(accel, frames[i].hand.palmNormal).magnitude);
                accelMag[accelMag.Count - 1] *= Mathf.Sign(Vector3.Dot(accel, frames[i].hand.palmNormal));
            }
            //Grab the roll of the hand
            float handRoll = Mathf.Abs(hand.PalmNormal.Roll);
            return((handRoll > 1.35 && accelMag[1] < -0.3f && accelMag[0] < accelMag[1] && accelMag[2] > accelMag[1]) ? true : false);
        }
        return(false);
    }
    bool ShouldGestureActivate(Leap.Hand hand)
    {
        bool shouldActivate = false;

        _latestPinchStrength = 0f;

        bool wasEligibleLastCheck = _isGestureEligible;

        _isGestureEligible = false;

        // Can only activate a pinch if we haven't already activated a pinch very recently.
        if (minReactivateTimer > MIN_REACTIVATE_TIME)
        {
            shouldActivate = CheckHandForActivation(hand, wasEligibleLastCheck);
        }
        else
        {
            minReactivateTimer += 1;
        }

        if (shouldActivate)
        {
            minDeactivateTimer = 0;
        }
        return(shouldActivate);
    }
Beispiel #22
0
        void OnCollisionEnter(Collision collision)
        {
            if (canCollide)
            {
                var parent = GetParent("RigidHand(Clone)", collision.collider.transform);

                if (parent == null)
                {
                    return;
                }

                LM.Hand hand   = parent.GetComponent <RigidHand>().GetLeapHand();
                Marker  marker = this.GetComponentInParent <Marker>();

                logger.Debug("Collision");

                if (hand.IsLeft == marker.IsLeft)
                {
                    logger.Debug("Collision with correct hand");

                    if (OnMarkerCollision != null)
                    {
                        OnMarkerCollision(marker, gesture, hand);
                    }
                }
            }
        }
Beispiel #23
0
    // Update is called once per frame
    void Update()
    {
        Leap.Hand          left = null, right = null;
        List <Leap.Finger> leftFingers = null, rightFingers = null;

        controller.CurrentFrame.Hands.ForEach(delegate(Leap.Hand hand)
        {
            if (hand.IsLeft)
            {
                left        = hand;
                leftFingers = hand.Fingers;
            }
            else if (hand.IsRight)
            {
                right        = hand;
                rightFingers = hand.Fingers;
            }
        });

        if (right != null)
        {
            if (previousDownVelocity > -2 && rightFingers[1].TipVelocity.y < -2 && Vector3.Angle(rightFingers[1].Direction.ToVector3(), right.Direction.ToVector3()) < 60 && Vector3.Angle(rightFingers[2].Direction.ToVector3(), right.Direction.ToVector3()) > 120 && Vector3.Angle(rightFingers[3].Direction.ToVector3(), right.Direction.ToVector3()) > 120)
            {
                ToggleMenu();
            }

            previousDownVelocity = rightFingers[1].TipVelocity.y;
        }
    }
    public HandRepresentation(int handID, Hand hand, Chirality chirality, ModelType modelType) {
      HandID = handID;
      this.MostRecentHand = hand;
      this.RepChirality = chirality;
      this.RepType = modelType;

    }
Beispiel #25
0
    // Update is called once per frame
    void Update()
    {
        controller = new Leap.Controller();
        Leap.Frame       frame = controller.Frame();
        List <Leap.Hand> hands = frame.Hands;

        Leap.Hand fristHand = hands[0];
        position = hands[0].PalmPosition;

        pos = Leap.Unity.UnityVectorExtension.ToVector3(position);


        // Attach to the palm
        // Vive Tracker
        //Vector3 pos = new Vector3(ViveHand.transform.position.x - 0.2f, ViveHand.transform.position.y + 1.0f, ViveHand.transform.position.z - 0.5f);

        //Vector3 pos = new Vector3(ViveHand.transform.position.x, ViveHand.transform.position.y, ViveHand.transform.position.z);

        transform.position = pos;

        //if (!pos.Equals(UnityEngine.Vector3.zero))
        //{
        //    // If non-zero, orientate to the hand surface
        //    Vector3 dir = new Vector3(hand.Direction.x, hand.Direction.y, 0.0f);
        //    Vector3 norm =new Vector3(hand.PalmNormal.x, hand.PalmNormal.y, 0.0f);

        //    transform.rotation = Quaternion.LookRotation(dir, norm);
        //}
    }
        /// <summary>
        /// Build a Node hierachy into the scene property 'mainScene' from a Hand object
        /// </summary>
        /// <param name="hand"></param>
        private void CreateNodeHierarchy(Hand hand, Scene handScene)
        {
            Node rootNode = handScene.RootNode = new Node();

            Node handNode = new Node();
            handNode.Name = GetNodeHandName(hand.Id.ToString());
            rootNode.Children.Add(handNode);
            
            NodeAnimationChannel bonetest = new NodeAnimationChannel();
            bonetest.NodeName = GetNodeHandName(hand.Id.ToString());
            handScene.Animations[0].NodeAnimationChannels.Add(bonetest);

            foreach (Finger finger in hand.Fingers)
            {
                Node fingerNode = handNode;

                foreach (Leap.Bone.BoneType boneType in (Leap.Bone.BoneType[])Enum.GetValues(typeof(Leap.Bone.BoneType)))
                {
                    string fingerType = finger.Type.ToString();
                    //Add a node hierarchy
                    fingerNode = AddChildBone(fingerType, boneType.ToString(), hand, fingerNode);
                    //Fill the NodeAnimChannel
                    NodeAnimationChannel bone = new NodeAnimationChannel();
                    bone.NodeName = GetNodeBoneName(fingerType, boneType.ToString(), hand);
                    handScene.Animations[0].NodeAnimationChannels.Add(bone);
                }
            }
        }
Beispiel #27
0
    // Update is called once per frame
    void FixedUpdate()
    {
        Leap.Hand mHand = myLeapManagerInstance.frontmostHand();

        if (mHand.IsValid)
        {
            if (!swordUp)
            {
                audio.Play();
            }

            swordUp = true;
        }
        else
        {
            if (swordUp)
            {
                AudioSource.PlayClipAtPoint(swordSheath, transform.position, 0.25f);
            }

            swordUp = false;
        }

        Vector3    targetPos = getTargetPos(mHand);
        Quaternion targetRot = getTargetRot(mHand);

        //moveWithForce(targetPos);
        moveWithMovePos(targetPos, targetRot);
    }
Beispiel #28
0
    private IEnumerator leftHandWatcher()
    {
        while (true)
        {
            if (leftHandModel != null)
            {
                leftHand = leftHandModel.GetLeapHand();
                if (leftHand != null)
                {
                    //if (leftHand.GrabStrength >= 0.85f)  Debug.Log("Left Grabbing");

                    if (leftHandState != 0 && leftHand.PinchStrength >= pinchStrengthForce)
                    {
                        //Debug.Log("Left Pinching");
                        leftHandState = 1;
                    }
                    else if (leftHand.GrabStrength <= grabStrengthForce)
                    {
                        //Debug.Log("Left AllExtend");
                        leftHandState = 2;
                    }
                    else
                    {
                        offset        = Vector3.zero;
                        leftHandState = 0;
                        if (workstationActivated)
                        {
                            dynamicUI.GetComponent <WorkstationBehaviourExample>().DeactivateWorkstation();
                            workstationActivated = false;
                        }
                    }

                    if (leftHandState == 2)
                    {
                        if (leftHand.PalmVelocity.z >= onoffVelocity)
                        {
                            //Debug.Log("Left Window TurnOff");
                            leftHandState = 3;
                        }
                        else if (leftHand.PalmVelocity.z <= -onoffVelocity)
                        {
                            //Debug.Log("Left Window TurnOn");
                            leftHandState = 4;
                        }
                        if (leftHand.PalmVelocity.x <= -onoffVelocity)
                        {
                            leftHandState = 5;
                            //Debug.Log("Left");
                        }
                        else if (leftHand.PalmVelocity.x >= onoffVelocity)
                        {
                            leftHandState = 6;
                        }
                    }
                }
            }
            yield return(new WaitForSeconds(0.1f));
        }
    }
Beispiel #29
0
 //Test the initial posture of the hand to start the gesture
 protected override void TestInitialGesture(Hand hand)
 {
     
         InitialPosition = hand.PalmPosition.x;
         PreviousHand = hand;
         ReceiveBeginningLeftMoveEvent();
     
 }
Beispiel #30
0
 public HandProxy(HandPool parent, Hand hand, Chirality repChirality, ModelType repType) :
   base(hand.Id, hand, repChirality, repType)
 {
   this.parent = parent;
   this.RepChirality = repChirality;
   this.RepType = repType;
   this.MostRecentHand = hand;
 }
    float GetCustomPinchDistance(Leap.Hand hand)
    {
        float pinchDistance = PinchSegmentToSegmentDisplacement(hand).magnitude;

        pinchDistance -= 0.01f;
        pinchDistance  = Mathf.Max(0f, pinchDistance);
        return(pinchDistance);
    }
    List <Leap.Hand> FloatArrayToHands(List <float> FloatArray, List <GameObject> zgloboviIKostii)
    {
        List <Leap.Hand> hands = new List <Hand>();
        int z = 0;

        int handsCount = (int)FloatArray[z];

        z++;

        for (int k = 0; k < handsCount; k++)
        {
            Leap.Hand h = new Leap.Hand();

            float leftRight = FloatArray[z];
            z++;

            if (leftRight == 0)
            {
                h.IsLeft = true;
            }
            else
            {
                h.IsLeft = false;
            }

            for (int i = 0; i < 5; i++)
            {
                Finger f = h.Fingers[i];

                f.TipPosition.x = FloatArray[z];
                f.TipPosition.y = FloatArray[z + 1];
                f.TipPosition.z = FloatArray[z + 2];
                z += 3;


                for (int j = 0; j < 4; j++)
                {
                    Bone b = f.Bone((Bone.BoneType)j);

                    b.PrevJoint = new Vector(FloatArray[z], FloatArray[z + 1], FloatArray[z + 2]);
                    z          += 3;

                    b.NextJoint = new Vector(FloatArray[z], FloatArray[z + 1], FloatArray[z + 2]);
                    z          += 3;
                }
            }

            h.PalmPosition.x = FloatArray[z];
            h.PalmPosition.y = FloatArray[z + 1];
            h.PalmPosition.z = FloatArray[z + 2];
            z += 3;


            hands.Add(h);
        }

        return(hands);
    }
Beispiel #33
0
    FrameInformation fetchFrameInformation()
    {
        FrameInformation frameInfo = new FrameInformation();

        frameInfo.grabHeld  = grabHeld;
        frameInfo.pinchHeld = pinchHeld;
        foreach (Leap.Finger f in hand.Fingers)
        {
            FingerInformation fingerInfo = new FingerInformation();
            fingerInfo.isExtended   = f.IsExtended;
            fingerInfo.direction    = f.Direction.ToVector3();
            fingerInfo.padDirection = Vector3.Cross(fingerInfo.direction, Vector3.Cross(fingerInfo.direction, f.bones[1].Direction.ToVector3()));
            fingerInfo.tipPosition  = f.TipPosition.ToVector3();
            fingerInfo.tipVelocity  = f.TipVelocity.ToVector3();
            switch (f.Type)
            {
            case Leap.Finger.FingerType.TYPE_INDEX:
                frameInfo.index = fingerInfo;
                break;

            case Leap.Finger.FingerType.TYPE_MIDDLE:
                frameInfo.middle = fingerInfo;
                break;

            case Leap.Finger.FingerType.TYPE_RING:
                frameInfo.ring = fingerInfo;
                break;

            case Leap.Finger.FingerType.TYPE_PINKY:
                frameInfo.pinky = fingerInfo;
                break;

            case Leap.Finger.FingerType.TYPE_THUMB:
                frameInfo.thumb = fingerInfo;
                break;
            }
        }
        if (handedness == "Right")
        {
            hand = Hands.Right;
        }
        else
        {
            hand = Hands.Left;
        }
        HandInformation handInfo = new HandInformation();

        handInfo.direction    = hand.Direction.ToVector3();
        handInfo.pitch        = hand.Direction.Pitch;
        handInfo.roll         = hand.Direction.Roll;
        handInfo.yaw          = hand.Direction.Yaw;
        handInfo.palmPosition = hand.PalmPosition.ToVector3();
        handInfo.palmVelocity = hand.PalmVelocity.ToVector3();
        handInfo.palmNormal   = hand.PalmNormal.ToVector3();
        handInfo.rotation     = hand.Rotation.ToQuaternion();
        frameInfo.hand        = handInfo;
        return(frameInfo);
    }
 protected Finger FindFingerByType(Hand hand, Finger.FingerType type)
 {
     foreach (var finger in hand.Fingers)
     {
         if (finger.Type() == type)
         return finger;
     }
     return null;
 }
Beispiel #35
0
    /* ========================= Initialize Tracking Algorithms ============================ */

    /* Method for the Distance Between Palm and Pointer */
    private static void OnLeapMotionUpdate(Leap.Hand hand)
    {
        // Get Instance
        InputManager IM = _instance;

        if (IM == null)
        {
            return;
        }

        // Complete First Pass
        FingerLift[] fingerTest       = IM.RetrieveFingerLift(hand);
        ASLTest      firstPassResults = IM.FirstPassAlgorithm(fingerTest);

        // Call Similarity Handler
        IM.UpdateCurrentSimilarity(firstPassResults);

        /*if(IM.similarityHandler != null)
         * {
         *      IM.similarityHandler(firstPassResults);
         * }*/

        if (firstPassResults == ASLTest.INVALID_ASL_TEST)
        {
            IM.UpdateCurrentLetter(INVALID_ASL_LETTER);
            return;
        }

        // Complete Second Pass
        char secondPassResults = IM.SecondPassAlgorithm(firstPassResults, hand);

        // Determine if Successful
        bool finalResults = (secondPassResults >= 'A' && secondPassResults <= 'Z') || (secondPassResults >= 'a' && secondPassResults <= 'z');

        if (IM.lastResult != secondPassResults)
        {
            IM.lastResult     = secondPassResults;
            IM.lastLetterTime = DateTime.Now.Ticks;
        }

        // Call Letter Handler
        if (finalResults)
        {
            if (((DateTime.Now.Ticks - IM.lastLetterTime) / TimeSpan.TicksPerMillisecond) >= (IM.dwellTime * 1000))
            {
                IM.UpdateCurrentLetter(secondPassResults);
            }
            else
            {
                IM.UpdateCurrentLetter(INVALID_ASL_LETTER);
            }
        }
        else
        {
            IM.UpdateCurrentLetter(INVALID_ASL_LETTER);
        }
    }
Beispiel #36
0
    // Use this for initialization


    void Start()
    {
        theHand = GameObject.FindGameObjectWithTag("handControl").GetComponent <HandController>();

        Leap.Frame    frame = theHand.GetFrame(); // controller is a Controller object
        Leap.HandList hands = frame.Hands;
        firstHand = hands[0];
        Debug.Log("starting");
    }
    private bool ShouldTriggerGrab(Leap.Hand hand)
    {
        float handAngle        = GetAngle(hand);
        float clampedHandAngle = Mathf.Clamp(handAngle, clickAngle, 180);

        GrabStrength = ScreenControlUtility.MapRangeToRange(clampedHandAngle, clickAngle, 180, 1, 0);

        return(handAngle < clickAngle);
    }
    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));
    }
Beispiel #39
0
    void createUI(Leap.Hand right_hand, Vector3 relPosBetweenHands)
    {
        initialAlpha = 0.0f;
        Vector3 r_palm_Pos = right_hand.PalmPosition.ToVector3();
        Vector3 uiPos      = camera_.transform.position + (camera_.forward * .503f);

        created_ui = (GameObject)Instantiate(UI, uiPos, Quaternion.identity);
        created_ui.GetComponent <Renderer>().material.color = new Color(Color.green.r, Color.green.g, Color.green.b, initialAlpha);
    }
Beispiel #40
0
/*
 *      IEnumerator BeklemeIncongruent()
 *      {
 *              int randomNumber = UnityEngine.Random.Range(0, 4);
 *              int randomNumberSecond = UnityEngine.Random.Range(0, 4);
 *
 *              yield return new WaitForSeconds(2.5f);
 *              GameObject.Find("Numerator").GetComponent<TextMesh>().text = digits[randomNumber];
 *              isTiming = true;
 *              //	GestureIncongruent();
 *              yield return new WaitUntil(() => DigitDetector() == randomNumber);
 *              Debug.Log(DigitDetector() + "  Reaction time: " + reactionTimer + " ms");
 *              GameObject.Find("Numerator").GetComponent<TextMesh>().text = "TRUE";
 *              yield return new WaitForSeconds(0.2f);
 *              GameObject.Find("Numerator").GetComponent<TextMesh>().text = "";
 *              isTiming = false;
 *              reactionTimer = 0;
 *
 *              yield return new WaitForSeconds(2.5f);
 *              GameObject.Find("Numerator").GetComponent<TextMesh>().text = digits[randomNumberSecond];
 *              isTiming = true;
 *              yield return new WaitUntil(() => DigitDetector() == randomNumberSecond);
 *              Debug.Log(DigitDetector() + "  Reaction timeSecond: " + reactionTimer + " ms");
 *              GameObject.Find("Numerator").GetComponent<TextMesh>().text = "TRUE";
 *              yield return new WaitForSeconds(0.2f);
 *              GameObject.Find("Numerator").GetComponent<TextMesh>().text = "";
 *              isTiming = false;
 *              reactionTimer = 0;
 *      }
 */

    public bool PostureDetector()
    {
        _current = _controller.Frame();
        var rightHandPosture       = new Vector3();
        var leftHandPosture        = new Vector3();
        var isRHandPostureCounting = false;
        var isLHandPostureCounting = false;

        //TODO: is this part necessary for this method
        if (_current.Hands.Count == 1)
        {
            if (_current.Hands[0].IsRight)
            {
                _handRight = _current.Hands[0];
                _handLeft  = null;
            }
            else if (_current.Hands[0].IsLeft)
            {
                _handLeft  = _current.Hands[0];
                _handRight = null;
            }
        }
        else if (_current.Hands.Count == 2)
        {
            _handRight = _current.Hands[0];
            _handLeft  = _current.Hands[1];
        }
        else if (_current.Hands.Count == 0)
        {
            _handRight = null;
            _handLeft  = null;
        }


        if (_handRight != null)
        {
            rightHandPosture = _handRight.Basis.yBasis.ToVector3();
        }

        if (_handLeft != null)
        {
            leftHandPosture = _handLeft.Basis.yBasis.ToVector3();
        }

        if (rightHandPosture.y >= 0)
        {
            isRHandPostureCounting = true;
        }

        if (leftHandPosture.y >= 0)
        {
            isLHandPostureCounting = true;
        }

        return(isLHandPostureCounting && isRHandPostureCounting);
    }
Beispiel #41
0
    void FollowHand(IVIHand ivihand)
    {
        Leap.Hand hand     = ivihand.LeapHand;
        Vector3   palmPos  = hand.PalmPosition.ToVector3();
        Vector3   palmNorm = hand.PalmNormal.ToVector3();
        float     palmRot  = .02f + transform.localScale.y / 2;

        transform.position = initialPos + palmNorm * palmRot + palmPos;
        transform.rotation = hand.Basis.rotation.ToQuaternion();
    }
Beispiel #42
0
 /** Calls Updates in IHandModels that are part of this HandRepresentation */
 public override void UpdateRepresentation(Hand hand)
 {
   base.UpdateRepresentation(hand);
   if (handModels != null) {
     for (int i = 0; i < handModels.Count; i++) {
       handModels[i].SetLeapHand(hand);
       handModels[i].UpdateHand();
     }
   }
 }
Beispiel #43
0
 //Test gesture and throw an event if the gesture is validated
 public override void TestGesture(Hand hand)
 {
     //throw an event if the posture is verified
     if (TestPosture(hand))
     {
         if (GestureRecognized != null)
         {
             GestureRecognized();
         }
     }
 }
Beispiel #44
0
        // Constructor for LeapFrame
        public HandData(Hand hand)
        {
            m_id = hand.Id;

            m_fingers = new List<FingerData>();
            foreach (Finger f in hand.Fingers)
            {
                m_fingers.Add(new FingerData(f));
            }

            m_isFrontmost = (hand.Id == hand.Frame.Hands.Frontmost.Id);
            m_palmPosition = hand.PalmPosition;
            m_isValid = hand.IsValid;
        }
    public HandProxy(HandPool parent, IHandModel handModel, Hand hand) :
      base(hand.Id)
    {
      this.parent = parent;
      this.handModel = handModel;

      // Check to see if the hand model has been initialized yet
      if (handModel.GetLeapHand() == null) {
        handModel.SetLeapHand(hand);
        handModel.InitHand();
      } else {
        handModel.SetLeapHand(hand);
      }
      handModel.BeginHand();
    }
Beispiel #46
0
 //get latest frame called each second
 public static void Update()
 {
     if(_controller != null)
     {
         Frame lastFrame = _frame == null ? Frame.Invalid : _frame;
         _frame = _controller.Frame();
         if(_frame != null)
         {
             if(_frame.Hands.Count > 0)
             {
                 _hand = _frame.Hands[0];
             }
         }
     }
 }
Beispiel #47
0
        //Test gesture and throw an event if the gesture is validated
        public override void TestGesture(Hand hand)
        {
            //verify if it is the first frame of the position
            if (!IsRunning)
            {
                TestInitialGesture(hand);
            }
            else
            {
                //verify the dynamic of the gesture
                if (CurrentNbOfFrame <= MinNbOfFrame)
                {
                    if (TestDynamic(hand))
                    {
                        PreviousHand = hand;
                        CurrentNbOfFrame++;
                    }
                    else
                    {
                        IsRunning = false;
                        CurrentNbOfFrame = 0;
                    }
                }

                //verify the dynamic of the gesture or the end of gesture
                else if (CurrentNbOfFrame <= MaxNbOfFrame)
                {
                    if (TestDynamic(hand))
                    {
                        PreviousHand = hand;
                        CurrentNbOfFrame++;
                        TestEndGesture(hand);
                    }
                    else
                    {
                        IsRunning = false;
                        CurrentNbOfFrame = 0;
                    }
                }

                //case if the gesture is too long
                else
                {
                    IsRunning = false;
                    CurrentNbOfFrame = 0;
                }
            }
        }
		/*--------------------------------------------------------------------------------------------*/
		private void UpdateForFinger(Hand pLeapHand, Finger.FingerType pLeapFingerType) {
			Finger leapFinger = LeapUtil.GetValidFinger(pLeapHand, pLeapFingerType);

			if ( leapFinger == null ) {
				UpdateForNull();
				return;
			}

			Bone bone = leapFinger.Bone(Bone.BoneType.TYPE_DISTAL); //GC_ALLOC

			IsAvailable = true;
			Position = leapFinger.TipPosition.ToUnityScaled(); //GC_ALLOC
			Rotation = LeapUtil.CalcQuaternion(bone.Basis); //GC_ALLOC

			Size = leapFinger.Width*SizeScaleFactor;
		}
Beispiel #49
0
	public static void Update() 
	{	
		if( m_controller != null )
		{
			
			Frame lastFrame = m_Frame == null ? Frame.Invalid : m_Frame;
			m_Frame	= m_controller.Frame();
			if (m_Frame != null)
			{
				if (m_Frame.Hands.Count > 0)
				{
					m_Hand = m_Frame.Hands[0];
				}
				fingerCount = m_Frame.Fingers.Count;
			}
		}
	}
Beispiel #50
0
 /**
  * MakeHandRepresentation receives a Hand and combines that with an IHandModel to create a HandRepresentation
  * @param hand The Leap Hand data to be drive an IHandModel
  * @param modelType Filters for a type of hand model, for example, physics or graphics hands.
  */
 public override HandRepresentation MakeHandRepresentation(Hand hand, ModelType modelType)
 {
     Chirality handChirality = hand.IsRight ? Chirality.Right : Chirality.Left;
       HandRepresentation handRep = new HandProxy(this, hand, handChirality, modelType);
       for (int i = 0; i < ModelPool.Count; i++) {
     ModelGroup group = ModelPool[i];
     if (group.IsEnabled) {
       IHandModel model = group.TryGetModel(handChirality, modelType);
       if (model != null) {
     handRep.AddModel(model);
     modelToHandRepMapping.Add(model, handRep);
       }
     }
       }
       activeHandReps.Add(handRep);
       return handRep;
 }
		/*--------------------------------------------------------------------------------------------*/
		public void UpdateWithHand(Hand pLeapHand) {
			if ( pLeapHand == null ) {
				UpdateForNull();
				return;
			}
			
			if ( vLeapFingerType != null ) {
				UpdateForFinger(pLeapHand, (Finger.FingerType)vLeapFingerType);
				return;
			}
			
			if ( vIsPalm ) {
				UpdateForPalm(pLeapHand);
				return;
			}

			throw new Exception("Unhandled CursorType: "+Type);
		}
Beispiel #52
0
	public static void Update() 
	{	
		if( m_controller != null )
		{
			
			Frame lastFrame = m_Frame == null ? Frame.Invalid : m_Frame;
			m_Frame	= m_controller.Frame();
			if (m_Frame != null)
			{
				if (m_Frame.Hands.Count > 0)
				{
					m_Hand = m_Frame.Hands[0];
					normal = m_Hand.PalmNormal;
					direction = m_Hand.Direction;
				}
			}
		}
	}
Beispiel #53
0
    // Update is called once per frame
    void Update()
    {
        transform.RotateAround(new Vector3(0.0f,1.0f,0.0f),angle);
        Leap.Frame frame = controller.Frame();
        guiFrame=frame;
        if (!frame.Hands.Empty)
        {
            hand0 = frame.Hands[0];
            hand1 = frame.Hands[1];
            Leap.FingerList fingers = hand0.Fingers;
            if (!fingers.Empty)
            {
                Leap.Finger firstfinger = fingers[0];
                if ((hand1.Fingers.Count) >=3 ){
                    mustPause=true;
                }
                    mustPause=false;
                    if (!hand1.IsValid ||(hand1.IsValid && hand1.Fingers.Count<=2) ){
                            if (mustPause==false && frame.Hands[0].Id != hand1ID){  // (*)<--

                                //if (scratch==true) if (audio.pitch > 0.0f)  audio.pitch-=0.010f;

                                if (hand0.PalmPosition.x>0 ){
                                float moveStraightY = hand0.PalmPosition.y;
                                    if (moveStraightY >190) angle = 2.0f;
                                    if (moveStraightY >=130 && moveStraightY<190) {
                                            moveStraightY/=180;
                                            if (moveStraightY>1) moveStraightY=1;
                                            angle = moveStraightY;
                                            }
                                    else {
                                        if (angle > 0.0f) angle -=0.30f;
                                        if (angle <= 0.0f) angle =0.0f;

                                        }
                                }
                            }
                }
            }
        }
        else {
            if (angle<2.0f) angle +=0.086f;
        }
    }
Beispiel #54
0
        public static Hand MakeTestHand(int frameId, int handId, bool isLeft){
            List<Finger> fingers = new List<Finger>(5);
            fingers.Add(MakeThumb (frameId, handId, isLeft));
            fingers.Add(MakeIndexFinger (frameId, handId, isLeft));
            fingers.Add(MakeMiddleFinger (frameId, handId, isLeft));
            fingers.Add(MakeRingFinger (frameId, handId, isLeft));
            fingers.Add( MakePinky (frameId, handId, isLeft));

            Vector armWrist = new Vector(-7.05809944059f, 4.0f, 50.0f);
            Vector elbow = armWrist + 250f * Vector.Backward;

            // Adrian: The previous "armBasis" used "elbow" as a translation component.
            Arm arm = new Arm(elbow, armWrist,(elbow + armWrist)/2, Vector.Forward, 250f, 41f, LeapQuaternion.Identity);
            Hand testHand = new Hand(frameId,
            handId,
            1.0f,
            0.0f,
            0.0f,
            0.0f,
            0.0f,
            85f,
            isLeft,
            0.0f,
            arm,
                fingers,
                new Vector (0,0,0),
                new Vector(0,0,0),
                new Vector(0,0,0),
                Vector.Down,
                Vector.Forward,
                new Vector(-4.36385750984f, 6.5f, 31.0111342526f)
            );
            LeapTransform restPosition = LeapTransform.Identity;
            //restPosition.rotation = RotationFromTo(Vector.Up, Vector.Left).Multiply(RotationFromTo(Vector.Up, Vector.Left));
            restPosition.rotation = AngleAxis(180 * Constants.DEG_TO_RAD, Vector.Forward);
            if(isLeft){
                restPosition.translation = new Vector(80f, 120f, 0f);

            } else {
                restPosition.translation = new Vector(-80f, 120f, 0f);
                restPosition.MirrorX();
            }
            return testHand.TransformedCopy(restPosition);
        }
    public Hand makeHand(ref LEAP_HAND hand, Frame owningFrame)
    {
      LEAP_BONE arm = LeapC.PtrToStruct<LEAP_BONE>(hand.arm);
      Arm newArm = makeArm(ref arm);
      LEAP_PALM palm = LeapC.PtrToStruct<LEAP_PALM>(hand.palm);

      Hand newHand = new Hand(
        (int)owningFrame.Id,
        (int)hand.id,
        hand.confidence,
        hand.grab_strength,
        hand.grab_angle,
        hand.pinch_strength,
        hand.pinch_distance,
        palm.width,
        hand.type == eLeapHandType.eLeapHandType_Left,
        hand.visible_time,
        newArm,
        new List<Finger>(5),
        new Vector(palm.position.x, palm.position.y, palm.position.z),
        new Vector(palm.stabilized_position.x, palm.stabilized_position.y, palm.stabilized_position.z),
        new Vector(palm.velocity.x, palm.velocity.y, palm.velocity.z),
        new Vector(palm.normal.x, palm.normal.y, palm.normal.z),
        new Vector(palm.direction.x, palm.direction.y, palm.direction.z),
        newArm.NextJoint //wrist position
      );
      LEAP_DIGIT thumbDigit = LeapC.PtrToStruct<LEAP_DIGIT>(hand.thumb);
      newHand.Fingers.Insert(0, makeFinger(owningFrame, ref hand, ref thumbDigit, Finger.FingerType.TYPE_THUMB));

      LEAP_DIGIT indexDigit = LeapC.PtrToStruct<LEAP_DIGIT>(hand.index);
      newHand.Fingers.Insert(1, makeFinger(owningFrame, ref hand, ref indexDigit, Finger.FingerType.TYPE_INDEX));

      LEAP_DIGIT middleDigit = LeapC.PtrToStruct<LEAP_DIGIT>(hand.middle);
      newHand.Fingers.Insert(2, makeFinger(owningFrame, ref hand, ref middleDigit, Finger.FingerType.TYPE_MIDDLE));

      LEAP_DIGIT ringDigit = LeapC.PtrToStruct<LEAP_DIGIT>(hand.ring);
      newHand.Fingers.Insert(3, makeFinger(owningFrame, ref hand, ref ringDigit, Finger.FingerType.TYPE_RING));

      LEAP_DIGIT pinkyDigit = LeapC.PtrToStruct<LEAP_DIGIT>(hand.pinky);
      newHand.Fingers.Insert(4, makeFinger(owningFrame, ref hand, ref pinkyDigit, Finger.FingerType.TYPE_PINKY));

      return newHand;
    }
 private bool CheckTwoHandGestures(Hand leftHand, Hand rightHand, Action<IEnumerable<Result>> fireNewMotions)
 {
     var leftHandOld = _startFrame.Hands.Find(h => h.IsLeft);
     var rightHandOld = _startFrame.Hands.Find(h => h.IsRight);
     var rightToLeftOld = leftHandOld.PalmPosition - rightHandOld.PalmPosition;
     var center = rightHandOld.StabilizedPalmPosition +
                  (rightToLeftOld) /2;
     var cmd = new ScaleAndRotate
     {
         Scale = (leftHand.PalmPosition - rightHand.PalmPosition).MagnitudeSquared / (rightToLeftOld).MagnitudeSquared,
         Center = center,
         Rotation = Quaternion.Inverse(rightHandOld.Rotation.ToBetterQuaternion()) * rightHand.Rotation.ToBetterQuaternion(),
         LeftHand = leftHand.PalmPosition,
         RightHand = rightHand.PalmPosition
     };
     var result = new Result(cmd, 0.9);
     fireNewMotions(new List<Result> {result});
     return true;
 }
		/*--------------------------------------------------------------------------------------------*/
		internal void Rebuild(Hand pLeapHand) {
			if ( pLeapHand == null ) {
				IsAvailable = false;
				Position = Vector3.zero;
				Rotation = Quaternion.identity;
				Radius = 0;
				NavigateBackStrength = 0;
				DisplayStrength = 0;
				return;
			}

			IsAvailable = true;
			Position = pLeapHand.PalmPosition.ToUnityScaled();
			Rotation = LeapUtil.CalcQuaternion(pLeapHand.Basis); //GC_ALLOC
			Radius = 0.01f;

			FingerList leapFingers = pLeapHand.Fingers; //GC_ALLOC

			for ( int i = 0 ; i < leapFingers.Count ; i++ ) {
				Finger leapFinger = leapFingers[i]; //GC_ALLOC

				if ( leapFinger == null || !leapFinger.IsValid ) {
					continue;
				}

				Vector3 palmToFinger = leapFinger.TipPosition.ToUnityScaled()-Position; //GC_ALLOC
				Bone bone = leapFinger.Bone(Bone.BoneType.TYPE_DISTAL); //GC_ALLOC
				Quaternion boneRot = LeapUtil.CalcQuaternion(bone.Basis); //GC_ALLOC

				Radius = Math.Max(Radius, palmToFinger.sqrMagnitude);
				Rotation = Quaternion.Slerp(Rotation, boneRot, 0.1f);
			}

			Radius = (float)Math.Sqrt(Radius);
			Position += Rotation*Vector3.down*vSettings.DistanceFromPalm*Radius;

			NavigateBackStrength = pLeapHand.GrabStrength/vSettings.NavBackGrabThreshold;
			NavigateBackStrength = Mathf.Clamp(NavigateBackStrength, 0, 1);

			DisplayStrength = Vector3.Dot(pLeapHand.PalmNormal.ToUnity(), vSettings.PalmDirection);
			DisplayStrength = Mathf.Clamp((DisplayStrength-0.7f)/0.25f, 0, 1);
		}
 /**
  * MakeHandRepresentation receives a Hand and combines that with an IHandModel to create a HandRepresentation
  * @param hand The Leap Hand data to be drive an IHandModel
  * @param modelType Filters for a type of hand model, for example, physics or graphics hands.
  */
 public override HandRepresentation MakeHandRepresentation(Hand hand, ModelType modelType) {
   HandRepresentation handRep = null;
   for (int i = 0; i < ModelPool.Count; i++) {
     IHandModel model = ModelPool[i];
     bool isCorrectHandedness;
     Chirality handChirality = hand.IsRight ? Chirality.Right : Chirality.Left;
     isCorrectHandedness = model.Handedness == handChirality;
     if (!EnforceHandedness || model.Handedness == Chirality.Either) {
       isCorrectHandedness = true;
     }
     bool isCorrectModelType;
     isCorrectModelType = model.HandModelType == modelType;
     if (isCorrectModelType && isCorrectHandedness) {
         ModelPool.RemoveAt(i);
         handRep = new HandProxy(this, model, hand);
         break;
     }
   }
   return handRep;
 }
Beispiel #59
0
        /// <summary>
        /// Builds the hand.
        /// </summary>
        /// <returns>The hand.</returns>
        /// <param name="hand">Hand.</param>
        /// <param name="side">Side.</param>
        private static IList<IJoint> BuildHand(Hand hand, int side)
        {
            var handJoint = new OrientedJoint();

            if (!hand.IsValid)
            {
                return new IJoint[]{handJoint};
            }
            var palmNormal = hand.PalmNormal;
            var handPosition = hand.PalmPosition;

            handJoint.Orientation = new Vector4(palmNormal.x, palmNormal.y, palmNormal.z, 0);
            handJoint.Point = new Vector3(0, 0, -100);
            var joints = new List<IJoint> { handJoint };
            var fingers = hand.Fingers;
            joints.AddRange(from t in fingers let normal = t.Direction let position = t.TipPosition - handPosition select CreateFinger(position, normal, FingerType2JointType(t.Type(), side)));
            handJoint.Valid = true;

            return joints;
        }
Beispiel #60
0
        public static Hand MakeTestHand(int frameId, int handId, bool isLeft)
        {
            FingerList fingers = new FingerList(5);
            fingers.Add(MakeThumb (frameId, handId));
            fingers.Add(MakeIndexFinger (frameId, handId));
            fingers.Add(MakeMiddleFinger (frameId, handId));
            fingers.Add(MakeRingFinger (frameId, handId));
            fingers.Add( MakePinky (frameId, handId));

            Vector armWrist = new Vector(-7.05809944059f, 4.0f, 50.0f);
            Vector elbow = armWrist + 250f * Vector.Backward;
            Matrix armBasis = new Matrix(Vector.Right, Vector.Down, Vector.Forward);
            Arm arm = new Arm(elbow,armWrist,(elbow + armWrist)/2, Vector.Forward, 250f, 41f, Bone.BoneType.TYPE_DISTAL, armBasis);
            Hand testHand = new Hand(frameId,
            handId,
            1.0f,
            0.0f,
            0.0f,
            0.0f,
            0.0f,
            85f,
            isLeft,
            0.0f,
            arm,
                fingers,
                new Vector (0,0,0),
                new Vector(0,0,0),
                new Vector(0,0,0),
                Vector.Down,
                Vector.Backward,
                new Vector(-4.36385750984f, 6.5f, 31.0111342526f)
            );

            if(isLeft){
                return testHand;
            } else {
                Matrix leftToRight = new Matrix(Vector.Right, Vector.Up, Vector.Forward);
                return testHand.TransformedCopy(leftToRight);
            }
        }