init

Masterarbeit/openvibe/extras-master/plugins/processing/classification/CMakeLists.txt

@@ -0,0 +1,39 @@
+PROJECT(openvibe-plugins-classification)
+
+SET(PROJECT_VERSION_MAJOR ${OV_GLOBAL_VERSION_MAJOR})
+SET(PROJECT_VERSION ${OV_GLOBAL_VERSION_STRING})
+
+FILE(GLOB_RECURSE SRC_FILES src/*.cpp src/*.h src/*.inl)
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRC_FILES}
+	"../../../contrib/packages/libSVM/svm.cpp"
+	"../../../contrib/packages/libSVM/svm.h")
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES
+	VERSION ${PROJECT_VERSION}
+	SOVERSION ${PROJECT_VERSION_MAJOR}
+	FOLDER ${PLUGINS_FOLDER}
+	COMPILE_FLAGS "-DOVP_Exports -DOVP_Shared")
+
+# ---------------------------------
+INCLUDE("FindOpenViBE")
+INCLUDE("FindOpenViBECommon")
+INCLUDE("FindOpenViBEToolkit")
+INCLUDE("FindOpenViBEModuleEBML")
+INCLUDE("FindOpenViBEModuleXML")
+INCLUDE("FindThirdPartyEigen")
+
+# ---------------------------------
+# Test applications
+# ---------------------------------
+IF(OV_COMPILE_TESTS)
+	ADD_SUBDIRECTORY(test)
+ENDIF(OV_COMPILE_TESTS)
+
+# -----------------------------
+# Install files
+# -----------------------------
+INSTALL(TARGETS ${PROJECT_NAME}
+	RUNTIME DESTINATION ${DIST_BINDIR}
+	LIBRARY DESTINATION ${DIST_LIBDIR}
+	ARCHIVE DESTINATION ${DIST_LIBDIR})
+
+INSTALL(DIRECTORY box-tutorials/ DESTINATION ${DIST_DATADIR}/openvibe/scenarios/box-tutorials)

Masterarbeit/openvibe/extras-master/plugins/processing/classification/box-tutorials/classification-1-testing.lua

@@ -0,0 +1,30 @@
+
+sent = false
+
+function initialize(box)
+	dofile(box:get_config("${Path_Data}") .. "/plugins/stimulation/lua-stimulator-stim-codes.lua")
+	sent = false;
+end
+
+function uninitialize(box)
+end
+
+function process(box)
+
+	while box:keep_processing() and sent == false do
+	
+		current_time = box:get_current_time() + 1
+
+		box:send_stimulation(1, OVTK_StimulationId_Label_01,       current_time, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_02,       current_time+10, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_03,       current_time+20, 0)
+		box:send_stimulation(1, OVTK_StimulationId_ExperimentStop, current_time+30, 0)	
+
+		sent = true
+		
+		box:sleep()
+		
+	end
+	
+end
+

Masterarbeit/openvibe/extras-master/plugins/processing/classification/box-tutorials/classification-2-incremental.cfg

@@ -0,0 +1,28 @@
+<OpenViBE-Classifier-Box FormatVersion="4">
+	<Strategy-Identifier class-id="(0xffffffff, 0xffffffff)">Native</Strategy-Identifier>
+	<Algorithm-Identifier class-id="(0x2ba17a3c, 0x1bd46d84)">Linear Discrimimant Analysis (LDA)</Algorithm-Identifier>
+	<Stimulations>
+		<Class-Stimulation class-id="0">OVTK_StimulationId_Label_01</Class-Stimulation>
+		<Class-Stimulation class-id="1">OVTK_StimulationId_Label_02</Class-Stimulation>
+		<Class-Stimulation class-id="2">OVTK_StimulationId_Label_03</Class-Stimulation>
+	</Stimulations>
+	<OpenViBE-Classifier>
+		<LDA version="1">
+			<Classes>0 1 2 </Classes>
+			<Class-config-list>
+				<Class-config>
+					<Weights> 1.420580e+002 1.407747e+002 1.515542e+002 1.064545e+002</Weights>
+					<Bias>-3949.05</Bias>
+				</Class-config>
+				<Class-config>
+					<Weights> 1.396979e+002 1.432478e+002 1.514010e+002 1.063725e+002</Weights>
+					<Bias>-3947.23</Bias>
+				</Class-config>
+				<Class-config>
+					<Weights> 1.396863e+002 1.410456e+002 1.539364e+002 1.070348e+002</Weights>
+					<Bias>-3961.82</Bias>
+				</Class-config>
+			</Class-config-list>
+		</LDA>
+	</OpenViBE-Classifier>
+</OpenViBE-Classifier-Box>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/box-tutorials/classification-2-incremental.lua

@@ -0,0 +1,39 @@
+
+sent = false
+
+function initialize(box)
+	dofile(box:get_config("${Path_Data}") .. "/plugins/stimulation/lua-stimulator-stim-codes.lua")
+	sent = false;
+end
+
+function uninitialize(box)
+end
+
+function process(box)
+
+	while box:keep_processing() and sent == false do
+	
+		current_time = box:get_current_time() + 1
+
+		box:send_stimulation(1, OVTK_StimulationId_Label_01,       current_time, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_02,       current_time+4, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_03,       current_time+8, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_02,       current_time+12, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_01,       current_time+16, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_03,       current_time+20, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_01,       current_time+24, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_02,       current_time+28, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_03,       current_time+32, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_03,       current_time+36, 0)
+		box:send_stimulation(1, OVTK_StimulationId_Label_02,       current_time+40, 0)		
+		box:send_stimulation(1, OVTK_StimulationId_Label_01,       current_time+44, 0)
+		box:send_stimulation(1, OVTK_StimulationId_ExperimentStop, current_time+48, 0)	
+
+		sent = true
+		
+		box:sleep()
+		
+	end
+	
+end
+

Masterarbeit/openvibe/extras-master/plugins/processing/classification/doc/Doc_BoxAlgorithm_OutlierRemoval.dox-part

@@ -0,0 +1,88 @@
+/**
+ * \page BoxAlgorithm_OutlierRemoval Outlier Removal
+__________________________________________________________________
+
+Detailed description
+__________________________________________________________________
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Description|
+The outlier removal box discards extremal feature vectors. The user can specify the desired quantile limits [min,max]. 
+The algorithm loops through the feature dimensions and computes range r(j)=[quantile(min),quantile(max)] for each dimension j. 
+If each feature j of example i is inside r(j), the example i is kept. Otherwise it is discarded. The box is intended to 
+be sent all the vectors of interest before being given the stimulation to start the removal.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Description|
+__________________________________________________________________
+
+Inputs description
+__________________________________________________________________
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Inputs|
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Inputs|
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Input1|
+ The stimulation to start the removal.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Input1|
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Input2|
+ The feature vectors to prune.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Input2|
+__________________________________________________________________
+
+Outputs description
+__________________________________________________________________
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Outputs|
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Outputs|
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Output1|
+The stimulation to announce that the removal is complete.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Output1|
+ 
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Output2|
+The kept feature vectors.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Output2|
+ 
+______________________________________________________
+__________________________________________________________________
+
+Settings description
+__________________________________________________________________
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Settings|
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Settings|
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Setting1| 
+Lower quantile threshold. In [0,1].
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Setting1|
+ 
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Setting2|
+Upper quantile threshold. In [0,1].
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Setting2|
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Setting3|
+Stimulation to start the removal at and to pass out after.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Setting3|
+
+__________________________________________________________________
+
+Examples description
+__________________________________________________________________
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Examples|
+Choice [0.02,0.95] truncates at 2% of the lowest feature values and at 95% of the highest feature values, per dimension.
+
+If the quantile range is specified as [0,1], the box will pass out the original vector set. 
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Examples|
+__________________________________________________________________
+
+Miscellaneous description
+__________________________________________________________________
+
+ * |OVP_DocBegin_BoxAlgorithm_OutlierRemoval_Miscellaneous|
+The box can be attempted to remove artifacts when training classifiers that are sensitive to extremal values, for example LDA. In band-power based Motor Imagery, eye blinks can cause really strong band powers, which can then bias the classifier training. With proper control of the upper quantile of this box, such examples can be pruned from the training set.
+
+An intuitive way to think about the filtering made by the box is to imagine a hypercube (rectangle) in the data space. The boundaries of the cube correspond to the estimated quantiles. Each feature vector that is fully inside the cube is kept.
+
+It may be difficult to choose meaningful quantile limits without looking at the feature values. The latter can be attempted with Signal Display. It is also possible to have outliers that are not in any way extremal. Such outliers can be wrongly placed in the feature space or have a wrong associated class label. This box cannot catch such problems.
+ * |OVP_DocEnd_BoxAlgorithm_OutlierRemoval_Miscellaneous|
+ */

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/algorithms/ovpCAlgorithmClassifierMLP.cpp

@@ -0,0 +1,476 @@
+#if defined TARGET_HAS_ThirdPartyEIGEN
+
+#include "ovpCAlgorithmClassifierMLP.h"
+#include "../ovp_defines.h"
+
+#include <map>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+
+#include <Eigen/Dense>
+#include <Eigen/Core>
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+
+//Need to be reachable from outside
+const char* const MLP_EVALUATION_FUNCTION_NAME = "Evaluation function";
+
+static const char* const MLP_TYPE_NODE_NAME                = "MLP";
+static const char* const MLP_NEURON_CONFIG_NODE_NAME       = "Neuron-configuration";
+static const char* const MLP_INPUT_NEURON_COUNT_NODE_NAME  = "Input-neuron-count";
+static const char* const MLP_HIDDEN_NEURON_COUNT_NODE_NAME = "Hidden-neuron-count";
+static const char* const MLP_MAX_NODE_NAME                 = "Maximum";
+static const char* const MLP_MIN_NODE_NAME                 = "Minimum";
+static const char* const MLP_INPUT_BIAS_NODE_NAME          = "Input-bias";
+static const char* const MLP_INPUT_WEIGHT_NODE_NAME        = "Input-weight";
+static const char* const MLP_HIDDEN_BIAS_NODE_NAME         = "Hidden-bias";
+static const char* const MLP_HIDDEN_WEIGHT_NODE_NAME       = "Hidden-weight";
+static const char* const MLP_CLASS_LABEL_NODE_NAME         = "Class-label";
+
+int MLPClassificationCompare(CMatrix& first, CMatrix& second)
+{
+	//We first need to find the best classification of each.
+	double* buffer        = first.getBuffer();
+	const double maxFirst = *(std::max_element(buffer, buffer + first.getBufferElementCount()));
+
+	buffer                 = second.getBuffer();
+	const double maxSecond = *(std::max_element(buffer, buffer + second.getBufferElementCount()));
+
+	//Then we just compared them
+	if (OVFloatEqual(maxFirst, maxSecond)) { return 0; }
+	if (maxFirst > maxSecond) { return -1; }
+	return 1;
+}
+
+#define MLP_DEBUG 0
+#if MLP_DEBUG
+void dumpMatrix(Kernel::ILogManager& rMgr, const MatrixXd& mat, const CString& desc)
+{
+	rMgr << Kernel::LogLevel_Info << desc << "\n";
+	for (int i = 0; i < mat.rows(); ++i) {
+		rMgr << Kernel::LogLevel_Info << "Row " << i << ": ";
+		for (int j = 0; j < mat.cols(); ++j) {
+			rMgr << mat(i, j) << " ";
+		}
+		rMgr << "\n";
+	}
+}
+#else
+void dumpMatrix(Kernel::ILogManager& /*rMgr*/, const Eigen::MatrixXd& /*mat*/, const CString& /*desc*/) { }
+#endif
+
+
+bool CAlgorithmClassifierMLP::initialize()
+{
+	Kernel::TParameterHandler<int64_t> iHidden(this->getInputParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_HiddenNeuronCount));
+	iHidden = 3;
+
+	Kernel::TParameterHandler<XML::IXMLNode*> config(this->getOutputParameter(OVTK_Algorithm_Classifier_OutputParameterId_Config));
+	config = nullptr;
+
+	Kernel::TParameterHandler<double> iAlpha(this->getInputParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_Alpha));
+	iAlpha = 0.01;
+	Kernel::TParameterHandler<double> iEpsilon(this->getInputParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_Epsilon));
+	iEpsilon = 0.000001;
+	return true;
+}
+
+bool CAlgorithmClassifierMLP::uninitialize() { return true; }
+
+bool CAlgorithmClassifierMLP::train(const Toolkit::IFeatureVectorSet& dataset)
+{
+	m_labels.clear();
+
+	this->initializeExtraParameterMechanism();
+	size_t hiddenNeuronCount = size_t(this->getInt64Parameter(OVP_Algorithm_ClassifierMLP_InputParameterId_HiddenNeuronCount));
+	double alpha             = this->getDoubleParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_Alpha);
+	double epsilon           = this->getDoubleParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_Epsilon);
+	this->uninitializeExtraParameterMechanism();
+
+	if (hiddenNeuronCount < 1)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "Invalid amount of neuron in the hidden layer. Fallback to default value (3)\n";
+		hiddenNeuronCount = 3;
+	}
+	if (alpha <= 0)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "Invalid value for learning coefficient (" << alpha << "). Fallback to default value (0.01)\n";
+		alpha = 0.01;
+	}
+	if (epsilon <= 0)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "Invalid value for stop learning condition (" << epsilon << "). Fallback to default value (0.000001)\n";
+		epsilon = 0.000001;
+	}
+
+	std::map<double, size_t> classCount;
+	std::map<double, Eigen::VectorXd> targetList;
+	//We need to compute the min and the max of data in order to normalize and center them
+	for (size_t i = 0; i < dataset.getFeatureVectorCount(); ++i) { classCount[dataset[i].getLabel()]++; }
+	size_t validationElementCount = 0;
+
+	//We generate the list of class
+	for (auto iter = classCount.begin(); iter != classCount.end(); ++iter)
+	{
+		//We keep 20% percent of the training set for the validation for each class
+		validationElementCount += size_t(iter->second * 0.2);
+		m_labels.push_back(iter->first);
+		iter->second = size_t(iter->second * 0.2);
+	}
+
+	const size_t nbClass  = m_labels.size();
+	const size_t nFeature = dataset.getFeatureVector(0).getSize();
+
+	//Generate the target vector for each class. To save time and memory, we compute only one vector per class
+	//Vector tagret looks like following [0 0 1 0] for class 3 (if 4 classes)
+	for (size_t i = 0; i < nbClass; ++i)
+	{
+		Eigen::VectorXd oTarget = Eigen::VectorXd::Zero(nbClass);
+		//class 1 is at index 0
+		oTarget[size_t(m_labels[i])] = 1.;
+		targetList[m_labels[i]]      = oTarget;
+	}
+
+	//We store each normalize vector we get for training. This not optimal in memory but avoid a lot of computation later
+	//List of the class of the feature vectors store in the same order are they are in validation/training set(to be able to get the target)
+	std::vector<double> oTrainingSet;
+	std::vector<double> oValidationSet;
+	Eigen::MatrixXd oTrainingDataMatrix(nFeature, dataset.getFeatureVectorCount() - validationElementCount);
+	Eigen::MatrixXd oValidationDataMatrix(nFeature, validationElementCount);
+
+	//We don't need to make a shuffle it has already be made by the trainer box
+	//We store 20% of the feature vectors for validation
+	int validationIndex = 0, trainingIndex = 0;
+	for (size_t i = 0; i < dataset.getFeatureVectorCount(); ++i)
+	{
+		const Eigen::Map<Eigen::VectorXd> oFeatureVec(const_cast<double*>(dataset.getFeatureVector(i).getBuffer()), nFeature);
+		Eigen::VectorXd oData = oFeatureVec;
+		if (classCount[dataset.getFeatureVector(i).getLabel()] > 0)
+		{
+			oValidationDataMatrix.col(validationIndex++) = oData;
+			oValidationSet.push_back(dataset.getFeatureVector(i).getLabel());
+			--classCount[dataset.getFeatureVector(i).getLabel()];
+		}
+		else
+		{
+			oTrainingDataMatrix.col(trainingIndex++) = oData;
+			oTrainingSet.push_back(dataset.getFeatureVector(i).getLabel());
+		}
+	}
+
+	//We now get the min and the max of the training set for normalization
+	m_max = oTrainingDataMatrix.maxCoeff();
+	m_min = oTrainingDataMatrix.minCoeff();
+	//Normalization of the data. We need to do it to avoid saturation of tanh.
+	for (size_t i = 0; i < size_t(oTrainingDataMatrix.cols()); ++i)
+	{
+		for (size_t j = 0; j < size_t(oTrainingDataMatrix.rows()); ++j)
+		{
+			oTrainingDataMatrix(j, i) = 2 * (oTrainingDataMatrix(j, i) - m_min) / (m_max - m_min) - 1;
+		}
+	}
+	for (size_t i = 0; i < size_t(oValidationDataMatrix.cols()); ++i)
+	{
+		for (size_t j = 0; j < size_t(oValidationDataMatrix.rows()); ++j)
+		{
+			oValidationDataMatrix(j, i) = 2 * (oValidationDataMatrix(j, i) - m_min) / (m_max - m_min) - 1;
+		}
+	}
+
+	const double featureCount = double(oTrainingSet.size());
+	const double boundValue   = 1. / (nFeature + 1);
+	double previousError      = std::numeric_limits<double>::max();
+	double cumulativeError    = 0;
+
+	//Let's generate randomly weights and biases
+	//We restrain the weight between -1/(fan-in) and 1/(fan-in) to avoid saturation in the worst case
+	m_inputWeight = Eigen::MatrixXd::Random(hiddenNeuronCount, nFeature) * boundValue;
+	m_inputBias   = Eigen::VectorXd::Random(hiddenNeuronCount) * boundValue;
+
+	m_hiddenWeight = Eigen::MatrixXd::Random(nbClass, hiddenNeuronCount) * boundValue;
+	m_hiddenBias   = Eigen::VectorXd::Random(nbClass) * boundValue;
+
+	Eigen::MatrixXd oDeltaInputWeight  = Eigen::MatrixXd::Zero(hiddenNeuronCount, nFeature);
+	Eigen::VectorXd oDeltaInputBias    = Eigen::VectorXd::Zero(hiddenNeuronCount);
+	Eigen::MatrixXd oDeltaHiddenWeight = Eigen::MatrixXd::Zero(nbClass, hiddenNeuronCount);
+	Eigen::VectorXd oDeltaHiddenBias   = Eigen::VectorXd::Zero(nbClass);
+
+	Eigen::MatrixXd oY1, oA2;
+	//A1 is the value compute in hidden neuron before applying tanh
+	//Y1 is the output vector of hidden layer
+	//A2 is the value compute by output neuron before applying transfer function
+	//Y2 is the value of output after the transfer function (softmax)
+	while (true)
+	{
+		oDeltaInputWeight.setZero();
+		oDeltaInputBias.setZero();
+		oDeltaHiddenWeight.setZero();
+		oDeltaHiddenBias.setZero();
+		//The first cast of tanh has to been explicit for windows compilation
+		oY1.noalias() = ((m_inputWeight * oTrainingDataMatrix).colwise() + m_inputBias).unaryExpr(
+			std::ptr_fun<double, double>(static_cast<double(*)(double)>(tanh)));
+		oA2.noalias() = (m_hiddenWeight * oY1).colwise() + m_hiddenBias;
+		for (size_t i = 0; i < featureCount; ++i)
+		{
+			const Eigen::VectorXd& oTarget = targetList[oTrainingSet[i]];
+			const Eigen::VectorXd& oData   = oTrainingDataMatrix.col(i);
+
+			//Now we compute all deltas of output layer
+			Eigen::VectorXd oOutputDelta = oA2.col(i) - oTarget;
+			for (size_t j = 0; j < nbClass; ++j)
+			{
+				for (size_t k = 0; k < hiddenNeuronCount; ++k) { oDeltaHiddenWeight(j, k) -= oOutputDelta[j] * oY1.col(i)[k]; }
+			}
+			oDeltaHiddenBias.noalias() -= oOutputDelta;
+
+			//Now we take care of the hidden layer
+			Eigen::VectorXd oHiddenDelta = Eigen::VectorXd::Zero(hiddenNeuronCount);
+			for (size_t j = 0; j < hiddenNeuronCount; ++j)
+			{
+				for (size_t k = 0; k < nbClass; ++k) { oHiddenDelta[j] += oOutputDelta[k] * m_hiddenWeight(k, j); }
+				oHiddenDelta[j] *= (1 - pow(oY1.col(i)[j], 2));
+			}
+
+			for (size_t j = 0; j < hiddenNeuronCount; ++j) { for (size_t k = 0; k < nFeature; ++k) { oDeltaInputWeight(j, k) -= oHiddenDelta[j] * oData[k]; } }
+			oDeltaInputBias.noalias() -= oHiddenDelta;
+		}
+		//We finish the loop, let's apply deltas
+		m_hiddenWeight.noalias() += oDeltaHiddenWeight / featureCount * alpha;
+		m_hiddenBias.noalias() += oDeltaHiddenBias / featureCount * alpha;
+		m_inputWeight.noalias() += oDeltaInputWeight / featureCount * alpha;
+		m_inputBias.noalias() += oDeltaInputBias / featureCount * alpha;
+
+		dumpMatrix(this->getLogManager(), m_hiddenWeight, "m_hiddenWeight");
+		dumpMatrix(this->getLogManager(), m_hiddenBias, "m_hiddenBias");
+		dumpMatrix(this->getLogManager(), m_inputWeight, "m_inputWeight");
+		dumpMatrix(this->getLogManager(), m_inputBias, "m_inputBias");
+
+		//Now we compute the cumulative error in the validation set
+		cumulativeError = 0;
+		//We don't compute Y2 because we train on the identity
+		oA2.noalias() = (m_hiddenWeight * ((m_inputWeight * oValidationDataMatrix).colwise() + m_inputBias).unaryExpr(std::ptr_fun<double, double>(tanh))).
+						colwise() + m_hiddenBias;
+		for (size_t i = 0; i < oValidationSet.size(); ++i)
+		{
+			const Eigen::VectorXd& oTarget         = targetList[oValidationSet[i]];
+			const Eigen::VectorXd& oIdentityResult = oA2.col(i);
+
+			//Now we need to compute the error
+			for (size_t j = 0; j < nbClass; ++j) { cumulativeError += 0.5 * pow(oIdentityResult[j] - oTarget[j], 2); }
+		}
+		cumulativeError /= oValidationSet.size();
+		//If the delta of error is under Epsilon we consider that the training is over
+		if (previousError - cumulativeError < epsilon) { break; }
+		previousError = cumulativeError;
+	}
+	dumpMatrix(this->getLogManager(), m_hiddenWeight, "oHiddenWeight");
+	dumpMatrix(this->getLogManager(), m_hiddenBias, "oHiddenBias");
+	dumpMatrix(this->getLogManager(), m_inputWeight, "oInputWeight");
+	dumpMatrix(this->getLogManager(), m_inputBias, "oInputBias");
+	return true;
+}
+
+bool CAlgorithmClassifierMLP::classify(const Toolkit::IFeatureVector& sample, double& classLabel, Toolkit::IVector& distance, Toolkit::IVector& probability)
+{
+	if (sample.getSize() != size_t(m_inputWeight.cols()))
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "Classifier expected " << size_t(m_inputWeight.cols()) << " features, got " << sample.getSize() << "\n";
+		return false;
+	}
+
+	const Eigen::Map<Eigen::VectorXd> oFeatureVec(const_cast<double*>(sample.getBuffer()), sample.getSize());
+	Eigen::VectorXd oData = oFeatureVec;
+	//we normalize and center data on 0 to avoid saturation
+	for (size_t j = 0; j < sample.getSize(); ++j) { oData[j] = 2 * (oData[j] - m_min) / (m_max - m_min) - 1; }
+
+	const size_t classCount = m_labels.size();
+
+	Eigen::VectorXd oA2 = m_hiddenBias + (m_hiddenWeight * (m_inputBias + (m_inputWeight * oData)).unaryExpr(std::ptr_fun<double, double>(tanh)));
+
+	//The final transfer function is the softmax
+	Eigen::VectorXd oY2 = oA2.unaryExpr(std::ptr_fun<double, double>(exp));
+	oY2 /= oY2.sum();
+
+	distance.setSize(classCount);
+	probability.setSize(classCount);
+
+	//We use A2 as the classification values output, and the Y2 as the probability
+	double max        = oY2[0];
+	size_t classFound = 0;
+	distance[0]       = oA2[0];
+	probability[0]    = oY2[0];
+	for (size_t i = 1; i < classCount; ++i)
+	{
+		if (oY2[i] > max)
+		{
+			max        = oY2[i];
+			classFound = i;
+		}
+		distance[i]    = oA2[i];
+		probability[i] = oY2[i];
+	}
+
+	classLabel = m_labels[classFound];
+
+	return true;
+}
+
+XML::IXMLNode* CAlgorithmClassifierMLP::saveConfig()
+{
+	XML::IXMLNode* rootNode = XML::createNode(MLP_TYPE_NODE_NAME);
+
+	std::stringstream classes;
+	for (int i = 0; i < m_hiddenBias.size(); ++i) { classes << m_labels[i] << " "; }
+	XML::IXMLNode* classLabelNode = XML::createNode(MLP_CLASS_LABEL_NODE_NAME);
+	classLabelNode->setPCData(classes.str().c_str());
+	rootNode->addChild(classLabelNode);
+
+	XML::IXMLNode* configuration = XML::createNode(MLP_NEURON_CONFIG_NODE_NAME);
+
+	//The input and output neuron count are not mandatory but they facilitate a lot the loading process
+	XML::IXMLNode* tempNode = XML::createNode(MLP_INPUT_NEURON_COUNT_NODE_NAME);
+	dumpData(tempNode, int64_t(m_inputWeight.cols()));
+	configuration->addChild(tempNode);
+
+	tempNode = XML::createNode(MLP_HIDDEN_NEURON_COUNT_NODE_NAME);
+	dumpData(tempNode, int64_t(m_inputWeight.rows()));
+	configuration->addChild(tempNode);
+	rootNode->addChild(configuration);
+
+	tempNode = XML::createNode(MLP_MIN_NODE_NAME);
+	dumpData(tempNode, m_min);
+	rootNode->addChild(tempNode);
+
+	tempNode = XML::createNode(MLP_MAX_NODE_NAME);
+	dumpData(tempNode, m_max);
+	rootNode->addChild(tempNode);
+
+	tempNode = XML::createNode(MLP_INPUT_WEIGHT_NODE_NAME);
+	dumpData(tempNode, m_inputWeight);
+	rootNode->addChild(tempNode);
+
+	tempNode = XML::createNode(MLP_INPUT_BIAS_NODE_NAME);
+	dumpData(tempNode, m_inputBias);
+	rootNode->addChild(tempNode);
+
+	tempNode = XML::createNode(MLP_HIDDEN_BIAS_NODE_NAME);
+	dumpData(tempNode, m_hiddenBias);
+	rootNode->addChild(tempNode);
+
+	tempNode = XML::createNode(MLP_HIDDEN_WEIGHT_NODE_NAME);
+	dumpData(tempNode, m_hiddenWeight);
+	rootNode->addChild(tempNode);
+
+	return rootNode;
+}
+
+bool CAlgorithmClassifierMLP::loadConfig(XML::IXMLNode* configNode)
+{
+	m_labels.clear();
+	std::stringstream data(configNode->getChildByName(MLP_CLASS_LABEL_NODE_NAME)->getPCData());
+	double temp;
+	while (data >> temp) { m_labels.push_back(temp); }
+
+	int64_t featureSize, hiddenNeuronCount;
+	XML::IXMLNode* neuronConfigNode = configNode->getChildByName(MLP_NEURON_CONFIG_NODE_NAME);
+
+	loadData(neuronConfigNode->getChildByName(MLP_HIDDEN_NEURON_COUNT_NODE_NAME), hiddenNeuronCount);
+	loadData(neuronConfigNode->getChildByName(MLP_INPUT_NEURON_COUNT_NODE_NAME), featureSize);
+
+	loadData(configNode->getChildByName(MLP_MAX_NODE_NAME), m_max);
+	loadData(configNode->getChildByName(MLP_MIN_NODE_NAME), m_min);
+
+	loadData(configNode->getChildByName(MLP_INPUT_WEIGHT_NODE_NAME), m_inputWeight, hiddenNeuronCount, featureSize);
+	loadData(configNode->getChildByName(MLP_INPUT_BIAS_NODE_NAME), m_inputBias);
+	loadData(configNode->getChildByName(MLP_HIDDEN_WEIGHT_NODE_NAME), m_hiddenWeight, m_labels.size(), hiddenNeuronCount);
+	loadData(configNode->getChildByName(MLP_HIDDEN_BIAS_NODE_NAME), m_hiddenBias);
+
+	return true;
+}
+
+void CAlgorithmClassifierMLP::dumpData(XML::IXMLNode* node, Eigen::MatrixXd& matrix)
+{
+	std::stringstream data;
+
+	data << std::scientific;
+	for (size_t i = 0; i < size_t(matrix.rows()); ++i) { for (size_t j = 0; j < size_t(matrix.cols()); ++j) { data << " " << matrix(i, j); } }
+
+	node->setPCData(data.str().c_str());
+}
+
+void CAlgorithmClassifierMLP::dumpData(XML::IXMLNode* node, Eigen::VectorXd& vector)
+{
+	std::stringstream data;
+
+	data << std::scientific;
+	for (size_t i = 0; i < size_t(vector.size()); ++i) { data << " " << vector[i]; }
+
+	node->setPCData(data.str().c_str());
+}
+
+void CAlgorithmClassifierMLP::dumpData(XML::IXMLNode* node, const int64_t value)
+{
+	std::stringstream data;
+	data << value;
+	node->setPCData(data.str().c_str());
+}
+
+void CAlgorithmClassifierMLP::dumpData(XML::IXMLNode* node, const double value)
+{
+	std::stringstream data;
+	data << std::scientific;
+	data << value;
+	node->setPCData(data.str().c_str());
+}
+
+void CAlgorithmClassifierMLP::loadData(XML::IXMLNode* node, Eigen::MatrixXd& matrix, const size_t nRow, const size_t nCol)
+{
+	matrix = Eigen::MatrixXd(nRow, nCol);
+	std::stringstream data(node->getPCData());
+
+	std::vector<double> coefs;
+	double value;
+	while (data >> value) { coefs.push_back(value); }
+
+	size_t index = 0;
+	for (size_t i = 0; i < nRow; ++i)
+	{
+		for (size_t j = 0; j < nCol; ++j)
+		{
+			matrix(int(i), int(j)) = coefs[index];
+			++index;
+		}
+	}
+}
+
+void CAlgorithmClassifierMLP::loadData(XML::IXMLNode* node, Eigen::VectorXd& vector)
+{
+	std::stringstream data(node->getPCData());
+	std::vector<double> coefs;
+	double value;
+	while (data >> value) { coefs.push_back(value); }
+	vector = Eigen::VectorXd(coefs.size());
+
+	for (size_t i = 0; i < coefs.size(); ++i) { vector[i] = coefs[i]; }
+}
+
+void CAlgorithmClassifierMLP::loadData(XML::IXMLNode* node, int64_t& value)
+{
+	std::stringstream data(node->getPCData());
+	data >> value;
+}
+
+void CAlgorithmClassifierMLP::loadData(XML::IXMLNode* node, double& value)
+{
+	std::stringstream data(node->getPCData());
+	data >> value;
+}
+
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE
+#endif  // TARGET_HAS_ThirdPartyEIGEN

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/algorithms/ovpCAlgorithmClassifierMLP.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#if defined TARGET_HAS_ThirdPartyEIGEN
+
+#include <openvibe/ov_all.h>
+#include <toolkit/ovtk_all.h>
+
+#define OVP_ClassId_Algorithm_ClassifierMLP									CIdentifier(0xF3FAB4BE, 0xDC401260)
+#define OVP_ClassId_Algorithm_ClassifierMLP_DecisionAvailable				CIdentifier(0xF3FAB4BE, 0xDC401261)
+#define OVP_ClassId_Algorithm_ClassifierMLPDesc								CIdentifier(0xF3FAB4BE, 0xDC401262)
+
+#define OVP_Algorithm_ClassifierMLP_InputParameterId_HiddenNeuronCount		CIdentifier(0xF3FAB4BE, 0xDC401263)
+#define OVP_Algorithm_ClassifierMLP_InputParameterId_Epsilon				CIdentifier(0xF3FAB4BE, 0xDC401264)
+#define OVP_Algorithm_ClassifierMLP_InputParameterId_Alpha					CIdentifier(0xF3FAB4BE, 0xDC401265)
+
+#include <Eigen/Dense>
+
+#include <xml/IXMLNode.h>
+#include <vector>
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+int MLPClassificationCompare(CMatrix& first, CMatrix& second);
+
+class CAlgorithmClassifierMLP final : public Toolkit::CAlgorithmClassifier
+{
+public:
+
+	bool initialize() override;
+	bool uninitialize() override;
+
+	bool train(const Toolkit::IFeatureVectorSet& dataset) override;
+	bool classify(const Toolkit::IFeatureVector& sample, double& classLabel,
+				  Toolkit::IVector& distance, Toolkit::IVector& probability) override;
+
+	XML::IXMLNode* saveConfig() override;
+	bool loadConfig(XML::IXMLNode* configNode) override;
+
+	size_t getNProbabilities() override { return m_labels.size(); }
+	size_t getNDistances() override { return m_labels.size(); }
+
+	_IsDerivedFromClass_Final_(CAlgorithmClassifier, OVP_ClassId_Algorithm_ClassifierMLP)
+
+private:
+	//Helpers for load or sotre data in XMLNode
+	static void dumpData(XML::IXMLNode* node, Eigen::MatrixXd& matrix);
+	static void dumpData(XML::IXMLNode* node, Eigen::VectorXd& vector);
+	static void dumpData(XML::IXMLNode* node, int64_t value);
+	static void dumpData(XML::IXMLNode* node, double value);
+
+	static void loadData(XML::IXMLNode* node, Eigen::MatrixXd& matrix, size_t nRow, size_t nCol);
+	static void loadData(XML::IXMLNode* node, Eigen::VectorXd& vector);
+	static void loadData(XML::IXMLNode* node, int64_t& value);
+	static void loadData(XML::IXMLNode* node, double& value);
+
+	std::vector<double> m_labels;
+
+	Eigen::MatrixXd m_inputWeight;
+	Eigen::VectorXd m_inputBias;
+
+	Eigen::MatrixXd m_hiddenWeight;
+	Eigen::VectorXd m_hiddenBias;
+
+	double m_min = 0;
+	double m_max = 0;
+};
+
+class CAlgorithmClassifierMLPDesc final : public Toolkit::CAlgorithmClassifierDesc
+{
+public:
+
+	void release() override { }
+
+	CString getName() const override { return CString("MLP Classifier"); }
+	CString getAuthorName() const override { return CString("Guillaume Serrière"); }
+	CString getAuthorCompanyName() const override { return CString("Inria / Loria"); }
+	CString getShortDescription() const override { return CString("Multi-layer perceptron algorithm"); }
+	CString getDetailedDescription() const override { return CString(""); }
+	CString getCategory() const override { return CString(""); }
+	CString getVersion() const override { return CString("0.1"); }
+
+	CIdentifier getCreatedClass() const override { return OVP_ClassId_Algorithm_ClassifierMLP; }
+	IPluginObject* create() override { return new CAlgorithmClassifierMLP; }
+
+	bool getAlgorithmPrototype(Kernel::IAlgorithmProto& prototype) const override
+	{
+		CAlgorithmClassifierDesc::getAlgorithmPrototype(prototype);
+
+		prototype.addInputParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_HiddenNeuronCount, "Number of neurons in hidden layer",
+									Kernel::ParameterType_Integer);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_Epsilon, "Learning stop condition", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierMLP_InputParameterId_Alpha, "Learning coefficient", Kernel::ParameterType_Float);
+		return true;
+	}
+
+	_IsDerivedFromClass_Final_(CAlgorithmClassifierDesc, OVP_ClassId_Algorithm_ClassifierMLPDesc)
+};
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE
+#endif // TARGET_HAS_ThirdPartyEIGEN

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/algorithms/ovpCAlgorithmClassifierSVM.cpp

