NeuralNetwork.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include <iostream>
#include <sstream>
#include <fstream>
#include <algorithm>
 
#include "NeuralNetwork.h"
#include "tinyxml2.h"
 
// this is here only to know where to send a finished training message
// defined in PluginBT
#include "Prerequisites.h"
 
/********************* CONSTRUCTOR AND DESTRUCTOR *************************************/
NeuralNetwork::NeuralNetwork(int featurePerSample, float sensibility, MlMode mode, MlType type)
{
  m_bayes = cv::ml::NormalBayesClassifier::create();
  m_svm = cv::ml::SVM::create();
  m_dt = cv::ml::DTrees::create();
  m_rt = cv::ml::RTrees::create();
  m_boost = cv::ml::Boost::create();
  m_ann = cv::ml::ANN_MLP::create();
  m_knn = cv::ml::KNearest::create();
        // Parameters
        // KNN
        m_knn_p = 3;
 
        // SVM
  m_svm->setType(cv::ml::SVM::C_SVC); // C_SVC o NU_SVC
        m_svm->setKernel(cv::ml::SVM::RBF); // SIGMOID or RBF;
  m_svm->setGamma(1.0);  // for poly/rbf/sigmoid
  m_svm->setCoef0(0.0);  // for poly/sigmoid
        m_svm->setC(0.5);
        m_svm->setNu(0.5);
 
        // DT
  m_dt->setMaxCategories(6);
 
        // Boost
  m_boost->setBoostType(cv::ml::Boost::DISCRETE);
        m_boost->setWeakCount(20);
  m_boost->setWeightTrimRate(0);
 
        // RT
  m_rt->setMaxCategories(6);
 
  // initialize variables
  m_mode = mode;
  m_type = type;
  m_newHistoryData = false;
  m_featurePerSample = featurePerSample;
  m_nbSamples = 0;
  m_nbMaxSamples = 0;
  m_nbAnchorPoints = 0;
  m_sensibility = sensibility;
  m_lastInputDate = 0;
  m_averageTime = 0;
 
  m_trainingThread = 0;
  m_detectionThread = 0;
  SetTrainingState(NOT_TRAINED);
}
 
NeuralNetwork::~NeuralNetwork()
{
  if (m_trainingThread != 0)
  {
    m_trainingThread->join();
    delete m_trainingThread;
    m_trainingThread = 0;
  }
 
  SetTrainingState(NOT_TRAINED);
 
  if (m_detectionThread != 0)
  {
    m_detectionThread->join();
    delete m_detectionThread;
    m_detectionThread = 0;
  }
 
  m_samples.clear();
  m_categories.clear();
  m_dataHistory.clear();
}
 
 
/********************* ACCESSOR  *************************************/
NeuralNetwork::TrainingState NeuralNetwork::GetTrainingState()
{
  boost::mutex::scoped_lock lock(m_trainingCriticalSection);
  return m_trainingState;
}
 
void NeuralNetwork::SetTrainingState(NeuralNetwork::TrainingState state)
{
  boost::mutex::scoped_lock lock(m_trainingCriticalSection);
  m_trainingState = state;
}
 
int NeuralNetwork::GetCategoryPos(std::string name)
{
  int iCategory = -1;
  for (unsigned int i = 0; i < m_categories.size(); i++)
  {
    if (m_categories[i].compare(name) == 0)
      iCategory = i;
  }
  return iCategory;
}
 
std::string NeuralNetwork::GetCategory(unsigned int pos)
{
  if(pos < m_categories.size())
          return m_categories[pos];
  else
  {
    return std::string("none");
  }
}
 
std::vector<std::string> NeuralNetwork::GetCategories()
{
  std::vector<std::string> names;
  for(unsigned int i = 0; i < m_categories.size(); i++)
  {
    names.push_back(m_categories[i]);
  }
 
  return names;
}
 
