#ifdef NICE_USELIB_OPENMP
#include <omp.h>
#endif

#include <iostream>

#include "vislearning/features/localfeatures/sift.h"
#include "vislearning/features/localfeatures/LocalFeatureRGBSift.h"

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


LocalFeatureRGBSift::LocalFeatureRGBSift (const Config *conf) : LocalFeatureSift (conf)
{
  deletemode = false;
}

LocalFeatureRGBSift::~LocalFeatureRGBSift()
{

}

int LocalFeatureRGBSift::getDescriptors (const NICE::ColorImage & img,
    VVector & positions,
    VVector & descriptors) const
{
  sortPositions (positions);
  descriptors.clear();
  // Fuer jede Position wird ein leerer NICE::Vector in descriptors eingefuegt
  for (int i = 0; i < (int) positions.size(); i++) {
    NICE::Vector v;
    descriptors.push_back (v);
  }

  vector<VVector> desc (3);

  // Maximale Anzahl an Thread ist abhaengig von der Anzahl der verfuegbaren Grafikkarten
  // bzw. (wenn siftGPU nicht genutzt wird) von der Anzahl der Prozessoren
  const int numberOfGPU = getNumOfDevices();
  const int numberOfCPU = omp_get_num_procs();

  if (numberOfGPU == -1) { // siftGPU wird nicht genutzt
    omp_set_num_threads (numberOfCPU);
  }
  else if (numberOfGPU == 0) {
    fthrow (Exception, "No Devices");
  }
  else { // siftGPU wird genutzt: LocalFeatureSiftGPU kuemmert sich um die threads.
    omp_set_num_threads (numberOfGPU);
  }

#pragma omp parallel for
  // Descriptor fuer jeden der 3 Kanaele berechnen
  for (int i = 0; i < 3; i++) {
    NICE::Image tmp (img.width(), img.height());

    for (int y = 0; y < img.height(); y++) {
      for (int x = 0; x < img.width(); x++) {
        tmp.setPixel (x, y, img.getPixel (x, y, i));
      }
    }
    VVector pos = positions;
    computeDesc (tmp, pos, desc[i]);
  }

  // ab hier stehen wird nur noch mit dem Prozessor gerechnet
  omp_set_num_threads (numberOfCPU);

  // ?
  //desc[0] = desc[2];
  for (int i = 0; i < 3; i++) {
    assert (desc[i].size() == descriptors.size());

    if (i == 0) {
#pragma omp parallel for
      for (int j = 0; j < (int) desc[i].size(); j++) {
        // kopiere den roten (1.)-Kanal in den Descriptorsvektor
        descriptors[j] = desc[i][j];
      }
    }
    else {
#pragma omp parallel for
      for (int j = 0; j < (int) desc[i].size(); j++) {
        descriptors[j].append (desc[i][j]);
      }
    }
  }

  return positions.size();
}