NeuralNetwork.h

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
 
-----------------------------------------------------------------------------
*/
 
#ifndef _NEURAl_NETWORK_H_
 
#define _NEURAl_NETWORK_H_
 
#include <string>
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/ml/ml.hpp>
 
#include <string>
#include <list>
#include <vector>
#include <map>
 
//keep for now, most of used shared_mutex and some other are C++17 only
#include <boost/thread/thread.hpp>
 
#define SCOL_PI 3.14159265358979323846f
 
class MlFeature : public cv::Point3d
{
public:
  MlFeature()
  {
    x = 0.0f;
    y = 0.0f;
    z = 0.0f;
    t = 0;
  }
 
  MlFeature(const cv::Point3d &p, int tl)
  {
    x = p.x;
    y = p.y;
    z = p.z;
    t = tl;
  }
 
  inline MlFeature &operator+(const MlFeature &rhs)
  {
    x += rhs.x;
    y += rhs.y;
    z += rhs.z;
    t += rhs.t;
    return *this;
  }
 
  inline MlFeature &operator-(const MlFeature &rhs)
  {
    x -= rhs.x;
    y -= rhs.y;
    z -= rhs.z;
    t -= rhs.t;
    return *this;
  }
 
  inline MlFeature &operator*(const MlFeature &rhs)
  {
    x *= rhs.x;
    y *= rhs.y;
    z *= rhs.z;
    t *= rhs.t;
    return *this;
  }
 
  inline MlFeature &operator+=(const MlFeature &rhs)
  {
    x += rhs.x;
    y += rhs.y;
    z += rhs.z;
    t += rhs.t;
    return *this;
  }
 
  inline MlFeature &operator-=(const MlFeature &rhs)
  {
    x -= rhs.x;
    y -= rhs.y;
    z -= rhs.z;
    t -= rhs.t;
    return *this;
  }
 
  inline MlFeature &operator/=(const MlFeature &rhs)
  {
    x /= rhs.x;
    y /= rhs.y;
    z /= rhs.z;
    t /= rhs.t;
    return *this;
  }
 
  int t;
};
 
class NeuralNetwork
{
public:
  enum TrainingState
  {
    NOT_TRAINED,
    TRAINING,
    TRAINED
  };
 
  enum MlType
  {
    KNN,
    Bayes,
    SVM,
    DT,
    ANN,
    Boost,
    RT,
    NONE,
    NUMTYPES
  };
 
  enum MlMode
  {
    ML_POSE,
    ML_MOTION
  };
 
  typedef std::map <unsigned int, std::vector<std::vector<MlFeature> > > SamplesMap;
protected:
private:
  MlType m_type;
  MlMode m_mode;
  cv::Ptr<cv::ml::KNearest> m_knn;
  int m_knn_p;
  cv::Ptr<cv::ml::NormalBayesClassifier> m_bayes;
  cv::Ptr<cv::ml::SVM> m_svm;
  cv::Ptr<cv::ml::DTrees> m_dt;
        cv::Ptr<cv::ml::RTrees> m_rt;
        cv::Ptr<cv::ml::Boost> m_boost;
        cv::Ptr<cv::ml::ANN_MLP> m_ann;
  
  std::vector<std::string> m_categories;
  std::vector<std::vector<float>> m_lastDetected;
  SamplesMap m_samples;
  
  TrainingState m_trainingState;
  boost::thread* m_trainingThread; 
  boost::mutex m_trainingCriticalSection;
 
  boost::thread* m_detectionThread; 
  boost::mutex m_detectionCriticalSection;
 
  unsigned int m_featurePerSample;
  int m_nbSamples;
  int m_nbMaxSamples;
  int m_nbMinSamples;
  unsigned int m_nbAnchorPoints;
  float m_sensibility;
  int m_lastInputDate;
  int m_averageTime;
  std::vector<std::vector<MlFeature>> m_dataHistory;
  bool m_newHistoryData;
 
public:
  /* \brief constructor
   * \param sampleSize : the number of values per sample
   * \param type : the machine learning type
  */
  NeuralNetwork(int featurePerSample, float sensibility, MlMode mode = ML_POSE, MlType type = KNN);
 
  /* \brief destructor
   *
  */
  ~NeuralNetwork();
 
  /* \brief set ML type
   *
  */
  inline void SetType(MlType type)
  {
    m_type = type;
  }
 
  /* \brief get ML type
   *
  */
  inline MlType GetType()
  {
    return m_type;
  }
 
  /* \brief set the categories
   *
  */
  inline void SetCategories(const std::vector<std::string>& names)
  {
    m_categories = names;
  }
 
  /* \brief get the category name list
   *
  */
  std::vector<std::string> GetCategories();
 
  /* \brief get a category
   *
  */
  std::string GetCategory(unsigned int pos);
 
  /* \brief fetch the index of a label
  */
  int GetCategoryPos(std::string name);
 
  /* \brief Launch the training of the neural network
  */
  void Train();
  
  /* \brief Load a saved neural network training file 
  */
  void Load(std::string filename);
  
  /* \brief Save the training of a neural network
  */
  void Save(std::string saveFile);
 
  /* \brief Add a single labelled input for future training
   * \param input : input vector
   * \param label : label associated to the input
  */
  void AddTrainingData(std::vector<cv::Point3d> input, std::string label);
 
  /* \brief Set threshold activation value for a given label
  */
  //void SetThreshold(std::string label, float threshold);
 
  /* \brief Get threshold activation value for a given label
  */
  //float GetThreshold(std::string label);
 
  /* \brief Calculate the label which should be associated to the input vector
  */
  void Reconize(cv::Mat reconizeIn, cv::Mat reconizeOut);
  
  /* \brief Add data to the detection history
   * \param input : input vector
  */
  void AddDetectionData(std::vector<cv::Point3d>);
 
  /* \brief current state of the neural network (safe threaded)
  */
  TrainingState GetTrainingState();
 
protected:
private:
  // ! THREADED FUNCTIONS ! 
  // launch the training in a thread
  void TrainingThread();
  void DetectionThread();
 
  // ! MUTEX INSIDE !
  void SetTrainingState(TrainingState state);
 
  int Evaluate(cv::Mat& predicted, float &accuracy);
 
  std::vector<std::vector<MlFeature>> ComputeData(std::vector<std::vector<MlFeature>> ldata);
  void ValidateDetectedData();
};
 
#endif