phANNSystem.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 <phANNSystem.h>
#include <autoblob_Filter.h>
#include <random_selection.h>

#define PRE_RESIZE_CANNY_INPUT() 1
#define PRE_RESIZE_SOBEL_INPUT() 1
#define PRE_RESIZE_HIST_INPUT() 0

/* ------------------------------------------------------------------------ */
#ifdef __cplusplus
extern "C" {
#endif

/* ------------------------------------------------------------------------ *
 * This randomizes the pixels of the image. 
 *
 * Make sure srand48(time(NULL)) or something equivalent is called at some 
 * point before invoking this function. This ensures that the image is 
 * random.
 *
 * Try not to call srand48 EVERY single time randomize_image is invoked if 
 * the function is invoked in a loop. Try to call srand48 once before the 
 * loop is started. 
 * ------------------------------------------------------------------------ */
int randomize_pixels( uint32_t width,
                     uint32_t height,
                     uint32_t format,
                     phImage  *image )
{
    phFUNCTION("randomize_image")
    uint8_t *imgptr     = NULL;
    uint32_t i          = 0;
    uint32_t limit      = 0;

    rc  = image->allocate(width,height,format);
    phCHECK_RC(rc,NULL,"image->allocate");

    imgptr = (uint8_t *)image->getImage();

    limit = image->getSize();
    
    for (i = 0; i < limit; i++ )
    {
        *imgptr = lrand48() % 256;
        imgptr++;
    }   
        
    return phSUCCESS;
error:
    return phFAIL;
}
 
/* ------------------------------------------------------------------------ */
int random_gradient( uint32_t width,
                  uint32_t height,
                  uint32_t format,
                  phImage  *image )
{
    phFUNCTION("random_gradient")
    uint8_t *imgptr     = NULL;
    uint32_t i          = 0;
    uint32_t j          = 0;
    uint32_t limit      = 0;
    uint32_t depth      = 0;
    int32_t  pixel[phCOLOR_MAXELEMS];
    int32_t  pixval     = 0;
    int32_t  pixchng    = 0;


    rc  = image->allocate(width,height,format);
    phCHECK_RC(rc,NULL,"image->allocate");

    imgptr = (uint8_t *)image->getImage();

    depth = phImageFormatToDepth(format);
    for (i = 0; i < depth; i++ )
    {
        pixel[i] = lrand48() % 256;
    }
    
    limit = image->getSize() / depth;
    
    for (i = 0; i < limit; i++ )
    {
        /* Random pixel channel adjustment */
        pixchng = (lrand48() % 16) - 8;
        
        /* Random value change */
        for (j = 0; j < depth; j++ )
        {
            pixval = pixel[j] + pixchng;

            if (pixval < 0) 
                pixval = 256 - pixval;
            else if (pixval > 255) 
                pixval = pixval % 256;

            /* Assign the new value to the image*/
            pixel[j] = *imgptr = pixval;
           
            imgptr++;
        }
    }   
        
    return phSUCCESS;
error:
    return phFAIL;
}   

/* ------------------------------------------------------------------------ */
int random_image( uint32_t width,
                  uint32_t height,
                  uint32_t format,
                  phImage  *image )
{
    phFUNCTION("random_image")
    uint8_t *imgptr     = NULL;
    uint32_t i          = 0;
    uint32_t j          = 0;
    uint32_t k          = 0;
    uint32_t depth      = 0;
    int      use_object_pixel = 0;
    uint32_t width_left = 0;
    uint32_t width_mid  = 0;
    int32_t  *pixel     = NULL;
    int32_t  object_pixel[phCOLOR_MAXELEMS];
    int32_t  notobj_pixel[phCOLOR_MAXELEMS];
    int32_t  pixval     = 0;
    int32_t  pixchng    = 0;
    uint32_t start_format = phImageRGB24;

    rc  = image->allocate(width,height,start_format);
    phCHECK_RC(rc,NULL,"image->allocate");

    imgptr = (uint8_t *)image->getImage();

    depth = phImageFormatToDepth(start_format);
    for (i = 0; i < depth; i++ )
    {
        object_pixel[i] = lrand48() % 250;
        notobj_pixel[i] = lrand48() % 250;
    }
    
    use_object_pixel = 0;
    pixel = notobj_pixel;

    for (i = 0; i < height; i++ )
    {
        width_left = lrand48() % (width - (width / 2));
        width_mid  = (lrand48() % (width - width_left));
        for (j = 0; j < width; j++ )
        {
            /* if the random number generator hits 1,
             * then use one pixel color, otherwise use the other */
            if (j == width_left)
                pixel = object_pixel;
            else if (j == (width_left + width_mid))
                pixel = notobj_pixel;
            
            /* Random pixel channel adjustment */
            pixchng = (lrand48() % 8) - 4;
            
            /* Random value change */
            for (k = 0; k < depth; k++ )
            {
                pixval = pixel[k] + pixchng;
                
                if (pixval < 0) 
                    pixval = 256 - pixval;
                else if (pixval > 255) 
                    pixval = pixval % 256;
                
                /* Assign the new value to the image*/
                *imgptr = pixval;
                
                imgptr++;
            }
        }   
    }

    rc = image->convert(format);
    phCHECK_RC(rc,NULL,"image->convert(%s)",
                phImageFormatToString(format));
    
    return phSUCCESS;
error:
    return phFAIL;
}   

#ifdef __cplusplus
}
#endif
/* ------------------------------------------------------------------------ */
phANNSystem::phANNSystem( image_data_collection data, int32_t flags )
{
    phFUNCTION("phANNSystem::phANNSystem")

    /* if the input flag if 0, set it to be all the inputs */
    if (flags == 0)   flags = phML_ALL;
    this->m_flags           = flags;    
    
    this->m_img_inputs      = 0;
    this->m_indiv_inputs    = 0;
    this->m_data            = data;
    this->m_width           = idc_get_width( data ); 
    this->m_height          = idc_get_height( data ); 
    
    this->m_bright          = NULL;
    this->m_bright_stepping =   10;
    this->m_bright_level    =   0;
    
    this->m_canny_resize    = NULL;
    this->m_sobel_resize    = NULL;
    
    this->m_hist_resize     = NULL;
    this->m_histograms      = NULL;
    this->m_histogram_data  = NULL;
    this->m_histogram_bins  = 32;
    this->m_hsv_convert     = NULL;
    
    this->m_canny           = NULL;
    this->m_canny_grey_conv = NULL;
    
    this->m_sobel           = NULL;
    this->m_sobel_grey_conv = NULL;

    this->m_system          = NULL;
    this->m_pipelines       = NULL;
    this->m_displays        = NULL;

    this->m_width_box       = 1.8;
    this->m_height_box      = 1.4;
    
    /* Count up the number of inputs according to the flags */
    if (flags & phML_RGB)     this->m_img_inputs += 3;
    if (flags & phML_HSV)     this->m_img_inputs += 3;
    if (flags & phML_CANNY)   this->m_img_inputs += 1;
    if (flags & phML_SOBEL)   this->m_img_inputs += 1;
    if (flags & phML_GREY)    this->m_img_inputs += 1;
    if (flags & phML_RATIO)   this->m_indiv_inputs += 1;
    if (flags & phML_HISTRGB) 
            this->m_indiv_inputs += (this->m_histogram_bins * 3);/*6*/
    if (flags & phML_HISTHSV)
            this->m_indiv_inputs += (this->m_histogram_bins * 3);/*6*/

    this->m_total_histograms= 0;
    this->m_histrgb_index   = 0;
    this->m_histhsv_index   = 0;
 
    this->m_total_pipelines = 0;
    this->m_bright_pipe     = this->m_total_pipelines++;
    this->m_canny_pipe      = this->m_total_pipelines++;
    this->m_sobel_pipe      = this->m_total_pipelines++;
    this->m_hist_pipe       = this->m_total_pipelines++;
    
    this->m_no_displays     = 0;
    this->m_total_displays  = 0;
    this->m_img_disp        = this->m_total_displays++;
    this->m_canny_disp      = this->m_total_displays++;
    this->m_sobel_disp      = this->m_total_displays++;
    this->m_histrgb_disp    = this->m_total_displays++;
    this->m_histhsv_disp    = this->m_total_displays++;
   
    this->m_total_images    = 0;
    this->m_input_image     = this->m_total_images++;
    this->m_rgb_image       = this->m_total_images++;
    this->m_hsv_image       = this->m_total_images++;
    this->m_grey_image      = this->m_total_images++;
    this->m_canny_image     = this->m_total_images++;
    this->m_sobel_image     = this->m_total_images++;

    this->m_ptr_count           = 0;
    this->m_ptr_array           = NULL;
    this->m_ptr_size_array      = NULL;
    this->m_ptr_stepping_array  = NULL;
    this->m_ptr_name_array      = NULL;

    rc = this->allocate();
    phPRINT_RC(rc,NULL,"this->allocate()");

    rc = this->connect_elements();
    phPRINT_RC(rc,NULL,"this->connect_elements()");

    rc = this->add_filters();
    phPRINT_RC(rc,NULL,"this->add_filters()");

    /* ANN stuff */
    this->m_training_algorithm = FANN_TRAIN_RPROP;
    this->m_connection_rate = 0.7;
    this->m_learning_rate   = 0.7;
    this->m_num_layers      = 3;
    this->m_num_hidden      = 3;
    this->m_num_output      = idc_get_ntags( this->m_data );
    this->m_ann_source      = 0;
    this->m_ann             = NULL;

    this->m_ann_file        = (char *)phCalloc(256,sizeof(char));
    phPRINT_PTR(this->m_ann_file,"phCalloc","phCalloc failed.");

    this->m_logfp           = NULL;
    this->m_logfile         = (char *)phCalloc(256,sizeof(char));
    phPRINT_PTR(this->m_logfile,"phCalloc","phCalloc failed.");

    this->m_ann_datafile    = (char *)phCalloc(256,sizeof(char));
    phPRINT_PTR(this->m_ann_datafile,"phCalloc","phCalloc failed.");

    this->m_input_nodes       = NULL;
    this->m_input_nodes_size  = 0;
    this->m_input_nodes_count = 0;
    this->m_output_nodes      = NULL;
    this->m_output_nodes_size = 0;
    this->m_output_nodes_count= 0;
    this->m_image_ratio       = 0.0;
}

/* ------------------------------------------------------------------------ */
phANNSystem::~phANNSystem( )
{
    phFUNCTION("phANNSystem::~phANNSystem")
    uint32_t i = 0;

    this->closeLogFile();

    phFree(this->m_input_nodes);
    phFree(this->m_output_nodes);

    rc = this->destroyNetwork();
    phPRINT_RC(rc,NULL,"this->destroyNetwork()");

    phFree(this->m_ann_file);
    phFree(this->m_logfile);
    phFree(this->m_ann_datafile);
    
    phFree(this->m_ptr_array);
    phFree(this->m_ptr_size_array);
    phFree(this->m_ptr_stepping_array);
    phFree(this->m_ptr_name_array);

    phDelete(this->m_system);
    phDelete(this->m_canny);
    phDelete(this->m_sobel);
    phDelete(this->m_hsv_convert);
    phDelete(this->m_bright);
    phDelete(this->m_gauss);
    phDelete(this->m_hist_resize);
    
    phDelete(this->m_canny_resize);
    phDelete(this->m_sobel_resize);
    
    for (i = 0; i < this->m_total_histograms; i++ )
    {
        phDelete(this->m_histograms[i]);
        phDelete(this->m_histogram_data[i]);
    }
    phDeleteArray(this->m_histograms);
    phDeleteArray(this->m_histogram_data);
    
    for (i = 0; i < this->m_total_displays; i++ )
    {
        phDelete(this->m_displays[i]);
    }
    phDeleteArray(this->m_displays);

    for (i = 0; i < this->m_total_pipelines; i++ )
    {
        phDelete(this->m_pipelines[i]);
    }
    phDeleteArray(this->m_pipelines);
    
    for (i = 0; i < this->m_total_images; i++ )
    {
        phDelete(this->m_images[i]);
    }
    phDeleteArray(this->m_images);
}

