middleware/src/Communication/Server.cs
changeset 5 d40f84d77db4
parent 3 92f19af39024
child 8 e4e7db2435f8
equal deleted inserted replaced
4:f4e52a4c34b3 5:d40f84d77db4
    25 using Microsoft.Kinect;
    25 using Microsoft.Kinect;
    26 using Trakers.Tracking;
    26 using Trakers.Tracking;
    27 using System.Windows.Media.Media3D;
    27 using System.Windows.Media.Media3D;
    28 using Trakers.Tracking.Events;
    28 using Trakers.Tracking.Events;
    29 using System.Timers;
    29 using System.Timers;
       
    30 using Trakers.Debug;
       
    31 using System.Resources;
       
    32 using System.Reflection;
    30 
    33 
    31 namespace Trakers.Communication
    34 namespace Trakers.Communication
    32 {
    35 {
    33     public class Server
    36     public class Server
    34     {
    37     {
    35         //Serveur TUIO, provenant de la DLL TuioServer créé par Bespoke.
    38         //Serveur TUIO, provenant de la DLL TuioServer créé par Bespoke.
    36         private TuioServer server;
    39         private TuioServer server;
       
    40         //Affichage de debug.
       
    41         private DebugWindow debug;
    37 
    42 
    38         //Permet de savoir si un curseur pour la main gauche/droite a été créé.
    43         //Permet de savoir si un curseur pour la main gauche/droite a été créé.
    39         private bool leftHandCursorCreated;
    44         private bool leftHandCursorCreated;
    40         private bool rightHandCursorCreated;
    45         private bool rightHandCursorCreated;
    41         private bool messageCreated;
    46         private bool messageCreated;
    42         private bool gestureLocked;
    47         private bool gestureLocked;
    43 
    48         //Intervalle minimum entre les gestures.
    44         private int timerElapsing;
    49         private int timerElapsing;
    45 
    50         //Timer.
    46         System.Timers.Timer _timer;
    51         private System.Timers.Timer _timer;
       
    52         //Gestionnaire de ressources.
       
    53         private ResourceManager rm;
    47 
    54 
    48         /*
    55         /*
    49         * Constructeur : On initialise le serveur avec une adresse et un port, au début les curseurs
    56         * Constructeur : On initialise le serveur avec une adresse et un port, au début les curseurs
    50         * ne sont pas créés et on indique au ThreadPool une fonction de callback de manière à vérifier
    57         * ne sont pas créés et on indique au ThreadPool une fonction de callback de manière à vérifier
    51         * s'il reçoit des notifications.
    58         * s'il reçoit des notifications.
    52         */
    59         */
    53         public Server(String host, int port, int _timerElapsing)
    60         public Server(String host, int port, int _timerElapsing, DebugWindow _debug)
    54         {
    61         {
    55             //On démarre le serveur TUIO.
    62             debug = _debug;
    56             server = new TuioServer(host, port);
    63             rm = new ResourceManager("Trakers.Properties.resources", Assembly.GetExecutingAssembly());
    57             //On initialise le threadPool (appelé toutes les N ms).
       
    58             ThreadPool.QueueUserWorkItem(ThreadPoolCallback);
       
    59 
       
    60             //Au départ, aucune main n'est dans le champ de recherche et aucune gesture n'est détectée.
    64             //Au départ, aucune main n'est dans le champ de recherche et aucune gesture n'est détectée.
    61             leftHandCursorCreated = false;
    65             leftHandCursorCreated = false;
    62             rightHandCursorCreated = false;
    66             rightHandCursorCreated = false;
    63             messageCreated = false;
    67             messageCreated = false;
    64             gestureLocked = false;
    68             gestureLocked = false;
    65 
    69 
    66             timerElapsing = _timerElapsing;
    70             timerElapsing = _timerElapsing;
    67 
    71 
    68             //On instancie le timer à N ms.
    72             try
    69             _timer = new System.Timers.Timer(timerElapsing);
    73             {
    70             //Dès que le timer est expiré, on appelle _timer_Elapsed.
    74                 //On démarre le serveur TUIO.
    71             _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
    75                 server = new TuioServer(host, port);
       
    76                 //On initialise le threadPool (appelé toutes les N ms).
       
    77                 ThreadPool.QueueUserWorkItem(ThreadPoolCallback);
       
    78 
       
    79                 //On instancie le timer à N ms.
       
    80                 _timer = new System.Timers.Timer(timerElapsing);
       
    81                 //Dès que le timer est expiré, on appelle _timer_Elapsed.
       
    82                 _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
       
    83             }
       
    84             catch (Exception)
       
    85             {
       
    86                 debug.ExceptionLbl.Content = rm.GetString("serverCantStart");
       
    87             }
    72         }
    88         }
    73 
    89 
    74         /*
    90         /*
    75         * Getter du serveur.
    91         * Getter du serveur.
    76         */
    92         */
    93         /*
   109         /*
    94         * Méthode appelée lors d'une notification de type : main gauche entrée dans le champ.
   110         * Méthode appelée lors d'une notification de type : main gauche entrée dans le champ.
    95         */
   111         */
    96         public void LeftHandTracked(object sender, LeftHandTrackedEventArgs e)
   112         public void LeftHandTracked(object sender, LeftHandTrackedEventArgs e)
    97         {
   113         {
    98             return;
       
    99             //Si le curseur de la main gauche n'est pas créé, alors on le crée.
   114             //Si le curseur de la main gauche n'est pas créé, alors on le crée.
   100             if (!leftHandCursorCreated)
   115             if (!leftHandCursorCreated)
   101             {
   116             {
   102                 server.AddTuioCursor(0, SkeletonPointToPoint3D(e.handJoint.Position));
   117                 server.AddTuioCursor(0, SkeletonPointToPoint3D(e.handJoint.Position));
   103                 leftHandCursorCreated = true;
   118                 leftHandCursorCreated = true;
   112         /*
   127         /*
   113         * Méthode appelée lors d'une notification de type : main droite entrée dans le champ.
   128         * Méthode appelée lors d'une notification de type : main droite entrée dans le champ.
   114         */
   129         */
   115         public void RightHandTracked(object sender, RightHandTrackedEventArgs e)
   130         public void RightHandTracked(object sender, RightHandTrackedEventArgs e)
   116         {
   131         {
   117             return;
       
   118             //Si le curseur de la main droite n'est pas créé, alors on le crée.
   132             //Si le curseur de la main droite n'est pas créé, alors on le crée.
   119             if (!rightHandCursorCreated)
   133             if (!rightHandCursorCreated)
   120             {
   134             {
   121                 server.AddTuioCursor(1, SkeletonPointToPoint3D(e.handJoint.Position));
   135                 server.AddTuioCursor(1, SkeletonPointToPoint3D(e.handJoint.Position));
   122                 //server.AddTuioString(1, "BOO");
       
   123                 rightHandCursorCreated = true;
   136                 rightHandCursorCreated = true;
   124             }
   137             }
   125             //S'il existe, on le met simplement à jour.
   138             //S'il existe, on le met simplement à jour.
   126             else
   139             else
   127             {
   140             {
   128                 server.UpdateTuioCursor(1, SkeletonPointToPoint3D(e.handJoint.Position));
   141                 server.UpdateTuioCursor(1, SkeletonPointToPoint3D(e.handJoint.Position));
   129                 //server.UpdateTuioString(1, "BOO");
       
   130             }
   142             }
   131         }
   143         }
   132 
   144 
   133         /*
   145         /*
   134         * Méthode appelée lors d'une notification de type : main gauche sortie du champ.
   146         * Méthode appelée lors d'une notification de type : main gauche sortie du champ.
   135         */
   147         */
   136         public void LeftHandQuit(object sender, LeftHandQuitEventArgs e)
   148         public void LeftHandQuit(object sender, LeftHandQuitEventArgs e)
   137         {
   149         {
   138             return;
       
   139             //Si le curseur de la main gauche existe, alors on le supprime.
   150             //Si le curseur de la main gauche existe, alors on le supprime.
   140             if (leftHandCursorCreated)
   151             if (leftHandCursorCreated)
   141             {
   152             {
   142                 server.DeleteTuioCursor(0);
   153                 server.DeleteTuioCursor(0);
   143                 leftHandCursorCreated = false;
   154                 leftHandCursorCreated = false;
   147         /*
   158         /*
   148         * Méthode appelée lors d'une notification de type : main droite sortie du champ.
   159         * Méthode appelée lors d'une notification de type : main droite sortie du champ.
   149         */
   160         */
   150         public void RightHandQuit(object sender, RightHandQuitEventArgs e)
   161         public void RightHandQuit(object sender, RightHandQuitEventArgs e)
   151         {
   162         {
   152             return;
       
   153             //Si le curseur de la main droite existe, alors on le supprime.
   163             //Si le curseur de la main droite existe, alors on le supprime.
   154             if (rightHandCursorCreated)
   164             if (rightHandCursorCreated)
   155             {
   165             {
   156                 server.DeleteTuioCursor(1);
   166                 server.DeleteTuioCursor(1);
   157                 //server.DeleteTuioString(1);
       
   158                 rightHandCursorCreated = false;
   167                 rightHandCursorCreated = false;
   159             }
   168             }
   160         }
   169         }
   161 
   170 
   162         /*
   171         /*
   188                 hand = "LEFT";
   197                 hand = "LEFT";
   189             else if (e.hand == Tracking.Gestures.PushDetector.Hand.RIGHT)
   198             else if (e.hand == Tracking.Gestures.PushDetector.Hand.RIGHT)
   190                 hand = "RIGHT";
   199                 hand = "RIGHT";
   191             else
   200             else
   192                 hand = "BOTH";
   201                 hand = "BOTH";
   193 
       
   194             Console.Out.WriteLine(pushPull + "-" + hand);
       
   195 
   202 
   196             GesturePerformed(pushPull + "-" + hand);
   203             GesturePerformed(pushPull + "-" + hand);
   197         }
   204         }
   198 
   205 
   199         /*
   206         /*
   208                 
   215                 
   209                 //On crée un message contenant le code à envoyer.
   216                 //On crée un message contenant le code à envoyer.
   210                 if (!messageCreated)
   217                 if (!messageCreated)
   211                 {
   218                 {
   212                     messageCreated = true;
   219                     messageCreated = true;
   213                     server.AddTuioString(1, code);
   220                     server.AddTuioString(2, code);
   214                     //On démarre le timer.
   221                     //On démarre le timer.
   215                     _timer.Start();
   222                     _timer.Start();
   216                 }
   223                 }
   217             }
   224             }
   218         }
   225         }
   244                 //Si une gesture a été effectuée et que le délai d'attente est expiré.
   251                 //Si une gesture a été effectuée et que le délai d'attente est expiré.
   245                 if (messageCreated && !gestureLocked)
   252                 if (messageCreated && !gestureLocked)
   246                 {
   253                 {
   247                     //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.
   254                     //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.
   248                     messageCreated = false;
   255                     messageCreated = false;
   249                     server.DeleteTuioString(1);
   256                     server.DeleteTuioString(2);
   250                 }
   257                 }
   251             }
   258             }
   252         }
   259         }
   253     }
   260     }
   254 }
   261 }