@@ -0,0 +1,757 @@
+#include "../ovp_defines.h"
+
+#include "ovpCAlgorithmClassifierSVM.h"
+
+#include <sstream>
+#include <iostream>
+#include <cstring>
+#include <cmath>
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+
+static const char* const TYPE_NODE_NAME        = "SVM";
+static const char* const PARAM_NODE_NAME       = "Param";
+static const char* const SVM_TYPE_NODE_NAME    = "svm_type";
+static const char* const KERNEL_TYPE_NODE_NAME = "kernel_type";
+static const char* const DEGREE_NODE_NAME      = "degree";
+static const char* const GAMMA_NODE_NAME       = "gamma";
+static const char* const COEF0_NODE_NAME       = "coef0";
+static const char* const MODEL_NODE_NAME       = "Model";
+static const char* const NR_CLASS_NODE_NAME    = "nr_class";
+static const char* const TOTAL_SV_NODE_NAME    = "total_sv";
+static const char* const RHO_NODE_NAME         = "rho";
+static const char* const LABEL_NODE_NAME       = "label";
+static const char* const PROB_A_NODE_NAME      = "probA";
+static const char* const PROB_B_NODE_NAME      = "probB";
+static const char* const NR_SV_NODE_NAME       = "nr_sv";
+static const char* const SVS_NODE_NAME         = "SVs";
+static const char* const SV_NODE_NAME          = "SV";
+static const char* const COEF_NODE_NAME        = "coef";
+static const char* const VALUE_NODE_NAME       = "value";
+
+int SVMClassificationCompare(CMatrix& first, CMatrix& second)
+{
+	if (OVFloatEqual(std::fabs(first[0]), std::fabs(second[0]))) { return 0; }
+	if (std::fabs(first[0]) > std::fabs(second[0])) { return -1; }
+	return 1;
+}
+
+bool CAlgorithmClassifierSVM::initialize()
+{
+	Kernel::TParameterHandler<int64_t> iSVMType(this->getInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMType));
+	Kernel::TParameterHandler<int64_t> iSVMKernelType(this->getInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMKernelType));
+	Kernel::TParameterHandler<int64_t> iDegree(this->getInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMDegree));
+	Kernel::TParameterHandler<double> iGamma(this->getInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMGamma));
+	Kernel::TParameterHandler<double> iCoef0(this->getInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMCoef0));
+	Kernel::TParameterHandler<double> iCost(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCost));
+	Kernel::TParameterHandler<double> iNu(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMNu));
+	Kernel::TParameterHandler<double> iEpsilon(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMEpsilon));
+	Kernel::TParameterHandler<double> iCacheSize(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCacheSize));
+	Kernel::TParameterHandler<double> iEpsilonTolerance(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMTolerance));
+	Kernel::TParameterHandler<bool> iShrinking(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMShrinking));
+	//TParameterHandler < bool > iProbabilityEstimate(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMProbabilityEstimate));
+	Kernel::TParameterHandler<CString*> ip_weight(this->getInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMweight));
+	Kernel::TParameterHandler<CString*> ip_weightLabel(this->getInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMWeightLabel));
+
+	iSVMType          = C_SVC;
+	iSVMKernelType    = LINEAR;
+	iDegree           = 3;
+	iGamma            = 0;
+	iCoef0            = 0;
+	iCost             = 1;
+	iNu               = 0.5;
+	iEpsilon          = 0.1;
+	iCacheSize        = 100;
+	iEpsilonTolerance = 0.001;
+	iShrinking        = true;
+	//iProbabilityEstimate=true;
+	*ip_weight      = "";
+	*ip_weightLabel = "";
+
+	Kernel::TParameterHandler<XML::IXMLNode*> config(this->getOutputParameter(OVTK_Algorithm_Classifier_OutputParameterId_Config));
+	config   = nullptr;
+	m_prob.y = nullptr;
+	m_prob.x = nullptr;
+
+	m_param.weight       = nullptr;
+	m_param.weight_label = nullptr;
+
+	m_model           = nullptr;
+	m_modelWasTrained = false;
+
+	return CAlgorithmClassifier::initialize();
+}
+
+bool CAlgorithmClassifierSVM::uninitialize()
+{
+	if (m_prob.x != nullptr && m_prob.y != nullptr)
+	{
+		for (size_t i = 0; i < size_t(m_prob.l); ++i) { delete[] m_prob.x[i]; }
+		delete[] m_prob.y;
+		delete[] m_prob.x;
+		m_prob.y = nullptr;
+		m_prob.x = nullptr;
+	}
+
+	if (m_param.weight != nullptr)
+	{
+		delete[] m_param.weight;
+		m_param.weight = nullptr;
+	}
+
+	if (m_param.weight_label != nullptr)
+	{
+		delete[] m_param.weight_label;
+		m_param.weight_label = nullptr;
+	}
+
+	deleteModel(m_model, !m_modelWasTrained);
+	m_model           = nullptr;
+	m_modelWasTrained = false;
+
+	return CAlgorithmClassifier::uninitialize();
+}
+
+void CAlgorithmClassifierSVM::deleteModel(svm_model* model, const bool freeSupportVectors)
+{
+	if (model != nullptr)
+	{
+		delete[] model->rho;
+		delete[] model->probA;
+		delete[] model->probB;
+		delete[] model->label;
+		delete[] model->nSV;
+
+		for (size_t i = 0; i < size_t(model->nr_class - 1); ++i) { delete[] model->sv_coef[i]; }
+		delete[] model->sv_coef;
+
+		// We need the following depending on how the model was allocated. If we got it from svm_train,
+		// the support vectors are pointers to the problem structure which is freed elsewhere. 
+		// If we loaded the model from disk, we allocated the vectors separately.
+		if (freeSupportVectors) { for (size_t i = 0; i < size_t(model->l); ++i) { delete[] model->SV[i]; } }
+		delete[] model->SV;
+
+		delete model;
+		model = nullptr;
+	}
+}
+
+void CAlgorithmClassifierSVM::setParameter()
+{
+	this->initializeExtraParameterMechanism();
+
+	m_param.svm_type    = int(this->getEnumerationParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMType, OVP_TypeId_SVMType));
+	m_param.kernel_type = int(this->getEnumerationParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMKernelType, OVP_TypeId_SVMKernelType));
+	m_param.degree      = int(this->getInt64Parameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMDegree));
+	m_param.gamma       = this->getDoubleParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMGamma);
+	m_param.coef0       = this->getDoubleParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMCoef0);
+	m_param.C           = this->getDoubleParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCost);
+	m_param.nu          = this->getDoubleParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMNu);
+	m_param.p           = this->getDoubleParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMEpsilon);
+	m_param.cache_size  = this->getDoubleParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCacheSize);
+	m_param.eps         = this->getDoubleParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMTolerance);
+	m_param.shrinking   = int(this->getBooleanParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMShrinking));
+	//	m_param.probability        = this->getBooleanParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMShrinking);
+	m_param.probability            = 1;
+	const CString paramWeight      = *this->getCStringParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMweight);
+	const CString paramWeightLabel = *this->getCStringParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMWeightLabel);
+
+	this->uninitializeExtraParameterMechanism();
+
+	std::vector<double> weights;
+	std::stringstream ssWeight(paramWeight.toASCIIString());
+	double value;
+	while (ssWeight >> value) { weights.push_back(value); }
+
+	m_param.nr_weight = weights.size();
+	double* weight    = new double[weights.size()];
+	for (uint32_t i = 0; i < weights.size(); ++i) { weight[i] = weights[i]; }
+	m_param.weight = weight;//nullptr;
+
+	std::vector<int64_t> labels;
+	std::stringstream ssLabel(paramWeightLabel.toASCIIString());
+	int64_t iValue;
+	while (ssLabel >> iValue) { labels.push_back(iValue); }
+
+	//the number of weight label need to be equal to the number of weight
+	while (labels.size() < weights.size()) { labels.push_back(labels.size() + 1); }
+
+	int* label = new int[weights.size()];
+	for (size_t i = 0; i < weights.size(); ++i) { label[i] = int(labels[i]); }
+	m_param.weight_label = label;//nullptr;
+}
+
+bool CAlgorithmClassifierSVM::train(const Toolkit::IFeatureVectorSet& dataset)
+{
+	if (m_prob.x != nullptr && m_prob.y != nullptr)
+	{
+		for (size_t i = 0; i < size_t(m_prob.l); ++i) { delete[] m_prob.x[i]; }
+		delete[] m_prob.y;
+		delete[] m_prob.x;
+		m_prob.y = nullptr;
+		m_prob.x = nullptr;
+	}
+	// default Param values
+	//std::cout<<"param config"<<std::endl;
+	this->setParameter();
+	this->getLogManager() << Kernel::LogLevel_Trace << paramToString(&m_param);
+
+	//configure m_prob
+	//std::cout<<"prob config"<<std::endl;
+	m_prob.l    = dataset.getFeatureVectorCount();
+	m_nFeatures = dataset[0].getSize();
+
+	m_prob.y = new double[m_prob.l];
+	m_prob.x = new svm_node*[m_prob.l];
+
+	//std::cout<< "number vector:"<<l_oProb.l<<" size of vector:"<<m_nFeatures<<std::endl;
+
+	for (size_t i = 0; i < size_t(m_prob.l); ++i)
+	{
+		m_prob.x[i] = new svm_node[m_nFeatures + 1];
+		m_prob.y[i] = dataset[i].getLabel();
+		for (size_t j = 0; j < m_nFeatures; ++j)
+		{
+			m_prob.x[i][j].index = int(j + 1);
+			m_prob.x[i][j].value = dataset[i].getBuffer()[j];
+		}
+		m_prob.x[i][m_nFeatures].index = -1;
+	}
+
+	// Gamma of zero is interpreted as a request for automatic selection
+	if (m_param.gamma == 0) { m_param.gamma = 1.0 / (m_nFeatures > 0 ? m_nFeatures : 1.0); }
+
+	if (m_param.kernel_type == PRECOMPUTED)
+	{
+		for (size_t i = 0; i < size_t(m_prob.l); ++i)
+		{
+			if (m_prob.x[i][0].index != 0)
+			{
+				this->getLogManager() << Kernel::LogLevel_Error << "Wrong input format: first column must be 0:sample_serial_number\n";
+				return false;
+			}
+			if (m_prob.x[i][0].value <= 0 || m_prob.x[i][0].value > m_nFeatures)
+			{
+				this->getLogManager() << Kernel::LogLevel_Error << "Wrong input format: sample_serial_number out of range\n";
+				return false;
+			}
+		}
+	}
+
+	this->getLogManager() << Kernel::LogLevel_Trace << problemToString(&m_prob);
+
+	//make a model
+	//std::cout<<"svm_train"<<std::endl;
+	if (m_model != nullptr)
+	{
+		//std::cout<<"delete model"<<std::endl;
+		deleteModel(m_model, !m_modelWasTrained);
+		m_model           = nullptr;
+		m_modelWasTrained = false;
+	}
+	m_model = svm_train(&m_prob, &m_param);
+
+	if (m_model == nullptr)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "the training with SVM had failed\n";
+		return false;
+	}
+
+	m_modelWasTrained = true;
+
+	//std::cout<<"log model"<<std::endl;
+	this->getLogManager() << Kernel::LogLevel_Trace << modelToString();
+
+	return true;
+}
+
+bool CAlgorithmClassifierSVM::classify(const Toolkit::IFeatureVector& sample, double& classLabel, Toolkit::IVector& distance, Toolkit::IVector& probability)
+{
+	//std::cout<<"classify"<<std::endl;
+	if (m_model == nullptr)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "Classification is impossible with a model equalling nullptr\n";
+		return false;
+	}
+	if (m_model->nr_class == 0 || m_model->rho == nullptr)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "The model wasn't loaded correctly\n";
+		return false;
+	}
+	if (m_nFeatures != sample.getSize())
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "Classifier expected " << m_nFeatures << " features, got " << sample.getSize() << "\n";
+		return false;
+	}
+	if (m_model->param.gamma == 0 &&
+		(m_model->param.kernel_type == POLY || m_model->param.kernel_type == RBF || m_model->param.kernel_type == SIGMOID))
+	{
+		m_model->param.gamma = 1.0 / (m_nFeatures > 0 ? m_nFeatures : 1.0);
+		this->getLogManager() << Kernel::LogLevel_Warning << "The SVM model had gamma=0. Setting it to [" << m_model->param.gamma << "].\n";
+	}
+
+	//std::cout<<"create X"<<std::endl;
+	svm_node* x = new svm_node[sample.getSize() + 1];
+	//std::cout<<"featureVector.getSize():"<<featureVector.getSize()<<"m_numberOfFeatures"<<m_numberOfFeatures<<std::endl;
+	for (uint32_t i = 0; i < sample.getSize(); ++i)
+	{
+		x[i].index = int(i + 1);
+		x[i].value = sample.getBuffer()[i];
+		//std::cout<< X[i].index << ";"<<X[i].value<<" ";
+	}
+	x[sample.getSize()].index = -1;
+
+	//std::cout<<"create ProbEstimates"<<std::endl;
+	double* probEstimates = new double[m_model->nr_class];
+	for (size_t i = 0; i < size_t(m_model->nr_class); ++i) { probEstimates[i] = 0; }
+
+	classLabel = svm_predict_probability(m_model, x, probEstimates);
+
+	//std::cout<<classLabel<<std::endl;
+	//std::cout<<"probability"<<std::endl;
+
+	//If we are not in these modes, label is nullptr and there is no probability
+	if (m_model->param.svm_type == C_SVC || m_model->param.svm_type == NU_SVC)
+	{
+		probability.setSize(m_model->nr_class);
+		this->getLogManager() << Kernel::LogLevel_Trace << "Label predict: " << classLabel << "\n";
+
+		for (size_t i = 0; i < size_t(m_model->nr_class); ++i)
+		{
+			this->getLogManager() << Kernel::LogLevel_Trace << "index:" << i << " label:" << m_model->label[i] << " probability:" << probEstimates[i] << "\n";
+			probability[(m_model->label[i])] = probEstimates[i];
+		}
+	}
+	else { probability.setSize(0); }
+
+	//The hyperplane distance is disabled for SVM
+	distance.setSize(0);
+
+	//std::cout<<";"<<classLabel<<";"<<distance[0] <<";"<<ProbEstimates[0]<<";"<<ProbEstimates[1]<<std::endl;
+	//std::cout<<"Label predict "<<classLabel<< " proba:"<<distance[0]<<std::endl;
+	//std::cout<<"end classify"<<std::endl;
+	delete[] x;
+	delete[] probEstimates;
+
+	return true;
+}
+
+XML::IXMLNode* CAlgorithmClassifierSVM::saveConfig()
+{
+	//xml file
+	//std::cout<<"model save"<<std::endl;
+
+	std::vector<CString> coefs;
+	std::vector<CString> values;
+
+	//std::cout<<"model save: rho"<<std::endl;
+	std::stringstream ssRho;
+	ssRho << std::scientific << m_model->rho[0];
+
+	for (size_t i = 1; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ssRho << " " << m_model->rho[i]; }
+
+	//std::cout<<"model save: sv_coef and SV"<<std::endl;
+	for (size_t i = 0; i < size_t(m_model->l); ++i)
+	{
+		std::stringstream ssCoef;
+		std::stringstream ssValue;
+
+		ssCoef << m_model->sv_coef[0][i];
+		for (int j = 1; j < m_model->nr_class - 1; ++j) { ssCoef << " " << m_model->sv_coef[j][i]; }
+
+		const svm_node* p = m_model->SV[i];
+
+		if (m_model->param.kernel_type == PRECOMPUTED) { ssValue << "0:" << double(p->value); }
+		else
+		{
+			if (p->index != -1)
+			{
+				ssValue << p->index << ":" << p->value;
+				p++;
+			}
+			while (p->index != -1)
+			{
+				ssValue << " " << p->index << ":" << p->value;
+				p++;
+			}
+		}
+		coefs.emplace_back(ssCoef.str().c_str());
+		values.emplace_back(ssValue.str().c_str());
+	}
+
+	XML::IXMLNode* svmNode = XML::createNode(TYPE_NODE_NAME);
+
+	//Param node
+	XML::IXMLNode* paramNode = XML::createNode(PARAM_NODE_NAME);
+	XML::IXMLNode* tempNode  = XML::createNode(SVM_TYPE_NODE_NAME);
+	tempNode->setPCData(get_svm_type(m_model->param.svm_type));
+	paramNode->addChild(tempNode);
+
+	tempNode = XML::createNode(KERNEL_TYPE_NODE_NAME);
+	tempNode->setPCData(get_kernel_type(m_model->param.kernel_type));
+	paramNode->addChild(tempNode);
+
+	if (m_model->param.kernel_type == POLY)
+	{
+		std::stringstream ss;
+		ss << m_model->param.degree;
+
+		tempNode = XML::createNode(DEGREE_NODE_NAME);
+		tempNode->setPCData(ss.str().c_str());
+		paramNode->addChild(tempNode);
+	}
+	if (m_model->param.kernel_type == POLY || m_model->param.kernel_type == RBF || m_model->param.kernel_type == SIGMOID)
+	{
+		std::stringstream ss;
+		ss << m_model->param.gamma;
+
+		tempNode = XML::createNode(GAMMA_NODE_NAME);
+		tempNode->setPCData(ss.str().c_str());
+		paramNode->addChild(tempNode);
+	}
+	if (m_model->param.kernel_type == POLY || m_model->param.kernel_type == SIGMOID)
+	{
+		std::stringstream ss;
+		ss << m_model->param.coef0;
+
+		tempNode = XML::createNode(COEF0_NODE_NAME);
+		tempNode->setPCData(ss.str().c_str());
+		paramNode->addChild(tempNode);
+	}
+	svmNode->addChild(paramNode);
+	//End param node
+
+	//Model Node
+	XML::IXMLNode* modelNode = XML::createNode(MODEL_NODE_NAME);
+	{
+		tempNode = XML::createNode(NR_CLASS_NODE_NAME);
+		std::stringstream ssNrClass;
+		ssNrClass << m_model->nr_class;
+		tempNode->setPCData(ssNrClass.str().c_str());
+		modelNode->addChild(tempNode);
+
+		tempNode = XML::createNode(TOTAL_SV_NODE_NAME);
+		std::stringstream ssTotalSv;
+		ssTotalSv << m_model->l;
+		tempNode->setPCData(ssTotalSv.str().c_str());
+		modelNode->addChild(tempNode);
+
+		tempNode = XML::createNode(RHO_NODE_NAME);
+		tempNode->setPCData(ssRho.str().c_str());
+		modelNode->addChild(tempNode);
+
+		if (m_model->label != nullptr)
+		{
+			std::stringstream ss;
+			ss << m_model->label[0];
+			for (size_t i = 1; i < size_t(m_model->nr_class); ++i) { ss << " " << m_model->label[i]; }
+
+			tempNode = XML::createNode(LABEL_NODE_NAME);
+			tempNode->setPCData(ss.str().c_str());
+			modelNode->addChild(tempNode);
+		}
+		if (m_model->probA != nullptr)
+		{
+			std::stringstream ss;
+			ss << std::scientific << m_model->probA[0];
+			for (size_t i = 1; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss << " " << m_model->probA[i]; }
+
+			tempNode = XML::createNode(PROB_A_NODE_NAME);
+			tempNode->setPCData(ss.str().c_str());
+			modelNode->addChild(tempNode);
+		}
+		if (m_model->probB != nullptr)
+		{
+			std::stringstream ss;
+			ss << std::scientific << m_model->probB[0];
+			for (size_t i = 1; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss << " " << m_model->probB[i]; }
+
+			tempNode = XML::createNode(PROB_B_NODE_NAME);
+			tempNode->setPCData(ss.str().c_str());
+			modelNode->addChild(tempNode);
+		}
+		if (m_model->nSV != nullptr)
+		{
+			std::stringstream ss;
+			ss << m_model->nSV[0];
+			for (size_t i = 1; i < size_t(m_model->nr_class); ++i) { ss << " " << m_model->nSV[i]; }
+
+			tempNode = XML::createNode(NR_SV_NODE_NAME);
+			tempNode->setPCData(ss.str().c_str());
+			modelNode->addChild(tempNode);
+		}
+
+		XML::IXMLNode* svsNode = XML::createNode(SVS_NODE_NAME);
+		{
+			for (size_t i = 0; i < size_t(m_model->l); ++i)
+			{
+				XML::IXMLNode* svNode = XML::createNode(SV_NODE_NAME);
+				{
+					tempNode = XML::createNode(COEF_NODE_NAME);
+					tempNode->setPCData(coefs[i]);
+					svNode->addChild(tempNode);
+
+					tempNode = XML::createNode(VALUE_NODE_NAME);
+					tempNode->setPCData(values[i]);
+					svNode->addChild(tempNode);
+				}
+				svsNode->addChild(svNode);
+			}
+		}
+		modelNode->addChild(svsNode);
+	}
+	svmNode->addChild(modelNode);
+	return svmNode;
+}
+
+bool CAlgorithmClassifierSVM::loadConfig(XML::IXMLNode* configNode)
+{
+	if (m_model != nullptr)
+	{
+		//std::cout<<"delete m_model load config"<<std::endl;
+		deleteModel(m_model, !m_modelWasTrained);
+		m_model           = nullptr;
+		m_modelWasTrained = false;
+	}
+	//std::cout<<"load config"<<std::endl;
+	m_model        = new svm_model();
+	m_model->rho   = nullptr;
+	m_model->probA = nullptr;
+	m_model->probB = nullptr;
+	m_model->label = nullptr;
+	m_model->nSV   = nullptr;
+	m_indexSV      = -1;
+
+	loadParamNodeConfiguration(configNode->getChildByName(PARAM_NODE_NAME));
+	loadModelNodeConfiguration(configNode->getChildByName(MODEL_NODE_NAME));
+
+	this->getLogManager() << Kernel::LogLevel_Trace << modelToString();
+	return true;
+}
+
+void CAlgorithmClassifierSVM::loadParamNodeConfiguration(XML::IXMLNode* paramNode)
+{
+	//svm_type
+	XML::IXMLNode* tempNode = paramNode->getChildByName(SVM_TYPE_NODE_NAME);
+	for (size_t i = 0; get_svm_type(i) != nullptr; ++i) { if (strcmp(get_svm_type(i), tempNode->getPCData()) == 0) { m_model->param.svm_type = i; } }
+	if (get_svm_type(m_model->param.svm_type) == nullptr)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "load configuration error: bad value for the parameter svm_type\n";
+	}
+
+	//kernel_type
+	tempNode = paramNode->getChildByName(KERNEL_TYPE_NODE_NAME);
+	for (size_t i = 0; get_kernel_type(i) != nullptr; ++i) { if (strcmp(get_kernel_type(i), tempNode->getPCData()) == 0) { m_model->param.kernel_type = i; } }
+	if (get_kernel_type(m_model->param.kernel_type) == nullptr)
+	{
+		this->getLogManager() << Kernel::LogLevel_Error << "load configuration error: bad value for the parameter kernel_type\n";
+	}
+
+	//Following parameters aren't required
+
+	//degree
+	tempNode = paramNode->getChildByName(DEGREE_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		ss >> m_model->param.degree;
+	}
+
+	//gamma
+	tempNode = paramNode->getChildByName(GAMMA_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		ss >> m_model->param.gamma;
+	}
+
+	//coef0
+	tempNode = paramNode->getChildByName(COEF0_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		ss >> m_model->param.coef0;
+	}
+}
+
+void CAlgorithmClassifierSVM::loadModelNodeConfiguration(XML::IXMLNode* modelNode)
+{
+	//nr_class
+	XML::IXMLNode* tempNode = modelNode->getChildByName(NR_CLASS_NODE_NAME);
+	std::stringstream ssNrClass(tempNode->getPCData());
+	ssNrClass >> m_model->nr_class;
+	//total_sv
+	tempNode = modelNode->getChildByName(TOTAL_SV_NODE_NAME);
+	std::stringstream ssTotalSv(tempNode->getPCData());
+	ssTotalSv >> m_model->l;
+	//rho
+	tempNode = modelNode->getChildByName(RHO_NODE_NAME);
+	std::stringstream ssRho(tempNode->getPCData());
+	m_model->rho = new double[m_model->nr_class * (m_model->nr_class - 1) / 2];
+	for (size_t i = 0; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ssRho >> m_model->rho[i]; }
+
+	//label
+	tempNode = modelNode->getChildByName(LABEL_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		m_model->label = new int[m_model->nr_class];
+		for (size_t i = 0; i < size_t(m_model->nr_class); ++i) { ss >> m_model->label[i]; }
+	}
+	//probA
+	tempNode = modelNode->getChildByName(PROB_A_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		m_model->probA = new double[m_model->nr_class * (m_model->nr_class - 1) / 2];
+		for (size_t i = 0; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss >> m_model->probA[i]; }
+	}
+	//probB
+	tempNode = modelNode->getChildByName(PROB_B_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		m_model->probB = new double[m_model->nr_class * (m_model->nr_class - 1) / 2];
+		for (size_t i = 0; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss >> m_model->probB[i]; }
+	}
+	//nr_sv
+	tempNode = modelNode->getChildByName(NR_SV_NODE_NAME);
+	if (tempNode != nullptr)
+	{
+		std::stringstream ss(tempNode->getPCData());
+		m_model->nSV = new int[m_model->nr_class];
+		for (size_t i = 0; i < size_t(m_model->nr_class); ++i) { ss >> m_model->nSV[i]; }
+	}
+
+	loadModelSVsNodeConfiguration(modelNode->getChildByName(SVS_NODE_NAME));
+}
+
+void CAlgorithmClassifierSVM::loadModelSVsNodeConfiguration(XML::IXMLNode* svsNodeParam)
+{
+	//Reserve all memory space required
+	m_model->sv_coef = new double*[m_model->nr_class - 1];
+	for (size_t i = 0; i < size_t(m_model->nr_class - 1); ++i) { m_model->sv_coef[i] = new double[m_model->l]; }
+	m_model->SV = new svm_node*[m_model->l];
+
+	//Now fill SV
+	for (size_t i = 0; i < svsNodeParam->getChildCount(); ++i)
+	{
+		XML::IXMLNode* tempNode = svsNodeParam->getChild(i);
+		std::stringstream coefData(tempNode->getChildByName(COEF_NODE_NAME)->getPCData());
+		for (int j = 0; j < m_model->nr_class - 1; ++j) { coefData >> m_model->sv_coef[j][i]; }
+
+		std::stringstream ss(tempNode->getChildByName(VALUE_NODE_NAME)->getPCData());
+		std::vector<int> svmIdx;
+		std::vector<double> svmValue;
+		char separateChar;
+		while (!ss.eof())
+		{
+			int index;
+			double value;
+			ss >> index;
+			ss >> separateChar;
+			ss >> value;
+			svmIdx.push_back(index);
+			svmValue.push_back(value);
+		}
+
+		m_nFeatures    = svmIdx.size();
+		m_model->SV[i] = new svm_node[svmIdx.size() + 1];
+		for (size_t j = 0; j < svmIdx.size(); ++j)
+		{
+			m_model->SV[i][j].index = svmIdx[j];
+			m_model->SV[i][j].value = svmValue[j];
+		}
+		m_model->SV[i][svmIdx.size()].index = -1;
+	}
+}
+
+CString CAlgorithmClassifierSVM::paramToString(svm_parameter* param)
+{
+	if (param == nullptr) { return std::string("Param: nullptr\n").c_str(); }
+
+	std::stringstream ss;
+	ss << "Param:\n";
+	ss << "\tsvm_type: " << get_svm_type(param->svm_type) << "\n";
+	ss << "\tkernel_type: " << get_kernel_type(param->kernel_type) << "\n";
+	ss << "\tdegree: " << param->degree << "\n";
+	ss << "\tgamma: " << param->gamma << "\n";
+	ss << "\tcoef0: " << param->coef0 << "\n";
+	ss << "\tnu: " << param->nu << "\n";
+	ss << "\tcache_size: " << param->cache_size << "\n";
+	ss << "\tC: " << param->C << "\n";
+	ss << "\teps: " << param->eps << "\n";
+	ss << "\tp: " << param->p << "\n";
+	ss << "\tshrinking: " << param->shrinking << "\n";
+	ss << "\tprobability: " << param->probability << "\n";
+	ss << "\tnr weight: " << param->nr_weight << "\n";
+	std::stringstream label;
+	for (size_t i = 0; i < size_t(param->nr_weight); ++i) { label << param->weight_label[i] << ";"; }
+	ss << "\tweight label: " << label.str() << "\n";
+	std::stringstream weight;
+	for (size_t i = 0; i < size_t(param->nr_weight); ++i) { weight << param->weight[i] << ";"; }
+	ss << "\tweight: " << weight.str() << "\n";
+	return ss.str().c_str();
+}
+
+
+CString CAlgorithmClassifierSVM::modelToString() const
+{
+	if (m_model == nullptr) { return std::string("Model: nullptr\n").c_str(); }
+
+	std::stringstream ss;
+	ss << paramToString(&m_model->param);
+	ss << "Model:" << "\n";
+	ss << "\tnr_class: " << m_model->nr_class << "\n";
+	ss << "\ttotal_sv: " << m_model->l << "\n";
+	ss << "\trho: ";
+	if (m_model->rho != nullptr)
+	{
+		ss << m_model->rho[0];
+		for (size_t i = 1; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss << " " << m_model->rho[i]; }
+	}
+	ss << "\n";
+	ss << "\tlabel: ";
+	if (m_model->label != nullptr)
+	{
+		ss << m_model->label[0];
+		for (size_t i = 1; i < size_t(m_model->nr_class); ++i) { ss << " " << m_model->label[i]; }
+	}
+	ss << "\n";
+	ss << "\tprobA: ";
+	if (m_model->probA != nullptr)
+	{
+		ss << m_model->probA[0];
+		for (size_t i = 1; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss << " " << m_model->probA[i]; }
+	}
+	ss << "\n";
+	ss << "\tprobB: ";
+	if (m_model->probB != nullptr)
+	{
+		ss << m_model->probB[0];
+		for (size_t i = 1; i < size_t(m_model->nr_class * (m_model->nr_class - 1) / 2); ++i) { ss << " " << m_model->probB[i]; }
+	}
+	ss << "\n";
+	ss << "\tnr_sv: ";
+	if (m_model->nSV != nullptr)
+	{
+		ss << m_model->nSV[0];
+		for (size_t i = 1; i < size_t(m_model->nr_class); ++i) { ss << " " << m_model->nSV[i]; }
+	}
+	ss << "\n";
+
+	return ss.str().c_str();
+}
+
+CString CAlgorithmClassifierSVM::problemToString(svm_problem* prob) const
+{
+	if (prob == nullptr) { return std::string("Problem: nullptr\n").c_str(); }
+	std::stringstream ss;
+	ss << "Problem\ttotal sv: " << prob->l << "\n\tnb features: " << m_nFeatures << "\n";
+	return ss.str().c_str();
+}
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/algorithms/ovpCAlgorithmClassifierSVM.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#include <openvibe/ov_all.h>
+#include <toolkit/ovtk_all.h>
+
+#include <xml/IXMLNode.h>
+
+#include <stack>
+#include "../../../../../contrib/packages/libSVM/svm.h"
+
+#define OVP_ClassId_Algorithm_ClassifierSVM										CIdentifier(0x50486EC2, 0x6F2417FC)
+#define OVP_ClassId_Algorithm_ClassifierSVM_DecisionAvailable					CIdentifier(0x21A61E69, 0xD522CE01)
+#define OVP_ClassId_Algorithm_ClassifierSVMDesc									CIdentifier(0x272B056E, 0x0C6502AC)
+
+#define OVP_Algorithm_ClassifierSVM_InputParameterId_SVMType					CIdentifier(0x0C347BBA, 0x180577F9)
+#define OVP_Algorithm_ClassifierSVM_InputParameterId_SVMKernelType				CIdentifier(0x1952129C, 0x6BEF38D7)
+#define OVP_Algorithm_ClassifierSVM_InputParameterId_SVMDegree					CIdentifier(0x0E284608, 0x7323390E)
+#define OVP_Algorithm_ClassifierSVM_InputParameterId_SVMGamma					CIdentifier(0x5D4A358F, 0x29043846)
+#define OVP_Algorithm_ClassifierSVM_InputParameterId_SVMCoef0					CIdentifier(0x724D5EC5, 0x13E56658)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCost					CIdentifier(0x353662E8, 0x041D7610)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMNu						CIdentifier(0x62334FC3, 0x49594D32)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMEpsilon					CIdentifier(0x09896FD2, 0x523775BA)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCacheSize				CIdentifier(0x4BCE65A7, 0x6A103468)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMTolerance				CIdentifier(0x2658168C, 0x0914687C)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMShrinking				CIdentifier(0x63F5286A, 0x6A9D18BF)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMProbabilityEstimate		CIdentifier(0x05DC16EA, 0x5DBD51C2)
+#define OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMweight					CIdentifier(0x0BA132BE, 0x17DD3B8F)
+#define OVP_Algorithm_ClassifierSVM_InputParameterId_SVMWeightLabel				CIdentifier(0x22C27048, 0x5CC6214A)
+
+#define OVP_TypeId_SVMType														CIdentifier(0x2AF426D1, 0x72FB7BAC)
+#define OVP_TypeId_SVMKernelType												CIdentifier(0x54BB0016, 0x6AA27496)
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+int SVMClassificationCompare(CMatrix& first, CMatrix& second);
+
+
+class CAlgorithmClassifierSVM final : public Toolkit::CAlgorithmClassifier
+{
+public:
+
+	CAlgorithmClassifierSVM() { }
+
+	bool initialize() override;
+	bool uninitialize() override;
+
+	bool train(const Toolkit::IFeatureVectorSet& dataset) override;
+	bool classify(const Toolkit::IFeatureVector& sample, double& classLabel, Toolkit::IVector& distance, Toolkit::IVector& probability) override;
+
+	XML::IXMLNode* saveConfig() override;
+	bool loadConfig(XML::IXMLNode* configNode) override;
+	static CString paramToString(svm_parameter* param);
+	CString modelToString() const;
+	CString problemToString(svm_problem* prob) const;
+
+	size_t getNProbabilities() override { return 1; }
+	size_t getNDistances() override { return 0; }
+
+	_IsDerivedFromClass_Final_(CAlgorithmClassifier, OVP_ClassId_Algorithm_ClassifierSVM)
+
+protected:
+
+	std::vector<double> m_class;
+	struct svm_parameter m_param;
+
+	//struct svm_parameter *m_param;	// set by parse_command_line
+	struct svm_problem m_prob;			// set by read_problem
+	struct svm_model* m_model = nullptr;
+
+	bool m_modelWasTrained = false;		// true if from svm_train(), false if loaded
+
+	int m_indexSV      = 0;
+	size_t m_nFeatures = 0;
+	CMemoryBuffer m_config;
+	//todo a modifier en fonction de svn_save_model
+	//vector m_coefficients;
+
+private:
+	void loadParamNodeConfiguration(XML::IXMLNode* paramNode);
+	void loadModelNodeConfiguration(XML::IXMLNode* modelNode);
+	void loadModelSVsNodeConfiguration(XML::IXMLNode* svsNodeParam);
+
+	void setParameter();
+
+	static void deleteModel(svm_model* model, bool freeSupportVectors);
+};
+
+class CAlgorithmClassifierSVMDesc : public Toolkit::CAlgorithmClassifierDesc
+{
+public:
+
+	void release() override { }
+
+	CString getName() const override { return CString("SVM classifier"); }
+	CString getAuthorName() const override { return CString("Laurent Bougrain / Baptiste Payan"); }
+	CString getAuthorCompanyName() const override { return CString("UHP_Nancy1/LORIA INRIA/LORIA"); }
+	CString getShortDescription() const override { return CString(""); }
+	CString getDetailedDescription() const override { return CString(""); }
+	CString getCategory() const override { return CString(""); }
+	CString getVersion() const override { return CString("1.0"); }
+
+	CIdentifier getCreatedClass() const override { return OVP_ClassId_Algorithm_ClassifierSVM; }
+	IPluginObject* create() override { return new CAlgorithmClassifierSVM; }
+
+	bool getAlgorithmPrototype(Kernel::IAlgorithmProto& prototype) const override
+	{
+		CAlgorithmClassifierDesc::getAlgorithmPrototype(prototype);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMType, "SVM type", Kernel::ParameterType_Enumeration,OVP_TypeId_SVMType);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMKernelType, "Kernel type", Kernel::ParameterType_Enumeration,
+									OVP_TypeId_SVMKernelType);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMDegree, "Degree", Kernel::ParameterType_Integer);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMGamma, "Gamma", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMCoef0, "Coef 0", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCost, "Cost", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMNu, "Nu", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMEpsilon, "Epsilon", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMCacheSize, "Cache size", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMTolerance, "Epsilon tolerance", Kernel::ParameterType_Float);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMShrinking, "Shrinking", Kernel::ParameterType_Boolean);
+		//prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMProbabilityEstimate,"Probability estimate",Kernel::ParameterType_Boolean);
+		prototype.addInputParameter(OVP_ALgorithm_ClassifierSVM_InputParameterId_SVMweight, "Weight", Kernel::ParameterType_String);
+		prototype.addInputParameter(OVP_Algorithm_ClassifierSVM_InputParameterId_SVMWeightLabel, "Weight Label", Kernel::ParameterType_String);
+		return true;
+	}
+
+	_IsDerivedFromClass_Final_(CAlgorithmClassifierDesc, OVP_ClassId_Algorithm_ClassifierSVMDesc)
+};
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/box-algorithms/ovpCBoxAlgorithmOutlierRemoval.cpp

