ave_Filter.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission :
        Realtime Vision Processing System

    Copyright (C) 2003 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics

    This file is part of Phission.

 ---------------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
    #include <phissionconfig.h>
#endif
#include <string.h>
#include <ave_Filter.h>
#include <phbase.h>

/* ---------------------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
ave_Filter::ave_Filter(uint32_t nFrames,
                       uint32_t frame_step ) :
    phFilter("ave_Filter")

{
    this->m_nFrames = 2;
    this->m_frame_step = 1;
    this->m_total_stored = 0;
    this->m_first_frame_index = 0;
    this->m_current_frame_index = 0;
    
    this->m_frame_elems = 0;
    this->m_frame_size = 0;
    
    this->m_imgptrs = NULL;
    this->m_imgptrs_size = 0;
    this->m_buffer = NULL;
    this->m_buffer_size = 0;
    this->m_outputBuffer = NULL;
    this->m_outputBuffer_size = 0;

    this->m_last_result = NULL;
    this->m_last_result_size = 0;
    this->m_last_result_weight = NULL;
    this->m_last_result_weight_size = 0;

    this->m_temp = NULL;
    this->m_temp_size = 0;

    this->m_buf_height = 0;
    this->m_buf_width = 0;
    this->m_buf_depth = 0;
    this->m_buf_format = phImageNOFORMAT;
    this->m_buf_nframes = 2;
    this->m_buf_step = 1;

    
    this->m_format = phImageRGB24 | phImageRGBA32 | phImageBGR24 | phImageABGR32 |
                     phImageGREY8 | phImageHSV24;
    this->set(nFrames,frame_step);
}

/* ---------------------------------------------------------------------- */
ave_Filter::~ave_Filter()
{
    phFree(this->m_temp);
    phFree(this->m_last_result);
    phFree(this->m_last_result_weight);
    phFree(this->m_buffer);
    phFree(this->m_imgptrs);
}

/* ------------------------------------------------------------------------ */
phFilter *ave_Filter::cloneFilter()
{
    return (phFilter *)new ave_Filter(this->m_nFrames,this->m_frame_step);
}

/* ---------------------------------------------------------------------- */
int ave_Filter::set( uint32_t nFrames,
                          uint32_t frame_step )
{
    phFUNCTION("ave_Filter::set")

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

    if (frame_step > nFrames)
        nFrames = frame_step;
        
    this->m_nFrames = nFrames;
    this->m_frame_step = frame_step;
    
    rc = this->unlock();
    phPRINT_RC(rc,NULL,"this->unlock()");
    
    return phSUCCESS;
}
/* ---------------------------------------------------------------------- */
/* this method resets all the variables required to start the filter anew */
/* ---------------------------------------------------------------------- */
int ave_Filter::flush()
{
    phFUNCTION("ave_Filter::flush")

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

    /* erased the buffers and reset all the vars */
    this->check_buffers(1);
    
    rc = this->unlock();
    phPRINT_RC(rc,NULL,"this->unlock()");

    return phSUCCESS;
}

/* ---------------------------------------------------------------------- */
/* This function checks to make sure the buffers have been initialized
 * and allocates memory if they haven't. This also checks to see if the
 * size of the image has changed: if it has, then it has to flush the 
 * buffers. */
