NICE_VisLearning/features/localfeatures/LFonHSG.cpp

/**
* @file LFonHSG.cpp
* @brief Implementation of the LocalFeatureHSG.h. See description there.
* @author Eric Bach
* @date 26.10.2011
*/

/* LocalFeatureHSG Include */
#include "vislearning/features/localfeatures/LFonHSG.h"

using namespace std;
using namespace NICE;
using namespace OBJREC;

#ifdef NICE_USELIB_BOOST
using namespace boost;
#endif

LFonHSG::LFonHSG (const Config *conf, const string section)
{
  /** initialization **/
  this->lf = NULL;

  /** get parameters for the grid **/
  sampleScaling    = conf->gI (section, "sample_scaling", 50);
  scales		 = conf->gS (section, "scales"        , "1");
  // the scales are seperated by '+', like in the Van de Sande implementation
  char separator = '+';

  /** get debuginformation **/
  debug 		 = conf->gB ("debug", "show_log_HSG", false);

  /** generate the descriptor-instanz **/
  lf = GenericLocalFeatureSelection::selectLocalFeature (conf, section);

  /** parse scales string **/
  debug && clog << "[log] LocalFeatureHSG::LocalFeatureHSG" << endl;
  debug && clog << "[log] try to parse the 'scales-string': " << scales << " -> ";

#ifdef NICE_USELIB_BOOST
  typedef tokenizer<boost::char_separator<char> > tokenizer;
  char_separator<char> sep (separator);
  tokenizer tokens (scales, sep);		// parse the string into tokens
  for (tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter) {
    debug && clog << *tok_iter << " ";
    scalesV.push_back(StringTools::convert<float>(*tok_iter));
  }
#else // standard
  vector<string> temp;
  StringTools::split (scales, separator, temp);
  for (vector<string>::const_iterator it = temp.begin(); it != temp.end(); ++it) {
    debug && clog << *it << " ";
    scalesV.push_back(StringTools::convert<float>(*it));
    //scalesV.push_back (strToFloat (*it));
  }
#endif
  debug && clog << endl;
}

LFonHSG::~LFonHSG()
{
  /** free memory of descriptors **/
}

void LFonHSG::getPositionsOnHSG (const unsigned int imageWidth, const unsigned int imageHeight, VVector& positions) const
{
  if (sampleScaling < 1) {
    cerr << "[err] sample-scaling (" << sampleScaling << ") musst be larger the 0!" << endl;
    return;
  }

  debug && clog << "[log] LocalFeatureHSG::getPositionsOnHSG calculate ";

  bool oddRow = true;
  NICE::Vector pos (4);

  /** we have to calculate the koo. for every different scale **/
  for (vector <float>::const_iterator it = scalesV.begin(); it != scalesV.end(); ++it) {
    oddRow = true;

    for (unsigned int j = sampleScaling; j <= (imageHeight - sampleScaling); j += sampleScaling) {
      for (unsigned int i = (oddRow ? sampleScaling + sampleScaling / 2 : sampleScaling); i <= (imageWidth - sampleScaling); i += sampleScaling) {
        pos[ 0] = i;
        pos[ 1] = j;
        pos[ 2] = *it;
        pos[ 3] = 0;
        positions.push_back (pos);
      }
      oddRow = !oddRow;
    }
  }
}

int LFonHSG::extractFeatures (const NICE::ColorImage & cimg, VVector & features, VVector & positions) const
{
  /** To get the keypoint descriptor, we need the positions of the keypoints. **/
  getPositionsOnHSG (cimg.width(), cimg.height(), positions);

  /** calulate the descriptor-values **/
  return lf->getDescriptors (cimg, positions, features);
}


int LFonHSG::extractFeatures (const NICE::Image & img, VVector & features, VVector & positions) const
{
  /** To get the keypoint descriptor, we need the positions of the keypoints. **/
  getPositionsOnHSG (img.width(), img.height(), positions);

  /** calculate the descriptor-values **/
  return lf->getDescriptors (img, positions, features);
}

void LFonHSG::visualizeFeatures (NICE::Image & mark, const VVector & positions, size_t color) const
{
  // TODO: Implementierung des gewaehlten Descriptortyps aufrufen.
}