/********************* TRAINING INTERFACE *************************************/
void NeuralNetwork::AddTrainingData(std::vector<cv::Point3d> input, std::string label)
{
  if ((GetTrainingState() == TRAINING) || ((int)input.size() < m_featurePerSample) || ((m_lastInputDate != 0) && ((cv::getTickCount() - m_lastInputDate) < 30)))
    return;
 
  // reset data
  /*if (GetTrainingState() == TRAINED)
  {
    SetTrainingState(NOT_TRAINED);
    m_categories.clear();
    m_samples.clear();
    m_dataHistory.clear();
    m_lastDetected.clear();
  }*/
 
  // get the category pos
  int cat = GetCategoryPos(label);
  if (cat == -1)
  {
    // add the new category
    m_categories.push_back(label);
    cat = m_categories.size() -1;
  }
 
  // for each sample
  for (unsigned int i = 0; i < input.size(); i = i + m_featurePerSample)
  {
    if ((i + m_featurePerSample) > (int)input.size())
      continue;
 
    // create the sample vector with m_featurePerSample size
    std::vector<MlFeature> sample;
    for (int k = 0; k < (int)m_featurePerSample; k++)
    {
      sample.push_back(MlFeature(input[i + k], cv::getTickCount()));
    }
 
    // look for the correct category
    SamplesMap::iterator catIt = m_samples.find(cat);
    if (catIt == m_samples.end())
      m_samples[cat].push_back(sample);
    else
      catIt->second.push_back(sample);
  }
 
  m_lastInputDate = cv::getTickCount();
}
 
