/*

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

*

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

*

* For the full copyright and license information, please view the LICENSE

* file that was distributed with this source code.

*/

/*

 * Projet : TraKERS

 * Module : MIDDLEWARE

 * Sous-Module : Tracking

 * Classe : KinectMain

 * 

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

 * 

 * Fonctionnalités : Récupère les trames de données de la Kinect, les squelettes détectés via le SDK 1.0 de Microsoft.

 * Interprète ces trames de façon à afficher le flux vidéo couleurs, et récupérer la distance de l'utilisateur et les

 * noeuds de son squelette. Lance des événements lorsque la main gauche/droite entre dans/quitte le champ.

 * Envoie des données au sous-module de debug de manière a afficher un retour visuel sur la position de l'utilisateur,

 * son squelette, la détection de ses mains.

 * Découpe l'interaction avec le middleware en différents modes.

 */

using System;

using System.Collections.Generic;

using System.Linq;

using System.Windows;

using Microsoft.Kinect;

using Trakers.Communication;

using Trakers.Debug;

using Trakers.MainModule.Events;

using Trakers.Tracking.Gestures;

using Trakers.Tracking.Postures;

namespace Trakers.MainModule

{

    //Il s'agit des fonctions permettant d'appeler les fonctions des événements Main droite/gauche entre/quitte le champ.

    public delegate void LeftHandTrackedHandler(object o, LeftHandTrackedEventArgs e);

    public delegate void RightHandTrackedHandler(object o, RightHandTrackedEventArgs e);

    public delegate void LeftHandQuitHandler(object o, LeftHandQuitEventArgs e);

