asequence.cpp

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

            idx = sseq[seq_idx]->count - num;
            if( num != 0 )
            {
                CHECK_CONDITION( !memcmp( elem, simple_seq_elem(sseq[seq_idx],idx), elem_size),
                             "The last popped sequence element is wrong after MULTI PUSH" );
            }

            sseq[seq_idx]->count = idx;

            if( sseq[seq_idx]->count != 0 )
            {
                elem2 = cvGetSeqElem( seq[seq_idx], -1, 0 );
                if( !elem2 )
                {
                    message_string = "GetSequenceElementPtr fails after POP";
                    code = TRS_FAIL;
                    goto test_exit;
                }

                CHECK_CONDITION( !memcmp( elem2, simple_seq_elem(sseq[seq_idx],idx-1), elem_size),
                                 "The last sequence element is wrong after POP" );
            }
            else
            {
                CHECK_CONDITION( seq[seq_idx]->first == 0,
                                 "The sequence doesn't become empty after final POP" );
            }
            break;

        case 6: /* push front */
            if( sseq[seq_idx]->count == sseq[seq_idx]->max_count  ) break;

            atsbRand8s( rng_state, elem, elem_size );
            
            idx = 0;
            insert_simple_seq_elem( sseq[seq_idx], idx, elem );
            
            DO_CV_ACTION( cvSeqPushFront, ( seq[seq_idx], elem ));
            
            elem2 = cvGetSeqElem( seq[seq_idx], idx, 0 );
            if( !elem2 )
            {
                message_string = "Push operation doesn't add the element";
                code = TRS_FAIL;
                goto test_exit;
            }

            CHECK_CONDITION( seq[seq_idx]->total == sseq[seq_idx]->count &&
                             !memcmp( elem2, simple_seq_elem(sseq[seq_idx],idx), elem_size),
                             "The first sequence element is wrong after PUSH FRONT" );
            break;

        case 7: /* pop front */
            if( sseq[seq_idx]->count == 0 ) break;
            
            idx = 0;
            DO_CV_ACTION( cvSeqPopFront, ( seq[seq_idx], elem ));

            CHECK_CONDITION( seq[seq_idx]->total == sseq[seq_idx]->count - 1 &&
                       !memcmp( elem, simple_seq_elem(sseq[seq_idx],idx), elem_size),
                       "The popped sequence element isn't equal to last elem of simple seq" );

            remove_simple_seq_elem( sseq[seq_idx], 0 );
            if( sseq[seq_idx]->count != 0 )
            {
                elem2 = cvGetSeqElem( seq[seq_idx], 0, 0 );
                if( !elem2 )
                {
                    message_string = "GetSequenceElementPtr fails after POP";
                    code = TRS_FAIL;
                    goto test_exit;
                }

                CHECK_CONDITION( !memcmp( elem2, simple_seq_elem(sseq[seq_idx],0), elem_size),
                                 "The first sequence element is wrong after POP FRONT" );
            }
            else
            {
                CHECK_CONDITION( seq[seq_idx]->first == 0,
                                 "The sequence doesn't become empty after final POP FRONT" );
            }
            break;

        default:
            assert(0);
            message_string = "Unknown error";
            code = TRS_FAIL;
            goto test_exit;
        }

        code = check_seq_block_consistence( seq[seq_idx], sseq[seq_idx]->count,
                                            &message_string );
        if( code != TRS_OK ) goto test_exit;

        code = check_get_seq_elem( seq[seq_idx], sseq[seq_idx],
                                   rng_state, 7, &message_string, &result );
        if( code != TRS_OK || result < 0 ) goto test_exit;
    }

test_exit:

    icvFree( &elem );
    if( *msg != message_string )
    {
        putchar('.');
    }

    *msg = message_string;
    *_result = result;
    return code;
}


static int calc_storage_blocks( CvMemStorage* storage )
{
    CvMemBlock* mblock = storage->bottom;
    int count = 0;

    for( ; mblock != 0; count++, mblock = mblock->next );

    return count;
}

