Fix double mutex request in core thread.

gui/GRT/Core.cpp

@@ -1,32 +1,12 @@
 #include "Core.h"
 
+
+
 Core::Core(QObject *parent) : QObject(parent)
 {
-    coreSleepTime = DEFAULT_CORE_THREAD_SLEEP_TIME;
-    coreRunning = false;
-    stopMainThread = false;
-    verbose = true;
-    debug = false;
-    enableOSCInput = true;
-    enableOSCControlCommands = true;
-    infoMessage = "";
-    version = GRT_GUI_VERSION;
-
-    incomingOSCDataPort = 5000;
-    outgoingOSCDataPort = 5001;
-    outgoingOSCAddress = "127.0.0.1";
     oscServer.setVerbose( false );
-    incomingDataAddress = "/Data";
-
-    numInputDimensions = 1;
-    targetVectorSize = 1;
     inputData.resize( numInputDimensions );
     targetVector.resize( targetVectorSize, 0 );
-    trainingClassLabel = 1;
-    recordTrainingData = false;
-    newDataReceived = false;
-    predictionModeEnabled = true;
-    pipelineMode = CLASSIFICATION_MODE;
 
     //Connect the training thread signals
     connect(&trainingThread, SIGNAL(newInfoMessage(std::string)), this, SIGNAL(newInfoMessage(std::string)));
@@ -91,10 +71,7 @@ bool Core::stop(){
         qDebug() << STRING_TO_QSTRING("Core::stop() - Stopping main thread...");
 
     //Flag that the core should stop
-    {
-        std::unique_lock< std::mutex > lock( mutex );
-        stopMainThread = true;
-    }
+    stopMainThread = true;
 
     //Wait for it to stop
     mainThread->join();
@@ -146,40 +123,27 @@ bool Core::resetOSCServer( const int in_OSCDataPort ){
     return true;
 }
 
-bool Core::addMessaage( const OSCMessagePtr msg ){
-    std::unique_lock< std::mutex > lock( mutex );
+void Core::addMessaage( const OSCMessagePtr msg ){
     oscServer.addMessaage( msg );
-    return true;
 }
 
-bool Core::setVersion( const std::string version ){
-    std::unique_lock< std::mutex > lock( mutex );
+void Core::setVersion( const std::string version ){
     this->version = version;
-    return true;
 }
 
-bool Core::setEnableOSCInput( const bool state ){
-    std::unique_lock< std::mutex > lock( mutex );
+void Core::setEnableOSCInput( const bool state ){
     enableOSCInput = state;
-    return true;
 }
 
-bool Core::setEnableOSCControlCommands( const bool state ){
-    std::unique_lock< std::mutex > lock( mutex );
+void Core::setEnableOSCControlCommands( const bool state ){
     enableOSCControlCommands = state;
-    return true;
 }
 
-bool Core::setPipelineMode( const unsigned int pipelineMode ){
-    bool modeChanged = false;
-    if( pipelineMode != this->pipelineMode ){
-        std::unique_lock< std::mutex > lock( mutex );
-        this->pipelineMode = pipelineMode;
-        modeChanged = true;
+void Core::setPipelineMode( const unsigned int my_pipelineMode ){
+    if( my_pipelineMode != this->pipelineMode ){
+        pipelineMode = my_pipelineMode;
+        emit pipelineModeChanged( my_pipelineMode );
     }
-    if( modeChanged )
-        emit pipelineModeChanged( pipelineMode );
-    return true;
 }
 
 bool Core::setRecordingState( const bool state ){
@@ -510,60 +474,25 @@ void Core::clearTrainingData(){
 ////////////////////////////      GETTERS      ////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-bool Core::getCoreRunning(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return coreRunning;
-}
-
-bool Core::getTrained(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getTrained();
-}
-
-bool Core::getTrainingInProcess(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return trainingThread.getTrainingInProcess();
-}
-
-bool Core::getRecordStatus(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return recordTrainingData;
-}
-
-unsigned int Core::getNumInputDimensions(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return numInputDimensions;
-}
-
-unsigned int Core::getPipelineMode(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipelineMode;
-}
-
-unsigned int Core::getTrainingClassLabel(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return trainingClassLabel;
-}
-
 unsigned int Core::getNumTrainingSamples(){
     std::unique_lock< std::mutex > lock( mutex );
     switch( pipelineMode ){
         case CLASSIFICATION_MODE:
             return classificationTrainingData.getNumSamples();
-        break;
+        // break;
         case REGRESSION_MODE:
             return regressionTrainingData.getNumSamples();
-        break;
+        // break;
         case TIMESERIES_CLASSIFICATION_MODE:
             return timeseriesClassificationTrainingData.getNumSamples();
-        break;
+        // break;
         case CLUSTER_MODE:
             return clusterTrainingData.getNumSamples();
-        break;
+        // break;
         default:
             qDebug() << "ERROR: getNumTrainingSamples() - Unknown pipeline mode!";
             return false;
-        break;
+        // break;
     }
 }
 
@@ -572,151 +501,50 @@ unsigned int Core::getNumTestSamples(){
     switch( pipelineMode ){
         case CLASSIFICATION_MODE:
             return classificationTestData.getNumSamples();
-        break;
+        // break;
         case REGRESSION_MODE:
             return regressionTestData.getNumSamples();
-        break;
+        // break;
         case TIMESERIES_CLASSIFICATION_MODE:
             return timeseriesClassificationTestData.getNumSamples();
-        break;
+        // break;
         case CLUSTER_MODE:
             return clusterTestData.getNumSamples();
-        break;
+        // break;
         default:
             qDebug() << "ERROR: getNumTestSamples() - Unknown pipeline mode!";
             return false;
-        break;
+        // break;
     }
 }
 
-unsigned int Core::getNumClasses(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getNumClasses();
-}
-
 unsigned int Core::getNumClassesInTrainingData(){
     std::unique_lock< std::mutex > lock( mutex );
     switch( pipelineMode ){
         case CLASSIFICATION_MODE:
             return classificationTrainingData.getNumClasses();
-        break;
+        // break;
         case REGRESSION_MODE:
             return 0; //There are no classes in regression data
-        break;
+        // break;
         case TIMESERIES_CLASSIFICATION_MODE:
             return timeseriesClassificationTrainingData.getNumClasses();
-        break;
+        // break;
         case CLUSTER_MODE:
             return 0; //There are no classes in cluster mode
-        break;
+        // break;
         default:
             qDebug() << "ERROR: getNumClassesInTrainingData() - Unknown pipeline mode!";
             return false;
-        break;
+        // break;
     }
     return 0;
 }
 
-vector<unsigned int> Core::getClassLabels(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getClassLabels();
-}
-
-GRT::VectorFloat Core::getTargetVector(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return targetVector;
-}
-
-GRT::ClassificationData Core::getClassificationTrainingData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return classificationTrainingData;
-}
-
-GRT::ClassificationData Core::getClassificationTestData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return classificationTestData;
-}
-
-GRT::RegressionData Core::getRegressionTrainingData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return regressionTrainingData;
-}
-
-GRT::RegressionData Core::getRegressionTestData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return regressionTestData;
-}
-
-GRT::TimeSeriesClassificationData Core::getTimeSeriesClassificationTrainingData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return timeseriesClassificationTrainingData;
-}
-
-GRT::TimeSeriesClassificationData Core::getTimeSeriesClassificationTestData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return timeseriesClassificationTestData;
-}
-
-GRT::UnlabelledData Core::getClusterTrainingData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return clusterTrainingData;
-}
-
-GRT::UnlabelledData Core::getClusterTestData(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return clusterTestData;
-}
-
-double Core::getTestAccuracy(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getTestAccuracy();
-}
-
-double Core::getCrossValidationAccuracy(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getCrossValidationAccuracy();
-}
-
-double Core::getTrainingRMSError(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getTrainingRMSError();
-}
-
-double Core::getTrainingSSError(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getTrainingSSError();
-}
-
-GRT::GestureRecognitionPipeline Core::getPipeline(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline;
-}
-
-GRT::TestResult Core::getTestResults(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getTestResults();
-}
-
-vector< GRT::TestResult > Core::getCrossValidationResults(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getCrossValidationResults();
-}
-
-std::string Core::getModelAsString(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return pipeline.getModelAsString();
-}
-
 ///////////////////////////////////////////////////////////////////////////
 ////////////////////////////      SETTERS      ////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-bool Core::setCoreSleepTime( const unsigned int coreSleepTime ){
-    std::unique_lock< std::mutex > lock( mutex );
-    this->coreSleepTime = coreSleepTime;
-    return true;
-}
-
 bool Core::setNumInputDimensions( const int numInputDim ){
 
     bool result = false;
@@ -757,7 +585,7 @@ bool Core::setNumInputDimensions( const int numInputDim ){
             default:
                 qDebug() << "ERROR: setNumInputDimensions() - Unknown pipeline mode!";
                 return false;
-            break;
+            //break;
         }
 
         result = true;
@@ -1057,12 +885,7 @@ bool Core::savePipelineToFile( const std::string filename ){
 
 bool Core::loadPipelineFromFile( const std::string filename ){
 
-    bool result = false;
-
-    {
-        std::unique_lock< std::mutex > lock( mutex );
-        result = pipeline.load( filename );
-    }
+    bool result = pipeline.load( filename );
 
     if( result ){
         emit newInfoMessage( "Pipeline loaded from file" );
@@ -1072,27 +895,6 @@ bool Core::loadPipelineFromFile( const std::string filename ){
     return result;
 }
 
-bool Core::setInfoMessage( const std::string infoMessage ){
-    std::unique_lock< std::mutex > lock( mutex );
-    this->infoMessage = infoMessage;
-    return true;
-}
-
-std::string Core::getInfoMessage(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return infoMessage;
-}
-
-std::string Core::getVersion(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return version;
-}
-
-std::string Core::getIncomingDataAddress(){
-    std::unique_lock< std::mutex > lock( mutex );
-    return incomingDataAddress;
-}
-
 ///////////////////////////////////////////////////////////////////////////
 //////////////////////////// PROTECTED METHODS ////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
@@ -1247,10 +1049,9 @@ bool Core::processOSCMessage( const OSCMessagePtr oscMessage  ){
             unsigned int pipelineMode_ = m[0].getInt();
             unsigned int numInputDimensions_ = m[1].getInt();
             unsigned int targetVectorSize_ = m[2].getInt();
-            if( setPipelineMode( pipelineMode_ ) ){
-                setNumInputDimensions( numInputDimensions_ );
-                setTargetVectorSize( targetVectorSize_ );
-            }else emit newErrorMessage( "Failed to set pipeline mode - invalid OSC /Setup message!" );
+            setPipelineMode( pipelineMode_ );
+            setNumInputDimensions( numInputDimensions_ );
+            setTargetVectorSize( targetVectorSize_ );
 
             return true;
         } else return false;
@@ -1650,11 +1451,12 @@ bool Core::trainAndTestOnRandomSubset( const unsigned int randomTestSubsetPercen
             result = trainingThread.startNewTraining( trainer );
         break;
         case TIMESERIES_CLASSIFICATION_MODE:
+            emit newInfoMessage( "Not yet implemented" );
         break;
         default:
             qDebug() << "ERROR: Unknown pipeline mode!";
             return false;
-        break;
+        //break;
     }
 
     return result;
@@ -1684,12 +1486,12 @@ bool Core::trainAndTestOnTestDataset(){
                 return trainingThread.startNewTraining( trainer );
             break;
             case TIMESERIES_CLASSIFICATION_MODE:
-                //result = pipeline.train( timeseriesClassificationTrainingData );
+                return pipeline.train( timeseriesClassificationTrainingData );
             break;
             default:
                 qDebug() << "ERROR: Unknown pipeline mode!";
                 return false;
-            break;
+            //break;
         }
     }
     return false;
@@ -1718,13 +1520,14 @@ bool Core::trainWithCrossValidation( const unsigned int numFolds ){
             result = trainingThread.startNewTraining( trainer );
         break;
         case TIMESERIES_CLASSIFICATION_MODE:
+            emit newInfoMessage( "Not yet implemented" );
             //trainer.setupCVTraining( pipeline, timeseriesClassificationTrainingData, numFolds );
             //result = trainingThread.startNewTraining( trainer );
         break;
         default:
             qDebug() << "ERROR: Unknown pipeline mode!";
             return false;
-        break;
+        //break;
     }
 
     return result;

gui/GRT/Core.h

@@ -3,11 +3,16 @@
 
 #define GRT_GUI_VERSION "0.1_18"
 
-#include <QObject>
-#include "OSC/OSCServer.h"
 #include <GRT/GRT.h>
+
+#include "OSC/OSCServer.h"
 #include "TrainingThread.h"
 
+//#include "OSC/OSCMessage.h"
+
+#include <vector>
+#include <QObject>
+
 #define DEFAULT_CORE_THREAD_SLEEP_TIME 10
 
 class Core : public QObject, public GRT::Observer< GRT::TrainingResult >, public GRT::Observer< GRT::TestInstanceResult >
@@ -20,39 +25,39 @@ class Core : public QObject, public GRT::Observer< GRT::TrainingResult >, public
 
     bool start();
     bool stop();
-    bool addMessaage( const OSCMessagePtr msg );
-    bool getCoreRunning();
-    bool getTrained();
-    bool getTrainingInProcess();
-    bool getRecordStatus();
-    unsigned int getNumInputDimensions();
-    unsigned int getPipelineMode();
-    unsigned int getTrainingClassLabel();
+    void addMessaage( const OSCMessagePtr msg );
+    bool getCoreRunning() const  { return coreRunning; }
+    bool getTrained() const { return pipeline.getTrained(); }
+    bool getTrainingInProcess() const { return trainingThread.getTrainingInProcess(); }
+    bool getRecordStatus() const { return recordTrainingData; }
+    unsigned int getNumInputDimensions() const { return numInputDimensions; }
+    unsigned int getPipelineMode() const { return pipelineMode; }
+    unsigned int getTrainingClassLabel() const { return trainingClassLabel; }
     unsigned int getNumTrainingSamples();
     unsigned int getNumTestSamples();
-    unsigned int getNumClasses();
+    unsigned int getNumClasses() const { return pipeline.getNumClasses(); }
     unsigned int getNumClassesInTrainingData();
-    vector<unsigned int> getClassLabels();
-    GRT::VectorFloat getTargetVector();
-    GRT::ClassificationData getClassificationTrainingData();
-    GRT::ClassificationData getClassificationTestData();
-    GRT::RegressionData getRegressionTrainingData();
-    GRT::RegressionData getRegressionTestData();
-    GRT::TimeSeriesClassificationData getTimeSeriesClassificationTrainingData();
-    GRT::TimeSeriesClassificationData getTimeSeriesClassificationTestData();
-    GRT::UnlabelledData getClusterTrainingData();
-    GRT::UnlabelledData getClusterTestData();
-    double getTestAccuracy();
-    double getCrossValidationAccuracy();
-    double getTrainingRMSError();
-    double getTrainingSSError();
-    GRT::GestureRecognitionPipeline getPipeline();
-    GRT::TestResult getTestResults();
-    vector< GRT::TestResult > getCrossValidationResults();
-    std::string getInfoMessage();
-    std::string getVersion();
-    std::string getIncomingDataAddress();
-    std::string getModelAsString();
+    std::vector<unsigned int> getClassLabels() const { return pipeline.getClassLabels(); }
+    GRT::VectorFloat getTargetVector() const { return targetVector; }
+    GRT::ClassificationData getClassificationTrainingData() const { return classificationTrainingData; }
+    GRT::ClassificationData getClassificationTestData() const { return classificationTestData; }
+    GRT::RegressionData getRegressionTrainingData() const { return regressionTrainingData;}
+    GRT::RegressionData getRegressionTestData() const { return regressionTestData; }
+    GRT::TimeSeriesClassificationData getTimeSeriesClassificationTrainingData() const { return timeseriesClassificationTrainingData; }
+    GRT::TimeSeriesClassificationData getTimeSeriesClassificationTestData() const { return timeseriesClassificationTestData; }
+    GRT::UnlabelledData getClusterTrainingData() const { return clusterTrainingData; }
+    GRT::UnlabelledData getClusterTestData() const { return clusterTestData; }
+    double getTestAccuracy() const { return pipeline.getTestAccuracy(); }
+    double getCrossValidationAccuracy() const { return pipeline.getCrossValidationAccuracy(); }
+    double getTrainingRMSError() const { return pipeline.getTrainingRMSError(); }
+    double getTrainingSSError() const { return pipeline.getTrainingSSError(); }
+    GRT::GestureRecognitionPipeline getPipeline() const { return pipeline; }
+    GRT::TestResult getTestResults() const { return pipeline.getTestResults(); }
+    vector< GRT::TestResult > getCrossValidationResults() const { return pipeline.getCrossValidationResults(); }
+    std::string getInfoMessage() const { return infoMessage; }
+    std::string getVersion() const { return version; }
+    std::string getIncomingDataAddress() const { return incomingDataAddress; }
+    std::string getModelAsString() const { return pipeline.getModelAsString(); }
 
 signals:
     void coreStarted();
@@ -106,10 +111,10 @@ class Core : public QObject, public GRT::Observer< GRT::TrainingResult >, public
 public slots:
     bool resetOSCClient( const std::string clientAddress,const int clientPort );
     bool resetOSCServer( const int in_OSCDataPort );
-    bool setVersion( const std::string version );
-    bool setEnableOSCInput( const bool state );
-    bool setEnableOSCControlCommands( const bool state );
-    bool setPipelineMode( const unsigned int pipelineMode );
+    void setVersion( const std::string version );
+    void setEnableOSCInput( const bool state );
+    void setEnableOSCControlCommands( const bool state );
+    void setPipelineMode( const unsigned int pipelineMode );
     bool setRecordingState( const bool state );
     bool saveTrainingDatasetToFile( const std::string filename );
     bool loadTrainingDatasetFromFile( const std::string filename );
@@ -121,7 +126,7 @@ public slots:
     bool trainWithCrossValidation( const unsigned int numFolds );
     bool enablePrediction( const bool enable );
 
-    bool setCoreSleepTime( const unsigned int coreSleepTime );
+    void setCoreSleepTime( const unsigned int cST ) { coreSleepTime = cST; }
     bool setNumInputDimensions( const int numInputDimensions );
     bool setTargetVectorSize( const int targetVectorSize );
     bool setTrainingClassLabel( const int trainingClassLabel );
@@ -140,7 +145,7 @@ public slots:
     bool removeAllPostProcessingModules();
     bool savePipelineToFile( const std::string filename );
     bool loadPipelineFromFile( const std::string filename );
-    bool setInfoMessage( const std::string infoMessage );
+    void setInfoMessage( const std::string iM ) { infoMessage = iM; }
 
 protected:
     virtual void notify( const GRT::TrainingResult &data );
@@ -160,32 +165,32 @@ public slots:
     //Core Stuff
     std::mutex mutex;
     std::shared_ptr< std::thread > mainThread;
-    bool coreRunning;
-    bool stopMainThread;
-    bool verbose;
-    bool debug;
-    bool enableOSCInput;
-    bool enableOSCControlCommands;
+    bool coreRunning = false;
+    bool stopMainThread = false;
+    bool verbose = true;
+    bool debug = true;
+    bool enableOSCInput = true;
+    bool enableOSCControlCommands = true;
 
     //OSC Stuff
-    unsigned int incomingOSCDataPort;
-    unsigned int outgoingOSCDataPort;
-    string outgoingOSCAddress;
-    string incomingDataAddress;
+    unsigned int incomingOSCDataPort = 5000;
+    unsigned int outgoingOSCDataPort = 5001;
+    string outgoingOSCAddress = "127.0.0.1";
+    string incomingDataAddress = "/Data";
     OSCServer oscServer;
     std::shared_ptr< UdpTransmitSocket > socket;
 
     //Data Stuff
-    unsigned int coreSleepTime;
-    unsigned int numInputDimensions;
-    unsigned int targetVectorSize;
-    unsigned int trainingClassLabel;
-    unsigned int pipelineMode;
+    unsigned int coreSleepTime = DEFAULT_CORE_THREAD_SLEEP_TIME;
+    unsigned int numInputDimensions = 1;
+    unsigned int targetVectorSize = 1;
+    unsigned int trainingClassLabel = 1;
+    unsigned int pipelineMode = CLASSIFICATION_MODE;
     GRT::VectorFloat inputData;
     GRT::VectorFloat targetVector;
-    bool newDataReceived;
-    bool recordTrainingData;
-    bool predictionModeEnabled;
+    bool newDataReceived = false;
+    bool recordTrainingData = false;
+    bool predictionModeEnabled = true;
     GRT::ClassificationData classificationTrainingData;
     GRT::ClassificationData classificationTestData;
     GRT::RegressionData regressionTrainingData;
@@ -199,7 +204,7 @@ public slots:
     GRT::WarningLog warningLog;
     GRT::ErrorLog errorLog;
     std::string infoMessage;
-    std::string version;
+    std::string version = GRT_GUI_VERSION;
 
     TrainingThread trainingThread;