examples/ofx/Bitalino_rapidmix/src/ofApp.h

+#pragma once
+
+#include "ofMain.h"
+#include "ofxMaxim.h"
+#include "RapidBitalino.h"
+#include "BITEnvironment.hpp"
+
+class ofApp : public ofBaseApp{
+
+public:
+    void setup ( void );
+    void update ( void );
+    void draw ( void );
+    void audioOut ( float * output, int bufferSize, int nChannels );
+    void exit ( void );
+    
+    void keyPressed ( int key );
+    void keyReleased ( int key );
+    
+    void updateMouse ( int x, int y, int8_t mouseButtonState );
+    
+    void mouseMoved ( int x, int y );
+    void mouseDragged ( int x, int y, int button );
+    void mousePressed ( int x, int y, int button );
+    void mouseReleased ( int x, int y, int button );
+    void mouseEntered ( int x, int y );
+    void mouseExited ( int x, int y );
+    void windowResized ( int w, int h );
+    void dragEvent ( ofDragInfo dragInfo );
+    void gotMessage ( ofMessage msg );
+    
+		
+private:
+    int8_t mouseButtonState = -1;
+    bool mouseButtonChanged = false;
+    
+    //DEBUG
+    bool pr = false;
+    //---
+    
+    BIT::Environment bitEnvironment;
+    int		bufferSize; 
+    int		sampleRate;
+};

examples/ofx/prob_drums+ml+myo/bin/data/thung

+<group>
+	<0>100</0>
+	<1>0</1>
+	<2>44</2>
+	<3>0</3>
+	<4>100</4>
+	<5>0</5>
+	<6>45</6>
+	<7>0</7>
+	<8>100</8>
+	<9>0</9>
+	<10>45</10>
+	<11>0</11>
+</group>

examples/ofx/prob_drums+ml+myo/src/main.cpp

+#include "ofMain.h"
+#include "ofApp.h"
+
+//========================================================================
+int main( ){
+	ofSetupOpenGL(1024,768,OF_WINDOW);			// <-------- setup the GL context
+
+	// this kicks off the running of my app
+	// can be OF_WINDOW or OF_FULLSCREEN
+	// pass in width and height too:
+	ofRunApp(new ofApp());
+
+}

examples/ofx/prob_drums+ml+myo/src/ofApp.cpp