/* sequence test */
static int  test_sequence( void )
{
    const char*  message_string = ok_message;
    int i = 0, j, k = 0, code = TRS_OK;
    CvStatus   result = CV_NO_ERR;
    simple_seq** sseq = 0;
    CvSeq** seq = 0;
    CvMemStorage* storage = 0;

    int seed = atsGetSeed();
    AtsRandState rng_state;

    read_data_struct_params();
    if( !ATS_RANGE( SEQUENCE_TEST, adt_l, adt_h+1 )) return TRS_UNDEF;

    atsRandInit( &rng_state, 0, 1, seed );

    sseq = (simple_seq**)icvAlloc( struct_count * sizeof(simple_seq*));
    seq = (CvSeq**)icvAlloc( struct_count * sizeof(CvSeq*));

    for( j = 0; j < struct_count; j++ )
    {
        sseq[j] = create_simple_seq( max_struct_size, elem_size );
        seq[j] = 0;
    }

    storage = cvCreateMemStorage( storage_block_size );

    for( i = 0; i < iters; i++ )
    {
        atsRandSetBounds( &rng_state, 0, max_struct_size - 10 );
        
        for( j = 0; j < struct_count; j++ )
        {
            sseq[j]->count = atsRand32s( &rng_state );
            atsbRand8s( &rng_state, sseq[j]->array, sseq[j]->count * sseq[j]->elem_size );
        }

        code = test_multi_create( struct_count, seq, sizeof(CvSeq) + 12,
                                  sseq, storage, &rng_state,
                                  &message_string, &result );
        if( code != TRS_OK || result < 0 ) goto test_exit;

        for( j = 0; j < struct_count; j++ )
        {
            code = check_seq_block_consistence( seq[j], sseq[j]->count, &message_string );
            if( code != TRS_OK ) goto test_exit;

            code = check_get_seq_elem( seq[j], sseq[j], &rng_state,
                                       MAX( sseq[j]->count/2, 10),
                                       &message_string, &result );
            if( code != TRS_OK || result < 0 ) goto test_exit;

            code = check_get_seq_reading( seq[j], sseq[j], &rng_state,
                                          MAX( sseq[j]->count/2, 10),
                                          &message_string, &result );

            if( code != TRS_OK || result < 0 ) goto test_exit;
        }

        code = test_seq_ops( struct_count, seq, sseq, &rng_state,
                             max_struct_size, &message_string, &result );
        if( code != TRS_OK || result < 0 ) goto test_exit;

        trsWrite( ATS_LST|ATS_CON,
            "iter = %d, storage blocks = %d\n", i, calc_storage_blocks(storage) );
    }

test_exit:

    if( code == TRS_OK && result >= 0 )
    {
        DO_CV_ACTION( cvReleaseMemStorage, ( &storage ));
    }
    else
    {
        cvReleaseMemStorage( &storage );
        trsWrite( ATS_LST, "seed = %08x, iter = %d, index = %d", seed, i, k );
        if( result < 0 ) trsWrite( ATS_LST, "error code: %d", result );
    }

    for( j = 0; j < struct_count; j++ )
    {
        release_simple_seq( sseq + j );
    }

    icvFree( &sseq );
    icvFree( &seq );

    return trsResult( code, message_string );
}



static int  test_set_ops( int count, CvSet** set, simple_set** sset,
                          AtsRandState* rng_state, int iters,
                          CvMemStorage* storage,
                          const char** msg, CvStatus * _result )
{
    const int max_op = 50*2 + 1;
    const char* message_string = *msg;
    CvStatus  result = *_result;
    int i, code = TRS_OK;
    char *elem4;
    CvSetElem *elem, *elem2, *elem3;
    int idx, idx2;
    int set_idx, op;
    int elem_size = sset[0]->elem_size - 1;
    int work_elem_size = ((elem_size + 3) & -4) + 4;

    elem = (CvSetElem*)icvAlloc( work_elem_size );

    for( i = 0; i < iters; i++ )
    {
        atsRandSetBounds( rng_state, 0, count * max_op );

        set_idx = atsRand32s( rng_state );
        op = set_idx % max_op;
        set_idx /= max_op;

        if( op == 0 ) /* clear */
        {
            if( set[set_idx] != 0 )
            {
                int prev_total = set[set_idx]->total;
                
                clear_simple_set( sset[set_idx] );
                DO_CV_ACTION( cvClearSet, ( set[set_idx] ));

                CHECK_CONDITION( set[set_idx]->total == 0 &&
                                 set[set_idx]->first == 0 &&
                                 set[set_idx]->free_elems == 0 &&
                                 (set[set_idx]->free_blocks != 0 || prev_total == 0),
                                 "The set is not empty after clearing" );
            }
            else
            {
                CHECK_CONDITION( sset[set_idx]->free_count == sset[set_idx]->max_count,
                                 "The set is empty while the simple_set is not" );
            }
        }
        else if( op % 2 == 0 ) /* add */
        {
            if( sset[set_idx]->free_count == 0  ) break;

            atsbRand8s( rng_state, (char*)(elem + 1), elem_size );
            idx = add_simple_set_elem( sset[set_idx], elem + 1 );
        
            if( set[set_idx] == 0 )
            {
                set[set_idx] = cvCreateSet( 0, sizeof(CvSet),
                                              work_elem_size, storage );
                if( !set[set_idx] )
                {
                    message_string = "cvCreateSet fails";
                    code = TRS_FAIL;
                    goto test_exit;
                }
            }
        
            idx2 = cvSetAdd( set[set_idx], elem, &elem2 );
            if( idx2 < 0 )
            {
                message_string = "cvSetAdd fails";
                code = TRS_FAIL;
                goto test_exit;
            }

            elem3 = cvGetSetElem( set[set_idx], idx2 );
            if( !elem3 )
            {
                message_string = "cvSetAdd doesn't add the element";
                code = TRS_FAIL;
                goto test_exit;
            }

            elem4 = find_simple_set_elem( sset[set_idx], idx );

            CHECK_CONDITION( CV_IS_SET_ELEM_EXISTS( elem2 ) &&
                             elem2 == elem3 && idx == idx2 &&
                             !memcmp( elem2 + 1, elem4, elem_size),
                             "The element is added to set incorrectly" );
        }
        else /* remove */
        {
            idx = atsRandPlain32s( rng_state ) % MAX( sset[set_idx]->count, 1);
            elem4 = find_simple_set_elem( sset[set_idx], idx );

            if( elem4 != 0 )
            {
                assert( set[set_idx] != 0 );

                elem2 = cvGetSetElem( set[set_idx], idx );
                if( !elem2 )
                {
                    message_string = "Existing element is not found";
                    code = TRS_FAIL;
                    goto test_exit;
                }

                CHECK_CONDITION( CV_IS_SET_ELEM_EXISTS(elem2) &&
                                 !memcmp( elem2 + 1, elem4, elem_size ),
                                 "Found element is incorrect");

                remove_simple_set_elem( sset[set_idx], idx );

                DO_CV_ACTION( cvSetRemove, ( set[set_idx], idx ));
                if( cvGetSetElem( set[set_idx], idx ) != 0 )
                {
                    message_string = "Element is not removed from the set";
                    code = TRS_FAIL;
                    goto test_exit;
                }

                CHECK_CONDITION( !CV_IS_SET_ELEM_EXISTS( elem2 ),
                                 "Remove operation doesn't clear existence flag");
            }
        }


        if( set[set_idx] )
        {
            code = check_seq_block_consistence( (CvSeq*)set[set_idx],
                                                sset[set_idx]->count,
                                                &message_string );
            if( code != TRS_OK ) goto test_exit;
        }
        else
        {
            CHECK_CONDITION( sset[set_idx]->free_count == sset[set_idx]->max_count,
                         "CvSet has different number of elements with simple_set");
        }
    }

test_exit:

    icvFree( &elem );

    *msg = message_string;
    *_result = result;
    return code;
}


