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 std;
using namespace NICE;

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

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

/** 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;
    beta = new NICE::Vector( beta_length, (1.0/beta_length) );
  }
  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 )
{
  NICE::Vector vec(window_size_x*window_size_y, 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 = 0;
  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;
    for ( NICE::Vector::iterator it = beta->begin();
          it != beta->end(); ++it, i++ )
    {
      *it = vec[i];
    }
  }
  else
    std::cerr << "ConvolutionFeature::setParameterVector: Vector sizes do not match! Could not update parameter vector..." << std::endl;

  if ( beta->Sum() != 1.0 )
    beta->normalizeL2();
}

/** 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 = 0;
  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 std::floor(val1);
}

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

  featurePool.addFeature(f);
}

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

  return f;
}

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

void ConvolutionFeature::restore ( 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 ( 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();
}