std::vector<std::vector<MlFeature>> NeuralNetwork::ComputeData(std::vector<std::vector<MlFeature>> ldata)
{
  std::vector<std::vector<MlFeature>> sortedData;
  std::vector<std::vector<MlFeature>> outData;
  sortedData.resize(m_featurePerSample);
 
  //debug
  unsigned int lsize = ldata.size();
 
  // sort data from vector samples<features> to vector features<samples>
  for(unsigned int i = 0; i < ldata.size(); i++)
  {
    std::vector<MlFeature> samples;
 
    for (unsigned int k = 0; k < m_featurePerSample; k++)
    {
      // look if we have enough features in the sample
      if(k < ldata[i].size())
        sortedData[k].push_back(ldata[i][k]);
      else
      {
        sortedData[k].push_back(MlFeature());
      }
    }
  }
 
  // add middle points if there is not enough data
  for(unsigned int k = 0; k < sortedData.size(); k++)
  {
    if ((int)sortedData[k].size() < (m_nbAnchorPoints + 1))
    {
      // add a point to interlpolate
      if (sortedData[k].size() < 2)
        sortedData[k].insert(sortedData[k].begin(), MlFeature());
 
      //add interpolated points
      while ((int)sortedData[k].size() <= (m_nbAnchorPoints + 1))
      {
        for (int j = 0; j < ((int)sortedData[k].size() - 1); j++)
        {
          MlFeature p1 = sortedData[k][j];
          MlFeature p2 = sortedData[k][j + 1];
 
          MlFeature pn = (p2 - p1);
          pn.x /= 2.0f;
          pn.y /= 2.0f;
          pn.z /= 2.0f;
          pn.t /= 2;
          j++;
          sortedData[k].insert(sortedData[k].begin() + j, (p1 + pn));
        }
 
        //add null point
        //sortedData[k].push_back(MlFeature());
      }
    }
 
    // smooth path
    // finds smallest interval and replaces two points on median point
    while ((int)sortedData[k].size() > (m_nbAnchorPoints + 1))
    {
      double d;
      double d_min = std::numeric_limits<double>::max();
 
      std::vector<MlFeature>::iterator p_min = sortedData[k].begin();
      ++p_min;
 
      std::vector<MlFeature>::iterator p = p_min;
      std::vector<MlFeature>::iterator i = p_min;
      ++i;
 
      std::vector<MlFeature>::iterator last     = sortedData[k].end();
      --last;
 
      for (; i != last; ++i)
      {
              d = sqrt(pow((*p).x - (*i).x, 2) + pow((*p).y - (*i).y, 2) + pow((*p).z - (*i).z, 2));
              if (d < d_min)
              {
                      d_min = d;
                      p_min = p;
              }
              p = i;
      }
 
      p = p_min;
      i = ++p_min;
 
      MlFeature pt;
      pt.x = ((*p).x + (*i).x) / 2;
      pt.y = ((*p).y + (*i).y) / 2;
      pt.z = ((*p).z + (*i).z) / 2;
      pt.t = ((*p).t + (*i).t) / 2;
 
      *i = pt;                          // changes coord of a base point
      sortedData[k].erase(p);           // erases an odd point
    }
  }
 
  if (m_mode == ML_POSE)
  {
    return sortedData;
  }
  else
  {
    // change data to angles
    for(unsigned int k = 0; k < sortedData.size(); k++)
    {
      std::vector<MlFeature>::iterator i = sortedData[k].begin();
            std::vector<MlFeature>::iterator p = i++;
            std::vector<MlFeature> ndata;
 
            for (; i != sortedData[k].end(); ++i)
            {
        MlFeature pt2 = (*i);
        MlFeature pt1 = (*p);
        MlFeature np;
        np.t = pt2.t - pt1.t;
 
                    //np.x = pt2.x - pt1.x;
                    //np.y = pt2.y - pt1.y;
        //np.z = pt2.z - pt1.z;
                    //np.x *= np.t;
                    //np.y *= np.t;
        //np.z *= np.t;
 
        float xangles = 0.0f;
        float yangles = 0.0f;
        float zangles = 0.0f;
 
        xangles = (float) (atan2((pt2.y - pt1.y), (pt2.x - pt1.x)) * 180.0 / (double)SCOL_PI);
              if (xangles < 0)
          xangles = 360.f + xangles;
 
              yangles = (float) (atan2((pt2.y - pt1.y), (pt2.z - pt1.z)) * 180.0 / (double)SCOL_PI);
              if (yangles < 0)
          yangles = 360.f + yangles;
 
              /*zangles = (float) (atan2((pt2.z - pt1.z), (pt2.x - pt1.x)) * 180.0 / (double)SCOL_PI);
              if (zangles < 0)
          zangles = 360.f + zangles;*/
 
        np.x = xangles;
        np.y = yangles;
        np.z = np.t;
        ndata.push_back(np);
 
                    p = i;
            }
 
      outData.push_back(ndata);
    }
 
    // change data to relative
    /*
    for(unsigned int k = 0; k < sortedData.size(); k++)
    {
      std::vector<MlFeature>::iterator i = sortedData[k].begin();
            std::vector<MlFeature>::iterator p = i++;
            std::vector<MlFeature> ndata;
 
            for (; i != sortedData[k].end(); ++i)
            {
        MlFeature pt2 = (*i);
        MlFeature pt1 = (*p);
 
        MlFeature np;
        int tl = pt2.t - pt1.t;
 
        // mutiply by time interval
        np.x = (pt2.x - pt1.x);// * tl;
                    np.y = (pt2.y - pt1.y);// * tl;
        np.z = (pt2.z - pt1.z);// * tl;
        np.t = tl <= 0 ? 0 : tl;
        ndata.push_back(np);
 
                    p = i;
            }
 
      outData.push_back(ndata);
    }*/
 
    return outData;
  }
}
 
void NeuralNetwork::Train()
{
  if (GetTrainingState() != TRAINING && (m_categories.size() > 0))
  {
    // prepare training
    SetTrainingState(TRAINING);
    if (m_trainingThread != 0)
    {
      m_trainingThread->join();
      delete m_trainingThread;
      m_trainingThread = 0;
    }
 
    if (m_detectionThread != 0)
    {
      m_detectionThread->join();
      delete m_detectionThread;
      m_detectionThread = 0;
    }
 
    // launch the training in another thread
    m_trainingThread = new boost::thread(boost::bind(&NeuralNetwork::TrainingThread, this));
  }
}
 
