hsvthreshold_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

    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 <hsvthreshold_Filter.h>

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

/* ---------------------------------------------------------------------- */
/* h,s,v : active threshold arguments
 * l* : lower threshold ; u* : upper threshold */
hsvthreshold_Filter::hsvthreshold_Filter(uint32_t h,  uint32_t s,  uint32_t v,
                                         uint32_t h1, uint32_t s1, uint32_t v1,
                                         uint32_t h2, uint32_t s2, uint32_t v2) :
    phFilter("hsvthreshold_Filter")

{
    this->m_format = phImageHSV24;
    this->set(h,s,v,h1,s1,v1,h2,s2,v2);
}

/* ---------------------------------------------------------------------- */
hsvthreshold_Filter::~hsvthreshold_Filter()
{
}

/* ------------------------------------------------------------------------ */
phFilter *hsvthreshold_Filter::cloneFilter()
{
    return (phFilter *)new hsvthreshold_Filter(this->m_h, this->m_s, this->m_v,
                                               this->m_h1,this->m_s1,this->m_v1,
                                               this->m_h2,this->m_s2,this->m_v2 );
}

/* ---------------------------------------------------------------------- */
int hsvthreshold_Filter::set(uint32_t h,  uint32_t s,  uint32_t v,
                             uint32_t h1, uint32_t s1, uint32_t v1,
                             uint32_t h2, uint32_t s2, uint32_t v2)
{

    this->m_h = h;
    this->m_s = s;
    this->m_v = v;
    
    this->m_h1 = h1;
    this->m_s1 = s1;
    this->m_v1 = v1;
    
    this->m_h2 = h2;
    this->m_s2 = s2;
    this->m_v2 = v2;

    return phSUCCESS;
}

/* ---------------------------------------------------------------------- */
int hsvthreshold_Filter::filter()
{
    phFUNCTION("hsvthreshold_Filter::filter")
    
    unsigned int i = 0;
    
    int32_t h_step = 16;
    int32_t s_step = 40;
    int32_t v_step = 30;

    uint8_t hi = 0;
    uint8_t si = 0;
    uint8_t vi = 0;
    uint8_t h = 0;
    uint8_t s = 0;
    uint8_t v = 0;
    
    uint8_t *imgptr = Image;
    const uint32_t limit = width * height;
    
    phImageFormatIndecies(this->format,&hi,&si,&vi,NULL);
    
    /* Begin filter */

    if ((!(this->format & phImageHSV24)) || (imgptr == NULL))
        return phSUCCESS;
        
    for (i = 0; i < limit; i++, imgptr += depth)
    {
        h = imgptr[hi];
        s = imgptr[si]; 
        v = imgptr[vi]; 
        
        /* Check to see if Saturation is being thresholded and set it to 0 if
         * it's out of bounds */
        if (this->m_s)
        {
            if (this->m_s1 > this->m_s2)
            {
                if ((s > this->m_s1) || (s < this->m_s2)) h = s = v = 0;
            }
            else
            {
                if ((s >= this->m_s1) && (s <= this->m_s2)) h = s = v = 0;
            }
            if (this->m_s == hsvthreshold_Group)
                s = (s - (s % s_step)) + (s_step / 2);
        }
        /* Check to see if Value is being thresholded and set the pixel to
         * 0 if it's out of the bounds */
        if (this->m_v)
        {
            if (this->m_v1 > this->m_v2)
            {
                if ((v > this->m_v1) || (v < this->m_v2)) h = s = v = 0;
            }
            else
            {
                if ((v >= this->m_v1) && (v <= this->m_v2)) h = s = v = 0;
            }
            if (this->m_v == hsvthreshold_Group)
                v = (v - (v % v_step)) + (v_step / 2);
        }
        
        /* Threshold Hue */
        if (this->m_h)
        {
            if (this->m_h1 > this->m_h2)
            {
                if ((h > this->m_h1) || (h < this->m_h2)) h = s = v = 0;
            }
            else
            {
                if ((h >= this->m_h1) && (h <= this->m_h2)) h = s = v = 0;
            }
            
            /* If Hue is being thresholded and Saturation/Value have non-zero values
             * then we will group the hues together */
            if ((this->m_h == hsvthreshold_Group) && (s > 0) && (v > 0))
                h = (h - (h % h_step)) + (h_step / 2);
        }
        imgptr[hi] = h;
        imgptr[si] = s;
        imgptr[vi] = v;
    }

    /* End Filter */

    return phSUCCESS;
}

Copyright (C) 2002 - 2007

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

---