@@ -0,0 +1,204 @@
+#include "ovpCBoxAlgorithmOutlierRemoval.h"
+
+#include <algorithm>
+#include <iterator>
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+
+
+static bool PairLess(const std::pair<double, uint32_t> a, const std::pair<double, uint32_t> b) { return a.first < b.first; }
+
+bool CBoxAlgorithmOutlierRemoval::initialize()
+{
+	m_stimDecoder.initialize(*this, 0);
+	m_sampleDecoder.initialize(*this, 1);
+
+	m_stimEncoder.initialize(*this, 0);
+	m_sampleEncoder.initialize(*this, 1);
+
+	// get the quantile parameters
+	m_lowerQuantile = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 0);
+	m_upperQuantile = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 1);
+	m_trigger       = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 2);
+
+	m_lowerQuantile = std::min<double>(std::max<double>(m_lowerQuantile, 0.0), 1.0);
+	m_upperQuantile = std::min<double>(std::max<double>(m_upperQuantile, 0.0), 1.0);
+
+	m_triggerTime = -1LL;
+
+	return true;
+}
+
+bool CBoxAlgorithmOutlierRemoval::uninitialize()
+{
+	m_sampleEncoder.uninitialize();
+	m_stimEncoder.uninitialize();
+
+	m_sampleDecoder.uninitialize();
+	m_stimDecoder.uninitialize();
+
+	for (auto& data : m_datasets)
+	{
+		delete data.sampleMatrix;
+		data.sampleMatrix = nullptr;
+	}
+	m_datasets.clear();
+
+	return true;
+}
+
+bool CBoxAlgorithmOutlierRemoval::processInput(const size_t /*index*/)
+{
+	getBoxAlgorithmContext()->markAlgorithmAsReadyToProcess();
+	return true;
+}
+
+
+bool CBoxAlgorithmOutlierRemoval::pruneSet(std::vector<feature_vector_t>& pruned)
+{
+	if (m_datasets.empty()) { return true; }
+
+	const size_t nSample   = m_datasets.size(),
+				 nFeatures = m_datasets[0].sampleMatrix->getDimensionSize(0),
+				 lowerIdx  = size_t(m_lowerQuantile * nSample),
+				 upperIdx  = size_t(m_upperQuantile * nSample);
+
+	this->getLogManager() << Kernel::LogLevel_Trace << "Examined dataset is [" << nSample << "x" << nFeatures << "].\n";
+
+	std::vector<size_t> keptIdxs;
+	keptIdxs.resize(nSample);
+	for (size_t i = 0; i < nSample; ++i) { keptIdxs[i] = i; }
+
+	std::vector<std::pair<double, size_t>> featureValues;
+	featureValues.resize(nSample);
+
+	for (size_t f = 0; f < nFeatures; ++f)
+	{
+		for (size_t i = 0; i < nSample; ++i) { featureValues[i] = std::pair<double, uint32_t>(m_datasets[i].sampleMatrix->getBuffer()[f], i); }
+
+		std::sort(featureValues.begin(), featureValues.end(), PairLess);
+
+		std::vector<size_t> newIdxs;
+		newIdxs.resize(upperIdx - lowerIdx);
+		for (size_t j = lowerIdx, cnt = 0; j < upperIdx; j++, cnt++) { newIdxs[cnt] = featureValues[j].second; }
+
+		this->getLogManager() << Kernel::LogLevel_Trace << "For feature " << (f + 1) << ", the retained range is [" << featureValues[lowerIdx].first
+				<< ", " << featureValues[upperIdx - 1].first << "]\n";
+
+		std::sort(newIdxs.begin(), newIdxs.end());
+
+		std::vector<size_t> intersections;
+		std::set_intersection(newIdxs.begin(), newIdxs.end(), keptIdxs.begin(), keptIdxs.end(), std::back_inserter(intersections));
+
+		keptIdxs = intersections;
+
+		this->getLogManager() << Kernel::LogLevel_Debug << "After analyzing feat " << f << ", kept " << keptIdxs.size() << " examples.\n";
+	}
+
+	this->getLogManager() << Kernel::LogLevel_Trace << "Kept " << keptIdxs.size() << " examples in total ("
+			<< (100.0 * keptIdxs.size() / double(m_datasets.size())) << "% of " << m_datasets.size() << ")\n";
+
+	pruned.clear();
+	for (size_t idx : keptIdxs) { pruned.push_back(m_datasets[idx]); }
+
+	return true;
+}
+
+bool CBoxAlgorithmOutlierRemoval::process()
+{
+	Kernel::IBoxIO& boxContext = this->getDynamicBoxContext();
+
+	// Stimulations
+	for (uint32_t i = 0; i < boxContext.getInputChunkCount(0); ++i)
+	{
+		m_stimDecoder.decode(i);
+		if (m_stimDecoder.isHeaderReceived())
+		{
+			m_stimEncoder.encodeHeader();
+			boxContext.markOutputAsReadyToSend(0, boxContext.getInputChunkStartTime(0, i), boxContext.getInputChunkEndTime(0, i));
+		}
+		if (m_stimDecoder.isBufferReceived())
+		{
+			const IStimulationSet* stimSet = m_stimDecoder.getOutputStimulationSet();
+			for (uint32_t s = 0; s < stimSet->getStimulationCount(); ++s)
+			{
+				if (stimSet->getStimulationIdentifier(s) == m_trigger)
+				{
+					std::vector<feature_vector_t> pruned;
+					if (!pruneSet(pruned)) { return false; }
+
+					// encode
+					for (auto& feature : pruned)
+					{
+						m_sampleEncoder.getInputMatrix()->copy(*feature.sampleMatrix);
+						m_sampleEncoder.encodeBuffer();
+						boxContext.markOutputAsReadyToSend(1, feature.startTime, feature.endTime);
+					}
+
+					const uint64_t halfSecondHack = CTime(0.5).time();
+					m_triggerTime                 = stimSet->getStimulationDate(s) + halfSecondHack;
+				}
+			}
+
+			m_stimEncoder.getInputStimulationSet()->clear();
+
+			if (m_triggerTime >= boxContext.getInputChunkStartTime(0, i) && m_triggerTime < boxContext.getInputChunkEndTime(0, i))
+			{
+				m_stimEncoder.getInputStimulationSet()->appendStimulation(m_trigger, m_triggerTime, 0);
+				m_triggerTime = -1LL;
+			}
+
+			m_stimEncoder.encodeBuffer();
+
+			boxContext.markOutputAsReadyToSend(0, boxContext.getInputChunkStartTime(0, i), boxContext.getInputChunkEndTime(0, i));
+		}
+		if (m_stimDecoder.isEndReceived())
+		{
+			m_stimEncoder.encodeEnd();
+
+			boxContext.markOutputAsReadyToSend(0, boxContext.getInputChunkStartTime(0, i), boxContext.getInputChunkEndTime(0, i));
+		}
+	}
+
+	// Feature vectors
+
+	for (uint32_t i = 0; i < boxContext.getInputChunkCount(1); ++i)
+	{
+		m_sampleDecoder.decode(i);
+		if (m_sampleDecoder.isHeaderReceived())
+		{
+			m_sampleEncoder.getInputMatrix()->copyDescription(*m_sampleDecoder.getOutputMatrix());
+			m_sampleEncoder.encodeHeader();
+
+			boxContext.markOutputAsReadyToSend(1, boxContext.getInputChunkStartTime(1, i), boxContext.getInputChunkEndTime(1, i));
+		}
+
+		// pad feature to set
+		if (m_sampleDecoder.isBufferReceived())
+		{
+			const CMatrix* pFeatureVectorMatrix = m_sampleDecoder.getOutputMatrix();
+
+			feature_vector_t tmp;
+			tmp.sampleMatrix = new CMatrix();
+			tmp.startTime    = boxContext.getInputChunkStartTime(1, i);
+			tmp.endTime      = boxContext.getInputChunkEndTime(1, i);
+
+			tmp.sampleMatrix->copy(*pFeatureVectorMatrix);
+			m_datasets.push_back(tmp);
+		}
+
+		if (m_sampleDecoder.isEndReceived())
+		{
+			m_sampleEncoder.encodeEnd();
+
+			boxContext.markOutputAsReadyToSend(1, boxContext.getInputChunkStartTime(1, i), boxContext.getInputChunkEndTime(1, i));
+		}
+	}
+
+	return true;
+}
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/box-algorithms/ovpCBoxAlgorithmOutlierRemoval.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <openvibe/ov_all.h>
+#include <toolkit/ovtk_all.h>
+
+#include <vector>
+#include <map>
+
+#define OVP_ClassId_BoxAlgorithm_OutlierRemovalDesc		OpenViBE::CIdentifier(0x11DA1C24, 0x4C7A74C0)
+#define OVP_ClassId_BoxAlgorithm_OutlierRemoval			OpenViBE::CIdentifier(0x09E41B92, 0x4291B612)
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+class CBoxAlgorithmOutlierRemoval final : public Toolkit::TBoxAlgorithm<IBoxAlgorithm>
+{
+public:
+
+	void release() override { delete this; }
+
+	bool initialize() override;
+	bool uninitialize() override;
+	bool processInput(const size_t index) override;
+	bool process() override;
+
+	_IsDerivedFromClass_Final_(Toolkit::TBoxAlgorithm<IBoxAlgorithm>, OVP_ClassId_BoxAlgorithm_OutlierRemoval)
+
+protected:
+
+	typedef struct
+	{
+		CMatrix* sampleMatrix;
+		uint64_t startTime;
+		uint64_t endTime;
+	} feature_vector_t;
+
+	bool pruneSet(std::vector<feature_vector_t>& pruned);
+
+	Toolkit::TFeatureVectorDecoder<CBoxAlgorithmOutlierRemoval> m_sampleDecoder;
+	Toolkit::TStimulationDecoder<CBoxAlgorithmOutlierRemoval> m_stimDecoder;
+
+	Toolkit::TFeatureVectorEncoder<CBoxAlgorithmOutlierRemoval> m_sampleEncoder;
+	Toolkit::TStimulationEncoder<CBoxAlgorithmOutlierRemoval> m_stimEncoder;
+
+	std::vector<feature_vector_t> m_datasets;
+
+	double m_lowerQuantile = 0;
+	double m_upperQuantile = 0;
+	uint64_t m_trigger     = 0;
+	uint64_t m_triggerTime = 0;
+};
+
+class CBoxAlgorithmOutlierRemovalDesc final : public IBoxAlgorithmDesc
+{
+public:
+
+	void release() override { }
+
+	CString getName() const override { return CString("Outlier removal"); }
+	CString getAuthorName() const override { return CString("Jussi T. Lindgren"); }
+	CString getAuthorCompanyName() const override { return CString("Inria"); }
+	CString getShortDescription() const override { return CString("Discards feature vectors with extremal values"); }
+	CString getDetailedDescription() const override { return CString("Simple outlier removal based on quantile estimation"); }
+	CString getCategory() const override { return CString("Classification"); }
+	CString getVersion() const override { return CString("1.0"); }
+
+	CIdentifier getCreatedClass() const override { return OVP_ClassId_BoxAlgorithm_OutlierRemoval; }
+	IPluginObject* create() override { return new CBoxAlgorithmOutlierRemoval; }
+	CString getStockItemName() const override { return "gtk-cut"; }
+
+	bool getBoxPrototype(Kernel::IBoxProto& prototype) const override
+	{
+		prototype.addInput("Input stimulations", OV_TypeId_Stimulations);
+		prototype.addInput("Input features", OV_TypeId_FeatureVector);
+
+		prototype.addOutput("Output stimulations", OV_TypeId_Stimulations);
+		prototype.addOutput("Output features", OV_TypeId_FeatureVector);
+
+		prototype.addSetting("Lower quantile", OV_TypeId_Float, "0.01");
+		prototype.addSetting("Upper quantile", OV_TypeId_Float, "0.99");
+		prototype.addSetting("Start trigger", OV_TypeId_Stimulation, "OVTK_StimulationId_Train");
+
+		return true;
+	}
+
+	_IsDerivedFromClass_Final_(IBoxAlgorithmDesc, OVP_ClassId_BoxAlgorithm_OutlierRemovalDesc)
+};
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/ovp_defines.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#define OVP_Classification_BoxTrainerFormatVersion					4
+#define OVP_Classification_BoxTrainerFormatVersionRequired			4
+
+#ifdef TARGET_HAS_ThirdPartyOpenViBEPluginsGlobalDefines
+#include "ovp_global_defines.h"
+#endif // TARGET_HAS_ThirdPartyOpenViBEPluginsGlobalDefines
+
+
+#define OVP_TypeId_ClassificationPairwiseStrategy					OpenViBE::CIdentifier(0x0DD51C74, 0x3C4E74C9)
+#define OVP_TypeId_OneVsOne_DecisionAlgorithms						OpenViBE::CIdentifier(0xDEC1510, 0xDEC1510)
+
+
+extern const char* const FORMAT_VERSION_ATTRIBUTE_NAME;
+extern const char* const IDENTIFIER_ATTRIBUTE_NAME;
+
+extern const char* const STRATEGY_NODE_NAME;
+extern const char* const ALGORITHM_NODE_NAME;
+extern const char* const STIMULATIONS_NODE_NAME;
+extern const char* const REJECTED_CLASS_NODE_NAME;
+extern const char* const CLASS_STIMULATION_NODE_NAME;
+
+extern const char* const CLASSIFICATION_BOX_ROOT;
+extern const char* const CLASSIFIER_ROOT;
+
+extern const char* const PAIRWISE_STRATEGY_ENUMERATION_NAME;
+
+extern const char* const MLP_EVALUATION_FUNCTION_NAME;
+extern const char* const MLP_TRANSFERT_FUNCTION_NAME;
+
+bool OVFloatEqual(double first, double second);

