calibfilter.cpp

微软的基于HMM的人脸识别原代码, 非常经典的说

    CAutoLock cAutoLock(&m_CCalibFilterLock);

    m_initial_params.enable_undistortion = m_params.enable_undistortion = enable;

    SetDirty(TRUE);

    return  NOERROR;
}


STDMETHODIMP CCalibFilter::get_Show3DWindow(
    long*   enable)
{
    *enable = m_params.show_3d_window;
    return  NOERROR;
}

STDMETHODIMP CCalibFilter::set_Show3DWindow(
    long    enable)
{
    CAutoLock cAutoLock(&m_CCalibFilterLock);

    m_initial_params.show_3d_window = m_params.show_3d_window = enable;

    m_window3D->Show( enable != 0 );

    SetDirty(TRUE);
    
    return  NOERROR;
}

STDMETHODIMP CCalibFilter::SaveCameraParams()
{
    if( m_params.calib_state == CalibState_Calibrated)
    {
        OPENFILENAME lpofn;
        char fileName[MAX_PATH] = "";
        
        lpofn.lStructSize       = sizeof(OPENFILENAME);
        lpofn.hwndOwner         = 0;
        lpofn.hInstance         = 0;
        lpofn.lpstrFilter       = "Camera parameters (*.txt)\0*.txt\0";
        lpofn.lpstrCustomFilter = 0;
        lpofn.nMaxCustFilter    = 0;
        lpofn.nFilterIndex      = 1;
        lpofn.lpstrFile         = fileName;
        lpofn.nMaxFile          = MAX_PATH;
        lpofn.lpstrFileTitle    = 0;
        lpofn.nMaxFileTitle     = 0;
        lpofn.lpstrInitialDir   = 0;
        lpofn.lpstrTitle        = 0;
        lpofn.Flags             = OFN_OVERWRITEPROMPT;
        lpofn.nFileOffset       = 0;
        lpofn.nFileExtension    = 0;
        lpofn.lpstrDefExt       = "txt";
        lpofn.lCustData         = 0;
        lpofn.lpfnHook          = 0;
        lpofn.lpTemplateName    = 0;
        
        GetSaveFileName(&lpofn);
        if( strlen(fileName) != 0)
        {
            FILE *file = fopen(fileName,"wt");
            if( file != 0)
            {
                int i, j;
                fprintf(file,"Camera Matrix:\n");
                for( i = 0; i < 3; i++ )
                {
                    for( j = 0; j < 3; j++ )
                    {
                        fprintf( file,"M[%d.%d]=%20.7f", i, j, m_camera.matrix[i*3+j]);
                    }
                    fprintf(file,"\n");
                }

                fprintf(file,"\n\nDistortion:\n");
                for( i = 0; i < 4; i++ )
                    fprintf(file,"D[%d]=%f\n", i, m_camera.distortion[i]);
                
                fclose(file);
            }
            else
            {
                MessageBox(0,"Can't open file","Save camera parameters",MB_OK|MB_ICONERROR);
            }
        }
    }
    else
    {
        MessageBox(0,"Camera was not calibrated","Save camera parameters",MB_OK);
    }

    return  NOERROR;
}

STDMETHODIMP CCalibFilter::LoadCameraParams()
{
    OPENFILENAME lpofn;
#define BUF_SIZE 10000
    char buffer[BUF_SIZE + 100];
    char fileName[MAX_PATH] = "";
    
    lpofn.lStructSize       = sizeof(OPENFILENAME);
    lpofn.hwndOwner         = 0;
    lpofn.hInstance         = 0;
    lpofn.lpstrFilter       = "Camera parameters (*.txt)\0*.txt\0";
    lpofn.lpstrCustomFilter = 0;
    lpofn.nMaxCustFilter    = 0;
    lpofn.nFilterIndex      = 1;
    lpofn.lpstrFile         = fileName;
    lpofn.nMaxFile          = MAX_PATH;
    lpofn.lpstrFileTitle    = 0;
    lpofn.nMaxFileTitle     = 0;
    lpofn.lpstrInitialDir   = 0;
    lpofn.lpstrTitle        = 0;
    lpofn.Flags             = OFN_FILEMUSTEXIST;
    lpofn.nFileOffset       = 0;
    lpofn.nFileExtension    = 0;
    lpofn.lpstrDefExt       = "txt";
    lpofn.lCustData         = 0;
    lpofn.lpfnHook          = 0;
    lpofn.lpTemplateName    = 0;
    
    GetOpenFileName(&lpofn);

    if( strlen(fileName) != 0)
    {
        FILE *file = fopen(fileName,"rb");

        if( file != 0)
        {
            int i, j, k;
            float cameraMatrix[9];
            float distortion[4];

            int sz = fread( buffer, 1, BUF_SIZE, file );
            char* ptr = buffer;
            buffer[sz] = '\0';

            /* read matrix */
            for( k = 0; k < 9; k++ )
            {
                ptr = strstr( ptr, "M[" );
                if( ptr )
                {
                    int s = 0;
                    ptr += 2;
                    if( sscanf( ptr, "%d%*[.,]%d%n", &i, &j, &s ) == 2 && i == k/3 && j == k%3 )
                    {
                        ptr += s;
                        ptr = strstr( ptr, "=" );
                        if( ptr )
                        {
                            s = 0;
                            ptr++;
                            if( sscanf( ptr, "%f%n", cameraMatrix + k, &s ) == 1 )
                            {
                                ptr += s;
                                continue;
                            }
                        }
                    }
                }

                /* else report a bug */
                MessageBox(0,"Invalid file format","Load camera parameters",MB_OK|MB_ICONERROR);
                return E_FAIL;
            }

            /* read distortion */
            for( k = 0; k < 4; k++ )
            {
                ptr = strstr( ptr, "D[" );
                if( ptr )
                {
                    int s = 0;
                    ptr += 2;
                    if( sscanf( ptr, "%d%n", &i, &s ) == 1 && i == k )
                    {
                        ptr += s;
                        ptr = strstr( ptr, "=" );
                        if( ptr )
                        {
                            s = 0;
                            ptr++;
                            if( sscanf( ptr, "%f%n", distortion + k, &s ) == 1 )
                            {
                                ptr += s;
                                continue;
                            }
                        }
                    }
                }

                /* else report a bug */
                MessageBox(0,"Invalid file format","Load camera parameters",MB_OK|MB_ICONERROR);
                return E_FAIL;
            }

            memcpy( m_camera.matrix, cameraMatrix, sizeof( cameraMatrix ));
            memcpy( m_camera.distortion, distortion, sizeof( distortion ));

            m_camera.focalLength[0] = m_camera.matrix[0];
            m_camera.focalLength[1] = m_camera.matrix[4];

            m_camera.principalPoint[0] = m_camera.matrix[2];
            m_camera.principalPoint[1] = m_camera.matrix[5];

            m_params.calib_state = CalibState_Calibrated;

            fclose(file);
        }
        else
        {
            MessageBox(0,"Can't open file","Load camera parameters",MB_OK|MB_ICONERROR);
        }
    }

    SetDirty(TRUE);
        
    return  NOERROR;
}

