/*

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

 */

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.Drawing;

using System.Windows.Media.Media3D;

using Microsoft.Kinect;

using Coding4Fun.Kinect.Wpf;

using System.ComponentModel;

using Trakers.Debug;

using Tuio;

using Trakers.Communication;

using System.IO;

using Trakers.Tracking.Gestures;

using Trakers.Tracking.Events;

using System.Configuration;

using System.Resources;

using System.Reflection;

namespace Trakers.Tracking

{

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

    public class KinectMain

    {

        //Gestionnaire de ressources.

        private ResourceManager rm;

        //Fenêtre de debug.

        private Debug.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;

        //Distances min/max délimitant le champ de recherche.

        private float minDistHands;

        private float maxDistHands;

        //Temps de rafraichissement pour le timer (Détection de gesture dans le serveur TUIO).

        private int timerElapsing;

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

        private Server server;

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

        private string connexionHost;

        private int connexionPort;

        /*

        *  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 Debug.DebugWindow(this);

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

            swipeDetector = new SwipeDetector(debug);

            pushDetector = new PushDetector(debug);

            jumpDetector = new JumpDetector(debug);

            //On tente de charger les paramètres du fichier params.ini.

            //Si on n'y arrive pas, on affiche une erreur et on charge les paramètres par défaut.

            if (!loadParameters())

            {

                debug.ExceptionLbl.Content = rm.GetString("loadParametersFail");

                //Distances de détection des mains par défaut pour la recherche (ici de 1m à 2m de la Kinect).

                minDistHands = (float)1.0;

                maxDistHands = (float)1.5;

                connexionHost = "127.0.0.1";

                connexionPort = 80;

                timerElapsing = 1000;

            }

            //On affiche la fenêtre de debug.

            try

            {

                debug.ShowDialog();

            }

            catch(Exception){}

        }

        /*

        *  Initialisation de la classe principale avec comme argument le gestionnaire de ressources.

        */

        public KinectMain(ResourceManager _rm) : this()

        {

            rm = _rm;

        }

        /*

        *  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();

                debug.ExceptionLbl.Content = "";

            }

            catch (System.Exception)

            {

                debug.ExceptionLbl.Content = rm.GetString("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.ShowOnScreen);

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

            RightHandTrackedListener rightHandTrackedListener = new RightHandTrackedListener();

            RightHandTrackedEvent += new RightHandTrackedHandler(rightHandTrackedListener.ShowOnScreen);

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

            LeftHandQuitListener leftHandQuitListener = new LeftHandQuitListener();

            LeftHandQuitEvent += new LeftHandQuitHandler(leftHandQuitListener.ShowOnScreen);

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

            RightHandQuitListener rightHandQuitListener = new RightHandQuitListener();

            RightHandQuitEvent += new RightHandQuitHandler(rightHandQuitListener.ShowOnScreen);

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

            SwipeListener swipeListener = new SwipeListener();

            SwipeEvent += new SwipeHandler(swipeListener.ShowOnScreen);

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

            PushListener pushListener = new PushListener();

            PushEvent += new PushHandler(pushListener.ShowOnScreen);

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

            JumpListener jumpListener = new JumpListener();

            JumpEvent += new JumpHandler(jumpListener.ShowOnScreen);

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

        }

        /*

        *  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.DebugImage.Source = null;

                //server = null;

                debug.ExceptionLbl.Content = "";

            }

            catch (System.Exception)

            {

                debug.ExceptionLbl.Content = rm.GetString("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 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.

                //On construit l'historique des postures.

                List<Joint> joints = new List<Joint>();

                joints.Clear();

                GestureDetector.UpdateSkeletonHistory(joints);

                //On obtient sa distance à la Kinect.

                float distance = first.Position.Z;

                //On affiche la distance dans le debug.

                debug.showDistance(distance);

                //Si la main gauche est dans le champ, on lance l'événement approprié.

                if (handLeft.Position.Z < maxDistHands && handLeft.Position.Z > minDistHands)