Masterarbeit/openvibe/extras-master/plugins/processing/classification/src/ovp_main.cpp

@@ -0,0 +1,75 @@
+#include <vector>
+
+#include "ovp_defines.h"
+#include "toolkit/algorithms/classification/ovtkCAlgorithmPairingStrategy.h" //For comparision mecanism
+
+#include "algorithms/ovpCAlgorithmClassifierSVM.h"
+
+#include "box-algorithms/ovpCBoxAlgorithmOutlierRemoval.h"
+
+#if defined TARGET_HAS_ThirdPartyEIGEN
+#include "algorithms/ovpCAlgorithmClassifierMLP.h"
+#endif // TARGET_HAS_ThirdPartyEIGEN
+
+#include<cmath>
+
+const char* const PAIRWISE_STRATEGY_ENUMERATION_NAME = "Pairwise Decision Strategy";
+
+namespace OpenViBE {
+namespace Plugins {
+namespace Classification {
+
+OVP_Declare_Begin()
+	// SVM related
+	context.getTypeManager().registerEnumerationEntry(OVTK_TypeId_ClassificationAlgorithm, "Support Vector Machine (SVM)",
+													  OVP_ClassId_Algorithm_ClassifierSVM.id());
+	Toolkit::registerClassificationComparisonFunction(OVP_ClassId_Algorithm_ClassifierSVM, SVMClassificationCompare);
+	OVP_Declare_New(CAlgorithmClassifierSVMDesc);
+
+	context.getTypeManager().registerEnumerationType(OVP_TypeId_SVMType, "SVM Type");
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_SVMType, "C-SVC", C_SVC);
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_SVMType, "Nu-SVC", NU_SVC);
+
+	context.getTypeManager().registerEnumerationType(OVP_TypeId_SVMKernelType, "SVM Kernel Type");
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_SVMKernelType, "Linear", LINEAR);
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_SVMKernelType, "Polinomial", POLY);
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_SVMKernelType, "Radial basis function", RBF);
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_SVMKernelType, "Sigmoid", SIGMOID);
+
+
+	context.getTypeManager().registerEnumerationType(OVP_TypeId_ClassificationPairwiseStrategy, PAIRWISE_STRATEGY_ENUMERATION_NAME);
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_ClassificationPairwiseStrategy, "Support Vector Machine (SVM)",
+													  OVP_ClassId_Algorithm_ClassifierSVM.id());
+
+	context.getTypeManager().registerEnumerationType(OVP_TypeId_OneVsOne_DecisionAlgorithms, "One vs One Decision Algorithms");
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_OneVsOne_DecisionAlgorithms, "SVM Kernel Type", OVP_TypeId_SVMType.id());
+
+#if defined TARGET_HAS_ThirdPartyEIGEN
+	//MLP section
+	OVP_Declare_New(CAlgorithmClassifierMLPDesc);
+	context.getTypeManager().registerEnumerationEntry(OVTK_TypeId_ClassificationAlgorithm, "Multi-layer Perceptron",
+													  OVP_ClassId_Algorithm_ClassifierMLP.id());
+	Toolkit::registerClassificationComparisonFunction(OVP_ClassId_Algorithm_ClassifierMLP, MLPClassificationCompare);
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_ClassificationPairwiseStrategy, "Multi-layer Perceptron",
+													  OVP_ClassId_Algorithm_ClassifierMLP.id());
+
+	context.getTypeManager().registerEnumerationEntry(OVP_TypeId_OneVsOne_DecisionAlgorithms, "Multi-layer Perceptron",
+													  OVP_ClassId_Algorithm_ClassifierMLP.id());
+
+#endif // TARGET_HAS_ThirdPartyEIGEN
+
+	// Register boxes
+	OVP_Declare_New(CBoxAlgorithmOutlierRemovalDesc);
+
+OVP_Declare_End()
+
+}  // namespace Classification
+}  // namespace Plugins
+}  // namespace OpenViBE
+
+
+bool OVFloatEqual(const double first, const double second)
+{
+	const double epsilon = 0.000001;
+	return epsilon > fabs(first - second);
+}

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/CMakeLists.txt

@@ -0,0 +1,27 @@
+PROJECT(test_accuracy)
+
+IF(WIN32)
+	ADD_DEFINITIONS(-DTARGET_OS_Windows)
+ENDIF(WIN32)
+IF(UNIX)
+	ADD_DEFINITIONS(-DTARGET_OS_Linux)
+ENDIF(UNIX)
+ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
+ADD_DEFINITIONS(-DTARGET_ARCHITECTURE_i386)
+	
+INCLUDE_DIRECTORIES(../src)
+ADD_EXECUTABLE(${PROJECT_NAME} test_accuracy.cpp)
+SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY FOLDER ${TESTS_FOLDER})	# Place project in folder unit-test (for some IDE)
+
+#INCLUDE("FindOpenViBE")
+
+# Unfortunately we need to install the tests as any application to find .dll/.so files
+# on both Windows and Linux.
+OV_INSTALL_LAUNCH_SCRIPT(SCRIPT_PREFIX "${PROJECT_NAME}" EXECUTABLE_NAME  "${PROJECT_NAME}")
+INSTALL(TARGETS ${PROJECT_NAME}
+	RUNTIME DESTINATION ${DIST_BINDIR}
+	LIBRARY DESTINATION ${DIST_LIBDIR}
+	ARCHIVE DESTINATION ${DIST_LIBDIR})
+
+#Install the signal file required for testing
+INSTALL(DIRECTORY ../../../../applications/demos/ssvep-demo/signals      DESTINATION ${DIST_DATADIR}/openvibe/scenarios/)

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/DartTestfile.txt

@@ -0,0 +1,66 @@
+#blabla
+
+# @FIXME there is a problem of using the global log, this will cause interference if any tests are run in parallel
+
+IF(WIN32)
+	SET(EXT cmd)
+	SET(OS_FLAGS "--no-pause")
+ELSE()
+	SET(EXT sh)
+	SET(OS_FLAGS "")
+ENDIF()
+
+# Misc classifier tests
+
+SET(TEST_SCENARIOS LDA-Native-Test LDA-OneVsOne-HT-Test LDA-OneVsOne-PKPD-Test LDA-OneVsOne-Voting-Test LDA-OneVsAll-Test sLDA-Native-Test sLDA-OneVsOne-HT-Test sLDA-OneVsOne-PKPD-Test sLDA-OneVsOne-Voting-Test sLDA-OneVsAll-Test SVM-Native-Test SVM-OneVsOne-Voting-Test SVM-OneVsOne-HT-Test SVM-OneVsOne-PKPD-Test SVM-OneVsAll-Test MLP-Native-Test MLP-OneVsOne-Voting-Test MLP-OneVsOne-HT-Test MLP-OneVsOne-PKPD-Test MLP-OneVsAll-Test)
+
+FOREACH(TEST_NAME ${TEST_SCENARIOS})
+
+	SET(SCENARIO_TO_TEST "${TEST_NAME}.xml")
+
+	ADD_TEST(clean_Classification_${TEST_NAME} "${CMAKE_COMMAND}" "-E" "remove" "-f" ${OV_LOGFILE} classifiers/multiclass.xml)
+	ADD_TEST(run_Classification_${TEST_NAME} "$ENV{OV_BINARY_PATH}/openvibe-designer.${EXT}" ${OS_FLAGS} "--invisible"  "--no-session-management" --define Plugin_Classification_RandomizeKFoldTestData true "--play-fast" ${SCENARIO_TO_TEST})
+	ADD_TEST(compare_Classification_${TEST_NAME} "$ENV{OV_BINARY_PATH}/test_accuracy.${EXT}" "${OS_FLAGS}" "${OV_LOGFILE}")
+	ADD_TEST(run_Classification_${TEST_NAME}_ProcessorBox "$ENV{OV_BINARY_PATH}/openvibe-designer.${EXT}" ${OS_FLAGS} "--invisible"  "--no-session-management" --define Plugin_Classification_RandomizeKFoldTestData true "--play-fast" "ProcessorBox-Test.xml")
+	
+	# It would be better to clean last, but we can't do this as it will delete the 
+	# output we wish to include, and we can't prevent clean from running if a prev. test fails
+	# We need the clean to be sure that the comparator stage is not getting data from a previous run.
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME} PROPERTIES DEPENDS clean_Classification_${TEST_NAME})
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME} PROPERTIES ATTACHED_FILES_ON_FAIL ${OV_LOGFILE})
+
+	SET_TESTS_PROPERTIES(compare_Classification_${TEST_NAME} PROPERTIES DEPENDS run_Classification_${TEST_NAME})
+	SET_TESTS_PROPERTIES(compare_Classification_${TEST_NAME} PROPERTIES ATTACHED_FILES_ON_FAIL ${OV_LOGFILE})
+	
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME}_ProcessorBox PROPERTIES DEPENDS run_Classification_${TEST_NAME})
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME}_ProcessorBox PROPERTIES ATTACHED_FILES_ON_FAIL ${OV_LOGFILE})
+
+ENDFOREACH(TEST_NAME)
+
+# Shrinkage LDA tests. These are in a different block as they use different data (and miss ProcessorBox part)
+
+SET(TEST_SCENARIOS shrinkage_lda shrinkage_lda_rot)
+SET(TEST_THRESHOLD 80)
+
+FOREACH(TEST_NAME ${TEST_SCENARIOS})
+
+	SET(SCENARIO_TO_TEST "shrinkageLDA/${TEST_NAME}.xml")
+
+	ADD_TEST(clean_Classification_${TEST_NAME} "${CMAKE_COMMAND}" "-E" "remove" "-f" ${OV_LOGFILE})
+	ADD_TEST(run_Classification_${TEST_NAME} "$ENV{OV_BINARY_PATH}/openvibe-designer.${EXT}" ${OS_FLAGS} "--invisible"  "--no-session-management" --define Plugin_Classification_RandomizeKFoldTestData true "--play-fast" ${SCENARIO_TO_TEST})
+	ADD_TEST(compare_Classification_${TEST_NAME} "$ENV{OV_BINARY_PATH}/test_accuracy.${EXT}" "${OS_FLAGS}" "${OV_LOGFILE}" "${TEST_THRESHOLD}")
+	
+	# It would be better to clean last, but we can't do this as it will delete the 
+	# output we wish to include, and we can't prevent clean from running if a prev. test fails
+	# We need the clean to be sure that the comparator stage is not getting data from a previous run.
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME} PROPERTIES DEPENDS clean_Classification_${TEST_NAME})
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME} PROPERTIES ATTACHED_FILES_ON_FAIL ${OV_LOGFILE})
+
+	SET_TESTS_PROPERTIES(compare_Classification_${TEST_NAME} PROPERTIES DEPENDS run_Classification_${TEST_NAME})
+	SET_TESTS_PROPERTIES(compare_Classification_${TEST_NAME} PROPERTIES ATTACHED_FILES_ON_FAIL ${OV_LOGFILE})
+	
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME}_ProcessorBox PROPERTIES DEPENDS run_Classification_${TEST_NAME})
+	SET_TESTS_PROPERTIES(run_Classification_${TEST_NAME}_ProcessorBox PROPERTIES ATTACHED_FILES_ON_FAIL ${OV_LOGFILE})
+	
+ENDFOREACH(TEST_NAME)
+	

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/classifiers/csp-1.cfg

@@ -0,0 +1,5 @@
+<OpenViBE-SettingsOverride>
+	<SettingValue>3.710409e-01 6.657479e-01 -1.042486e-01 7.402487e-02 -4.998371e-01 -3.910547e-01 -4.640642e-01 3.905098e-01 -3.351870e-01 -1.548908e-01 6.889251e-01 -1.455582e-01 </SettingValue>
+	<SettingValue>2</SettingValue>
+	<SettingValue>6</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/classifiers/csp-2.cfg

@@ -0,0 +1,5 @@
+<OpenViBE-SettingsOverride>
+	<SettingValue>3.650117e-01 2.806841e-01 4.808358e-01 1.014923e-02 -7.237455e-01 -1.812988e-01 -3.742728e-01 5.225129e-01 -2.793061e-01 3.121540e-01 5.283969e-01 -3.636546e-01 </SettingValue>
+	<SettingValue>2</SettingValue>
+	<SettingValue>6</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/classifiers/csp-3.cfg

@@ -0,0 +1,5 @@
+<OpenViBE-SettingsOverride>
+	<SettingValue>-5.343845e-01 1.369963e-02 3.678158e-01 -6.578927e-01 3.275904e-01 1.970249e-01 4.196543e-01 -5.389358e-01 3.383975e-01 5.559860e-02 -5.922296e-01 2.551440e-01 </SettingValue>
+	<SettingValue>2</SettingValue>
+	<SettingValue>6</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/configuration/stimulation-based-epoching.cfg

@@ -0,0 +1,5 @@
+<OpenViBE-SettingsOverride>
+	<SettingValue>7</SettingValue>
+	<SettingValue>1</SettingValue>
+	<SettingValue>OVTK_StimulationId_Target</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/configuration/temporal-filter-freq-1.cfg

@@ -0,0 +1,8 @@
+<OpenViBE-SettingsOverride>
+<SettingValue>Butterworth</SettingValue>
+<SettingValue>Band pass</SettingValue>
+<SettingValue>4</SettingValue>
+<SettingValue>19.75</SettingValue>
+<SettingValue>20.25</SettingValue>
+<SettingValue>0.500000</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/configuration/temporal-filter-freq-2.cfg

@@ -0,0 +1,8 @@
+<OpenViBE-SettingsOverride>
+<SettingValue>Butterworth</SettingValue>
+<SettingValue>Band pass</SettingValue>
+<SettingValue>4</SettingValue>
+<SettingValue>14.75</SettingValue>
+<SettingValue>15.25</SettingValue>
+<SettingValue>0.500000</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/configuration/temporal-filter-freq-3.cfg

@@ -0,0 +1,8 @@
+<OpenViBE-SettingsOverride>
+<SettingValue>Butterworth</SettingValue>
+<SettingValue>Band pass</SettingValue>
+<SettingValue>4</SettingValue>
+<SettingValue>11.75</SettingValue>
+<SettingValue>12.25</SettingValue>
+<SettingValue>0.500000</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/configuration/time-based-epoching.cfg

@@ -0,0 +1,4 @@
+<OpenViBE-SettingsOverride>
+<SettingValue>0.5</SettingValue>
+<SettingValue>0.1</SettingValue>
+</OpenViBE-SettingsOverride>

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/scripts/classifier-training-target-separator.lua

@@ -0,0 +1,62 @@
+
+targets = {}
+non_targets = {}
+sent_stimulation = 0
+
+function initialize(box)
+	dofile(box:get_config("${Path_Data}") .. "/plugins/stimulation/lua-stimulator-stim-codes.lua")
+	
+	-- read the parameters of the box
+	
+	s_targets = box:get_setting(2)
+
+	for t in s_targets:gmatch("%d+") do
+		targets[t + 0] = true
+	end
+
+	s_non_targets = box:get_setting(3)
+
+	for t in s_non_targets:gmatch("%d+") do
+		non_targets[t + 0] = true
+	end
+
+	sent_stimulation = _G[box:get_setting(4)]
+
+end
+
+function uninitialize(box)
+end
+
+function process(box)
+
+	finished = false
+
+	while box:keep_processing() and not finished do
+
+		time = box:get_current_time()
+
+		while box:get_stimulation_count(1) > 0 do
+
+			s_code, s_date, s_duration = box:get_stimulation(1, 1)
+			box:remove_stimulation(1, 1)
+			
+			if s_code >= OVTK_StimulationId_Label_00 and s_code <= OVTK_StimulationId_Label_1F then
+
+				received_stimulation = s_code - OVTK_StimulationId_Label_00
+
+				if targets[received_stimulation] ~= nil then
+					box:send_stimulation(1, sent_stimulation, time)
+				elseif non_targets[received_stimulation] ~= nil then
+					box:send_stimulation(2, sent_stimulation, time)
+				end
+
+			elseif s_code == OVTK_StimulationId_ExperimentStop then
+				finished = true
+			end
+		end
+
+		box:sleep()
+
+	end
+
+end

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/README.txt

@@ -0,0 +1,9 @@
+
+Some (toy) materials to test the shrinkage LDA.
+
+The data were created by createData.R
+
+Running the example scenarios in Designer should illustrate how the shrinkage LDA behaves better in a situations where there's too few training examples for accurate covariance estimation.
+
+Todo: proper automatic tests, e.g. verify that accuracy in some real-data scenario stays above a threshold.
+

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/class1.csv