/* ------------------------------------------------------------------------ */
int phANNSystem::allocate( )
{
    phFUNCTION("phANNSystem::allocate")
    uint32_t i = 0;
    uint32_t x = 0;
    uint32_t y = 0;

    /* -------------------------------------------------------------- */
    this->m_ptr_count = this->m_total_images;
    
    this->m_ptr_array           
        = (uint8_t **)phCalloc(this->m_ptr_count,sizeof(uint8_t*));
    phCHECK_PTR(this->m_ptr_array,"phCalloc","phCalloc failed");
    this->m_ptr_size_array      
        = (uint32_t *)phCalloc(this->m_ptr_count,sizeof(uint32_t));
    phCHECK_PTR(this->m_ptr_size_array,"phCalloc","phCalloc failed");
    this->m_ptr_stepping_array  
        = (uint32_t *)phCalloc(this->m_ptr_count,sizeof(uint32_t));
    phCHECK_PTR(this->m_ptr_stepping_array,"phCalloc","phCalloc failed");
    this->m_ptr_name_array      
        = (char **)phCalloc(this->m_ptr_count,sizeof(char *));
    phCHECK_PTR(this->m_ptr_name_array,"phCalloc","phCalloc failed");
    
    this->m_ptr_name_array[0]   = "rgb";
    this->m_ptr_name_array[1]   = "hsv";
    this->m_ptr_name_array[2]   = "grey";
    this->m_ptr_name_array[3]   = "canny";
    this->m_ptr_name_array[4]   = "sobel";

    /* ------------------------------------------------------------------ */
    /* allocate the system and filters */
    this->m_system = new phSystem();
    
    /* -------------------------------------------------------------- */
    /* allocate the displays and the display pointer array */
    this->m_displays = new phDisplayInterface *[this->m_total_displays];
    for (i = 0; i < this->m_total_displays; i++ )
    {
        this->m_displays[i] = new X11Display();
    }
    
    /* -------------------------------------------------------------- */
    /* allocate the pipelines and the pipeline pointer array */
    this->m_pipelines = new phPipeline *[this->m_total_pipelines];
    for (i = 0; i < this->m_total_pipelines; i++ )
    {
        this->m_pipelines[i] = new phPipeline();

        rc = this->m_system->add(this->m_pipelines[i]);
        phPRINT_RC(rc,NULL,"this->m_system->add(pipelines[%d])",i);
    }

    /* -------------------------------------------------------------- */
    this->m_bright = new brightness_Filter();
    this->m_gauss  = new gaussianBlur_Filter();
    this->m_canny_resize = new resize_Filter(this->m_width,this->m_height);
    this->m_sobel_resize = new resize_Filter(this->m_width,this->m_height);
    this->m_hist_resize = new resize_Filter(this->m_width,this->m_height);
    
    /* -------------------------------------------------------------- */
    /* Set up the histogram data and filter arrays */
    if (this->m_flags & (phML_HISTRGB | phML_HISTHSV))
    {
        if (this->m_flags & phML_HISTRGB)
        {
            this->m_histrgb_index = this->m_total_histograms++;
        }
        if (this->m_flags & phML_HISTHSV)
        {
            this->m_histhsv_index = this->m_total_histograms++;
        }

        this->m_histograms      = new histogram_Filter *[this->m_total_histograms];
        this->m_histogram_data  = new phHistogramData *[this->m_total_histograms];
        for (i = 0; i < this->m_total_histograms; i++ )
        {
            this->m_histograms[i] = 
                new histogram_Filter(0,0,
                                     this->m_width,this->m_height,
                                     this->m_histogram_bins,0,NULL);
#if 0
            this->m_histograms[i]->setBoxSize(this->m_width_box,
                                              this->m_height_box);
#endif
            this->m_histogram_data[i] = new phHistogramData();

            rc = this->m_histogram_data[i]->connect(this->m_histograms[i]->getLiveHistogramOutput());
            phPRINT_RC(rc,NULL,"histogram_data->connect");
        }
    }

    /* -------------------------------------------------------------- */
    /* histogram */
    if (this->m_flags & (phML_HISTHSV | phML_HSV))
    {
        this->m_hsv_convert = new convert_Filter(phImageHSV24);
    }
    
    /* -------------------------------------------------------------- */
    /* canny */
    if (this->m_flags & phML_CANNY)
    {
        this->m_canny_grey_conv = new convert_Filter(phImageGREY8);
#if PH_HAVE_OPENCV
        this->m_canny           = new cv_canny_Filter(70,200,3);
#else
        this->m_canny           = new canny_Filter(100,200);
#endif
    }
    
    /* -------------------------------------------------------------- */
    /* sobel */
    if (this->m_flags & phML_SOBEL)
    {
        this->m_sobel_grey_conv = new convert_Filter(phImageGREY8);
        this->m_sobel           = new sobel_Filter();
    }

    /* -------------------------------------------------------------- */
    /* allocate the images and image pointer array */
    this->m_images = new phImage *[this->m_total_images];
    for (i = 0; i < this->m_total_images; i++ )
    {
        this->m_images[i] = new phImage();
    }
 
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::connect_elements( )
{
    phFUNCTION("phANNSystem::connect_elements")

    phLiveObject *source = NULL;
    phLiveObject *s      = NULL;

    /* -------------------------------------------------------------- */
    source = this->m_images[this->m_input_image];
    rc = this->m_pipelines[this->m_bright_pipe]->setLiveSourceInput(source);
    phPRINT_RC(rc,NULL,
               "this->m_pipelines[this->m_bright_pipe]->setLiveSourceInput");

    source = this->m_pipelines[this->m_bright_pipe]->getLiveSourceOutput();

    /* -------------------------------------------------------------- */
    /* If we're inputing an RGB image into the neural network, then
       we need to connect the RGB image */
    if (this->m_flags & phML_RGB)
    {
        rc = this->m_images[this->m_rgb_image]->connect(source);
        phPRINT_RC(rc,NULL,"images[this->m_rgb_image]->connect");
    }
    
    /* -------------------------------------------------------------- */
    /* If we're inputing a grey scale image into the neural network,
       then we need to connect the grey image */
    if (this->m_flags & phML_GREY)
    {
        rc = this->m_images[this->m_grey_image]->connect(source);
        phPRINT_RC(rc,NULL,"images[this->m_grey_image]->connect");
    }
 
    /* -------------------------------------------------------------- */
    /* If we're inputing an HSV image into the neural network,
       then we need to connect the grey image */
    if (this->m_flags & phML_HSV)
    {
        s = this->m_pipelines[this->m_hist_pipe]->getLiveSourceOutput();
        rc = this->m_images[this->m_hsv_image]->connect(s);
        phPRINT_RC(rc,NULL,"images[this->m_grey_image]->connect");
    }
   
    /* -------------------------------------------------------------- */
    /* histogram */
    if (this->m_flags & (phML_HISTRGB | phML_HISTHSV | phML_HSV))
    {
        rc = this->m_pipelines[this->m_hist_pipe]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"pipelines[this->m_hist_pipe]->setLiveSourceInput");
    }
    
    /* -------------------------------------------------------------- */
    /* canny */
    if (this->m_flags & phML_CANNY)
    {
        rc = this->m_pipelines[this->m_canny_pipe]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"pipelines[this->m_canny_pipe]->setLiveSourceInput");

        s = this->m_pipelines[this->m_canny_pipe]->getLiveSourceOutput();
        rc = this->m_images[this->m_canny_image]->connect(s);
        phPRINT_RC(rc,NULL,"images[this->m_canny_image]->connect");
    }
    
    /* -------------------------------------------------------------- */
    /* sobel */
    if (this->m_flags & phML_SOBEL)
    {
        rc = this->m_pipelines[this->m_sobel_pipe]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"pipelines[this->m_sobel_pipe]->setLiveSourceInput");

        s = this->m_pipelines[this->m_sobel_pipe]->getLiveSourceOutput();
        rc = this->m_images[this->m_sobel_image]->connect(s);
        phPRINT_RC(rc,NULL,"images[this->m_sobel_image]->connect");
    }
    
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::pipeline_add( uint32_t index,  phFilter *filter )
{
    phFUNCTION("phANNSystem::pipeline_add")
        
    if ((index < this->m_total_pipelines) && (filter != NULL))
    {
        rc = this->m_pipelines[index]->add(filter);
        phPRINT_RC(rc,NULL,"pipelines[%d]->add(%p:%s)",
                   index,filter,filter->getName());
    }
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::add_filters( )
{
    phFUNCTION("phANNSystem::add_filters")

    /* brightness adjustment */
    this->pipeline_add(this->m_bright_pipe,this->m_bright);
    //this->pipeline_add(this->m_bright_pipe,this->m_gauss);

    /* -------------------------------------------------------------- */
    /* histogram */
    if (this->m_flags & (phML_HISTRGB | phML_HISTHSV | phML_HSV))
    {
#if PRE_RESIZE_HIST_INPUT()
        this->pipeline_add(this->m_hist_pipe,
                           this->m_hist_resize);
#endif
        if (this->m_flags & phML_HISTRGB)
        {
            this->pipeline_add(this->m_hist_pipe,
                               this->m_histograms[this->m_histrgb_index]);
        }
        if (this->m_flags & (phML_HISTHSV | phML_HSV))
        {
            this->pipeline_add(this->m_hist_pipe, this->m_hsv_convert);
        }
        if (this->m_flags & phML_HISTHSV)
        {
            this->pipeline_add(this->m_hist_pipe, 
                               this->m_histograms[this->m_histhsv_index]);
        }
    }
    
    /* -------------------------------------------------------------- */
    /* canny */
    if (this->m_flags & phML_CANNY)
    {
#if PRE_RESIZE_CANNY_INPUT()
        this->pipeline_add(this->m_canny_pipe,
                           this->m_canny_resize);
#endif
        this->pipeline_add(this->m_canny_pipe,this->m_canny_grey_conv);
        this->pipeline_add(this->m_canny_pipe,this->m_canny);
    }
    
    /* -------------------------------------------------------------- */
    /* sobel */
    if (this->m_flags & phML_SOBEL)
    {
#if PRE_RESIZE_SOBEL_INPUT()
        this->pipeline_add(this->m_sobel_pipe,
                           this->m_sobel_resize);
#endif
        this->pipeline_add(this->m_sobel_pipe,this->m_sobel);
        this->pipeline_add(this->m_sobel_pipe,this->m_sobel_grey_conv);
    }
    
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::connect_displays( )
{
    phFUNCTION("phANNSystem::connect_displays")
    uint32_t i = 0;
    uint32_t x = 0;
    uint32_t y = 0;
    phLiveObject *source = NULL;

    if (this->m_no_displays) return phSUCCESS;

    /* -------------------------------------------------------------- */
    /* add the displays to the system and set the x,y coords */
    for (i = 0; i < this->m_total_displays; i++ )
    {
        rc = this->m_system->add(this->m_displays[i]);
        phPRINT_RC(rc,NULL,"system->add(display)");
        
        x = 50+(i*(((this->m_width<170)?170:this->m_width)+16));
        y = 50;
        rc = this->m_displays[i]->move(x,y);
        phPRINT_RC(rc,NULL,"displays[%u]->move",i);
    }

    /* -------------------------------------------------------------- */
    /* Raw image display, brightness adjusted */
    source = this->m_pipelines[this->m_bright_pipe]->getLiveSourceOutput();
    rc = this->m_displays[this->m_img_disp]->setLiveSourceInput(source);
    phPRINT_RC(rc,NULL,"display_pipe");

    /* -------------------------------------------------------------- */
    /* histogram */
    if (this->m_flags & phML_HISTRGB)
    {
        /* RGB histogram display */
        source = this->m_histogram_data[this->m_histrgb_index]->getImage();
        rc = this->m_displays[this->m_histrgb_disp]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"displays[HISTRGB_DISP]");
    }
    if (this->m_flags & phML_HISTHSV)
    {
        /* HSV histogram display */
        source = this->m_histogram_data[this->m_histhsv_index]->getImage();
        rc = this->m_displays[this->m_histhsv_disp]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"displays[HISTHSV_DISP]");
    }
    
    /* -------------------------------------------------------------- */
    /* canny */
    if (this->m_flags & phML_CANNY)
    {
        /* Canny edge detection display */
        source = this->m_pipelines[this->m_canny_pipe]->getLiveSourceOutput();
        rc = this->m_displays[this->m_canny_disp]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"displays[this->m_canny_disp]");
    }
    
    /* -------------------------------------------------------------- */
    /* sobel */
    if (this->m_flags & phML_SOBEL)
    {
        /* Sobel edge detection display */
        source = this->m_pipelines[this->m_sobel_pipe]->getLiveSourceOutput();
        rc = this->m_displays[this->m_sobel_disp]->setLiveSourceInput(source);
        phPRINT_RC(rc,NULL,"display_pipe");
    }
    
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::disconnect_displays( )
{
    phFUNCTION("phANNSystem::disconnect_displays")
    uint32_t i = 0;

    for (i = 0; i < this->m_total_displays; i++ )
    {
        if ((this->m_displays[i] != NULL) && (this->m_no_displays == 0))
        {
            rc = this->m_system->remove(this->m_displays[i]);
            phPRINT_RC(rc,NULL,"system->remove(display)");
        
            rc = this->m_displays[i]->setLiveSourceInput(NULL);
            phPRINT_RC(rc,NULL,
                    "this->m_displays[i:%d]->setLiveSourceInput(NULL)",i);
        }
    }
    
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::startup()
{
    phFUNCTION("phANNSystem::startup");

    rc = this->connect_displays();
    phPRINT_RC(rc,NULL,"this->connect_displays()");

    rc = this->m_system->startup();
    phPRINT_RC(rc,NULL,"system->startup()");

    return rc;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::shutdown()
{
    phFUNCTION("phANNSystem::shutdown");

    rc = this->m_system->shutdown();
    phPRINT_RC(rc,NULL,"system->shutdown()");

    rc = this->disconnect_displays();
    phPRINT_RC(rc,NULL,"this->disconnect_displays()");

    return rc;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::useDisplays( int use )
{
    return (this->m_no_displays = (use ? 0 : 1));
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setBrightnessStep ( int step  )
{
    this->m_bright_stepping = step;
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setBrightnessLevel( int level )
{
    int32_t value = (this->m_bright_stepping * level);
    this->m_bright_level = level;
    this->m_bright->set( value );
    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
uint32_t phANNSystem::getInputCount()
{
    return (this->m_width * this->m_height * this->m_img_inputs) + 
            this->m_indiv_inputs;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::update( )
{
    phFUNCTION("phANNSystem::update")
    uint32_t    k           = 0;
    uint32_t    l           = 0;
    uint32_t    m           = 0;
    uint32_t    input_index = 0;

    uint8_t    *ptr         = NULL;
    uint32_t    ptr_size    = 0;
    uint32_t    ptr_stepping= 0;
    char       *ptr_name    = NULL;

    float       histogrammed_pixels = 0.0;
    uint32_t    bin_total           = 0;
    uint32_t    *cnt_array          = NULL;

    /* Get the number of inputs */
    this->m_input_nodes_count = this->getInputCount();
    if (this->m_input_nodes_count == 0) 
    {
        return phFAIL;
    }
    
    /* allocate the array if it isn't allocated; clear the data too */
    phDALLOC(this->m_input_nodes,
             this->m_input_nodes_size,
             this->m_input_nodes_count,
             fann_type);

    /* -------------------------------------------------------------- */
    /* UPDATE IMAGES */
    /* -------------------------------------------------------------- */
    /* Updqate the pipeline output images : HSV, GREY, CANNY, SOBEL */
    for ( k = this->m_rgb_image; k < this->m_total_images; k++ )
    {
        /* Check the input flags for the presence of the
         * image we want to update; Don't update it if
         * it's unwanted as an input to the ANN */
        if ((1<<(k-1)) & this->m_flags)
        {
            rc = this->m_images[k]->update();
            phPRINT_RC(rc,NULL,"this->m_images[k:%d]->update()",k);
            
            rc = this->m_images[k]->resize(this->m_width,
                                           this->m_height);
            phPRINT_RC(rc,NULL,"this->m_images[k:%d]->resize(%u,%u)",
                    k,this->m_width,this->m_height);
        }
    }

    if (this->m_flags & phML_GREY)
    {
        /* The grey scale still need to be converted */
        rc = this->m_images[this->m_grey_image]->convert(phImageGREY8);
        phPRINT_RC(rc,NULL,"images[this->m_grey_image]->convert");
    }

    /* -------------------------------------------------------------- */
    /* UPDATE HISTOGRAMS */
    /* -------------------------------------------------------------- */
    for ( k = 0; k < this->m_total_histograms; k++ )
    {
        /* Check the input flags to see if we want to
         * update the hist data; 6 is the start for the
         * histogram flags in the phML_ flags */ 
        if (this->m_flags & (1<<(k+6)))
        {
            rc = this->m_histogram_data[k]->update();
            phPRINT_RC(rc,NULL,"histogram_data[k]->update()");

            if (this->m_no_displays == 0)
            {
                rc = this->m_histogram_data[k]->generateImage(120);
                phPRINT_RC(rc,NULL,"histogram_data[k]->generateImage()");
            }
        }
    }

    /* -------------------------------------------------------------- */
    /* COPY IMAGES TO INPUT NODES */
    /* -------------------------------------------------------------- */

    /* Set up the pointer arrays to make things a bit easier in the
     * copying loop, next */
    for (k = this->m_rgb_image; k < this->m_total_images; k++ )
    {
        /* save time here by only copying the info we need
         * because everything else we're not going to
         * touch */
        if ((1<<(k-1)) & this->m_flags)
        {
            this->m_ptr_array[k]         = (uint8_t*)this->m_images[k]->getImage();
            this->m_ptr_size_array[k]    = this->m_images[k]->getSize();
            this->m_ptr_stepping_array[k]= 
                phImageFormatToDepth(this->m_images[k]->getFormat());
            if (this->m_ptr_array[k] == NULL)
            {
                phPROGRESS("WARNING !!! Image %d data == NULL\n",k);
            }
            if (this->m_ptr_size_array[k] == 0)
            {
                phPROGRESS("WARNING !!! Image %d size == 0\n",k);
            }
        }
    }

    /* SET UP THE INPUT NODES */

    /* copy all the image data to the input node array */
    for (k = this->m_rgb_image; k < this->m_total_images; k++ )
    {
        /* Check the input flags for the presence of the
         * image we want to copy to the input nodes. */
        /* The -1 is to offset the k to match up the 1<<x
         * with the flags in this->m_flags */
        if ((1<<(k-1)) & this->m_flags)
        {
            ptr         = this->m_ptr_array[k];
            ptr_size    = this->m_ptr_size_array[k];
            ptr_stepping= this->m_ptr_stepping_array[k];
            ptr_name    = this->m_ptr_name_array[k];

            for ( m = 0; m < ptr_stepping; m++ )
            {
                for ( l = 0; l < ptr_size; l += ptr_stepping )
                {
                    if (input_index >= this->m_input_nodes_count)
                    {
                        phPROGRESS("WARNING!!! %d >= %d\n",
                                    input_index,
                                    this->m_input_nodes_count);
#if 0
                        exit(1);
#endif
                    }
                    this->m_input_nodes[input_index++] = ((fann_type)(ptr[l+m])) - 127;
                }
            }
        }
    }

    /* -------------------------------------------------------------- */
    /* COPY HISTOGRAM PERCENTAGES */
    /* -------------------------------------------------------------- */

    /* -------------------------------------------------------------- */
    /* copy the histogram information to the input node arrays */
    histogrammed_pixels = this->m_images[this->m_input_image]->getWidth() *
                          this->m_images[this->m_input_image]->getHeight();
    for (k = 0; k < this->m_total_histograms; k++ )
    {
        /* Only copy over the histogram data if we're
         * inputing it into the ANN */
        if ((1<<(k+6)) & this->m_flags)
        {
            bin_total= this->m_histogram_data[k]->getBinStep() * 
                this->m_histogram_data[k]->getBinCount();
            cnt_array= this->m_histogram_data[k]->getBinCntArray();

            for ( m = 0; m < bin_total; m++ )
            {
                this->m_input_nodes[input_index++] = 
                    (fann_type)(cnt_array[m] / histogrammed_pixels);
            }
        }
    }

    /* The final input is the ratio */
    if (this->m_flags & phML_RATIO)
    {
        /* ratio is for the w/h ratio of the current img */
        this->m_input_nodes[input_index++] = (fann_type)this->m_image_ratio;
    }

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setOutputNodes( const uint32_t     nids,
                                 const uint32_t    *output_tag_ids )
{
    phFUNCTION("phANNSystem::setOutputNodes")
    uint32_t ntags  = 0;
    uint32_t m      = 0;
    
    ntags = idc_get_ntags( this->m_data );
    
    this->m_output_nodes_count = ntags;
        
    /* IMPORTANT!! This resets all the nodes to 0 */
    /* this reinitializes the output nodes or allocates more */
    phDALLOC(this->m_output_nodes,
             this->m_output_nodes_size,
             this->m_output_nodes_count,
             fann_type);

    /* Set up the output nodes */
    for ( m = 0; m < nids; m++ )
    {
        if (output_tag_ids[m] < ntags)
        {
            this->m_output_nodes[output_tag_ids[m]] = 1.0F;
        }
    }
    /* clear all nodes that aren't 1.0 by setting them to -1.0 */
    for (m = 0; m < ntags; m++ )
    {
        if (this->m_output_nodes[m] < 1.0F)
        {
            this->m_output_nodes[m] = -1.0F;
        }
    }
 
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setInputImage( char           *filename,
                                float           ratio,
                                const uint32_t  nids,
                                const uint32_t *output_tag_ids )
{
    phFUNCTION("phANNSystem::setInputImage(char*,float,uint32_t,uint32_t*)")

    /* Load up the image */
    rc = this->m_images[this->m_input_image]->load( filename );
    phCHECK_RC(rc, NULL, 
               "this->m_images[this->m_input_image]->load( %s )", 
               filename );

    this->m_image_ratio = ratio;
    
    rc = this->update();
    phCHECK_RC(rc,NULL,"update");

    rc = this->setOutputNodes( nids, output_tag_ids );
    phCHECK_RC(rc,NULL,"setOutputNodes");

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setInputImage( phImage        &image,
                                float           ratio,
                                const uint32_t  nids,
                                const uint32_t *output_tag_ids )
{
    phFUNCTION("phANNSystem::setInputImage(phImage,float,uint32_t,uint32_t*)")

    rc = image.copy(this->m_images[this->m_input_image]);
    phCHECK_RC(rc,NULL,"image.copy(images[this->m_input_image])");

    this->m_image_ratio = ratio;
    
    rc = this->update();
    phCHECK_RC(rc,NULL,"update");

    rc = this->setOutputNodes( nids, output_tag_ids );
    phCHECK_RC(rc,NULL,"setOutputNodes");

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setInputImage( char  *filename, 
                                float ratio )
{
    phFUNCTION("phANNSystem::setInputImage(char*,float)")

    /* Load up the image */
    rc = this->m_images[this->m_input_image]->load( filename );
    phCHECK_RC(rc, NULL, 
               "this->m_images[this->m_input_image]->load( %s )", 
               filename );

    this->m_image_ratio = ratio;
    
    rc = this->update();
    phCHECK_RC(rc,NULL,"update");

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setInputImage( phImage &image,
                                float   ratio )
{
    phFUNCTION("phANNSystem::setInputImage(phImage&,float)")

    rc = image.copy(this->m_images[this->m_input_image]);
    phCHECK_RC(rc,NULL,"image.copy(images[this->m_input_image])");

    this->m_image_ratio = ratio;
    
    rc = this->update();
    phCHECK_RC(rc,NULL,"update");

    return phSUCCESS;
error:
    return phFAIL;
}
/* ------------------------------------------------------------------------ */
int phANNSystem::getInputNodes( uint32_t       *input_count,
                                uint32_t       *input_size,
                                fann_type     **pinput_nodes )
{
    phFUNCTION("phANNSystem::getInputNodes")
    uint32_t size = 0;
    uint32_t count= 0;
    
    /* allocate the array if necessary */
    if (pinput_nodes == NULL) return phFAIL;
  
    /* set */
    count = this->m_input_nodes_count;
    if (input_count != NULL)*input_count = count;
    
    /* allocate the array if it isn't allocated; clear the data too */
    if (input_size != NULL) size = *input_size;
    phDALLOC((*pinput_nodes), size, count, fann_type);
    if (input_size != NULL) *input_size = size;
    
    /* copy */
    phMemcpy(*pinput_nodes,
             this->m_input_nodes,
             this->m_input_nodes_size);

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::getOutputNodes(uint32_t       *output_count,
                                uint32_t       *output_size,
                                fann_type     **poutput_nodes )
{
    phFUNCTION("phANNSystem::getOutputNodes")
    uint32_t size = 0;
    uint32_t count= 0;
    
    /* allocate the array if necessary */
    if (poutput_nodes == NULL) return phFAIL;
  
    count = this->m_output_nodes_count;
    if (output_count != NULL)*output_count = count;

    /* allocate */
    if (output_size != NULL) size = *output_size;
    phDALLOC((*poutput_nodes), size, count, fann_type);
    if (output_size != NULL) *output_size = size;

    /* copy */
    phMemcpy(*poutput_nodes,
             this->m_output_nodes,
             this->m_output_nodes_size);

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::getNodes( uint32_t       *input_count,
                           uint32_t       *input_size,
                           fann_type     **pinput_nodes,
                           uint32_t       *output_count,
                           uint32_t       *output_size,
                           fann_type     **poutput_nodes )
{
    phFUNCTION("phANNSystem::getNodes")

    rc = this->getInputNodes(input_count,input_size,pinput_nodes);
    phCHECK_RC(rc,NULL,"getInputNodes");

    rc = this->getOutputNodes(output_count,output_size,poutput_nodes);
    phCHECK_RC(rc,NULL,"getOutputNodes");

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::getNodes( fann_type     **pinput_nodes,
                           fann_type     **poutput_nodes )
{
    phFUNCTION("phANNSystem::getNodes(fann_type **,fann_type **)")

    rc = this->getInputNodes(NULL,NULL,pinput_nodes);
    phCHECK_RC(rc,NULL,"getInputNodes");

    rc = this->getOutputNodes(NULL,NULL,poutput_nodes);
    phCHECK_RC(rc,NULL,"getOutputNodes");

    return phSUCCESS;
error:
    return phFAIL;
}
/* ------------------------------------------------------------------------ */
FILE *phANNSystem::openLogFile( const char *prefix,
                                const char *suffix )
{
    phFUNCTION("phANNSystem::openLogFile")

    if (this->m_logfp)
    {
        this->closeLogFile();
    }
        
    snprintf(this->m_logfile,
             255,
             "%s_flgs%03x_alg%d_lyrs%02u_in%05u_h%03u_o%03u_w%03u_h%03u_%s.log",
             prefix, 
             this->m_flags,
             this->m_training_algorithm,
             this->m_num_layers,
             this->getInputCount(), 
             this->m_num_hidden, 
             this->m_num_output,
             this->m_width, 
             this->m_height,
             suffix );

    phPRINT("Opening log file for statistical output: %s\n",
            this->m_logfile );
    this->m_logfp = fopen( this->m_logfile,"w+" );
    phCHECK_PTR(this->m_logfp,"fopen",
                "fopen %s failed.",this->m_logfile );

    return this->m_logfp;
error:
    return NULL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::closeLogFile()
{
    phFUNCTION("phANNSystem::closeLogFile")
    
    /* close the logfile */
    if (this->m_logfp != NULL)
    {
        phPRINT("Closing log file.\n");
        fclose(this->m_logfp);
        this->m_logfp = NULL;
    }

    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::createNetwork()
{
    phFUNCTION("phANNSystem::createNetwork")
    uint32_t i = 0;

    if (this->m_ann_source == 1)
    {
        phPRINT("Opening ANN from %s\n",this->m_ann_file);
        this->m_ann = fann_create_from_file( this->m_ann_file );
        phPRINT("Done.\n");
        if (this->m_ann == NULL) goto error;

        this->m_learning_rate       = fann_get_learning_rate(this->m_ann);
        this->m_num_output          = fann_get_num_output(this->m_ann);
        this->m_training_algorithm  = fann_get_training_algorithm(this->m_ann);
        /* connection_rate */
        /* num_hidden ?? */
        /* num_layers ?? */
    }
    else
    {
        unsigned int *neurons_per_layer = 
            (unsigned int *)phCalloc(this->m_num_layers,sizeof(unsigned int));
        phCHECK_PTR(neurons_per_layer,"phCalloc","phCalloc failed.");
        
        /* Print out the first arguments to the creation function */
        phPRINT("Creating new ANN( %f, %f, %u, ",
                this->m_connection_rate, 
                this->m_learning_rate, 
                this->m_num_layers );

        /* Set the number of input nodes */
        neurons_per_layer[0] = this->getInputCount();
        /* Print the number of input neurons */
        phPRINT(" { %u ", neurons_per_layer[0] );
        /* Set the number of output nodes */
        neurons_per_layer[this->m_num_layers - 1] = this->m_num_output;
        /* Set the hidden layer number of nodes */
        for (i = 1; i < (this->m_num_layers - 1); i++ )
        {
            neurons_per_layer[i] = this->m_num_hidden;
            phPRINT(" %u,", neurons_per_layer[i] );
        }
        /* Print the output node count */
        phPRINT(" %u} )\n", this->m_num_output );
        
        /* Create the FANN ANN With the specific arguments */
        this->m_ann = fann_create_array(  this->m_connection_rate, 
                                          this->m_learning_rate, 
                                          this->m_num_layers,
                                          neurons_per_layer );
        phPRINT("Done.\n");
        phCHECK_PTR(this->m_ann,NULL,"fann_create");

        /* Set the training algorithm; it will be saved in the ann .net file
         * when the system is saved */
        fann_set_training_algorithm(this->m_ann,
                                    this->m_training_algorithm);

        /* Set the activation function to FANN_SIGMOID_SYMMETRIC because the
           system being used here outputs -1.0 for no and 1.0 for yes */
        fann_set_activation_function_hidden(this->m_ann,FANN_SIGMOID_SYMMETRIC);
        fann_set_activation_function_output(this->m_ann,FANN_SIGMOID_SYMMETRIC);
        
        phPRINT("Input Nodes        : %u\n", this->getInputCount() );
        phPRINT("Hidden nodes       : %u\n",this->m_num_hidden );
        phPRINT("Output nodes       : %u\n",this->m_num_output);
        phPRINT("Number of Layers   : %u\n",this->m_num_layers);

        phFree(neurons_per_layer);
    }
    fann_print_parameters( this->m_ann );

    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::destroyNetwork()
{
    phFUNCTION("phANNSystem::destroyNetwork")

    if (this->m_ann != NULL)
    {
        fann_destroy(this->m_ann);
        this->m_ann = NULL;
    }

    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setNetwork( char *ann_startfile )
{
    phFUNCTION("phANNSystem::setNetwork")

    this->m_ann_source  = 1;
    snprintf(this->m_ann_file,255,"%s",ann_startfile);
    
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::setNetwork(float       connection_rate, 
                            float       learning_rate, 
                            int32_t     training_algorithm,
                            uint32_t    num_layers,
                            uint32_t    num_hidden )
{
    phFUNCTION("phANNSystem::setNetwork")

    this->m_ann_source          = 0;
        
    this->m_connection_rate     = connection_rate;
    this->m_learning_rate       = learning_rate;
    this->m_training_algorithm  = training_algorithm;
    
    if (num_layers < 2)
        this->m_num_layers = 2;
    else
        this->m_num_layers          = num_layers;
    
    if ((this->getInputCount() > 0) && (num_hidden == 0))
    {
        this->m_num_hidden = this->getInputCount() / 600;
    }
    else
    {
        this->m_num_hidden = num_hidden;
    }
    if (this->m_num_hidden < 3)
    {
        this->m_num_hidden = 3;
    }
    
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phANNSystem::saveNetwork( const char *prefix,
                              const char *suffix )
{
    phFUNCTION("phANNSystem::saveNetwork")

    snprintf(this->m_ann_datafile,
            255,
            "%s_flgs%03x_alg%d_lyrs%02u_in%05u_h%03u_o%03u_w%03u_h%03u_%s.net",
            prefix, 
            this->m_flags, 
            this->m_training_algorithm,
            this->m_num_layers,
            this->getInputCount(), 
            this->m_num_hidden, 
            this->m_num_output,
            this->m_width, 
            this->m_height, 
            suffix );
    
    phPRINT( "\nSaving ANN file: %s\n", this->m_ann_datafile );
    fann_save(this->m_ann,this->m_ann_datafile);
    phPRINT( "Done saving.\n" );

    return phSUCCESS;
}

/* ------------------------------------------------------------------------ */
void phANNSystem::print_epoch_info( const char      *label,
                                    ml_class_stats  *stats)
{
    phFUNCTION("phANNSystem::print_epoch_info")
        
    float percent_correct   = 0.0;
    float percent_incorrect = 0.0;

    /* Print the testing set's final MSE */
    percent_correct = ((float)stats->correctly_classified / 
                       (float)(stats->nclassifications)) * 100;
    percent_incorrect = ((float)stats->incorrectly_classified / 
                       (float)(stats->nclassifications)) * 100;
    
    phPRINT("%s(MSE:%8.20f) (Classified: %5u/%5u of %5u) %0.3f%% %0.3f%%     \n",
            label,
            fann_get_MSE(this->m_ann),
            stats->correctly_classified,
            stats->incorrectly_classified,
            stats->nclassifications,
            percent_correct,
            percent_incorrect );
}

/* ------------------------------------------------------------------------ */
int phANNSystem::generateNodes(int      preload_images,
                               int      generate_random,
                               uint32_t train_set_size,
                               uint32_t test_set_size,
                               uint32_t *ptrain_array_count,
                               uint32_t *ptest_array_count,
                               uint32_t *pinput_array_count,
                               fann_type ***pinput_nodes,
                               fann_type ***prand_input_nodes,
                               uint32_t *poutput_array_count,
                               fann_type ***poutput_nodes,
                               fann_type ***prand_output_nodes )
{
    phFUNCTION("phANNSystem::train")

    /* ------------------------------------------------------------------ */
    double          size        = 0.0;
    uint32_t        i           = 0;
    uint32_t        j           = 0;
    uint32_t        last_j      = 1;
    
    /* The 'array's here point to all the input and output pairing of nodes
       that are the result of processing all the data */       
    uint32_t        processed_index     = 0;
    uint32_t        train_array_count   = 0;
    int             train_generated     = 0;
    uint32_t        test_array_count    = 0;
    fann_type       **input_array  = NULL;
    fann_type       **rand_input_array  = NULL;
    fann_type       **output_array = NULL;
    fann_type       **rand_output_array = NULL;
    /* input and output are allocated and populated by this program;
     * actual_output is returned from fann_run and compared against the
     * output_nodes array to determine correctly classified objects */
    fann_type       *input_nodes        = NULL;
    fann_type       *output_nodes       = NULL;

    /* ------------------------------------------------------------------ */
    random_selection_type   *selection          = NULL;
    uint32_t                file_id             = 0; /* i.e. sel. set */
    uint32_t                img_set_id          = 0; /* i.e. sel. index */
   
    /* ------------------------------------------------------------------ */
    uint32_t        ntags               = 0;
    uint32_t        nsets               = 0;
    uint32_t        total_train_imgs    = 0;
    uint32_t        total_test_imgs     = 0;
    uint32_t        total_imgs          = 0;
    uint32_t        set_size            = 0;

    /* ------------------------------------------------------------------ */
    /* image_array is used when preloading a set of images */
    phImage         *image_array= NULL;
    phImage         temp_image;
    /* filename is a temporary variable used when opening an image */
    char            *filename   = NULL;
    /* ratio is used as an input to the network */
    float           ratio       = 0.0;
    /* nids is used for each image to loop through tags for an image */
    uint32_t        nids        = 0;
    /* tag_ids is a pointer to an array of tags for activate output nodes */
    uint32_t        *tag_ids    = NULL;
    /* img is a handle to information of set of images loaded from file   */
    image_data_set  img         = NULL;
    uint32_t        x1          = 0;
    uint32_t        y1          = 0;
    uint32_t        x2          = 0;
    uint32_t        y2          = 0;

    /* ------------------------------------------------------------------ */
    int32_t         b               = 0;
    int32_t         bright_level    = 0;
    const int32_t   nbright_levels  = 5;
    const int32_t   bright_offset   = -4; /* start darker */
    const int32_t   initial_bright  = (nbright_levels / 2) + bright_offset;
    
    int32_t         hue_adjust      = 0;
    int32_t         sat_adjust      = 0;
    int32_t         val_adjust      = 0;
    int32_t         *adjust_arr      = NULL;

    int rand_w = 0;
    int rand_h = 0;
   
    /* ------------------------------------------------------------------ */
    /* Check the input parameters. Make sure the information isn't allocated
     * because the information will be lost when we set the return parameters
     * at the end of this method */
    if ((pinput_nodes != NULL) && (*pinput_nodes != NULL))
    {
        phCHECK_PTR(NULL,NULL,
                    "Invalid parameter: *pinput_nodes != NULL");
    }
    if ((poutput_nodes != NULL) && (*poutput_nodes != NULL))
    {
        phCHECK_PTR(NULL,NULL,
                    "Invalid parameter: *poutput_nodes != NULL");
    }
    if ((prand_input_nodes != NULL) && (*prand_input_nodes != NULL))
    {
        phCHECK_PTR(NULL,NULL,
                    "Invalid parameter: *prand_input_nodes != NULL");
    }
    if ((prand_output_nodes != NULL) && (*prand_output_nodes != NULL))
    {
        phCHECK_PTR(NULL,NULL,
                    "Invalid parameter: *prand_output_nodes != NULL");
    }
    
    /* ------------------------------------------------------------------ */
    /* retreive the info from the data set */
    set_size            = train_set_size + test_set_size;
    nsets               = idc_get_nsets( this->m_data );
    total_train_imgs    = nsets * train_set_size * nbright_levels;
    total_test_imgs     = nsets * test_set_size * nbright_levels;
    total_imgs          = total_train_imgs + total_test_imgs;

    /* preload the images if necessary */
    if (preload_images)
    {
        image_array = new phImage[nsets];
    }
  
    size =  (double)(sizeof(fann_type) * 
                     (this->getInputCount() + idc_get_ntags( this->m_data )) * 
                     total_imgs *
                     (generate_random ? 2 : 1));
    
    phPRINT("Test Set Size      : %u\n",train_set_size);
    phPRINT("Train Set Size     : %u\n",test_set_size);
    phPRINT("Array Count        : %u\n",total_imgs);
    phPRINT("Total Data size    : %.4lf Bytes %.4lf KBytes %.4lf MBytes %.4lf GBytes\n",
            size, 
            size / 1024, 
            size / (1024*1024),
            size / (1024 * 1024 * 1024));
    
    input_array = (fann_type **)phCalloc(total_imgs,sizeof(fann_type *));
    phCHECK_PTR(input_array,"phCalloc","phCalloc failed.");
    
    output_array = (fann_type **)phCalloc(total_imgs,sizeof(fann_type *));
    phCHECK_PTR(output_array,"phCalloc","phCalloc failed.");

    if (generate_random)
    {
        rand_input_array = (fann_type **)phCalloc(total_imgs,sizeof(fann_type *));
        phCHECK_PTR(rand_input_array,"phCalloc","phCalloc failed.");
    
        rand_output_array = (fann_type **)phCalloc(total_imgs,sizeof(fann_type *));
        phCHECK_PTR(rand_output_array,"phCalloc","phCalloc failed.");
    }
    
    /* Create random indexes for the training and test sets. */
    /* training = array[0] testing = array[train_set_size] */
    rc = random_selection_new( this->m_data,
                               train_set_size, 
                               test_set_size, 
                               &selection );
    phCHECK_RC(rc,NULL,"random_selection_new failed.");
    
    /* start up the processing system */
    rc = this->startup();
    phCHECK_RC(rc,NULL,"this->startup()");
    
    phPRINT("Number of Image sets   : %u\n", nsets );
    phPRINT("Training Images        : %u\n", total_train_imgs );
    phPRINT("Testing Images         : %u\n", total_test_imgs );
    
    processed_index = 0;
    
    if (generate_random)
    {
        srand48((unsigned int)time(NULL));
    }

    for (j = 0; j < set_size; j++ )
    {
        if ((j >= train_set_size) && (train_generated == 0))
        {
            train_array_count = processed_index;
            train_generated = 1;
        }
        
        file_id = selection->rset_array[j];

        /* preload the images for the current training set */
        if (preload_images)
        {
            /* load one for each image of the current set index */
            for (i = 0; i < nsets; i++ )
            {
                img_set_id = selection->rindex_array[j][i];

                /* Get the image settings */
                img = idc_get_set       ( this->m_data, img_set_id );

                rc = ids_get_filename  ( img,  file_id, &filename );
                phPRINT_RC(rc,NULL,"ids_get_filename");

                rc = ids_get_crop_coords( img, &x1, &y1, &x2, &y2 );
                phCHECK_RC(rc, NULL, "ids_get_crop_coords failed.");

                /* Load up the image */
                rc = image_array[i].load( filename );
                phCHECK_RC(rc, NULL, "image.load( %s )", filename );

                /* crop the image, don't resize it */
                rc = image_array[i].crop( x1, y1, x2, y2 );
                phCHECK_RC(rc,NULL,
                        "images[temp_index]->crop(%u,%u,%u,%u) failed.",
                        x1, y1, x2, y2 );
            }
        }

        for (i = 0; i < nsets; i++ )
        {
            img_set_id = selection->rindex_array[j][i];

            /* Get the image settings */
            img = idc_get_set( this->m_data, img_set_id );

            rc = ids_get_crop_coords( img, &x1, &y1, &x2, &y2 );
            phCHECK_RC(rc, NULL, "ids_get_crop_coords failed.");

            ratio       = ids_get_ratio     ( img );
            nids        = ids_get_ntags     ( img );
            tag_ids     = ids_get_tag_ids   ( img );

            rc = ids_get_hsv_adjust( img, 
                    &hue_adjust, &sat_adjust, &val_adjust );
            phPRINT_RC( rc, NULL, "ids_get_hsv_adjust" );

            /* set the initial brightness level */
            bright_level = initial_bright;

            for (b = 0; b < nbright_levels; b++ )
            {
                /* Brightness adjustment loop for training on varying
                 * brightness levels. This is artificial and would be
                 * better as real world brightness adjustments of lighting */
                if ((!this->m_no_displays) || (last_j != j))
                {
                    if (j < train_set_size)
                    {
                        phPRINT("Processing training set (%5d of %5d)\r", 
                                (j * nsets * nbright_levels) + 
                                (i * nbright_levels) + 
                                (b + 1), /* current set */
                                total_train_imgs /* total image sets */ );
                    }
                    else 
                    {
                        phPRINT("Processing test set     (%5d of %5d)\r",
                         ((j-train_set_size) * nsets * nbright_levels) + 
                         (i * nbright_levels) + 
                         (b + 1), /* current set */
                         total_test_imgs );
                    }
                        
                    last_j = j;
                }

                /* Set the brightness level of the brightness
                 * adjustment filter */
                rc = this->setBrightnessLevel( bright_level );
                phPRINT_RC(rc,NULL,"this->setBrightnessLevel()");

                bright_level++;

                /* load a file from file, the pipeline will see this
                 * and brightness adjust the image. The same for the
                 * copy in the else statement below. */
                if (!preload_images)
                {
                    rc = ids_get_filename  ( img,  file_id, &filename );
                    phPRINT_RC(rc,NULL,"ids_get_filename");

                    rc = temp_image.load(filename);
                    phCHECK_RC(rc,NULL,"temp_image.load(%s)",filename);

                    /* crop the image, don't resize it */
                    rc = temp_image.crop( x1, y1, x2, y2 );
                    phCHECK_RC(rc,NULL,
                            "images[temp_index]->crop(%u,%u,%u,%u) failed.",
                            x1, y1, x2, y2 );

                    rc = this->setInputImage(temp_image,
                                             ratio,nids,tag_ids);
                    phCHECK_RC(rc, NULL, "this->setInputImage()");
                }
                else /* use the preloaded images */
                {
                    rc = this->setInputImage(image_array[i],
                                             ratio,nids,tag_ids);
                    phCHECK_RC(rc, NULL, "this->setInputImage()");
                }        

                rc = this->getNodes(&input_nodes,      /* fann_type **  */
                                    &output_nodes      /* fann_type **  */ );
                phPRINT_RC(rc,NULL,"this->getNodes()");

                input_array [processed_index] = input_nodes;
                output_array[processed_index] = output_nodes;
                input_nodes = NULL;
                output_nodes = NULL;

                /* Input a random image into the set */
                if (generate_random)
                {
                    char foofile[256];
                    
                    if (generate_random == 1)
                    {
                        rc = random_gradient(this->m_width,
                                          this->m_height,
                                          phImageRGB24,
                                          &temp_image );
                        phCHECK_RC(rc,NULL,"random_gradient");
                    }
                    else if (generate_random == 2)
                    {
                        rc = randomize_pixels(this->m_width,
                                              this->m_height,
                                              phImageRGB24,
                                              &temp_image );
                        phCHECK_RC(rc,NULL,"randomize_pixels");
                    }
                    else if (generate_random == 3)
                    {
                        rc = random_image(this->m_width,
                                          this->m_height,
                                          phImageRGB24,
                                          &temp_image );
                        phCHECK_RC(rc,NULL,"randomize_pixels");
                    }
                        
#if 0
                    /* save a sampling of the random images */
                    if (processed_index < 5000)
                    {
                        snprintf(foofile,255,"random/file%06u.ppm",
                                 processed_index);
                        temp_image.save(foofile);
                    }
#endif               
                    /* the 320 and 240 really don't matter; They could be 
                     * any number because we're dividing them; You would 
                     * just want the ranges of W and H to be too different */
                    rand_w = lrand48() % 321;
                    rand_h = lrand48() % 241;
                    ratio = ((float)rand_w) / ((float)rand_h);
                    
                    rc = this->setInputImage(temp_image,ratio,0,NULL);
                    phCHECK_RC(rc, NULL, "this->setInputImage()");
                
                    rc = this->getNodes(&input_nodes,      /* fann_type **  */
                                        &output_nodes      /* fann_type **  */ );
                    phPRINT_RC(rc,NULL,"this->getNodes()");

                    rand_input_array [processed_index] = input_nodes;
                    rand_output_array[processed_index] = output_nodes;
                    input_nodes = NULL;
                    output_nodes = NULL;
                }

                processed_index++;
            } /* b : nbright_levels */
        } /* i :  nsets */
    } /* j : set_size */

    rc = this->shutdown();
    phPRINT_RC(rc,NULL,"this->shutdown()");

    /* Free up all the data */
    phDeleteArray(image_array);
    phFree(filename);

    /* Free the random selection arrays */
    rc = random_selection_free( &selection );
    phPRINT_RC(rc,NULL,"random_selection_free failed.");

    if (processed_index != total_imgs)
    {
        phPROGRESS("WARNING !!! All expected images weren't generated.\n");
    }

    /* Set the output pointers to the informatin generated from this method */
    if (pinput_array_count != NULL)
        *pinput_array_count = processed_index;
    
    if (ptrain_array_count != NULL)
        *ptrain_array_count = train_array_count;
   
    test_array_count = processed_index - train_array_count;
    
    if (ptest_array_count != NULL)
        *ptest_array_count = test_array_count;
    
    if (poutput_array_count != NULL)
        *poutput_array_count = processed_index;
    
    /* Set the input node array or free it */
    if (pinput_nodes == NULL) 
    {
        for (i = 0; i < total_imgs; i++ )
        {
            phFree(input_array[i]);
        }
        phFree(input_array);
    }
    else
        *pinput_nodes = input_array;

    if (poutput_nodes == NULL) 
    {
        for (i = 0; i < total_imgs; i++ )
        {
            phFree(output_array[i]);
        }
        phFree(output_array);
    }
    else
        *poutput_nodes= output_array;

    if (generate_random)
    {
        if (prand_input_nodes == NULL) 
        {
            for (i = 0; i < total_imgs; i++ )
            {
                phFree(rand_input_array[i]);
            }
            phFree(rand_input_array);
        }
        else
            *prand_input_nodes = rand_input_array;

        if (prand_output_nodes == NULL) 
        {
            for (i = 0; i < total_imgs; i++ )
            {
                phFree(rand_output_array[i]);
            }
            phFree(rand_output_array);
        }
        else
            *prand_output_nodes= rand_output_array;
    }


    return phSUCCESS;

error:
    /* Free up all the data */
    phDeleteArray(image_array);
    phFree(filename);
                
    /* Free the random selection arrays */
    rc = random_selection_free( &selection );
    phPRINT_RC(rc,NULL,"random_selection_free failed.");

    for (i = 0; (i < total_imgs) && (input_array); i++ )
    {
        phFree(input_array[i]);
    }
    phFree(input_array);

    for (i = 0; (i < total_imgs) && (output_array); i++ )
    {
        phFree(output_array[i]);
    }
    phFree(output_array);
    
    if (generate_random)
    {
        for (i = 0; (i < total_imgs) && (rand_input_array); i++ )
        {
            phFree(rand_input_array[i]);
        }
        phFree(rand_input_array);

        for (i = 0; (i < total_imgs) && (rand_output_array); i++ )
        {
            phFree(rand_output_array[i]);
        }
        phFree(rand_output_array);
    }
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
/* train
 *      This function is designed to train a neural network. It logs data
 *  about training and testing errors including percentages for correctly
 *  and incorrectly classified objects.
 */
/* ------------------------------------------------------------------------ */
/* preload_images   : Load the current set of images into an array so that 
 *                    all the hard drive accesses are done at once.
 * train_set_size   : 
 * test_set_size    :
 * max_epochs       :
 * desired_error    :
 * start_epoch      :
 *
 */
/* important parameters: desired error, learning rate, max epochs,
 *                       num_layers, connection rate                        */
/* ------------------------------------------------------------------------ */
int phANNSystem::train(int      preload_images,
                       int      use_random,
                       uint32_t train_set_size,
                       uint32_t test_set_size,
                       uint32_t max_epochs,
                       float    desired_error,
                       uint32_t start_epoch )
{
    phFUNCTION("phANNSystem::train")

    /* ------------------------------------------------------------------ */
    uint32_t    i = 0;
    uint32_t    last_j      = 1;
    char        *ann_prefix = "ann";
    char        suffix[255];
    
    ml_class_stats  *train_stats        = NULL;
    ml_class_stats  *test_stats         = NULL;
    ml_class_stats  *rand_train_stats   = NULL;
    ml_class_stats  *rand_test_stats    = NULL;
    ml_class_stats  *use_stats          = NULL;
    ml_class_stats  *rand_use_stats     = NULL;
    float           train_mse           = 0.0F;
    
    /* input and output are allocated and populated by this program;
     * actual_output is returned from fann_run and compared against the
     * output_nodes array to determine correctly classified objects */
    uint32_t    input_array_count   = 0;
    fann_type   **input_array       = NULL;
    uint32_t    output_array_count  = 0;
    fann_type   **output_array      = NULL;
    uint32_t    train_array_count   = 0;
    uint32_t    test_array_count    = 0;
    fann_type   **rand_input_array  = NULL;
    fann_type   **rand_output_array = NULL;
    
    fann_type   *actual_output      = NULL;

    uint32_t    nsets       = 0;
    uint32_t    node_index  = 0;
    uint32_t    epoch       = 0;
    int         trained     = 0;
    int         train_done  = 0;

    /* ------------------------------------------------------------------ */
    /* retreive the info from the data set */
    nsets               = idc_get_nsets( this->m_data );

    /* ------------------------------------------------------------------ */
    /* create a new class_stats object to calculate the per epoch stats... */
    /* ... for the actual input data */
    rc = ml_class_stats_new(this->m_num_output, &train_stats );
    phPRINT_RC(rc,NULL,"ml_class_stats_new");
    rc = ml_class_stats_new(this->m_num_output, &test_stats );
    phPRINT_RC(rc,NULL,"ml_class_stats_new");
    /* ... for the randomized information */
    if (use_random)
    {
        rc = ml_class_stats_new(this->m_num_output, &rand_train_stats );
        phPRINT_RC(rc,NULL,"ml_class_stats_new");
        rc = ml_class_stats_new(this->m_num_output, &rand_test_stats );
        phPRINT_RC(rc,NULL,"ml_class_stats_new");
    }

    /* Open the log file... */
    sprintf(suffix,"nimages%03u_ran%02d", nsets, use_random );
    this->openLogFile( ann_prefix, suffix );

    /* print the column headers to the log file */
    ml_class_stats_headers_print( this->m_logfp, 
                                  train_stats,
                                  idc_get_tags( this->m_data ), 
                                  idc_get_ntags( this->m_data ));
               
    /* generate the processed data */           
    rc = this->generateNodes( 0 /* preload images */,
                              use_random, /* generate random images */
                              train_set_size,
                              test_set_size,
                              &train_array_count,
                              &test_array_count,
                              &input_array_count,
                              &input_array,
                              &rand_input_array,
                              &output_array_count,
                              &output_array,
                              &rand_output_array );
    phCHECK_RC(rc,NULL,"ann_system->generateNodes");

    /* Create the network */
    rc = this->createNetwork();
    phPRINT_RC(rc,NULL,"this->createNetwork()");
    
    /* -------------------------------------------------------------- */
    /* Training set */
    phPRINT("Input Array Count      : %u\n",input_array_count);
    phPRINT("Output Array Count     : %u\n",output_array_count);
    phPRINT("Training size          : %u\n",train_array_count );
    phPRINT("Testing  size          : %u\n",test_array_count);
    phPRINT("\n\n");
    for (epoch = start_epoch; 
         ((epoch < max_epochs) && (!train_done)) || (epoch < 3); 
         epoch++ )
    {
        phPRINT("\nEpoch:%u\n",epoch);

        /* Reset the MSE for the training set */
        fann_reset_MSE(this->m_ann);
        ml_class_stats_reset(train_stats);
        ml_class_stats_reset(test_stats);
        if (use_random)
        {
            ml_class_stats_reset(rand_train_stats);
            ml_class_stats_reset(rand_test_stats);
        }
        use_stats       = train_stats;
        rand_use_stats  = rand_train_stats;

        train_mse   = 0.0F;
        trained     = 0;
        node_index  = 0;

        /* when node_index is less than train_set_size, we're training...
         * when node_index >= train_set_size and less than test_set_size, we're tesing... */
        while (node_index < input_array_count)
        {
            /* OUTPUT RESULTS:
             *  from the Training Set training */
            /* if node_index == train_set_size, we're on the transition from
             * training to testing and we need to reset the MSE for the
             * testing set */
            if ((node_index == train_array_count) && (trained == 0))
            {
                train_mse = fann_get_MSE(this->m_ann);
                
                /* Print the testing set's final MSE */
                phPRINT("Training Session (MSE: %8.20f)           \n",
                        fann_get_MSE(this->m_ann) );
                
                /* Reset the MSE,[in]correctly classified variables for the training set testing */
                fann_reset_MSE(this->m_ann);
                trained     = 1;
                node_index  = 0;
            }
            /* OUTPUT RESULTS:
             *  from the Training Set's testing run */
            else if (node_index == train_array_count)
            {
                /* Print the training set MSE to the log file *
                 * Print the classification statistics to file */
                ml_class_stats_set_mse(train_stats,fann_get_MSE(this->m_ann));

                this->print_epoch_info( "Training Set         ", 
                                        train_stats );
                if (use_random)
                {
                    this->print_epoch_info( "Training Set (random)", 
                                            rand_train_stats );
                }                    
                /* Reset the MSE,[in]correctly classified variables for the validation set testing */
                fann_reset_MSE(this->m_ann);

                /* switch to using the test_stats variable for the actual
                 * testing loop */
                use_stats       = test_stats;
                rand_use_stats  = rand_test_stats;
            }

            if ((node_index % 100) == 0)
            {
                if (!trained)
                {
                    phPRINT("Training               (%5d of %5d)\r", 
                            /* total train image sets */
                            node_index+1, train_array_count );
                }
                else if (node_index <= train_array_count)
                {
                    phPRINT("Training set testing   (%5d of %5d)\r",
                            /* total train image sets */
                            node_index+1, train_array_count );
                }
                else
                {
                    phPRINT("Validation set testing (%5d of %5d)\r",
                            (node_index - train_array_count)+1,
                            (input_array_count - train_array_count) );
                }
            }
            
            /* TRAIN */
            if (!trained)
            {
                /* Train on the data * -------------------------------- */
                fann_train(this->m_ann, 
                            input_array[node_index], 
                            output_array[node_index] );
            }
            /* TEST */
            else
            {
                /* Test on the data * -------------------------------- */
                fann_test(this->m_ann, 
                          input_array[node_index], 
                          output_array[node_index] );

                /* Run the ANN and get the output for comparison
                 * against the expected output so we can compute the
                 * correctly classified sets */
                actual_output = fann_run(this->m_ann, 
                                         input_array[node_index] );

                ml_class_stats_classify( use_stats,
                                         output_array[node_index],
                                         actual_output );
            }
            
            /* RANDOM IMAGE TRAIN */
            if ((!trained) && (use_random))
            {
                /* Train on the data * -------------------------------- */
                fann_train(this->m_ann, 
                           rand_input_array[node_index], 
                           rand_output_array[node_index] );
            }
            /* TEST */
            else if (use_random)
            {
                /* Test on the data * -------------------------------- */
                fann_test(this->m_ann, 
                          rand_input_array[node_index], 
                          rand_output_array[node_index] );

                /* Run the ANN and get the output for comparison
                 * against the expected output so we can compute the
                 * correctly classified sets */
                actual_output = fann_run(this->m_ann, 
                                         rand_input_array[node_index] );

                ml_class_stats_classify( rand_use_stats,
                                         rand_output_array[node_index],
                                         actual_output );
            }
            node_index++;
        } /* node_index < input_array_count */

        /* Set the TESTing MSE */
        ml_class_stats_set_mse(test_stats,fann_get_MSE(this->m_ann));

        /* Print the stat info to the log file */
        rc = ml_class_stats_row_print(this->m_logfp,epoch,train_mse,
                                      train_stats,test_stats );
        phCHECK_RC(rc,NULL,"ml_class_stats_row_print");
        
        this->print_epoch_info("Testing Set          ", test_stats);
        if (use_random)
        {
            this->print_epoch_info("Testing Set  (random)", rand_test_stats);
        }

        if ( fann_get_MSE(this->m_ann) < desired_error )
        {
            phPRINT("final MSE: %f\n", fann_get_MSE(this->m_ann));
            train_done = 1;
        }

        sprintf(suffix,"nimages%03u_ran%02u_epoch%03u", nsets, use_random,epoch );
        this->saveNetwork(ann_prefix,suffix);

    } /* epoch : !train_done, max_epochs */

    rc = this->destroyNetwork();
    phPRINT_RC(rc,NULL,"this->destroyNetwork()");

    /* Free the processed data */
    for (i = 0; i < input_array_count; i++ )
    {
        phFree(input_array[i]);
    }
    phFree(input_array);

    for (i = 0; i < output_array_count; i++ )
    {
        phFree(output_array[i]);
    }
    phFree(output_array);
    
    /* Free the statistics object */
    rc = ml_class_stats_free(&train_stats);
    phPRINT_RC(rc, NULL, "ml_class_stats_free");
    rc = ml_class_stats_free(&test_stats);
    phPRINT_RC(rc, NULL, "ml_class_stats_free");

    /* Delete the randomized information */
    if (use_random)
    {
        for (i = 0; i < input_array_count; i++ )
        {
            phFree(rand_input_array[i]);
        }
        phFree(rand_input_array);

        for (i = 0; i < output_array_count; i++ )
        {
            phFree(rand_output_array[i]);
        }
        phFree(rand_output_array);

        /* Free the randomized data  statistics object */
        rc = ml_class_stats_free(&rand_train_stats);
        phPRINT_RC(rc, NULL, "ml_class_stats_free");
        rc = ml_class_stats_free(&rand_test_stats);
        phPRINT_RC(rc, NULL, "ml_class_stats_free");
    }

    return phSUCCESS;

error:
    /* Free the processed data */
    for (i = 0; i < input_array_count; i++ )
    {
        phFree(input_array[i]);
    }
    phFree(input_array);

    for (i = 0; i < output_array_count; i++ )
    {
        phFree(output_array[i]);
    }
    phFree(output_array);
 
    /* Free the statistics object */
    rc = ml_class_stats_free(&train_stats);
    phPRINT_RC(rc, NULL, "ml_class_stats_free");
    rc = ml_class_stats_free(&test_stats);
    phPRINT_RC(rc, NULL, "ml_class_stats_free");

    /* Delete the randomized information */
    if (use_random)
    {
        for (i = 0; i < input_array_count; i++ )
        {
            phFree(rand_input_array[i]);
        }
        phFree(rand_input_array);

        for (i = 0; i < output_array_count; i++ )
        {
            phFree(rand_output_array[i]);
        }
        phFree(rand_output_array);

        /* Free the randomized data  statistics object */
        rc = ml_class_stats_free(&rand_train_stats);
        phPRINT_RC(rc, NULL, "ml_class_stats_free");
        rc = ml_class_stats_free(&rand_test_stats);
        phPRINT_RC(rc, NULL, "ml_class_stats_free");
    }

    return phFAIL;
}
    
/* ------------------------------------------------------------------------ */
uint32_t phANNSystem::nodesToString( fann_type *output_nodes,
                                     uint32_t  *string_size,
                                     char      **string )
{
    phFUNCTION("phANNSystem::nodesToString")

    uint32_t    i               = 0;
    uint32_t    active_nodes    = 0;
    uint32_t    pos             = 0;
    uint32_t    len             = 0;
    char        **tags          = NULL;
    uint32_t    ntags           = 0;
    char        *buf            = NULL;

    if ((output_nodes == NULL) || 
        (string_size == NULL) ||
        (string == NULL))
    {
        return 0;
    }
    
    tags = idc_get_tags( this->m_data );
    ntags = idc_get_ntags( this->m_data );

    if (ntags == 0) return 0;

    if (*string == NULL)
    {
        *string = (char *)phCalloc(2,sizeof(char));
        phCHECK_PTR(*string,"phCalloc","phCalloc failed.");
        
        *string_size = 2;
    }
    
    phMemset(*string,0,sizeof(char)*(*string_size));
    
    for (i = 0; (i < this->m_num_output) && (i < ntags); i++ )
    {
        if (output_nodes[i] >= 0.99999F)
        {
            active_nodes++;
            
            if (buf == NULL)
            {
                buf = (char *)phCalloc(256,sizeof(char));
                phCHECK_PTR(buf,"phCalloc","phCalloc failed.");
            }
            
            /* print the string to a buffer */
            snprintf(buf,255,"[%s]",tags[i]);
            
            len += strlen(buf);
            if (*string_size < (len+pos+1))
            {
                /* +1 for the NULL BYTE */
                *string = (char *)phRealloc((*string),(len + 1)*sizeof(char));
                phCHECK_PTR(*string,"phRealloc","phRealloc failed");
                *string_size = len + 1;
            }
            
            sprintf(&((*string)[pos]),"%s",buf);
            
            pos = strlen((*string));
        }
    }
    
    phFree(buf);
    return active_nodes;
error:
    phFree(buf);
    return 0;
}

/* ------------------------------------------------------------------------ */
/* type - 0:ppm w/input_label == prefix of ppm files; prefix_00000.ppm
 *        1:jpg ''
 *        2:video capture w/input_label == device string;"/dev/video0","0"
 */
/* ------------------------------------------------------------------------ */
int phANNSystem::classify( const char     *input_label,
                           const int      input_type,
                           const uint32_t total_files )
{
    phFUNCTION("phANNSystem::classify")

    int retrc = phSUCCESS;

    /* input and output are allocated and populated by this program;
     * actual_output is returned from fann_run and compared against the
     * output_nodes array to determine correctly classified objects */
    uint32_t        input_nodes_count   = 0;
    uint32_t        input_nodes_size    = 0;
    fann_type       *input_nodes        = NULL;
    fann_type       *actual_output      = NULL;

    char       *class_string        = NULL;
    uint32_t    class_string_size   = 0;
    
    float       ratio               = 0.0;
    
    int use_hsvthresh = 0;
    int use_sobel = 0;
    int use_canny = 1;

    int                 loop        = 0;
    uint32_t            filecount   = 0;
    char                *filename   = NULL;
    
    phImage             *input_image= NULL;

    gaussianBlur_Filter *gauss      = NULL;
    meanNxN_Filter      *mean       = NULL;
    medianNxN_Filter    *med        = NULL;
    sobel_Filter        *sobel      = NULL;
    subtract_Filter     *sub        = NULL;
    original_Filter     *orig       = NULL;
    inverse_Filter      *inverse    = NULL;
    convert_Filter      *grey_convert = NULL;
    threshold_Filter    *threshold_grey = NULL;
    threshold_Filter    *thresholdr = NULL;
    threshold_Filter    *thresholdg = NULL;
    threshold_Filter    *thresholdb = NULL;
    hsvthreshold_Filter *hsvthresh  = NULL;
    convert_Filter      *hsvconvert = NULL;
#if PH_HAVE_OPENCV
    cv_canny_Filter     *canny      = NULL;
#else
    canny_Filter        *canny      = NULL;
#endif
    
    phSystem            *system     = NULL;
    phPipeline          *pipeline   = NULL;
    X11Display          *display    = NULL;
    X11Display          *monitor_display    = NULL;
#ifdef WIN32
    VFWSource           *capture    = NULL;
#else
    V4LCapture          *capture    = NULL;
#endif

    int32_t hl = 0;
    int32_t sl = 0;
    int32_t vl = 0;
    int32_t hu = 0;
    int32_t su = 0;
    int32_t vu = 0;
    
    autoblob_Filter *blob       = NULL;
    phAutoBlobData  *blob_data  = NULL;
    uint32_t        minsize     = 150;
    uint32_t        total_blobs = 0;
    
    phautoblob  blobinfo;
    phImage     crop_image;
    uint32_t    i = 0;
    
    /* non-autoblobbing */
    phColor     outcolor    = phColorRGB24_new(0,255,255);

    /* autoblobbing */
    /* for HSV:
     * the SV thresholds effect how well objects with gradients
     * are matched. If the gradient is one direction, an S of 
     * 10 low and 80 high will match gradients where they get 
     * more saturated as they go from the top of the image down.
     * The reverse applies for 80 low and 10 high.
     * The same goes for the V channel where there may be a gradual
     * increase/decrease in the color value and a significant difference
     * in the thresholds will match different gradients better */
    /* For RGB:
     * All the pixel channels can be used the same way as discussed 
     * above. When the lower threshold is less than the upper threshold,
     * then there is a certain type of gradient that is matched. The 
     * gradient is usuallu due to certain lighting. In the case,
     * of the auto blob filter, lower to upper is from top left to bottom
     * right */

#if 0
    /* good for the solid color blocks */
    /* 
    phColor     lower_threshold = phColorHSV24_new(1,1,1);
    phColor     upper_threshold = phColorHSV24_new(1,1,1);
    phColor     loop_threshold  = phColorHSV24_new(0,0,0);
    */
    /* good for the sphere images */
    /*
    phColor     lower_threshold = phColorHSV24_new(8,2,2);
    phColor     upper_threshold = phColorHSV24_new(8,15,11);
    phColor     loop_threshold  = phColorHSV24_new(0,0,0);
    */
#else

/* movie0 */
#if 0
    phColor     lower_threshold = phColorHSV24_new(5,24,25);
    phColor     upper_threshold = phColorHSV24_new(5,84,55);
    phColor     loop_threshold  = phColorHSV24_new(0,0,0);
#endif
/* movie5 */
#if 0
    phColor     lower_threshold = phColorHSV24_new(5,20,25);
    phColor     upper_threshold = phColorHSV24_new(9,55,55);
    phColor     loop_threshold  = phColorHSV24_new(0,0,0);
#endif
#if 0
    phColor     lower_threshold = phColorHSV24_new(3,20,25);
    phColor     upper_threshold = phColorHSV24_new(5,55,55);
    phColor     loop_threshold  = phColorHSV24_new(0,0,0);
#endif
/* Movie 0 with RGB */
#if 1
    phColor     lower_threshold = phColorRGB24_new(15,15,15);
    phColor     upper_threshold = phColorRGB24_new(18,18,18);
    phColor     loop_threshold  = phColorRGB24_new(0,0,0);
#endif
#endif
    
    uint32_t threshold_value = 80;
    
    system          = new phSystem();
    gauss           = new gaussianBlur_Filter();
    mean            = new meanNxN_Filter(3);
    med             = new medianNxN_Filter(3);
    sobel           = new sobel_Filter();
#if PH_HAVE_OPENCV
    //canny           = new cv_canny_Filter(50,175,3);//(40,50);
    canny           = new cv_canny_Filter(94,165,3);
#else
    canny           = new canny_Filter(100,200);
#endif
    sub             = new subtract_Filter();
    grey_convert    = new convert_Filter(phImageGREY8);
    threshold_grey  = new threshold_Filter(0,threshold_value);
    thresholdr      = new threshold_Filter(0,threshold_value);
    thresholdg      = new threshold_Filter(1,threshold_value);
    thresholdb      = new threshold_Filter(2,threshold_value);
    orig            = new original_Filter();
    inverse         = new inverse_Filter();
    blob            = new autoblob_Filter();
    blob_data       = new phAutoBlobData();
    pipeline        = new phPipeline();
    hsvconvert      = new convert_Filter(phImageHSV24);
    hsvthresh       = new hsvthreshold_Filter(  0,  1,  1,
                                                1, 20, 20,
                                              255,250,255);
    if (this->m_no_displays == 0)
    {
        display         = new X11Display();
        monitor_display = new X11Display();
    }

    filename = (char *)phCalloc(513,sizeof(char));
    phCHECK_PTR(filename,"phCalloc","phCalloc failed.");

    if (input_type == 2)
    {
#ifdef WIN32
        capture = new VFWSource();
#else
        capture = new V4LCapture();
#endif
        rc = capture->set(320,240,(char*)input_label);
        phCHECK_RC(rc,NULL,"capture->set");

        rc = pipeline->setLiveSourceInput(capture->getLiveSourceOutput());
        phCHECK_RC(rc,NULL,"pipeline->setLiveSourceInput()");

        rc = system->add(capture);
        phCHECK_RC(rc,NULL,"system->add(capture)");
    }
    else
    {
        input_image     = new phImage();

        rc = pipeline->setLiveSourceInput(input_image);
        phCHECK_RC(rc,NULL,"pipeline->setLiveSourceInput()");
    }

    if (this->m_no_displays == 0)
    {
        rc = display->setLiveSourceInput(pipeline->getLiveSourceOutput());
        phCHECK_RC(rc,NULL,"display->setLiveSourceInput()");

        rc = system->add(display);
        phCHECK_RC(rc,NULL,"system->add(display)");
        
        rc = system->add(monitor_display);
        phCHECK_RC(rc,NULL,"system->add(monitor_display)");
    }

    rc = system->add(pipeline);
    phCHECK_RC(rc,NULL,"system->add(pipeline)");

    rc = pipeline->add(gauss);
    //rc = pipeline->add(mean);
    //rc = pipeline->add(med);
    
    //monitor_display->setLiveSourceInput(input_image);
    monitor_display->setLiveSourceInput(canny->getLiveSourceOutput());
    //monitor_display->setLiveSourceInput(thresholdb->getLiveSourceOutput());
    
    if ((use_sobel) || (use_canny))
    {
        if (use_canny && use_sobel)
        {
            sub->set(3,1,3);
        }
        else
        {
            sub->set(2,1,2);
        }
        rc = pipeline->add(sub);
        rc = pipeline->add(orig);
        if (use_canny)
        {
            rc = pipeline->add(canny);
#if ! PH_HAVE_OPENCV
            rc = pipeline->add(inverse);
#endif
            rc = pipeline->add(sub);
        }
        if (use_sobel)
        {
            if (use_canny) 
            {
                rc = pipeline->add(orig);
            }
            rc = pipeline->add(gauss);
            rc = pipeline->add(sobel);
            rc = pipeline->add(inverse);
#if 0
            rc = pipeline->add(grey_convert);
            rc = pipeline->add(threshold_grey);
            rc = pipeline->add(gauss);
#endif
#if 1
            rc = pipeline->add(thresholdr);
            rc = pipeline->add(thresholdg);
            rc = pipeline->add(thresholdb);
#endif
            //rc = pipeline->add(canny);
            rc = pipeline->add(sub);

        }
    }
    
    if (use_hsvthresh)
    {
        rc = pipeline->add(hsvconvert);
        rc = pipeline->add(hsvthresh);
    }
    rc = pipeline->add(blob);

    rc = blob->setThresholds(lower_threshold,
                             upper_threshold,
                             loop_threshold);
    rc = blob->setAutoBlob();
    //rc = blob->setOutcolor(outcolor);
    //rc = blob->setDrawRects(1);
    rc = blob->setColorBlobs(1);
    rc = blob->setColorMinSize(minsize);

    /* connect the blob data to the blob's data output */
    rc = blob_data->connect(blob->getLiveBlobOutput());
    phPRINT_RC(rc,NULL,"blob_data->connect");

    rc = this->createNetwork();
    phPRINT_RC(rc,NULL,"this->createNetwork()");
    
    rc = this->startup();
    phPRINT_RC(rc,NULL,"this->startup");
    
    rc = system->startup();
    phCHECK_RC(rc,NULL,"system->startup()");

    while (((system->displaysOpen() > 0)) || (this->m_no_displays))
    {
        if (input_type < 2)
        {
            if (filecount == 0)
            {
                //filecount = 10;
            }

            sprintf(filename,
                    "%s_%04u.%s",
                    input_label,
                    filecount,
                    input_type == 1 ? "jpg" : "ppm");

            rc = input_image->load(filename);
            phCHECK_RC(rc,NULL,"input_image->load(%s)",filename);

            rc = blob_data->update();
            phPRINT_RC(rc,NULL,"blob_data");
            
            if ((total_blobs = blob_data->getTotalBlobs(minsize)) > 0)
            {
                blobinfo = blob_data->getBlob(0);
                phPRINT("Total Blobs: %5u %5d:( %3d, %3d; %3d, %3d ) ( %3d x %3d )\n",
                        blob_data->getTotalBlobs(minsize),
                        blobinfo.mass,
                        blobinfo.x1,
                        blobinfo.y1,
                        blobinfo.x2,
                        blobinfo.y2,
                        blobinfo.w,
                        blobinfo.h
                        );
                for (i = 0; i < total_blobs; i++ )
                {
                    /* The the information on the blob */
                    blobinfo = blob_data->getBlob(i);

                    /* Crop the blob out from the input image */
                    rc = crop_image.crop(*input_image,
                            blobinfo.x1 - 6,
                            blobinfo.y1 - 6,
                            blobinfo.x2 + 6, 
                            blobinfo.y2 + 6);
                    phPRINT_RC(rc,NULL,"crop_image.crop");

                    /* Get the ratio of the blobs w/h for input */
                    ratio = crop_image.getWidth() / crop_image.getHeight();

                    /* don't resize the image */
#if 0
                    rc = crop_image.resize(this->m_width,this->m_height);
                    phPRINT_RC(rc,NULL,"crop_image.resize(%u,%u)",
                               this->m_width,this->m_height);
#endif
                    rc = this->setInputImage( crop_image, ratio );
                    phPRINT_RC(rc,NULL,"this->setInputImage(crop_image,ratio)");
                    
                    rc = this->getInputNodes( &input_nodes_count,/* uint32_t *    */
                                              &input_nodes_size, /* uint32_t *    */
                                              &input_nodes       /* fann_type **  */ );
                    phPRINT_RC(rc,NULL,"this->getInputNodes()");
                    
                    actual_output = fann_run(this->m_ann, input_nodes);

                    rc = this->nodesToString(actual_output,
                                             &class_string_size,
                                             &class_string);
                    /* rc == number of active nodes */                       
                    if (rc)
                    {
                        phPRINT("%s\n",class_string);
                        snprintf(filename,512,"blobs/file%05d_blob%06d_%s.ppm",
                                filecount, i, class_string);
                    }
                    else
                    {
                        snprintf(filename,512,"blobs/file%05d_blob%06d_[unknown].ppm",
                                filecount, i );
                    }
                    crop_image.save(filename);
                }
            }
            else
            {
                phPRINT("Total Blobs: %5u mass_:( x1x, y1y; x2x, y2y ) ( www x hhh )\n",
                        blob_data->getTotalBlobs(minsize));
            }

            if (total_files > 10)
                filecount += 5;
            else
                filecount += 1;
            
            if (filecount >= total_files)
            {
                if (loop)
                    filecount = 0;
                else
                    system->stopDisplays();
            }

            //phUSleep(1333333);
        }
    }

    goto success;
error:
    retrc = phFAIL;
success:
    
    rc = this->shutdown();
    phPRINT_RC(rc,NULL,"this->shutdown");
    
    rc = this->destroyNetwork();
    phPRINT_RC(rc,NULL,"this->destroyNetwork()");
    
    rc = system->shutdown();
    phPRINT_RC(rc,NULL,"system->shutdown()");

    phFree(input_nodes);
    phFree(class_string);

    phDelete(input_image);
    phDelete(system);
    phDelete(gauss);
    phDelete(mean);
    phDelete(med);
    phDelete(sobel);
    phDelete(grey_convert);
    phDelete(threshold_grey);
    phDelete(thresholdr);
    phDelete(thresholdg);
    phDelete(thresholdb);
    phDelete(canny);
    phDelete(inverse);
    phDelete(sub);
    phDelete(orig);
    phDelete(hsvconvert);
    phDelete(hsvthresh);
    phDelete(blob);
    phDelete(blob_data);
    phDelete(pipeline);
    phDelete(display);
    phDelete(monitor_display);
    phFree(filename);

    return retrc;
}

Copyright (C) 2002 - 2007

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

---