meanBlur_Filter.cpp

Go to the documentation of this file.

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

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

 ---------------------------------------------------------------------------
    <Add other copyrights here> 
 ---------------------------------------------------------------------------

    This file is part of Phission.

    Phission is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Phission is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Phission; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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

#include <phStandard.h>

#include <meanBlur_Filter.h>

#include <phError.h>
#include <phMemory.h>
#include <phPrint.h>

/* ---------------------------------------------------------------------- */
meanBlur_Filter::meanBlur_Filter(uint32_t kernel_size) :
    phFilter("meanBlur_Filter")

{
    this->m_format = (phImageRGB24    | 
                      phImageBGR24    |
                      phImageRGBA32   | 
                      phImageABGR32   |
                      phImageHSV24    |
                      phImageGREY8);

    this->m_average = NULL;
    this->m_average_size = 0;
    this->m_kernel_size = 3;
    
    this->set(kernel_size);
}

/* ---------------------------------------------------------------------- */
meanBlur_Filter::~meanBlur_Filter()
{
    phFree(this->m_average);
}

/* ------------------------------------------------------------------------ */
phFilter *meanBlur_Filter::cloneFilter()
{
    return (phFilter *)new meanBlur_Filter(this->m_kernel_size);
}

/* ---------------------------------------------------------------------- */
int meanBlur_Filter::set(uint32_t kernel_size)
{
    if(kernel_size < 3)
    {
        kernel_size = 3;
    }
    else if(kernel_size % 2 == 0) 
    {
        this->m_kernel_size = kernel_size - 1;
    }
    else
    {
        this->m_kernel_size = kernel_size;
    }

    return phSUCCESS;
}

/* ---------------------------------------------------------------------- */
int meanBlur_Filter::filter()
{
    phFUNCTION("meanBlur_Filter::filter")

    uint32_t w  = 0;
    uint32_t h  = 0;
    uint32_t d  = 0;
    
    int32_t i   = 0;
    int32_t j   = 0;
    int32_t side= 0;

    uint32_t kernelSquared  = 0;
    uint32_t pixel          = 0;
    uint32_t heightBound    = 0;
    uint32_t widthBound     = 0;
    uint32_t row            = 0;

    phDALLOC_RESIZE(this->m_average,
                    this->m_average_size,
                    depth,
                    uint32_t);

    kernelSquared = this->m_kernel_size * this->m_kernel_size;

    /* Begin filter */
    
    side = (uint32_t)(this->m_kernel_size - 1) / 2;
    heightBound = height - side;
    widthBound = width - side;

    for ( h = side; h < heightBound; h++ )
    {
        for ( w = side; w < widthBound; w++ )
        {
            /* reset average */
            phMemset(this->m_average,0,depth*sizeof(uint32_t));
            
            /* calculate average color of surrounding pixels*/
            for ( i = -side; i <= side; i++ )
            {
                row = (uint32_t)((h+i) * width);
                for ( j = -side; j <= side; j++ )
                {       
                    pixel = (uint32_t)((row + (w+j)) * depth);
                    for( d = 0; d < depth; d++ )
                    {
                        this->m_average[d] += (Image)[pixel + d];
                    }
                }
            }

            pixel = (h * width + w) * depth;
            for(d = 0; d < depth; d++)
            {
                (Image)[pixel + d] = this->m_average[d] / (kernelSquared);
            }
        }
    }

    /* end filter */

    return phSUCCESS;
error:
    return phFAIL;
}

Copyright (C) 2002 - 2007

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

---