// Called by the trainingthread, never by the main thread!
void NeuralNetwork::TrainingThread()
{
  m_nbMaxSamples = 0;
  m_nbMinSamples = std::numeric_limits<int>::max();
  m_nbSamples = 0;
  m_averageTime = 0;
 
  //calculate the max samples
  for(SamplesMap::iterator i = m_samples.begin(); i != m_samples.end(); i++)
  {
    m_nbMaxSamples = std::max(m_nbMaxSamples, (int)i->second.size());
    m_nbMinSamples = std::min(m_nbMinSamples, (int)i->second.size());
    int lasttime = 0;
    for (unsigned int j = 0; j < i->second.size(); j++)
    {
      if (lasttime != 0)
        m_averageTime += i->second[j][0].t - lasttime;
      lasttime = i->second[j][0].t;
 
      m_nbSamples++;
    }
  }
 
  // speed average
  m_averageTime /= m_nbSamples;
  // set a minimum
  if (m_averageTime == 0)
    m_averageTime = 30;
 
  // nb samples average
  m_nbAnchorPoints = m_nbSamples; //(int)((float)(m_nbSamples / m_samples.size())/* * ((float)m_averageTime / 100.0f)*/);
 
  //compute SamplesMap to cv::Mat trainIn
  cv::Mat trainIn(m_nbAnchorPoints * m_categories.size(), m_featurePerSample * 3, CV_32FC1);
 
  cv::Mat trainOut(m_nbAnchorPoints * m_categories.size(), 1, CV_32FC1);
  // init the categories to -1
  trainOut.setTo(-1);
 
  cv::Mat var_type(trainIn.cols + 1, 1, CV_8U);
  var_type.setTo(cv::ml::VAR_NUMERICAL);
  var_type.at<uchar>(trainIn.cols, 0) = cv::ml::VAR_CATEGORICAL;
 
  int sampleIdx = 0;
  try
  {
    for(SamplesMap::iterator i = m_samples.begin(); i != m_samples.end(); i++)
          {
      int featureIdx = 0;
 
      //not enough data for motion
      if ((i->second.size() < 2) && (m_mode == ML_MOTION))
        continue;
 
      std::vector<std::vector<MlFeature>> data = ComputeData(i->second);
 
      //features
      for (unsigned int j = 0; j < data.size(); j++)
      {
        //samples
        for (unsigned int k = 0; (k < m_nbAnchorPoints) && (k < data[j].size()); k++)
        {
          // repeat the last data top complete the train mat
          trainIn.at<float>(k + (i->first * m_nbAnchorPoints), featureIdx) = (float)data[j][k].x;
          trainIn.at<float>(k + (i->first * m_nbAnchorPoints), featureIdx +1) = (float)data[j][k].y;
          trainIn.at<float>(k + (i->first * m_nbAnchorPoints), featureIdx +2) = (float)data[j][k].z;
 
          // increment sample number only on the first feature
          if(j == 0)
          {
            trainOut.at<float>(sampleIdx) = data[j][k].t == 0 ? -1 : (float)i->first;
            sampleIdx ++;
          }
        }
 
        featureIdx = featureIdx + 3;
      }
          }
 
    cv::Ptr<cv::ml::TrainData> traindata = cv::ml::TrainData::create(trainIn, cv::ml::ROW_SAMPLE, trainOut);
    switch (m_type)
    {
      case KNN:
        m_knn->clear();
        m_knn->train(traindata);
                  break;
 
                  case Bayes:
        m_bayes->clear();
                    m_bayes->train(traindata);
                  break;
 
                  case SVM:
        m_svm->clear();
                    m_svm->train(traindata);
                  break;
 
                  case DT:
        m_dt->clear();
                    m_dt->train(traindata);
                  break;
 
                  case Boost:
        m_boost->clear();
                    m_boost->train(traindata);
                  break;
 
                  case RT:
        m_rt->clear();
                    m_rt->train(traindata);
                  break;
 
      default:
        break;
          }
 
    trainIn.release();
    trainOut.release();
    SetTrainingState(TRAINED);
 
    // launch the detection in another thread
    m_detectionThread = new boost::thread(boost::bind(&NeuralNetwork::DetectionThread, this));
 
    // post the scol event
    OBJpostEvent(WM_ML_TRAINING_FINISHED, SCOL_PTR this, 0);
  }
  catch(cv::Exception &e)
  {
    MMechostr(MSKRUNTIME, "Machine learning - Trainning Error : %s", e.what());
    trainIn.release();
    trainOut.release();
    SetTrainingState(NOT_TRAINED);
  }
}
 