@@ -0,0 +1,30 @@
+Time:1x50,End Time,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,Event Id,Event Date,Event Duration
+0.1,0.2,-1.77233830755434,-0.236827251592077,1.46919909228546,1.77215815513424,-0.506267686281275,-1.51953712478023,1.21926844675747,-0.591336201883905,0.810793892940092,-0.0478351524521654,-1.07795341398774,1.04901825661264,0.290957678674044,1.13979936881618,0.173211780905492,-0.784805991192958,0.687022984726741,1.27668771671656,-0.477600037966964,1.07180555201423,0.662293452335553,0.72269911407146,-1.02250250717064,-0.528905944325278,3.59972319160266,-0.698655925414516,-0.870816336958357,-1.86830514291458,0.102628294986787,0.730214877977463,1.58392297876495,-0.184792411750226,-0.521677930225734,0.632881884596409,-0.758686850714144,-0.282183317841164,2.01338729793665,0.259570955722691,0.236797786923556,0.0063118555176279,0.341959434312799,0.830818003713969,-0.21410802873012,0.0890005001856433,1.09341162189432,0.346395457608115,-0.139910909240344,-1.67861512918353,-0.43165719962675,1.79020262175456,,,
+0.2,0.3,-1.84606867265548,0.391990239663702,0.264997941836784,-1.34722509967576,-1.44756131640788,-1.47073158350782,-0.172875064506289,-0.508381528023055,0.667066261460272,-0.486728966589707,1.35935857182339,0.294102062812508,1.26240447360024,-0.706411886980103,-1.98153732109541,-0.666274660672812,-0.324676533580154,-1.34944985149662,0.642290035316992,-0.0658277874749391,-0.668311724925967,0.377983358583464,-0.0650165799849114,-0.808947051287604,0.378791095274704,-0.438853903495148,0.128720306499055,-0.676193785278865,-0.859260575094699,-0.448409101403276,1.10791246770839,-0.370116295343959,0.962442327287394,1.78727943629502,-0.585974434161261,1.37340523472128,0.478725873282862,-0.285222490010332,-0.344132711407871,-1.39615102264855,-0.041689311831386,0.747850847366967,1.9166268887971,-1.0226763945532,-0.192783789854472,-0.531362953553267,1.05865794858109,-0.505532040344319,0.0629551176360539,-1.15992871917437,,,
+0.3,0.4,-2.49332533548487,1.64409749416937,0.285645369721553,-1.14532555306981,-0.367842010009751,0.889564732867821,0.902042445399143,-0.479509583638291,-0.403361444997069,1.02694383797405,-0.848993411267516,-0.975248366803951,-0.268861969752326,1.02713379098879,-1.45754459594992,1.74028420775379,0.98372459913046,0.692933224611794,0.321110966455445,-0.0436112465411973,0.526018910770931,-0.241847911053705,-0.595516014524317,-0.331585203599734,-0.760752181009177,0.206508150525299,-0.394642384347293,0.407995613700545,1.44231841313081,1.49540198041276,0.0215532601393211,-0.775072535037915,1.16103481714688,1.64769834294968,-0.287162546801277,-0.818966182436235,0.70835625526849,-0.669831237747049,-0.434648073958831,-1.01585838221087,-0.395541781732566,0.289189332438686,1.3341684522212,0.0134047395380486,0.773604766122364,0.701127516516158,0.841741052522346,-1.83128613295486,-0.0246511108994746,0.294720307354779,,,
+0.4,0.5,-2.52499988807365,0.527501220434984,0.97156939662727,-0.637213490174128,-0.354994075323081,-0.745014144258316,-1.21842947507402,-0.331920661880045,-1.19124415803104,0.975903495573172,-0.249597671810458,-0.00939059557927655,0.844201228502543,1.30277300274817,-1.87865915519727,1.25389747263313,-1.5652198477258,1.04897773099458,0.902064536138848,-1.94163561677897,-1.25107351174543,1.1575206731627,0.547764946794999,0.191380498627734,-0.503248172544535,0.855745482972341,0.442492152610449,1.88240828455809,-1.01801218822784,-0.570930259426521,-0.80063210672233,0.105326611459969,-0.352559624804854,0.123826916309908,0.656982714082648,-1.83943913691478,-0.230713358494733,0.619725768853545,-2.23195126444731,-0.0342518400322894,2.16643862640049,-0.790097359634875,0.73936477715902,0.979025947077225,1.02883817581993,0.191311766158682,3.5125755903309,-0.172830577468843,1.13638386199638,0.449415434248763,,,
+0.5,0.6,-2.4371996996854,-0.199762163143325,-1.66412064115944,1.32209383657703,1.78564808467757,-2.4841632180253,-0.0413739866403881,-1.84399075960103,-1.0630168927679,0.747782305764574,-0.59877556126373,1.00517471083475,-0.95820773957635,0.879504473737644,0.446123315813148,-1.96198514565717,-0.0108819510492637,-0.487353380475919,-0.207961619182551,0.0131011081827504,0.828421906272808,-1.20032945601014,0.225538212304263,1.28470060387135,-0.290121102088802,0.412876421212137,-0.763403474395873,0.0401559259511038,-0.314976740657898,0.124394805554818,-1.33184767770709,1.76659175055496,0.213153581937775,-0.124365036113027,0.337072558576539,2.55224327581814,-0.0241814435233937,-0.139778764718498,1.35388309283917,0.487634179934281,-0.709676528019773,-0.681813968533813,-2.29986097092805,-1.46971925217763,-0.725585249890308,0.329178548531522,-0.44558196076003,1.77560311952576,0.49967867998446,-0.530980731671024,,,
+0.6,0.7,-1.93849912979167,0.861397778707997,-1.2452326372904,-0.0607259633500062,0.935059706269999,-0.157345974529202,1.36919107938006,-0.259620642461268,0.801260702566358,-1.0722632775712,-0.631842607777485,0.405810093906153,-0.328198810307636,-0.812771037789669,-0.792895889997469,-0.0679581527852328,0.771611375578924,1.35400923122275,2.89965611507454,-1.73827174484685,0.00346343909790884,0.796031396687008,1.87566288659025,1.01633163119628,2.29403948090692,0.629757373786624,0.792443385689405,0.895193616699357,-0.673182057230165,-0.26435621334367,-1.06300665789059,-0.292767792806413,1.33312025105921,-0.872720812321334,0.819544696704868,1.28201785161169,0.393992181070491,-0.77442908477424,-2.44049053359049,0.858494129344435,-0.25023526774339,-0.0618877341108,-0.988740291550961,-0.0739872230807312,-0.552534738897729,-1.62200295119109,-0.0880826904503559,-0.664695381005107,0.355978324679464,0.927432000495081,,,
+0.7,0.8,-3.34684672140526,-1.26497793354093,-1.16666704428218,-0.780385840997041,0.0470739145971587,-0.605642340825465,0.945587408381604,-1.18126075190584,2.20328717668555,-0.531089179504808,0.201762811766242,-0.584209829626112,0.989899029221811,-0.212533541879578,1.44148304883411,0.00429125290958928,-0.21688568091344,0.909911885569311,-0.533485924810609,-0.220018565796853,-1.33429944720633,1.93287125392024,0.981381645673963,-0.466938397358383,0.170148127053635,-0.27938724823399,-0.778711059848325,-0.32886669555033,-1.06135570930341,1.13476644789916,0.733578755479842,-0.542526637610404,-0.224990428177821,-0.267924453922976,-1.08670312862221,-0.119159342356234,-0.142084166616695,-0.814458646531745,-0.235567135467998,-1.2732800223355,0.285530058673434,-0.483299969473905,0.855165375924984,-0.602204571777015,0.583407634150875,-0.411289622327927,-0.12665450861076,-2.03830175110953,-0.112053964894063,-0.827535602476982,,,
+0.8,0.9,-3.55989888905074,-0.634059705872217,-0.558120631489627,-0.0418754010266019,1.28680024265942,1.21221922245683,-0.611048728676769,0.957834760817381,-0.844482328959705,0.766673075055981,-0.030934714413184,0.0362884816349346,0.983046328277927,-1.11364782712676,-0.510890038959101,-0.791997369952067,0.0593454735299368,1.06352039878449,0.140439522991638,-1.59429902500644,0.434101232678913,1.38726371611854,1.23211248454009,-1.90705039732404,-1.61529765128843,-1.67728770168705,-0.173536259867967,1.1394470025958,-0.94668039917753,-0.159478059315696,1.18481106763709,0.509593145230726,0.223848028545494,-0.888110063272082,2.18764575481975,1.96946486165186,2.09662648828097,1.7941254408658,1.19925480288416,-0.618560083251035,0.212357198789346,0.0641730637906699,0.292256698626024,-0.370664045570373,0.135009399239684,-2.27491997321184,0.143495396810159,0.262601199604499,0.201438823482189,-0.35520204591383,,,
+0.9,1.0,-4.44774030679586,-1.11275749388428,0.507366692631453,0.468550525914631,0.843409924450063,0.414280505855425,0.367914640879673,-0.0577851382478128,-1.22726870960233,-1.09819710691446,-0.464505901680104,1.84871519571589,0.265276441889633,-1.31158079172016,0.712224135204576,0.100510353152504,-0.643517623763363,-0.951878314639593,0.350363706301863,-0.976652062169023,0.475285596160765,-0.79133848742369,-0.0150662484609962,-0.801567753668075,1.40360526910113,-0.585922680523054,-0.354246667522073,1.05968312635924,-0.478696160094725,-1.18762712568568,0.13032251587019,-1.31338117331829,-1.37683533578805,-0.415242723427493,0.287002767287016,0.519446561615298,0.507784977222456,-1.21775283862233,0.596969584534787,-1.09103745197065,-0.188026141054213,-0.539574607790159,-0.0267049724022197,0.985234967105008,-0.0121637953667821,-0.289343790077273,0.327801788546679,0.699013959334725,1.0507772042841,1.06381547894067,,,
+1.0,1.1,-3.09909090168284,-0.359659659892329,-0.12749543385773,0.0622887876624331,-0.860619457274199,0.432094735622488,-0.609981669720907,0.0639099707864614,0.71775040542059,-2.24915557008654,-0.165856156539402,-0.950303021513061,0.0656750471171471,0.758981750209037,0.948229456853139,0.122742557170879,-1.30170649111395,-0.117717471446721,2.31892773448122,0.496869451937333,0.0631715517104231,-1.04088228315997,0.348651895145636,0.277377856805705,-0.527340753898461,-0.96188662382932,-0.736239266993153,-1.63835364530386,-0.0719209782666559,0.970770321960414,0.274203363515058,-0.284515346876542,-1.24310305588837,-0.815182204543421,1.29841206516442,2.25762754300289,-1.33797487751071,-2.39232726554899,0.0602891581081039,-0.632722864132576,-0.381380674267328,1.08467301597097,0.343659227147748,0.896896049042744,-1.46506091422012,-0.41763537978796,0.191286527582262,-0.468464363834216,-1.09892741923733,-0.391740225452495,,,
+1.1,1.2,-3.23802049326389,1.74596554721976,-0.499540280575761,-0.843266359194183,0.573232774026051,-0.713900576181787,-1.01901854468152,0.145538742231609,1.36825506560525,0.249028977435512,-2.46295229308899,1.66652457591327,-0.198615690717076,-0.263385204486557,-1.10521035548769,-0.734121299064804,-0.0229783754545948,0.0506840308453182,0.0113112445149267,-0.232951781013076,0.8133440309898,0.788243285045267,-0.356270965183636,1.292547804447,0.0646992755668471,-1.18031609339379,-0.980296876246065,0.256282517705126,0.803914801562479,-0.751495033745804,0.981149907729045,-0.218071038366991,0.665941831057366,-1.29621525136853,-1.1315337185554,0.67324249885459,0.331420850707798,0.853789310822153,-0.387209285971316,-0.0617473807402586,-1.93892715623836,-1.79489758161487,-0.47320101114311,-0.96654353623563,-1.2562143127768,-0.0014335058494865,-0.670128660468449,1.98605312333715,0.155033281607601,0.44551846807408,,,
+1.2,1.3,-0.971273433953891,-0.868345934416637,0.525360395096701,-0.232597422322256,-1.49601379893642,-2.52908668132291,0.291107229457754,0.216753524716416,-0.961402923979911,0.232884908650992,1.33497405956156,0.185974162869079,1.0819664783459,-0.683211977341269,-0.0934249609722174,-1.94210519332242,0.876783253159539,-1.27882840637407,2.03294200453347,0.286838582976075,1.42283712316724,-0.323100316805324,0.201814501530754,-0.898363784626655,-0.522562418589968,1.41867825157879,-0.974730135201073,-1.11760089937304,0.824620917859167,-0.423862364857514,-0.619400480877842,-0.529399534279475,0.991986600554311,0.583331428519991,-0.211006241723627,0.821435708131965,0.138342791590999,-0.403542777463114,1.06464765714606,-0.789060097014565,-0.102395197252538,-0.552297480477896,0.259669506929517,1.00031484962009,1.25326497422323,-0.741706107221702,0.716317949428723,0.638207825629194,1.28595639165337,0.0879702349290783,,,
+1.3,1.4,-2.86248692076582,0.347890538416066,-1.27278549801312,-0.291262617102902,2.36838805394921,0.464807495400011,1.08687090634751,1.7832729004785,0.727591185856305,1.00011602975499,-0.197069897467726,-1.59253654229969,-1.64298561684632,1.49831743106751,-0.597772192484045,0.534515335680498,0.0147234393366317,0.205012890150111,-0.559613169455437,-1.27252520194646,-0.105259587819075,0.49919375150749,-0.0593172762281228,-1.2613346568111,-0.706536925074285,0.589008747567681,-1.82492862669336,1.02376845413314,-1.23239646747825,0.543736988061945,-1.00654350266696,-2.77981804434358,0.152840164690063,-0.569119801165209,-1.4765816373035,-0.836364979594367,0.947475048136282,-0.124377979840782,-0.56598077703248,0.640581016214566,1.05668713246614,1.17188350874907,-0.455197255050525,-1.08127895925572,-1.39520562119579,1.71350013442997,0.169194774895656,-1.74996304423433,-0.559784363697703,-2.41031769108155,,,
+1.4,1.5,-1.61101017216006,-0.933884563317575,1.77639273280316,-1.22203590775144,0.173117535987142,0.130395618992478,-0.229938731031663,-0.828432541105236,-0.65746443653727,-0.296129659235114,0.162498175403568,1.29392008320793,1.29282600686564,-0.896980042419235,0.507126153194601,0.203043147539653,0.0262655034896133,-0.726980024285828,-0.471118173096727,0.578424279342402,-0.494577652134584,0.585113326390058,0.266905931745185,1.06619468640444,-0.226461756216445,0.153805224449896,0.884667797835743,-0.73145034358127,0.883383448678899,-0.245424268895577,1.21322261487307,-0.612067222292678,1.13627205183641,0.663131024262672,-0.189002307247342,1.53096473041284,-0.240151295433385,1.63123088303574,0.823185628496508,0.563026841296833,1.7121295131197,1.74225139594617,0.273741789403298,-1.21564752302175,-0.394465389843137,0.27139832154876,0.0079851620072709,0.673908463250784,0.581259050717442,0.239130338326016,,,
+1.5,1.6,-1.47427082496119,0.880755954362544,0.742140486863105,-0.679923565750302,2.23474813364379,0.0831968758265776,0.921053927597004,-0.336904428023005,0.231647401537525,2.24282268035046,-0.201960134649665,1.05175879662423,0.934015462626019,-0.277109705767538,-0.92559175175182,-0.688993962906492,1.34672176799686,0.101930814133559,-0.875125700863262,-1.1427133721363,-0.0724775204102265,0.265296514759947,-0.112800263354246,0.34020759264344,-1.73072177388175,1.63516677283923,0.432011635283091,2.96879223508065,-0.230962539625279,0.318801361467567,-0.442616565484198,0.418444835558832,-0.657491006481548,-0.745899492310761,0.336188254349959,0.15854548301566,0.326894288956611,-0.251516391189098,-0.313611323506182,0.508390499905596,-0.352375131081077,-0.166613664863456,-0.435997664997284,-0.963397485442238,-0.395454331546453,-2.35273763662371,0.107904851761832,-0.760076049292479,0.516168120330722,1.2123522342855,,,
+1.6,1.7,-2.09878977951197,0.639592539001515,0.160859420829667,-0.68061632337174,-1.73228975812342,0.664737146144949,-0.644974944394484,-0.811542394703354,-1.37945183248634,1.75860825213751,0.916485573328238,0.81897185806978,-0.693589826320362,0.681099395272082,-0.289784693839316,2.14907331402146,2.84667680062198,-0.714098980306512,1.64022490599201,-0.274462053774466,-0.172631276449679,-2.62301402007093,-0.665881807160798,0.610794240026294,-0.766810027481317,-1.19704396547744,-0.964983796291884,-0.192824843413811,0.098091768309394,1.00785659850046,0.463936909180991,-1.17757024503215,0.0443283083305587,1.28602855352551,-0.377532722965945,0.247163046230049,-0.383194459654412,0.404788347682512,-2.13005637167212,-2.18846271817293,2.02469036169784,0.338833981163382,-0.193979627063926,-0.142272817736529,-0.0790912393453113,0.710852443746004,2.08857309582745,-2.55286755746463,-0.421403230578765,0.467182390084249,,,
+1.7,1.8,1.00925391275254,1.37474656008589,-0.0090970278399998,-0.346412275426031,0.960628573252543,1.07715536792327,-2.00475436597727,-1.56685475297392,0.527744554627656,0.350121171283212,-1.20761742136517,-0.640978005425133,0.976684464214235,0.136880206616241,0.419116030133855,-1.23663547845226,0.494175779354801,-1.60180256913862,1.00282279389971,-1.09222642056937,-0.676949249802419,-0.856909319000302,0.584890561606453,0.320699369767227,0.420736666081711,0.145759861726765,-0.696584372073265,2.59648777138279,0.80272534126436,0.91425151103223,1.75310992646248,0.0157181701985221,1.14176165460167,0.057867979669775,0.907452340987986,0.541366292230641,-1.20531301851502,0.523890687372466,-0.690749190269591,0.86128754855452,0.937471982293557,-0.76863066919468,0.390041647440194,0.377747647050882,-0.0925261167039724,-1.45200143918822,0.0588267317099769,1.00687365185681,1.30765171155742,-0.669801305308203,,,
+1.8,1.9,-1.449594453978,1.17139932899863,0.0750821226143516,0.402334066842221,-0.434053740121578,1.46229623677783,-0.40822810695267,-0.200212655188883,-1.41941880026543,-0.0947556282723024,0.878117342976929,-1.67925230891458,0.964932430177351,0.105044968428406,-0.163666571018362,0.315634284221749,0.595423854338757,-0.558239445944123,0.748599974931374,-0.143875921205212,-0.298259487797806,1.61886661049491,1.69376135816157,-0.081411744009167,-0.589388792134599,0.326106176383826,-1.84071182220167,-0.544133226268706,-1.00339762061913,-1.77315717289631,-2.09299090118694,-0.0907615334930632,0.105712304395261,-2.43334806412051,2.08155204494469,0.486160023717119,0.822201198399303,-0.718711825930808,0.688447292167804,1.16279100339109,-1.48346426111682,-0.483079916972782,0.900034333224391,-0.458946285539368,-0.570485909385145,0.064255910039447,-0.746295416149551,1.40704506258393,-0.0337277371081988,-0.376358937143787,,,
+1.9,2.0,-1.85125066455972,0.66028943384553,0.0139229187456611,0.0104477116502975,-0.717761311325679,-0.077370000264326,0.141068435366493,-1.14732631185047,0.547388940976638,-1.69487405911705,0.875876393720465,0.65637835416811,-1.16189641270829,-1.45244309288448,-1.07714046115485,-1.8495144551776,-1.27563561931607,-1.7835008631496,2.26131600509309,-0.215594069788061,0.660982537636236,0.507831783381489,0.0756562183288402,0.0303060196596953,-0.251522354647413,1.9035082759663,0.679440511558685,-0.120825055617998,1.57153193878004,-0.674754137724121,-0.685970198592187,0.48160460978278,-0.675817358494143,-0.757187469307967,1.64516172371811,0.0328976045088034,-1.85362372620806,0.157436894672794,0.50208354031508,0.241095341962767,-0.118239094477677,1.18842861973302,-0.126251241771557,-1.38899127317018,0.408141933895154,-0.404688150439642,-1.0048437133398,0.748231276199803,0.837737301889623,-0.560698942261964,,,
+2.0,2.1,-1.60601535923233,0.669143816704662,0.143810896251667,-0.815482700549905,1.45004996217576,1.48594020039215,-0.0267442432670983,0.549738822168395,0.136195893534055,1.76053186383306,-0.250904539200862,0.414756564478482,-0.437014625251531,-1.21508289877814,0.729413806183881,0.646634130867828,2.12882757172237,-1.20727255876545,-0.290014674271168,0.625562846141297,-0.142092235155255,1.13604222523948,-0.472366514145488,-0.536686593371494,-0.765157580097147,-0.354361814801958,0.392700341865491,-1.13375277944537,-0.57922946388263,-1.17090850044028,-0.403554130111788,1.98681181743454,1.83226342549388,0.330101205662862,0.918958964478383,-0.230415239782638,-1.05825458415651,0.440372530007424,-1.81209642037741,0.621457180575732,-0.522960148313009,-0.473494045615778,-0.150850398309924,-1.87121101604963,-0.194111875340998,-1.08040209110534,-1.99421926943775,-1.06970982913185,0.38256984977095,-0.499435538752386,,,
+2.1,2.2,-1.37691918932328,-1.88854092758226,-1.01045232254161,-2.46073542709708,2.96314659086332,-1.40812220494217,0.700873530768047,-0.569588091543524,0.910217643518832,-0.00505673948620012,-0.860408038052145,0.0699061321527326,-1.0887764238652,0.89234390981033,-1.844415455218,-0.0949612097519673,0.429075075031871,-0.0861284502880812,0.718162675940565,-1.65893736229242,-0.0504488664062409,-0.293958967283765,0.729135489869696,0.121905982046074,-1.11866670633372,0.719576754670144,0.131709051338085,-0.515902505202922,-0.0788055596524318,0.89294545648814,-1.41054922202298,-0.397909765898704,0.985505790375688,-1.22365632525866,-2.50174502444724,0.557537529414053,0.638935746143102,1.39907915785192,0.766138588211053,-1.39238254210462,-1.08607601020725,0.779388358390366,-2.17603247266285,-0.480889968851674,-2.38613179112004,-1.83628807369454,-0.961519057282883,1.68374338449346,2.1145273233512,-0.597602227196933,,,
+2.2,2.3,-0.38485346976322,1.71441742542603,0.862630467549317,-0.38033261179794,-0.489618746025318,0.0591983154344916,-0.596753298343392,0.72371617762678,0.307130803493028,0.229723466533615,1.36217923270807,-0.0976142284614124,-0.516148530800558,0.180752605358601,-0.826935513982694,0.364143346070747,2.55486560475664,0.453046914065365,0.701704298729262,-0.235450982734894,-1.0940257936463,-0.500459110672278,0.728549142164805,1.55433138279028,0.432181919838667,0.225275871831435,-0.560135650986184,-0.231570867766364,-0.885142044952308,-0.558604971294484,-1.82459833477448,0.152679415051044,-0.125541765002843,-1.44085634510553,0.87827690281758,1.03732438955034,-1.05131048011142,-0.273626319864078,0.398383142429682,1.24853761129889,-0.23406343149014,0.730678604180361,0.225644042490417,1.15011530488428,0.306140418894449,-0.764800139388062,-0.924377070043919,-0.906311349980566,0.154097326038458,2.04525910094737,,,
+2.3,2.4,-1.28953743425881,0.593602699110775,2.28235083814812,1.89089006844817,1.41913375564524,-0.0376542089295913,0.959291492150015,0.800192364266494,-0.495746741284409,-0.98359094713131,0.199432824975916,-0.697445523136789,-0.0798953477697274,-0.612534884940749,0.443031050594771,-0.845466308111129,0.304773223207354,1.20220052501968,-1.41724461142755,-0.535825571756851,-0.139249120602771,0.743431046015611,0.291707162253733,0.407436706748691,-2.45042392696164,0.66568793227417,1.98724448888319,-0.242180462441927,-1.29080554014862,-1.7644259703506,-0.226250118490315,-0.286473135967021,0.87066607626009,-0.0454371001278132,-0.717027434930964,-2.35620436046941,-1.28761888215381,1.43827166511107,0.854679947898158,0.242906490252199,-0.252577293411509,-1.2014577983329,0.342176439541731,0.581907722507583,-0.309393537463487,0.247393152243891,-2.28076596723148,-2.33534043885578,-0.211655718745541,1.54353757434573,,,
+2.4,2.5,-0.653467900262419,-0.4963479578044,1.34873552106367,0.140149504864691,0.497634043092993,0.982318308333538,-0.826889515884245,0.617397236813882,-0.910038168697828,-0.107244212651211,-0.119806078457305,0.598141199247828,0.147492056696988,-0.276606629015641,0.535388471247822,-2.06786965619509,0.925946856266965,1.40859693946566,-0.806256213703648,0.697914132932985,1.98377488724377,1.3529800010859,0.851109881666436,-0.187952626360489,-0.823303448246129,0.570003128501322,-0.272345848190497,-0.218644079368752,0.296511558256157,0.945466889273468,-1.41315823448521,0.787752559162959,0.0868721808757943,0.25469902919241,0.850835715705959,0.692932459340385,1.32808310265405,2.16679915504799,0.820491555238031,0.354603164292584,0.917115025480176,1.25492386535447,-0.40484396218625,0.441931463949241,-1.25163888923188,-1.02571105855879,1.2985824606236,-1.06012379597561,0.505781873560172,1.31644108760808,,,
+2.5,2.6,-1.54163213914593,0.485718053589599,-1.52127302211832,-0.186093807125215,1.2385646382438,1.68353722385926,-1.34629358758577,2.39226430970994,-1.46624078818285,-1.38239862125204,0.838861770549575,-0.778476350568663,0.594631532225217,0.940078976781259,-0.502948166867935,-1.07483152075934,0.224941156270868,0.787674340996857,-1.879681953764,-0.0952589756004587,1.64347220367494,-1.29972845714763,-0.675189839885044,1.71339294384532,-1.6327536941499,-0.639897645620297,1.75141899880403,0.587444804993354,1.39107000629944,0.146981604351645,0.625188076694792,0.212038108387411,0.792899026779549,-0.698394053222702,1.74301239955783,0.692738384625026,-0.216369491109795,0.489231855098492,-0.573088134753217,-0.233511723120165,-1.50575411603236,0.130816691092331,0.538649062428657,-2.06428227766601,-0.513328244956785,-0.652124424972041,0.725442646365652,-2.19521189057892,0.767383981948306,0.518928362028896,,,
+2.6,2.7,-0.404164810533275,0.102274692088978,-1.08449618505089,2.09120909855889,-1.11917775235596,1.45097833771738,0.472911649999107,-0.828369240740054,0.785002577610665,0.414678613589617,0.199880405625152,-0.459821332878392,-0.909044084453528,-0.20578644825676,-0.341583188023587,0.782588866071394,-1.00847019061368,-0.691400981543019,-0.936096623208734,1.76530172830329,-0.501773287936934,-0.59919079156968,-0.065960895964635,0.956384308331524,0.671657382647727,1.68458953985207,0.0578286678859909,1.51891459959947,-0.544925308287521,-0.997252253975146,-0.89037363257251,1.36046314798829,-1.2793402221833,0.968538961419931,0.339608576710708,0.521992311995813,-0.257562532745493,-1.53988194336016,0.0644864952819011,-1.05527339556824,-0.565676268382917,1.20003602131403,-1.89571329172304,-1.98168191343,-0.593378676096049,1.27445879451447,0.862152277941382,0.0328038178449537,-1.43096570122999,-1.36017771437072,,,
+2.7,2.8,-3.56797705751825,1.09881194979225,-1.16831493597144,0.520983425027833,1.66749976766568,-0.0712834678280598,-0.638360247864907,-1.08051765792604,0.410719825157519,0.557510193799553,-0.511652979040744,0.995594990713032,0.816075238131488,0.88144246148645,-1.01680198833235,0.346174298538861,1.96905166966619,-0.735663903508833,2.32584847448696,-0.645145416990287,-0.84755524555166,-0.0284009610648053,1.21701891050411,1.88489226576535,-0.921828385172571,0.885798458807903,2.63083698314068,0.302745787563594,-1.42894475273606,-1.15584495989824,-0.100107869379229,-0.575279817044032,-0.314382673734126,-0.846617862679996,1.53277218248083,-0.66636411626898,-1.33864745977004,-0.72607207779172,-1.2987258124462,0.991971138905104,0.234719066783197,-1.42403749517274,-0.280562003087986,-0.240745897998986,-0.201106126547365,-0.0904003897201168,0.826545621980961,-1.2922743016258,-0.837884142081378,0.64380255904924,,,
+2.8,2.9,-0.988262968181082,0.418037719544605,1.04568410951798,-0.318713751270629,0.0188084459047177,0.96559234262152,0.334954418508725,-0.898917032840481,-0.638666684250415,0.180112703828211,2.00537827140566,1.390614788546,-0.943091895589548,0.933749406472778,0.448753970569277,1.34981987477594,0.951964997738819,-2.3005656213913,2.46873873656557,-0.70411151718615,-1.17081741958248,-1.30309836890683,0.497336105348077,2.19835328570869,0.276001894721499,1.190950526532,-0.763423017036248,-1.2560434290105,1.79284551512437,-0.312315924182818,-0.740192502628443,-0.847316266032773,-0.582484908106787,-0.319241508047501,-0.181283696126251,0.850896972462388,2.38909196491941,0.409117949690621,-0.881198976461458,-0.90303180161685,-0.334475351110278,0.586634767430369,-0.874811521187844,0.621486109769527,0.584669008122476,-0.744766894881111,-0.864900302918206,1.34009908917876,-1.02186219137494,0.392832361133756,,,
+2.9,3.0,-1.61005461936525,-1.1498200138669,0.121323143019759,-1.55103143054491,-1.00079445648052,1.67717800323898,0.262355004435243,0.475624933029085,-0.0267365775761464,1.64952299721817,0.965516586287597,-1.18419488848939,2.25378360734499,-0.922028013165381,-0.64637684456314,-0.990505334606425,-0.124163448381048,-1.69486189330993,0.271925005428862,1.22873770978493,0.305907426366617,0.875467367403968,0.588791614961203,0.427098588933039,-1.15696099332683,-0.346455014574285,-0.830310509840663,0.754478112837592,1.07622127929693,-0.52791318770056,1.36584478582221,0.0698614444643175,0.107833627896301,0.187859731925132,1.3713634192136,-2.16969187615497,-0.0230684927188355,0.524184182040186,0.860954882028488,-0.683571728503834,0.712840566573534,0.314542576183367,0.644421820807391,-1.15144187414628,-1.68359919846919,0.304745480696108,1.15615485096293,-1.24076669807937,-0.451694284250098,-0.785002603819057,,,

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/class1rot.csv

