MlToolkit.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 "Prerequisites.h"
 
#include "NeuralNetwork.h"
#include <algorithm>
 
// Scol object
int OBJMLSCOL;
 
// For CB
int WM_ML_TRAINING_FINISHED;
int WM_ML_DETECTION;
 
/************************* OBJECT CREATION AND DESTRUCTION******************************/
 
// scol CB destructor
int destroyMlObj(mmachine m, SCOL_PTR_TYPE handsys, int obj)
{
  NeuralNetwork* nnObj = MMgetPointer<NeuralNetwork*>(m, MTOP(obj));
  SAFE_DELETE(nnObj);
  MMsetPointer<NeuralNetwork*>(m, MTOP(obj), 0);
  return 0;
}
 
int _CRml(mmachine m)
{
  //fetch params
  int sensibility = MMpull(m);
  int nbval = MMpull(m);
  int mode = MMpull(m);
  int channel = MMget(m, 0);
 
  if (channel == NIL || nbval == NIL)
  {
    MMset(m, 0, NIL);
    MMechostr(MSKDEBUG, "_CRml : failed -> NIL parameter used during contruction\n");
    return 0;
  }
 
  if (sensibility == NIL)
    sensibility = FTOM(0.8f);
 
  NeuralNetwork::MlMode mlMode = NeuralNetwork::ML_POSE;
  mode = MTOI(mode);
  if (mode >= 1)
    mlMode = NeuralNetwork::ML_MOTION;
 
  NeuralNetwork* neuralnetwork = 0;
  try
  {
    neuralnetwork = new NeuralNetwork(MTOI(nbval), MTOF(sensibility), mlMode, NeuralNetwork::KNN);
  }
  catch (const cv::Exception& e)
  {
    MMechostr(MSKDEBUG, const_cast<char*>(e.what()));
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((MMpushPointer(m, neuralnetwork) != 0))
  {
    MMset(m, 0, NIL);
    SAFE_DELETE(neuralnetwork);
    MMechostr(MSKDEBUG, "_CRML : Memory allocation failed\n");
    return 0;
  }
 
        // Create a new ML object
  MMechostr(MSKDEBUG, "_CRML ...object creation successful\n");
        return OBJcreate(m, OBJMLSCOL, SCOL_PTR neuralnetwork, NIL, 0);
}
 
int _DSml(mmachine m)
{
#ifdef  _SCOL_DEBUG_
MMechostr(MSKDEBUG, "_DSml\n");
#endif
 
  int mlTab = MMget(m, 0);
  if (mlTab == NIL)
  {
    MMechostr(MSKDEBUG, "_DSML : object NIL");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, OBJMLSCOL, mlTab);
 
        MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
        return 0;
}
 
int _MlAddDetectionData(mmachine m)
{
  int list = MMpull(m);
  int mlTab = MMget(m, 0);
  if (mlTab == NIL || list == NIL)
  {
    MMechostr(MSKDEBUG, "_MlPredict : failed to fetch neural network");
    MMset(m, 0, NIL);
    return 0;
  }
 
  NeuralNetwork* nn = MMgetPointer<NeuralNetwork*>(m, MTOP(mlTab));
  if(!nn)
  {
    MMechostr(MSKDEBUG, "_MlPredict : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  list = MTOP(list);
  std::vector<cv::Point3d> input;
 
  while(list != NIL)
  {
    // Get point coordinate
    int tuple = MTOP(MMfetch(m, list, 0));
    cv::Point3d vec;
    vec.x       = MTOF(MMfetch(m, tuple, 0));
    vec.y       = MTOF(MMfetch(m, tuple, 1));
    vec.z       = MTOF(MMfetch(m, tuple, 2));
 
    input.push_back(vec);
    list = MTOP(MMfetch(m, list, 1));
  }
  nn->AddDetectionData(input);
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
 
int _MlAddTrainingData(mmachine m)
{
  int name = MMpull(m);
  int list = MMpull(m);
  int mlTab = MMget(m, 0);
 
  if (mlTab == NIL || list == NIL || name == NIL)
  {
    MMechostr(MSKDEBUG, "_MlAddTrainingData : received nil parameter");
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string label = MMstartstr(m, MTOP(name));
  NeuralNetwork* nn = MMgetPointer<NeuralNetwork*>(m, MTOP(mlTab));
  if(!nn)
  {
    MMechostr(MSKDEBUG, "_MlAddTrainingData : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  list = MTOP(list);
  std::vector<cv::Point3d> input;
 
  while(list != NIL)
  {
    // Get point coordinate
    int tuple = MTOP(MMfetch(m, list, 0));
    cv::Point3d vec;
    vec.x       = MTOF(MMfetch(m, tuple, 0));
    vec.y       = MTOF(MMfetch(m, tuple, 1));
    vec.z       = MTOF(MMfetch(m, tuple, 2));
 
    input.push_back(vec);
    list = MTOP(MMfetch(m, list, 1));
  }
 
  nn->AddTrainingData(input, label);
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
int _MlTrain(mmachine m)
{
  int mlTab = MMget(m, 0);
  if (mlTab == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  NeuralNetwork* nn = MMgetPointer<NeuralNetwork*>(m, MTOP(mlTab));
  if(!nn)
  {
    MMechostr(MSKDEBUG, "_MlTrain : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  nn->Train();
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
 
int _MlSaveData(mmachine m)
{
  int ifile = MMpull(m);
  int mlTab = MMget(m, 0);
  if (mlTab == NIL || ifile == NIL)
  {
    MMechostr(MSKDEBUG, "_MlSaveData : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  NeuralNetwork* nn = MMgetPointer<NeuralNetwork*>(m, MTOP(mlTab));
  if(!nn)
  {
    MMechostr(MSKDEBUG, "_MlSaveData : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
        std::string nameFile = MMstartstr(m, MTOP(ifile));
  try
  {
    nn->Save(nameFile);
  }
  catch(const cv::Exception&)
  {
    MMechostr(MSKDEBUG, "_MlSaveData : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
int _MlLoadData(mmachine m)
{
  int ifile = MMpull(m);
  int mlTab = MMget(m, 0);
  if (mlTab == NIL || ifile == NIL)
  {
    MMechostr(MSKDEBUG, "_MlLoadData : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  NeuralNetwork* nn = MMgetPointer<NeuralNetwork*>(m, MTOP(mlTab));
  if(!nn)
  {
    MMechostr(MSKDEBUG, "_MlLoadData : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
        std::string nameFile = MMstartstr(m, MTOP(ifile));
  nn->Load(nameFile);
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
 
int _MlGetCategories(mmachine m)
{
  int mlTab = MMget(m, 0);
  if (mlTab == NIL)
  {
    MMechostr(MSKDEBUG, "_MlGetCategories : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  NeuralNetwork* nn = MMgetPointer<NeuralNetwork*>(m, MTOP(mlTab));
  if(!nn)
  {
    MMechostr(MSKDEBUG, "_MlGetCategories : failed");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last param
  MMpull(m);
 
  int k = 0;
 
  // push the category list
  std::vector<std::string> names = nn->GetCategories();
  for(unsigned int i = 0; i < names.size(); i++)
  {
    if ((k = Mpushstrbloc(m, (char*)names[i].c_str())))
      return k;
  }
 
  if (MMpush(m, NIL))
    return MERRMEM;
 
        for(unsigned int j = 0; j < names.size(); j++)
        {
                if (MMpush(m, 2*2))
      return MERRMEM;
                if ((k = MBdeftab(m)))
      return k;
        }
 
  return 0;
}
 
 
int _CBMlTrainingFinished(mmachine m)
{
        MMechostr(MSKDEBUG, "_CBMlTrainingFinished training finished\n");
        return OBJaddreflex(m, OBJMLSCOL, SCOL_ML_TRAINING_FINISHED_CB);
}
 
int getMlTrainingFinishedCb(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE msg_ptr)
{
        if (OBJbeginreflex(m, OBJMLSCOL, SCOL_PTR id, SCOL_ML_TRAINING_FINISHED_CB))
  {
    MMechostr(MSKDEBUG, "getMlTrainingFinished ...MlTraining error\n");
                return 0;
        }
  return OBJcallreflex(m, 0);
}
 
int _CBMlDetect(mmachine m)
{
        MMechostr(MSKDEBUG, "_CBMlDetect training finished\n");
  return OBJaddreflex(m, OBJMLSCOL, SCOL_ML_DETECTION_CB);
}
 
int getMlDetectionCb(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE msg_ptr)
{
  std::string* category = (std::string*)msg_ptr;
        if (OBJbeginreflex(m, OBJMLSCOL, SCOL_PTR id, SCOL_ML_DETECTION_CB))
  {
    MMechostr(MSKDEBUG, "getMlDetectionCb ...MlDetection error\n");
    delete category;
                return 0;
        }
 
  // push the category name
  Mpushstrbloc(m, (char*)category->c_str());
  int p = OBJcallreflex(m, 1);
 
  delete category;
  return p;
}
 
 
#define NbMltkPKG 11
 
char* MltkName[NbMltkPKG] =
{
  "ObjMl",
  "_CRml",
  "_DSml",
  "_MlAddTrainingData",
  "_MlAddDetectionData",
  "_CBMlTrainingFinished",
  "_MlLoadData",
  "_MlSaveData",
  "_MlGetCategories",
  "_MlTrain",
  "_CBMlDetect"
};
 
int (*MltkFunc[NbMltkPKG]) (mmachine m) =
{
  NULL,                       //ObjMl
  _CRml,
  _DSml,
  _MlAddTrainingData,
  _MlAddDetectionData,
  _CBMlTrainingFinished,
  _MlLoadData,
  _MlSaveData,
  _MlGetCategories,
  _MlTrain,
  _CBMlDetect
};
 
int MltkNArg[NbMltkPKG] =
{
  TYPTYPE,                   //ObjMl
  4,                         //_CRml
  1,                         //_DSml
  3,                         //_MlAddTrainingData
  2,                         //_MlAddDetectionData
  3,                         //_CBMlTrainingFinished
  2,                         //_MlLoadData
  2,                         //_MlSaveData
  1,                         //_MlGetCategories
  1,                         //_MlTrain
  3                          //_CBMlDetect
};
 
char* MltkType[NbMltkPKG] =
{
  NULL,                                  //ObjMl
  "fun [Chn I I F] ObjMl",               //_CRml
  "fun [ObjMl] I",                       //_DSml
  "fun [ObjMl [[F F F] r1] S] I",        //_MlAddTrainingData
  "fun [ObjMl [[F F F] r1]] I",          //_MlAddDetectionData
  "fun [ObjMl fun [ObjMl u0] u1 u0] ObjMl",  //_CBMlTrainingFinished
  "fun [ObjMl P] I",                     //_MlLoadData
  "fun [ObjMl W] I",                     //_MlSaveData
  "fun [ObjMl] [S r1]",                  //_MlGetCategories
  "fun [ObjMl] I",                       //_MlTrain
  "fun [ObjMl fun [ObjMl u0 S] u1 u0] ObjMl" //_CBMlDetect
};
 
 
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadMlToolkit(mmachine m)
{
  int k;
  MMechostr(MSKDEBUG," > Loading MlToolkit\n");
 
  OBJMLSCOL = OBJregister(2 /*nb of callback*/, /* deleted from parent */ 1, destroyMlObj, "OBJ_ML_SCOL");
 
  // Callbacks
  WM_ML_TRAINING_FINISHED = OBJgetUserEvent();
  OBJdefEvent(WM_ML_TRAINING_FINISHED, getMlTrainingFinishedCb);
 
  WM_ML_DETECTION = OBJgetUserEvent();
  OBJdefEvent(WM_ML_DETECTION, getMlDetectionCb);
 
  k = PKhardpak(m, "MltkEngine", NbMltkPKG, MltkName, MltkFunc, MltkNArg, MltkType);
        MMechostr(MSKDEBUG," > Successfully Loaded\n");
        return k;
}