Source: hmmLis.h

/**
 * Classe principale de l'algorithme hmm.
 *
 * @short Module HMM
 * @author G.Garcia (source cpp: Philippe Chose)
 * @version 7
 */

class hmmLis
{
public:
  /**
   * Fréquence minimale d'analyse
   */
  float   fmin;
  /**
   * Fréquence maximale d'analyse
   */
  float   fmax;
  /**
   * Variation maximale absolue de fréquence
   */
  float   df_abs;
  /**
   * Variation maximale relative de fréquence
   */
  float   df_rel;
  /**
   * Poids des scores (frequence, amplitude, phase)
   */
  param* gain_coefs;
  /**
   * Variances pour le calcul du score
   */
  param* variances;
  /**
   * Coefficients additifs pour le calcul du score
   */
  param* add_coefs;
  /**
   * Taille de la fenêtre d'analyse HMM
   */
  int     window;
  /**
   * Nombre maximal de pics dans une trame 
   */
  int     maxNbPeaks;
  /**
   * Nombre maximal de partiels dans une trame
   */
  int     maxNbOutput;
  /**
   * Nombre maximal de partiels détectés dans une fenêtre d'analyse HMM
   */
  int     maxNbViterbi;
  /**
   * Pas de temps entre deux trames
   */
  float   step;
  /**
   * Marqueur de fin d'analyse
   */
  float   tmax;
  /**
   * Marqueur de début d'analyse
   */
  float   tmin;
  /**
   * Fréquence d´échantillonage
   */
  float   SR;
  /** 
   * Nombre maximal de lignes détectées dans une fenêtre d'analyse HMM
   */
  int     maxNbLines;
  /**
   * Nombre maximal de lignes dans un fenêtre d'analyse HMM ayant au moins un
   * pic en commun
   */
  int     maxNbLinks;
  /**
   * Résolution fréquentielle pour algorithme de viterbi (cf @ref lines::res_freq )
   */
  float   res_freq;
  /**
   * Nombre de cellules fréquentielles pour algorithme de viterbi (cf @ref lines::nb_freq )
   */
  int	  nb_freq;
  /**
   * Choix entre détection de partiels ou de formants. Deux valeurs possibles: HMM_ADDITIVE
   * et HMM_FORMANT.
   */
  char    param_type;
  /**
   * Structure de gestion du delai de deuil après mort d'un partiel et avant réutilisation de son index.
   */
  tab_time 	*heaven ;
  /**
   * Drapeau indiquant le mode d'entrées/sorties de Pm: PM_BIN ou PM_SDIF.
   */
  PmFormat pmMode;
  
private:
  /**
   * Type de fonction de lecture de partiels (cf @ref hmmLis::read_additive_param et
   * @ref hmmLis::read_formant_param )
   */
  typedef int(hmmLis::*READ_PARAM)(FILE *fp, PmPartialSet ps, PmFormat format_flag);
  /**
   * Pointeur sur la fonction de lecture de pics choisie
   */
  READ_PARAM read_param;
  /**
   * Tableau de PmPartialSet contenant les données à analyser
   */
  PmPartialSet* bande;
  /**
   * TODO
   */
  float* mean_freq ;
  /**
   * Tableau contenant le nombre de pics par trame
   */
  int* nombre_f;
  /**
   * Tableau contenant les repères temporels des trames
   */
  float* tmp_f;
  /**
   * Tableau contenant les trajets de partiels correspondant à une fenêtre
   * d'analyse HMM.
   */
  int** Tviterbi;
  /**
   * Trajectoires de partiels indexées en fonction de leur état (Alive, Dead, ...)
   */
  int** Toutput;
  /**
   * Tableaux d'index des partiels détectés (vivants,morts,...)
   */
  partials* p ;
  
public:
  /**
   * Constructeur
   *  effectue certaines allocations mémoire (p,heaven,gain_coefs,variances,mul_coefs)
   *  et initialise les variables 
   */
  hmmLis();
  /**
   * Destructeur
   *  ne fait rien
   */
  ~hmmLis();

  /**
   * Procédure de calcul
   *  selectionne la fonction de lecture, alloue de la mémoire, initialise
   *  les données en mémoire puis rentre dans la boucle principale.
   *  Cette boucle principale est constituée essentiellement
   *  de deux appels de méthodes dans les classes lines et line_sets.
   *  le premier appel (@ref lines::find_lines ) détecte les lignes de pics
   *  susceptibles de devenir des partiels
   */
  void process();

private:

  /**
   * Décalage des tableaux en mémoire au changement de trame
   *
   * @param bande tableau des pics
   * @param tmp_f tableau des repères temporels
   * @param nombre_f tableau du nombre de pics par trame
   * @param window taille de la fenêtre d'analyse
   */
  void ShiftMem( PmPartialSet* bande, float* tmp_f, int* nombre_f, int window );

  /**
   * Initializations diverses
   *
   * @param bande tableau de pics
   * @param tmp_f tableau des repères temporels
   * @param nombre_f tableau du nombre de pics par trame
   * @param p tableaux des index de partiels
   */
  void Init(PmPartialSet* bande, int* nombre_f, float* tmp_f, partials* p);
  
  /**
   * Allocation mémoire
   *
   * @param maxNbPeaks nombre maximal de pics par trame
   */
  void AllocMem(int maxNbPeaks );
  /**
   * Désallocation mémoire
   */
  void DesallocMem();
  
  /**
   * Lecture de trames de pics au format fmt(Pm)
   *   option partiels
   *
   * @param fp fichier au format fmt(Pm)
   * @param ps tableau de pics à remplir
   * @param format_flag format du fichier à lire
   */
  int read_additive_param(FILE* fp, PmPartialSet ps, PmFormat format_flag);
  /** 
   * Lecture de trames de pics au format fmt(Pm)
   *   option formants
   *
   * @param fp fichier au format fmt(Pm)
   * @param ps tableau de pics à remplir
   * @param format_flag format du fichier à lire
   */
  int read_formant_param(FILE* fp, PmPartialSet ps, PmFormat format_flag);

  /**
   * Mise à jour des données du tableau @ref hmmLis::Toutput à partir du tableau @ref hmmLis::Tviterbi
   *
   * @param optnbPart nombre de partiels détectés dans la fenêtre d'analyse courante
   * et contenus dans le tableau @ref hmmLis::Tviterbi
   */  
  void FillToutput(int optnbPart);
  /**
   * Sortie fichier des partiels détectés au format fmt(Pm)
   */
  void write_param();
  /**
   * Décalage des tableaux de lignes en fin de trame
   */
  void ShiftLines();
  /**
   * Mise à jour des temps de deuil après mort de partiels (cf @ref tab_time )
   */
  void IncrHeavenTime();
};


/**
 * Aide sur la ligne de commande
 */
void usage();

/**
 * Program entry point
 *
 * @param argc nombre de paramètre sur la ligne de commande + 1
 * @param argv tableau contenant ces paramètres
 */
int main(int argc, char **argv);

/**
 * Drapeau indiquant si les informations de debugging doivent être affichées
 */
int DEBUG;