@@ -0,0 +1,30 @@
+Time:1x50,End Time,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,Event Id,Event Date,Event Duration
+0.1,0.2,-2.8105715330572,1.97044458445776,-2.25117345900302,-2.77675325596564,-4.22282858289576,-0.728730107287751,-0.131732851290365,3.23812046801923,1.87194312096294,0.0509042820995466,-2.90935563390039,3.43795625693612,-1.32743202763949,3.8467147199148,-1.82018863917555,-1.36195423261369,0.593938250540402,-2.54952409351015,-0.175868239114684,0.50401883279692,-0.716112709508492,-4.10682380182668,0.0882455175640278,1.570217526566,1.6746016187139,2.13928318875744,0.132878113953894,4.41237860071733,2.3168155047397,-2.21781976501155,-2.44112900600351,-0.104452294200763,-0.773750302848905,1.65799007451332,-4.54910403234098,-3.18987869603497,-0.643838919963144,6.03278566607531,3.81082112670311,1.52019407424606,-1.66503431554912,-4.67716077003471,-0.307195357516731,-2.79758638051557,1.35403525166371,1.41842144044514,1.59365203345603,-3.91180899655509,2.61716637984177,2.7363702888213,,,
+0.2,0.3,2.25856479866076,-3.49853226072837,-0.204747634265671,-3.123651935946,1.32269874452053,-0.045246441431997,0.826989491779179,3.57231405076905,0.157685681320851,-0.785867067767291,3.98778104233212,0.47721614309732,-0.273763205878514,0.824947712507762,-0.727107039939137,0.509710542052856,0.432551955289065,1.53328644287134,-2.2172295385466,-1.14765359725631,0.185969502641448,-2.39861199956817,1.38897527789934,2.06245070219219,1.80779257171327,-1.93473494853549,-1.98187339671248,-4.30650653667619,2.45822371424924,-1.3921074151963,0.0372807168892847,0.246795943961955,-1.29489560034757,-2.98251767778177,1.0344437952679,4.48603532474317,-1.72960192058539,0.461554531572219,0.721970839888233,-1.02068312273811,0.963181417175223,-3.79292757071271,0.761099359957011,-1.55491887600319,-0.452570408436559,-0.146906581768742,-1.93106207104724,-0.457600143698669,1.07622796765881,-0.554860828645116,,,
+0.3,0.4,3.98271705203809,-2.19811608631682,-2.1272346934832,-4.15505507189997,-1.06351972345606,0.156350653104381,3.10390611504748,3.4577709548516,1.36596164016536,-0.876084740407852,2.03353697983148,1.6203122010471,-2.20077388312022,1.81588733006304,-1.1236658015585,1.74698940603952,1.41380534324175,-1.03472179830907,-5.01422644462888,-2.34951517958835,3.66846562862928,-1.64138661588594,-0.389487814237493,-0.77351281712287,-2.13397549783302,-2.21313548827122,1.89385059590299,-2.62307428860125,2.33581002613165,-0.683017994176775,2.30054191521104,-0.993874634899022,-1.23055222002998,-4.84295369928031,1.50317829886755,0.797955787551626,-2.91779452963703,2.18382394900967,-0.211129040842678,-2.20480379998498,1.05807079707262,0.442964608661533,-0.894842081976626,-1.68766394511601,0.636103400816211,2.05854951816596,1.19045045798009,-2.11288470560948,-3.0233443960854,-2.23276966075083,,,
+0.4,0.5,-1.17123394261144,1.56266409361991,-5.75684621310878,-3.27311883849878,-1.49936701447769,1.67428766519967,-0.751928437348566,-1.59207698422662,-0.913676313905993,-5.80665618290006,-1.31335302117651,-6.08103845207449,0.883650223159432,-1.44746163612749,-0.984476573506612,1.90935067132634,0.547599462132903,-1.35089088234226,-1.18914071103552,-1.23626613899387,0.540308505900391,-1.5652666538784,3.10367078122746,1.27949840246372,-0.725315728611452,4.41371403560844,-0.0941457384539908,-5.60478407683596,0.266378731150281,1.8900311024272,-0.941983647969998,2.26301522311613,1.2668601814492,0.533375859527004,0.713642842458907,2.84239664303946,2.0904637170955,2.99967287920232,-0.061431830618343,-2.49172764650727,-0.44792560342362,-1.50500892753702,3.29497898594663,1.33328104708473,1.38389613749,-2.36872695837441,1.95739718108967,0.112831906968402,0.0875822236921859,-1.26059900856129,,,
+0.5,0.6,-0.691247835099285,0.35996239578975,3.72856536111607,1.3095821399835,-0.192335263199433,-1.74440017537381,-5.2325370637816,-4.5354085867458,-0.289846498200247,2.75928482075316,-3.81463586270434,0.238113238131077,-2.94192509811481,-1.14056121237894,2.4696485347111,-3.55346297492856,-2.77505338982254,0.377538094414719,2.04356990495184,-0.476353207374357,2.06180654461382,0.785941061962911,4.16103196784365,0.649447629480342,4.55573479309417,-0.70719113064945,-1.16211165037149,2.14789207417241,-4.26600318248493,-3.08023629234495,-1.72775893942949,1.0349789891197,2.25218453237596,0.568962494959985,0.204608890163155,-3.8260925894879,4.2583197972008,-2.03384851730742,-0.7835817765404,-0.947556618147915,-1.76778945090148,0.12159982825841,-2.75734737864209,3.17774885950749,2.41334219641258,-6.06417185221909,-1.8454115223381,1.65243260991619,1.13925836274113,3.11635886675106,,,
+0.6,0.7,-0.75469594624195,0.277343480909411,-3.1636484573233,0.269002296814459,1.23823363844859,0.0930367535985796,-3.9845686942331,0.99730312897028,0.174687065123597,-1.38723558312686,-3.15866226239419,-0.111147547774084,-0.646508789590673,3.26908929138036,-2.10374571303398,-0.129499535867985,0.00920667326941993,1.8441735131152,-1.16913550437466,1.48330673764097,2.54663374176198,2.57550509917293,2.49665653618342,-2.02027283311533,2.68460899674504,1.77754912007238,2.1977518373163,-0.756515811157936,-0.752451827155607,0.778742298490477,-5.00762792946691,0.236043923049721,4.27956735453061,-2.41057475241384,-0.768662997319675,-2.04401085234801,2.75855960423778,-0.340242190891457,1.82678981424863,2.20565473039744,-2.96994068191173,-3.62966732095131,-2.76300680262596,-0.815348420401293,0.996291282202418,-5.08422721374475,2.75835523156865,-2.59055871406729,1.54681587683948,-0.6755499067224,,,
+0.7,0.8,0.65651046080783,-0.426811813020632,-1.27303253891505,-3.00885024186743,-1.1946822047483,2.029884867178,-1.78260059201804,1.31070297837884,0.858616942720236,1.27851484579747,-0.088707743833295,-0.0913789344242943,1.15074849398106,2.79518758083919,-3.41755619582524,0.912217609339767,1.52089973412281,1.48236340692864,-1.98030834507565,-1.49778400009765,4.09357289038769,0.503035444580094,-1.08678696370095,-0.900368815495746,-0.66528273447498,-1.02244076034782,-0.684245024852757,1.35853819221209,1.28055291730888,0.17381734572867,-5.72824052807078,-1.51247653309703,2.51443335786332,-1.67631850267937,0.304470774157041,0.291468141091596,0.159318948794085,1.46952680188977,-0.430479543495719,-1.43442327098508,-2.53171639182582,-1.50103059883364,2.80143890875172,-1.23149564747545,-0.200945108374293,-1.47865850182882,3.40999800364323,-0.189847162108051,1.31516281465757,1.86243645208503,,,
+0.8,0.9,1.46460867610958,-1.49477111598966,-1.97071051223149,3.34503243843136,0.216045380474084,-1.38054836097643,-1.18926155021276,1.58280716598142,-3.2522551983989,-1.33570609580013,-0.199585777875705,1.30739319220861,1.22307437656635,1.28456382308241,-0.725947804108099,3.31571671019217,-1.22737032728076,-0.868881508621964,-1.2422592721294,-3.28637889860691,2.14064522726149,1.57975502572686,2.15190758666344,4.82350344346956,1.82477255827722,-2.57428674502732,1.61505914955868,0.312213335313871,-1.49465280461993,3.34818297213971,-4.75605714075815,-0.0404034610890573,4.0977040381511,-3.51520295138231,1.79291040966315,3.20783033440413,0.15782207398605,1.61426471927668,-2.24059831228095,-0.496650417379842,-3.0925896828248,-2.66799338104973,1.13571372821778,-0.950916872411329,-2.95087780744659,-2.17630449777817,0.70079437125197,0.534384220843388,3.35852849234982,-0.608448198074922,,,
+0.9,1.0,1.54648622091098,0.610416710732742,-0.655157807669775,-1.8563415221732,1.20697381422682,2.4480340290493,-0.907959644908824,0.129307677878469,-0.485060975837386,2.1272760657214,-0.206233760269315,-2.88013869657892,-3.59465500044503,3.63597265491814,2.55951651783495,2.52421128422679,-1.06147013867897,-0.116388265092203,-1.90813701607482,-2.67647157136635,1.58848760158363,-1.99741579574876,3.10060717795274,3.75032660151804,2.1853235444508,2.88227131411482,-1.77009490361947,0.955234614316146,-2.1212687388531,-0.144629256010725,-2.99577734771928,-0.941715199200326,4.86893875570262,-2.29249542879953,0.387089555877114,-0.152259516980132,-2.34828961030103,0.447723687352788,-1.47945473788336,-1.16806190686824,-3.10152625351283,1.35588786835852,-0.0672166407663362,1.14045322745097,0.949832763087217,0.134050690965881,1.13113588581846,3.26950687798222,1.46910013398604,2.88185352313814,,,
+1.0,1.1,0.412548674966722,-1.75352041257501,-1.21841087637463,-0.00210429161672981,2.29633195111569,2.20448449548543,0.580557159447253,0.678191658712035,0.730977484381622,0.685330294197169,1.27484902309455,0.353892132669408,-3.70642431577221,3.86252449424315,1.05600212010077,1.01293777656738,1.76203544350132,-0.628319406461999,1.02450800039242,-3.22326390613028,5.85097588704723,0.537030130000432,0.837903044217678,-1.39299644137185,-1.69305324354949,-0.221998000343763,-3.72463422965969,0.630340258140646,-3.44505148366852,-3.77203469072097,-5.58125415389162,-3.45229159846523,0.29308788400517,-2.86879803398118,4.50973229119948,-0.905414610529336,-3.43044863553659,-0.699749644515564,-4.29491049577396,-0.9266611339983,-0.443119083279365,-0.196604547740539,1.76413028876312,3.80476887958539,-2.34947666703353,-0.621479397013964,0.462227210772041,2.70108740966535,-0.724827507896309,2.39883673765848,,,
+1.1,1.2,1.7158474115172,-1.11407359505675,-0.867814052370603,-0.185779264871818,-4.48822812275538,-2.56596517645758,-5.63320279778413,-0.338065796354731,1.58715856491674,-0.919645420360434,1.83921061064595,0.341252980343316,-2.02140258523139,0.265722874969387,1.87576029732289,1.35709498003436,-0.474780548059455,0.0639095616887276,-2.14450483371912,-1.11734898176555,3.16152385534152,-2.20181856663677,0.244723112338881,2.37250829851378,-0.835498556833158,0.109746453938632,-2.69948485904786,2.52241582576951,-4.10300368587047,-1.7082843774407,-2.43644996269643,-2.53281845444085,1.92051391993592,-0.0765474035060689,1.60287818999326,-0.484901720024071,3.75083238626015,1.14727072767643,-0.0301685611034201,-1.66854303056552,-5.52581959182569,-3.03478842787926,-1.44016366655733,0.898863931163821,0.150936913411882,-2.84415766058223,1.41309641807674,-2.19249169987643,-0.62988660432605,4.5278577326279,,,
+1.2,1.3,2.83869893875188,-4.10907238130391,2.09574727390126,0.606857359697584,3.49239284220778,3.30456550602594,0.546672902910804,-1.44254872491866,1.24184645982262,1.44693360483477,0.599338208233538,1.57645377635247,-2.50143646969459,-0.243935769825188,-0.223406358455314,0.216377460237278,-2.03156658039766,1.66365679078492,-0.770769965581541,1.78289590722595,-2.30484790168524,-4.08385133217365,1.71014075191883,1.97464009882288,2.46124729571871,2.77208305150849,1.07295296288269,-2.04231410601069,2.62795861579049,-1.78239075603147,1.87633825065428,0.529538705968275,0.453620570662779,-2.40147617168371,-2.71752861171083,0.200625727951212,-2.17597746621015,0.516259286356495,1.19966048702541,1.57952390309727,-0.27102194928997,-0.931738839560132,-2.14619202807606,-0.707153693060139,1.84677933563161,0.760001180227281,-1.9830791581216,0.702052828271839,0.238177144117116,-0.622493459299261,,,
+1.3,1.4,0.555751358439945,-2.38202472767864,-2.5374263593009,-0.668202304854171,0.460100676574187,-0.468381646864945,-3.14175970014952,2.59508399671427,-2.1636104727435,3.2015653434026,0.996379591348406,1.29034980481803,-1.01449313948565,4.13101071641878,0.746477773437528,2.67476274247404,1.64519247767868,0.368970054327677,-4.07664230697739,-1.83764605017084,9.18832855645467,5.16014230624288,1.45248686878921,-0.776861944410294,1.32987372892995,0.439452988986878,1.02452951447159,5.22593777208589,-0.304641461822068,-0.986507095790607,0.0981512605340924,-1.35029669565622,0.0099829983298233,-1.47368672538286,4.25421420892833,1.05443042597449,-1.65613790933755,2.98531820395854,-1.61579611561761,-1.61584959582512,-3.05915206957465,0.171499849562224,3.18424620169122,1.67412084797257,0.493112633827945,-2.53382502823378,3.36003748293486,1.68616378568491,-4.62782463244664,-5.06452631747941,,,
+1.4,1.5,0.725609180412714,2.15340088045979,0.312438496055849,-2.79541909155967,0.266136430579753,-0.296658418348459,1.25094970669959,1.98841534699095,-0.20356849893254,-1.01301516249052,0.14658543837751,1.55728052430123,2.14359139714842,-0.924509335865053,2.57332163112923,0.841364857115575,1.74952560279345,-0.798187414539234,-1.58230032535238,1.12690198287515,-4.48092799955653,-1.56496320500463,1.04759575280675,3.93739240958469,2.48962138973262,-0.322621445521173,-1.11320984336191,-3.43070160902344,0.647523942010786,-3.43098882142036,-0.184620378606986,1.83250535956895,0.946799389445305,-1.22878351100888,-1.55605224522125,0.891889919197199,-1.60547887211236,1.11724886038631,-0.990609385659061,-1.6435084128692,0.536852399226953,1.11404523700155,0.987738670119397,0.759006399041441,-1.73816815681788,0.92951475199042,-0.105823241600692,0.274242055837412,1.22289414504949,-0.653786799794155,,,
+1.5,1.6,0.651725771835592,2.79369621485552,-1.37687441806266,-0.407487663410837,1.62489500501172,1.2203757596244,-1.84909310478014,-1.24107264872941,-0.880668115945116,-2.94584540053303,-0.0799874045010337,1.6562651670194,2.22229929432724,-0.0454283749717774,0.4360705392719,0.438710836310926,0.548796483100254,-0.209581665775903,-2.67667297251137,-1.68993432209153,0.449957629732672,-1.5715535560288,2.8493908122811,0.38551226507793,1.3392989543818,-3.4408083716611,2.25423993707932,-3.31090080586337,-2.47061164324379,2.22703096525324,-2.17637284653793,3.60066284954513,1.78645711931948,0.0592741235546194,-1.06488789593085,1.29491418427606,4.26288588784497,1.62340178464192,-2.67013193416794,2.7416015538228,-0.170232652373118,0.0338503654648348,1.23148477084599,-1.42045160925335,-1.64494945478888,-1.3710753937353,1.26227327101454,2.37569192804425,-0.241378082718342,-0.94141566584387,,,
+1.6,1.7,7.39921973166246,-0.695323549222931,-1.29022376196738,-2.46132709002258,2.60794080383602,4.16004576975047,2.61058144706203,-0.305688389239895,1.37970040402818,-1.93487009859452,5.51417622490348,2.00519019723876,-0.118353364826195,-0.0453841153231959,0.007609924278713,5.44662603392165,0.543699734132417,2.28939840621075,-2.07516963857466,-4.84259659482211,1.59314698493873,-3.44267186897438,3.28670840577811,2.72752969322703,1.20215577661964,1.28109449622157,-0.153558241469811,-2.25831181023467,-0.401765452800865,-2.40258042778156,-2.34908665568599,-0.0227078048695048,2.03449114924152,-4.32010175839527,3.96501438479819,2.54423985445574,-1.64189946684155,2.0845653373771,-5.50125722921213,-2.6875591289533,-0.163407238610649,-1.4322659342638,-1.81300446632046,0.766094802683155,-2.84656208836804,-2.8301943914545,0.81803966540716,1.63212174935272,0.642463660458146,-1.31059906341514,,,
+1.7,1.8,2.40588037434168,1.33039783843917,-0.676884441898234,3.9034250403503,0.026080009366245,-1.41498941047684,-1.52539331129802,-0.136692793413889,1.78515476396359,-0.272110467927108,-1.03913869112042,-3.95328513920296,3.54706744419001,-3.07232325418042,1.03550145860662,-1.30510608569039,0.0831224719320189,0.230952532086129,0.61680831948405,-0.468731010887522,-1.13055337796658,-1.73055994221095,-3.63352006608614,-0.663598602388298,-1.24460303435534,-1.51121672205882,-1.52637907376702,-1.02550969078375,-2.73998732974856,-3.02420915791703,-0.489561390404151,1.03685012920996,1.87847392838446,0.142937530346172,1.58136094353528,0.389288448399853,2.10611093909263,0.998352265479031,-1.1842648634099,-0.399779712744055,0.755589774348053,-3.18101225183453,-1.19040645637607,2.88257675019185,-2.24674176658863,-1.70109418681355,0.469551110969173,-1.86120280800877,0.200420492491152,-0.170969679382766,,,
+1.8,1.9,-3.20274463724113,0.773874222718237,1.64614599552711,0.721835333507736,3.93709924623571,-2.00023478310303,-1.95375661600176,-1.40683949305642,-1.49533716890984,1.33742901373974,1.68128149808239,-1.48225142349032,-2.82335564183784,0.33677294148062,-0.0705610715199127,-0.654777732293916,-0.588031998074302,1.40917242926869,0.192535954883576,-1.9426264972193,1.54892554113787,1.28606653159581,-1.36745206825355,-2.4752302749925,1.48071387511901,2.49142625711704,-1.24276734358494,2.09266549042474,-0.315042987645562,0.210091625977274,1.81097950695311,0.66454498571702,-0.342790813760022,-2.71740630384103,3.33146589076221,1.06768335060535,-2.86953251056654,-3.82573821243968,-1.90898599885506,0.423860982618232,1.68913491433077,2.43051491805584,2.79440401778651,3.22274031254474,-3.59971157971169,-0.886168034310385,-1.70783582660157,-0.495986090369399,-1.91792586186559,-2.94314750152996,,,
+1.9,2.0,-2.17482790458379,0.974048986992111,2.50720655506521,0.310344029426504,3.029771535603,2.32155605830909,0.48961003088954,-0.530501467196968,-2.08815679535763,-0.350817701462446,-3.31879706220302,-0.150101146644014,-1.36761020237915,0.329564642269529,0.151859484582866,-0.731743935703456,1.165150611636,-0.126659476331722,-1.58210143912405,2.40029974000982,-0.419009236387041,0.0205680067575303,1.57698784982093,-1.55636961438757,0.84089664128493,-0.293581864211237,-3.63053421071102,-4.04858738998121,-1.12185579908497,-0.407284882949091,1.02837701828957,0.743307386021124,-1.64124938614129,-2.08445761807348,-0.341657317246554,-1.5775959407046,-3.82624192764141,-3.40074062736046,-0.69097617117135,-1.5099611868015,3.11317230406707,0.944927613389534,-0.369232833938974,-0.267999119835704,-1.75306554143873,-1.34422869796015,-1.65184063468003,0.818604975237236,0.481712426628555,-0.39126962740233,,,
+2.0,2.1,1.28588026785764,0.242055191722788,1.83495626173443,-1.22584325351487,-1.86138484726045,-0.334380034388681,0.8602625790677,0.731133600188683,-1.81742354075479,-0.670131845522926,0.565289104407008,2.68240079386625,1.49619270042143,-0.499753614504373,-0.00593603689844963,0.873817777556575,1.1799683982929,0.0149184268034789,-2.74589133068304,0.0552461621863612,-0.364950444572966,1.02773865740661,0.248011258589835,4.58260468125937,-0.372391779435783,-2.46818518706614,-0.321481964868768,0.501854875773063,-0.637713909521712,1.88655870462753,-1.2345376271931,2.37026253643203,0.308162625012256,-1.50321242593588,3.10209565387954,0.84510820105889,-0.0227992859728542,-2.21521586711323,-2.45789968289505,1.13422839398902,-0.358324633085681,1.46115530424515,-1.45661915719781,1.06386101731876,-3.75119702585009,-2.77901860024965,2.57606428491255,-1.85322048316374,0.935566536866204,-4.16964723600851,,,
+2.1,2.2,-1.45595302791712,-3.57203754805573,-0.815506112758829,0.86142150987229,-0.988717272063613,-0.222193792429366,-3.246909231049,2.27503038255254,-0.800514907940624,0.549338669325995,-1.05066184625963,2.2746754238737,0.363543280947518,1.40414308206969,1.69945377853004,4.50774994874455,1.20223959405357,1.85909907336244,-3.24469307180972,0.855690588091828,4.21134125625123,3.07879848931523,5.32896722938934,1.21308307493136,3.30547180724902,-0.645243835491161,-1.25337919163304,0.656934943302804,-4.52429465197901,-3.91428393500123,-1.7765716293542,1.20932991970504,-0.916065734657072,0.387133798593019,0.300669078071486,-2.4194646539746,3.36804299408804,-2.70507039359375,-1.36113004172581,-2.6446624915564,-1.1197854645974,-1.15097220537407,-5.33015585932497,-1.29985921367422,0.911327331646307,-0.748876375591805,1.56240555543428,2.16907844970491,-0.879581760650955,-0.210638601845813,,,
+2.2,2.3,-0.695316721718133,2.50580067026623,0.342352306956665,2.33122928942166,1.60760484543937,1.02138008510811,0.730546441424613,-2.53420597397529,-1.32657870349675,-1.13265789579094,1.96618304860504,0.872422646185038,0.940954498758207,2.24378699479052,0.900437254658936,-1.85703510573607,1.63183714350095,1.62167299551082,-2.42860493973049,-0.143964202917475,-1.52340629061167,-0.776991798845568,1.59619942360886,-1.63246865731022,1.75258907821379,0.704937339267046,0.719425792854076,0.664391979753537,-3.55102105869637,1.26364997650117,-1.12794438600857,2.53082753575905,0.965734661711472,2.68712386519609,1.9077439192026,0.281828211637222,1.10630018764366,-0.8920498543118,-3.57624944910106,4.38946217311561,1.45722022222272,-0.059683808577177,-0.0477368750044317,0.549688270212891,-3.38423461405594,-2.05080706578523,1.46925421347341,0.454535362381171,0.318459970864058,-1.6960031613442,,,
+2.3,2.4,-1.48218346248402,3.46125195708384,-0.492540950627984,0.544057939822881,0.441588335565786,3.0614104944499,2.68628311500204,-0.0609205366504261,-1.34816730109857,0.586755785487694,-2.12285001733083,-1.29086600230877,2.19676698440496,1.73215488305539,-2.01960009109088,-0.147653140741244,3.32641159068301,-2.63336963803951,-4.06356464775544,3.96559046760408,-1.09689674487257,3.33222137623058,1.96872332977963,-2.7590273516545,3.91011613437886,0.86488570904271,2.96669860814855,1.69518563572462,-4.50462178108515,1.83214299806079,-2.58671989049746,0.926054162472394,0.290080416872772,0.432157453004865,1.77388988736588,-1.42785426872192,0.39562249550647,2.93836505217524,-0.212929193357425,3.45185149013537,-1.6509881585105,2.38247652421273,5.33752639489644,2.4995348870182,1.86459611915521,-0.278614333324306,-0.346787033955834,1.31568306109716,-1.81117567687268,-2.25646538895242,,,
+2.4,2.5,0.121196347609945,-0.108058453229338,-1.3666297709267,1.3892607096631,1.34190009763646,1.12502341813738,-0.296618515251649,0.27879411233236,-0.816439153232276,-1.96949993946581,-2.42747831788924,4.7028315044458,-1.46991728421293,-0.427530429842848,0.0334335738897268,0.690259265012689,-1.17855121711516,-1.80953763674345,2.66940357202808,0.248849540737759,-0.436439838991066,-0.164186270492,1.86888985765844,2.23653385611028,4.49797980722596,0.12562140059158,1.84491658206054,-0.800392272296285,-1.97833407142157,-0.549403080053561,-1.02855491676895,1.36142389318909,0.66518185389273,-0.592651963070647,0.516351315343134,-2.30678657498335,0.563760065966653,0.74199760084777,-0.384324496484074,3.58348600543669,-0.460634439449161,-0.476830571512249,2.4166886084528,-1.78011883548886,-2.39448292644583,-1.7111715521367,1.14180574890064,0.908482436809666,-2.01868172029746,-3.16647407435079,,,
+2.5,2.6,2.87546766905874,-1.30621499151423,-1.34661732751893,-1.36477619357409,-1.14264820521448,-2.76989640927341,1.75272335939491,-1.42290480691446,3.44702211675669,1.63575852594528,-0.219423869291532,2.95260236961516,-1.52950658409964,1.49781395101231,-0.236524245808489,-0.130862990057083,3.51966699095968,-0.760070063174663,-0.834352893691635,-2.4472013266978,3.01089708386508,3.07663634302213,0.752187570783965,2.13915330505701,1.66827897714483,-4.248919790756,3.49420800023391,-2.87734173773384,-1.94597630889998,3.14981680240701,0.329600611802459,-1.36025568469886,3.3539302366922,-1.83370150017945,4.12060945090974,2.03738381934561,-0.629698384798938,-0.874529807846123,-0.282191544097119,2.49092623890012,3.05137031056639,-1.86297566587833,2.23949538329493,1.61619728021969,-1.41911081102793,-2.81122776182811,-0.666640273773287,2.11188821571898,-1.72807196192256,0.534916148176379,,,
+2.6,2.7,-2.58291541319657,2.05575680453866,3.64848138591017,-3.73352121598204,2.2721524226842,-1.67855353426209,-2.13432596021327,-1.45831823264329,0.267296279878805,3.24220577672824,-0.876541076455338,-1.06872394889996,-2.54121051975109,-1.04476560014838,1.26399824950922,-4.32479028809923,-0.423320959939235,2.4181007249442,0.4129004490422,-2.85007271867082,2.52086714873968,2.66432472631436,2.54842559392743,-2.40185417451743,0.739285109692632,-2.56275345143781,-3.29173741829593,-1.22457811421248,0.0585742373572882,-1.1726843274996,2.19035019714661,2.08526827075641,-1.60798078443537,-0.584378392553168,0.697340757464979,-3.1631673300676,1.35766554627518,-4.40113543117786,-1.39745361783941,-3.28078913191396,0.382828683839479,4.45045035917699,1.09593532158843,0.399900943441046,2.35216869758084,-2.33962412450393,-2.92480688421603,1.60065194914302,0.93781145842988,0.753682873805719,,,
+2.7,2.8,0.932683340169992,1.47837502134545,-2.56389985042069,-0.440880535582118,0.475992112863668,2.21235932891905,-1.90444022064287,-3.21361622547755,0.482668890801513,-2.45602656825286,-0.505301555242597,-3.49049163558378,1.92799486795625,0.997938162955951,0.0599281719905099,-1.34507967471535,3.82189376781025,0.331007670209716,-2.15741572597535,-1.75784318568333,2.81608741183253,0.630516851311377,0.831992923949784,-0.188173170589422,2.26677323326173,2.27376676907206,-0.460479070446479,0.169525480609984,-4.21932639654056,0.751329606664413,-6.80415308223362,2.23935803109211,-0.018765074753383,-3.26038991970702,2.66257612320678,0.854879371150657,3.80768716172088,-0.569740539684696,-2.05031634316988,1.14116335233794,-0.0624477988921045,-1.66043953096112,2.11647821477234,6.31731006084865,0.282713522222256,-3.88822044598149,-1.06386227797414,-1.07341330181575,1.24947512857584,-2.01099874124951,,,
+2.8,2.9,-0.190764871534067,-0.832683595775219,4.48165218241009,-0.691791576828947,1.18005190384955,2.70038942918774,0.607385090498741,1.07954507259054,-3.16675865840481,0.243219872351482,3.31759476703298,2.98499171203703,-1.59474356678471,1.98261676185004,1.33239950083889,2.09045293925977,0.165482827752169,3.27115733639514,-1.75444622984331,-2.88058232695821,-1.8091418529978,-4.04848130509037,1.75778297768681,-1.5540361341628,0.283874786720228,3.14614180738661,-1.35698609171216,-0.232826073905957,-1.59728751176671,-4.13432866851944,2.69735945545562,2.10283068399961,1.56835473170226,-3.09600323401495,0.373272038971625,-0.368765506251781,-3.61270397621319,0.398525474873015,-3.1488522568666,-4.15482879074718,1.48371969785945,1.25791651679408,-3.31853535809201,1.88390872396579,-6.66250342209356,1.1141688428176,-1.98675173049563,0.0550567031742593,1.17527707100265,-0.408929415222566,,,
+2.9,3.0,2.07584718231275,1.22002900362819,-0.793861217166859,-4.33305743455819,1.80364355654205,1.2054011245442,0.617079862963498,0.702664451418367,2.46513448392998,0.373017728171608,2.36993975046339,2.32330921888993,1.44658011375259,-3.68352563077178,0.0455222200288473,2.00322824264919,1.84810694421118,0.608164656295271,-0.966256589288504,-2.80295614627345,0.826259418959985,1.2844076291427,-1.85315405559947,1.02958262198594,-0.82285382584283,-1.32888373681357,-3.03466250664774,-2.2169339817719,4.88651727184018,0.00293327338421558,-0.615234856142122,1.82602515752514,-0.986413208404311,-3.98866340832859,2.09078820555829,2.01987007944622,-4.36533631131179,-0.772240437726864,-2.73586097516928,-3.38593133263736,2.42187603572045,0.435091844412334,4.01268645130089,0.413454620799435,-3.23150779238356,-0.121342130699243,-2.67511289867455,0.146342750015175,-1.26366106590203,-3.25548100559938,,,

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/class2.csv

