examples/ofx/Bitalino_rapidmix/src/bitalino.h

+/**
+ * \file
+ * \copyright  Copyright 2014-2015 PLUX - Wireless Biosignals, S.A.
+ * \author     Filipe Silva
+ * \version    2.0
+ * \date       November 2015
+ * 
+ * \section LICENSE
+ 
+ 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 3 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, see <http://www.gnu.org/licenses/>.
+ 
+ */
+
+
+ /**
+  \mainpage
+  
+  The %BITalino C++ API (available at http://github.com/BITalinoWorld/cpp-api) is a cross-platform library which enables C++ applications to communicate
+  with a %BITalino device through a simple interface.
+  The API is composed of a header file (bitalino.h)
+  and an implementation file ([bitalino.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.cpp)).
+  A sample test application in C++ ([test.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/test.cpp)) is also provided.
+  
+  There are three ways to connect to a %BITalino device:
+  - direct Bluetooth connection using the device Bluetooth MAC address (Windows and Linux);
+  - indirect Bluetooth connection using a virtual serial port (all platforms);
+  - wired UART connection using a serial port (all platforms).
+  
+  The API exposes a single class (BITalino). Each instance of this class represents a connection
+  to a %BITalino device. The connection is established in the constructor and released in the destructor,
+  thus following the RAII paradigm. An application can create several instances (to distinct devices).
+  The library is thread-safe between distinct instances. Each instance can be a local variable
+  (as in the sample application) or it can be allocated on the heap (using new and delete operators).
+  
+  \section sampleapp About the sample application
+  
+  The sample application ([test.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/test.cpp)) creates an instance to a %BITalino device.
+  Then it starts acquiring all channels on the device at 1000 Hz and enters a loop while dumping
+  one frame out of 100 and toggling the device green LED. Pressing the Enter key exits the loop,
+  destroys the instance and closes the application.
+  
+  One of the provided constructor calls must be used to connect to the device.
+  The string passed to the constructor can be a Bluetooth MAC address (you must change the one provided)
+  or a serial port. The serial port string format depends on the platform.
+  
+  In order to have a more compact and readable code, the sample test code uses C++11 vector initializer lists.
+  This new C++ feature is supported only in Visual Studio 2013 or later (on Windows), GCC 4.4 or later and Clang 3.1
+  or later. If you are using an older compiler, use the commented alternative code for the `start()` and
+  `trigger()` methods calls.
+  
+  \section windows Compiling on Windows
+  
+  The API was tested in Windows 7 (32-bit and 64-bit).
+  
+  To compile the library and the sample application:
+  - create a C++ Empty Project in Visual Studio;
+  - copy [bitalino.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.cpp),
+  [bitalino.h](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.h) and
+  [test.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/test.cpp) to the project directory;
+  - add bitalino.cpp and test.cpp files to the project at the “Source Files” folder;
+  - edit test.cpp as described \ref sampleapp "above";
+  - add a reference to `ws2_32.lib` in Project Properties → Configuration Properties → Linker → Input → Additional Dependencies;
+  - build the solution and run the application.
+  
+  \section linux Compiling on Linux
+
+  The API was tested in Ubuntu (32-bit and 64-bit) and Raspberry Pi (Raspbian).
+  
+  To compile the library and the sample application:
+  - `make` and `g++` must be installed;
+  - packages `bluez`, `libbluetooth3` and `libbluetooth-dev` must be installed if you want to
+    compile the library with Bluetooth functionality (to search for Bluetooth devices and
+    to make direct Bluetooth connections);
+  - copy [bitalino.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.cpp),
+  [bitalino.h](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.h),
+  [test.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/test.cpp) and
+  [Makefile](http://github.com/BITalinoWorld/cpp-api/tree/master/Makefile) into a new directory;
+  - if you want to compile the library without Bluetooth functionality, disable the line in
+    Makefile where `LINUX_BT` is defined;
+  - if your compiler doesn't support vector initializer lists, remove the flag `-std=c++0x`
+    from the test.cpp compiling rule in Makefile;
+  - edit test.cpp as described \ref sampleapp "above";
+  - enter command `make` in the command line to build the library and the application;
+  - enter command `./test` in the command line to run the application.
+  
+  \section macosx Compiling on Mac OS X
+  
+  The API was tested in Mac OS X 10.6 and 10.9.
+  
+  On Mac OS X, the %BITalino API Bluetooth functionality is not available, so it is only possible
+  to connect to a %BITalino device through a serial port for indirect Bluetooth connections or for wired UART connections.
+  
+  To compile the library and the sample application:
+  - copy [bitalino.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.cpp),
+  [bitalino.h](http://github.com/BITalinoWorld/cpp-api/tree/master/bitalino.h),
+  [test.cpp](http://github.com/BITalinoWorld/cpp-api/tree/master/test.cpp) and
+  [Makefile](http://github.com/BITalinoWorld/cpp-api/tree/master/Makefile) into a new directory;
+  - if your compiler doesn't support vector initializer lists, remove the flag `-std=c++0x` from
+    the test.cpp compiling rule in Makefile;
+  - edit test.cpp as described \ref sampleapp "above";
+  - enter command `make` in the command line to build the library and the application;
+  - enter command `./test` in the command line to run the application.  
+  */
+
+#ifndef _BITALINOHEADER_
+#define _BITALINOHEADER_
+
+#include <string>
+#include <vector>
+
+#ifdef _WIN32 // 32-bit or 64-bit Windows
+
+#include <winsock2.h>
+
+#endif
+
+/// The %BITalino device class.
+class BITalino
+{
+public:
+// Type definitions
+
+   typedef std::vector<bool>  Vbool;   ///< Vector of bools.
+   typedef std::vector<int>   Vint;    ///< Vector of ints.
+
+   /// Information about a Bluetooth device found by BITalino::find().
+   struct DevInfo
+   {
+      std::string macAddr; ///< MAC address of a Bluetooth device
+      std::string name;    ///< Name of a Bluetooth device
+   };
+   typedef std::vector<DevInfo> VDevInfo; ///< Vector of DevInfo's.
+
+   /// A frame returned by BITalino::read()
+   struct Frame
+   {
+      /// %Frame sequence number (0...15).
+      /// This number is incremented by 1 on each consecutive frame, and it overflows to 0 after 15 (it is a 4-bit number).
+      /// This number can be used to detect if frames were dropped while transmitting data.
+      char  seq;        
+
+      /// Array of digital ports states (false for low level or true for high level).
+      /// On original %BITalino, the array contents are: I1 I2 I3 I4.
+      /// On %BITalino 2, the array contents are: I1 I2 O1 O2.
+      bool  digital[4]; 
+
+      /// Array of analog inputs values (0...1023 on the first 4 channels and 0...63 on the remaining channels)
+      short analog[6];
+   };
+   typedef std::vector<Frame> VFrame;  ///< Vector of Frame's.
+
+   /// Current device state returned by BITalino::state()
+   struct State
+   {
+      int   analog[6],     ///< Array of analog inputs values (0...1023)
+            battery,       ///< Battery voltage value (0...1023)
+            batThreshold;  ///< Low-battery LED threshold (last value set with BITalino::battery())
+      /// Array of digital ports states (false for low level or true for high level).
+      /// The array contents are: I1 I2 O1 O2.
+      bool  digital[4];
+   };
+
+   /// %Exception class thrown from BITalino methods.
+   class Exception
+   {
+   public:
+      /// %Exception code enumeration.
+      enum Code
+      {
+         INVALID_ADDRESS = 1,       ///< The specified address is invalid
+         BT_ADAPTER_NOT_FOUND,      ///< No Bluetooth adapter was found
+         DEVICE_NOT_FOUND,          ///< The device could not be found
+         CONTACTING_DEVICE,         ///< The computer lost communication with the device
+         PORT_COULD_NOT_BE_OPENED,  ///< The communication port does not exist or it is already being used
+         PORT_INITIALIZATION,       ///< The communication port could not be initialized
+         DEVICE_NOT_IDLE,           ///< The device is not idle
+         DEVICE_NOT_IN_ACQUISITION, ///< The device is not in acquisition mode
+         INVALID_PARAMETER,         ///< Invalid parameter
+         NOT_SUPPORTED,             ///< Operation not supported by the device 
+      } code;  ///< %Exception code.
+
+      Exception(Code c) : code(c) {}      ///< Exception constructor.
+      const char* getDescription(void);   ///< Returns an exception description string
+   };
+
+// Static methods
+
+   /** Searches for Bluetooth devices in range.
+    * \return a list of found devices
+    * \exception Exception (Exception::PORT_INITIALIZATION)
+    * \exception Exception (Exception::BT_ADAPTER_NOT_FOUND)
+    */
+   static VDevInfo find(void);
+
+// Instance methods
+
+   /** Connects to a %BITalino device.
+    * \param[in] address The device Bluetooth MAC address ("xx:xx:xx:xx:xx:xx")
+    * or a serial port ("COMx" on Windows or "/dev/..." on Linux or Mac OS X)
+    * \exception Exception (Exception::PORT_COULD_NOT_BE_OPENED)
+    * \exception Exception (Exception::PORT_INITIALIZATION)
+    * \exception Exception (Exception::INVALID_ADDRESS)
+    * \exception Exception (Exception::BT_ADAPTER_NOT_FOUND) - Windows only
+    * \exception Exception (Exception::DEVICE_NOT_FOUND) - Windows only
+    */
+   BITalino(const char *address);
+   
+   /// Disconnects from a %BITalino device. If an aquisition is running, it is stopped. 
+   ~BITalino();
+
+   /** Returns the device firmware version string.
+    * \remarks This method cannot be called during an acquisition.
+    * \exception Exception (Exception::DEVICE_NOT_IDLE)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    */
+   std::string version(void);
+   
+   /** Starts a signal acquisition from the device.
+    * \param[in] samplingRate Sampling rate in Hz. Accepted values are 1, 10, 100 or 1000 Hz. Default value is 1000 Hz.
+    * \param[in] channels Set of channels to acquire. Accepted channels are 0...5 for inputs A1...A6.
+    * If this set is empty or if it is not given, all 6 analog channels will be acquired.
+    * \param[in] simulated If true, start in simulated mode. Otherwise start in live mode. Default is to start in live mode.
+    * \remarks This method cannot be called during an acquisition.
+    * \exception Exception (Exception::DEVICE_NOT_IDLE)
+    * \exception Exception (Exception::INVALID_PARAMETER)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    */
+   void start(int samplingRate = 1000, const Vint &channels = Vint(), bool simulated = false);
+   
+   /** Stops a signal acquisition.
+    * \remarks This method must be called only during an acquisition.
+    * \exception Exception (Exception::DEVICE_NOT_IN_ACQUISITION)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    */
+   void stop(void);
+   
+   /** Reads acquisition frames from the device.
+    * This method returns when all requested frames are received from the device, or when 5-second receive timeout occurs.
+    * \param[out] frames Vector of frames to be filled. If the vector is empty, it is resized to 100 frames.
+    * \return Number of frames returned in frames vector. If a timeout occurred, this number is less than the frames vector size.
+    * \remarks This method must be called only during an acquisition.
+    * \exception Exception (Exception::DEVICE_NOT_IN_ACQUISITION)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    */   
+   int read(VFrame &frames);
+   
+   /** Sets the battery voltage threshold for the low-battery LED.
+    * \param[in] value Battery voltage threshold. Default value is 0.
+    * Value | Voltage Threshold
+    * ----- | -----------------
+    *     0 |   3.4 V
+    *  ...  |   ...
+    *    63 |   3.8 V
+    * \remarks This method cannot be called during an acquisition.
+    * \exception Exception (Exception::DEVICE_NOT_IDLE)
+    * \exception Exception (Exception::INVALID_PARAMETER)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    */
+   void battery(int value = 0);
+   
+   /** Assigns the digital outputs states.
+    * \param[in] digitalOutput Vector of booleans to assign to digital outputs, starting at first output (O1).
+    * On each vector element, false sets the output to low level and true sets the output to high level.
+    * If this vector is not empty, it must contain exactly 4 elements for original %BITalino (4 digital outputs)
+    * or exactly 2 elements for %BITalino 2 (2 digital outputs).
+    * If this parameter is not given or if the vector is empty, all digital outputs are set to low level.
+    * \remarks This method must be called only during an acquisition on original %BITalino. On %BITalino 2 there is no restriction.
+    * \exception Exception (Exception::DEVICE_NOT_IN_ACQUISITION)
+    * \exception Exception (Exception::INVALID_PARAMETER)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    */
+   void trigger(const Vbool &digitalOutput = Vbool());
+
+   /** Assigns the analog (PWM) output value (%BITalino 2 only).
+    * \param[in] pwmOutput Analog output value to set (0...255).
+    * The analog output voltage is given by: V (in Volts) = 3.3 * (pwmOutput+1)/256
+    * \exception Exception (Exception::INVALID_PARAMETER)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    * \exception Exception (Exception::NOT_SUPPORTED)
+    */
+   void pwm(int pwmOutput = 100);
+
+   /** Returns current device state (%BITalino 2 only).
+    * \remarks This method cannot be called during an acquisition.
+    * \exception Exception (Exception::DEVICE_NOT_IDLE)
+    * \exception Exception (Exception::CONTACTING_DEVICE)
+    * \exception Exception (Exception::NOT_SUPPORTED)
+    */
+   State state(void);
+
+private:
+   void send(char cmd);
+   int  recv(void *data, int nbyttoread);
+   void close(void);
+
+   char nChannels;
+   bool isBitalino2;
+#ifdef _WIN32
+   SOCKET	fd;
+   timeval  readtimeout;
+   HANDLE   hCom;
+#else // Linux or Mac OS
+   int      fd;
+   bool     isTTY;
+#endif
+};
+
+#endif // _BITALINOHEADER_