+#include <array>
+
+#include "ofApp.h"
+
+//--------------------------------------------------------------
+void ofApp::setup(){
+    
+    myo.setup();
+    
+    //gui
+    probsClear.addListener(this, &ofApp::probsClearPressed);
+    resetModel.addListener(this, &ofApp::resetModelPressed);
+    
+    guiTong.setup("tong");
+    guiTong.add(tong0.setup("1", 50, 0, 100));
+    guiTong.add(tong1.setup("2", 0, 0, 100));
+    guiTong.add(tong2.setup("3", 90, 0, 100));
+    guiTong.add(tong3.setup("4", 0, 0, 100));
+    guiTong.add(tong4.setup("5", 90, 0, 100));
+    guiTong.add(tong5.setup("6", 0, 0, 100));
+    guiTong.add(tong6.setup("7", 0, 0, 100));
+    guiTong.add(tong7.setup("8", 60, 0, 100));
+    guiTong.add(tong8.setup("9", 0, 0, 100));
+    guiTong.add(tong9.setup("10", 90, 0, 100));
+    guiTong.add(tong10.setup("11", 0, 0, 100));
+    guiTong.add(tong11.setup("12", 0, 0, 100));
+    ofColor green(0, 255, 0);
+    guiTong.setHeaderBackgroundColor(green);
+    
+    guiThung.setup("thung", "thung", 250, 10);
+    guiThung.add(thung0.setup("1", 100, 0, 100));
+    guiThung.add(thung1.setup("2", 0, 0, 100));
+    guiThung.add(thung2.setup("3", 10, 0, 100));
+    guiThung.add(thung3.setup("4", 0, 0, 100));
+    guiThung.add(thung4.setup("5", 60, 0, 100));
+    guiThung.add(thung5.setup("6", 0, 0, 100));
+    guiThung.add(thung6.setup("7", 10, 0, 100));
+    guiThung.add(thung7.setup("8", 0, 0, 100));
+    guiThung.add(thung8.setup("9", 60, 0, 100));
+    guiThung.add(thung9.setup("10", 0, 0, 100));
+    guiThung.add(thung10.setup("11", 30, 0, 100));
+    guiThung.add(thung11.setup("12", 0, 0, 100));
+    ofColor yellow(255, 255, 0);
+    guiThung.setHeaderBackgroundColor(yellow);
+    
+    guiGeneral.setup("general", "general", 500, 10);
+    guiGeneral.add(gain.setup("gain", 1., 0., 1.));
+    guiGeneral.add(modelControl.setup("run model", false));
+    guiGeneral.add(resetModel.setup("reset model"));
+    guiGeneral.add(inputDevice.setup("myo", false));
+    guiGeneral.add(probsClear.setup("clear"));
+    
+    //This will make life easier later
+    allSliders.push_back(tong0);
+    allSliders.push_back(tong1);
+    allSliders.push_back(tong2);
+    allSliders.push_back(tong3);
+    allSliders.push_back(tong4);
+    allSliders.push_back(tong5);
+    allSliders.push_back(tong6);
+    allSliders.push_back(tong7);
+    allSliders.push_back(tong8);
+    allSliders.push_back(tong9);
+    allSliders.push_back(tong10);
+    allSliders.push_back(tong11);
+    allSliders.push_back(thung0);
+    allSliders.push_back(thung1);
+    allSliders.push_back(thung2);
+    allSliders.push_back(thung3);
+    allSliders.push_back(thung4);
+    allSliders.push_back(thung5);
+    allSliders.push_back(thung6);
+    allSliders.push_back(thung7);
+    allSliders.push_back(thung8);
+    allSliders.push_back(thung9);
+    allSliders.push_back(thung10);
+    allSliders.push_back(thung11);
+    
+    //RapidLib
+    trained = false;
+    
+    //loading samples
+    saron_sbpl1.load(ofToDataPath("saron-sbpl1.wav"));
+    saron_sbpl2.load(ofToDataPath("saron-sbpl2.wav"));
+    saron_sbpl3.load(ofToDataPath("saron-sbpl3.wav"));
+    saron_sbpl4.load(ofToDataPath("saron-sbpl4.wav"));
+    saron_sbpl5.load(ofToDataPath("saron-sbpl5.wav"));
+    
+    ciblon_tong.load(ofToDataPath("drums-ciblon-medium-tong.wav"));
+    ciblon_thung.load(ofToDataPath("drums-ciblon-medium-thung.wav"));
+    
+    //maxi Clock
+    myClock.setTicksPerBeat(4);//This sets the number of ticks per beat
+    myClock.setTempo(120);// This sets the tempo in Beats Per Minute
+    
+    //audio setup
+    sampleRate 	= 44100;
+    bufferSize	= 512;
+    
+    ofxMaxiSettings::setup(sampleRate, 2, initialBufferSize);
+    ofSoundStreamSetup(2,2,this, sampleRate, bufferSize, 4);
+}
+
+//--------------------------------------------------------------
+void ofApp::update(){
+
+    if (inputDevice) { //Only when Myo is toggled on
+        
+        //Simple gain control
+        float emg = myo.getDevices()[0]->getEmgSamples()[4];
+        streamBuf.pushToWindow(double(emg));
+        gain = streamBuf.rms() * 0.01;
+        
+        //Machine learning with quarternions
+        double myoX = myo.getDevices()[0]->getQuaternion().x();
+        double myoY = myo.getDevices()[0]->getQuaternion().y();
+        double myoZ = myo.getDevices()[0]->getQuaternion().z();
+        double myoW = myo.getDevices()[0]->getQuaternion().w();
+        
+        if (inputDevice) {
+            if (recordingState > 0) {
+                trainingExample tempExample;
+                tempExample.input = { myoX, myoY, myoZ, myoW };
+                for (int i = 0; i < allSliders.size() ; ++i) {
+                    tempExample.output.push_back(double(allSliders[i]));
+                }
+                trainingSet.push_back(tempExample);
+            } else if (trained && modelControl == 1) {
+                std::vector<double> inputVec;
+                inputVec.push_back(myoX);
+                inputVec.push_back(myoY);
+                inputVec.push_back(myoZ);
+                inputVec.push_back(myoW);
+                std::vector<double> output = myNN.run(inputVec);
+                
+                for (int i = 0; i < output.size(); ++i) {
+                    allSliders[i] = int(output[i]);
+                }
+            }
+        }
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::exit(){
+    myo.stop();
+}
+
+
+//--------------------------------------------------------------
+void ofApp::draw(){
+    //ofClear(0);
+    ofDrawBitmapString(currentBeat, 100, 300);
+    ofDrawBitmapString("Hold space to record", 200, 300);
+    
+    guiTong.draw();
+    guiThung.draw();
+    guiGeneral.draw();
+    
+    if (inputDevice) {
+        ofSetColor(255);
+        for ( int i=0; i<myo.getDevices().size(); i++ ) {
+            stringstream s;
+            s << "id: " << myo.getDevices()[i]->getId() << endl;
+            s << "which: " << myo.getDevices()[i]->getWhichArm() << endl;
+            s << "pose: " << myo.getDevices()[i]->getPose() << endl;
+            s << "accel:          ";
+            s << myo.getDevices()[i]->getAccel().x << ",";
+            s << myo.getDevices()[i]->getAccel().y << ",";
+            s << myo.getDevices()[i]->getAccel().z << endl;
+            s << "gyro:           ";
+            s << myo.getDevices()[i]->getGyro().x << ",";
+            s << myo.getDevices()[i]->getGyro().y << ",";
+            s << myo.getDevices()[i]->getGyro().z << endl;
+            s << "quaternion:     ";
+            s << myo.getDevices()[i]->getQuaternion().x() << ",";
+            s << myo.getDevices()[i]->getQuaternion().y() << ",";
+            s << myo.getDevices()[i]->getQuaternion().z() << ",";
+            s << myo.getDevices()[i]->getQuaternion().w() << endl;
+            s << "roll/pitch/yaw: ";
+            s << myo.getDevices()[i]->getRoll() << ",";
+            s << myo.getDevices()[i]->getPitch() << ",";
+            s << myo.getDevices()[i]->getYaw() << endl;
+            s << "raw data:       ";
+            for ( int j=0; j<8; j++ ) {
+                s << myo.getDevices()[i]->getEmgSamples()[j];
+                s << ",";
+            }
+            s << endl;
+            ofSetColor(0);
+            ofDrawBitmapString(s.str(), 10, 400 + i*100);
+        }
+    }
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::probsClearPressed() {
+    std::cout << "clearing probs" << std::endl;
+    for (int i = 0; i < allSliders.size(); ++i) {
+        allSliders[i] = 0;
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::resetModelPressed() {
+    std::cout << "resetting models" << std::endl;
+    myNN.reset();
+    trainingSet.clear();
+    modelControl = false;
+}
+
+//--------------------------------------------------------------
+bool eventTest(int prob) {
+    int testRand = rand() % 100;
+    if (testRand < prob) {
+        return true;
+    }
+    return false;
+}
+
+//--------------------------------------------------------------
+void ofApp::audioOut(float * output, int bufferSize, int nChannels) {
+    //probs = { tong0, tong1, tong2, tong3, tong4, tong5, tong6, tong7, tong8, tong9, tong10, tong11 };
+    //probs2 = { thung0, thung1, thung2, thung3, thung4, thung5, thung6, thung7, thung8, thung9, thung10, thung11 };
+    bool beatsTong[12];
+    bool beats2[12];
+    for (int i = 0; i < 12; ++i) {
+        beatsTong[i] = eventTest(allSliders[i]);
+        beats2[i] = eventTest(allSliders[i + 12]);
+    }
+    int lastCount = 0;
+    int testMe = 0;
+    for (int i = 0; i < bufferSize; i++){
+        
+        myClock.ticker();
+        if (myClock.tick) {
+            if (beatsTong[currentBeat]) {
+                ciblon_tong.trigger();
+            }
+            if (beats2[currentBeat]) {
+                ciblon_thung.trigger();
+            }
+            currentBeat = (currentBeat + 1) % 12;
+        }
+        
+        outputs[0] = ciblon_tong.playOnce() * gain;
+        outputs[1] = ciblon_thung.playOnce() * gain;
+        output[i*nChannels    ] = outputs[0];
+        output[i*nChannels + 1] = outputs[1];
+    }
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::keyPressed(int key){
+    //std::cout << "key: " << key << std::endl;
+    switch(key) {
+        case 32:
+            recordingState = 1;
+            break;
+        case 13:
+            modelControl = (modelControl) ? false : true;
+            break;
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::keyReleased(int key){
+    recordingState = 0;
+    if (trainingSet.size() > 0) {
+        trained = myNN.train(trainingSet);
+        std::cout << "trained: " << trained << std::endl;
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseMoved(int x, int y ){
+    if (inputDevice == false) { //don't do this with Myo is on
+        if (recordingState > 0) {
+            trainingExample tempExample;
+            tempExample.input = { double(x), double(y) };
+            for (int i = 0; i < allSliders.size() ; ++i) {
+                tempExample.output.push_back(double(allSliders[i]));
+            }
+            trainingSet.push_back(tempExample);
+        } else if (trained && modelControl == 1) {
+            std::vector<double> inputVec;
+            inputVec.push_back(double(x));
+            inputVec.push_back(double(y));
+            std::vector<double> output = myNN.run(inputVec);
+            
+            for (int i = 0; i < output.size(); ++i) {
+                allSliders[i] = int(output[i]);
+            }
+        }
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseDragged(int x, int y, int button){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::mousePressed(int x, int y, int button){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseReleased(int x, int y, int button){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseEntered(int x, int y){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseExited(int x, int y){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::windowResized(int w, int h){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::gotMessage(ofMessage msg){
+    
+}
+
+//--------------------------------------------------------------
+void ofApp::dragEvent(ofDragInfo dragInfo){
+    
+}

examples/ofx/prob_drums+ml+myo/src/ofApp.h

+#pragma once
+
+#include <vector>
+
+#include "ofMain.h"
+#include "ofxGui.h"
+#include "ofxMyo.h"
+#include "ofxMaxim.h"
+#include "regression.h"
+#include "rapidStream.h"
+
+class ofApp : public ofBaseApp{
+    
+public:
+    void setup();
+    void update();
+    void draw();
+    void exit();
+    
+    void keyPressed(int key);
+    void keyReleased(int key);
+    void mouseMoved(int x, int y );
+    void mouseDragged(int x, int y, int button);
+    void mousePressed(int x, int y, int button);
+    void mouseReleased(int x, int y, int button);
+    void mouseEntered(int x, int y);
+    void mouseExited(int x, int y);
+    void windowResized(int w, int h);
+    void dragEvent(ofDragInfo dragInfo);
+    void gotMessage(ofMessage msg);
+    
+    void probsClearPressed();
+    void resetModelPressed();
+    
+    ofxIntSlider thung0, thung1, thung2, thung3;
+    ofxIntSlider thung4, thung5, thung6, thung7;
+    ofxIntSlider thung8, thung9, thung10, thung11;
+    std::vector<ofxIntSlider> thungs;
+    ofxPanel guiThung;
+
+    ofxIntSlider tong0, tong1, tong2, tong3;
+    ofxIntSlider tong4, tong5, tong6, tong7;
+    ofxIntSlider tong8, tong9, tong10, tong11;
+    ofxPanel guiTong;
+    
+    ofxFloatSlider gain;
+    ofxToggle inputDevice;
+    ofxToggle modelControl;
+    ofxButton resetModel;
+    ofxButton probsClear;
+    ofxPanel guiGeneral;
+    
+    std::vector<ofxIntSlider> allSliders;
+    
+    //Maxi
+    void audioOut(float * output, int bufferSize, int nChannels);
+    //void audioIn(float * input, int bufferSize, int nChannels);
+    
+    int	bufferSize;
+    int	initialBufferSize;
+    int sampleRate;
+    
+private:
+    
+    ofxMyo::Myo myo;
+    
+    //---------Maxi---------------//
+    double outputs[2];
+    
+    maxiSample saron_sbpl1;
+    maxiSample saron_sbpl2;
+    maxiSample saron_sbpl3;
+    maxiSample saron_sbpl4;
+    maxiSample saron_sbpl5;
+    
+    maxiSample ciblon_tong;
+    maxiSample ciblon_thung;
+    
+    maxiClock myClock;
+   
+    int currentBeat;
+    
+    //---------RapidLib---------------//
+    regression myNN;
+    std::vector<trainingExample> trainingSet;
+    int recordingState;
+    bool trained;
+    
+    rapidStream streamBuf = rapidStream(25);
+    
+};

rmix_build_test.sh

+#!/bin/bash
+
+#Make sure we've got the latest version
+git pull
+git submodule update --init --recursive
+
+rm -rf build/
+mkdir build
+cd build
+cmake ..
+make
+./rapidmixTest
+cp ./helloRapidMix ../examples/HelloRapidMix/helloRapidMix
\ No newline at end of file

src/machineLearning/machineLearning.cpp

-/*
- * machineLearning.cpp
- * Created by Michael Zbyszynski on 10 Jan 2016
+/**
+ * @file machineLearning.cpp
+ * @author Michael Zbyszynski
+ * @date 10 Jan 2016
+ * @copyright
  * Copyright © 2017 Goldsmiths. All rights reserved.
  */
 
 #include "machineLearning.h"
 
-RAPIDMIX_BEGIN_NAMESPACE
-
-void trainingData2rapidLib (const trainingData &newTrainingData, std::vector<trainingExample> &trainingSet) {
-    for (int h = 0; h < newTrainingData.trainingSet.size(); ++h) { //Go through every phrase
-        for (int i = 0; i < newTrainingData.trainingSet[h].elements.size(); ++i) { //...and every element
-            trainingExample tempExample;
-            tempExample.input = newTrainingData.trainingSet[h].elements[i].input;
-            if (newTrainingData.trainingSet[h].elements[i].output.size() > 0) {
-                tempExample.output = newTrainingData.trainingSet[h].elements[i].output;
-            } else {
-                std::unordered_map<std::string, int>::const_iterator mappedLabel = newTrainingData.labels.find(newTrainingData.trainingSet[h].label);
-                tempExample.output.push_back(double(mappedLabel->second));
+namespace rapidmix {
+    
+    //////////////////////////////////////////////////////////////////////// Generic train
+    template <class MachineLearningModule>
+    bool machineLearning<MachineLearningModule>::train(const trainingData &newTrainingData) {
+        return MachineLearningModule::train(newTrainingData);
+    }
+    
+    /////////////////////////////////////////////////////////////////////// RapidLib specializations
+    
+    void trainingData2rapidLib (const trainingData &newTrainingData, std::vector<trainingExample> &trainingSet) {
+        for (int h = 0; h < newTrainingData.trainingSet.size(); ++h) { //Go through every phrase
+            
+            for (int i = 0; i < newTrainingData.trainingSet[h].elements.size(); ++i) { //...and every element
+                trainingExample tempExample;
+                tempExample.input = newTrainingData.trainingSet[h].elements[i].input;
+                if (newTrainingData.trainingSet[h].elements[i].output.size() > 0) {
+                    tempExample.output = newTrainingData.trainingSet[h].elements[i].output;
+                } else {
+                    tempExample.output.push_back(double(h));
+                }
+                trainingSet.push_back(tempExample);
             }
-            trainingSet.push_back(tempExample);
         }
+    };
+    
+    /////////////////////////////////////////////////////////////////////// RapidLib classification
+    template<>
+    bool machineLearning<classification>::train(const trainingData &newTrainingData) {
+        std::vector<trainingExample> trainingSet;
+        labels.clear();
+        for (int i = 0; i < newTrainingData.trainingSet.size(); ++i) {
+            labels.push_back(newTrainingData.trainingSet[i].label);
+        }
+        trainingData2rapidLib(newTrainingData, trainingSet);
+        return classification::train(trainingSet);
+    }
+    
+    template<>
+    std::string machineLearning<classification>::run(const std::vector<double> &inputVector, const std::string &label) {
+        int classIndex = classification::run(inputVector)[0];
+        return labels[classIndex];
+    };
+    
+    /////////////////////////////////////////////////////////////////////// RapidLib regression
+    template<>
+    bool machineLearning<regression>::train(const trainingData &newTrainingData) {
+        std::vector<trainingExample> trainingSet;
+        trainingData2rapidLib(newTrainingData, trainingSet);
+        return regression::train(trainingSet);
+    }
+    
+    /////////////////////////////////////////////////////////////////////// RapidLib seriesClassification
+    template<>
+    bool machineLearning<seriesClassification>::train(const trainingData &newTrainingData) {
+        std::vector<trainingSeries> seriesSet;
+        for (int i = 0; i < newTrainingData.trainingSet.size(); ++i) { //each phrase
+            trainingSeries tempSeries;
+            tempSeries.label = newTrainingData.trainingSet[i].label;
+            for (int j = 0; j < newTrainingData.trainingSet[i].elements.size(); ++j) { //each element
+                tempSeries.input.push_back(newTrainingData.trainingSet[i].elements[j].input);
+            }
+            seriesSet.push_back(tempSeries);
+        }
+        return seriesClassification::train(seriesSet);
+    }
+    
+    template<>
+    std::string machineLearning<seriesClassification>::run(const std::vector<std::vector<double> > &inputSeries) {
+        return seriesClassification::run(inputSeries);
+    }
+    
+    
+    /////////////////////////////////////////////////////////////////////// GVF
+    template<>
+    bool machineLearning<rapidGVF>::train(const trainingData &newTrainingData) {
+        return rapidGVF::train(newTrainingData);
     }
-};
-
-template<>
-bool machineLearning<classification>::train(const trainingData &newTrainingData) {
-    std::vector<trainingExample> trainingSet;
-    trainingData2rapidLib(newTrainingData, trainingSet);
-    return classification::train(trainingSet);
-}
-
-template<>
-bool machineLearning<regression>::train(const trainingData &newTrainingData) {
-    std::vector<trainingExample> trainingSet;
-    trainingData2rapidLib(newTrainingData, trainingSet);
-    return regression::train(trainingSet);
 }
-
-
-RAPIDMIX_END_NAMESPACE

src/machineLearning/machineLearning.h

-/*
- * machineLearning.h
- * Created by Michael Zbyszynski on 10 Jan 2016
+/**
+ * @file machineLearning.h
+ * @author Michael Zbyszynski on 10 Jan 2016
+ * @copyright
  * Copyright © 2017 Goldsmiths. All rights reserved.
+ *
+ * @ingroup machinelearning
  */
 
 #ifndef machineLearning_h
 #define machineLearning_h
 
-#include "rapidMix.h"
-#include "trainingData.h"
+#include <vector>
+#include "../rapidmix.h"
 
 ////////// Include all of the machine learning algorithms here
 #include "classification.h"
 #include "regression.h"
-#include "rapidXmmTools.h"
-//#include "gvf.h"
+#include "seriesClassification.h"
+#include "./rapidXMM/rapidXMM.h"
+#include "./rapidGVF/rapidGVF.h"
 
-// forward declaration
-namespace rapidmix { class trainingData; }
-
-RAPIDMIX_BEGIN_NAMESPACE
-
-//* Host class for machine learning algorithms */
-template <typename MachineLearningModule>
-class machineLearning : public MachineLearningModule {
-public:
+namespace rapidmix {
     
-    //* Constructors */
-    machineLearning() : MachineLearningModule() {};
+    // forward declaration
+    class trainingData;
     
-    template<class T>
-    machineLearning(T type) : MachineLearningModule(type) {};
+    /** @brief A generic ouptut struct to fit all kinds of models */
+    typedef struct runResults_t {
+        std::vector<double> likelihoods;
+        std::vector<double> regression;
+        std::vector<double> progressions;
+        std::string likeliest;
+    } runResults;
     
-    //* this function becomes specialized in the implementation */
-    bool train(const trainingData &newTrainingData);
+    /**
+     * @brief Host class for machine learning algorithms
+     */
+    template <typename MachineLearningModule>
+    class machineLearning : public MachineLearningModule {
+    public:
+        
+        //* Constructors */
+        machineLearning() : MachineLearningModule() {};
+        
+        template<class T>
+        machineLearning(T type) : MachineLearningModule(type) {};
+        
+        /**
+         * @brief This function becomes specialized in the implementation
+         */
+        bool train(const trainingData &newTrainingData);
+        
+        //* this function is not being specialized
+        std::vector<double> run(const std::vector<double> &inputVector) {
+            return MachineLearningModule::run(inputVector);
+        }
+        
+        // This is a hack while I think about how to do this. -MZ //
+        std::string run(const std::vector<double> &inputVector, const std::string &label);
+        
+        //* This is the one I'm using for DTW */
+        std::string run(const std::vector<std::vector<double> > &inputSeries);
+        
+        bool reset() {
+            return MachineLearningModule::reset();
+        }
+        
+    private:
+        MachineLearningModule module;
+        
+        //this holds string labels
+        std::vector<std::string> labels; //FIXME: This probably should be pushed down into rapidLib?
+        std::string getLabel(int value);
+        
+    };
     
-    // Could overload this, or specialize, or both
-    std::vector<double> run(const std::vector<double> &inputVector) {
-        return MachineLearningModule::process(inputVector);
-    }
+    ////////// typedefs for calling different algorithms
     
-    bool reset() {
-        return MachineLearningModule::reset();
-    }
+    ///// RapidLib
     
-private:
-    MachineLearningModule module;
-};
-
-////////// typedefs for calling different algorithms
-
-typedef machineLearning<classification> staticClassification;
-typedef machineLearning<regression> staticRegression;
-
-typedef xmmToolConfig xmmConfig;
-typedef machineLearning<xmmGmmTool> xmmStaticClassification;
-typedef machineLearning<xmmGmrTool> xmmStaticRegression;
-typedef machineLearning<xmmHmmTool> xmmTemporalClassification;
-typedef machineLearning<xmmHmrTool> xmmTemporalRegression;
-//*/
-
-/*
-typedef machineLearning<GVF> gvf;
-//*/
-
-RAPIDMIX_END_NAMESPACE
+    /** @brief static classification using KNN from RapidLib */
+    typedef machineLearning<classification> staticClassification;
+    
+    /** @brief static regression using Neural Networks from RapidLib */
+    typedef machineLearning<regression> staticRegression;
+    
+    /** @brief temporal classification using Dynamic Time Warping from RapidLib */
+    typedef machineLearning<seriesClassification> dtwTemporalClassification;
+    
+    ///// XMM
+    
+    /** @brief configuration for XMM based algorithms */
+    typedef xmmToolConfig xmmConfig;
+    
+    /** @brief static classification using Gaussian Mixture Models from XMM */
+    typedef machineLearning<rapidXmmGmm> xmmStaticClassification;
+    
+    /** @brief static regression using Gaussian Mixture Models from XMM */
+    typedef machineLearning<rapidXmmGmr> xmmStaticRegression;
+    
+    /** @brief temporal classification using Hierarchical Hidden Markov Models from XMM */
+    typedef machineLearning<rapidXmmHmm> xmmTemporalClassification;
+    
+    /** @brief temporal regression using Hierarchical Hidden Markov Models from XMM */
+    typedef machineLearning<rapidXmmHmr> xmmTemporalRegression;
+    
+    ///// GVF
+    
+    /** @brief temporal variation estimation using GVF library */
+    typedef machineLearning<rapidGVF> gvfTemporalVariation;
+    
+    
+}
 
 #endif

src/machineLearning/rapidGVF/rapidGVF.cpp

+//
+//  rapidGVF.cpp
+//
+//  Created by Francisco on 04/05/2017.
+//  Copyright © 2017 Goldsmiths. All rights reserved.
+//
+
+#include "rapidGVF.h"
+#include "../trainingData.h"
+
+rapidGVF::rapidGVF() {}
+
+rapidGVF::~rapidGVF() {}
+
+bool rapidGVF::train(const rapidmix::trainingData &newTrainingData)
+{
+    
+    if (newTrainingData.trainingSet.size() < 1)
+    {
+        // no recorded phrase
+        return false;
+    }
+    
+    if (newTrainingData.trainingSet.size() == 1 && newTrainingData.trainingSet[0].elements.size() == 0) {
+        // empty recorded phrase
+        return false;
+    }
+    
+    if(gvf.getState() != GVF::STATE_LEARNING)
+    {
+        gvf.setState(GVF::STATE_LEARNING);
+    }
+    
+    //Go through every phrase
+    for (int h = 0; h < newTrainingData.trainingSet.size(); ++h)
+    {
+        gvf.startGesture();
+        for (int i = 0; i < newTrainingData.trainingSet[h].elements.size(); ++i)
+        {
+            std::vector<double> vd = newTrainingData.trainingSet[h].elements[i].input;
+
+            // Using template <class InputIterator> vector to change for vec<double> to vec<float>
+            std::vector<float> vf(vd.begin(), vd.end());
+            this->currentGesture.addObservation(vf);
+        }
+        gvf.addGestureTemplate(this->currentGesture);
+    }
+    return true;
+}
+
+std::vector<double> rapidGVF::run(const std::vector<double> &inputVector)
+{
+    
+    if (inputVector.size() == 0)
+    {
+        return std::vector<double>();
+    }
+    
+    gvf.restart();
+    
+    if (gvf.getState() != GVF::STATE_FOLLOWING)
+    {
+        gvf.setState(GVF::STATE_FOLLOWING);
+    }
+    
+    // Using template <class InputIterator> vector to change for vec<double> to vec<float>
+    std::vector<float> vf(inputVector.begin(),inputVector.end());
+    
+    this->currentGesture.addObservation(vf);
+    outcomes = gvf.update(this->currentGesture.getLastObservation());
+    
+    std::vector<double> output;
+    output.push_back(outcomes.likeliestGesture);
+    output.insert(output.end(), outcomes.likelihoods.begin(), outcomes.likelihoods.end());
+    output.insert(output.end(), outcomes.alignments.begin(), outcomes.alignments.end());
+    return output;
+}
+
+const std::vector<float> rapidGVF::getLikelihoods()
+{
+    return outcomes.likelihoods;
+};
+
+const std::vector<float> rapidGVF::getAlignments()
+{
+    return outcomes.alignments;
+};
+
+const std::vector<std::vector<float> > * rapidGVF::getDynamics()
+{
+    return &outcomes.dynamics;
+};
+
+const std::vector<std::vector<float> > * rapidGVF::getScalings()
+{
+    return &outcomes.scalings;
+};
+
+const std::vector<std::vector<float> > * rapidGVF::getRotations()
+{
+    return &outcomes.rotations;
+};

src/machineLearning/rapidGVF/rapidGVF.h

+/**
+ * @file rapidGVF.h
+ * Created by Francisco on 04/05/2017.
+ * Copyright © 2017 Goldsmiths. All rights reserved.
+ *
+ * @ingroup machinelearning
+ */
+
+#ifndef rapidGVF_h
+#define rapidGVF_h
+
+#include <vector>
+#include <string>
+#include "GVF.h"
+
+namespace rapidmix { class trainingData; }
+
+/**
+ * @brief This class is an adapter for the GVF library from Baptiste Caramiaux
+ */
+class rapidGVF {
+
+public:
+    rapidGVF();
+    ~rapidGVF();
+
+    bool train(const rapidmix::trainingData &newTrainingData);
+    std::vector<double> run(const std::vector<double> &inputVector);
+    //TODO: needs a "reset" message
+
+    const std::vector<float> getLikelihoods();
+    const std::vector<float> getAlignments();
+    const std::vector<std::vector<float> > * getDynamics();
+    const std::vector<std::vector<float> > * getScalings();
+    const std::vector<std::vector<float> > * getRotations();
+    
+private:
+    GVF gvf;
+    GVFGesture currentGesture;
+    GVFOutcomes outcomes;
+};
+
+#endif

src/machineLearning/rapidXmmTools/rapidXmmTools.cpp → src/machineLearning/rapidXMM/rapidXMM.cpp

-#include "rapidXmmTools.h"
-#include "trainingData.h"
-#include "machineLearning.h"
+#include "rapidXMM.h"
+#include "../trainingData.h"
+#include "../machineLearning.h"
 
 static bool trainingData2xmmTrainingSet(const rapidmix::trainingData& data, xmm::TrainingSet& set) {
-  if (data.trainingSet.size() <= 1) {
-    // no recorded phrase (only default one)
+  if (data.trainingSet.size() < 1) {
     return false;
   }
 
-  if (data.trainingSet.size() > 1 && data.trainingSet[1].elements.size() == 0) {
+  if (data.trainingSet.size() > 0 && data.trainingSet[0].elements.size() == 0) {
     // empty recorded phrase
     return false;
   }
 
-  rapidmix::trainingData::element el = data.trainingSet[1].elements[0];
+  rapidmix::trainingData::element el = data.trainingSet[0].elements[0];
   int dimIn = static_cast<int>(el.input.size());
   int dimOut = static_cast<int>(el.output.size());
 
@@ -43,9 +42,7 @@ static bool trainingData2xmmTrainingSet(const rapidmix::trainingData& data, xmm:
   set.clear();
 
   //for (auto &phrase : data.trainingSet) {
-  // changed to look starting from index 1
-  // because phrase at index 0 is for unordered elements
-  for (int i = 1; i < data.trainingSet.size(); ++i) {
+  for (int i = 0; i < data.trainingSet.size(); ++i) {
     const rapidmix::trainingData::phrase &phrase = data.trainingSet[i];
     xp.clear();
     xp.label.set(phrase.label);
@@ -84,25 +81,27 @@ bool xmmTool<SingleClassModel, Model>::train(const rapidmix::trainingData& newTr
 template <class SingleClassModel, class Model>
 Json::Value xmmTool<SingleClassModel, Model>::toJSON(/*std::string modelType*/) {
   Json::Value root;
-  Json::Value metadata;
-  Json::Value modelSet;
 
-  metadata["creator"] = "Rapid API C++";
-  metadata["version"] = "v0.1.1"; //TODO: This should be a macro someplace
-  metadata["family"] = "xmm";
-  root["metadata"] = metadata;
+  root["docType"] = "rapid-mix:ml-model";
+  root["docVersion"] = RAPIDMIX_JSON_DOC_VERSION;
 
-  modelSet.append(model.toJson());
-  root["modelSet"] = modelSet;
+  Json::Value target;
+
+  target["name"] = "xmm";
+  target["version"] = "v1.0.0";
+
+  root["target"] = target;
+  root["payload"] = model.toJson();
 
   return root;
 }
 
 template <class SingleClassModel, class Model>
 bool xmmTool<SingleClassModel, Model>::fromJSON(Json::Value &jm) {
-  if (jm["metadata"]["family"].asString().compare("xmm") == 0 &&
-      jm["modelSet"].size() > 0) {
-    model.fromJson(jm["modelSet"][0]);
+  if (jm["docType"].asString().compare("rapid-mix:ml-model") == 0 &&
+      jm["target"]["name"].asString().compare("xmm") == 0 &&
+      jm["payload"].size() > 0) {
+    model.fromJson(jm["payload"]);
     model.reset();
     return true;
   }
@@ -146,14 +145,14 @@ bool xmmTool<SingleClassModel, Model>::readJSON(const std::string &filepath) {
 
 //============================== xmmGmmTool ==================================//
 
-std::vector<double> xmmGmmTool::process(const std::vector<double>& inputVector) {
+std::vector<double> rapidXmmGmm::run(const std::vector<double>& inputVector) {
   xmmTool::preProcess(inputVector);
   return model.results.smoothed_normalized_likelihoods;
 }
 
 //============================== xmmGmrTool ==================================//
 
-std::vector<double> xmmGmrTool::process(const std::vector<double>& inputVector) {
+std::vector<double> rapidXmmGmr::run(const std::vector<double>& inputVector) {
   xmmTool::preProcess(inputVector);
   std::vector<float> *res = &model.results.output_values;
   std::vector<double> dRes(res->begin(), res->end());
@@ -162,7 +161,7 @@ std::vector<double> xmmGmrTool::process(const std::vector<double>& inputVector)
 
 //============================== xmmHmmTool ==================================//
 
-std::vector<double> xmmHmmTool::process(const std::vector<double>& inputVector) {
+std::vector<double> rapidXmmHmm::run(const std::vector<double>& inputVector) {
   xmmTool::preProcess(inputVector);
   std::vector<double> res;
 
@@ -178,7 +177,7 @@ std::vector<double> xmmHmmTool::process(const std::vector<double>& inputVector)
 
 //============================== xmmHmrTool ==================================//
 
-std::vector<double> xmmHmrTool::process(const std::vector<double>& inputVector) {
+std::vector<double> rapidXmmHmr::run(const std::vector<double>& inputVector) {
   xmmTool::preProcess(inputVector);
   std::vector<float> *res = &model.results.output_values;
   std::vector<double> dRes(res->begin(), res->end());
@@ -186,16 +185,27 @@ std::vector<double> xmmHmrTool::process(const std::vector<double>& inputVector)
 }
 
 ///////////////////////////////////////////////////////////////////////////
-///// generic train method and forward declaration of specialized templates 
+///// generic train method and forward declaration of specialized templates
 ///////////////////////////////////////////////////////////////////////////
 
+template class xmmTool<xmm::GMM, xmm::GMM>;
+template class xmmTool<xmm::HMM, xmm::HierarchicalHMM>;
+
+template class xmmStaticTool<xmm::GMM, xmm::GMM>;
+template class xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM>;
+
+//I wonder why this can't be defined in machineLearning.cpp? -MZ
+
+// It is needed by the template instantiations below.
+// You get an undefined symbols error otherwise.
+
 template <class MachineLearningModule>
 bool rapidmix::machineLearning<MachineLearningModule>::train(const trainingData &newTrainingData) {
     return MachineLearningModule::train(newTrainingData);
 }
 
-template class rapidmix::machineLearning<xmmGmmTool>;
-template class rapidmix::machineLearning<xmmGmrTool>;
-template class rapidmix::machineLearning<xmmHmmTool>;
-template class rapidmix::machineLearning<xmmHmrTool>;
+template class rapidmix::machineLearning<rapidXmmGmm>;
+template class rapidmix::machineLearning<rapidXmmGmr>;
+template class rapidmix::machineLearning<rapidXmmHmm>;
+template class rapidmix::machineLearning<rapidXmmHmr>;
 

src/machineLearning/rapidXmmTools/rapidXmmTools.h → src/machineLearning/rapidXMM/rapidXMM.h

+/**
+ * @file rapidXMM.h
+ * @author joseph larralde
+ *
+ * @copyright
+ * Copyright (C) 2016 - 2017 by IRCAM - Centre Pompidou, Paris, France.
+ * All rights reserved.
+ *
+ * @ingroup machinelearning
+ */
+
 #ifndef _RAPID_XMM_TOOLS_H_
 #define _RAPID_XMM_TOOLS_H_
 
@@ -129,7 +140,7 @@ protected:
     mCfg.gaussians.set(cfg.gaussians);
     mCfg.relative_regularization.set(cfg.relativeRegularization);
     mCfg.absolute_regularization.set(cfg.absoluteRegularization);
-    
+
     xmm::MultiClassRegressionEstimator mcre;
     switch (cfg.regressionEstimator) {
       case xmmLikeliestRegression:
@@ -210,40 +221,52 @@ public:
 
 //================== actual classes used in machineLearning.h ================//
 
-class xmmGmmTool : public xmmStaticTool<xmm::GMM, xmm::GMM> {
+/**
+ * @brief Static classification using Gaussian Mixture Models
+ */
+class rapidXmmGmm : public xmmStaticTool<xmm::GMM, xmm::GMM> {
 public:
-  xmmGmmTool(xmmToolConfig cfg = xmmToolConfig()) :
+  rapidXmmGmm(xmmToolConfig cfg = xmmToolConfig()) :
   xmmStaticTool<xmm::GMM, xmm::GMM>(cfg, false) {}
-  ~xmmGmmTool() {}
+  ~rapidXmmGmm() {}
 
-  std::vector<double> process(const std::vector<double>& inputVector);
+  std::vector<double> run(const std::vector<double>& inputVector);
 };
 
-class xmmGmrTool : public xmmStaticTool<xmm::GMM, xmm::GMM> {
+/**
+ * @brief Static regression using Gaussian Mixture Models
+ */
+class rapidXmmGmr : public xmmStaticTool<xmm::GMM, xmm::GMM> {
 public:
-  xmmGmrTool(xmmToolConfig cfg = xmmToolConfig()) :
+  rapidXmmGmr(xmmToolConfig cfg = xmmToolConfig()) :
   xmmStaticTool<xmm::GMM, xmm::GMM>(cfg, true) {}
-  ~xmmGmrTool() {}
+  ~rapidXmmGmr() {}
 
-  std::vector<double> process(const std::vector<double>& inputVector);
+  std::vector<double> run(const std::vector<double>& inputVector);
 };
 
-class xmmHmmTool : public xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM> {
+/**
+ * @brief Temporal classification using Hierarchical Hidden Markov Models
+ */
+class rapidXmmHmm : public xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM> {
 public:
-  xmmHmmTool(xmmToolConfig cfg = xmmToolConfig()) :
+  rapidXmmHmm(xmmToolConfig cfg = xmmToolConfig()) :
   xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM>(cfg, false) {}
-  ~xmmHmmTool() {}
+  ~rapidXmmHmm() {}
 
-  std::vector<double> process(const std::vector<double>& inputVector);
+  std::vector<double> run(const std::vector<double>& inputVector);
 };
 
-class xmmHmrTool : public xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM> {
+/**
+ * @brief Temporal regression using Hierarchical Hidden Markov Models
+ */
+class rapidXmmHmr : public xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM> {
 public:
-  xmmHmrTool(xmmToolConfig cfg = xmmToolConfig()) :
+  rapidXmmHmr(xmmToolConfig cfg = xmmToolConfig()) :
   xmmTemporalTool<xmm::HMM, xmm::HierarchicalHMM>(cfg, true) {}
-  ~xmmHmrTool() {}
+  ~rapidXmmHmr() {}
 
-  std::vector<double> process(const std::vector<double>& inputVector);
+  std::vector<double> run(const std::vector<double>& inputVector);
 };
 
 #endif /* _RAPID_XMM_TOOLS_H_ */