/*

* 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_MIDDLEWARE

* 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.Documents;

using Microsoft.Kinect;

using Trakers.Communication;

using Trakers.MainModule.Events;

using Trakers.MainModule.Gestures;

using Trakers.MainModule.Search;

using Trakers.Debug;

using System.Windows;

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 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 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 swipes.

        private SwipeDetector swipeDetector;

        //Détecteur de pushes.

        private PushDetector pushDetector;

        //Détecteur de jumps.

        private JumpDetector jumpDetector;

        //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 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 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 gestes.

            swipeDetector = new SwipeDetector();

            pushDetector = new PushDetector();

            jumpDetector = new JumpDetector();

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

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

            //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);

            debug.getQuitMenu().Click += new RoutedEventHandler(Quit_ClickInKinectMain);

            //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 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 se déplace dans la zone de détection.

            UserPositionListener userPositionListener = new UserPositionListener();

            UserPositionEvent += new UserPositionHandler(userPositionListener.showAndSend);

        }

        /*

        * 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++)

                {

                    s = skeletons.ElementAt(i);

                    //S'il est tracké.

                    if(s.TrackingState == SkeletonTrackingState.Tracked)

                    {

                        //On récupère sa position et on obtient la distance min et l'ID du squelette qui est à la distance min.

                        float dist = skeletons.ElementAt(i).Position.Z;

                        if (minDist == -1)

                        {

                            minDist = dist;

                            minID = i;

                        }

                        else if(minDist > dist)

                        {

                            minDist = dist;

                            minID = i;

                        }

                    }

                }

                //On renvoie le skelette le plus proche.

                return skeletons.ElementAt(minID);

            }

        }

        /*

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

        */

        private void AllFramesReady(object sender, AllFramesReadyEventArgs e)

        {

            //On ne calcule rien si la fenêtre de debug se ferme.

            if (debug.isClosing())

                return;

            //On écoute le debug pour savoir si les paramètres ont été modifiés.

            //On met à jour la vidéo de debug.

            debug.RefreshVideo(e);

            //On récupère le premier squelette tracké.

            //Skeleton first = GetFirstSkeleton(e);

            //On récupère le plus proche squelette tracké.

            Skeleton first = GetNearestSkeleton(sender, e);

            //Si celui-ci n’est pas nul

            if (first == null)

                return;

            //Si ce squelette est tracké (donc suivi et reconnu par la camera)

            if (first.TrackingState == SkeletonTrackingState.Tracked)

            {

                //Ensemble des noeuds du squelette.

                Joint hipCenter = getJoint(first, JointType.HipCenter), spine = getJoint(first, JointType.Spine), shoulderCenter = getJoint(first, JointType.ShoulderCenter), head = getJoint(first, JointType.Head);

                Joint shoulderLeft = getJoint(first, JointType.ShoulderLeft), elbowLeft = getJoint(first, JointType.ElbowLeft), wristLeft = getJoint(first, JointType.WristLeft), handLeft = getJoint(first, JointType.HandLeft);

                Joint shoulderRight = getJoint(first, JointType.ShoulderRight), elbowRight = getJoint(first, JointType.ElbowRight), wristRight = getJoint(first, JointType.WristRight), handRight = getJoint(first, JointType.HandRight);

                Joint hipLeft = getJoint(first, JointType.HipLeft), kneeLeft = getJoint(first, JointType.KneeLeft), ankleLeft = getJoint(first, JointType.AnkleLeft), footLeft = getJoint(first, JointType.FootLeft);

                Joint hipRight = getJoint(first, JointType.HipRight), kneeRight = getJoint(first, JointType.KneeRight), ankleRight = getJoint(first, JointType.AnkleRight), footRight = getJoint(first, JointType.FootRight);