image_collection.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission : 
        Realtime Vision Processing System
    
    Copyright (C) 2003 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 <phission.h>

#include <image_collection.h>
#include <phStdint.h> /* if stdint.h doesn't come till after phission.h,
                       then __STDC_LIMIT_MACROS won't be defined and thus 
                       UINT32_MAX won't be defined */
#include <errno.h>

#if USE_FILETYPE
#else
    #include <sys/file.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
#endif


#ifdef __cplusplus
extern "C" {
#endif

/* ------------------------------------------------------------------------ */
typedef struct image_data_set_t
{
    /* loaded during reading */
    char       *filedir;
    char       *fileprefix;
    char       *filetype;
    uint32_t    nfiles; /* indexed from 0 */
    int32_t     hue_adjust;
    int32_t     sat_adjust;
    int32_t     val_adjust;
    uint32_t    x1;
    uint32_t    y1;
    uint32_t    x2;
    uint32_t    y2;
    
    char      **tags;
    uint32_t    tags_size;
    uint32_t    ntags;

    /* set up after all the image data sets have been read */
    uint32_t   *tag_ids;
    
    uint32_t    width;
    uint32_t    height;
    float       ratio;
};

/* ------------------------------------------------------------------------ */
typedef struct image_data_collection_t
{
    uint32_t                    nsets;
    struct image_data_set_t    *images;
    uint32_t                    collection_size;
    
    int     width;
    int     height;
    char   *outdir;

    char      **tags;
    uint32_t    tags_size;
    uint32_t    ntags;
};

/* ------------------------------------------------------------------------ */
static int check_and_add_tags( char ***tags, uint32_t *ntags, uint32_t *arrsize,
                               char **newtags, uint32_t n_newtags )
{
    phFUNCTION("check_and_add_tags")
    uint32_t    x           = 0;
    uint32_t    y           = 0;
    uint32_t    i           = 0;
    int         tag_found   = 0;
    uint32_t    index       = 0;
    char        *tmp_tag    = NULL;

    //phPRINT("%p %p %p %p %d\n",tags,ntags,arrsize,newtags,n_newtags);
    
    for (x = 0; x < n_newtags; x++ )
    {
        tag_found = 0;

        /* search for the tag in the data collection list */
        for (y = 0; (y < *ntags) && (tag_found == 0); y++ )
        {
            if (strcasecmp((*tags)[y],newtags[x]) == 0)
            {
                tag_found = 1;
            }
        }
        if ((strcasecmp(newtags[x],"unknown") != 0) &&
            (tag_found == 0))
        {
            tmp_tag = (char *)phCalloc(strlen(newtags[x])+5,sizeof(char));
            phCHECK_PTR(tmp_tag,"phCalloc","phCalloc failed");

            sprintf(tmp_tag,"%s",newtags[x]);

            (*ntags)++;

            /* allocate a new location by resizing it with phDALLOC_RESIZE */
            phDALLOC_RESIZE((*tags),(*arrsize),(*ntags),char *);
            (*tags)[(*ntags)-1] = NULL;

            /* find the right place in the list (alphabetically) for the
             * new tag */
            for (index = 0; 
                 /* The last array location is new, so we don't need to go
                  * beyond that location */
                 (index < (*ntags-1)) && 
                 /* The last index will be null, this is a double check */
                 ((*tags)[index] != NULL) && 
                 /* while the string is alphabetically greater than the
                  * current string indexed */
                 (strcasecmp(tmp_tag,(*tags)[index]) > 0 );
                 /* next location */
                 index++ );
            
            if (index != ((*ntags)-1)) 
            {
                /*
                // Here's an interesting lesson. If you do this, it won't
                // work because it will copy the same byte from location to
                // location because the memory segments overlap.
                phMemcpy(&((*tags)[index+1]),
                         &((*tags)[index]),
                         sizeof(char *) * ((*ntags)-(index+1)));
                */
                // However, if you use memmove, it will work because it
                // checks if the memory segments are overlapped
                phMemmove(&((*tags)[index+1]),
                          &((*tags)[index]),
                          sizeof(char *) * ((*ntags)-(index+1)));
            }
            /* keep the new string in the array */
            (*tags)[index] = tmp_tag;
        }
    }
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
static int create_tag_index_array( char        **alltags, 
                                   uint32_t    n_alltags,
                                   char        **tags,
                                   uint32_t    ntags,
                                   uint32_t    **index_array )
{
    phFUNCTION("create_tag_index_array")
    uint32_t i      = 0; 
    uint32_t j      = 0; 
    uint32_t done   = 0;

    (*index_array) = (uint32_t *)phCalloc(ntags,sizeof(uint32_t));
    phCHECK_PTR((*index_array),"phCalloc", "phCalloc failed.");

    for ( i = 0; i < ntags; i++ )
    {
        done = 0;
        for ( j = 0; (j < n_alltags) && (done == 0); j++ )
        {
            if (strcasecmp(alltags[j],tags[i]) == 0)
            {
                (*index_array)[i] = j;
                done = 1;
            }
        }
    }

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int idc_new( struct image_data_collection_t **data )
{
    phFUNCTION("idc_new")

    /* Check the arguments */
    phCHECK_PTR(data,NULL,"data == NULL");
    if (*data != NULL) return phFAIL;

    /* allocate the database */
    *data = (struct image_data_collection_t *)
                phCalloc(1,sizeof(struct image_data_collection_t));
    phCHECK_PTR(*data,"phCalloc","*data == NULL");

    (*data)->nsets      = 0;
    (*data)->images     = NULL;
    (*data)->width      = 0;
    (*data)->height     = 0;
    (*data)->outdir     = NULL;

    (*data)->tags       = NULL;
    (*data)->tags_size  = 0;
    (*data)->ntags      = 0;

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
static struct image_data_set_t *idc_new_data_set( 
                                    struct image_data_collection_t   *data,
                                    const char                       *str )
{
    phFUNCTION("idc_new_data_set")

    int     nfields         = 0;

    char    *filedir        = NULL;
    char    *fileprefix     = NULL;
    char    *filetype       = NULL;
    uint32_t nfiles         = 0;
    uint32_t x1, y1, x2, y2 = 0;
    int32_t hue, sat, val   = 0;
    char    *h              = NULL;
    char    *s              = NULL;
    char    *v              = NULL;
    char    *x1_b           = NULL;
    char    *y1_b           = NULL;
    char    *x2_b           = NULL;
    char    *y2_b           = NULL;
    
    char    *tag_str        = NULL;

    uint32_t    done    = 0;
    uint32_t    i       = 0;
    uint32_t    count   = 0;
    char       *tmp_tag    = NULL;

    struct image_data_set_t *new_image_data_set = NULL;

    filedir  = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(filedir,"phCalloc","phCalloc failed.");

    fileprefix  = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(fileprefix,"phCalloc","phCalloc failed.");

    filetype  = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(filetype,"phCalloc","phCalloc failed.");

    h = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(h,"phCalloc","phCalloc failed.");

    s = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(s,"phCalloc","phCalloc failed.");

    v = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(v,"phCalloc","phCalloc failed.");

    x1_b = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(x1_b,"phCalloc","phCalloc failed.");

    y1_b = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(y1_b,"phCalloc","phCalloc failed.");

    x2_b = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(x2_b,"phCalloc","phCalloc failed.");

    y2_b = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(y2_b,"phCalloc","phCalloc failed.");

    tag_str = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(tag_str,"phCalloc","phCalloc failed.");

    nfields = sscanf(   str,
                        "%s %s %s %u %s %s %s %s %s %s %s %s",
                        filetype,
                        filedir,
                        fileprefix,
                        &nfiles,
                        h,s,v,
                        x1_b, 
                        y1_b,
                        x2_b,
                        y2_b,
                        tag_str);
    if (nfields == 12)
    {
        data->nsets++;
        phDALLOC_RESIZE(data->images,
                        data->collection_size,
                        data->nsets,
                        struct image_data_set_t );

        new_image_data_set = &(data->images[data->nsets - 1]);
        new_image_data_set->filetype    = NULL;
        new_image_data_set->filedir     = NULL;
        new_image_data_set->fileprefix  = NULL;
        new_image_data_set->nfiles      = 0;
        new_image_data_set->hue_adjust  = 0;
        new_image_data_set->sat_adjust  = 0;
        new_image_data_set->val_adjust  = 0;
        new_image_data_set->x1          = 0;
        new_image_data_set->y1          = 0;
        new_image_data_set->x2          = 0;
        new_image_data_set->y2          = 0;
        new_image_data_set->ntags       = 0;
        new_image_data_set->tags        = NULL;
        new_image_data_set->tags_size   = 0;

        /* file type */
        new_image_data_set->filetype = 
            (char *)phCalloc(strlen(filetype)+5, sizeof(char));
        phCHECK_PTR(new_image_data_set->filetype,"phCalloc","phCalloc failed.");

        sprintf( new_image_data_set->filetype, "%s", filetype);

        /* file dir */
        new_image_data_set->filedir = 
            (char *)phCalloc(strlen(filedir)+5,sizeof(char));
        phCHECK_PTR(new_image_data_set->filedir,"phCalloc","phCalloc failed.");

        sprintf( new_image_data_set->filedir, "%s", filedir);

        /* file prefix */
        new_image_data_set->fileprefix = 
            (char *)phCalloc(strlen(fileprefix)+5,sizeof(char));
        phCHECK_PTR(new_image_data_set->fileprefix,"phCalloc","phCalloc failed.");

        sprintf( new_image_data_set->fileprefix, "%s", fileprefix);

        hue = (int32_t)atoi(h);
        sat = (int32_t)atoi(s);
        val = (int32_t)atoi(v);
        
        /* Set up the x and y coordinates of the object in the original
         * images */
        if (strcasecmp(x1_b,"min") == 0)
        {
            x1 = 0;
        }
        else
        {
            x1 = (uint32_t)atoi(x1_b);
        }
        if (strcasecmp(y1_b,"min") == 0)
        {
            y1 = 0;
        }
        else
        {
            y1 = (uint32_t)atoi(y1_b);
        }
         
        if (strcasecmp(x2_b,"max") == 0)
        {
            x2 = UINT32_MAX;
        }
        else
        {
            x2 = (uint32_t)atoi(x2_b);
        }
        
        if (strcasecmp(y2_b,"max") == 0)
        {
            y2 = UINT32_MAX;
        }
        else
        {
            y2 = (uint32_t)atoi(y2_b);
        }

        new_image_data_set->nfiles  = nfiles;
        new_image_data_set->hue_adjust = hue;
        new_image_data_set->sat_adjust = sat;
        new_image_data_set->val_adjust = val;
        new_image_data_set->x1      = x1;
        new_image_data_set->y1      = y1;
        new_image_data_set->x2      = x2;
        new_image_data_set->y2      = y2;
        new_image_data_set->width   = x2 - x1;
        new_image_data_set->height  = y2 - y1;
        new_image_data_set->ratio   = 
                (float)new_image_data_set->width / (float)new_image_data_set->height;

        /* Process the tag string */
        i = 0;
        count = 0;
        while (!done)
        {
            if (((tag_str[i] == ',') || (tag_str[i] == '\0')) && (count > 0))
            {
                /* allocate a new string for the tag */
                tmp_tag = (char *)phCalloc(count+1,sizeof(char));
                phCHECK_PTR(tmp_tag,"phCalloc","phCalloc failed.");
                
                /* copy the string from the tag str */
                /*
                phPRINT("%d %d %s:%c:\n",
                        i,
                        count,
                        &(tag_str[i-count]),
                        tag_str[i]);
                 */
                snprintf(tmp_tag,count+1,"%s",&(tag_str[i-count]));

                /* increment the total tags for this set */
                new_image_data_set->ntags++;
                
                /* Resize the pointer of arrays */
                phDALLOC_RESIZE(new_image_data_set->tags,
                                new_image_data_set->tags_size,
                                new_image_data_set->ntags,
                                char *);

                /* Add the new string to the array */
                new_image_data_set->tags[new_image_data_set->ntags-1] = tmp_tag;
                
                if (tag_str[i] == '\0') done = 1;

                count = 0;
                i++;
            }
            else
            {
                count++;
                i++;
            }
        }
    }
    else
    {
        phPROGRESS("nfields:%d < 12\n",nfields);
    }

    phFree(fileprefix);
    phFree(filedir);
    phFree(filetype);
    phFree(h);
    phFree(s);
    phFree(v);
    phFree(x1_b);
    phFree(y1_b);
    phFree(x2_b);
    phFree(y2_b);
    phFree(tag_str);

    return new_image_data_set;

error:
    phFree(fileprefix);
    phFree(filedir);
    phFree(filetype);
    phFree(h);
    phFree(s);
    phFree(v);
    phFree(x1_b);
    phFree(y1_b);
    phFree(x2_b);
    phFree(y2_b);
    phFree(tag_str);

    return NULL;
}

/* ------------------------------------------------------------------------ */
int free_data_set_allocs( struct image_data_set_t *data_set )
{
    uint32_t i = 0;

    phFree( data_set->filedir );
    phFree( data_set->fileprefix );
    phFree( data_set->filetype );

    for (i = 0; i < data_set->ntags; i++ )
    {
        phFree(data_set->tags[i]);
    }
    phFree(data_set->tags);
    phFree(data_set->tag_ids);
   
    return phSUCCESS;
}


/* ------------------------------------------------------------------------ */
int idc_readfile( const char *filename, 
                  struct image_data_collection_t *data )
{
    phFUNCTION("idc_readfile")

    intmax_t    frc             = 0;
    FILE        *fp             = NULL;
    char        *buffer         = NULL;
    int         file_finished   = 0;
    uint32_t    i               = 0;
    int         nfields         = 0;
    char        *outdir         = NULL;
    
    char        *type           = NULL;
    int         width, height   = 0;

    struct image_data_set_t *setptr = NULL;

    /* Check the arguments */
    phCHECK_PTR(filename,NULL,"filename == NULL");
    phCHECK_PTR(data,NULL,"data == NULL");

    /* open the file */
    fp = fopen(filename,"r");
    phCHECK_PTR(fp,"fopen","fopen(%s,\"r\")",filename);

    buffer      = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(buffer,"phCalloc","phCalloc failed.");

    type        = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(type,"phCalloc","phCalloc failed.");
    
    outdir  = (char *)phCalloc(255,sizeof(char));
    phCHECK_PTR(outdir,"phCalloc","phCalloc failed.");

    /* lock the file */
    rc = flock(fileno(fp),LOCK_SH);
    phPRINT_RC(rc,"flock","flock(%d,LOCK_SH)",fileno(fp));

    while (!file_finished)
    {
        buffer[0] = '\0';
        frc = (intmax_t)fgets(buffer,254,fp);
        //phPROGRESS("(%d)buf-%s\n",errno,buffer);
        if (frc != EOF)
        {
            while ((buffer[i] != '\0') && (buffer[i] != '#')) i++;
            if (buffer[i] == '#') buffer[i] = '\0';

            /* Make sure we actually read the type from the buffer */
            nfields = sscanf(buffer,"%s ",type);
            //phPROGRESS("%s\n",type);

            if (nfields > 0)
            {
                /* an image set with the location of the object in the
                 * image covered by the box (x1,y1)-(x2,y2) */
                if (strcasecmp(type,":end") == 0)
                {
                    file_finished = 1;
                }
                else if (strcasecmp(type,"set:") == 0)
                {
                    setptr = idc_new_data_set( data, &(buffer[5]) );
                    phPRINT_PTR( setptr, NULL, "idc_new_data_set" );

                    if (setptr != NULL)
                    {
                        rc = check_and_add_tags(&data->tags,
                                                &data->ntags,
                                                &data->tags_size,
                                                setptr->tags,
                                                setptr->ntags );
                        phPRINT_RC(rc,NULL,"check_and_add_tags");
                    }
                }
                else if (strcasecmp(type,"outdir:") == 0)
                {
                    nfields = sscanf( &(buffer[7]),"%s", outdir);
                    if (nfields == 1)
                    {
                        data->outdir = (char *)phCalloc(strlen(outdir)+5,
                                                                     sizeof(char));
                        phCHECK_PTR(data->outdir,"phCalloc","phCalloc failed.");

                        sprintf(data->outdir,"%s",outdir);
                    }
                }
                else if (strcasecmp(type,"size:") == 0)
                {
                    nfields = sscanf( &(buffer[6]),"%d %d",
                                      &width,
                                      &height);
                    if (nfields == 2)
                    {
                        data->width = width;
                        data->height = height;
                    }
                }
            }
        }
        else
        {
            file_finished = 1;
        }
    }
    
    /* unlock the file */
    rc = flock(fileno(fp),LOCK_UN);
    phPRINT_RC(rc,"flock","flock(%d,LOCK_UN)",fileno(fp));

    fclose(fp);
    fp = NULL;

    /* map the tags to the index locations of the total tags */
    for (i = 0; i < data->nsets; i++ )
    {
        rc = create_tag_index_array( data->tags, data->ntags, 
                                     data->images[i].tags,
                                     data->images[i].ntags,
                                     &(data->images[i].tag_ids));
        phPRINT_RC(rc,NULL,"create_tag_index_array");
    }
    
    
    phFree(buffer);
    phFree(type);
    phFree(outdir);

    return phSUCCESS;
error:
    if (fp != NULL)
    {
        fclose(fp);
    }

    phFree(buffer);
    phFree(type);
    phFree(outdir);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int idc_print( struct image_data_collection_t *collection )
{
    phFUNCTION("idc_print");
    
    uint32_t                i       = 0;
    uint32_t                j       = 0;
    struct image_data_set_t *img    = NULL;

    phPRINT("set count:\t%d\n",
            collection->nsets );
    phPRINT("output size - w:%d h:%d\n",
            collection->width,
            collection->height );
    phPRINT("outdir:\t\t%s\nnsets:\t\t%d\n", 
            collection->outdir,
            collection->nsets );
    phPRINT( "tags: ");
    for ( j = 0; j < collection->ntags; j++ )
    {
        phPRINT( "%s%s", collection->tags[j], (j == collection->ntags-1) ? "" : ", ");
    }
    phPRINT("\n");
    
    for ( i = 0; i < collection->nsets; i++ )
    {
        img = &collection->images[i];
        phPRINT("fileset - \n\tdir:\t%s\n\tname:\t%s\n\ttype:\t%s\n\tnfiles:\t%d\nadjustment( h:%d, s:%d, v:%d )\n\tlocation:( %d, %d, %d, %d )\n",
                img->filedir,
                img->fileprefix,
                img->filetype,
                img->nfiles,
                img->hue_adjust,
                img->sat_adjust,
                img->val_adjust,
                img->x1,
                img->y1,
                img->x2,
                img->y2 );

        phPRINT( "\ttags: ");
        for ( j = 0; j < img->ntags; j++ )
        {
            phPRINT( "%s%s", img->tags[j], (j == img->ntags-1) ? "" : ", ");
        }
        phPRINT("\n");
    }
    
    phPRINT("\n");
    
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int idc_crop_resize( struct image_data_collection_t *collection )
{
    phFUNCTION("idc_crop_resize");

    phImage                 image;
    struct image_data_set_t *img    = NULL;
    
    uint32_t    j   = 0;
    uint32_t    i   = 0;
    
    char        to_filename[255];
    char        from_filename[255];

    uint32_t    to_width    = 0;
    uint32_t    to_height   = 0;

    /*
    phPRINT("image count: %d\n", collection->nsets );
    phPRINT("output size - w:%d h:%d\n", collection->width, collection->height );
     */
    for ( i = 0; i < collection->nsets; i++ )
    {
        img = &collection->images[i];

        phPRINT("Processing: %s",img->fileprefix);
        
        for (j = 0; j < img->nfiles; j++ )
        {
            phPRINT(".");
            /*
            img->filetype
            img->filedir
            img->fileprefix;
            img->nfiles;
            img->x1;
            img->y1;
            img->x2;
            img->y2;
            */
            sprintf(from_filename,
                    "%s/%s_%04u.%s",
                    img->filedir,
                    img->fileprefix,
                    j,
                    img->filetype);
            
            sprintf(to_filename,
                    "%s/%s_%04u.%s",
                    collection->outdir,
                    img->fileprefix,
                    j,
                    img->filetype);
            
            to_width  = collection->width;
            to_height = collection->height;
            
            rc = image.load(from_filename);
            
            if (rc == phSUCCESS)
            {
                if (img->x2 == INT_MAX)
                {
                    img->x2 = image.getWidth();
                }
                if (img->y2 == INT_MAX)
                {
                    img->y2 = image.getHeight();
                }

                rc = image.crop(img->x1,img->y1,img->x2,img->y2);
                phCHECK_RC(rc,NULL,"image.crop()");

                rc = image.resize(to_width,to_height);
                phCHECK_RC(rc,NULL,"image.resize()");

                rc = image.save(to_filename);
                phCHECK_RC(rc,NULL,"image.save(to_filename)");
            }
            else
            {
                phPROGRESS("%s failed to load\n",from_filename);
            }
        }
        phPRINT("\n");
    }
    
    phPRINT("\n");

    return phSUCCESS;
error:

    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int idc_free( struct image_data_collection_t **collection )
{
    phFUNCTION("idc_free")
    uint32_t i = 0;
        
    phCHECK_PTR(collection,NULL,"collection == NULL");
    phCHECK_PTR(*collection,NULL,"collection == NULL");

    if (((*collection)->images) != NULL)
    {
        for (i = 0; i < (*collection)->nsets; i++ )
        {
            rc = free_data_set_allocs( &((*collection)->images[i]) );
            phPRINT_RC(rc,NULL,"free_data_set_allocs");
        }
    }    

    for (i = 0; i < (*collection)->ntags; i++ )
    {
        phFree((*collection)->tags[i]);
    }
    
    phFree((*collection)->tags);
    phFree((*collection)->outdir );
    phFree((*collection)->images );
    phFree((*collection));

    return phSUCCESS;
    
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
const char *idc_get_dir( struct image_data_collection_t *data )
{
    return data == NULL ? NULL : data->outdir;
}

/* ------------------------------------------------------------------------ */
uint32_t idc_get_width( struct image_data_collection_t *data )
{
    return data == NULL ? 0 : data->width;
}

/* ------------------------------------------------------------------------ */
uint32_t idc_get_height( struct image_data_collection_t *data )
{
    return data == NULL ? 0 : data->height;
}

/* ------------------------------------------------------------------------ */
uint32_t idc_get_nsets( struct image_data_collection_t *data )
{
    return data == NULL ? 0 : data->nsets;
}

/* ------------------------------------------------------------------------ */
struct image_data_set_t *idc_get_set( struct image_data_collection_t *data,
                                      uint32_t index )
{
    if ((data == NULL) ||
        (data->nsets <= index) ||
        (index < 0)) return NULL;

    return &(data->images[index]);
}

/* ------------------------------------------------------------------------ */
uint32_t idc_get_ntags( struct image_data_collection_t *data )
{
    return data == NULL ? 0 : data->ntags;
}

/* ------------------------------------------------------------------------ */
char **idc_get_tags( struct image_data_collection_t *data )
{
    return data == NULL ? 0 : data->tags;
}

/* ------------------------------------------------------------------------ */
const char *ids_get_filedir     ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->filedir : NULL;
}
/* ------------------------------------------------------------------------ */
const char *ids_get_fileprefix  ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->fileprefix : NULL;
}
/* ------------------------------------------------------------------------ */
const char *ids_get_filetype    ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->filetype : NULL;
}
/* ------------------------------------------------------------------------ */
int   ids_get_filename( struct image_data_set_t *data_set,
                        uint32_t                fileid,
                        char                  **pfilename )
{
    phFUNCTION("ids_get_filename")
    char *filename = NULL;
    
    if (data_set == NULL) return phFAIL;
    if (pfilename == NULL) return phFAIL;
    
    if (*pfilename == NULL)
    {
        filename = *pfilename = (char *)phCalloc(255,sizeof(char));
        phCHECK_PTR(filename,"phCalloc","phCalloc failed.");
    }
    else
    {
        filename = *pfilename;
    }
    if (fileid > data_set->nfiles) fileid = data_set->nfiles - 1;
    
    sprintf(filename,
            "%s/%s_%04u.%s",
            data_set->filedir,
            data_set->fileprefix,
            fileid,
            data_set->filetype);

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
uint32_t    ids_get_nfiles      ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->nfiles : NULL;
}
/* ------------------------------------------------------------------------ */
uint32_t    ids_get_width       ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->width : NULL;
}
/* ------------------------------------------------------------------------ */
uint32_t    ids_get_height      ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->height : NULL;
}
/* ------------------------------------------------------------------------ */
float       ids_get_ratio       ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->ratio : NULL;
}
/* ------------------------------------------------------------------------ */
uint32_t    ids_get_ntags       ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->ntags : NULL;
}
/* ------------------------------------------------------------------------ */
char      **ids_get_tags        ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->tags : NULL;
}

/* ------------------------------------------------------------------------ */
uint32_t   *ids_get_tag_ids     ( struct image_data_set_t *data_set )
{
    return (data_set != NULL) ? data_set->tag_ids : NULL;
}

/* ------------------------------------------------------------------------ */
int         ids_get_crop_coords ( struct image_data_set_t *data_set,
                                  uint32_t *x1,
                                  uint32_t *y1, 
                                  uint32_t *x2,
                                  uint32_t *y2 )
{
    if (data_set == NULL) return phFAIL;
    if (x1 != NULL) *x1 = data_set->x1;
    if (y1 != NULL) *y1 = data_set->y1;
    if (x2 != NULL) *x2 = data_set->x2;
    if (y2 != NULL) *y2 = data_set->y2;
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int         ids_get_hsv_adjust ( struct image_data_set_t *data_set,
                                 int32_t *h,
                                 int32_t *s, 
                                 int32_t *v )
{
    if (data_set == NULL) return phFAIL;
    if (h != NULL) *h = data_set->hue_adjust;
    if (s != NULL) *s = data_set->sat_adjust;
    if (v != NULL) *v = data_set->val_adjust;
    return phSUCCESS;
}

#ifdef __cplusplus
}
#endif

Copyright (C) 2002 - 2007

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

---