static int  test_set( void )
{
    const char*  message_string = ok_message;
    int i = 0, j, k = 0, code = TRS_OK;
    CvStatus   result = CV_NO_ERR;
    simple_set** sset = 0;
    CvSet** set = 0;
    CvMemStorage* storage = 0;

    int seed = atsGetSeed();
    AtsRandState rng_state;

    read_data_struct_params();
    if( !ATS_RANGE( SET_TEST, adt_l, adt_h+1 )) return TRS_UNDEF;

    atsRandInit( &rng_state, 0, 1, seed );

    sset = (simple_set**)icvAlloc( struct_count * sizeof(simple_set*));
    set = (CvSet**)icvAlloc( struct_count * sizeof(CvSet*));

    for( j = 0; j < struct_count; j++ )
    {
        sset[j] = create_simple_set( max_struct_size, elem_size );
        set[j] = 0;
    }

    storage = cvCreateMemStorage( storage_block_size );

    for( i = 0; i < iters; i++ )
    {
        atsRandSetBounds( &rng_state, 0, max_struct_size - 10 );
        
        code = test_set_ops( struct_count, set, sset, &rng_state,
                             max_struct_size*2, storage, &message_string, &result );
        if( code != TRS_OK || result < 0 ) goto test_exit;

        trsWrite( ATS_LST|ATS_CON,
            "iter = %d, storage blocks = %d\n", i, calc_storage_blocks(storage) );
    }

test_exit:

    if( result < 0 ) code = TRS_FAIL;

    if( code == TRS_OK && result >= 0 )
    {
        DO_CV_ACTION( cvReleaseMemStorage, ( &storage ));
    }
    else
    {
        cvReleaseMemStorage( &storage );
        trsWrite( ATS_LST, "seed = %08x, iter = %d, index = %d", seed, i, k );
        if( result < 0 ) trsWrite( ATS_LST, "error code: %d", result );
    }

    for( j = 0; j < struct_count; j++ )
    {
        release_simple_set( sset + j );
    }

    icvFree( &sset );
    icvFree( &set );

    return trsResult( code, message_string );
}


static int  test_graph_ops( int count, CvGraph** gr, simple_graph** sgr,
                            AtsRandState* rng_state, int iters,
                            CvMemStorage* storage,
                            const char** msg, CvStatus * _result )
{
    const int max_op_ex = 4;
    const int max_op = 100*max_op_ex + 1;
    const char* message_string = *msg;
    CvStatus  result = *_result;
    int i, j, code = TRS_OK;
    char *elem4, *elem5;
    CvGraphVtx *v_elem, *v_elem2, *v_elem3;
    CvGraphEdge *e_elem, *e_elem2, *e_elem3;
    CvGraphEdge **e_list;
    int idx, idx2;
    int e_count, e_count2;