@@ -0,0 +1,30 @@
+Time:1x50,End Time,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,Event Id,Event Date,Event Duration
+0.1,0.2,2.41756423308863,-1.70401239595644,0.791729847451285,0.645613889707579,1.11917441900686,-0.177752798768,-0.502323231129607,2.27946077930473,-0.620097027979108,0.237200592861211,0.0614235140029632,-1.17348720105883,-0.357925117766627,-1.63796061515849,0.917322979592683,-0.37833171872684,-0.946119121861523,-0.0503651450477355,-0.409013192293217,-2.04614769290604,-0.399654044524648,-1.14109064360204,0.989314861039603,0.495639145844508,-1.13685436997172,-0.626825600799964,2.50922453214131,1.53860969964381,-0.725461590878397,-1.28921524286806,-1.25706071230653,-3.03884011510721,1.47410400452375,0.0819561326981504,-0.0726196267672344,-1.50559081777541,1.74664432671996,-0.794270918369097,0.047953240677887,1.73699254493474,-2.62826713575325,1.01534561048104,-0.803431439823553,-0.71471177906596,1.18060299534523,-0.794322346919578,0.786606149688323,2.21317519625281,0.285011727658921,-0.850868910204617,,,
+0.2,0.3,1.80188889404418,0.315552223608854,-0.262557343411401,1.50045825269355,1.09064026780364,-0.121730539970911,0.43812652908932,-0.523034229650523,-2.24084439581267,0.830347937150517,1.13562332595139,0.500494429219252,2.7482349340849,-2.04509150717098,0.747749245376466,0.909745017984892,-0.11757130812107,0.34959788740953,-1.23615166703237,-0.962361521724509,-0.316579482791706,-2.15681891438129,0.217396498323689,1.14963077925616,0.45710847937624,-0.8491784768972,-0.199441196263061,-0.463154271272553,-0.780671078974483,0.927772277443112,2.22085753515201,0.173035255914104,0.0466857464951015,-2.23192589786752,0.156802490410574,-1.24385666850783,0.994065197710682,-1.1310557055715,1.19025094222507,0.837362802103179,0.074635180422496,-1.9382936377041,-1.73623206073621,0.350917204209175,0.581364553631124,-2.11549024802639,0.075091310820531,-1.59987906951638,0.0804263264426524,-0.903175045614212,,,
+0.3,0.4,0.134053583211802,0.0736801397485045,1.35381433181395,0.222143313225455,-0.75615540652887,0.585896104848566,-1.25487765942792,0.0618414485259265,1.12136347313419,1.15103586902857,-2.47540474891527,-0.0267486987367018,2.38995759188258,1.22420774775832,0.350169519590248,0.614336199725246,0.164327360348982,0.706118648266181,0.017764527876496,-2.45963606734507,0.408266243351976,0.499192662808535,-0.154965880654383,0.407760603757424,-1.12462097112783,0.733355721866381,0.0825686379798897,-0.0172780002074716,-1.05483478155031,0.961605145031084,0.504011431147704,-0.23031362553634,0.715156030740589,0.491340264675297,0.870910633389063,-1.38576760545291,1.38532666311733,0.600341172100502,-0.569899583962448,-1.37604736692897,-0.576111195613606,0.486881201184612,-1.78599173287689,0.973587613719928,-2.79205436913732,0.824791999063363,2.69283120653806,0.0885622445383038,-0.55454569217847,0.0419115553038687,,,
+0.4,0.5,3.90115375281321,-0.576843586677304,-1.22322026530138,2.2393112250765,0.453301595875585,-0.947102724052319,-0.00634279476540103,1.02464991682588,-0.280551482291064,0.528251543160952,1.09696987922838,0.441769695436964,1.3606920172692,-0.143379233801836,-0.220345613536676,0.858622330768882,1.1254595004879,-1.40443570509893,-0.833433599180464,-0.386850253103523,-1.09025758540741,-0.0511331048601226,-1.700690045554,0.850097256319639,0.956316330592468,-1.10214629428405,0.656517748854216,-0.0273847042090798,0.680440019977418,-0.329551663768347,-1.69547266144089,-0.217295520359744,-0.361747049327876,-0.806967833979068,-0.144567005025595,0.515712914667356,1.23407811678742,0.00121636506162939,0.514447404322184,-0.640932521250631,-1.00452312124515,0.687568802825433,0.51765138915709,0.107761745506942,0.508235191756896,-0.210951431667897,-1.33803212964343,0.336138128677005,-0.52523247628906,0.508716885104579,,,
+0.5,0.6,2.26390217116451,-1.11463592272539,1.92580963388041,-0.459159911520928,0.885822481928998,0.278584038590067,-0.846951437744313,-0.506883849690481,0.883766555166351,0.950918475131371,-0.241239682802772,-0.41734585303162,0.221022811563535,0.271093819366761,0.493949741422186,0.00328354898697439,-1.39527802298993,0.164774504765728,1.2418703063445,0.519520494733933,-1.28749439877126,0.36102828532919,-0.566770014589174,-0.328233925354516,0.660468829346089,-0.0548298205374033,-0.447993806816061,-1.46872800617216,0.466328029312081,-1.00473991515938,1.45687239177829,1.08409591929311,-0.420261551755275,-1.29127008779562,1.30273374540705,-0.103175281479033,-0.600428434711648,-0.775686160702368,-0.967953544940887,0.465842846859284,2.06030085775973,-1.69420952713817,1.91444788712457,2.19963525743073,-0.447592829097785,0.125523618774679,-2.68795734330282,0.312151306862779,-0.129740420682068,1.01856191637845,,,
+0.6,0.7,1.28681920398356,-1.73554129729895,-0.197041094065271,1.23260541291538,0.25942640448246,-0.247257463789772,-0.429863925040663,-0.879770176316215,-1.59061156135753,1.57407287022937,0.950144580297151,-1.13013947143077,0.316832232415441,0.0350104505182429,-0.198904683103634,1.2080507210976,-0.633695774000356,1.17785905881309,2.99481707872686,0.348473904965908,0.887456350739495,-0.0280041788075179,-1.70696967612494,-0.215893371515469,-0.634744466860558,0.668115688647831,-0.0875239839984323,-0.390153017637281,1.7813682669371,1.26933780643966,0.179719027234534,0.576675269856259,0.162452560452856,1.97061540006131,0.709455669205445,1.71279592251747,0.757308119186768,-0.415474760353766,-0.0711510430153657,-0.909962183354922,1.3518334698559,0.176589282814468,-1.05789139292939,-1.60417030737624,2.24555069710889,0.3147718036389,0.511316053526405,-0.092583472608371,0.215447449060973,0.276938935894284,,,
+0.7,0.8,1.7143878588671,0.318553319550764,0.7105413822878,1.53929387721496,1.17219403804553,0.914321111147704,0.445074348035177,0.864040919966386,-1.30955461943129,-0.38192639010032,-1.63356859757793,-0.0578335431210713,-0.705976590644803,1.48879996667957,0.906412378740496,1.00635243733724,-0.860068560811214,0.25157523868098,-0.700285646636355,1.63742514597695,-1.44597174367909,-0.334068790556961,0.369935570208775,-2.06508288737651,1.34297495735268,0.509447063069645,0.170816044092557,0.226714523719044,0.745181779363815,-0.969225705128717,-0.177438715283015,0.822982782642091,1.0371944602826,0.577685327764532,1.70813554580091,2.39356091163575,-0.346884726302522,-1.42225821911172,0.500597355279659,0.524234693802535,0.729733076217236,0.47456515128138,-0.660405774073152,0.267060538646901,0.000426531833439704,0.715069562151028,-0.868863424039719,1.48823661679146,-2.31786866819867,-1.45294959225448,,,
+0.8,0.9,0.697057441008775,0.698790009807599,0.867820323427383,0.0811664846339576,-1.4472231601051,0.997767154622138,0.76618207296053,0.878651658684913,1.71080398924943,0.929524691395211,-1.44876807504741,0.839031972695844,-1.48805829633174,-0.50845406468288,-0.304523720289152,0.351577492189797,-0.791474627573446,-0.0731064149233324,0.0118503183356555,-0.94940960665759,0.222997198912361,-1.7254389034402,1.36115001780592,1.41274470145576,-2.00017992853741,-0.404570800129302,0.0410800836576833,0.794815690704137,0.93598122103314,-0.0391567604442919,-1.97149287295885,0.101864284607686,-0.550151672011335,-1.36443082486966,-0.225199678538552,-0.439947140031294,-0.435924408967588,-0.692718679506362,0.805440351782625,-0.169890876199317,1.38782563973323,2.92735443147801,0.524445171344603,1.66054859338096,0.402666015005784,0.424174309807325,-0.66521968800587,0.01738015871613,0.361867157614173,-1.37457037615209,,,
+0.9,1.0,3.52897644396081,0.422128745354343,1.25248286681702,-0.950703924432279,2.51811470021927,0.187631658327211,0.0294973585186574,1.69556178117789,0.405807897438738,-1.64177540546277,0.275407803221126,-0.11671417338093,0.0581305705766578,0.274108570345926,0.791124732212224,0.172462582908223,-1.14215257394054,0.423134416176203,1.32629897532172,-0.23939890190641,0.011552509015188,0.393634403403334,1.61597385031162,1.25862095079157,1.27679363991336,-0.261622116935512,-0.475755662418219,0.236200319452776,-0.31328170702761,1.02359375302955,-0.221950005364121,-1.34862373561157,0.110497607966458,1.5354393778831,2.10234202132854,0.344538220593261,1.60485808855624,-1.97233422609305,-0.766832367234666,0.480155254082462,-0.324478218471555,-0.376564743260814,1.8236538168715,0.0511160324888412,-0.844828893457091,-0.34538568446893,0.314551576353477,-1.10815772973927,-1.11731920702865,0.46420549167493,,,
+1.0,1.1,2.2349303919686,0.574218989497726,-1.27507776210747,-0.691893048210729,1.23889754707696,1.09136200313909,0.903178957417063,-0.0383450493306883,-1.87599757865119,0.507501274578597,-0.443368706120003,-0.378281077195736,0.490810167526783,-0.771969296893111,0.831225714056053,0.547306569799624,-1.34018685039238,-0.334519169731117,0.506179096791726,1.09903254737982,-1.64437042216723,-1.41065404332665,-0.551204541436527,-1.66049829709579,1.11959912640833,0.70196278086534,0.114890097276731,0.495064598951083,-0.849710879875456,-1.39290937328785,-2.20914476764139,-0.414585999149955,-0.0685079983959239,0.201207480854693,0.368934977351352,-0.560360686563783,1.22607205658501,0.41929577282257,0.393460393461204,-0.961312552821879,1.25172263455976,-0.81826950295172,-1.04633627939148,-0.746109258253462,0.352254610503885,-0.867627639226765,-2.6375353545019,1.46592226213751,1.01698508619519,0.107564981881061,,,
+1.1,1.2,1.90905608282086,0.16215602902349,-0.35655805663903,-0.523178514593638,0.964899194189744,1.6222753959523,0.219085663684405,1.15426264371121,-1.24502181738719,-0.866076969231395,0.505721545064514,0.715912175667961,-0.987807527481338,0.286521572827326,-0.652235567554811,1.54688229235656,1.52479834913992,0.261306722767349,-0.287643387358626,0.588966783068548,-1.01860474742667,-0.272490554703533,-2.54293342449673,0.663603748421948,-1.90793856071731,0.892296010475099,1.2677764947497,0.102244295534873,-0.192134963445369,1.68534811369718,1.17723504139249,-0.761940422354176,0.0761991779137232,2.16735803291766,0.4448566545144,1.03485896087065,0.227702285072451,-0.563369979998674,-2.04111698127948,-0.143561213814264,1.2523436946126,1.48262069225916,-0.496833366155436,-2.67088622136062,0.213467760508286,0.656874752811013,-0.163930500814305,0.503368907434312,-1.15649235180276,-0.326602268574231,,,
+1.2,1.3,1.82817174278505,-0.915740723481944,-1.03397774676955,-0.0393381784441342,-0.786463555009029,-0.491849260938815,1.11102671071298,0.628932722019228,0.200299617640272,1.28377449540738,-0.253027772897481,0.255562390948539,-1.28031501733204,-1.19585660531198,0.586857023188176,-0.400961177593881,-1.17244918888821,-1.0213245830234,-1.27155342814585,-0.792598648327314,-0.493647891138553,-1.06161347607627,0.179951616570891,-1.51078529195779,-0.760922980284442,0.394460954386319,-1.15724508546002,-0.293104407076505,0.434954857926243,1.15827516527076,-2.0390862403136,-0.866199826749087,0.342186941946617,-1.35222657540178,-0.337872950381222,0.90850056534597,-0.617078219759492,-0.02729832872889,0.00600052372204561,-0.770688409385996,-0.822658332586892,-0.785053794646164,-0.326984528190858,-0.191059445623554,-0.169054704183838,0.649927127346464,-0.323827478609514,-0.214716977074725,-0.682253620558535,1.22397511430413,,,
+1.3,1.4,2.32236853223443,0.427806931249306,0.0402703488023772,0.113862885576774,0.0754927902472402,2.70406468195407,1.04096994307005,0.64771066009713,-1.85695063630025,1.69570239206156,0.491082605773716,-0.123025225831437,-0.0354374776650886,1.92113962370778,-1.2590573313434,0.00875643793143263,0.376386004283907,0.174125611303642,2.15149411768753,1.65926366577081,-0.487098654381922,-1.7100674664531,0.764500072760924,-0.567933253038316,0.987495990460228,0.00949996883680931,-1.25855902616332,0.809357345422902,-1.62511020616499,0.42269146211559,-0.070708576022989,-0.487328175670994,0.164900621002674,-0.683617816803271,-1.04542000052847,0.724483495811625,-0.228120180148957,-0.115000975380967,0.826195913275038,0.442365448092266,0.135587213557908,-0.109488943016988,0.0309216082549297,-0.698165360098408,0.612867470522679,1.19806990644916,1.38542920455704,-0.379494251426188,-0.731897155098474,-1.35668649190231,,,
+1.4,1.5,1.45439547273008,-0.929810951541978,-0.591944576136757,-0.411474639985248,0.289652928461575,-0.253764704019275,2.03654647389044,-0.936592370293857,1.62902125089821,-1.01506182826729,-0.158378237807025,-0.299168462814882,0.508691096423908,-1.41615001234424,0.331446304693132,0.960927520369855,-0.0188706880668929,0.832655068862004,-0.650859111020964,0.679972642521691,0.393631169376017,1.61308504239881,1.3498864827501,0.817367048913504,-1.07304883617417,-0.747468195211896,-0.365260632211411,0.485667789172747,-1.7150830945153,0.587471134281994,-0.859472136779999,1.85745130601475,1.16221951542599,0.427722140784601,0.263307588505152,-0.217164070073997,1.33534523533395,-0.600663931025257,-0.15425051251824,1.61929892116195,-1.84832764639647,-0.675788199193317,-0.803409264963564,-0.437313747732349,-0.765909210679953,-1.30827477420875,2.14311433473649,1.31143432968157,-1.4266078787346,1.65668499033972,,,
+1.5,1.6,0.595521266870661,0.670827444340013,0.822349032920016,1.48671063767886,-0.20591879343225,0.583029392512904,-0.484613644765427,-0.614161729978392,-0.679100407713575,1.76315303217649,-1.17014896754858,-0.86726463730375,-1.33529480977493,-1.21221300830339,2.58447799745804,-0.248351350386802,-1.98327524911415,0.568963822015204,1.49249573377712,-0.72091582182537,1.81381156530344,-3.01314816868743,0.152853800008917,0.117622027015652,0.278507598597378,-0.0184210704865948,0.183121169493893,-0.575401221633333,0.427227245715667,0.49782259523041,0.0121123765173689,0.0605642365961841,-0.714177967040767,0.634344450459318,-1.87727132746797,0.0952605631767785,0.231143650290242,-0.641723073845394,1.23774853664246,-0.65590732710293,-0.0412916456639285,0.679248067992509,-0.38198476499436,0.526950080954531,1.89759407362439,-2.31203317081741,-1.42377201016702,-0.689755443820253,-0.18622422267855,0.965931525511026,,,
+1.6,1.7,1.89979409534188,0.114201731029458,2.11093333569011,0.462634950869365,0.802017284993703,0.45514125342449,-0.741147770239103,0.301082308780641,1.09083469426141,0.679739573634555,-1.30511622720764,-1.12831998478253,-0.709779255952854,0.786495319085328,-1.32696869643567,0.279463547951855,-0.253466304734537,0.252930796714509,1.05907750468596,-0.298027494330392,0.183088883093571,0.779773656314397,-0.158195417336922,1.79688605194308,-1.3838126103276,0.308120164886491,0.606905014035848,0.085984830734963,0.356346802002905,-1.22769019162751,0.373144957964786,-1.87713470192505,-0.171542630218531,0.10405010428406,-0.134565397882384,-1.40524107297725,-0.489312450251409,-0.422137504979368,-0.505231646825649,0.588717173734515,1.05117859910455,0.907752266022308,0.962844639182917,-0.946294028300419,-0.98306249307748,-1.38635130884037,-1.62446697801481,-1.25639807547798,-0.900244784331326,-0.313335627738682,,,
+1.7,1.8,0.326093856462409,0.0718318053141033,-0.780989120529917,0.637204898155618,-0.910877969410234,-0.639233538433986,0.0774259505879961,-0.113492051110571,-1.89804390654581,1.56708966843491,0.202586104969294,-1.30215934609719,0.447191335524953,0.00263359948905052,-0.183162806239416,-1.69534204409441,-0.0999978083298749,-0.551192660276627,-0.361905518259104,-0.670312262837318,-1.87386246016378,0.316208011441323,-0.00256785804749727,0.178342041493682,-1.40822528162159,1.04326994172408,-0.292480406483948,-1.47127673416754,-0.0599809240520088,-0.214670559294986,-0.032534147093615,-0.825317796231491,0.717711471846127,-0.202824366243721,0.208381005095076,0.456347108459851,0.164122164540019,-0.377421649056397,-0.453920115194515,0.0955023622260769,-1.79249664781062,-0.583047306936519,-0.270493627569649,-2.04017251810275,0.388453344865416,1.6092844666269,-1.06114066894118,1.26616548498011,0.595967473989876,-0.491718736512471,,,
+1.8,1.9,2.49850607542732,-0.0260826570912244,0.0700077723592852,0.32604773433282,-0.337215828267252,-1.47078362042724,-1.27195080354675,0.12978088784109,-3.03846808346853,-0.971348447288014,0.274289225628083,0.162120486399879,-1.66513885211497,-0.305161314181406,0.629718567018265,0.57872289230021,1.18813766954819,-0.503338569277094,0.81626217765867,-0.584970486977983,-1.34298310710332,0.111566420141956,-0.948592939426938,-2.62770679654794,0.335001574178879,-0.467151181788328,0.345335492044936,-1.06596135937543,-1.15411840762396,0.759080521827426,0.188628959777562,1.80321198870907,1.40570504545831,0.50475428027401,0.261269132151034,-1.18302501013173,0.819429246309387,0.135359951198624,-1.68396068163217,1.06503229465112,0.967037280889348,1.42663508424886,0.405490271188921,0.81881808633476,-0.738100260180903,-0.470512553560968,1.90696635564439,0.240714186472695,-0.616643676792083,0.0183787390087662,,,
+1.9,2.0,2.06665141514131,0.589269784283709,0.410861099476856,0.239607023122536,-0.428429902516973,-1.32387867673835,-0.436342217523423,-1.31177357968924,-0.57166336986993,0.766187042598625,1.85715937580771,-0.0646796789020885,-0.131612570633307,0.156344942430573,-0.292498182364307,-0.605901957216522,1.80288902912815,0.107614436799477,1.01545574953744,0.235458117756115,-0.560286444234255,1.40477760148376,-0.178458068629514,-0.306794936438191,-0.626652381817584,-0.762817604120119,-1.58336895381413,-0.267099064013039,-1.23405298471095,1.17914343200233,0.337035821835839,-0.0152210799009971,1.22133229367176,2.01715392601076,0.134127095325089,0.0573181658213635,-0.555011540914146,1.30874794052678,-0.280379176326033,1.48128495901716,-1.87613965794929,-0.0844195837827267,-0.0865570974259608,-0.498074760737799,0.249241068349945,-0.634249582641167,-0.912077870193607,1.52322784942974,0.34946589163777,0.60884773848211,,,
+2.0,2.1,1.25072038831056,0.884511094884224,-2.53005978943368,-0.594147504273335,-1.22455094600989,0.8088980792455,-1.1559076709631,-0.313456180075642,-2.33992485126947,0.414859193544999,-1.18566295764187,0.28667090137156,0.0021803291889954,-1.19398936831679,0.927042879338312,0.886711571360871,1.13422062049977,-0.106101059019173,0.200656552743109,-0.265776897059496,-0.380337268430462,-0.366182542407946,0.34614171816554,1.08098970984179,-0.811909505752476,-1.24261374129163,-1.48559581576313,0.115605019107189,-0.186868208961315,-0.310212300747893,-0.647715518796204,2.07188521487881,-1.76171640025885,0.596309901468307,1.32136522112511,0.866199375352612,-0.792865310935251,-1.47466956895915,-1.97470970595862,0.481210882834296,0.701222093740299,-0.50039714712929,-1.12549432940301,1.30696947198215,0.0692254628482164,0.766280297070935,1.33796279501695,0.898354220407461,-1.2698773801033,-0.956425880143152,,,
+2.1,2.2,3.24233817634079,0.611332941669357,0.553565138294653,0.740912626542948,0.160484851636472,0.966306683799727,0.0157197654763288,-0.418906835967379,-0.993467023338004,0.952855403270322,-0.0507862328568682,-1.16062067771541,-0.955485158439478,-0.271225065632924,-0.180715228496015,0.298769684325482,-0.113150877809225,0.674209250471744,-0.115937280452863,0.713839866310203,-0.157143374717018,-0.803984616852196,1.03618721076386,-1.22666095182436,0.304425016446541,0.535110611330054,1.13853902418258,0.999367974696372,1.48896681303053,1.42882431838821,-0.191451670763673,1.06738547316907,-1.27084041318144,-0.330614109159349,-0.318905931995561,-0.0639034589228693,-0.350445049432439,0.162081666508749,0.701550573521023,-0.269222796283582,-0.945463021692602,-0.240843103522553,-0.592389210337589,-0.32454427810745,1.02319337504888,-0.266539115563354,0.743055660073062,-0.777314120810054,-1.13555364579478,1.77335238095689,,,
+2.2,2.3,1.78052390402475,0.665637714587631,-0.648997178120195,0.954128799797641,1.41385204828449,-0.502812403466289,0.968310287502695,0.91101467821115,-0.572199674137244,0.912254039997721,-1.09754904538959,0.147228911090131,0.0383776154710461,0.320546273692963,1.12977707295365,1.06134531673029,0.602512235233535,-0.297055970641868,-0.336964274729707,-1.86103603615554,0.503710255101245,1.32202116631243,-1.32992339608002,1.46537132363442,0.685250787399239,0.17004623788851,-0.042790270206702,0.944091774113867,-0.336345967584359,-1.11582812548653,-3.20376697872025,0.358617024868947,0.466359430505646,0.63021584154174,1.58981213564031,-0.598604346535196,-0.194186670167715,0.160252896078136,0.755976391028381,0.526185943444232,0.351952584397874,2.10812258597098,1.17952247562452,0.181872981618181,1.19487790332494,0.196802219270225,-0.795725040107823,-0.0813670628146194,-0.161018343450083,0.235357092559411,,,
+2.3,2.4,1.66110887942948,-0.669171282639242,0.238791082981945,0.0576994998190187,-0.97045739524025,-0.625648713558978,-0.392040947398715,0.47912679319728,-1.15954530463293,-0.444723564393173,1.51017154458763,-0.884904326863893,0.0505720293967651,-0.303309636250349,-1.82967782137182,0.387245958771402,-2.13812872160708,0.072839052284346,0.0921060823917312,-0.0911599285979533,0.898380471999799,-0.526249926112628,1.19558698015037,0.969765680705507,-0.192868137727943,-1.51635603693505,-1.92422846979144,1.89635828012013,0.624560518950448,-0.246221011762433,-1.54400325325503,-0.137298773758103,0.421647397408932,0.492821551830173,1.3870877899599,-0.590327781524724,1.27611725199891,-1.59339914985378,-0.282554109608869,-0.655996567521023,0.713209895985469,-0.52303567728746,-0.0924481354977824,1.12424704252145,-1.63045814634044,0.258267356486971,-0.554897666380704,0.16136328446575,-0.124360476328799,-0.549251050056783,,,
+2.4,2.5,4.2144129802884,1.15898984987893,-0.0844153450190744,-0.415923956983743,-0.177865843083346,0.805532603528472,0.660962307500386,0.769279245139492,0.30274257091051,2.2384881947132,-0.204404715593324,-0.907373757346249,0.0815032706101724,0.549679069629391,0.0153941242673955,0.0316799229228484,-1.31237420042331,-0.848387326916689,0.12566078951003,0.294025729524649,-1.78368059321223,1.53834255027231,-0.32417845149616,0.573747951412659,0.0563033506143221,-0.45843759977199,-0.0659690318608789,-0.762778707863747,0.0465531117516997,0.843511199293728,0.998400993784405,0.12534453477303,0.665143050267884,-2.01125189725731,0.0165900260888228,0.230619309995715,-0.097760200327044,-0.8739763196608,-0.498505472658232,-0.78016319216843,0.0541555843231652,-0.487035806332951,0.325982358570861,-0.529373162591848,1.05252157316922,1.37956010954273,1.81126597562892,1.63851281677777,1.3415173869553,-0.395835128133719,,,
+2.5,2.6,1.64945509303401,-0.943806283002299,0.518442408130331,-1.86758987159609,0.563419517709897,1.98880849454813,0.167822442506707,0.939696795995567,0.957763670018228,0.960397965214072,0.674303186177436,0.646109771358858,-1.45706939809679,-1.09270022459707,1.12414813658601,-0.0548237364380222,0.342970589673467,-1.18525568151988,-0.675482305011838,1.62729267632758,-0.291640531599325,-0.47840349262149,0.457483054641541,0.870577313214227,-0.721224674333584,-0.211421172433712,0.106876393679008,-0.719604590553536,1.28437850162297,0.589983443821127,-0.502935041331622,0.288891110097736,-1.09949782151984,0.285138781326583,0.23221497065685,0.0244430722130607,-0.369613395128652,1.48523871641508,-0.401019247232261,-0.201210463412771,-0.799169232524,0.441214035498657,0.150811602503801,-0.689976172263641,1.27124947577614,1.07938635876632,0.74629311413399,-0.629628032288343,0.623020619345286,-0.554008269580513,,,
+2.6,2.7,2.74267095821661,0.105328987636752,-0.396652597752965,-1.17520661147774,-0.0920467556319642,0.499021818079761,1.17621837900761,-0.0511456831345421,0.234026363651286,2.08275367409868,-1.6625168393052,0.0304967639095206,1.10773653213436,-0.212429385610628,-0.149985303022734,-1.07752592911075,-0.380523025075435,0.770899987294562,-0.0539998960961163,-0.110282138852179,0.864326522573728,-0.174194827211763,-0.291475882506444,-0.0162377291336753,-1.17835573282497,0.951712346336096,0.391718062267479,-1.73933567256628,0.144549816691083,0.0745948834215085,-1.32807861476269,-0.256265565244772,-0.176818563119596,-0.37585623353079,-0.00496330052164495,0.591117464132105,0.107386092347437,0.256027134157681,0.133555757775967,1.96139700569588,-2.37082732509051,0.275216717079046,-0.487104342274867,1.35625023660206,0.526932865956488,0.538355956868382,-0.883022071885734,-1.27433359665672,1.70343797719687,0.344580833665085,,,
+2.7,2.8,1.10599819482375,0.237686255846713,0.389575810089312,-0.42357314693201,-1.5697127920899,-1.18130344829903,-0.474537353410163,0.21754092125466,0.756115468071972,2.41509704931181,-1.63628828754697,1.3024635233633,-1.52399652503083,0.061368969725903,-2.1890136434063,-1.70507987925561,0.00331165686672664,0.0741319526982085,0.721220937977569,0.0265753026951838,-0.638723152733768,-1.31123192949694,1.31303801156959,0.192062225960722,-1.18094929526039,0.262928271104671,-0.139079336118455,-1.80673965081279,-0.581312905582967,0.132667092003635,-0.305509290511996,0.0422474468859502,-0.0622162430143679,-0.0818912919901172,0.0795471459755263,-1.53503922671932,-1.09568190861783,-0.478083259453381,1.07430885815161,-0.926219815267994,-0.979514541691635,2.82062839696617,-1.80974199682299,-0.727729198249089,-1.04255250763512,-1.08426631652103,-1.39661976827106,0.363835609024638,-2.08799866608004,-0.0703183201969761,,,
+2.8,2.9,3.23628638516357,-0.524234451568147,0.357667308557918,0.226220896928561,0.228399918268658,-1.39852263854515,-2.85926196102661,0.287948519947749,0.234972759232946,-0.15751905583906,-0.126263813909429,0.393895889734945,-1.59995691732761,0.821950331886864,0.942984216497974,-1.34939928982119,-0.317975140563889,-1.88453080321454,1.61781787045376,-3.19935100536208,-0.72779542665994,1.40163022950578,-0.881671115674016,-2.5937032724123,-1.6294249814381,1.97735867406683,-0.28841888620391,0.138567992185448,-0.208531413485633,2.35174016965935,-0.212575934186355,1.20033459199205,-0.809834121624679,-0.814571086128561,-0.804256508506296,0.486135360016604,-1.38226305141847,0.488812788692303,2.07070275715958,-0.127237250550859,0.214354832595851,0.65845721303472,2.01756523803506,0.357082435071566,2.2600868489938,0.699568890561675,0.346368826321668,-0.0750746044920143,-1.53383571481332,0.223863784801219,,,
+2.9,3.0,0.379596496393281,-0.445807282790103,-0.181181655990299,-2.1290714394348,1.0047830962631,-0.862784781268212,0.339212363564143,0.504844509995135,0.130668088226239,0.255920303674645,-0.0797566577461414,-0.650352862835467,0.530666970519608,1.54024666448574,0.0580229399848478,-1.05283397579991,1.51267922226895,-0.712964510711093,-1.70352662244298,1.22623513633027,-0.927269105123236,0.615835182518445,2.20892273231957,-0.0726308362325351,-0.266315624357186,-1.02098821580133,0.199836806404051,0.664043859159181,0.997514218296064,-0.52791373286299,-1.2072954979183,-0.31849279568277,-0.381189684390601,-0.949856501813098,-0.340319634467726,-0.231545343146002,0.231219459130344,0.876616515272772,1.42976090587133,-0.0339603499085388,-2.20355494273046,-0.131839907176857,-0.0559721527756556,0.56882218677041,1.27168044162329,2.5792700875897,0.355753148367243,-0.193920486746723,-0.995100829461892,0.573162251370111,,,

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/class2rot.csv

