NICE_VisLearning/features/localfeatures/LFColorSande.cpp

/**
* @file LFColorSande.cpp
* @brief interface to ColorSande implementation
* @author Erik Rodner
* @date 11/19/2007

*/
#include <errno.h>
#include <iostream>

#include <core/image/Convert.h>

#include "core/basics/StringTools.h"
#include "core/basics/FileMgt.h"
#include "vislearning/baselib/Globals.h"

#include "vislearning/features/localfeatures/LFColorSande.h"


#define DESCSIZE_DUMMY "/home/bachi/HiWi/nice/nice/objrec-froehlichexp/progs/IMG_8762.JPG"

#include <sstream>

using namespace OBJREC;

using namespace std;
using namespace NICE;



LFColorSande::LFColorSande ( const Config *conf, std::string section )
{
  c_binaryExecutable = conf->gS ( section, "binaryExecutable", "/home/bachi/libs/van_de_sande/x86_64-linux-gcc/colorDescriptor" );
  c_params = conf->gS ( section, "params", "--descriptor opponentsift" );
  scales = conf->gS ( section, "scales", "1+1.5+3.0+4.5+6" );

  descriptor_size = conf->gI ( section, "descriptor_size", -1 );

  usegrid = conf->gB ( section, "usegrid", false );

  int g = conf->gI ( section, "grid", 5 );
  std::ostringstream temp;
  temp << g;
  gridsize = temp.str();

  if ( descriptor_size <= 0 )
  {
    fprintf ( stderr, "LFColorSande::LFColorSande: No descriptor size found in config -> self test\n" );
    /** get feature dimension **/
    NICE::Image testimg ( DESCSIZE_DUMMY );
    VVector features;
    VVector positions;
    extractFeatures ( testimg, features, positions );
    if ( features.size() <= 0 )
      fthrow ( Exception, "No features found in " << DESCSIZE_DUMMY << " picture." );
    descriptor_size = features[0].size();

    fprintf ( stderr, "LFColorSande::LFColorSande Self Test features:%d dimension:%d\n", ( int ) features.size(), descriptor_size );
  }

  if ( descriptor_size != conf->gI ( "features", "descriptor_size", descriptor_size ) )
  {
    cerr << "Warning: LFColorSande: descriptor sizes do not match !!!" << endl;
  }
}

LFColorSande::~LFColorSande()
{
}

int LFColorSande::getDescSize () const
{
  return descriptor_size;
}

int LFColorSande::extractFeatures ( const NICE::Image & img, VVector & features,
                                    VVector & positions ) const
{
  cerr << "Warning: LFColorSande is a color local feature implementation, but you are calling the gray-image version of extractFeatures" << endl;
  NICE::ColorImage colorimg;
  NICE::grayToRGB ( img, &colorimg );
  extractFeatures ( colorimg, features, positions );

  return 0;
}

