NICE_VisLearning/features/fpfeatures/ConvolutionFeature.cpp

/**
* @file ConvolutionFeature.cpp
* @brief convolutional feature
* @author Sven Sickert
* @date 10/13/2008

*/
#include <iostream>

#include "ConvolutionFeature.h"
#include "vislearning/cbaselib/FeaturePool.h"

using namespace OBJREC;

using namespace NICE;

/* Convolutional feature consists of shift parameter beta[0] and the
   convolutional mask, which is stored in the rest of the parameter vector
   beta */


/** simple constructor */
ConvolutionFeature::ConvolutionFeature ( )
{
    window_size_x = 15;
    window_size_y = 15;
    isColor = false;
    useSpatialPriors = false;

    initializeParameterVector();
}

/** alternative constructor */
ConvolutionFeature::ConvolutionFeature (
        const int wsize_x,
        const int wsize_y,
        const bool color )
{
    window_size_x = wsize_x;
    window_size_y = wsize_y;
    isColor = color;
    useSpatialPriors = false;

    initializeParameterVector();
}

/** default constructor */
ConvolutionFeature::ConvolutionFeature ( const Config *conf )
{
    std::string section = "ConvolutionFeature";
    window_size_x = conf->gI ( section, "window_size_x", 15 );
    window_size_y = conf->gI ( section, "window_size_y", 15 );
    isColor = conf->gB ( section, "is_color", false );
    useSpatialPriors = conf->gB ( section, "use_spatial_priors", false );

    initializeParameterVector();
}

/** copy constructor */
ConvolutionFeature::ConvolutionFeature ( const ConvolutionFeature *confFeat )
{
    window_size_x = confFeat->window_size_x;
    window_size_y = confFeat->window_size_y;
    betaLength = confFeat->betaLength;
    isColor = confFeat->isColor;
    useSpatialPriors = confFeat->useSpatialPriors;
    numChannels = confFeat->numChannels;
    beta = new NICE::Vector( betaLength, 0.0 );

    int i = 0;
    for ( NICE::Vector::iterator it = confFeat->beta->begin();
          it != confFeat->beta->end(); ++it, i++ )
    {
        beta[i] = *it;
    }
}

/** simple destructor */
ConvolutionFeature::~ConvolutionFeature ( )
{

}


/** (re)initialize parameter vector */
void ConvolutionFeature::initializeParameterVector()
{
    if (window_size_x > 0 && window_size_y > 0)
    {
        if (isColor)
            numChannels = 3;
        else
            numChannels = 1;

        betaLength = numChannels*window_size_x*window_size_y + 1;

        if (useSpatialPriors) betaLength += 2;

        beta = new NICE::Vector( betaLength, (1.0/(double)(betaLength-1) ) );
        beta[0] = 1;
    }
    else
        std::cerr << "ConvolutionFeature::initializeVector: Size of window is Zero! Could not initialize..."
                  << std::endl;
}

bool ConvolutionFeature::isColorMode() const
{
    return isColor;
}

/** return parameter vector */
NICE::Vector ConvolutionFeature::getParameterVector() const
{
    NICE::Vector res = (*this->beta);
    return res;
}

/** return feature vector */
NICE::Vector ConvolutionFeature::getFeatureVector( const Example *example ) const
{
    NICE::Vector vec(betaLength, 1.0);

    NICE::MultiChannelImageT<double> * imgD = NULL;
    imgD = & example->ce->getDChannel( CachedExample::D_EOH );

    int xsize, ysize, x, y;

    example->ce->getImageSize( xsize, ysize );
    x = example->x;
    y = example->y;

    const int halfwsx = std::floor ( window_size_x / 2 );
    const int halfwsy = std::floor ( window_size_y / 2 );
    const int step = window_size_x*window_size_y;

    int k = 1;
    for ( int v = -halfwsy; v <= halfwsy; v++ )
        for ( int u = -halfwsx; u <= halfwsx; u++, k++ )
        {
            int uu = u;
            int vv = v;
            if (x+u < 0 || x+u >= xsize) uu=-u;
            if (y+v < 0 || y+v >= ysize) vv=-v;

            if ( x+uu > 0
                 && x+uu < xsize
                 && y+vv > 0
                 && y+vv < ysize
                 && k < vec.size() )
            {
                for ( int c = 0; c < numChannels; c++)
                    vec[k+c*step] = imgD->get(x+uu,y+vv,c);
            }
        }

    if (useSpatialPriors)
    {
        vec[betaLength-2] = (double)x/(double)xsize;
        vec[betaLength-1] = (double)y/(double)ysize;
    }

    return vec;
}

/** return length of parameter vector */
int ConvolutionFeature::getParameterLength() const
{
    return betaLength;
}

