/**
* @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;

    initializeParameterVector();
}

/** alternative constructor */
ConvolutionFeature::ConvolutionFeature ( const int wsize_x, const int wsize_y )
{
    window_size_x = wsize_x;
    window_size_y = wsize_y;

    initializeParameterVector();
}

/** default constructor */
ConvolutionFeature::ConvolutionFeature ( const Config *conf )
{
    window_size_x = conf->gI ( "ConvolutionFeature", "window_size_x", 15 );
    window_size_y = conf->gI ( "ConvolutionFeature", "window_size_y", 15 );

    initializeParameterVector();
}

/** copy constructor */
ConvolutionFeature::ConvolutionFeature ( const ConvolutionFeature *confFeat )
{
    window_size_x = confFeat->window_size_x;
    window_size_y = confFeat->window_size_y;
    beta_length = confFeat->beta_length;
    beta = new NICE::Vector( beta_length, 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)
    {
        beta_length = window_size_x*window_size_y + 1;
        beta = new NICE::Vector( beta_length, (1.0/(double)(beta_length-1) ) );
        beta[0] = 1;
    }
    else
        std::cerr << "ConvolutionFeature::initializeVector: Size of window is Zero! Could not initialize..." << std::endl;
}

/** 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(window_size_x*window_size_y + 1, 1.0);;

    const NICE::MultiChannelImageT<int> & img =
            example->ce->getIChannel( CachedExample::I_GRAYVALUES );

    int xsize, ysize, x, y;

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

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

    int k = 1;
    for ( int v = -halfwsy; v <= halfwsy; v++ )
        for ( int u = -halfwsx; u <= halfwsx; u++ )
        {
            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() )
            {
                vec[k] = img.get(x+uu,y+vv);
            }
            k++;
        }

    return vec;
}

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

/** set parameter vector */
void ConvolutionFeature::setParameterVector( const Vector & vec )
{
    if ( beta->size() == vec.size() )
    {
        int i = 0;
        double sum = 0.0;
        for ( NICE::Vector::iterator it = beta->begin();
              it != beta->end(); ++it, i++ )
        {
            *it = vec[i];
            sum = vec[i];
        }

        // Normalize only kernel parameters
        double betaZero = vec[0];
        sum -= betaZero;
        beta->operator/= (sum);
        beta->operator[](0) = betaZero;

    }
    else
        std::cerr << "ConvolutionFeature::setParameterVector: Vector sizes do not match! Could not update parameter vector..." << std::endl;

}

/** return feature value */
double ConvolutionFeature::val ( const Example *example ) const
{
    // is parameter vector initialized?
    if (beta == NULL)
        return 0.0;

    const NICE::MultiChannelImageT<int> & img =
            example->ce->getIChannel( CachedExample::I_GRAYVALUES );

    int xsize, ysize, x, y;

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

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

    int k = 1;
    double val1 = 0.0;
    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 < beta->size() )
            {
                val1 += (double)img.get(x+uu,y+vv) * beta->operator [](k);
            }
        }

    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 );

    featurePool.addFeature(f);
}

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

    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 >> beta_length;

    beta = new NICE::Vector( beta_length, 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 << " "
       << beta_length;

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

}

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