/* ---------------------------------------------------------------------- */
int ave_Filter::check_buffers(uint32_t alloc)
{
    phFUNCTION("ave_Filter::check_buffers")
    uint32_t i = 0;

    /* check to see if the buffer needs to be allocated */
    if (this->m_buffer == NULL)
    {
        alloc = 1;
    }
    /* Check to see if one of the parameters has changed */
    else if ((this->m_buf_height != height) ||
             (this->m_buf_width != width) ||
             (this->m_buf_depth != depth) || 
             (this->m_buf_format != format) ||
             (this->m_buf_nframes != this->m_nFrames) || 
             (this->m_buf_step != this->m_frame_step))
    {
        alloc = 1;
    }
    
    /* height, width and depth are set by 'process' */
    if (((height > 0) && (width > 0) && (depth > 0)) && (alloc))
    {
        this->m_frame_elems = height * width * depth;
        
        this->m_buf_height = height;
        this->m_buf_width = width;
        this->m_buf_depth = depth;
        this->m_buf_format = format;
        this->m_buf_nframes = this->m_nFrames;
        this->m_buf_step = this->m_frame_step;
        
        phDALLOC_RESIZE(this->m_last_result,
                        this->m_last_result_size,
                        this->m_frame_elems,
                        double);
        
        phDALLOC_RESIZE(this->m_last_result_weight,
                        this->m_last_result_size,
                        this->m_buf_nframes,
                        double);
        
        phDALLOC_RESIZE(this->m_temp,
                        this->m_temp_size,
                        this->m_frame_elems,
                        uint8_t);
        
        /* allocate one chunk of memory for all the stored frame buffers
         * being differenced */
        phDALLOC( this->m_buffer,
                  this->m_buffer_size,
                  (this->m_frame_elems * this->m_buf_nframes),
                  uint8_t);
        phDALLOC( this->m_imgptrs,
                  this->m_imgptrs_size,
                  this->m_buf_nframes,
                  uint8_t * );
        
        this->m_frame_size = this->m_frame_elems * sizeof(uint8_t);
        
        for (i = 0; i < this->m_nFrames; i++)
        {
            this->m_imgptrs[i] = this->m_buffer + 
                                 (this->m_frame_size * i);
        }

/* Not being used; If one decides they want to use this, instead of writing
 * to Image below (in the 'filter') function, write to this buffer and then
 * maybe phMemcpy to Image */
/*
        phDALLOC( this->m_outputBuffer,
                  this->m_outputBuffer_size,
                  this->m_frame_elems,
                  uint8_t );
*/        
        /* preping the filter to wait for nFrames again before differencing 
         * those frames.
         * Need to reset this if we've reallocated buffers. Something TODO
         * might be to find out if this is really necessary or a 
         * way to allow reallocation without complete reset. Currently,
         * this is just being super-extra-doubly sure things work right
         * by limiting the filter with such an action. */
        this->m_total_stored = 0;
        this->m_first_frame_index = 0;
        this->m_current_frame_index = 0;
    }
    
    return phSUCCESS;
error:
    return phFAIL;
}

/* ---------------------------------------------------------------------- */
/* 'process' locks the object before calling 'filter' */
/* ---------------------------------------------------------------------- */
int ave_Filter::filter()
{
    phFUNCTION("ave_Filter::filter")
    uint32_t i = 0;
    uint32_t j = 0;
    uint32_t index = 0;
    double X = 0;
    
    double  weight = 0.0;
    int32_t oldest_index    = 0;
    uint8_t *oldest_frame = NULL;
    double  oldest_weight   = 0.0;

    /* defined before being called:
     *  width
     *  height
     *  depth
     *  Image
     */

    /* 0.) Allocate the required space to store up nFrames before 
     * differencing them */
    this->check_buffers();
    
    /* Begin Filter */
    
    /* copy the current frame into the buffer and adjust the 
     * index pointers to the first and last frames */
    phMemcpy(this->m_temp,
             Image,
             this->m_frame_size);
    
    weight = (1.0 / ((double)this->m_buf_nframes));   
    oldest_index = ((int32_t)this->m_current_frame_index + 1) % this->m_buf_nframes;
    oldest_weight = this->m_last_result_weight[oldest_index];
    oldest_frame = this->m_imgptrs[oldest_index];

    for (j = 0; j < this->m_frame_elems; j++)
    {
        X = this->m_last_result[j];
        X -= (((double)oldest_frame[j]) * oldest_weight);
        X += (((double)Image[j])) * weight;
        
        this->m_last_result[j] = X;
        
        X = (X > 255) ? 255 : X;
        Image[j] = (uint8_t)X;
    }    

    this->m_last_result_weight[this->m_current_frame_index] = weight;
        
    /* copy the current frame into the buffer and adjust the 
     * index pointers to the first and last frames */
    phMemcpy(this->m_imgptrs[this->m_current_frame_index],
             this->m_temp,
             this->m_frame_size);
    
    this->m_current_frame_index = (this->m_current_frame_index+1) %
                                   this->m_buf_nframes;
    
    /* End Filter */
    
    /* make sure to free up any space here, not including Image */
    
    return phSUCCESS;
#if 0
error:
    /* make sure to free up any space here, not including Image */
    
    return phFAIL;
#endif
}

Copyright (C) 2002 - 2007

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

---