/** set parameter vector */
void ConvolutionFeature::setParameterVector( const Vector & vec )
{
    if ( beta->size() == vec.size() )
    {
        int i = 0;
        for ( NICE::Vector::iterator it = beta->begin();
              it != beta->end(); ++it, i++ )
        {
            *it = vec[i];
        }
        beta->normalizeL2();
    }
    else
        std::cerr << "ConvolutionFeature::setParameterVector: Vector sizes do not match!"
                  << " expected: " << beta->size() << ", got: " << vec.size()
                  << std::endl;

}

/** return feature value */
double ConvolutionFeature::val ( const Example *example ) const
{
    double val1 = 0.0;

    // is parameter vector and image data available?
    if (beta == NULL)
    {
        std::cerr << "ConvolutionalFeature::val: Missing parameter vector!"
                  << std::endl;

        return val1;
    }

    NICE::MultiChannelImageT<double> * imgD = NULL;
    imgD = & example->ce->getDChannel( CachedExample::D_EOH );

    int xsize, ysize, x, y;

    example->ce->getImageSize( xsize, ysize );
    x = example->x;
    y = example->y;

    const int colorStep = window_size_x*window_size_y;
    const int scalingSteps = 1;

    int halfwsx = std::floor ( window_size_x / 2 );
    int halfwsy = std::floor ( window_size_y / 2 );
    int wScale = 1;

    for ( int s = 0; s < scalingSteps; s++ )
    {
        for ( int c = 0; c < numChannels; c++ )
        {
            int paramIdx = 1;
            int pxIdx = 0;
            for ( int v = -halfwsy; v <= halfwsy; v++ )
                for ( int u = -halfwsx; u <= halfwsx; u++, pxIdx++ )
                {
                    if (pxIdx % wScale == 0) paramIdx++;

                    int colorShift = paramIdx + c*colorStep;
                    int uu = u;
                    int vv = v;

                    if (x+u < 0 || x+u >= xsize) uu=-u;
                    if (y+v < 0 || y+v >= ysize) vv=-v;

                    if ( x+uu > 0
                         && x+uu < xsize
                         && y+vv > 0
                         && y+vv < ysize
                         && paramIdx < beta->size() )
                    {
                        val1 += imgD->get(x+uu,y+vv,c)
                                * beta->operator [](colorShift)
                                / wScale * wScale;
                    }

                }
        }

        // increase scaling
        halfwsx *= 3;
        halfwsy *= 3;
        wScale *= 3;
    }

    // normalize scaling
    val1 /= (double)scalingSteps;

    if (useSpatialPriors)
    {
        val1 += (double)x/(double)xsize * beta->operator [](betaLength-2);
        val1 += (double)y/(double)ysize * beta->operator [](betaLength-1);
    }

    return val1;
}

/** creature feature pool */
void ConvolutionFeature::explode ( FeaturePool &featurePool, bool variableWindow ) const
{
    ConvolutionFeature *f =
            new ConvolutionFeature ( this->window_size_x, this->window_size_y, this->isColor );

    featurePool.addFeature(f);
}

/** clone current feature */
Feature *ConvolutionFeature::clone ( ) const
{
    ConvolutionFeature *f =
            new ConvolutionFeature ( this->window_size_x, this->window_size_y, this->isColor );

    f->setParameterVector( *beta );

    return f;
}

Feature *ConvolutionFeature::generateFirstParameter () const
{
    return clone();
}

void ConvolutionFeature::restore ( std::istream & is, int format )
{
    is >> window_size_x;
    is >> window_size_y;
    is >> betaLength;

    isColor = false;
    useSpatialPriors = false;
    numChannels = 1;

    if ( betaLength == (window_size_x*window_size_y+3) )
    {
        useSpatialPriors = true;
    }
    else if ( betaLength == (3*window_size_x*window_size_y+1) )
    {
        isColor = true;
        numChannels = 3;
    }
    else if ( betaLength == (3*window_size_x*window_size_y+3) )
    {
        isColor = true;
        numChannels = 3;
        useSpatialPriors = true;
    }

    beta = new NICE::Vector( betaLength, 1.0 );
    for ( NICE::Vector::iterator it = beta->begin();
          it != beta->end(); ++it )
        is >> *it;
}

void ConvolutionFeature::store ( std::ostream & os, int format ) const
{
    os << "ConvolutionFeature "
       << window_size_x << " "
       << window_size_y << " "
       << betaLength;

    for ( NICE::Vector::const_iterator it = beta->begin();
          it != beta->end(); ++it )
        os << ' ' << *it;

}

void ConvolutionFeature::clear ()
{
    beta->clear();
}