void NeuralNetwork::ValidateDetectedData()
{
  {
    boost::mutex::scoped_lock lock(m_detectionCriticalSection);
    bool tooLong = (m_lastInputDate != 0) && (((int)cv::getTickCount() - m_lastInputDate) > (m_averageTime * 3));
    if (tooLong || ((int)m_dataHistory.size() >= m_nbMaxSamples))
    {
      //post the last category found
      if(m_lastDetected.size() != 0)
      {
        unsigned int catId = (unsigned int)m_lastDetected[m_lastDetected.size() - 1][0];
        std::string* catname = new std::string(GetCategory(catId));
        m_lastDetected.clear();
        m_dataHistory.clear();
        m_newHistoryData = false;
        m_lastInputDate = 0;
        OBJpostEvent(WM_ML_DETECTION, SCOL_PTR this, SCOL_PTR catname);
      }
      else
      {
        // if the last input is too old we reset the history
        if(tooLong)
        {
          m_dataHistory.clear();
          m_newHistoryData = false;
          m_lastInputDate = 0;
        }
      }
    }
  }
  boost::this_thread::sleep_for(boost::chrono::milliseconds(m_averageTime));
}
 
void NeuralNetwork::DetectionThread()
{
  while (GetTrainingState() == TRAINED)
  {
    std::vector<std::vector<MlFeature>> data;
    {
      boost::mutex::scoped_lock lock(m_detectionCriticalSection);
 
      // need a minimum of data
      if (m_dataHistory.empty() || ((int)m_dataHistory.size() < m_nbMinSamples))
        continue;
 
      // this revert the vector to features<samples>
      data = ComputeData(m_dataHistory);
    }
 
    if (!m_newHistoryData)
    {
      ValidateDetectedData();
      continue;
    }
    else
    {
      m_newHistoryData = false;
    }
 
    cv::Mat recognizeIn(m_nbAnchorPoints, m_featurePerSample * 3, CV_32FC1);
    cv::Mat recognizeOut(m_nbAnchorPoints, 1, CV_32FC1);
    recognizeOut.setTo(-1);
 
    //features
    int featureIdx = 0;
    for (unsigned int i = 0; i < data.size(); i++)
    {
      //samples
      for (unsigned int k = 0; (k < m_nbAnchorPoints) && (k < data[i].size()); k++)
      {
        recognizeIn.at<float>(k, featureIdx) = (float)data[i][k].x;
        recognizeIn.at<float>(k, featureIdx+1) = (float)data[i][k].y;
        recognizeIn.at<float>(k, featureIdx+2) = (float)data[i][k].z;
      }
      featureIdx = featureIdx + 3;
    }
 
    int cat = -1;
    float accuracy = 0.0f;
    try
    {
      Reconize(recognizeIn, recognizeOut);
      cat = Evaluate(recognizeOut, accuracy);
    }
    catch(cv::Exception &e)
    {
      MMechostr(MSKRUNTIME, "Machine learning - Recognized Error : %s", e.what());
      ValidateDetectedData();
      continue;
    }
 
    if (cat == -1)
    {
      ValidateDetectedData();
      continue;
    }
 
    std::vector<float> result;
    result.push_back((float)cat);
    result.push_back(accuracy);
 
    //keep the detected categories
    m_lastDetected.push_back(result);
 
    ValidateDetectedData();
  }
}
 
