1 /*

     2 * This file is part of the TraKERS\Middleware package.

     3 *

     4 * (c) IRI <http://www.iri.centrepompidou.fr/>

     5 *

     6 * For the full copyright and license information, please view the LICENSE_MIDDLEWARE

     7 * file that was distributed with this source code.

     8 */

     9 

    10 /*

    11  * Projet : TraKERS

    12  * Module : MIDDLEWARE

    13  * Sous-Module : Communication

    14  * Classe : Server

    15  * 

    16  * Auteur : alexandre.bastien@iri.centrepompidou.fr

    17  * 

    18  * Fonctionnalités : Reçoit des notifications du module sous-module Tracking.

    19  * Traduit les notifications sous forme de messages OSC et les envoie au Front Atelier.

    20  * Forme des messages :

    21  * - Notification de main dans le champ de recherche : Point3D indiquant la position de la main dans l'espace.

    22  */

    23 

    24 using System;

    25 using System.Collections.Generic;

    26 using System.Linq;

    27 using System.Text;

    28 using System.IO;

    29 using System.Net;

    30 using System.Net.Sockets;

    31 using System.Threading;

    32 using Tuio;

    33 using System.Windows;

    34 using Microsoft.Kinect;

    35 using System.Windows.Media.Media3D;

    36 using System.Timers;

    37 using System.Resources;

    38 using System.Reflection;

    39 

    40 namespace Trakers.Communication

    41 {

    42     public class Server

    43     {

    44         //Serveur TUIO, provenant de la DLL TuioServer créé par Bespoke.

    45         private TuioServer server;

    46 

    47         //Permet de savoir si un curseur pour la main gauche/droite a été créé.

    48         private bool leftHandCursorCreated;

    49         private bool rightHandCursorCreated;

    50         private bool messageCreated;

    51         private bool gestureLocked, modLocked;

    52         //Intervalle minimum entre les gestures.

    53         private int timerElapsing;

    54         //Timer.

    55         private System.Timers.Timer _timer;

    56         //Dernier code envoyé.

    57         private String lastCode;

    58 

    59         /*

    60         * Constructeur : On initialise le serveur avec une adresse et un port, au début les curseurs

    61         * ne sont pas créés et on indique au ThreadPool une fonction de callback de manière à vérifier

    62         * s'il reçoit des notifications.

    63         */

    64         public Server(String host, int port, int _timerElapsing)

    65         {

    66             //Au départ, aucune main n'est dans le champ de recherche et aucune gesture n'est détectée.

    67             leftHandCursorCreated = false;

    68             rightHandCursorCreated = false;

    69             messageCreated = false;

    70             gestureLocked = false;

    71             modLocked = false;

    72             lastCode = "";

    73 

    74             timerElapsing = _timerElapsing;

    75 

    76             //On démarre le serveur TUIO.

    77             server = new TuioServer(host, port);

    78             //On initialise le threadPool (appelé toutes les N ms).

    79             ThreadPool.QueueUserWorkItem(ThreadPoolCallback);

    80 

    81             //On instancie le timer à N ms.

    82             _timer = new System.Timers.Timer(timerElapsing);

    83             //Dès que le timer est expiré, on appelle _timer_Elapsed.

    84             _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);

    85         }

    86 

    87         /*

    88         * Getter du serveur.

    89         */

    90         public TuioServer getServer()

    91         {

    92             return server;

    93         }

    94 

    95         /*

    96          * Méthode appelée à l'expiration du timer pour les gestures et modes.

    97          */

    98         public void _timer_Elapsed(object sender, ElapsedEventArgs e)

    99         {

   100             //On débloque la détection de gesture.

   101             gestureLocked = false;

   102             //On débloque la notification de nouveau mode.

   103             modLocked = false;

   104             //On arrête le timer.

   105             _timer.Stop();

   106         }

   107 

   108         /*

   109         * Méthode appelée lors d'une notification de type : main gauche entrée dans le champ.

   110         */

   111         public void LeftHandTracked(Point3D pt)

   112         {

   113             //Si le curseur de la main gauche n'est pas créé, alors on le crée.

   114             if (!leftHandCursorCreated)

   115             {

   116                 server.AddTuioCursor(0, pt);

   117                 leftHandCursorCreated = true;

   118             }

   119             //S'il existe, on le met simplement à jour.

   120             else

   121                 server.UpdateTuioCursor(0, pt);

   122         }

   123 

   124         /*

   125         * Méthode appelée lors d'une notification de type : main droite entrée dans le champ.

   126         */

   127         public void RightHandTracked(Point3D pt)

   128         {

   129             //Si le curseur de la main droite n'est pas créé, alors on le crée.

   130             if (!rightHandCursorCreated)

   131             {

   132                 server.AddTuioCursor(1, pt);

   133                 rightHandCursorCreated = true;

   134             }

   135             //S'il existe, on le met simplement à jour.

   136             else

   137                 server.UpdateTuioCursor(1, pt);

   138         }

   139 

   140         /*

   141         * Méthode appelée lors d'une notification de type : main gauche sortie du champ.

   142         */

   143         public void LeftHandQuit()

   144         {

   145             //Si le curseur de la main gauche existe, alors on le supprime.

   146             if (leftHandCursorCreated)

   147             {

   148                 server.DeleteTuioCursor(0);

   149                 leftHandCursorCreated = false;

   150             }

   151         }

   152 

   153         /*

   154         * Méthode appelée lors d'une notification de type : main droite sortie du champ.

   155         */

   156         public void RightHandQuit()

   157         {

   158             //Si le curseur de la main droite existe, alors on le supprime.

   159             if (rightHandCursorCreated)

   160             {

   161                 server.DeleteTuioCursor(1);

   162                 rightHandCursorCreated = false;

   163             }

   164         }

   165 

   166         /*

   167         * Méthode appelée lorsqu'une gesture a été détectée et que l'événement approprié a été lancé.

   168         */

   169         public void GesturePerformed(String code)

   170         {

   171             //Si le code vient d'être envoyé, on passe.

   172             if (lastCode.Equals(code))

   173                 return;

   174             lastCode = code;

   175             //Si une gesture a été effectuée, on bloque un certain temps.

   176             if (!gestureLocked)

   177             {

   178                 gestureLocked = true;

   179                 

   180                 //On crée un message contenant le code à envoyer.

   181                 if (!messageCreated)

   182                 {

   183                     messageCreated = true;

   184                     server.AddTuioString(2, code);

   185                     //On démarre le timer.

   186                     _timer.Start();

   187                 }

   188             }

   189         }

   190 

   191         /*

   192         * Méthode appelée lorsqu'on doit entrer dans un autre mode.

   193         */

   194         public void ModeNotification(String code)

   195         {

   196             //Si le code vient d'être envoyé, on passe.

   197             if (lastCode.Equals(code))

   198                 return;

   199             lastCode = code;

   200             //Si on a été notifié.

   201             if (!modLocked)

   202             {

   203                 modLocked = true;

   204 

   205                 //On crée un message contenant le code à envoyer.

   206                 if (!messageCreated)

   207                 {

   208                     messageCreated = true;

   209                     server.AddTuioString(2, code);

   210                     //On démarre le timer.

   211                     _timer.Start();

   212                 }

   213             }

   214         }

   215 

   216         /*

   217         * Méthode de callback vérifiant toutes les 25 ms les nouvelles notifications.

   218         * Il est à noter que si le temps de rafraîchissement des trop rapide, les messages n'ont pas

   219         * le temps d'être envoyés.

   220         */

   221         private void ThreadPoolCallback(Object threadContext)

   222         {

   223             while (true)

   224             {

   225                 //On initialise le message OSC.

   226                 server.InitFrame();

   227                 //On l'envoie au client (au host et au port spécifiés dans le constructeur).

   228                 server.CommitFrame();

   229                 //On attend 25 ms.

   230                 Thread.Sleep(25);

   231 

   232                 //Si une gesture a été effectuée et que le délai d'attente est expiré.

   233                 if (messageCreated && !gestureLocked && !modLocked)

   234                 {

   235                     //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.

   236                     messageCreated = false;

   237                     server.DeleteTuioString(2);

   238                 }

   239             }

   240         }

   241     }

   242 }