examples/ofx/Bitalino_rapidmix/src/main.cpp

+#include "ofApp.h"
+#include "ofAppGlutWindow.h"
+
+//========================================================================
+int main( ){
+    ofAppGlutWindow window;
+	ofSetupOpenGL( &window, 1024, 768, OF_WINDOW );			// <-------- setup the GL context
+
+	ofRunApp( new ofApp(  ) );
+
+}

examples/ofx/Bitalino_rapidmix/src/ofApp.cpp

+#include "ofApp.h"
+
+//--------------------------------------------------------------
+void ofApp::setup ( void )
+{
+    ofSetWindowTitle( "Rapid Bitalino Example" );
+    
+    sampleRate 	= 44100; /* Sampling Rate */
+    bufferSize	= 512; /* Buffer Size. you have to fill this buffer with sound using the for loop in the audioOut method */
+    
+    ofSetVerticalSync( true );
+    ofEnableAlphaBlending(  );
+    ofEnableSmoothing(  );
+    
+    ofBackground( 0, 0, 0 );
+    
+    // Enter the name of your BITalino board here
+    bitEnvironment.setup( "/dev/cu.BITalino-DevB", ofRectangle( 0, 0, 1024, 768 ) );
+    
+    ofxMaxiSettings::setup( sampleRate, 2, bufferSize );
+    
+    // sets up and starts a global ofSoundStream.
+    ofSoundStreamSetup( 2, 0, sampleRate, bufferSize, 4 );
+}
+
+//--------------------------------------------------------------
+void ofApp::update ( void )
+{
+    bitEnvironment.update(  );
+}
+
+//--------------------------------------------------------------
+void ofApp::draw ( void )
+{
+    ofBackground( 0, 0, 0 );
+    bitEnvironment.draw(  );
+}
+
+//--------------------------------------------------------------
+void ofApp::audioOut ( float *output, int bufferSize, int nChannels )
+{
+    bitEnvironment.audioOut ( output, bufferSize, nChannels );
+}
+
+//--------------------------------------------------------------
+void ofApp::exit ( void )
+{
+    printf( "stopping...\n" );
+//    rapidBitalino.stop(  );
+    bitEnvironment.stop(  );
+}
+
+//--------------------------------------------------------------
+void ofApp::keyPressed ( int key )
+{
+    if ( key == '1' && !pr ) {
+        bitEnvironment.bst.buttonPressed(  );
+        printf( "1 down\n" );
+        pr = true;
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::keyReleased ( int key )
+{
+    if ( key == '1' ) {
+        bitEnvironment.bst.buttonReleased(  );
+        printf( "1 up\n" );
+        pr = false;
+    }
+}
+
+void ofApp::updateMouse ( int x, int y, int8_t mouseButtonState )
+{
+    // Only really one mouse function necessary for this example:
+    if ( mouseButtonState != this->mouseButtonState )
+    {
+        mouseButtonChanged = true;
+        this->mouseButtonState = mouseButtonState;
+    } else
+        mouseButtonChanged = false;
+    
+    ofVec2f mousePos( x, y );
+    if ( bitEnvironment.isMouseInside( mousePos ) )
+    {
+        bitEnvironment.mouseActive( mousePos, mouseButtonState, mouseButtonChanged );
+    }
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseMoved ( int x, int y )
+{
+    updateMouse( x, y, mouseButtonState );
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseDragged ( int x, int y, int button )
+{
+    updateMouse( x, y, button );
+}
+
+//--------------------------------------------------------------
+void ofApp::mousePressed ( int x, int y, int button )
+{
+    //std::cout << "BUTTON: " <<  button << std::endl;
+    updateMouse( x, y, button );
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseReleased ( int x, int y, int button )
+{
+    updateMouse( x, y, -1 );
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseEntered( int x, int y )
+{
+    updateMouse( x, y, mouseButtonState );
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseExited ( int x, int y )
+{
+    updateMouse( x, y, mouseButtonState );
+}
+
+//--------------------------------------------------------------
+void ofApp::windowResized ( int w, int h )
+{
+    bitEnvironment.resize( ofRectangle( 0, 0, w, h ) );
+}
+
+//--------------------------------------------------------------
+void ofApp::gotMessage ( ofMessage msg )
+{
+
+}
+
+//--------------------------------------------------------------
+void ofApp::dragEvent ( ofDragInfo dragInfo )
+{
+
+}

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;
+};