// Constructor for ReplayFrame
 public FingerData(int id, bool isFrontmost, float tipPosition_x, float tipPosition_y, float tipPosition_z, bool isValid)
 {
     m_id = id;
     m_isFrontmost = isFrontmost;
     m_tipPosition = new Vector(tipPosition_x, tipPosition_y, tipPosition_z);
     m_isValid = isValid;
 }

 /**
    * Constructs a transformation matrix from the specified basis vectors.
    *
    * \include Matrix_Matrix_basis.txt
    *
    * @param xBasis A Vector specifying rotation and scale factors for the x-axis.
    * @param yBasis A Vector specifying rotation and scale factors for the y-axis.
    * @param zBasis A Vector specifying rotation and scale factors for the z-axis.
    * @since 1.0
    */
 public Matrix(Vector xBasis, Vector yBasis, Vector zBasis)
 {
     this._xBasis = xBasis;
     this._yBasis = yBasis;
     this._zBasis = zBasis;
     this._origin = Vector.Zero;
 }

 public Finger(int frameId,
                    int handId, 
                    int fingerId,
                    float timeVisible,
                    Vector tipPosition,
                    Vector tipVelocity,
                    Vector direction,
                    Vector stabilizedTipPosition,
                    float width,
                    float length,
                    bool isExtended,
                    Finger.FingerType type,
                    Bone metacarpal,
                    Bone proximal,
                    Bone intermediate,
                    Bone distal)
 {
     _type = type;
     _bones [0] = metacarpal;
     _bones [1] = proximal;
     _bones [2] = intermediate;
     _bones [3] = distal;
     _frameId = frameId;
     _id = (handId * 10) + fingerId;
     _handID = handId;
     _tipPosition = tipPosition;
     _tipVelocity = tipVelocity;
     _direction = direction;
     _width = width;
     _length = length;
     _isExtended = isExtended;
     _isValid = false;
     _stabilizedTipPosition = stabilizedTipPosition;
     _timeVisible = timeVisible;
 }

        public override void OnFrame(Controller controller)
        {
            Pointable pointable = FindPointable(controller);

            // use the pointable movement to move the mouse
            if (null != pointable)
            {
                //SafeWriteLine("pointable: " + pointable.Id + ", " + GetPosition(pointable).ToString());

                if (HasPrevTipPosition)
                {
                    Vector tipMovement = GetPosition(pointable) - PrevTipPosition;
                    //Vector tipMovement = pointable.TipVelocity; // too noisy; need better precision for this

                    Vector mouseMovement = LeapTransform.TransformToScreenSpace(tipMovement);
                    mouseMovement.x *= MouseSensitivityX;
                    mouseMovement.y *= MouseSensitivityY;

                    // there are discontinuities in the data we get back; ignore them and only perform reasonably small movements
                    if (mouseMovement.Magnitude < 300)
                    {
                        MouseWrapper.MoveMouse((int)mouseMovement.x, (int)mouseMovement.y);
                    }
                }

                HasPrevTipPosition = true;
                PrevPointableId = pointable.Id;
                PrevTipPosition = GetPosition(pointable);
            }
            else
            {
                SafeWriteLine("No pointable");

                HasPrevTipPosition = false;
                PrevPointableId = int.MinValue;
                PrevTipPosition = null;
            }

            // convert keyboard presses into mouse clicks. We only want to do this with certain presses,
            // where the key combination would not normally cause anything to happen.  We assume that no
            // one actually presses the right shift key. :)
            if ((KeyboardWrapper.IsKeyDown(Keys.LControlKey)) && (KeyboardWrapper.IsKeyDown(Keys.Space)) && (FrameSinceLastClick > 20))
            {
                MouseWrapper.LeftClick();
                FrameSinceLastClick = 0;
            }
            else if ((KeyboardWrapper.IsKeyDown(Keys.RControlKey)) && (KeyboardWrapper.IsKeyDown(Keys.Space) && (FrameSinceLastClick > 20)))
            {
                MouseWrapper.RightClick();
                FrameSinceLastClick = 0;
            }
            else
            {
                FrameSinceLastClick += 1;
                if (FrameSinceLastClick < 0)
                {
                    FrameSinceLastClick = 20;
                }
            }
        }

 protected override void ApplyPositionUpdate(PersistentHand hand, Vector change, int velocity)
 {
     var linesToScroll = (IsInverted ? -Lines : Lines) * Math.Sign(GetX(change));
     if (IsAccelerated)
         linesToScroll *= Convert.ToInt32(Math.Floor(change.Magnitude / MinDistance));
     InputSimulator.Mouse.VerticalScroll(linesToScroll);
 }

        protected override void ApplyPositionUpdate(PersistentHand hand, Vector change, int velocity)
        {
            double scaleX;
            double scaleY;
            if (velocity > 150)
            {
                scaleX = _ScaleFactorX;
                scaleY = _ScaleFactorY;
            }
            else if (velocity > 100)
            {
                scaleX = _ScaleFactorX * 2.0 / 3.0;
                scaleY = _ScaleFactorY * 2.0 / 3.0;
            }
            else if (velocity > 50)
            {
                scaleX = _ScaleFactorX * 1.0 / 3.0;
                scaleY = _ScaleFactorY * 1.0 / 3.0;
            }
            else
            {
                scaleX = 1;
                scaleY = 1;
            }
            var x = Convert.ToInt32(GetX(change) * 2 * scaleX);
            var y = Convert.ToInt32(GetY(change) * 2 * scaleY);

            InputSimulator.Mouse.MoveMouseBy(x, -y);
        }

 /**
  * Provides the translation matrix to convert Leap transform data to the Unity space of a specific Unity Transform.
  * @param t The Unity Transform to which the Leap transformation data is translated
  */
 public static Matrix GetLeapMatrix(Transform t) {
   Vector xbasis = new Vector(t.right.x, t.right.y, t.right.z) * t.lossyScale.x * MM_TO_M;
   Vector ybasis = new Vector(t.up.x, t.up.y, t.up.z) * t.lossyScale.y * MM_TO_M;
   Vector zbasis = new Vector(t.forward.x, t.forward.y, t.forward.z) * -t.lossyScale.z * MM_TO_M;
   Vector trans = new Vector(t.position.x, t.position.y, t.position.z);
   return new Matrix(xbasis, ybasis, zbasis, trans);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Leap.GestureSpace"/> class
        /// using the predefined constants to define the workspace size.
        /// </summary>
        public GestureSpace()
        {
            Vector topLeft = new Vector(Left, 0, Top);
            Vector bottomRight = new Vector(Right, 0, Bottom);

            xz = new Rectangle((int)topLeft.x, (int)topLeft.z, (int)(bottomRight.x - topLeft.x), (int)Math.Abs(topLeft.z - bottomRight.z));
        }

 /**
  * Constructs a finger.
  *
  * Generally, you should not create your own finger objects. Such objects will not
  * have valid tracking data. Get valid finger objects from a hand in a frame
  * received from the service.
  *
  * @param frameId The id of the frame this finger appears in.
  * @param handId The id of the hand this finger belongs to.
  * @param fingerId The id of this finger (handId + 0-4 for finger position).
  * @param timeVisible How long this instance of the finger has been visible.
  * @param tipPosition The position of the finger tip.
  * @param tipVelocity The velocity of the finger tip.
  * @param direction The pointing direction of the finger.
  * @param stabilizedTipPosition The stabilized tip position.
  * @param width The average width of the finger.
  * @param length The length of the finger.
  * @param isExtended Whether the finger is more-or-less straight.
  * @param type The finger name.
  * @param metacarpal The first bone of the finger (inside the hand).
  * @param proximal The second bone of the finger
  * @param intermediate The third bone of the finger.
  * @param distal The end bone.
  * @since 3.0
  */
 public Finger(long frameId,
               int handId,
               int fingerId,
               float timeVisible,
               Vector tipPosition,
               Vector tipVelocity,
               Vector direction,
               Vector stabilizedTipPosition,
               float width,
               float length,
               bool isExtended,
               Finger.FingerType type,
               Bone metacarpal,
               Bone proximal,
               Bone intermediate,
               Bone distal)
 {
   Type = type;
   _bones[0] = metacarpal;
   _bones[1] = proximal;
   _bones[2] = intermediate;
   _bones[3] = distal;
   _frameId = frameId;
   Id = (handId * 10) + fingerId;
   HandId = handId;
   TipPosition = tipPosition;
   TipVelocity = tipVelocity;
   Direction = direction;
   Width = width;
   Length = length;
   IsExtended = isExtended;
   StabilizedTipPosition = stabilizedTipPosition;
   TimeVisible = timeVisible;
 }

        private void CalculateRealScreenPosition(Screen screen, Vector intersection)
        {
            CursorPositionX += (intersection.x * screen.WidthPixels - CursorPositionX) * VelocityResponse;
            CursorPositionY += ((1 - intersection.y) * screen.HeightPixels - CursorPositionY) * VelocityResponse;

            mouseFacade.SetCursorPosition((int)CursorPositionX, (int)CursorPositionY);
        }

 public PositionTracker(PersistentHand hand, Func<PersistentHand, Vector> positionGetter, Func<PersistentHand, int> velocityGetter)
 {
     Hand = hand;
     PositionGetter = positionGetter;
     VelocityGetter = velocityGetter;
     _CurrentPosition = PositionGetter(Hand);
 }

 public void DrawBasis(Vector position, LeapTransform basis, float scale)
 {
     Vector3 origin = position.ToVector3();
       Debug.DrawLine(origin, origin + basis.xBasis.ToVector3() * scale, Color.red);
       Debug.DrawLine(origin, origin + basis.yBasis.ToVector3() * scale, Color.green);
       Debug.DrawLine(origin, origin + basis.zBasis.ToVector3() * scale, Color.blue);
 }

 public Vector TransformToScreenSpace(Vector leapVector)
 {
     if (Orientation.Equals(SensorOrientation.DesktopLeftward))
     {
         return new Vector(leapVector.x, -leapVector.y, 0);
     }
     else if (Orientation.Equals(SensorOrientation.MonitorLeftward))
     {
         return new Vector(leapVector.x, leapVector.z, 0);
     }
     else if (Orientation.Equals(SensorOrientation.MonitorRightward))
     {
         return new Vector(leapVector.x, -leapVector.z, 0);
     }
     else if (Orientation.Equals(SensorOrientation.MonitorSkyward))
     {
         return new Vector(-leapVector.z, leapVector.x, 0);
     }
     else if (Orientation.Equals(SensorOrientation.MonitorEarthward))
     {
         return new Vector(-leapVector.z, -leapVector.x, 0);
     }
     else
     {
         Debug.Assert(false);
         return new Vector();
     }
 }

 public GestureDetectedEventArgs(GestureType type, float speed, Vector direction, long timestamp)
 {
     m_type = type;
     m_speed = speed;
     m_direction = direction;
     m_timestamp = timestamp;
 }

        private long TimeDifference; // difference between time stamps

        #endregion Fields

        #region Methods

        public double cursorFingerVelocity(Vector pos1, Vector pos2, Vector pos3, Vector pos4)
        {
            double fingerVelocity = 0;

            fingerVelocity = (pos1.y - pos2.y) / 0.1;

            return fingerVelocity;
        }

 // Constructor for ReplayFrame
 public HandData(int id, int nbOfFingers, bool isFrontmost, float palmPosition_x, float palmPosition_y, float palmPosition_z, bool isValid)
 {
     m_id = id;
     m_nbOfFingers = nbOfFingers;
     m_isFrontmost = isFrontmost;
     m_palmPosition = new Vector(palmPosition_x, palmPosition_y, palmPosition_z);
     m_isValid = isValid;
 }

  static Finger MakeMiddleFinger(int frameId, int handId){
     //Middle Finger
     Vector position = new Vector(2.78877821918f, 4.0f, -23.252105626f);
     Vector forward = new Vector(0.0295207858556f, -0.148340452932f, -0.988495641481f);
     Vector up = new Vector(-0.145765270107f, 0.977715980076f, -0.151075968756f);
     float[]  jointLengths = {64.60f, 44.63f, 26.33f, 17.40f};
     return MakeFinger (Finger.FingerType.TYPE_MIDDLE, position, forward, up, jointLengths, frameId, handId, handId + 2);
 }

 private static IJoint CreateFinger(Vector position, Vector normal, JointType jt)
 {
     var finger = new OrientedJoint();
     finger.JointType = jt;
     finger.Point = new Vector3(position.x, position.y, position.z);
     finger.Orientation = new Vector4(10 * normal.x, 10 * normal.y, 10 * normal.z, 0);
     return finger;
 }

 public LeapTransform(Vector translation, LeapQuaternion rotation, Vector scale)
     : this()
 {
     _scale = scale;
       // these are non-trival setters.
       this.translation = translation;
       this.rotation = rotation; // Calls validateBasis
 }

  static Finger MakeThumb(int frameId, int handId){
     //Thumb
     Vector position = new Vector(19.3382610281f, -6.0f, 53.168484654f);
     Vector forward = new Vector(0.436329113772f, 0.0f, -0.899787143982f);
     Vector up = new Vector(0.804793943718f, 0.447213915513f, 0.390264553767f);
     float[] jointLengths = {0.0f, 46.22f, 31.57f, 21.67f};
     return MakeFinger (Finger.FingerType.TYPE_THUMB, position, forward, up, jointLengths, frameId, handId, handId + 0);
 }