train_lattice_node.h

这是处理语音信号的程序

// file: train_lattice_node.h
//
// this is the header for the lattice node class
//

// make sure definitions are only made once
//
#ifndef __ISIP_TRAIN_LATTICE_NODE
#define __ISIP_TRAIN_LATTICE_NODE

// isip include files
//
#ifndef __ISIP_INTEGRAL
#include <integral.h>
#endif

// forward declaration of classes
//
#ifndef __ISIP_TRAIN_LINK_LIST
#include <train_link_list.h>
#endif

#ifndef __ISIP_TRAIN_WORD
#include <train_word.h>
#endif

class Train_Lex_tree;

// Train_Lattice_node: a class that is used to store the word (or other
// acoustic unit) end information in the lattice. it also contains
// a list of all possible next nodes and all prev nodes leading to
// this node
//
class Train_Lattice_node {
  
  //---------------------------------------------------------------------------
  //
  // protected data
  //
  //---------------------------------------------------------------------------
protected:
  
  // node identity
  //
  int_4 node_index_d;                // node index
  int_4 type_d;                      // word/model/state etc.
  Train_Word* word_d;                      // word represented by the node
  int_4 pron_variant_d;              // pronunciation variant d
  int_4 frame_d;                     // frame at which the item ended
  
  // node statistics
  //
  int_4 num_arcs_in_d;		     // number of incoming arcs	
  int_4 num_arcs_out_d;              // number of outgoing arcs

  // nodes connected to this node
  //
  Train_Link_list* prev_nodes_d;           // linked list of previous nodes
  Train_Link_list* next_nodes_d;           // linked list of following nodes

  // pointer to the corresponding lexical tree
  //
  Train_Lex_tree* lex_tree_d;

  // acoustic and language model scores of words emanating from this
  // node
  //
  float_8* lm_scores_d;
  float_8* ac_scores_d;
  
  //---------------------------------------------------------------------------
  //
  // public methods
  //
  //---------------------------------------------------------------------------
public:
  
  // required methods
  //
  char_1* name_cc();
  volatile void error_handler_cc(char_1* mname, char_1* msg);
  logical_1 debug_cc(FILE* fp, char_1* message);
  int_4 size_cc();
    
  // destructors/constructors
  //
  ~Train_Lattice_node();                             // destructor
  Train_Lattice_node();                              // default constructor
  Train_Lattice_node(int_4 node_index);              // overloaded
  Train_Lattice_node(Train_Lattice_node& lat_node);        // copy constructor
    
  // methods to set/get generic information
  //
  logical_1 set_type_cc(int_4 item_index);     // type
  int_4 get_type_cc();
  logical_1 set_word_cc(Train_Word* word);           // word
  Train_Word* get_word_cc();               
  logical_1 set_pron_var_cc(int_4 pron_var);  // pronunciation variant
  int_4 get_pron_var_cc();             
  logical_1 set_frame_index_cc(int_4 frame);  // frame index
  int_4 get_frame_index_cc();
  logical_1 set_node_index_cc(int_4 index);  // node index
  int_4 get_node_index_cc();             

  // methods to set/get node statistics
  //
  logical_1 set_num_arcs_in_cc(int_4 num_arcs);  // number of incoming arcs
  logical_1 incr_num_arcs_in_cc();
  int_4 get_num_arcs_in_cc();
  logical_1 set_num_arcs_out_cc(int_4 num_arcs); // number of outgoing arcs
  logical_1 incr_num_arcs_out_cc();
  int_4 get_num_arcs_out_cc();

  // methods to set/get list of nodes connected to this node
  //
  Train_Link_list* get_prev_nodes_cc();             // prev nodes
  Train_Link_list* get_next_nodes_cc();             // next nodes  
  
  // methods to add a node to the prev/next nodes list
  //
  logical_1 add_prev_node_cc(Train_Lattice_node* lat_node); 
  logical_1 add_next_node_cc(Train_Lattice_node* lat_node);

  // methods to set/get lexical tree
  //
  logical_1 set_lex_tree_cc(Train_Lex_tree* tree);
  Train_Lex_tree* get_lex_tree_cc();

  // methods to handle lm scores
  //
  float_8* get_lm_scores_cc();      // get the array containing the LM scores
  logical_1 add_lm_score_cc(float_8 lm_score);    // add a score to the array
  
  // methods to handle acoustic scores
  //
  float_8* get_ac_scores_cc(); // get the array containing the acoustic scores
  logical_1 add_ac_score_cc(float_8 lm_score);    // add a score to the array
  
  // method to add a node to the next list of this node
  //
  logical_1 add_node_cc(Train_Lattice_node* lat_node, float_8 lmscore,
			float_8 acscore, Train_Lattice_node** lnode,
			int_4*& map_list, int_4& count);

  // method to clear the contents of the lattice node
  //
  logical_1 clear_cc();
  
  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:

};

// end of file
// 
#endif