random_selection.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission : 
        Realtime Vision Processing System
    
    Copyright (C) 2003-2005 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics
    
    This file is part of Phission.

 ---------------------------------------------------------------------------*/
#include <time.h>
#include <phission.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <random_selection.h>

/* ------------------------------------------------------------------------ */
/* Create random indexes for the training and test sets.
 * Then create randomized index arrays for each member of the set.
 * The train set starts at [0] in rset_array and the test set starts
 * at [train_set_size] 
 * The rindex location also holds all the indecies into the train and
 * test sets,
 */
/* ------------------------------------------------------------------------ */
int random_selection_new( image_data_collection data,
                          uint32_t              train_set_size,
                          uint32_t              test_set_size,
                          random_selection_type **info )
{
    phFUNCTION("random_selection_new")
        
    uint32_t i = 0;
    uint32_t j = 0;

    uint32_t        *random_flag_array  = NULL;
    uint32_t        random_flag_size    = 0;
    uint32_t        chosen_set          = 0;
    uint32_t        nsets               = 0;
    uint32_t        maxsets             = 0;
    image_data_set  img                 = NULL;
    uint32_t        nfiles              = 0;
    uint32_t        looped              = 0;

    if (info == NULL) return phFAIL;

    *info = (random_selection_type *)phCalloc(1,sizeof(random_selection_type));
    phCHECK_PTR(*info,"phCalloc","phCalloc failed.");
    
    nsets = idc_get_nsets( data );

    /* find the maximum number of files that any image set has */
    maxsets = 0;
    for (i = 0; i < nsets; i++)
    {
        img = idc_get_set( data, i );
        nfiles = ids_get_nfiles( img );

        if (nfiles > maxsets) maxsets = nfiles;
    }
    
    (*info)->total_sets         = train_set_size + test_set_size;
    (*info)->train_array_count  = train_set_size;
    (*info)->test_array_count   = test_set_size;
        
    /* allocate the set array */
    (*info)->rset_array_count = (*info)->total_sets;
    phDALLOC((*info)->rset_array,
             (*info)->array_size[0],
             (*info)->rset_array_count,
             uint32_t);
    phDALLOC((*info)->rindex_array_size,
             (*info)->array_size[1],
             (*info)->rset_array_count,
             uint32_t);
    phDALLOC((*info)->rindex_array_count,
             (*info)->array_size[2],
             (*info)->rset_array_count,
             uint32_t);

    /* allocate the index arrays */
    phDALLOC((*info)->rindex_array,
             (*info)->array_size[3],
             (*info)->total_sets,
             uint32_t *);
    
    srand(time(NULL));

    phDALLOC(random_flag_array,
             random_flag_size,
             maxsets,
             uint32_t);

    /* RANDOMLY CHOOSE THE FILE */
    
    /* Randomize the set/file selection */
    for (i = 0; i < (*info)->total_sets; i++ )
    {            
        /* choose a set that hasn't been chosen this time around*/
        chosen_set = ((uint32_t)rand()) % maxsets;
        looped = 0;
        while (random_flag_array[chosen_set])
        {
            chosen_set = ( chosen_set + 1 ) % maxsets;
            
            if (looped >= maxsets) 
            {
                phPROGRESS("WARNING !!! No spaces in random flag array left: %d %d\n",
                        i,
                        (*info)->total_sets );
                exit(1);
            }
            looped++;
        }
        /* mark the set as already chosen */
        random_flag_array[chosen_set] = 1;

        (*info)->rset_array[i] = chosen_set;
    }

    phDALLOC(random_flag_array,
             random_flag_size,
             nsets,
             uint32_t);
                 
    /* RANDOMLY CHOOSE THE SET array for each file */
    
    /* randomize the set index selections */
    for (i = 0; i < (*info)->total_sets; i++ )
    {
        srand(time(NULL));

        phMemset(random_flag_array,0,nsets*sizeof(uint32_t));

        /* allocate the array for the current set indecies */
        phDALLOC((*info)->rindex_array[i],
                 (*info)->array_size[4],
                 nsets,
                 uint32_t);
        
        for (j = 0; j < nsets; j++ )
        {
            /* choose a set that hasn't been chosen this time around*/
            chosen_set = ((uint32_t)rand()) % nsets;
            looped = 0;
            while (random_flag_array[chosen_set])
            {
                chosen_set = ( chosen_set + 1 ) % nsets;
            
                if (looped >= nsets) 
                {
                    phPROGRESS("WARNING !!! No spaces in random flag array left\n");
                    exit(1);
                }
                looped++;
            }
            /* mark the set as already chosen */
            random_flag_array[chosen_set] = 1;

            (*info)->rindex_array[i][j] = chosen_set;
        }
    }

    phFree(random_flag_array);
    
    return phSUCCESS;
error:
    phFree(random_flag_array);
    
    return phFAIL;
} 

/* ------------------------------------------------------------------------ */
int random_selection_free( random_selection_type **info )
{
    phFUNCTION("random_selection_free")
        
    uint32_t i = 0;
    uint32_t j = 0;

    if (info == NULL) return phFAIL;
    if (*info == NULL) return phSUCCESS;

    phFree((*info)->rset_array);
    
    for (i = 0; i < (*info)->total_sets; i++ )
    {
        phFree((*info)->rindex_array[i]);
    }
        
    phFree((*info)->rindex_array);
    phFree((*info)->rindex_array_size);
    phFree((*info)->rindex_array_count);

    phFree(*info);

    return phSUCCESS;
} 

#ifdef __cplusplus
}
#endif

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---