void NeuralNetwork::Save(std::string saveFile)
{
  if(m_samples.empty())
    return;
 
  tinyxml2::XMLDocument xmlDoc;
  tinyxml2::XMLNode* rootnode = xmlDoc.NewElement("MLDATA");
  xmlDoc.InsertEndChild(rootnode);
 
  for(SamplesMap::iterator i = m_samples.begin(); i != m_samples.end(); i++)
  {
    std::string catname = GetCategory((unsigned int)i->first);
    std::vector<std::vector<MlFeature>> data = i->second;
 
    tinyxml2::XMLElement* catnode = xmlDoc.NewElement("CATEGORY");
    catnode->SetAttribute("name", catname.c_str());
 
    //samples
    for (unsigned int j = 0; j < data.size(); j++)
    {
      tinyxml2::XMLElement* samplenode = xmlDoc.NewElement("SAMPLE");
 
      //features
      for (unsigned int k = 0; k < data[j].size(); k++)
      {
        tinyxml2::XMLElement* featurenode = xmlDoc.NewElement("FEATURE");
        featurenode->SetAttribute("x", data[j][k].x);
        featurenode->SetAttribute("y", data[j][k].y);
        featurenode->SetAttribute("z", data[j][k].z);
        featurenode->SetAttribute("time", data[j][k].t);
        samplenode->InsertEndChild(featurenode);
      }
 
      catnode->InsertEndChild(samplenode);
    }
 
    rootnode->InsertEndChild(catnode);
  }
 
  xmlDoc.SaveFile(saveFile.c_str());
}
 
void NeuralNetwork::Load(std::string filename)
{
  tinyxml2::XMLDocument xmlDoc;
  if (xmlDoc.LoadFile(filename.c_str()) != tinyxml2::XML_NO_ERROR)
    return;
 
  // reset training samples
  m_samples.clear();
  m_categories.clear();
 
  SetTrainingState(NOT_TRAINED);
 
  tinyxml2::XMLElement* rootnode = xmlDoc.FirstChildElement("MLDATA");
  if (rootnode)
  {
    //get name + id
    tinyxml2::XMLElement* catnode = 0;
    while ((catnode = rootnode->FirstChildElement("CATEGORY")) != 0)
    {
      std::string catname = catnode->Attribute("name");
      int catid = GetCategoryPos(catname);
      if (catid == -1)
      {
        // add the new category
        m_categories.push_back(catname);
        catid = m_categories.size() -1;
      }
 
      tinyxml2::XMLElement* samplenode = 0;;
      while ((samplenode = catnode->FirstChildElement("SAMPLE")) != 0)
      {
        std::vector<MlFeature> sample;
        tinyxml2::XMLElement* featurenode = 0;
        int numFeatures = 0;
 
        while ((featurenode = samplenode->FirstChildElement("FEATURE")) != 0)
        {
          MlFeature feature;
          feature.x = featurenode->FloatAttribute("x");
          feature.y = featurenode->FloatAttribute("y");
          feature.z = featurenode->FloatAttribute("z");
          feature.t = featurenode->IntAttribute("time");
 
          sample.push_back(feature);
          samplenode->DeleteChild(featurenode);
          numFeatures++;
        }
 
        m_featurePerSample = std::max((int)m_featurePerSample, numFeatures);
 
        SamplesMap::iterator catIt = m_samples.find(catid);
        if (catIt == m_samples.end())
          m_samples[catid].push_back(sample);
        else
          catIt->second.push_back(sample);
 
        catnode->DeleteChild(samplenode);
      }
 
      rootnode->DeleteChild(catnode);
    }
 
    Train();
  }
}
 
