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

     7 * file that was distributed with this source code.

     8 */

     9 

    10 /*

    11  * Projet : TraKERS

    12  * Module : MIDDLEWARE

    13  * Sous-Module : Communication

    14  * Classe : TUIOServer

    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  * - Notification de gesture/mode : String.

    23  * - Paramètres de config : String.

    24  */

    25 

    26 using System;

    27 using System.Collections.Generic;

    28 using System.Linq;

    29 using System.Text;

    30 using System.IO;

    31 using System.Net;

    32 using System.Net.Sockets;

    33 using System.Threading;

    34 using Tuio;

    35 using System.Windows;

    36 using Microsoft.Kinect;

    37 using System.Windows.Media.Media3D;

    38 using System.Timers;

    39 using System.Resources;

    40 using System.Reflection;

    41 

    42 namespace Trakers.Communication

    43 {

    44     public class TUIOServer

    45     {

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

    47         private TuioServer server;

    48 

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

    50         private bool leftHandCursorCreated;

    51         private bool rightHandCursorCreated;

    52         private bool messageCreated;

    53         private bool gestureLocked, modLocked;

    54         //Intervalle minimum entre les gestures.

    55         private int timerElapsing;

    56         //Timer.

    57         private System.Timers.Timer _timer;

    58         //Dernier code envoyé.

    59         private String lastCode;

    60 

    61         /*

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

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

    64         * s'il reçoit des notifications.

    65         */

    66         public TUIOServer(String host, int port, int _timerElapsing)

    67         {

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

    69             leftHandCursorCreated = false;

    70             rightHandCursorCreated = false;

    71             messageCreated = false;

    72             gestureLocked = false;

    73             modLocked = false;

    74             lastCode = "";

    75 

    76             timerElapsing = _timerElapsing;

    77 

    78             //On démarre le serveur TUIO.

    79             server = new TuioServer(host, port);

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

    81             ThreadPool.QueueUserWorkItem(ThreadPoolCallback);

    82 

    83             //On instancie le timer à N ms.

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

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

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

    87         }

    88 

    89         /*

    90         * Getter du serveur.

    91         */

    92         public TuioServer getServer()

    93         {

    94             return server;

    95         }

    96 

    97         /*

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

    99          */

   100         public void _timer_Elapsed(object sender, ElapsedEventArgs e)

   101         {

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

   103             gestureLocked = false;

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

   105             modLocked = false;

   106             //On arrête le timer.

   107             _timer.Stop();

   108         }

   109 

   110         /*

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

   112         */

   113         public void LeftHandTracked(Point3D pt)

   114         {

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

   116             if (!leftHandCursorCreated)

   117             {

   118                 server.AddTuioCursor(0, pt);

   119                 leftHandCursorCreated = true;

   120             }

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

   122             else

   123                 server.UpdateTuioCursor(0, pt);

   124         }

   125 

   126         /*

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

   128         */

   129         public void RightHandTracked(Point3D pt)

   130         {

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

   132             if (!rightHandCursorCreated)

   133             {

   134                 server.AddTuioCursor(1, pt);

   135                 rightHandCursorCreated = true;

   136             }

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

   138             else

   139                 server.UpdateTuioCursor(1, pt);

   140         }

   141 

   142         /*

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

   144         */

   145         public void LeftHandQuit()

   146         {

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

   148             if (leftHandCursorCreated)

   149             {

   150                 server.DeleteTuioCursor(0);

   151                 leftHandCursorCreated = false;

   152             }

   153         }

   154 

   155         /*

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

   157         */

   158         public void RightHandQuit()

   159         {

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

   161             if (rightHandCursorCreated)

   162             {

   163                 server.DeleteTuioCursor(1);

   164                 rightHandCursorCreated = false;

   165             }

   166         }

   167 

   168         /*

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

   170         */

   171         public void GesturePerformed(String code)

   172         {

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

   174             if (lastCode.Equals(code))

   175                 return;

   176             lastCode = code;

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

   178             if (!gestureLocked)

   179             {

   180                 gestureLocked = true;

   181 

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

   183                 if (!messageCreated)

   184                 {

   185                     messageCreated = true;

   186                     server.AddTuioString(2, code);

   187                     //On démarre le timer.

   188                     _timer.Start();

   189                 }

   190             }

   191         }

   192 

   193         /*

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

   195         */

   196         public void ModeNotification(String code)

   197         {

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

   199             if (lastCode.Equals(code))

   200                 return;

   201             lastCode = code;

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

   203             if (!modLocked)

   204             {

   205                 modLocked = true;

   206 

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

   208                 if (!messageCreated)

   209                 {

   210                     messageCreated = true;

   211                     server.AddTuioString(2, code);

   212                     //On démarre le timer.

   213                     _timer.Start();

   214                 }

   215             }

   216         }

   217 

   218         /*

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

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

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

   222         */

   223         private void ThreadPoolCallback(Object threadContext)

   224         {

   225             while (true)

   226             {

   227                 //On initialise le message OSC.

   228                 server.InitFrame();

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

   230                 server.CommitFrame();

   231                 //On attend 25 ms.

   232                 Thread.Sleep(25);

   233 

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

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

   236                 {

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

   238                     messageCreated = false;

   239                     server.DeleteTuioString(2);

   240                 }

   241             }

   242         }

   243 

   244         /*

   245          * Getters et Setters

   246          */

   247         public void setTimerElapsing(int _timerElapsing)

   248         {

   249             timerElapsing = _timerElapsing;

   250         }

   251 

   252         public int getTimerElapsing()

   253         {

   254             return timerElapsing;

   255         }

   256     }

   257 }