From 3e42a9074c29ef77ed245b70e007e147ebbd1487 Mon Sep 17 00:00:00 2001 From: Arthur Desbois Date: Mon, 19 Apr 2021 15:33:28 +0200 Subject: [PATCH] Added Graph Laplacian box Graph Laplacian + Denoising computation from Connectivity Matrices --- .../connectivity/graphLaplacian.cpp | 253 ++++++++++++++++++ .../algorithms/connectivity/graphLaplacian.h | 77 ++++++ .../CBoxAlgorithmGraphLaplacian.cpp | 110 ++++++++ .../CBoxAlgorithmGraphLaplacian.h | 109 ++++++++ .../signal-processing/src/ovp_defines.h | 5 + .../signal-processing/src/ovp_main.cpp | 16 +- 6 files changed, 569 insertions(+), 1 deletion(-) create mode 100644 plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.cpp create mode 100644 plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.h create mode 100644 plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.cpp create mode 100644 plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.h diff --git a/plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.cpp b/plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.cpp new file mode 100644 index 000000000..8926f7c49 --- /dev/null +++ b/plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.cpp @@ -0,0 +1,253 @@ +#include "graphLaplacian.h" +#include +#include +#include +#include +#include + +bool GraphLaplacian::initialize(EGraphLaplacianDenoisingType denoisingType, size_t denoisingSize, bool denoising, bool debugLogs, EGraphLaplacianOutputType outputType) +{ + m_denoisingSize = denoisingSize; + m_denoising = denoising; + m_debugLogs = debugLogs; + + m_outputType = outputType; + m_denoisingType = denoisingType; + + return true; +} + + +bool GraphLaplacian::process(const OpenViBE::IMatrix& in, OpenViBE::IMatrix& out) +{ + // in matrix : A (freq x N x N) + // GraphLaplacian computation (for each frequency) : Lf = Deg(Af) - Af + // with Deg(Af) = diag(sum_rows(Af)) + + // Conversion from OpenViBE's IMatrix of 3 dimensions (fftsize x nchan x nchan) + // to std:vector (vect of fftsize x (nChan x nChan) ) + std::vector< Eigen::Matrix > laplacianMatrices(in.getDimensionSize(0), Eigen::MatrixXd(in.getDimensionSize(1),in.getDimensionSize(2))); + std::vector< Eigen::Matrix > adjacencyMatrices(in.getDimensionSize(0), Eigen::MatrixXd(in.getDimensionSize(1),in.getDimensionSize(2))); + + size_t fftSize = in.getDimensionSize(0); + size_t nbChan = in.getDimensionSize(1); + + const double* inbuffer = in.getBuffer(); + for (size_t fftIdx = 0; fftIdx < fftSize; ++fftIdx) { + for (size_t chan0 = 0; chan0 < nbChan; ++chan0) { + for (size_t chan1 = 0; chan1 < nbChan; ++chan1) { + // inverted sign to put (-A) in (L = D - A) + laplacianMatrices[fftIdx](chan0, chan1) = -inbuffer[fftIdx*nbChan*nbChan + chan0*nbChan + chan1]; + } + } + } + + if(m_debugLogs) { + std::cout << "GraphLaplacian : process() this matrix (freq0) : " << std::endl; + for (size_t chan0 = 0; chan0 < nbChan; ++chan0) { + std::cout << -laplacianMatrices[0].row(chan0) << std::endl; + } + std::cout << std::endl; + } + + // Degree matrix and laplacian computation + for(size_t fftIdx = 0; fftIdx < fftSize; ++fftIdx) { + for (size_t rowIdx = 0; rowIdx < nbChan; ++rowIdx) { + double deg = 0.0; + // sum of the row values + for(size_t colIdx = 0; colIdx < nbChan; ++colIdx) { + deg += laplacianMatrices[fftIdx](rowIdx, colIdx); + } + // degree value in the diagonal (inverted sign since we already inverted before) + laplacianMatrices[fftIdx](rowIdx, rowIdx) = -deg; + } + } + + if(m_debugLogs) { + std::cout << "GraphLaplacian matrix for freq0 (pre denoising) :" << std::endl; + for (size_t chan0 = 0; chan0 < nbChan; ++chan0) { + std::cout << laplacianMatrices[0].row(chan0) << std::endl; + } + std::cout << std::endl; + } + + // At this point, the GraphLaplacian matrix L=D-A is fully computed. + // Now, depending on the parameters, we can perform "denoising" by manipulating the eigenvectors & eigenvalues + + if(m_denoising) { + // /!\ we assume the connectivity/adjacency matrix is symmetric and self adjoint. + // Its eigenvalues/vectors are real valued. + + Eigen::SelfAdjointEigenSolver esright(laplacianMatrices[0].rows()); + Eigen::SelfAdjointEigenSolver esleft(laplacianMatrices[0].cols()); + + for(size_t fftIdx = 0; fftIdx < fftSize; ++fftIdx) { + + // compute the eigenValues and RIGHT eigenVectors of GraphLaplacian Matrix for freq fftIdx + // right eigenvectors are V as A.V = V.D (with D = diag(eigenvalues)) (=> A = V.D.V(-1)) + esright.compute(laplacianMatrices[fftIdx]); + + // compute the eigenValues and LEFT eigenVectors of GraphLaplacian Matrix for freq fftIdx + // left eigenvectors are W as W'.A = D.W' (with D = diag(eigenvalues)) (=> A = W'(-1).D.W') + esleft.compute(laplacianMatrices[fftIdx].transpose()); + + Eigen::MatrixXd D = esright.eigenvalues().asDiagonal(); + Eigen::MatrixXd V = esright.eigenvectors(); + Eigen::MatrixXd W = esleft.eigenvectors(); + + size_t nbEigen = V.rows(); + + // When using SelfAdjointEigenSolver, the eigenvalues (and associated vectors) are + // already sorted from smallest to largest value. + + if(m_debugLogs && fftIdx == 0) { + + std::cout << "GraphLaplacian : eigenvalues of the GraphLaplacian (freq0) : " << std::endl; + for (size_t idx = 0; idx < nbEigen; ++idx) { + std::cout << D.row(idx) << std::endl; + } + std::cout << std::endl; + + std::cout << "GraphLaplacian : eigenvectors of the GraphLaplacian (freq0) : " << std::endl; + for (size_t idx = 0; idx < nbEigen; ++idx) { + std::cout << V.row(idx) << std::endl; + } + std::cout << std::endl; + } + + // "Filter" the eigenvectors & values + Eigen::MatrixXd Dfilt; + Eigen::MatrixXd Vfilt; + Eigen::MatrixXd Wfilt; + + switch(m_denoisingType) { + + case EGraphLaplacianDenoisingType::LowPass : + // We keep the m_L first columns of V, W, and L first eigenvalues in D + {size_t L = std::min(m_denoisingSize, nbEigen); + Dfilt = D.block(0, 0, L, L); + Vfilt = V.block(0, 0, V.rows(), L); + Wfilt = W.block(0, 0, W.rows(), L);} + break; + + case EGraphLaplacianDenoisingType::MidCut : + // We CUT the m_M "mid" columns of V, W, and m_M "mid" eigenvalues in D + if(m_denoisingSize < nbEigen) { + size_t nbCols = nbEigen - m_denoisingSize; + size_t nbColsLeft = (size_t)(nbCols/2); + size_t nbColsRight = nbCols - nbColsRight; + Dfilt = Eigen::MatrixXd::Zero(nbCols,nbCols); + Vfilt.resize(V.rows(), nbCols); + Wfilt.resize(W.rows(), nbCols); + size_t idxColNew = 0; + for(size_t idxCol = 0; idxCol < nbColsLeft; idxCol++) { + Dfilt(idxColNew,idxColNew) = D(idxCol,idxCol); + Vfilt.col(idxColNew) = V.col(idxCol); + Wfilt.col(idxColNew++) = W.col(idxCol); + } + + for(size_t idxCol = V.cols()-nbColsRight; idxCol < V.cols(); idxCol++) { + Dfilt(idxColNew,idxColNew) = D(idxCol,idxCol); + Vfilt.col(idxColNew) = V.col(idxCol); + Wfilt.col(idxColNew++) = W.col(idxCol); + } + } else { + // Everything is cut...! + // TODO : error message ? + Dfilt = Eigen::MatrixXd(0,0); + Vfilt = Eigen::MatrixXd(0,0); + Wfilt = Eigen::MatrixXd(0,0); + } + break; + + case EGraphLaplacianDenoisingType::HighPass : + // We keep the m_H last columns of V, W, and m_H last eigenvalues in D + {size_t H = std::min(m_denoisingSize, nbEigen); + size_t idxStart = nbEigen-H; + Dfilt = D.block(idxStart, idxStart, H, H); + Vfilt = V.block(0, idxStart, V.rows(), H); + Wfilt = W.block(0, idxStart, W.rows(), H);} + break; + + default: + // Do something if parameter values (L/M/H) conflict with eigen sizes? + break; + } + + // Reconstruct the laplacian matrix L = W.D.V' + laplacianMatrices[fftIdx] = Wfilt * Dfilt * Vfilt.transpose(); + + // Reconstruct the adjacency matrix A = -(L-D) + if(m_outputType == EGraphLaplacianOutputType::AdjacencyMatrix) { + for(size_t idxRow = 0; idxRow < laplacianMatrices[fftIdx].rows(); idxRow++) { + for(size_t idxCol = 0; idxCol < laplacianMatrices[fftIdx].cols(); idxCol++) { + adjacencyMatrices[fftIdx](idxRow,idxCol) = - (laplacianMatrices[fftIdx](idxRow,idxCol)); + } + } + for(size_t idxRow = 0; idxRow < adjacencyMatrices[fftIdx].rows(); idxRow++) { + adjacencyMatrices[fftIdx](idxRow,idxRow) = 0.0; + } + } + + } + + if(m_debugLogs) { + std::cout << "GraphLaplacian matrix for freq0 (reconstructed post denoising) :" << std::endl; + for (size_t idx = 0; idx < laplacianMatrices[0].rows(); ++idx) { + std::cout << laplacianMatrices[0].row(idx) << std::endl; + } + std::cout << std::endl; + } + + } + + // Output : GraphLaplacian or Adjacency + // Conversion from eigen format to IMatrix format + // freq x N x N x 2 (real/imag) + + if (out.getDimensionCount() != 3 + || out.getDimensionSize(0) != fftSize + || out.getDimensionSize(1) != nbChan + || out.getDimensionSize(2) != nbChan) + { + out.setDimensionCount(3); + out.setDimensionSize(0, fftSize); + out.setDimensionSize(1, nbChan); + out.setDimensionSize(2, nbChan); + } + + double* outbuffer = out.getBuffer(); + size_t outidx = 0; + + if(m_outputType == EGraphLaplacianOutputType::GraphLaplacianMatrix) { + + for (size_t fftIdx = 0; fftIdx < fftSize; ++fftIdx) { + for (size_t chan0 = 0; chan0 < nbChan; ++chan0) { + for (size_t chan1 = 0; chan1 < nbChan; ++chan1) { + outbuffer[outidx++] = laplacianMatrices[fftIdx](chan0, chan1); + } + } + } + + } else { + if(m_denoising) { + for (size_t fftIdx = 0; fftIdx < fftSize; ++fftIdx) { + for (size_t chan0 = 0; chan0 < nbChan; ++chan0) { + for (size_t chan1 = 0; chan1 < nbChan; ++chan1) { + outbuffer[outidx++] = adjacencyMatrices[fftIdx](chan0, chan1); + } + } + } + } else { + // output = input but you computed lots of things that will not be used. + // why would you do this ? + // TODO : warning ? + for (size_t inIdx = 0; inIdx < in.getBufferElementCount(); ++inIdx) { + outbuffer[outidx++] = inbuffer[inIdx]; + } + } + + } + + return true; +} diff --git a/plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.h b/plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.h new file mode 100644 index 000000000..454f7d984 --- /dev/null +++ b/plugins/processing/signal-processing/src/algorithms/connectivity/graphLaplacian.h @@ -0,0 +1,77 @@ +///------------------------------------------------------------------------------------------------- +/// +/// \file graphLaplacian.hpp +/// \brief Graph Laplacian & denoising for BCI connectivity. +/// \author Arthur Desbois (Inria). +/// \version 1.0 +/// \date 28 Jan 2021 +/// \copyright GNU Affero General Public License v3.0. +/// \remarks +///------------------------------------------------------------------------------------------------- + +#pragma once +#include +#include +#include + +enum class EGraphLaplacianOutputType +{ + GraphLaplacianMatrix, + AdjacencyMatrix +}; + +/// Convert GraphLaplacian output to string. +/// Output type. +/// std::string +inline std::string toString(const EGraphLaplacianOutputType type) +{ + switch (type) + { + case EGraphLaplacianOutputType::GraphLaplacianMatrix: return "GraphLaplacian Matrix"; + case EGraphLaplacianOutputType::AdjacencyMatrix: return "Adjacency Matrix"; + } +} + +enum class EGraphLaplacianDenoisingType +{ + LowPass, + MidCut, + HighPass +}; + +/// Convert GraphLaplacian denoising type to string. +/// Denoising type. +/// std::string +inline std::string toString(const EGraphLaplacianDenoisingType type) +{ + switch (type) + { + case EGraphLaplacianDenoisingType::LowPass: return "Low Pass (lowest eigenvalues)"; + case EGraphLaplacianDenoisingType::MidCut: return "Mid cut (lowest & highest eigenvalues)"; + case EGraphLaplacianDenoisingType::HighPass: return "High Pass (highest eigenvalues)"; + } +} + +class GraphLaplacian +{ +public: + GraphLaplacian() {}; + ~GraphLaplacian() {}; + + bool initialize(EGraphLaplacianDenoisingType denoisingType, size_t denoisingSize, bool denoising, bool debugLogs, EGraphLaplacianOutputType outputType); + + bool process(const OpenViBE::IMatrix& in, OpenViBE::IMatrix& out); + +private: + + size_t m_denoisingSize = 0; + bool m_denoising = false; + + EGraphLaplacianOutputType m_outputType = EGraphLaplacianOutputType::GraphLaplacianMatrix; + EGraphLaplacianDenoisingType m_denoisingType = EGraphLaplacianDenoisingType::LowPass; + + bool m_debugLogs = false; + +}; + + diff --git a/plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.cpp b/plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.cpp new file mode 100644 index 000000000..1f5faa522 --- /dev/null +++ b/plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.cpp @@ -0,0 +1,110 @@ +#include "CBoxAlgorithmGraphLaplacian.h" + +using namespace OpenViBE; +using namespace /*OpenViBE::*/Kernel; +using namespace /*OpenViBE::*/Plugins; +using namespace /*OpenViBE::Plugins::*/SignalProcessing; + +bool CBoxAlgorithmGraphLaplacian::initialize() +{ + m_i0MatrixCodec.initialize(*this, 0); + m_o0MatrixCodec.initialize(*this, 0); + + m_iMatrix = m_i0MatrixCodec.getOutputMatrix(); + m_oMatrix = m_o0MatrixCodec.getInputMatrix(); + + // Settings + m_outputType = EGraphLaplacianOutputType(uint64_t(FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 0))); + m_denoisingType = EGraphLaplacianDenoisingType(uint64_t(FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 1))); + m_denoisingSize = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 2); + m_denoising = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 3); + m_debugLogs = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 4); + + laplacian.initialize(m_denoisingType, m_denoisingSize, m_denoising, m_debugLogs, m_outputType); + + if(m_denoising) { + if(m_denoisingSize <= 0) OV_ERROR_KRF("L, M, H must be positive", Kernel::ErrorType::BadInput); + if( m_denoisingType == EGraphLaplacianDenoisingType::MidCut ) OV_ERROR_KRF("Mid-cut not yet available", Kernel::ErrorType::BadInput); + } + + return true; +} +/*******************************************************************************/ + +bool CBoxAlgorithmGraphLaplacian::uninitialize() +{ + m_i0MatrixCodec.uninitialize(); + m_o0MatrixCodec.uninitialize(); + return true; +} + +bool CBoxAlgorithmGraphLaplacian::processInput(const size_t ) +{ + getBoxAlgorithmContext()->markAlgorithmAsReadyToProcess(); + return true; +} + +/*******************************************************************************/ + + +bool CBoxAlgorithmGraphLaplacian::process() +{ + const IBox& staticBoxContext=this->getStaticBoxContext(); + IBoxIO& boxContext = this->getDynamicBoxContext(); + + for (size_t i = 0; i < boxContext.getInputChunkCount(0); ++i) + { + m_i0MatrixCodec.decode(i); + + const uint64_t tStart = boxContext.getInputChunkStartTime(0, i); // Time Code Chunk Start + const uint64_t tEnd = boxContext.getInputChunkEndTime(0, i); // Time Code Chunk End + + if(m_i0MatrixCodec.isHeaderReceived()) {// Header received. This happens only once when pressing "play". + + IMatrix* matrix = m_i0MatrixCodec.getOutputMatrix(); // the StreamedMatrix of samples. + + // OUTPUT MATRIX INIT + m_oMatrix->setDimensionCount(matrix->getDimensionCount()); + m_oMatrix->setDimensionSize(0, matrix->getDimensionSize(0)); // frequencies + m_oMatrix->setDimensionSize(1, matrix->getDimensionSize(1)); // channels + m_oMatrix->setDimensionSize(2, matrix->getDimensionSize(2)); // channels + Toolkit::Matrix::clearContent(*m_oMatrix); + + m_o0MatrixCodec.encodeHeader(); // Pass the header to the next boxes + + if(m_debugLogs) { + this->getLogManager() << LogLevel_Info << "Header buffer processed\n"; + } + + + } + else if(m_i0MatrixCodec.isBufferReceived()) { + + IMatrix* matrix = m_i0MatrixCodec.getOutputMatrix(); // the StreamedMatrix of samples. + + if(m_debugLogs) { + this->getLogManager() << LogLevel_Info << "Matrix received : " << matrix->getDimensionSize(0) << "x" << matrix->getDimensionSize(1) << "x" << matrix->getDimensionSize(2) << "\n"; + } + + OV_ERROR_UNLESS_KRF(laplacian.process(*matrix, *m_oMatrix), "GraphLaplacian error", ErrorType::BadProcessing); + + if(m_debugLogs) { + this->getLogManager() << LogLevel_Info << "GraphLaplacian computed : " << m_oMatrix->getDimensionSize(0) << "x" << m_oMatrix->getDimensionSize(1) << "x" << m_oMatrix->getDimensionSize(2) << "\n"; + } + + m_o0MatrixCodec.encodeBuffer(); + + + } + else if(m_i0MatrixCodec.isEndReceived()) { + m_o0MatrixCodec.encodeEnd(); + } + + // send the output chunk. The dates are the same as the input chunk + boxContext.markOutputAsReadyToSend(0, tStart, tEnd); + + } + + return true; +} + diff --git a/plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.h b/plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.h new file mode 100644 index 000000000..4de579960 --- /dev/null +++ b/plugins/processing/signal-processing/src/box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.h @@ -0,0 +1,109 @@ +///------------------------------------------------------------------------------------------------- +/// +/// \file CBoxAlgorithmGraphLaplacian.h +/// \brief Classes of the Box GraphLaplacian +/// \author Arthur DESBOIS (INRIA). +/// \version 0.0.1. +/// \date Thu Jan 28 16:18:49 2021. +/// \copyright GNU Affero General Public License v3.0. +/// +///------------------------------------------------------------------------------------------------- +#pragma once + +#include "ovp_defines.h" + +#include +#include +#include +#include "graphLaplacian.h" + + +#define OV_AttributeId_Box_FlagIsUnstable OpenViBE::CIdentifier(0x666FFFFF, 0x666FFFFF) + +namespace OpenViBE +{ + namespace Plugins + { + namespace SignalProcessing + { + /// The class CBoxAlgorithmGraphLaplacian describes the box. + class CBoxAlgorithmGraphLaplacian final : virtual public Toolkit::TBoxAlgorithm + { + public: + void release() override { delete this; } + + bool initialize() override; + bool uninitialize() override; + + bool processInput(const size_t index) override; + bool process() override; + + // As we do with any class in openvibe, we use the macro below to associate this box to an unique identifier. + // The inheritance information is also made available, as we provide the superclass Toolkit::TBoxAlgorithm < IBoxAlgorithm > + _IsDerivedFromClass_Final_(Toolkit::TBoxAlgorithm, OVP_ClassId_BoxAlgorithm_GraphLaplacian) + + protected: + + // Algo class instance + GraphLaplacian laplacian; + + // Codecs + Toolkit::TStreamedMatrixDecoder m_i0MatrixCodec; + Toolkit::TStreamedMatrixEncoder m_o0MatrixCodec; + + // Matrices + IMatrix* m_iMatrix = nullptr; // Input Matrix pointer + IMatrix* m_oMatrix = nullptr; // Output Matrix pointer + + // Settings + EGraphLaplacianOutputType m_outputType = EGraphLaplacianOutputType::GraphLaplacianMatrix; + EGraphLaplacianDenoisingType m_denoisingType = EGraphLaplacianDenoisingType::LowPass; + size_t m_denoisingSize = 0; + + bool m_denoising = false; // enabling/disabling denoising TODO : Keep ? + + bool m_debugLogs = false; + + Kernel::ELogLevel m_logLevel = Kernel::LogLevel_Info; + }; + + /// Descriptor of the box GraphLaplacian. + class CBoxAlgorithmGraphLaplacianDesc final : virtual public IBoxAlgorithmDesc + { + public: + + void release() override { } + + CString getName() const override { return CString("GraphLaplacian"); } + CString getAuthorName() const override { return CString("Arthur DESBOIS"); } + CString getAuthorCompanyName() const override { return CString("INRIA"); } + CString getShortDescription() const override { return CString("GraphLaplacian / denoising for BCI connectivity"); } + CString getDetailedDescription() const override { return CString("Computes laplacian & denoising process"); } + CString getCategory() const override { return CString("Signal processing/Connectivity"); } + CString getVersion() const override { return CString("0.0.1"); } + CString getStockItemName() const override { return CString("gtk-zoom-out"); } + + CIdentifier getCreatedClass() const override { return OVP_ClassId_BoxAlgorithm_GraphLaplacian; } + IPluginObject* create() override { return new CBoxAlgorithmGraphLaplacian; } + + bool getBoxPrototype(Kernel::IBoxProto& prototype) const override + { + prototype.addInput("Input matrix",OV_TypeId_StreamedMatrix); + prototype.addOutput("Output matrix",OV_TypeId_StreamedMatrix); + + prototype.addSetting("Output Type", OV_TypeId_GraphLaplacian_OutputType, toString(EGraphLaplacianOutputType::GraphLaplacianMatrix).c_str()); + prototype.addSetting("Denoising Type", OV_TypeId_GraphLaplacian_DenoisingType, toString(EGraphLaplacianDenoisingType::LowPass).c_str()); + prototype.addSetting("Denoising Size",OV_TypeId_Integer, "0"); + prototype.addSetting("Denoising activated",OV_TypeId_Boolean,"false"); + + prototype.addSetting("DEBUG LOGS",OV_TypeId_Boolean,"false"); + + prototype.addFlag(OV_AttributeId_Box_FlagIsUnstable); + + return true; + } + _IsDerivedFromClass_Final_(IBoxAlgorithmDesc, OVP_ClassId_BoxAlgorithm_GraphLaplacianDesc) + }; + } // namespace SignalProcessing + } // namespace Plugins +} // namespace OpenViBE diff --git a/plugins/processing/signal-processing/src/ovp_defines.h b/plugins/processing/signal-processing/src/ovp_defines.h index e2e45757f..4d0281196 100755 --- a/plugins/processing/signal-processing/src/ovp_defines.h +++ b/plugins/processing/signal-processing/src/ovp_defines.h @@ -58,6 +58,8 @@ #define OVP_ClassId_BoxAlgorithm_IFFTboxDesc OpenViBE::CIdentifier(0xD533E997, 0x4AFD2423) #define OVP_ClassId_BoxAlgorithm_Matrix3dTo2d OpenViBE::CIdentifier(0x3ab2b81e, 0x73ef01a5) #define OVP_ClassId_BoxAlgorithm_Matrix3dTo2dDesc OpenViBE::CIdentifier(0xb9099590, 0xae33d758) +#define OVP_ClassId_BoxAlgorithm_GraphLaplacian OpenViBE::CIdentifier(0x35202ffc, 0xa6a312cc) +#define OVP_ClassId_BoxAlgorithm_GraphLaplacianDesc OpenViBE::CIdentifier(0x58b723d7, 0xfb32fdf7) // Type definitions //--------------------------------------------------------------------------------------------------- @@ -155,4 +157,7 @@ enum class EWaveletLevel { L1, L2, L3, L4, L5 }; #define OVP_TypeId_Connectivity_Metric OpenViBE::CIdentifier(0x9188339d, 0x5da83a84) #define OV_TypeId_ConnectivityMeasure_WindowMethod OpenViBE::CIdentifier(0x8815bfa7, 0x557b102f) +#define OV_TypeId_GraphLaplacian_OutputType OpenViBE::CIdentifier(0x8f5633a5, 0x6cc7f6e9) +#define OV_TypeId_GraphLaplacian_DenoisingType OpenViBE::CIdentifier(0xbe346f0b, 0xe0ee4117) + #define OV_AttributeId_Box_FlagIsUnstable OpenViBE::CIdentifier(0x666FFFFF, 0x666FFFFF) diff --git a/plugins/processing/signal-processing/src/ovp_main.cpp b/plugins/processing/signal-processing/src/ovp_main.cpp index 12d8bd202..8ad813570 100755 --- a/plugins/processing/signal-processing/src/ovp_main.cpp +++ b/plugins/processing/signal-processing/src/ovp_main.cpp @@ -28,6 +28,8 @@ #include "box-algorithms/CBoxAlgorithmMatrix3dTo2d.hpp" +#include "box-algorithms/connectivity/CBoxAlgorithmGraphLaplacian.h" + namespace OpenViBE { namespace Plugins { namespace SignalProcessing { @@ -39,8 +41,9 @@ OVP_Declare_Begin() //OVP_Declare_New(CBoxAlgorithmNullDesc) OVP_Declare_New(CBoxAlgorithmERSPAverageDesc) OVP_Declare_New(CBoxAlgorithmQuadraticFormDesc) - OVP_Declare_New(CEpochVarianceDesc); + OVP_Declare_New(CEpochVarianceDesc) OVP_Declare_New(CBoxAlgorithmMatrix3dTo2dDesc) + OVP_Declare_New(CBoxAlgorithmGraphLaplacianDesc) #if defined TARGET_HAS_ThirdPartyEIGEN OVP_Declare_New(CBoxAlgorithmARCoefficientsDesc); @@ -159,6 +162,17 @@ OVP_Declare_Begin() context.getTypeManager().registerEnumerationEntry(OVP_TypeId_Connectivity_Metric, toString(EConnectMetric::MagnitudeSquaredCoherence).c_str(), size_t(EConnectMetric::MagnitudeSquaredCoherence)); context.getTypeManager().registerEnumerationEntry(OVP_TypeId_Connectivity_Metric, toString(EConnectMetric::ImaginaryCoherence).c_str(), size_t(EConnectMetric::ImaginaryCoherence)); context.getTypeManager().registerEnumerationEntry(OVP_TypeId_Connectivity_Metric, toString(EConnectMetric::AbsImaginaryCoherence).c_str(), size_t(EConnectMetric::AbsImaginaryCoherence)); + + context.getTypeManager().registerEnumerationType(OV_TypeId_GraphLaplacian_OutputType, "Output Type"); + context.getTypeManager().registerEnumerationEntry(OV_TypeId_GraphLaplacian_OutputType, toString(EGraphLaplacianOutputType::GraphLaplacianMatrix).c_str(), size_t(EGraphLaplacianOutputType::GraphLaplacianMatrix)); + context.getTypeManager().registerEnumerationEntry(OV_TypeId_GraphLaplacian_OutputType, toString(EGraphLaplacianOutputType::AdjacencyMatrix).c_str(), size_t(EGraphLaplacianOutputType::AdjacencyMatrix)); + + context.getTypeManager().registerEnumerationType(OV_TypeId_GraphLaplacian_DenoisingType, "Denoising Type"); + context.getTypeManager().registerEnumerationEntry(OV_TypeId_GraphLaplacian_DenoisingType, toString(EGraphLaplacianDenoisingType::LowPass).c_str(), size_t(EGraphLaplacianDenoisingType::LowPass)); + context.getTypeManager().registerEnumerationEntry(OV_TypeId_GraphLaplacian_DenoisingType, toString(EGraphLaplacianDenoisingType::MidCut).c_str(), size_t(EGraphLaplacianDenoisingType::MidCut)); + context.getTypeManager().registerEnumerationEntry(OV_TypeId_GraphLaplacian_DenoisingType, toString(EGraphLaplacianDenoisingType::HighPass).c_str(), size_t(EGraphLaplacianDenoisingType::HighPass)); + + #endif OVP_Declare_End() -- GitLab