//////////////////////////////////////
//////////////////////////////////////
//////////////////////////////////////

STDMETHODIMP CCalibFilter::set_FramesToCollect(
    long    frames)
{
    CAutoLock cAutoLock(&m_CCalibFilterLock);

    m_initial_params.frames_to_collect = m_params.frames_to_collect = frames;
    SetDirty(TRUE);
    return  NOERROR;
}


STDMETHODIMP CCalibFilter::StartCalibrate()
{
    CAutoLock cAutoLock(&m_CCalibFilterLock);

    m_params = m_initial_params;
    m_params.calib_state = CalibState_CalibrationProcess;
    m_params.frames_collected = 0;

    return  NOERROR;
}

STDMETHODIMP CCalibFilter::GetCameraParams( CvCameraParams* camera )
{
    if( m_params.calib_state != CalibState_Calibrated ) return E_PENDING;
    
    *camera = m_camera;
    return  NOERROR;
}


STDMETHODIMP CCalibFilter::GetState(
   CalibState*  calib_state,
   long*   frames_collected,
   long*   frames_passed,
   double* last_frame_time)
{
    *calib_state = m_params.calib_state;
    *frames_collected = m_params.frames_collected;
    *frames_passed = m_params.frames_passed;
    *last_frame_time = m_params.last_frame_time;

    return NOERROR;
}


STDMETHODIMP CCalibFilter::GetPages(CAUUID *pPages)
{
    pPages->cElems = 1;
    pPages->pElems = (GUID *) CoTaskMemAlloc(sizeof(GUID));
    if( !pPages->pElems ) return E_OUTOFMEMORY;
    *(pPages->pElems) = CLSID_CCalibFilterPropertyPage;
    return NOERROR;
}

STDMETHODIMP CCalibFilter::Update3DWindow()
{
    CvSize etalon_size = cvSize( (int)m_params.etalon_params[0],
                                      (int)m_params.etalon_params[1] );
    float square_size = m_params.etalon_params[2];

    m_window3D->SetParams( &m_camera, etalon_size, square_size );
    return  NOERROR;
}


// IPersistStream implementation
STDMETHODIMP CCalibFilter::GetClassID( CLSID *pClsID )
{
    return CBaseFilter::GetClassID( pClsID );
}


DWORD CCalibFilter::GetSoftwareVersion()
{
    return 0x11;
}

int CCalibFilter::SizeMax()
{
    return 1024;
}


#define WRITEOUT(var)  hr = pStream->Write(&var, sizeof(var), NULL); \
               if (FAILED(hr)) return hr;

#define READIN(var)    hr = pStream->Read(&var, sizeof(var), NULL); \
               if (FAILED(hr)) return hr;

HRESULT CCalibFilter::ReadFromStream( IStream* pStream )
{
    HRESULT hr;
    READIN( m_initial_params );

    m_params = m_initial_params;

    m_params.calib_state = m_params.calib_state == CalibState_Calibrated ?
                           CalibState_Calibrated : CalibState_NotCalibrated;

    if( m_params.calib_state == CalibState_Calibrated )
    {
        READIN( m_camera );
    }
    return NOERROR;
}

HRESULT CCalibFilter::WriteToStream( IStream* pStream )
{
    HRESULT hr;
    m_initial_params.calib_state = m_params.calib_state;
    WRITEOUT( m_initial_params );

    if( m_params.calib_state == CalibState_Calibrated )
    {
        WRITEOUT( m_camera );
    }

    /*SetDirty(FALSE);*/

    return NOERROR;
}


STDAPI DllRegisterServer()
{
    return AMovieDllRegisterServer2( TRUE );
}

STDAPI DllUnregisterServer()
{
   return AMovieDllRegisterServer2( FALSE );
}

/* End of file. */