protected override FingerGestures.FingerPhase GetPhase( Finger finger )
    {
        int button = finger.Index;

        // did we just press it?
        if( Input.GetMouseButtonDown( button ) )
            return FingerPhase.Began;

        // mouse button down?
        if( Input.GetMouseButton( button ) )
        {
            // find out if the mouse has moved since last update
            Vector3 delta = GetPosition( finger ) - finger.Position;

            if( delta.sqrMagnitude < 1.0f )
                return FingerPhase.Stationary;

            return FingerPhase.Moved;
        }

        // did we just release the button?
        if( Input.GetMouseButtonUp( button ) )
            return FingerPhase.Ended;
        
        return FingerPhase.None;
    }

 // Returns the direction the given bone is facing on the finger.
 protected Vector3 GetBoneDirection(Finger finger, int bone)
 {
     Vector3 difference = finger.JointPosition((Finger.FingerJoint)(bone + 1)).ToUnity() -
                      finger.JointPosition((Finger.FingerJoint)(bone)).ToUnity();
     difference.Normalize();
     return difference;
 }

	public static PointerType ConvertType(Hand hand, Finger.FingerType fingerType)
	{
		if (hand.IsRight) {
			switch (fingerType) {
			case Finger.FingerType.TYPE_THUMB:
				return PointerType.RightThumb;
			case Finger.FingerType.TYPE_INDEX:
				return PointerType.RightIndex;
			case Finger.FingerType.TYPE_MIDDLE:
				return PointerType.RightMiddle;
			case Finger.FingerType.TYPE_RING:
				return PointerType.RightRing;
			case Finger.FingerType.TYPE_PINKY:
				return PointerType.RightPinky;
			}
		} else if (hand.IsLeft) {
			switch (fingerType) {
			case Finger.FingerType.TYPE_THUMB:
				return PointerType.LeftThumb;
			case Finger.FingerType.TYPE_INDEX:
				return PointerType.LeftIndex;
			case Finger.FingerType.TYPE_MIDDLE:
				return PointerType.LeftMiddle;
			case Finger.FingerType.TYPE_RING:
				return PointerType.LeftRing;
			case Finger.FingerType.TYPE_PINKY:
				return PointerType.LeftPinky;
			}
		}
		
		return PointerType.NULL;
		
	}

 private void TrackIndex(Finger finger, PXCMHandData.IHand handInfo) {
     SetJointdata(handInfo, PXCMHandData.JointType.JOINT_INDEX_BASE, finger.BaseJoint);
     SetJointdata(handInfo, PXCMHandData.JointType.JOINT_INDEX_JT1, finger.FirstJoint);
     SetJointdata(handInfo, PXCMHandData.JointType.JOINT_INDEX_JT2, finger.SecondJoint);
     SetJointdata(handInfo, PXCMHandData.JointType.JOINT_INDEX_TIP, finger);
     SetFingerOpenness(finger, PXCMHandData.FingerType.FINGER_INDEX, handInfo);
 }

    public override void UpdateFinger(Finger finger, Transform deviceTransform,
                                     Vector3 palm_normal, Vector3 palm_direction)
    {
        Vector3 last_bone_normal = palm_normal;
        Vector3 last_bone_direction = palm_direction;

        for (int i = 0; i < NUM_BONES; ++i) {
          // Set velocity.
          Vector3 next_bone_position = deviceTransform.TransformPoint(GetBonePosition(finger, i));
          bones[i].rigidbody.velocity = (next_bone_position - bones[i].transform.position) *
                                    ((1 - easing) / Time.fixedDeltaTime);

          // Set angular velocity.
          Vector3 bone_direction = deviceTransform.rotation * GetBoneDirection(finger, i);
          Vector3 bone_normal = Quaternion.FromToRotation(last_bone_direction, bone_direction) * last_bone_normal;

          Quaternion delta_rotation = Quaternion.LookRotation(bone_direction, -bone_normal) *
                                  Quaternion.Inverse(bones[i].transform.rotation);
          float angle = 0.0f;
          Vector3 axis = Vector3.zero;
          delta_rotation.ToAngleAxis(out angle, out axis);

          if (angle >= 180) {
        angle = 360 - angle;
        axis  = -axis;
          }
          if (angle != 0)
        bones[i].rigidbody.angularVelocity = (1 - easing) * angle * axis;

          last_bone_direction = bone_direction;
          last_bone_normal = bone_normal;
        }
    }

 void OnTriggerEnter(Collider collider)
 {
     if (IsFinger(collider) && gm.getColorChoserActive()) {
         if (!hasSphere)
         {
             fingerModel = collider.gameObject.GetComponentInParent<FingerModel>();
             f = fingerModel.GetLeapFinger();
     //                Debug.Log(f);
             if(fingerModel.fingerType.ToString().Equals("TYPE_INDEX"))
             {
                 col = collider;
                 // Neue Sphere erstellen mit der Farbe vom Bucket
                 QuizManager.setHasColor(true);
                 Destroy(drop);
                 Colors.drop = Instantiate(Resources.Load("Drop")) as GameObject;
                 Colors.drop.transform.position = new Vector3(0, 1.5F, 0);
                 Colors.drop.transform.localScale = new Vector3(0.5F,0.5F,0.5F);
                 Renderer m = Colors.drop.GetComponent<Renderer>();
                 QuizManager.shaderName = bucketMat.name;
                 m.material = bucketMat;
                 Colors.drop.transform.position = fingerModel.GetTipPosition();
                 hasSphere = true;
                 QuizManager.setHasColor(true);
             }
         }
     }
     if (IsHand(collider))
     {
      //           print("Hand berührt");
     }
 }

 public Hand(Side side) {
     Thumb = new Finger();
     Index = new Finger();
     Middle = new Finger();
     Ring = new Finger();
     Pinky = new Finger();
     Side = side;
 }

 public GeneInfo.GeneInfoC_Reflect Finger2C_Reflect(Finger finger)
 {
     Vector3 point = Camera.main.ScreenToWorldPoint (finger.Positions [0]);
     point.z = 0;
     Debug.LogFormat ("Reflet:ScreenPoint {0},{1}", finger.Positions [0].x, finger.Positions [0].y);
     Debug.LogFormat ("Reflet:WorldPoint {0},{1}", point.x, point.y);
     return new GeneInfo.GeneInfoC_Reflect (point);
 }

 private IKSegment[] makeFinger(Finger finger)
 {
     List<IKSegment> chain = new List<IKSegment>();
     addToChain(ref chain, finger.Base);
     addToChain(ref chain, finger.Mid);
     addToChain(ref chain, finger.End);
     return chain.ToArray();
 }

    UnityEngine.Touch GetTouch( Finger finger )
    {
        int touchIndex = finger2touchMap[finger.Index];

        if( touchIndex == -1 )
            return nullTouch;

        return Input.touches[touchIndex];
    }

 public GeneInfo.GeneInfoC_Curve Finger2C_Curbe(Finger finger)
 {
     List<Vector3> pts = new List<Vector3> ();
     for (int i = 0; i < finger.Positions.Count; i++) {
         Vector3 pt = Camera.main.ScreenToWorldPoint(finger.Positions[i]);
         pt.z = 0;
         pts.Add(pt);
     }
     return new GeneInfo.GeneInfoC_Curve (pts);
 }

    public GeneInfo.GeneInfoC_Board Finger2C_Borard(Finger finger0, Finger finger1)
    {
        Vector3 p1 = Camera.main.ScreenToWorldPoint (finger0.Positions [0]);
        Vector3 p2 = Camera.main.ScreenToWorldPoint (finger1.Positions [0]);
        p1.z = 0f;
        p2.z = 0f;

        Debug.LogFormat ("Board:ScreenPoint {0},{1},{2},{3}", finger0.Positions [0].x, finger0.Positions [0].y, finger1.Positions [0].x, finger1.Positions [0].y);
        Debug.LogFormat ("Board:WorldPoint {0},{1},{2},{3}", p1.x, p1.y, p2.x, p2.y);
        return new GeneInfo.GeneInfoC_Board (p1, p2);
    }

    void UpdatePosition()
    {
        #if UNITY_EDITOR
            Finger f = new Finger();
            f.x = Input.mousePosition.x;
            f.y = Input.mousePosition.y;
            Vector3 mousePosition = Camera.main.ScreenToWorldPoint(new Vector3(f.x, f.y));
        transform.position=mousePosition;

        #endif
    }

 public static LEAP_DIGIT CreateDigit(Finger finger) {
   LEAP_DIGIT digit = new LEAP_DIGIT();
   digit.finger_id = finger.Id;
   digit.metacarpal = CreateBone(finger.Bone(Bone.BoneType.TYPE_METACARPAL));
   digit.proximal = CreateBone(finger.Bone(Bone.BoneType.TYPE_PROXIMAL));
   digit.intermediate = CreateBone(finger.Bone(Bone.BoneType.TYPE_INTERMEDIATE));
   digit.distal = CreateBone(finger.Bone(Bone.BoneType.TYPE_DISTAL));
   digit.tip_velocity = new LEAP_VECTOR(finger.TipVelocity);
   digit.stabilized_tip_position = Vector3.zero.ToCVector(); //HACK: stabilized position is sometimes NaN, ignore it
   digit.is_extended = finger.IsExtended ? 1 : 0;
   return digit;
 }

        public TestOSC(IEnumerable<string> args)
        {
            allPixels = new VirtualPixel1D("All Pixels", 28 + 50);

            loopSeq = new Controller.Sequence("Loop Seq");
            fingers = new Finger[10];
            for (int i = 0; i < 10; i++)
                fingers[i] = new Finger();

            testDimmer = new Dimmer("Test");

            this.oscServer = new Expander.OscServer(5555);
        }

 /// <summary>
 /// Determines whether this instance is double tap the specified finger1 finger2.
 /// </summary>
 /// <returns><c>true</c> if this instance is double tap the specified finger1 finger2; otherwise, <c>false</c>.</returns>
 /// <param name="finger1">Finger1.</param>
 /// <param name="finger2">Finger2.</param>
 public bool IsDoubleTap(Finger finger1,Finger finger2)
 {
     if (!IsTap (finger1) || !IsTap (finger2)) {
         return false;
     }
     if (Mathf.Abs (finger1.Times [0] - finger2.Times [0]) > toleranceTime) {
         return false;
     }
     if (Mathf.Abs (finger1.Times [finger1.Times.Count - 1] - finger2.Times [finger2.Times.Count - 1]) > toleranceTime) {
         return false;
     }
     return true;
 }

 void OnTriggerEnter(Collider collider)
 {
     if (IsFinger(collider) && gm.getColorChoserActive() && QuizManager.getHasColor())
     {
         fingerModel = collider.gameObject.GetComponentInParent<FingerModel>();
         f = fingerModel.GetLeapFinger();
         controller = fingerModel.GetController();
         shoeRender.material = QuizManager.getChosenMaterial();
         //shoeRender.material = new Material(Shader.Find(QuizManager.shaderName));
         QuizManager.changedObjects.Add(shoeRender);
         QuizManager.setHasColor(false);
         Destroy(Colors.drop);
     }
 }

 public GeneInfo.GeneInfoC_Jump Finger2C_Jump(Finger finger)
 {
     Vector3 meanPt = Camera.main.ScreenToWorldPoint (finger.Positions [0]);
     float range = 0.0f;
     for (int i = 0; i < finger.Positions.Count; i++) {
         Vector3 pt = Camera.main.ScreenToWorldPoint(finger.Positions[i]);
         meanPt += pt;
     }
     meanPt /= finger.Positions.Count;
     for (int i = 0; i < finger.Positions.Count; i++) {
         float dist = Vector2.Distance(finger.Positions[0],finger.Positions[i]);
         if(range < dist){
             range = dist;
         }
     }
     return new GeneInfo.GeneInfoC_Jump (meanPt, range * JUMP_POWER_MULTIPLIER);
 }

 /// <summary>
 /// Determines whether this instance is circle the specified finger.
 /// </summary>
 /// <returns><c>true</c> if this instance is circle the specified finger; otherwise, <c>false</c>.</returns>
 /// <param name="finger">Finger.</param>
 public bool IsCircle(Finger finger)
 {
     bool isLongTrace = false;
     for (int i = 0; i < finger.Positions.Count; i++) {
         if (!isLongTrace) {
             if (Vector2.Distance (finger.Positions [0], finger.Positions [i]) >= toleranceCircleDistance) {
                 isLongTrace = true;
             }
         } else{
             if (Vector2.Distance (finger.Positions [0], finger.Positions [i]) < toleranceCircleDistance) {
                 finger.Positions.RemoveRange (i, finger.Positions.Count - i);
                 return true;
             }
         }
     }
     return false;
 }

    protected void JumpToPosition(Finger finger, Transform deviceTransform,
                                Vector3 palm_normal, Vector3 palm_direction)
    {
        Vector3 last_bone_normal = palm_normal;
        Vector3 last_bone_direction = palm_direction;

        for (int i = 0; i < NUM_BONES; ++i) {
          if (bones[i] != null) {
        // Set position.
        bones[i].transform.position = deviceTransform.TransformPoint(GetBonePosition(finger, i));

        // Set rotation.
        Vector3 bone_direction = deviceTransform.rotation * GetBoneDirection(finger, i);
        last_bone_normal = Quaternion.FromToRotation(last_bone_direction, bone_direction) * last_bone_normal;
        bones[i].transform.rotation = Quaternion.LookRotation(bone_direction, -last_bone_normal);
        last_bone_direction = bone_direction;
          }
        }
    }