Перейти к содержимому
Compvision.ru

Krok27

Пользователи
  • Количество публикаций

    2
  • Зарегистрирован

  • Посещение

Сообщения, опубликованные пользователем Krok27


  1. Сохранение и загрузка сохраненной модели:

    Сохранение:

    void HMM_Save( const std::string &fileName, CvEHMM*  _ehmm, int _vecSize )
    {
    	
    	int i = 0;
    	int j = 0;
    	int m = 0;
    	int k = 0;
    	vector<int> NumStates;
        assert( _ehmm != 0 );
    	FileStorage fs;
    	fs.open(fileName, FileStorage::WRITE);
    	if(!fs.isOpened())
    			return;
    	    
        // записываем топологию
        fs << "NumSuperStates" << _ehmm->num_states;
    	fs << "NumStates" <<  "[";
    	
        for( i = 0; i < _ehmm->num_states; i++ )
        {
            fs << _ehmm->u.ehmm[ i ].num_states;
        }
    	fs << "]";
    	fs << "NumGaussMixtures" <<  "[";
    	for( i = 0; i < _ehmm->num_states; i++ )
            {
              CvEHMM* ehmm = &( _ehmm->u.ehmm[ i ] );
    
              for( int j = 0; j < ehmm->num_states; j++ )
              {
            	fs << ehmm->u.state[ j ].num_mix ;
              }
            }
    	fs << "]";
        
            fs << "VecSize"  << _vecSize;
    	
        //Пишем все hmms
        
    	CvEHMM* hmm = _ehmm;
            fs << "DataHMM" << "{";
    	for( i = 0; i < _ehmm->num_states + 1; i++ )
            {
              if ( hmm->level == 0 )
    		{
                       fs << "EmbeddedHMM"+ToString(i) << "{" ;
    		}
                    else
    		{
    	         fs << "ExternalHMM" << "{" ;
    		}
    
            fs << "NumStates" << hmm->num_states;
    		
            if ( hmm->level == 0 )
            {
                for ( j = 0; j < hmm->num_states; j++)
                {
                          CvEHMMState* state = &( hmm->u.state[ j ] );
    		      fs << "State" + ToString(j) <<  "{";
    		      fs  << "NumMixes" <<  state->num_mix;
                          float* mu = state->mu;
                          float* inv_var = state->inv_var;
    		   for( m = 0; m < state->num_mix; m++)
                       {
                          fs << "Mixture" + ToString(m)<< "{";
    		      fs << "Weight" << state->weight[ m ];
    		      fs << "Mean" << "[" ; 
    		      for ( k = 0; k < _vecSize; k++)
                          {  
                            fs << mu[ 0 ]; 
    			mu++;
                          } 
    			fs << "]" ; // mean
                    	fs << "Inverted_Deviation" << "[";
    				                    
                        for ( k = 0; k < _vecSize; k++)
                        {
                            fs << inv_var[ 0 ];
    			      inv_var++;
                        }
    			fs << "]"; //Inverted_Deviation
                       	fs << "LogVarVal" << state->log_var_val[ m ];
    			fs << "}"; //mixture
                    }
    
    			   fs << "}";// state
                }
            }
    
            //
            fs << "TransP" << "[";
    	float* prob = hmm->transP;
            for ( int j = 0; j < hmm->num_states; j++)
            {
                for ( int k = 0; k < hmm->num_states; k++)
                {
                   fs << *prob;
    		       prob++;
                }            
            }
    		fs << "]"; //TransP
    		fs << "}"; // EmbeddedHMM или ExternalHMM
            hmm = &( _ehmm->u.ehmm[ i ] );
        }
    	fs << "}"; //DataHMM
    	fs.release();
    }
    
    //*****************************************************************************
    

    Загрузка:

    bool HMM_Load( const string &fileName, CvEHMM**  _ehmm)
    {
    	vector<int> states;
    	vector<int> GaussMix;
    	vector<float> TransP;
    	vector<float> Mean;
    	string Tmp;
    	int NumSuperStates = 0;
    	int VecSize = 0;
    	
      
    	FileStorage fs;
    	fs.open(fileName, FileStorage::READ | FileStorage::FORMAT_XML);
    	if(!fs.isOpened())
    			return false;
       
    	
        fs["NumSuperStates"] >> NumSuperStates;
    	fs["NumStates"] >> states;
    	states.insert(states.begin(),NumSuperStates);
    	int size = states.size();
    	fs["NumGaussMixtures"] >> GaussMix;
    	fs["VecSize"] >> VecSize;
        (*_ehmm) = cvCreate2DHMM( &states[0], &GaussMix[0], VecSize);
    
        
      
        
    	CvEHMM* hmm = *_ehmm;
    	FileNode DataHMM = fs["DataHMM"];
    	int idx = 0;
            FileNodeIterator it_beg = DataHMM.begin(); 
    	FileNodeIterator it_end = DataHMM.end();
    	
    	for(it_beg; it_beg != it_end; ++it_beg,  ++idx)
    	{
    		if(idx != 0)
    		{
    			for(int j=0; j < states[idx]; j++)
    			{
    			
    				
    				FileNode node =  (*it_beg)["State"+ToString(j)];//State0
    				int count = node.size();
    				string name = node.name();
    				CvEHMMState* state = &( hmm->u.state[ j ] );
    				float* mu = state->mu;
    				float* inv_var = state->inv_var;
    				
    				for( int m = 0; m < state->num_mix; m++)
                                    {
    					FileNode node_mix = node["Mixture"+ToString(m)];
    					Mean.clear();
    					state->weight[ m ] = node_mix["Weight"];
    					node_mix["Mean"] >> Mean;
    					for ( int k = 0; k < VecSize; k++)
                                            {  
                                                   (*mu) =  Mean[k]; 
    						++mu;
                                            } 
    					
    					Mean.clear();
    					node_mix["Inverted_Deviation"] >> Mean;
    					for ( int k = 0; k < VecSize; k++)
                                            {
                                                (*inv_var) = Mean[k];
    					     ++inv_var;
                                            }
    					state->log_var_val[ m ] = node_mix["LogVarVal"];
    				}
    			}		
    		}
    	
    		TransP.clear();
    		(*it_beg)["TransP"] >> TransP;
    		 float* prob = hmm->transP;
    		 int counter = 0;
    		for ( int j = 0; j < hmm->num_states; j++)
                    {
                       for ( int k = 0; k < hmm->num_states; k++)
                       {
                          *prob  = TransP[counter++];
                           prob++;
                       }            
                    }
    		hmm = &( (*_ehmm)->u.ehmm[ idx] );	
    	 }
    return true;
    }
    
    
    • Like 1

  2. VideoCapture cap(0);
    if(!cap.isOpened())
    			return;
    // разрешение камеры
     cap.set(CV_CAP_PROP_FRAME_WIDTH, 640);
     cap.set(CV_CAP_PROP_FRAME_HEIGHT, 480);
    
    Mat frame;
    // создадим  писатель
    VideoWriter videowriter;
    // попытка получить fps
    //double fps = cap.get( CV_CAP_PROP_FPS); в Windows всегда возвращает 0.
    // высавим имперически 14-16 fps. 
    double fps = 14;
    // размер видеофреймов
    CvSize size = cvSize(cap.get((int) CV_CAP_PROP_FRAME_WIDTH), cap.get((int) CV_CAP_PROP_FRAME_HEIGHT));
    // откроем файл
    string FileCaptureCamera = "test.avi";
    videowriter.open(FileCaptureCamera, CV_FOURCC('X','V','I','D'), fps, size, true);// последний параметр функции - цветность.
    if(!videowriter.isOpened())
    	return;
    while(1)
    {
    // получим картинку
    cap >> frame;
    // с фремом что-то сделать, рамку вокруг лица, например, нарисовать ))))
    
    // сохраняем в файл
    videowriter.write(frame);  
    // или videowriter << frame;
    if(cvWaitKey(33) == 27)
          break;
    
    }
    if(writefile)
    {
    		
    // можно не вызывать, в деструкторе VideoWriter имеено этот метод вызывается
    videowriter.release();
    		
    }
    
    
    

    Именования кодеков можно посмотреть на сайте http://www.fourcc.org/codecs.php

    Кодек должен быть установлен в системе. Или в папку с исполняемым фалом кладем opencv_ffmpegxxx.dll, где xxx номер вашей библиотеки opencv. 

    Я так понял к каждой камере нужно подбирать или вычислять свой fps, т.к. записанное видео может воспроизводиться в ускоренном или замедленном темпе.

    Здесь вопрос пока открыт.

×