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_MIDDLEWARE

     7 * file that was distributed with this source code.

     8 */

     9 

    10 /*

    11  * Projet : TraKERS

    12  * Module : MIDDLEWARE

    13  * Sous-Module : Tracking/Gestures

    14  * Classe : UserPositionDetector

    15  * 

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

    17  * 

    18  * Fonctionnalités : Permet de détecter si l'utilisateur s'est déplacé dans la zone de détection, en se basant

    19  * sur la distance de l'utilisateur à Kinect.

    20  */

    21 

    22 using System;

    23 using System.Collections.Generic;

    24 using System.Linq;

    25 using System.Text;

    26 

    27 namespace Trakers.MainModule.Gestures

    28 {

    29     public class UserPositionDetector

    30     {

    31         float minDistance, maxDistance, zeroPoint;

    32         float searchMinDistance, searchMaxDistance;

    33 

    34         static int n = 0;

    35 

    36         /*

    37          * Le constructeur prend en entrée le debug mais aussi les principales distances qui délimitent la

    38          * zone de détection.

    39          */

    40         public UserPositionDetector(float _minDistance, float _maxDistance, float _zeroPoint, float _searchMinDistance, float _searchMaxDistance)

    41         {

    42             minDistance = _minDistance;

    43             maxDistance = _maxDistance;

    44             searchMinDistance = _searchMinDistance;

    45             searchMaxDistance = _searchMaxDistance;

    46             zeroPoint = _zeroPoint;

    47         }

    48 

    49         public void setParams(float minDist, float maxDist, float minDistHands, float maxDistHands, float zero)

    50         {

    51             //On charge tous les paramètres d'un coup.

    52             minDistance = minDist;

    53             maxDistance = maxDist;

    54             searchMinDistance = minDistHands;

    55             searchMaxDistance = maxDistHands;

    56             zeroPoint = zero;

    57         }

    58 

    59         /*

    60          * Lit la position de l'utilisateur à Kinect et ressort un pourcentage de proximité.

    61          * Règles : Droite affine de coefficient négatif.

    62          * .

    63          */

    64         public float CalcProximity(float distance)

    65         {

    66             //Si on se trouve trop loin.

    67             if (distance > maxDistance)

    68                 return 0.0f;

    69             //Si on se trouve trop près.

    70             if (distance < searchMinDistance)

    71                 return 0.0f;

    72             //Si on n'est pas encore trop près mais qu'on dépasse le point zéro.

    73             if (distance < zeroPoint)

    74                 return 100.0f;

    75 

    76             //Equation, de droite affine à partir de deux points.

    77             //Ici 99 tout simplement car 100 - 1, les limites de pourcentage de proximité.

    78             float a = 99/((float)zeroPoint - maxDistance);

    79             float b = 100 - a * zeroPoint;

    80 

    81             return a * distance + b;

    82         }

    83 

    84         /*

    85          * Estime le nombre de vidéos à afficher en fonction du pourcentage de proximité et du nombre de

    86          * vidéos dans la mosaïque.

    87          * .

    88          */

    89         public int ImagesToShow(float proximity, int N)

    90         {

    91             //Si la proximité est nulle, on retourne 0.

    92             if (proximity == 0f)

    93                 return 0;

    94             //Si on n'est pas encore trop près mais qu'on dépasse le point zéro.

    95             if (proximity >= 90f)

    96                 return N;

    97 

    98             //Pour chaque intervalle de déciles (dans les pourcentages), le nombre de dizaines

    99             //du pourcentage de proximité plus un, fois le nombre de dizaines d'images seront affichées.

   100             return (((int)proximity / 10) + 1) * ((int)N / 2);

   101         }

   102     }

   103 }