FeatureImage.h

Go to the documentation of this file.

#ifndef FeatureImage_H
#define FeatureImage_H

#include <vector>
#include <cstdlib>

#include "SingleElementImage.h"
#include "Feature.h"
#include "GrayLevelImage8.h"

namespace puma2 {

template <typename T> class FeatureImage : public SingleElementImage<T> {

    private:

        void createMask(int radius, bool **(&mask));

    public:

        FeatureImage(int x = 0, int y = 0)
            : SingleElementImage<T>(x,y) {}

        FeatureImage(int x, int y, FeatureImage * m, int xo, int yo)
            : SingleElementImage<T>(x,y,m,xo,yo) {}

        virtual ~FeatureImage() {}


        Feature<T> getGlobalMaximum();


        std::vector<Feature<T> > getGlobalMaxima(int n);


        Feature<T> getGlobalMinimum();


        std::vector<Feature<T> > getGlobalMinima(int n);


        std::vector<Feature<T> > getLocalMinima(int n, T threhold, int radius);


        std::vector<Feature<T> > getLocalMinima(T thresh, int radius);


        std::vector<Feature<T> > getLocalMaxima(int n, T threshold, int radius);


        std::vector<Feature<T> > getLocalMaxima(T threshold, int radius);


        virtual GrayLevelImage8 getGrayLevelImageRepresentation() = 0;

};


/*******************************************************************************
 * Returns the maximum of the given image.
 ******************************************************************************/
template <typename T> Feature<T> FeatureImage<T>::getGlobalMaximum()
{
    int h = this->getHeight();
    int w = this->getWidth();

    Feature<T> max;

    max.x   = 0;
    max.y   = 0;
    max.val = &(this->c0[0][0]);

    for (int y = 0; y < h; ++y)
    {
        for (int x = 0; x < w; ++x)
        {
            T *tmp = &(this->c0[y][x]);
            if ( (*max.val) < (*tmp) )
            {
                max.x   = x;
                max.y   = y;
                max.val = tmp;
            }
        }
    }

    return max;
}


/*******************************************************************************
 * Returns the n maxima of the given image.
 ******************************************************************************/
template <typename T> std::vector<Feature<T> > FeatureImage<T>::getGlobalMaxima(int n)
{
    int h = this->getHeight();
    int w = this->getWidth();

    assert (w*h >= n);

    std::vector<Feature<T> > maxima;
    maxima.resize(n);

    // Store if the current slot has already been written. This temporary vector
    // replaces an initialization of all slots with maximum elements which in
    // fact cannot be done with such features like edges.
    std::vector<bool> isSet(n,false);

    for (int y = 0; y < h; ++y)
    {
        for (int x = 0; x < w; ++x)
        {
            T *tmp = &(this->c0[y][x]);
            if ( !isSet[0] || ( (*maxima[0].val) < *tmp ) )
            {
                int i=1;
                while ( (i < n) && (!isSet[i] || ( *maxima[i].val) < *tmp ) )
                    ++i;
                --i;
                for (int j=0; j<i; ++j)
                {
                    maxima[j].x   = maxima[j+1].x;
                    maxima[j].y   = maxima[j+1].y;
                    maxima[j].val = maxima[j+1].val;
                }
                maxima[i].x   = x;
                maxima[i].y   = y;
                maxima[i].val = tmp;
                isSet [i]     = true;
            }
        }
    }

    return maxima;
}


/*******************************************************************************
 * Returns the minimum of the given image.
 ******************************************************************************/
template <typename T> Feature<T> FeatureImage<T>::getGlobalMinimum()
{
    int h = this->getHeight();
    int w = this->getWidth();

    Feature<T> min;

    min.x   = 0;
    min.y   = 0;
    min.val = &(this->c0[0][0]);
    for (int y = 0; y < h; ++y) {
        for (int x = 0; x < w; ++x)
        {
            T *tmp = &(this->c0[y][x]);
            if ( *tmp < (*min.val) )
            {
                min.x   = x;
                min.y   = y;
                min.val = tmp;
            }
        }
    }

    return min;
}


/*******************************************************************************
 * Returns the n minima of the given image.
 ******************************************************************************/
template <typename T> std::vector<Feature<T> > FeatureImage<T>::getGlobalMinima(int n)
{
    int h = this->getHeight();
    int w = this->getWidth();

    assert (w*h >= n);

    std::vector<Feature<T> > minima;
    minima.resize(n);

    // Store if the current slot has already been written. This temporary vector
    // replaces an initialization of all slots with minimum elements which in
    // fact cannot be done with such features like edges.
    std::vector<bool> isSet(n,false);

    for (int y=0; y<h; ++y)
    {
        for (int x=0; x<w; ++x)
        {
            T *tmp = &(this->c0[y][x]);
            if ( !isSet[0] || ( *tmp < (*minima[0].val) ) )
            {
                int i=1;
                while ( (i < n) && (!isSet[i] ||  *tmp < (*minima[i].val) ) )
                    ++i;
                for (int j = --i; j > 0; --j)
                {
                    minima[j-1].x   = minima[j].x;
                    minima[j-1].y   = minima[j].y;
                    minima[j-1].val = minima[j].val;
                }
                minima[i].x   = x;
                minima[i].y   = y;
                minima[i].val = tmp;
                isSet [i]     = true;
            }
        }
    }

    return minima;
}



/*******************************************************************************
 * Returns a vector of n local maxima of the actual image.
 ******************************************************************************/
template <typename T> std::vector<Feature<T> > FeatureImage<T>::getLocalMaxima(int n,
    T thresh, int radius)
{
    int h = this->getHeight();
    int w = this->getWidth();

    assert (w*h >= n);

    std::vector<Feature<T> > maxima;
    maxima.resize(n);

    // Create the mask that will be used for defining locality.
    bool **mask;
    createMask(radius, mask);


    // Store if the current slot has already been written. This temporary vector
    // replaces an initialization of all slots with maximum elements which in
    // factcannot be done with such features like edges.
    std::vector<bool> isSet(n,false);


    for (int y = 0; y < h; ++y)
    {
        for (int x=0; x<w; ++x)
        {
            bool isMax = true;
            T * val = &(this->c0[y][x]);
            for (int i = -radius; ( i <= radius ) && isMax; ++i)
            {
                for (int j = -radius; (j <= radius) && isMax; ++j)
                {
                    if ( (mask[i][j]) && ( j!= 0 || i != 0) &&
                         ( y + i >= 0 && y + i < h ) &&
                         ( x + j >= 0 && x + j < w ) )
                        isMax &= ( *val >= this->c0[y+i][x+j] && *val > thresh);
                }
            }
            if (isMax)
            {
                T *tmp = &(this->c0[y][x]);
                if ( !isSet[0] || ( (*maxima[0].val) < *tmp ) )
                {
                    int i=1;
                    while ( (i < n) && (!isSet[i] || (*maxima[i].val) <  *tmp ))
                        ++i;
                    --i;
                    for (int j=0; j<i; ++j)
                    {
                        maxima[j].x   = maxima[j+1].x;
                        maxima[j].y   = maxima[j+1].y;
                        maxima[j].val = maxima[j+1].val;
                    }
                    maxima[i].x   = x;
                    maxima[i].y   = y;
                    maxima[i].val = tmp;
                    isSet [i]     = true;
                }
            }
        }
    }

    return maxima;
}



/*******************************************************************************
 * Returns a vector of all local maxima of the actual image.
 ******************************************************************************/
template <typename T> std::vector<Feature<T> > FeatureImage<T>::getLocalMaxima(T thresh,
    int radius)
{
    int h = this->getHeight();
    int w = this->getWidth();

    // Create the mask that will be used for defining locality.
    bool **mask;
    createMask(radius, mask);

    std::vector<Feature<T> > maxima;

    for (int y = 0; y < h; ++y)
    {
        for (int x = 0; x < w; ++x)
        {
            bool isMax = true;
            T * val = &(this->c0[y][x]);
            for (int i = -radius; (i <= radius) && isMax; ++i)
            {
                for (int j = -radius; (j <= radius) && isMax; ++j)
                {
                    if ( (mask[i][j]) && (j != 0 || i != 0) &&
                         (y + i >= 0 && y + i < h) &&
                         (x + j >= 0 && x + j < w))
                        isMax &= (*val >= this->c0[ y + i ][ x + j ] &&
                                  *val > thresh);
                }
            }
            if (isMax)
            {
                Feature<T> feat;
                feat.x   = x;
                feat.y   = y;
                feat.val = &(this->c0[y][x]);
                maxima.push_back(feat);
            }
        }
    }

    return maxima;
}



/*******************************************************************************
 * Returns a vector of n local minima of the actual image.
 ******************************************************************************/
template <typename T> std::vector<Feature<T> > FeatureImage<T>::getLocalMinima(int n,
    T thresh, int radius)
{
    int h = this->getHeight();
    int w = this->getWidth();

    assert (w*h >= n);

    std::vector<Feature<T> > minima;
    minima.resize(n);

    // Create the mask that will be used for defining locality.
    bool **mask;
    createMask(radius, mask);


    // Store if the current slot has already been written. This temporary vector
    // replaces an initialization of all slots with minimum elements which in
    // fact cannot be done with such features like edges.
    std::vector<bool> isSet(n,false);


    for (int y = 0; y < h; ++y)
    {
        for (int x = 0; x < w; ++x)
        {
            bool isMin = true;
            T * val = &(this->c0[y][x]);
            for (int i = -radius; (i <= radius) && isMin; ++i)
            {
                for (int j = -radius; (j <= radius) && isMin; ++j)
                {
                    if ( (mask[i][j]) && (j != 0 || i != 0) &&
                         (y + i >= 0 && y + i < h) &&
                         (x + j >= 0 && x + j < w))
                        isMin &= (*val <= this->c0[ y + i ][ x + j ] &&
                                  *val < thresh);
                }
            }
            if (isMin) {
                T *tmp = &(this->c0[y][x]);
                if ( !isSet[0] || ( (*minima[0].val) > *tmp ) )
                {
                    int i=1;
                    while ( (i < n) && (!isSet[i] || (*minima[i].val) > *tmp ) )
                        ++i;
                    --i;
                    for (int j = 0; j < i; ++j)
                    {
                        minima[j].x   = minima[ j + 1 ].x;
                        minima[j].y   = minima[ j + 1 ].y;
                        minima[j].val = minima[ j + 1 ].val;
                    }
                    minima[i].x   = x;
                    minima[i].y   = y;
                    minima[i].val = tmp;
                    isSet [i]     = true;
                }
            }
        }
    }

    return minima;
}


/*******************************************************************************
 * Returns a vector of all local minima of the actual image.
 ******************************************************************************/
template <typename T> std::vector<Feature<T> > FeatureImage<T>::getLocalMinima(T thresh,
    int radius)
{
    int h = this->getHeight();
    int w = this->getWidth();

    std::vector<Feature<T> > minima;

    // Create the mask that will be used for defining locality.
    bool **mask;
    createMask(radius, mask);

    for (int y = 0; y < h; ++y)
    {
        for (int x = 0; x < w; ++x)
        {
            bool isMin = true;
            T * val = &(this->c0[y][x]);
            for (int i = -radius; (i <= radius) && isMin; ++i)
            {
                for (int j = -radius; (j <= radius) && isMin; ++j)
                {
                    if ( (mask[i][j]) && (j != 0 || i != 0) &&
                         (y + i>= 0 && y + i < h) && (x + j >= 0 && x + j < w))
                        isMin &= (*val <= this->c0[y+i][x+j] && *val < thresh);
                }
            }
            if (isMin)
            {
                Feature<T> feat;
                feat.x   = x;
                feat.y   = y;
                feat.val = &(this->c0[y][x]);
                minima.push_back(feat);
            }
        }
    }

    return minima;
}



/*******************************************************************************
 * Creates a binary mask for defining a local neighborhood.
 ******************************************************************************/
template <typename T> void FeatureImage<T>::createMask(int radius, bool **(&mask))
{
    int size = 2*radius+1;
    int radius21 = radius * radius + 1;

    mask = (bool**) calloc(size, sizeof(bool*)) + radius;

    for(int y = -radius; y <= radius; ++y)
    {
        *(mask+y) = (bool*) calloc(size, sizeof(bool)) + radius;
        for (int x = -radius; x <= radius; ++x)
        {
            if (radius21 >= x * x + y * y)
                mask[y][x] = true;
            else
                mask[y][x] = false;
        }
    }
}

} // end of namespace

#endif