/*

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

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

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

    public class KinectMain

    {

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

        private SwipeDetector swipeDetector;

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

        private float minDistHands;

        private float maxDistHands;

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

        public static event SwipeHandler SwipeEvent;

        //Voici les ID des noeuds d'un squelette.

        /*

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

            {

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

            }

            //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 démarre la Kinect.

                kinectSensor.Start();

                debug.ExceptionLbl.Content = "";

            }

            catch (System.Exception)

            {

            }

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

            SwipeEvent += new SwipeHandler(swipeListener.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)

            {

            }

        }

        /*

        *  Récupère le premier squelette.

        */

        {

            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.

        */

        {

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

            //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, hipCenterID), spine = getJoint(first, spineID), shoulderCenter = getJoint(first, shoulderCenterID), head = getJoint(first, headID);

                Joint shoulderLeft = getJoint(first, shoulderLeftID), elbowLeft = getJoint(first, elbowLeftID), wristLeft = getJoint(first, wristLeftID), handLeft = getJoint(first, handLeftID);

                Joint shoulderRight = getJoint(first, shoulderRightID), elbowRight = getJoint(first, elbowRightID), wristRight = getJoint(first, wristRightID), handRight = getJoint(first, handRightID);

                Joint hipLeft = getJoint(first, hipLeftID), kneeLeft = getJoint(first, kneeLeftID), ankleLeft = getJoint(first, ankleLeftID), footLeft = getJoint(first, footLeftID);

                Joint hipRight = getJoint(first, hipRightID), kneeRight = getJoint(first, kneeRightID), ankleRight = getJoint(first, ankleRightID), footRight = getJoint(first, footRightID);

                //On construit l'historique des postures.

                joints.Clear();