@@ -0,0 +1,30 @@
+Time:1x50,End Time,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,V 1:,Event Id,Event Date,Event Duration
+0.1,0.2,-1.41232437907546,-4.38221566333654,-0.589097699064319,0.217372153255027,1.27685520628543,-0.756778481698309,-0.543962016747266,-0.187181516773856,-1.58507038797054,3.13563802128473,1.91172848200559,-3.86922895374677,4.12192248984278,1.45303296714151,-0.656269348110641,2.37407036184574,2.58975534728869,-2.40859466417441,-0.617070760407336,-0.304654607987442,0.984240355760732,6.97482380197961,-1.11771787282909,-0.86525116147396,-3.23825575513482,-0.538260960885557,5.49599735857233,-0.164809703737508,-1.27860257610813,4.01751415924776,4.74927678631869,1.88634276049864,2.12067929110647,0.399126112513965,-3.10239276974533,1.0629811449084,-2.60833706563185,0.284012867924059,5.49759259653058,6.58112241867482,-0.192683715345061,4.44602723389523,-3.07100252473818,-1.6052712435052,4.00766074970893,5.78511623305967,0.634161961205727,3.12744389732379,1.42603298182921,-3.16319555524887,,,
+0.2,0.3,1.23025167728829,2.55042197348026,-0.996797522796963,3.11806930521677,0.399136455645935,0.56095615427698,4.59284506207901,-1.84567236703288,1.8816965753032,0.750729173641131,-0.829389368162276,-0.487405081904131,4.91804790857892,-2.1543740276208,0.26684094368407,2.67856896870312,0.691289502023455,0.987665148165264,3.78934998772079,-3.34374902882119,-5.44868781295565,-2.02522881313808,1.46967805316524,-0.404231945768228,1.36218718246369,2.32809332192605,3.46211643962893,-0.0935594029982055,2.55546097585287,1.8285128290357,-3.33242202454528,-0.81647528277583,4.78109928979897,1.31043910420667,-4.26628298568948,4.28910480462471,0.530555688570553,-0.474160971125616,0.53544116203418,3.56379070526742,0.0519593475829907,-3.03383843699085,-0.345415155244719,1.34779086652161,-0.593473775123416,-2.14076326226118,-1.00822931767497,-3.22067324001478,1.29926372514046,3.04170584248838,,,
+0.3,0.4,-1.27952659735789,-0.678694034794376,-7.82905738068359,-0.453899386644462,-0.753031099492228,0.979661086218665,-0.145265745943201,3.3305149026421,1.40553600310107,-2.71025217679511,1.91691429643109,-1.66337966276611,0.491278647558013,-0.217054613705415,1.30642053034477,4.42155452174562,-1.20798772143527,-3.99764898858139,1.16793671123473,-4.00477404985,2.85824304874785,0.0389253585144361,-0.561022996231375,0.953884500494647,-0.581119570114544,3.66788193041374,0.937030386226416,-1.85477673926392,-3.50829167417705,-2.29384068911566,-3.01630266121275,3.70404305303742,-2.99212185026577,-0.805293998539477,-0.197505568250145,-4.06364555944777,2.20829484109197,2.21595280420013,1.46393840866214,0.463084322420088,-0.0925093216843882,-2.03260255466236,1.18708012237896,1.21157092378972,0.362154361384203,1.39296797924311,-1.04406256191426,-1.62062237565984,0.351120592419513,-1.00927590927613,,,
+0.4,0.5,-2.09063898202145,-0.885281257588577,2.95731628011309,1.00726807670656,1.18387334367457,-2.55830621315147,0.328466116650074,2.70320901698313,1.97284271456488,0.81107860874752,2.09099386575403,0.3555519090344,2.37598172887946,0.66818278902417,-0.190371511963837,-3.343388865518,1.21793902737849,0.0984098117557504,1.11595575053085,1.36701904711547,-2.28258562180032,-0.560253392047431,-1.59159179981677,0.56780414999771,1.33190662675105,0.639266075327812,3.70709664830959,-0.507385000728346,0.475155225763881,3.10663479560096,2.25207747584878,3.4745549102939,-1.44545077904603,5.65483928695995,-2.25683275445989,1.68259107985316,0.661591836783155,-0.457201675623602,2.05726753879515,3.16098266017121,2.04449928381376,-2.19163282650609,-3.50026559979492,-1.53775220398596,-3.73802650641534,1.62864227404371,-3.78922329429375,-1.82410237974745,2.288643534796,3.24115982383583,,,
+0.5,0.6,-2.98522799710803,4.36673455162735,-0.913239491117599,3.37091298095012,-2.85566029410916,-0.240479200085136,-0.0912376280480195,1.91082754809618,-2.21321531259226,-2.05032531808526,-0.40695956382635,-1.27738678943432,1.73181147069958,-1.33457987938084,0.641156726971704,-2.34938281658383,-1.35937565189658,-0.115081669604994,0.442052347494917,4.82608960749163,-4.77444037931449,-2.00083972335266,-1.99839808817676,-1.97880121135913,-4.0278099493376,0.45826619586843,-2.86175180125398,3.003887735408,2.08768815172436,-0.175604692890707,-3.89226036160365,-1.66556725296722,-1.75134329758897,2.15598722351507,0.408689902307966,-0.595924197768275,0.638198078041635,2.36876727660785,-1.55762956391767,-1.06095325198528,1.50573831504874,-2.04130812607458,0.660258593931511,3.4896733702911,-3.32855687979512,1.24703499718318,1.19952647235344,-3.10247346356164,1.24474651415173,1.67934846815462,,,
+0.6,0.7,-1.15658088905979,-2.23235830634288,1.50436241827814,0.0526692213027273,2.0198785602985,0.10578780244313,0.189999063495495,1.47025665787305,1.38649214334925,-1.93419764299863,-0.918027002619115,2.59694632721724,0.30028812139129,-2.53964587566085,0.0370193604133886,-1.33547475687044,-2.98158175293884,-0.31318076115017,-1.16007483686783,2.93468359379349,-0.937165509062934,0.0895422263395593,3.12715890376222,2.0152844514168,-1.77056204656165,-2.23384358328873,1.91737015795644,-4.69067255566191,5.71707274836576,-0.622744985301739,0.92941364429288,1.01513193551207,-2.17831879408022,-1.45710660800518,-5.98274644022098,-1.79283910736022,-1.0662345980025,1.22595128536558,2.42167427418027,-1.48194213486215,2.18829385078776,0.198953449834362,-4.72694901068695,-1.29902767589321,0.804746364108259,-0.686429215723727,-0.83291212587698,-1.24093394299829,3.27279310614253,1.7478608376101,,,
+0.7,0.8,-1.25358500769904,1.35794652211513,2.56427712370512,0.331694030331151,-0.610145896441222,-5.06185443991055,1.62811621493617,0.166683579229065,-0.991576105509301,2.49436818212971,-5.05822778553097,-1.19484897136277,-1.80096731156371,1.00965637987569,1.48637877798285,-3.25243735341964,0.7602695903532,-1.55570913957909,0.803710614119578,2.20270892356598,0.271082479820789,2.67826597331098,-0.167156401034695,-1.0189606868846,0.698173219597948,-0.553865581931714,-2.07028897360437,1.66540144781335,1.33019904765178,-2.86659170314343,2.55644987075593,0.332285698926189,-1.08163157358189,-0.0664648801325007,1.26660556815642,-2.28412146640259,0.109061078243492,-0.764479323044105,-2.00358010348985,-1.86275645195572,-1.82398665296699,4.24123772073239,0.53850492318425,1.22178375019037,0.138526415183611,-0.0864866024316983,-1.80822412833675,0.846863936662275,-0.25957287145996,-0.755333141671768,,,
+0.8,0.9,0.0400239009034142,0.31877160410125,0.772324632442131,2.04794057956307,1.66442407777497,2.43184966430293,1.11512625379363,1.84801178709294,-3.41957677452621,0.893293180458025,0.977108503724518,-0.634949907966531,1.20658952859773,2.15951702360555,0.257475150245731,0.549636118504802,-0.408784522780224,-1.45843672790158,-1.32949286448782,-2.23800289360708,0.390721576507646,1.89140133442457,-1.10736057581823,-3.657168147283,-2.76062421568351,0.0597087776668026,0.577691945950767,0.232170836044584,-3.77523472579614,2.986557137518,1.07605846302119,0.114010759463974,0.856826264183817,1.97154579006937,2.30060876816591,-1.94551170510611,-0.943304530791566,0.867919966889015,-2.68715114322971,0.0147172973718559,-0.615790646620068,2.20137399584509,-0.952862526341853,-0.691051938273551,-0.708546423768488,4.56359712401853,1.03046342125096,-1.08013320119103,0.567239139230345,-0.650774391296837,,,
+0.9,1.0,-1.46503679137344,-1.49213241036758,-0.99320737892599,1.6244749375569,1.35225824287811,-0.657725478908601,-0.0450954076330051,2.48378605775998,0.945999913983723,1.94296108399823,1.63625088609024,1.99593756618544,-0.0320278617168418,1.77802523558196,-0.0604864808228987,-0.274496590416412,-0.0198818245146311,-1.36886516477305,1.61964372472403,0.732472141160006,2.39337757792445,3.72602731849955,-2.57768731426988,-3.68714735730894,-2.36053394479404,-0.65158842351975,2.59757289348601,-0.298075334143069,2.7152734126952,1.41470919393573,1.03091218814005,0.620929744990655,-1.05007917964554,-1.58464385779122,1.16235950298532,-1.28801628865518,-1.26706415660331,1.99656577214933,2.79492268601702,3.69527352720757,1.80217382050355,1.29722077369995,2.27910850195407,0.142482417103059,-3.75204527653695,1.03229407502558,0.877277456867889,-1.69995155354368,-2.67786462947105,-3.329591798966,,,
+1.0,1.1,-3.31763380566697,2.39203616550534,3.45822524468127,0.707536878709489,-0.196790989720546,-1.65136648162632,1.38420796359217,-0.870229631454724,-2.77591770862265,1.78954903070472,-3.52388381888171,-2.25825414194062,-2.41385824035081,-2.92887971112554,4.22629706785009,-1.34162907002301,-4.17892038006087,2.97083755394025,1.27393531600851,3.5629509726942,-3.95979478720083,3.5736487779145,1.04052703866236,-1.13032019431616,2.42975870536696,1.96710725632097,0.484374050055673,0.269765192726298,3.14043085744899,0.59092120740701,3.24016804205636,2.01896113901305,-3.63252419365971,-0.870377620904804,1.73695765871405,1.22568720810474,-2.2857952346332,-0.951517315251112,-0.815608303222192,-3.71122564975411,0.566161527775791,4.43986756329715,-3.38023306933696,1.72497791801079,-1.39959140291067,-0.701878951276849,-0.788386244254526,0.187838240305984,1.36323750776444,-0.0517027805738488,,,
+1.1,1.2,0.00294251269778084,-0.228599613389657,-1.23427211548751,-0.191181971944222,1.6041558310856,1.66836823762611,3.69995309783192,-0.234482805840524,-0.214455559533649,-1.78743324878138,3.09245627785752,6.08583811847784,-0.23650277847394,-0.327005658625549,2.17109141838304,0.794061650181908,-0.0282302573042368,1.39100521799944,0.689400652808229,0.302108937613976,0.571736577620463,1.09787785309722,0.218553665007896,2.34796958033908,-1.96620903664443,-5.55043155867659,1.34141348171962,-5.19920537673989,1.71439165968605,-2.51206533605387,2.08304646886491,0.597952651756358,-0.709847636643395,-2.98602762315499,-0.226510993485331,1.09401815694868,-0.925219523831217,0.671545098856139,-0.728688357271658,-2.02528701480992,4.0031863413811,3.61672973367981,-1.18455320924896,-0.813437963326547,-1.35048175492362,-0.690953206301008,-2.00039504385881,3.10102214061032,0.0429218250142522,-1.21434706883531,,,
+1.2,1.3,1.84958201367322,-1.00481108086674,3.08780803669978,0.0296988303804707,2.44759575996005,0.0034027154071001,-1.21495711483478,-0.71193003205416,-1.51482916652321,2.09989741763963,1.25281538022842,0.460287897859289,-1.38930725666937,0.726731324074365,1.02715302835589,1.55977542589838,-1.1048958969477,3.2925250939511,-0.646936882463826,1.26900162104335,0.953368239365401,0.677720370299007,1.07970244577731,-2.09388671690298,0.650490771778257,0.434918917674436,2.13235507969008,1.00174064320083,0.449892677398025,1.14304722864807,-0.684002851445322,-2.58437391853044,0.753222622753823,1.10885193485282,-0.494308828491774,-0.0360895391041974,-0.33304224917097,-0.0927606892121839,-1.24300315438234,0.91411708803711,-0.936753693307299,3.42198952136922,-1.15082992450971,-4.34234945597692,0.178846293671331,1.6160852052275,2.21631527901358,3.80187567688086,-2.36968240231566,1.81203633517944,,,
+1.3,1.4,0.56660644776425,-0.0271230021080172,4.43310066549021,1.09613235217935,2.99186990209512,-1.08631811992788,-0.772793861352253,-1.47260513142128,1.00778854071732,2.5280581478466,0.657603420306527,0.632076978992156,-1.46284144459844,0.996180032441916,1.07079743515669,-0.536993699243975,-2.57159938279999,3.36399733584398,-1.74013840754709,-0.766955737425094,1.61145659399616,3.29766522554713,1.26923475994324,-3.1825762310479,2.63224093595566,0.722463029887448,-3.17371485850347,1.81159309517182,3.14169342900623,-2.42622980860964,2.6328555123511,-0.752313157323256,-2.69469059643352,-1.27495427353956,0.247655278036003,0.0445661153797095,-1.44591633219888,-1.05610612775835,-1.25503523033866,-1.45633172667776,2.71201689412899,1.64600107063596,0.746398736023923,-0.735808163797691,0.725745262556987,-0.318530018656508,-0.154649782968684,0.267183053799668,-0.951154510576489,-4.24360665935723,,,
+1.4,1.5,-3.3185886967884,-0.76691156951287,-1.76762226282636,-2.3313814360203,0.990354081415756,-0.499567621999231,-2.45781909589062,-3.01774207261569,-0.869335061361338,-1.77929549105591,1.11348984399329,1.5920059460526,0.491991214618287,-1.56178947748258,-2.7409203420492,-0.840128318821629,-1.03051552746483,2.03683225856635,4.09431992205192,-1.54990142639776,1.26818146608216,3.18665778106475,-1.27504415799283,-1.43719056147623,-0.776689365041736,-3.02207982719896,1.5314427842767,-0.323042625317928,1.47042429871633,2.16345164447118,-1.04753391793687,-0.712379856494644,2.36767700396589,0.119191902385424,-4.41287148750215,-1.46406521693758,3.3836865734087,-2.15517623199179,2.89935581135562,3.19400039911001,-2.31514106835062,2.782825000743,1.12838641260009,-3.7994169520939,3.37034689638179,0.605619706707026,1.22351285318196,0.296780812019547,-2.01200487292807,-1.42337275915205,,,
+1.5,1.6,1.51121177930002,-0.468153149892247,4.79621881641431,2.15282049256067,1.36000831895153,1.76461888875732,1.03222347694678,0.646095282626219,-0.802694752287815,-0.151848120127994,-1.29763769415122,-1.19582116862269,0.292078938845926,1.12052845666294,1.05980354314239,-0.222680486647928,-2.94026152325142,-2.34589941743966,-1.38620632144066,-1.06825962413843,-3.02020634017001,-1.47364362486126,1.39833701738049,-2.06651370098612,-3.21539722748519,-0.0802052408204153,3.2664377116934,2.33387514345511,-1.48837266028941,-0.0929710542565618,-0.553619747879515,-0.389516447679783,-1.69644208037309,-0.255359141833334,-1.41719160078737,-2.09144249761817,-1.42546166259595,3.34341916424844,1.55316101221632,2.16297385671399,-1.73176061173602,1.78400745223146,-3.94654132491128,0.357944442986356,1.20550737036747,3.66213203292596,3.91998029002927,-0.804156105341732,1.99727326786523,3.19329695523194,,,
+1.6,1.7,-2.77318492310507,1.30127588425824,-1.17671067832355,0.382990853975427,2.12076124111223,1.06910861031852,-1.24187293035933,2.52580927376997,1.25057970086451,-1.41421797803869,1.64960160736037,1.76526785000459,3.99433902973274,0.209237703287374,-0.437649523412842,-0.242346770775713,4.23972254017372,-3.41066656430198,-1.88746153755346,1.38626872395904,0.837088538977375,2.35358453055453,-0.876969294180495,-2.75773199738558,-4.36612766651864,-1.25701670648561,0.548810492648368,0.432597609701371,-1.07663558048454,-1.12579545156523,-0.823239311271533,2.43783245482838,-4.51670104679146,0.411440190589157,2.64663542886705,-1.5002300985206,1.4862225806374,3.37428364348244,-0.161900927454004,1.39604422571105,0.994496861275975,-0.363648150051651,1.50597340197581,1.51854811620162,-0.98293570356039,2.39090297130017,0.635835880055919,-1.65326330162276,-1.36407235177857,-2.05144541966198,,,
+1.7,1.8,-1.37956416751984,-0.0195674146216682,2.23265516009393,-0.258705713944022,1.33373683263979,-1.62855452122211,-1.18985493483261,-0.648076731558928,0.706670861441087,1.80753065725883,1.69538928333015,-0.367144522208532,-1.32969006729146,-1.85443872184972,0.865544584170506,-0.106527270263076,-1.5583859920028,1.71799187438944,-0.39205601098304,1.14305287469714,-0.398503758068568,0.763849087010321,-0.688670318523366,-1.45466384955709,0.12563329896557,0.00470472496464156,0.830340963919348,-0.610215658805861,1.28603825559476,-2.68401980688577,0.962085063837756,-0.302804796370285,-0.420205078685492,-1.67591717320937,-0.416010842491834,0.513847546434064,-2.02218374671912,0.156465691490543,1.95252284987379,-1.07024115411877,3.75328579537804,2.24672478343153,-0.930914149121089,0.761001433620736,0.948064206672273,0.406374258701911,-3.74709839139581,0.530462182954344,0.888379711482461,0.630065677054879,,,
+1.8,1.9,1.54694877841666,-0.847823334702446,-3.76968708744548,2.3448506546552,1.14606108268797,0.374643319372579,5.86764477191342,-2.09939703937804,-1.28750530969492,-5.3037918545851,-2.45380047334452,-0.260076791256238,1.07683129920361,-1.76978186721982,-2.12839619509946,3.84227782428045,0.961646084423603,-2.00217523089889,5.67096521048264,1.26045695149155,-1.36717343148684,-0.684436710914471,1.25315244337001,2.40677908375336,1.37950772243836,1.81136985471315,0.559169652967571,-1.69873047103125,2.42842137130187,-0.852701958637376,1.1645637132616,-0.0929904937968398,0.0802355538008128,0.213487033080293,-0.377925229261292,3.25272997333102,-2.8379898305251,-0.425302037842293,1.36067842014039,0.758598554561745,2.2909675487736,-1.68123838102379,-0.800688843608186,-2.44557914020732,-1.58435638274633,-2.59658895981263,-1.65759052294503,0.473730310219512,-1.24085571535322,-3.71010952766359,,,
+1.9,2.0,-1.22082506564589,-0.497338882505742,1.32074608444538,2.50204940754068,1.22355108646505,-0.223747709466705,-1.29903826236884,-0.776214386781921,-0.869292634200802,-1.39368761174202,1.57072616553869,1.76632079215019,1.96488421257976,-3.13788402021873,-1.48732326794496,0.107737385980569,-0.452735194797825,-1.0235245022967,1.91664445196357,0.869088262800819,-2.25438754359147,-0.926588812084567,-1.30534895407157,-0.231066756337278,-1.47134681589392,-2.25875973891762,0.269798180715215,-1.64807635996559,0.370329611762003,-1.94914930701637,2.59870428865079,1.872881204141,-1.21291157388318,0.868256004274856,-1.75976752568427,-0.152740673861283,1.15850450707281,-0.081505341478509,2.19947862016223,2.69132682922351,1.95669473360073,-0.261615218703724,-2.80603507444815,-2.1625902053865,-0.776019717215764,-0.137477839722539,-1.21880508824945,-1.1310034827153,0.639458777494653,-2.33763961409578,,,
+2.0,2.1,2.97682103159632,0.6637140745606,-0.171246714518869,1.78118161753372,1.42971089741128,1.21322144784784,-0.337156035891973,-6.37217212692342,-0.107169166200335,-3.52650997379181,2.6613610585236,-0.531735158719905,-0.575845429664075,-5.81999952036502,2.06616840611659,0.563273770293763,-5.0739196537086,1.91628468806411,7.6178727717803,-4.48273533469124,-0.05973725159027,-0.929764351705911,-2.28640224137518,4.06146544705906,-3.25356792421827,1.39491986299245,-1.44270701561409,-0.263905053942344,-0.508713086352647,0.173478094095145,-2.41613816466446,-2.01634345926973,3.7917836534071,0.188440363711339,4.24927579304243,1.62435822095484,1.83068308249619,-4.01401607018206,-2.31755014196848,-2.25456581351344,-0.135258920097315,2.12853169751258,-1.21382552024341,2.41486231616609,-1.85747887951972,-4.6636570064605,-2.21071529052012,-0.533756910476013,-0.0186583034918115,0.910351723421371,,,
+2.1,2.2,0.588846073485853,1.19602205999125,2.70810712036,0.831386412814,1.83093545202126,-2.14027537177742,1.96010700949098,-0.886830278659494,1.64721049327601,-2.36176100099554,-2.09165930665075,-0.830893661036872,2.35583540764596,-2.27782133924736,-1.87093956597154,-0.0242347183995278,1.02665760994215,0.392422113169452,-0.666206933154701,1.63775677668632,-0.749262976184406,0.0111246674287723,0.532988161523799,-3.56658105263342,0.476882709052065,-2.21183032290678,0.600723809698169,-0.77938109579893,0.902018212241312,1.35125935098703,1.44957541690666,-0.242690523237852,-3.06710692364147,1.13879802976562,-3.49146152278356,0.0927441390592058,0.524061483991716,-1.92698854877169,-0.491911217126778,1.65744121338439,1.86609313043487,3.13129690099302,-0.0517538683188628,-4.14443518707577,-0.793033613594441,2.22087669233407,-0.326310749094584,2.00759981178538,-1.28032083035844,0.15948486849958,,,
+2.2,2.3,-3.38568356387666,2.03477565940673,1.26998567426876,-0.611960142198271,0.854631568568371,-0.664076332375726,0.178130196776701,0.803290032145864,-0.758903309013727,0.0835379883108125,-1.3483867877042,-0.635201153363848,0.898468982416352,2.80131320329932,0.572447911995825,-3.92727992847732,-1.03632340695166,-4.73067469695904,-0.71716919925457,0.894201156962548,-1.08745999142748,2.85569279102193,-2.29551544369771,1.80870797768336,-1.20248105884086,1.94046425522815,5.83472310467492,-1.17217761141632,-0.209134870713454,4.46056834982749,3.21039521462341,6.95145666192604,-2.1999983832633,4.18409136049878,0.759472200547565,-3.15556210903395,-0.149957644994364,1.44555265724796,3.41767152095492,2.72717917495781,1.81743146992586,2.04645242113262,-1.90939006755421,-0.283607025409339,-1.95904975974213,0.0393427114585407,1.26777581206735,-3.32550464822513,0.989870077761044,-2.4501294195438,,,
+2.3,2.4,-0.488198592624695,-1.09254712691361,-1.32228710895179,-0.606907075002112,2.85388559859612,0.218202616488629,-1.63897896152918,0.575150041859665,0.332533518879666,2.36028157651246,0.755716148145986,0.533852075219828,-0.900812477131349,-3.97730550017679,-0.339745321692641,-0.252976691270395,-0.466849449636295,0.815110684326396,3.62693898633812,-1.29983249663371,1.5706496761355,2.67446195442727,0.755777803867609,-3.88319565260341,-1.54793753100892,-0.181372925213423,-0.673153867750792,-2.01996503825753,3.26148068480058,1.76798432580635,2.92194843483694,-0.144258970086289,2.21646972211498,-0.28735536300575,3.13649910605972,0.342111101114112,-0.0576749910988138,-2.19579095362317,-1.03773792885122,-1.73266640580466,-0.208102014787992,0.140591231512377,-0.652950085011339,-0.182458132134831,-0.448539290312923,-1.11077781538217,-3.25661036951738,0.298742657140007,-2.90603968139518,1.23778277137667,,,
+2.4,2.5,-2.15616386953233,-1.33290795915105,-0.557059335774373,0.339951114852152,-0.563733461702318,-2.28853971255126,0.516912138214922,3.11239609193249,2.89459048370558,-0.58382756269164,2.37843875782424,-1.9465415396898,0.178480224102955,-0.337222683261412,-0.536147078286055,0.236404204634036,-2.94015374783926,3.43308769757597,0.0783730745712926,1.02452363082663,-1.63833401862295,-0.37754522690096,-3.71427363184686,-1.56768211139015,-1.58126090995035,0.35700991362944,0.00835129455646182,-1.70804837241887,2.83189624931246,-0.562202174380604,1.69740319747029,0.371537977973951,-1.64109915453121,2.75301861553217,-3.75624723825591,0.935106025763558,-0.376050115589752,0.741772993495607,2.31980584994586,-0.48179954023363,2.12401167834398,0.95643758423328,-1.08008990753712,-1.13661064540939,-0.924179562618883,1.82165472441751,0.735168431591556,-2.4869834321712,-0.410542732285207,-0.551625773999562,,,
+2.5,2.6,1.37881296061145,-1.12914415664187,4.7758841055428,-0.136501855561357,-2.04927775420084,0.211728298887886,1.08877077520669,0.220850415254667,-2.07719035779118,2.25985244843422,3.35775657756306,2.64376084838762,1.35848609459951,-0.686816499907193,0.815818841707736,1.93315278514834,-0.213793653630425,2.27270157783792,-1.10086098246545,-0.366636677079596,-0.62742633956824,1.48066716399762,-0.997929740806428,2.18373137555264,-2.0157409963734,-2.13233486433797,-0.774990201258137,0.336727407015108,-0.526170993671044,1.97193608205678,2.79633738099436,-0.93930201152594,0.0493858891360088,0.704588765216077,0.518427483018597,0.184342880606744,-3.04653018271994,-1.93001848923548,-1.60902344388626,-0.0337993154813671,2.24483484094204,4.76376353373781,-0.602664215487312,-1.96549789560035,-4.0013876150368,2.37504570758208,2.6638596332302,0.541782527135,0.0380511191766738,-4.16424548251387,,,
+2.6,2.7,-1.3329959701647,-1.18883802893281,0.560686680689653,2.12838566891993,-1.72826297660466,-1.47573712641656,-0.529400742178531,1.95199596166756,-2.61264403010361,0.058008696847583,0.509044040721609,1.2069432724943,-0.483995828831695,-0.847697450869864,3.10816193376628,-0.846540966624373,-3.6337988961162,-1.2394880741945,0.995963402213537,1.41958397060607,-2.91162001343447,1.22533412259867,-1.35171621449816,0.783412916721203,-1.46120423404449,1.03426698606251,3.93281118222532,0.987472874345992,-0.241856742234803,2.23337929619378,0.362529607431243,-2.13529227782332,-3.43959686240657,2.29826097570196,-1.3296066070049,-0.881038673309384,0.34133576670169,0.0287484638451527,3.94802608286607,4.06767664745933,3.56051485207831,0.47455853601654,-2.45320593567447,-0.800554127545072,2.45513137004464,5.39687720939536,1.34001090508905,-4.96858725220808,-0.894968766925007,-3.16570419725118,,,
+2.7,2.8,-1.88031953510677,1.08273742502546,0.289096226186868,0.145442968351952,0.840005415092104,1.62217493278532,0.439479269304948,-1.70091727510146,-1.63862280728423,-1.62022878351422,-0.835354535882028,3.50367835226417,2.26631918545743,-0.445512550837549,1.41280140659686,2.53506482093936,2.798295795401,-1.83915296130029,-0.484995151124497,-2.60304021792617,0.557821899682088,1.81434082934347,1.60635932454516,-1.91409589083802,-2.62086186932772,-0.969964225780648,-3.7339674125233,0.354753396626877,-1.49512297512331,-2.63656250448595,-2.5903194092648,3.10438709079862,-6.2840082271021,0.0955553256654889,2.07253177710775,-3.83953381431878,1.75738799012675,-0.801417604398757,-1.2199005804177,0.542999021690137,2.25563232832019,1.77447944089314,-2.91550509519634,-3.77081899323202,-0.21100977834489,2.43657671269048,-1.77221947025634,-0.0110825738723026,1.87794630096308,0.214687098906287,,,
+2.8,2.9,0.887297082996313,-2.98320378743449,2.9928511278737,6.78204774526589,3.32840930827169,3.40549253368447,1.65617552414324,-2.41635347548855,-1.7436179599396,-3.72273092079473,-0.231783232475308,-1.29429084285747,4.28436105903319,1.84107283325842,-0.280869343591292,-0.228307163277049,-0.657884021974231,-2.75724758408696,-2.67989886086249,2.84935665597603,1.92378770822667,-1.91987729012316,-1.7331414962177,-0.232113221169467,-1.8427199560257,0.0705790707590537,-0.949689569467352,-0.253576192866496,-1.95468846615996,1.08025449994452,0.429449652157862,2.14334880861348,-5.56355396724729,4.03173406805506,-2.79465914024831,-0.870818234610577,-0.671051903499333,0.944317732177208,1.05030006790658,0.677226234574206,5.48815639900187,0.305304178613231,2.24419422180127,-4.36391219394466,-3.83695718903544,1.90663421245902,0.112376343535206,2.84732141005798,-0.573021738179849,-0.0149907763591499,,,
+2.9,3.0,0.998064176968434,-1.14973366903289,1.83976122422861,-2.85683916955725,-2.85966339505963,-2.94074424162789,-1.27050108286986,-2.60104662006269,0.696816132825509,2.80529156470863,0.516780865160611,-0.583761148071988,2.75198431550269,-0.56886907769016,-1.34360919908592,-0.629229295679807,3.16683411945325,1.57823058453391,-2.35940632365108,-0.241013836344989,3.48188419823192,3.21613458019436,-3.71401529146625,0.255398147149734,2.46816949123091,0.12021953833055,-2.1728488261266,4.61660248893364,-1.13519660356753,1.69130597349401,2.54997349492956,0.470184758609311,-1.29553526038967,2.08648663420679,1.59280173455874,0.533450391850695,-0.368246157075794,-2.41228341183792,-1.03706268207785,0.149123758242417,1.02350465346359,3.78710781674726,1.89465489141229,-1.4585107455624,-1.94916767105757,2.59893995597665,-1.52616094249858,1.76309349603794,-2.24243015050549,-3.06566699250248,,,

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/classifier-training-flipswitch.lua

@@ -0,0 +1,43 @@
+
+flip_count = 0
+switched_flip_count = 0
+flips = {}
+
+function initialize(box)
+	dofile(box:get_config("${Path_Data}") .. "/plugins/stimulation/lua-stimulator-stim-codes.lua")
+
+	flip_count = box:get_input_count()
+
+	for i = 1, flip_count do
+		flips[i] = false
+	end
+end
+
+function uninitialize(box)
+end
+
+function process(box)
+
+	while box:keep_processing() and switched_flip_count < flip_count do
+
+		for i = 1, flip_count do
+			if box:get_stimulation_count(i) > 0 then
+
+				box:remove_stimulation(i, 1)
+
+				if not flips[i] then
+					switched_flip_count = switched_flip_count + 1
+					flips[i] = true
+
+					-- io.write("Flip ", i, " of ", flip_count, " switched\n")
+
+				end
+
+			end
+		end
+
+		box:sleep()
+	end
+
+	box:send_stimulation(1, OVTK_StimulationId_Label_00, box:get_current_time())
+end

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/shrinkageLDA/createData.R

@@ -0,0 +1,42 @@
+
+# Creates some toy test data
+
+# note that for openvibe .csv you need to manually add the freq value as the last item of the two first lines.
+# its not done by this script.
+
+nExamples<-30;
+nDim<-50;
+
+# Gaussian data
+a<-matrix(data=rnorm(nExamples*nDim),nrow=nExamples);
+b<-matrix(data=rnorm(nExamples*nDim),nrow=nExamples);
+
+# slightly overlapping classes, dimension 1 is the only one that matters
+a[,1]<-a[,1]-2;
+b[,1]<-b[,1]+2;
+
+# transform the data a little with a full rank matrix
+tol<-0.1;go<-TRUE;
+while(go) {
+  r<-matrix(runif(nDim*nDim)-0.5,nrow=nDim);
+  if(min(svd(r)$d)>tol) {
+	go<-FALSE;
+  }
+}
+
+# add the time column required by openvibe csv reader
+aPad<-cbind(matrix(data=seq(1,nExamples),ncol=1),a);
+bPad<-cbind(matrix(data=seq(1,nExamples),ncol=1),b);
+
+write.table(aPad,file="class1.csv",row.names=FALSE,sep=",");
+write.table(bPad,file="class2.csv",row.names=FALSE,sep=",");
+
+a<-a%*%r;
+b<-b%*%r;
+
+aPad<-cbind(matrix(data=seq(1,nExamples),ncol=1),a);
+bPad<-cbind(matrix(data=seq(1,nExamples),ncol=1),b);
+
+write.table(aPad,file="class1rot.csv",row.names=FALSE,sep=",");
+write.table(bPad,file="class2rot.csv",row.names=FALSE,sep=",");
+

Masterarbeit/openvibe/extras-master/plugins/processing/classification/test/test_accuracy.cpp

@@ -0,0 +1,58 @@
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <iostream>
+#include <cstring>
+#include <cstdlib>
+#include <cerrno>
+
+double threshold = 72;
+
+int main(int argc, char** argv)
+{
+	if (argc != 2 && argc != 3)
+	{
+		std::cout << "Usage: test_accuracy <filename> <threshold>\n";
+		return 3;
+	}
+	if (argc == 3) { threshold = atof(argv[2]); }
+
+	std::ifstream file(argv[1], std::ios::in);
+
+	if (file.good() && !file.bad() && file.is_open()) // ...
+	{
+		std::string line;
+		while (getline(file, line))
+		{
+			size_t pos;
+			if ((pos = line.find("Cross-validation")) != std::string::npos)
+			{
+				std::string cutline = line.substr(pos);
+				pos                 = cutline.find("is") + 3;//We need to cut the coloration
+				cutline             = cutline.substr(pos);
+
+				pos = cutline.find('%');
+
+				cutline = cutline.substr(0, pos);
+				std::stringstream ss(cutline);
+
+				double percentage;
+				ss >> percentage;
+
+				if (percentage < threshold)
+				{
+					std::cout << "Accuracy too low ( " << percentage << " % )" << std::endl;
+					return 1;
+				}
+				std::cout << "Test ok ( " << percentage << " % )" << std::endl;
+				return 0;
+			}
+		}
+		std::cout << "Error: EOF of log file reached without finding the cross-validation accuracy string.\n";
+		return 4;
+	}
+	std::cout << "Error: Problem opening [" << argv[1] << "]\n";
+	std::cerr << "Error: Code is " << strerror(errno) << "\n";
+	return 5;
+	//return 2; // shouldn't happen
+}