# HG changeset patch
# User PAMPHILE Jonathan <pamphile@efrei.fr>
# Date 1258619295 -3600
# Node ID 09c4d30fe8d10828ef0172e180a0e3fe6341cb0f
# Parent  0699cab5cbb377c2093267098856897d3b118234
Indentations

diff -r 0699cab5cbb3 -r 09c4d30fe8d1 src/FingersDance.GestureControl/GestureControl.cs
--- a/src/FingersDance.GestureControl/GestureControl.cs	Wed Nov 18 13:06:55 2009 +0100
+++ b/src/FingersDance.GestureControl/GestureControl.cs	Thu Nov 19 09:28:15 2009 +0100
@@ -156,7 +156,7 @@
         {
             try
             {
-                Thread.Sleep(1000);
+                Thread.Sleep(550);
                 CommonPattern();
                 string gesture = GetPattern(_Gestures);
                 if (gesture != "None")
diff -r 0699cab5cbb3 -r 09c4d30fe8d1 src/FingersDance.GestureControl/GestureVector.cs
--- a/src/FingersDance.GestureControl/GestureVector.cs	Wed Nov 18 13:06:55 2009 +0100
+++ b/src/FingersDance.GestureControl/GestureVector.cs	Thu Nov 19 09:28:15 2009 +0100
@@ -37,7 +37,7 @@
         /// <param name="precision"></param>
         public SurfaceGesture(List<SurfaceGesturePoint> list, int precision)
         {
-            this.Precision = precision;
+            this.Precision = 20;
             this.Generate(list);
         }
         #endregion
@@ -93,7 +93,7 @@
             /*if (this.GetPattern() != "None")
                 return true;
             else*/
-            return false;
+                return false;
         }
         /// <summary>
         /// Get distance between two points
@@ -124,62 +124,590 @@
         /// </summary>
         /// <param name="list"></param>
         private void Generate(List<SurfaceGesturePoint> list)
-        {
+        {            
+            SurfaceGestureVectorDirection lastDirection = SurfaceGestureVectorDirection.NONE;
+            int lastPoint = 0;
+            SurfaceGesturePoint LastChange = list[0];
+
+            /////// TEST///////////
+            if (this.GenerateCourb(list, 5) == true)
+                return;
             this.Clear();
-            if (list.Count < 2)
+            ///////////////////////
+
+            for (int i = 0; i < list.Count - 1; i++)
             {
-                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.TAP, Lenght = 0 });
-                return;
+                if (GetHorizontal(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.UP && lastDirection != SurfaceGestureVectorDirection.UP)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.UP;
+                }
+                else if (GetHorizontal(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.DOWN && lastDirection != SurfaceGestureVectorDirection.DOWN)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.DOWN;
+                }
+                else if (GetHorizontal(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.UPLEFT && lastDirection != SurfaceGestureVectorDirection.UPLEFT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.UPLEFT;
+                }
+                else if (GetHorizontal(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.UPRIGHT && lastDirection != SurfaceGestureVectorDirection.UPRIGHT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.UPRIGHT;
+                }
+                else if (GetHorizontal(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.DOWNLEFT && lastDirection != SurfaceGestureVectorDirection.DOWNLEFT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.DOWNLEFT;
+                }
+                else if (GetHorizontal(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.DOWNRIGHT && lastDirection != SurfaceGestureVectorDirection.DOWNRIGHT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.DOWNRIGHT;
+                }
+                else if (GetVertical(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.LEFT && lastDirection != SurfaceGestureVectorDirection.LEFT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = (Math.Abs(LastChange.X - list[i + 1].X)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.LEFT;
+                }
+                else if (GetVertical(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.RIGHT && lastDirection != SurfaceGestureVectorDirection.RIGHT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = (Math.Abs(LastChange.X - list[i + 1].X)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.RIGHT;
+                }
+                else if (GetVertical(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.UPLEFT && lastDirection != SurfaceGestureVectorDirection.UPLEFT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.UPLEFT;
+                }
+                else if (GetVertical(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.UPRIGHT && lastDirection != SurfaceGestureVectorDirection.UPRIGHT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.UPRIGHT;
+                }
+                else if (GetVertical(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.DOWNLEFT && lastDirection != SurfaceGestureVectorDirection.DOWNLEFT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.DOWNLEFT;
+                }
+                else if (GetVertical(list[lastPoint], list[i + 1]) == SurfaceGestureVectorDirection.DOWNRIGHT && lastDirection != SurfaceGestureVectorDirection.DOWNRIGHT)
+                {
+                    this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = (Math.Abs(LastChange.Y - list[i + 1].Y)), Origin = list[lastPoint] });
+                    LastChange = list[i + 1];
+                    lastDirection = SurfaceGestureVectorDirection.DOWNRIGHT;
+                }
+                ++lastPoint;
             }
 
-            List<SurfaceGesturePoint> Points = new List<SurfaceGesturePoint>();
-            List<SurfaceGestureVector> Vectors = new List<SurfaceGestureVector>();
-            
-            for (int index = 1; index <= list.Count; index++)
-            {
-                if (index == list.Count / 2 || index == list.Count)
-                {
-                    SurfaceGestureVector verctorTemp = AnalysePoints(Points);
-                    if (Vectors.Count == 0 || !Vectors[Vectors.Count - 1].Direction.Equals(verctorTemp.Direction))
-                        Vectors.Add(verctorTemp);
-                    Points.Clear();
-                }
-                else
-                    Points.Add(list[index]);
-            }
-            foreach (SurfaceGestureVector elt in Vectors)
-                this.Add(elt);
-        }
+            //  Analyse des extrémités de la gesture
+            /*
 
-        SurfaceGestureVector AnalysePoints(List<SurfaceGesturePoint> list)
-        {
             double diffX = Math.Abs(list[0].X - list[list.Count - 1].X);
             double diffY = Math.Abs(list[0].Y - list[list.Count - 1].Y);
 
             if (diffX < 10 && diffY > 10)
             {
-                if (list[0].Y > list[list.Count - 1].Y)
-                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = 0, Origin = list[0] });
+                this.Clear();
+                if (up > down)
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up });
                 else
-                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = 0, Origin = list[0] });
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down });
             }
             else if (diffY < 10 && diffX > 10)
             {
-                if (list[list.Count - 1].X > list[0].X)
-                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = 0, Origin = list[0] });
+                this.Clear();
+                if (left > right)
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left });
                 else
-                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = 0, Origin = list[0] });
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right });
+            }
+
+            */
+
+            //  Analyse détaillée de la gesture
+
+            List<SurfaceGestureVector> ThisTemp = new List<SurfaceGestureVector>();
+            List<SurfaceGestureVector> temp = new List<SurfaceGestureVector>();
+            List<SurfaceGestureVector> Tempo = new List<SurfaceGestureVector>();
+
+            if ((this.Count / 10) >= 1)
+            {
+                /*
+                for (int i = 1; i < this.Count + 1; i++)
+                {
+                    temp.Add(this[i-1]);
+                    if (i % 7 == 0)
+                    {
+                        SurfaceGestureVector result = Analyse(temp);
+                        if (ThisTemp.Count == 0 || !ThisTemp[ThisTemp.Count - 1].Direction.Equals(result.Direction))
+                            ThisTemp.Add(result);
+                        else
+                            ThisTemp[ThisTemp.Count - 1].Lenght += result.Lenght;
+                        temp.Clear();
+                    }
+                }
+                if (temp.Count > 0)
+                {
+                    SurfaceGestureVector result = Analyse(temp);
+                    if (ThisTemp[ThisTemp.Count - 1].Direction.Equals(result.Direction))
+                        ThisTemp[ThisTemp.Count - 1].Lenght += result.Lenght;
+                    else
+                        ThisTemp.Add(result);
+                    temp.Clear();
+                }
+                this.Clear();
+                foreach(SurfaceGestureVector elt in ThisTemp)
+                    this.Add(elt);
+                 */
+                switch (this.Count / 10)
+                {
+                    case 1:
+                        ThisTemp.Add(Analyse(this));
+                        this.Clear();
+                        if (ThisTemp.Count > 1)
+                        {
+                            double up = 0, down = 0, left = 0, right = 0, upleft = 0, upright = 0, downleft = 0, downright = 0;
+                            foreach (SurfaceGestureVector elt in ThisTemp)
+                            {
+                                switch (elt.Direction)
+                                {
+                                    case SurfaceGestureVectorDirection.DOWN:
+                                        down += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.DOWNLEFT:
+                                        downleft += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.DOWNRIGHT:
+                                        downright += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.LEFT:
+                                        left += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.RIGHT:
+                                        right += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.UP:
+                                        up += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.UPLEFT:
+                                        upleft += elt.Lenght;
+                                        break;
+                                    case SurfaceGestureVectorDirection.UPRIGHT:
+                                        upright += elt.Lenght;
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            }
+                            if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(up))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upleft))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upright))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(down))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downleft))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downright))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = downright, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(left))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = null });
+                            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(right))
+                                this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = null });
+                        }
+                        else
+                            this.Add(ThisTemp[0]);
+                        break;
+                    case 2:
+                        for (int index = 1; index <= this.Count; index++)
+                        {
+                            if (index == this.Count / 2 || index == this.Count)
+                            {
+                                ThisTemp.Add(Analyse(temp));
+                                if (ThisTemp.Count > 1)
+                                {
+                                    double up = 0, down = 0, left = 0, right = 0, upleft = 0, upright = 0, downleft = 0, downright = 0;
+                                    foreach (SurfaceGestureVector elt in ThisTemp)
+                                    {
+
+                                        switch (elt.Direction)
+                                        {
+                                            case SurfaceGestureVectorDirection.DOWN:
+                                                down += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.DOWNLEFT:
+                                                downleft += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.DOWNRIGHT:
+                                                downright += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.LEFT:
+                                                left += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.RIGHT:
+                                                right += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UP:
+                                                up += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UPLEFT:
+                                                upleft += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UPRIGHT:
+                                                upright += elt.Lenght;
+                                                break;
+                                        }
+                                    }
+                                    if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(up))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upleft))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upright))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(down))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downleft))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downright))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = downright, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(left))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(right))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = null });
+                                }
+                                else
+                                    Tempo.Add(ThisTemp[0]);
+                            }
+                            else
+                                ThisTemp.Add(this[index]);
+                        }
+                        this.Clear();
+                        if (Tempo[0].Direction.Equals(Tempo[1].Direction))
+                            this.Add(Tempo[0]);
+                        else
+                            foreach (SurfaceGestureVector elt in Tempo)
+                                this.Add(elt);
+                        break;
+                    case 3:
+                        for (int index = 1; index <= this.Count; index++)
+                        {
+                            if (index == this.Count / 3 || index == this.Count)
+                            {
+                                ThisTemp.Add(Analyse(temp));
+                                if (ThisTemp.Count > 1)
+                                {
+                                    double up = 0, down = 0, left = 0, right = 0, upleft = 0, upright = 0, downleft = 0, downright = 0;
+                                    foreach (SurfaceGestureVector elt in ThisTemp)
+                                    {
+
+                                        switch (elt.Direction)
+                                        {
+                                            case SurfaceGestureVectorDirection.DOWN:
+                                                down += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.DOWNLEFT:
+                                                downleft += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.DOWNRIGHT:
+                                                downright += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.LEFT:
+                                                left += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.RIGHT:
+                                                right += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UP:
+                                                up += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UPLEFT:
+                                                upleft += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UPRIGHT:
+                                                upright += elt.Lenght;
+                                                break;
+                                        }
+                                    }
+                                    if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(up))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upleft))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upright))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(down))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downleft))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downright))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = downright, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(left))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(right))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = null });
+                                }
+                                else
+                                    Tempo.Add(ThisTemp[0]);
+                            }
+                            else
+                                ThisTemp.Add(this[index]);
+                        }
+                        this.Clear();
+                        if (Tempo[0].Direction.Equals(Tempo[1].Direction) && Tempo[0].Direction.Equals(Tempo[2].Direction))
+                            this.Add(Tempo[0]);
+                        else
+                            foreach (SurfaceGestureVector elt in Tempo)
+                                this.Add(elt);
+                        break;
+                    default:
+                        for (int index = 1; index <= this.Count; index++)
+                        {
+                            if (index == this.Count / 4 || index == this.Count)
+                            {
+                                ThisTemp.Add(Analyse(temp));
+                                if (ThisTemp.Count > 1)
+                                {
+                                    double up = 0, down = 0, left = 0, right = 0, upleft = 0, upright = 0, downleft = 0, downright = 0;
+                                    foreach (SurfaceGestureVector elt in ThisTemp)
+                                    {
+
+                                        switch (elt.Direction)
+                                        {
+                                            case SurfaceGestureVectorDirection.DOWN:
+                                                down += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.DOWNLEFT:
+                                                downleft += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.DOWNRIGHT:
+                                                downright += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.LEFT:
+                                                left += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.RIGHT:
+                                                right += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UP:
+                                                up += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UPLEFT:
+                                                upleft += elt.Lenght;
+                                                break;
+                                            case SurfaceGestureVectorDirection.UPRIGHT:
+                                                upright += elt.Lenght;
+                                                break;
+                                        }
+                                    }
+                                    if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(up))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upleft))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upright))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(down))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downleft))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downright))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = downright, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(left))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = null });
+                                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(right))
+                                        Tempo.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = null });
+                                }
+                                else
+                                    Tempo.Add(ThisTemp[0]);
+                            }
+                            else
+                                ThisTemp.Add(this[index]);
+                        }
+                        this.Clear();
+                        if (Tempo[0].Direction.Equals(Tempo[1].Direction) && Tempo[0].Direction.Equals(Tempo[2].Direction) && Tempo[0].Direction.Equals(Tempo[3].Direction))
+                            this.Add(Tempo[0]);
+                        else
+                            foreach (SurfaceGestureVector elt in Tempo)
+                                this.Add(elt);
+                        break;
+                }
+            }
+            else
+            {
+                ThisTemp.Add(Analyse(this));
+                this.Clear();
+                if (ThisTemp.Count > 1)
+                {
+                    double up = 0, down = 0, left = 0, right = 0, upleft = 0, upright = 0, downleft = 0, downright = 0;
+                    foreach (SurfaceGestureVector elt in ThisTemp)
+                    {
+
+                        switch (elt.Direction)
+                        {
+                            case SurfaceGestureVectorDirection.DOWN:
+                                down += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.DOWNLEFT:
+                                downleft += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.DOWNRIGHT:
+                                downright += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.LEFT:
+                                left += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.RIGHT:
+                                right += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.UP:
+                                up += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.UPLEFT:
+                                upleft += elt.Lenght;
+                                break;
+                            case SurfaceGestureVectorDirection.UPRIGHT:
+                                upright += elt.Lenght;
+                                break;
+                        }
+                    }
+                    if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(up))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upleft))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upright))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(down))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downleft))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downright))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = downright, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(left))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = null });
+                    else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(right))
+                        this.Add(new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = null });
+                }
+                else
+                    this.Add(ThisTemp[0]);
+            }
+        }
+
+        private SurfaceGestureVector Analyse(List<SurfaceGestureVector> list)
+        {
+            //  Analyse de la forme
+            
+            double up = 0, down = 0, left = 0, right = 0, upleft = 0, upright = 0, downleft = 0, downright = 0;
+            foreach (SurfaceGestureVector elt in list)
+            {
+
+                switch (elt.Direction)
+                {
+                    case SurfaceGestureVectorDirection.DOWN:
+                        down += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.DOWNLEFT:
+                        downleft += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.DOWNRIGHT:
+                        downright += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.LEFT:
+                        left += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.RIGHT:
+                        right += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.UP:
+                        up += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.UPLEFT:
+                        upleft += elt.Lenght;
+                        break;
+                    case SurfaceGestureVectorDirection.UPRIGHT:
+                        upright += elt.Lenght;
+                        break;
+                }
+            }
+            /*
+            //double cupleft = 0, cupright = 0, cdownleft = 0, cdownright = 0;
+
+            
+            if (list.Count > 2)
+            {
+                double min = 180;
+                for (int i = 1; i < list.Count - 2; i++)
+                {
+                    double a = GetDistancePoints(list[list.Count - 1].Origin, list[0].Origin);
+                    double b = GetDistancePoints(list[i].Origin, list[0].Origin);
+                    double c = GetDistancePoints(list[i].Origin, list[list.Count - 1].Origin);
+                    double angle = 180 * (Math.Acos((b * b + c * c - a * a) / (2 * b * c))) / Math.PI ;
+                    min = Math.Min(angle > 0 ? angle : 180, min);
+                }
+                if(min<130)
+                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.NONE, Lenght = up, Origin = list[0].Origin };
+            }
+
+            if (up < 4 && upleft < 4 && upright < 4 && down < 4 && downleft < 4 && downright < 4 && right < 4 && left < 4)
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.TAP, Lenght = 0 };
+            if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(up))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upleft))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(upright))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(down))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downleft))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(downright))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = downright, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(left))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = list[0].Origin };
+            else if (Math.Max(up, Math.Max(upleft, Math.Max(upright, Math.Max(down, Math.Max(downleft, Math.Max(left, Math.Max(downright, right))))))).Equals(right))
+                return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = list[0].Origin };
+            else
+                return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.NONE, Lenght = 0, Origin = list[0].Origin });
+             */
+
+            double diffX = Math.Abs(list[0].Origin.X - list[list.Count - 1].Origin.X);
+            double diffY = Math.Abs(list[0].Origin.Y - list[list.Count - 1].Origin.Y);
+
+            if (diffX < 10 && diffY > 10)
+            {
+                if (list[0].Origin.Y > list[list.Count - 1].Origin.Y)
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UP, Lenght = up, Origin = list[0].Origin });
+                else
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWN, Lenght = down, Origin = list[0].Origin });
+            }
+            else if (diffY < 10 && diffX > 10)
+            {
+                if (list[list.Count - 1].Origin.X > list[0].Origin.X)
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.LEFT, Lenght = left, Origin = list[0].Origin });
+                else
+                    return (new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.RIGHT, Lenght = right, Origin = list[0].Origin });
             }
             else if (diffX > 10 && diffY > 10)
             {
-                if (list[0].Y > list[list.Count - 1].Y && list[list.Count - 1].X > list[0].X)
-                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = 0, Origin = list[0] };
-                else if (list[0].Y > list[list.Count - 1].Y && list[list.Count - 1].X < list[0].X)
-                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = 0, Origin = list[0] };
-                else if (list[0].Y < list[list.Count - 1].Y && list[list.Count - 1].X > list[0].X)
-                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNRIGHT, Lenght = 0, Origin = list[0] };
+                if (list[0].Origin.Y > list[list.Count - 1].Origin.Y && list[list.Count - 1].Origin.X > list[0].Origin.X)
+                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPLEFT, Lenght = upleft, Origin = list[0].Origin };
+                else if (list[0].Origin.Y > list[list.Count - 1].Origin.Y && list[list.Count - 1].Origin.X < list[0].Origin.X)
+                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = list[0].Origin };
+                else if (list[0].Origin.Y < list[list.Count - 1].Origin.Y && list[list.Count - 1].Origin.X > list[0].Origin.X)
+                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = downleft, Origin = list[0].Origin };
                 else