    public delegate void RightHandQuitHandler(object o, RightHandQuitEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Bend.

    public delegate void BendHandler(object o, BendEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Cross.

    public delegate void CrossHandler(object o, CrossEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements KneeUp.

    public delegate void KneeUpHandler(object o, KneeUpEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Swipe left/right/up/down.

    public delegate void SwipeHandler(object o, SwipeEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Push/Pull.

    public delegate void PushHandler(object o, PushEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Jump.

    public delegate void JumpHandler(object o, JumpEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Fall.

    public delegate void FallHandler(object o, FallEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Wave.

    public delegate void WaveHandler(object o, WaveEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements Circle.

    public delegate void CircleHandler(object o, CircleEventArgs e);

    //Il s'agit de la fonction permettant d'appeler les fonctions des événements de proximité.

    public delegate void UserPositionHandler(object o, UserPositionEventArgs e);

    public class KinectMain

    {

        //Fenêtre de debug.

        private DebugWindow debug;

        //Squelettes (Il y en a 6 par défaut).

        private Skeleton[] skeletons;

        //Caméra infrarouge (sensor) de la Kinect.

        private KinectSensor kinectSensor;

        //Détecteur de penchés.

        private BendDetector bendDetector;

        //Détecteur de croisement de bras en X.

        private CrossDetector crossDetector;

        //Détecteur de levé de genou.

        private KneeUpDetector kneeUpDetector;

        //Détecteur de position correcte.

        private CorrectPosture correctPostureDetector;

        //Détecteur de swipes.

        private SwipeDetector swipeDetector;

        //Détecteur de pushes.

        private PushDetector pushDetector;

        //Détecteur de jumps.

        private JumpDetector jumpDetector;

        //Détecteur de falls.

        private FallDetector fallDetector;

        //Détecteur de waves.

        private WaveDetector waveDetector;

        //Détecteur de cercles.

        private CircleDetector circleDetector;

        //Détecteur de proximité.

        private UserPositionDetector userPositionDetector;

        //Serveur TUIO pour la connexion du Middleware vers le Front Atelier.

        private Server server;

        //Gestionnaire de modes.

        private ModeManagement modeManagement;

        //Les événements des mains pour la recherche.

        public static event LeftHandTrackedHandler LeftHandTrackedEvent;

        public static event RightHandTrackedHandler RightHandTrackedEvent;

        public static event LeftHandQuitHandler LeftHandQuitEvent;

        public static event RightHandQuitHandler RightHandQuitEvent;

        //L'événement bend.

        public static event BendHandler BendEvent;

        //L'événement cross.

        public static event CrossHandler CrossEvent;

        //L'événement kneeUp.

        public static event KneeUpHandler KneeUpEvent;

        //L'événement swipe.

        public static event SwipeHandler SwipeEvent;

        //L'événement push.

        public static event PushHandler PushEvent;

        //L'événement jump.

        public static event JumpHandler JumpEvent;

        //L'événement fall.

        public static event FallHandler FallEvent;

        //L'événement wave.

        public static event WaveHandler WaveEvent;

        //L'événement circle.

        public static event CircleHandler CircleEvent;

        //L'événement l'utilisateur se déplace dans la zone de détection.

        public static event UserPositionHandler UserPositionEvent;

        /*

        *  Initialisation de la classe principale.

        *  Affiche l'écran de debug dans lequel on voit la distance à la Kinect,

        *  les mains détectées et le squelette de l'utilisateur.

        */

        public KinectMain()

        {

            //On crée la fenêtre de debug.

            debug = new DebugWindow();

            //On crée les détecteurs de postures.

            bendDetector = new BendDetector(debug);

            crossDetector = new CrossDetector(debug);

            kneeUpDetector = new KneeUpDetector(debug);

            correctPostureDetector = new CorrectPosture(debug);

            //On crée les détecteurs de gestes.

            swipeDetector = new SwipeDetector(debug);

            pushDetector = new PushDetector(debug);

            jumpDetector = new JumpDetector(debug);

            fallDetector = new FallDetector(debug);

            waveDetector = new WaveDetector(debug);

            circleDetector = new CircleDetector(debug);

            //On crée le détecteur de proximité.

            userPositionDetector = new UserPositionDetector(debug.getMinDist(), debug.getMaxDist(), debug.getZeroPoint(), debug.getMinDistHands(), debug.getMaxDistHands());

            //On connecte le serveur à l'adresse locale sur le port 80.

            try

            {

                //On crée le gestionnaire de modes.

                modeManagement = new ModeManagement(server, debug, this);

            }

            catch (Exception)

            {

                debug.ShowException("serverCantStart");

            }

            //On écoute l'événement de clic sur le bouton on/off du debug.

            //Car on lancera l'intitialisation/fermeture de la kinect.

            debug.getSwitch().Click += new RoutedEventHandler(Switch_ClickInKinectMain);

            debug.Loaded += new RoutedEventHandler(Window_LoadedInKinectMain);

            debug.Closed += new EventHandler(Window_CloseInKinectMain);

            //On affiche la fenêtre de debug.

            try

            {

                debug.ShowDialog();

            }

            catch(Exception){

            }

        }

        /*

        *  Initialisation du sensor de la Kinect.

        */

        public void KinectInitialization()

        {

            try

            {

                //On sélectionne la première kinect détectée.

                kinectSensor = KinectSensor.KinectSensors.FirstOrDefault(s => s.Status == KinectStatus.Connected);

                //La caméra couleur est activée avec une résolution 640x480 et un framerate de 30 FPS.

                kinectSensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);

                //La caméra de profondeur est activée.

                kinectSensor.DepthStream.Enable();

                //Le squelette est activé.

                kinectSensor.SkeletonStream.Enable();

                //Quand le Middleware reçoit des trames de la Kinect, on va dans cette fonction.

                kinectSensor.AllFramesReady += new EventHandler<AllFramesReadyEventArgs>(AllFramesReady);

                //On applique des paramètres d'ajustement pour le squelette.

                TransformSmoothParameters parameters = new TransformSmoothParameters();

                parameters.Smoothing = 0.2f;

                parameters.Correction = 0.8f;

                parameters.Prediction = 0.0f;

                parameters.JitterRadius = 0.5f;

                parameters.MaxDeviationRadius = 0.5f;

                kinectSensor.SkeletonStream.Enable(parameters);

                //On démarre la Kinect.

                kinectSensor.Start();

            }

            catch (System.Exception)

            {

                debug.ShowException("KinectNotConnected");

            }

            //Pour les événements main gauche/droite entre dans/quitte le champ, on a 4 listeners.

            //Fonction appelée lorsque la main gauche entre dans le champ de recherche.

            LeftHandTrackedListener leftHandTrackedListener = new LeftHandTrackedListener();

            LeftHandTrackedEvent += new LeftHandTrackedHandler(leftHandTrackedListener.showAndSend);

            //Fonction appelée lorsque la main droite entre dans le champ de recherche.

            RightHandTrackedListener rightHandTrackedListener = new RightHandTrackedListener();

            RightHandTrackedEvent += new RightHandTrackedHandler(rightHandTrackedListener.showAndSend);

            //Fonction appelée lorsque la main gauche quitte le champ de recherche.

            LeftHandQuitListener leftHandQuitListener = new LeftHandQuitListener();

            LeftHandQuitEvent += new LeftHandQuitHandler(leftHandQuitListener.showAndSend);

            //Fonction appelée lorsque la main droite quitte le champ de recherche.

            RightHandQuitListener rightHandQuitListener = new RightHandQuitListener();

            RightHandQuitEvent += new RightHandQuitHandler(rightHandQuitListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur se penche.

            BendListener bendListener = new BendListener();

            BendEvent += new BendHandler(bendListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur croise les bras en X.

            CrossListener crossListener = new CrossListener();

            CrossEvent += new CrossHandler(crossListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur lève le genou.

            KneeUpListener kneeUpListener = new KneeUpListener();

            KneeUpEvent += new KneeUpHandler(kneeUpListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur effectue un Swipe right/left/up/down.

            SwipeListener swipeListener = new SwipeListener();

            SwipeEvent += new SwipeHandler(swipeListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur effectue un Push/Pull.

            PushListener pushListener = new PushListener();

            PushEvent += new PushHandler(pushListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur effectue un Jump.

            JumpListener jumpListener = new JumpListener();

            JumpEvent += new JumpHandler(jumpListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur effectue un Fall.

            FallListener fallListener = new FallListener();

            FallEvent += new FallHandler(fallListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur effectue un Wave.

            WaveListener waveListener = new WaveListener();

            WaveEvent += new WaveHandler(waveListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur effectue un Circle.

            CircleListener circleListener = new CircleListener();

            CircleEvent += new CircleHandler(circleListener.showAndSend);

            //Fonction appelée lorsque l'utilisateur se déplace dans la zone de détection.

            UserPositionListener userPositionListener = new UserPositionListener();

            UserPositionEvent += new UserPositionHandler(userPositionListener.showAndSend);

            modeManagement.DetectProximityBasedModes(0);

        }

        /*

        * Bouton ON/OFF du debug écouté dans KinectMain.

        */

        public void Switch_ClickInKinectMain(object sender, RoutedEventArgs e)

        {

            Console.Out.WriteLine(debug.getOn());

            //Si la kinect est allumée.

            if (debug.getOn())

            {

                //On initialise la Kinect.

                KinectInitialization();

            }

            else

            {

                //On éteint la Kinect.

                KinectClose();

            }

        }

        /*

         * Méthode associée à l'événement : Quitter via le menu écoutée dans KinectMain.

         */

        private void Quit_ClickInKinectMain(object sender, RoutedEventArgs e)

        {

            KinectClose();

            debug.Quit_Click(sender, e);

        }

        /*

         * Permet d'initialiser la Kinect dès que la fenêtre est lancée écoutée dans KinectMain.

         */

        private void Window_LoadedInKinectMain(object sender, RoutedEventArgs e)

        {

            KinectInitialization();

        }

        /*

        * Fermeture du debug écouté dans KinectMain.

        */

        private void Window_CloseInKinectMain(object sender, EventArgs e)

        {

            //On éteint la Kinect.

            KinectClose();

            debug.Window_Closed(sender, e);

        }

        /*

        *  Fermeture du sensor de la Kinect.

        */

        public void KinectClose()

        {

            try

            {

                //On stoppe la Kinect.

                kinectSensor.Stop();

                //On met a zero l'image d'affichage et le serveur.

                debug.ShutDownInterface();

            }

            catch (System.Exception)

            {

                debug.ShowException("KinectNotConnected");

            }

        }

        /*

        *  Récupère le premier squelette.

        */

        Skeleton GetFirstSkeleton(object sender, AllFramesReadyEventArgs e)

        {

            using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())

            {

                if (skeletonFrameData == null)

                    return null;

                if ((skeletons == null) || (skeletons.Length != skeletonFrameData.SkeletonArrayLength))

                    skeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];

                skeletonFrameData.CopySkeletonDataTo(skeletons);

                //On obtient le premier skelette.

                Skeleton first = (from s in skeletons where s.TrackingState == SkeletonTrackingState.Tracked select s).FirstOrDefault();

                return first;

            }

        }

        /*

        *  Récupère le squelette le plus proche.

        */

        Skeleton GetNearestSkeleton(object sender, AllFramesReadyEventArgs e)

        {

            using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())

            {

                if (skeletonFrameData == null)

                    return null;

                if ((skeletons == null) || (skeletons.Length != skeletonFrameData.SkeletonArrayLength))

                    skeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];

                skeletonFrameData.CopySkeletonDataTo(skeletons);

                Skeleton s;

                float minDist = (float)-1.0;

                int minID = 0;

                //Pour tous les squelettes.

                for(int i = 0 ; i < skeletons.Count() ; i++)