void NeuralNetwork::Reconize(cv::Mat reconizeIn, cv::Mat reconizeOut)
{
  if (GetTrainingState() != TRAINED)
    return;
 
  cv::Mat sample;
  cv::Mat out;
  cv::ml::DTrees::Node* n = 0;
        for (int r = 0; r < reconizeIn.rows; r++)
  {
    sample = reconizeIn.row(r);
          float v = 0.0f;
        switch (m_type)
    {
                  case KNN:
        v = m_knn->findNearest(sample, m_knn_p, out);
                  break;
 
                  case Bayes:
          v = m_bayes->predict(sample);
                  break;
 
                  case SVM:
          v = m_svm->predict(sample);
                  break;
 
                  case DT:
        v = m_dt->predict(sample);
                    //n = m_dt->predict(sample);
                    //if(n)
                            //v = (float)n->value;
                  break;
 
                  case Boost:
                    v = m_boost->predict(sample);
                  break;
 
                  case RT:
                    v = m_rt->predict(sample);
                  break;
 
                default:
        break;
        }
 
    reconizeOut.at<float>(r, 0) = v;
        }
}
 
int NeuralNetwork::Evaluate(cv::Mat& predicted, float &accuracy)
{
  std::vector<int> countCategories;
  countCategories.resize(m_categories.size());
  for (unsigned int i = 0; i < countCategories.size(); i++)
    countCategories[i] = 0;
 
  // look for category index found
  for (int i = 0; i < predicted.rows; i++)
  {
    float p = predicted.at<float>(i, 0);
    if (p >= 0.0)
    {
      // increment the category count
      countCategories[(int)p]++;
    }
  }
 
  int maxCategory = -1;
  int nbCorrelFound = 0;
  accuracy = 0.0f;
 
  for (unsigned int i = 0; i < countCategories.size(); i++)
  {
    /*float catWeight = 1.0f;
    float catAccuracy = 1.0f;
    SamplesMap::iterator catIt = m_samples.find(i);
    if(catIt != m_samples.end())
    {
      //catAccuracy = (float)m_dataHistory.size() / (float)catIt->second.size();
      catAccuracy = (float)catIt->second.size() / (float)m_nbAnchorPoints;
      catWeight = ((float)countCategories[i] / (float)m_nbAnchorPoints) / catAccuracy;
    }
 
    if (catWeight > accuracy)
    {
      accuracy = catWeight;
      maxCategory = i;
    }*/
 
    if (countCategories[i] > nbCorrelFound)
    {
      nbCorrelFound = countCategories[i];
      maxCategory = i;
    }
  }
 
  accuracy = (float)nbCorrelFound / (float)m_nbAnchorPoints;
  if (accuracy < m_sensibility)
    return -1;
 
  return maxCategory;
}
 
void NeuralNetwork::AddDetectionData(std::vector<cv::Point3d> input)
{
  if ((GetTrainingState() != TRAINED) || (input.size() == 0) || ((m_lastInputDate != 0) && ((int)(cv::getTickCount() - m_lastInputDate) < m_averageTime)))
    return;
 
  boost::mutex::scoped_lock lock(m_detectionCriticalSection);
 
  // decompose input to several samples and add to the history
  for (unsigned int i = 0; i < input.size(); i += m_featurePerSample)
  {
    if ((i + m_featurePerSample) > (int)input.size())
      continue;
 
    std::vector<MlFeature> sample;
    for (unsigned int k = 0; k < m_featurePerSample; k++)
    {
      sample.push_back(MlFeature(input[i+k], cv::getTickCount()));
    }
 
    m_dataHistory.push_back(sample);
 
    m_newHistoryData = true;
  }
 
  //remove old data
  while ((int)m_dataHistory.size() > m_nbMaxSamples)
  {
    m_dataHistory.erase(m_dataHistory.begin());
  }
  m_lastInputDate = cv::getTickCount();
}