-                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.DOWNLEFT, Lenght = 0, Origin = list[0] };
+                    return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.UPRIGHT, Lenght = upright, Origin = list[0].Origin };
             }
             else
                 return new SurfaceGestureVector { Direction = SurfaceGestureVectorDirection.TAP, Lenght = 0 };
@@ -190,21 +718,41 @@
             if (p1.Y < p2.Y)
             {
                 // go up
-                if (Math.Abs(p2.X - p1.X) < Math.Abs(p2.Y - p1.Y))
-                    return SurfaceGestureVectorDirection.DOWN;
-                else
+                if (Math.Abs(p2.Y - p1.Y) > this.Precision)
                 {
-                    if (p1.X < p2.X)
-                        return SurfaceGestureVectorDirection.DOWNRIGHT;
+                    if (Math.Abs(p2.X - p1.X) < Math.Abs(p2.Y - p1.Y))
+                        return SurfaceGestureVectorDirection.DOWN;
                     else
-                        return SurfaceGestureVectorDirection.DOWNLEFT;
+                    {
+                        if (p1.X < p2.X)
+                            return SurfaceGestureVectorDirection.DOWNRIGHT;
+                        else
+                            return SurfaceGestureVectorDirection.DOWNLEFT;
+                    }
                 }
+                    else
+                    {
+                        if (p1.X < p2.X)
+                            return SurfaceGestureVectorDirection.DOWNRIGHT;
+                        else
+                            return SurfaceGestureVectorDirection.DOWNLEFT;
+                    }
             }
             else
             {
                 // go down
-                if (Math.Abs(p1.X - p2.X) < Math.Abs(p1.Y - p2.Y))
-                    return SurfaceGestureVectorDirection.UP;
+                if (Math.Abs(p1.Y - p2.Y) > this.Precision)
+                {
+                    if (Math.Abs(p1.X - p2.X) < Math.Abs(p1.Y - p2.Y))
+                        return SurfaceGestureVectorDirection.UP;
+                    else
+                    {
+                        if (p1.X < p2.X)
+                            return SurfaceGestureVectorDirection.UPRIGHT;
+                        else
+                            return SurfaceGestureVectorDirection.UPLEFT;
+                    }
+                }
                 else
                 {
                     if (p1.X < p2.X)
@@ -220,8 +768,18 @@
             if (p1.X < p2.X)
             {
                 // go left
-                if (Math.Abs(p2.Y - p1.Y) < Math.Abs(p2.X - p1.X))
-                    return SurfaceGestureVectorDirection.RIGHT;
+                if (Math.Abs(p2.X - p1.X) > this.Precision)
+                {
+                    if (Math.Abs(p2.Y - p1.Y) < Math.Abs(p2.X - p1.X))
+                        return SurfaceGestureVectorDirection.RIGHT;
+                    else
+                    {
+                        if (p1.Y < p2.Y)
+                            return SurfaceGestureVectorDirection.DOWNRIGHT;
+                        else
+                            return SurfaceGestureVectorDirection.UPRIGHT;
+                    }
+                }
                 else
                 {
                     if (p1.Y < p2.Y)
@@ -232,9 +790,19 @@
             }
             else
             {
-                // go right=
-                if (Math.Abs(p1.Y - p2.Y) < Math.Abs(p1.X - p2.X))
-                    return SurfaceGestureVectorDirection.LEFT;
+                // go right
+                if (Math.Abs(p1.X - p2.X) > this.Precision)
+                {
+                    if (Math.Abs(p1.Y - p2.Y) < Math.Abs(p1.X - p2.X))
+                        return SurfaceGestureVectorDirection.LEFT;
+                    else
+                    {
+                        if (p1.Y < p2.Y)
+                            return SurfaceGestureVectorDirection.DOWNLEFT;
+                        else
+                            return SurfaceGestureVectorDirection.UPLEFT;
+                    }
+                }
                 else
                 {
                     if (p1.Y < p2.Y)
diff -r 0699cab5cbb3 -r 09c4d30fe8d1 src/FingersDance.GestureControl/Resources/Patterns.xml
--- a/src/FingersDance.GestureControl/Resources/Patterns.xml	Wed Nov 18 13:06:55 2009 +0100
+++ b/src/FingersDance.GestureControl/Resources/Patterns.xml	Thu Nov 19 09:28:15 2009 +0100
@@ -1,78 +1,37 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <Patterns>
-  
   <Pattern>
-    <Name>TRIGGER</Name>
+    <Name>UP</Name>
     <Childs>
       <Child>
-        <Name>RIGHT</Name>
+        <Name>UP</Name>
         <Directions>
-          <Direction>Right</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>TAP</Name>
-        <Directions>
-          <Direction>TAP</Direction>
+          <Direction>Up</Direction>
         </Directions>
       </Child>
     </Childs>
   </Pattern>
-  
   <Pattern>
-    <Name>CONTRE POINTS</Name>
+    <Name>LEFT</Name>
     <Childs>
       <Child>
-        <Name>TAP</Name>
+        <Name>Up</Name>
         <Directions>
-          <Direction>TAP</Direction>
+          <Direction>Up</Direction>
         </Directions>
       </Child>
       <Child>
-        <Name>TAP</Name>
+        <Name>Up</Name>
         <Directions>
-          <Direction>TAP</Direction>
+          <Direction>Up</Direction>
         </Directions>
       </Child>
     </Childs>
   </Pattern>
-  
   <Pattern>
-    <Name>CONTRE PESANTEUR</Name>
-    <Childs>
-      <Child>
-        <Name>UPRIGHT-DOWNRIGHT</Name>
-        <Directions>
-          <Direction>Upright</Direction>
-		  <Direction>Downright</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>AVEC PESANTEUR</Name>
+    <Name>RIGHT</Name>
     <Childs>
       <Child>
-        <Name>DOWNRIGHT-UPRIGHT</Name>
-        <Directions>
-		  <Direction>Downright</Direction>
-          <Direction>Upright</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>ALIGNEMENT</Name>
-    <Childs>
-      <Child>
-        <Name>RIGHT</Name>
-        <Directions>
-          <Direction>Right</Direction>
-        </Directions>
-      </Child>
-      <Child>
         <Name>RIGHT</Name>
         <Directions>
           <Direction>Right</Direction>
@@ -80,61 +39,8 @@
       </Child>
     </Childs>
   </Pattern>
-  
   <Pattern>
-    <Name>CONTACT VISUEL</Name>
-    <Childs>
-      <Child>
-        <Name>DOWNRIGHT-DOWNLEFT</Name>
-        <Directions>
-		  <Direction>Downright</Direction>
-          <Direction>Downleft</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWNLEFT-DOWNRIGHT</Name>
-        <Directions>
-          <Direction>Downleft</Direction>
-		  <Direction>Downright</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>MOUVEMENT CONTRAINTE</Name>
-    <Childs>
-      <Child>
-        <Name>DOWNLEFT-DOWNRIGHT</Name>
-        <Directions>
-          <Direction>Downleft</Direction>
-		  <Direction>Downright</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWNRIGHT-DOWNLEFT</Name>
-        <Directions>
-		  <Direction>Downright</Direction>
-          <Direction>Downleft</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>UN DANSEUR</Name>
-    <Childs>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>DEUX DANSEURS</Name>
+    <Name>PAUSE</Name>
     <Childs>
       <Child>
         <Name>DOWN</Name>
@@ -150,134 +56,42 @@
       </Child>
     </Childs>
   </Pattern>
-  
   <Pattern>
-    <Name>TROIS DANSEURS</Name>
+    <Name>PAUSE</Name>
     <Childs>
       <Child>
-        <Name>DOWN</Name>
+        <Name>DOWNRIGHT</Name>
         <Directions>
-          <Direction>Down</Direction>
+          <Direction>DownRight</Direction>
         </Directions>
       </Child>
       <Child>
-        <Name>DOWN</Name>
+        <Name>DOWNRIGHT</Name>
         <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
+          <Direction>DownRight</Direction>
         </Directions>
       </Child>
     </Childs>
   </Pattern>
-  
   <Pattern>
-    <Name>QUATRE DANSEURS</Name>
-    <Childs>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>TOUS LES DANSEURS</Name>
+    <Name>PAUSE</Name>
     <Childs>
       <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
+        <Name>DOWNLEFT</Name>
         <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWN</Name>
-        <Directions>
-          <Direction>Down</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>CONTACT TABLE/DANSEUR</Name>
-    <Childs>
-      <Child>
-        <Name>DOWNRIGHT</Name>
-        <Directions>
-		  <Direction>Downright</Direction>
+          <Direction>DownLeft</Direction>
         </Directions>
       </Child>
       <Child>
         <Name>DOWNLEFT</Name>
         <Directions>
-          <Direction>Downleft</Direction>
+          <Direction>DownLeft</Direction>
         </Directions>
       </Child>
     </Childs>
   </Pattern>
   <Pattern>
-    <Name>CONTACT TABLE-DANSEUR</Name>
-    <Childs>
-      <Child>
-        <Name>DOWNLEFT</Name>
-        <Directions>
-          <Direction>Downleft</Direction>
-        </Directions>
-      </Child>
-      <Child>
-        <Name>DOWNRIGHT</Name>
-        <Directions>
-		  <Direction>Downright</Direction>
-        </Directions>
-      </Child>
-    </Childs>
-  </Pattern>
-  
-  <Pattern>
-    <Name>PLAY-PAUSE</Name>
+    <Name>PLAY</Name>
     <Childs>
       <Child>
         <Name>TAP</Name>
@@ -287,5 +101,4 @@
       </Child>
     </Childs>
   </Pattern>
-  
 </Patterns>
\ No newline at end of file