int LFColorSande::extractFeatures ( const NICE::ColorImage & img, VVector & features, VVector & positions ) const
{
  if ( features.size() != positions.size() )
  {
    positions.clear();
  }

  bool delete_imgfile = false;
  std::string imgfile = Globals::getCurrentImgFN();

  fprintf ( stderr, "imgfile: %s\n", imgfile.c_str() );
  if ( ( imgfile.size() <= 0 ) || ( ( !StringTools::regexMatch ( imgfile, ".[Jj][pP][Gg]$" ) )
                                    && ( !StringTools::regexMatch ( imgfile, ".[Pp][Nn][Gg]$" ) ) ) )
  {

    if ( imgfile.size() <= 0 )
    {
      imgfile = FileMgt::createTempFile ( "/tmp/osl_lfColorSande_input_%s.png" );
      fprintf ( stderr, "LFColorSande: write image to %s (write image)\n", imgfile.c_str() );
      ImageFile imgf ( imgfile );
      imgf.writer ( &img );
    } else {
      std::string tmpfile = FileMgt::createTempFile ( "/tmp/osl_lfColorSande_input_%s.png" );
      fprintf ( stderr, "LFColorSande: write image to %s (convert)\n", tmpfile.c_str() );

      std::string convertcall = "convert " + imgfile + " " + tmpfile;
      cerr << "convert call: " << convertcall << endl;
      system ( convertcall.c_str() );

      imgfile = tmpfile;
    }

    delete_imgfile = true;
  }

  std::string outputfn  = FileMgt::createTempFile ( "/tmp/osl_lfColorSande_output_%s" ) ;

  std::string gridparams = "";

  if ( usegrid )
    gridparams = " --detector densesampling --ds_spacing " + gridsize + " --ds_scales " + scales;

  std::string call = c_binaryExecutable + " " +
                     imgfile            + " " +
                     c_params           +
                     gridparams         +
                     " -output "        + outputfn;

  cerr << "LFColorSande: parameters: <" << c_params + gridparams << ">" << endl;
  clog << "Systemcall: " << call << endl;


  const int buffersize = 65536;
  char *buffer = new char [buffersize];
  FILE *f = popen ( call.c_str(), "r" );
  if ( f == NULL )
  {
    fthrow ( Exception, "Unable to run the implementation of van de Sande: " << call << endl << strerror ( errno ) );
  }

  while ( ! feof ( f ) )
  {
    if ( fgets ( buffer, buffersize, f ) <= 0 )
    {
      break;
    } else {
      fprintf ( stderr, "LFColorSande::extractFeatures: [INFO] %s", buffer );
    }
  }


  pclose ( f );

  f = fopen ( outputfn.c_str(), "r" );
  if ( f == NULL )
  {
    fthrow ( Exception, "Unable to read output of van de Sande implementation\n" );
  }

  if ( fgets ( buffer, buffersize, f ) <= 0 )
  {
    fprintf ( stderr, "LFColorSande::extractFeatures: output is empty !\n" );
    fprintf ( stderr, "img %s out %s\n", imgfile.c_str(), outputfn.c_str() );
    fprintf ( stderr, "call %s\n", call.c_str() );

    exit ( -1 );
  }

  if ( ! strcmp ( buffer, "KOEN1" ) )
  {
    fprintf ( stderr, "LFColorSande::extractFeatures: wrong file format\n" );
    fprintf ( stderr, "img %s out %s\n", imgfile.c_str(), outputfn.c_str() );
    fprintf ( stderr, "call %s\n", call.c_str() );

    exit ( -1 );
  }


  fgets ( buffer, buffersize, f );
  int dimension = atoi ( buffer );
  fprintf ( stderr, "LFColorSande: descriptor dimension = %d\n", dimension );

  if ( ( descriptor_size > 0 ) && ( dimension != descriptor_size ) )
  {
    fprintf ( stderr, "LFColorSande::extractFeatures: dimensions do not match %d -> %d!\n",
              dimension, descriptor_size );
    fprintf ( stderr, "img %s out %s\n", imgfile.c_str(), outputfn.c_str() );
    fprintf ( stderr, "call %s\n", call.c_str() );
    fprintf ( stderr, "dimension std::string buffer: \"%s\"", buffer );
    exit ( -1 );
  }

  fgets ( buffer, buffersize, f );
  int noDesc = atoi ( buffer );

  fprintf ( stderr, "LFColorSande::extractFeatures: no. of descriptors = %d\n", noDesc );

  NICE::Vector x;
  while ( ! feof ( f ) )
  {
    // <CIRCLE 119 307 1.26134 0 0.00014763>; 0 0 6 2 0 6 25 7 9 4 4 0 0 4 20 36 78 4 5 0 0
    if ( fgets ( buffer, buffersize, f ) == NULL )
      break;

    const char *buffer_data = strchr ( buffer, ';' );
    if ( strlen ( buffer_data ) <= 0 )
    {
      fprintf ( stderr, "LFColorSande::extractFeatures: it seems you forget to specify a descriptor\n" );
      exit ( -1 );
    }

    const char *buffer_key_start = strchr ( buffer, ' ' );
    const char *buffer_key_end = strchr ( buffer, '>' );
    buffer_key_start++;
    int keylen = buffer_key_end - buffer_key_start;
    char *key = new char [keylen+1];
    strncpy ( key, buffer_key_start, keylen );
    key[keylen] = '\0';

    buffer_data += 2;

    std::string buffer_data_s ( buffer_data );

    //clog << "[log] buffer = " << buffer_data_s << endl;

    StringTools::splitVector ( buffer_data_s, ' ', x );
    if ( ( int ) x.size() != dimension )
    {
      cerr << "Line = " << buffer_data_s << endl;
      cerr << "Vector = " << x << endl;
      cerr << "dimension = " << dimension << endl;
      cerr << "x.size() = " << x.size() << endl;
      fprintf ( stderr, "LFColorSande::extractFeatures: error parsing output !!\n" );
      exit ( -1 );
    } else {
      NICE::Vector pos;

      StringTools::splitVector ( key, ' ', pos );

      if ( pos.size() != 5 ) {
        fprintf ( stderr, "LFColorSande::extractFeatures: dimension mismatch (position information)\n" );
        exit ( -1 );
      }
      // Van De Sande verwendet MatLab-Darstellung der Koordinaten. Diese fangen bei 1 an und nicht bei 0.
      pos[0] --;
      pos[1] --;
      positions.push_back ( pos );
      features.push_back ( x );
    }
  }

  fclose ( f );

  if ( delete_imgfile )
    FileMgt::deleteTempFile ( imgfile );

  FileMgt::deleteTempFile ( outputfn );

  delete [] buffer;

  return 0;
}