rtsensordatacontroller.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "rtsensordatacontroller.h"
#include "rtsensordataworker.h"
#include "rtsensorinterpolationmatworker.h"
 
#include <QThread>
#include <QTimer>
#include <QDebug>
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
RtSensorDataController::RtSensorDataController(QObject *parent)
    : QObject(parent)
{
    // Create data worker
    m_pWorker = new DISP3DLIB::RtSensorDataWorker();
 
    // Create and configure data thread
    m_pWorkerThread = new QThread(this);
    m_pWorker->moveToThread(m_pWorkerThread);
 
    // Clean up worker when thread finishes
    connect(m_pWorkerThread, &QThread::finished, m_pWorker, &QObject::deleteLater);
 
    // Forward worker signals to controller signals
    connect(m_pWorker, &DISP3DLIB::RtSensorDataWorker::newRtSensorColors,
            this, &RtSensorDataController::newSensorColorsAvailable);
    connect(m_pWorker, &DISP3DLIB::RtSensorDataWorker::newRtRawSensorData,
            this, &RtSensorDataController::newRawSensorDataAvailable);
 
    // Create timer for driving the streaming cadence
    m_pTimer = new QTimer(this);
    m_pTimer->setTimerType(Qt::PreciseTimer);
    connect(m_pTimer, &QTimer::timeout, m_pWorker, &DISP3DLIB::RtSensorDataWorker::streamData);
 
    // Start the data worker thread
    m_pWorkerThread->start();
 
    // Create interpolation matrix worker
    m_pInterpWorker = new DISP3DLIB::RtSensorInterpolationMatWorker();
    m_pInterpThread = new QThread(this);
    m_pInterpWorker->moveToThread(m_pInterpThread);
 
    connect(m_pInterpThread, &QThread::finished, m_pInterpWorker, &QObject::deleteLater);
 
    // Forward interpolation results: auto-apply to data worker + re-emit for external listeners
    connect(m_pInterpWorker, &DISP3DLIB::RtSensorInterpolationMatWorker::newMegMappingAvailable,
            this, &RtSensorDataController::onNewMegMapping);
    connect(m_pInterpWorker, &DISP3DLIB::RtSensorInterpolationMatWorker::newEegMappingAvailable,
            this, &RtSensorDataController::onNewEegMapping);
 
    m_pInterpThread->start();
 
    qDebug() << "RtSensorDataController: Initialized with" << m_iTimeInterval << "ms interval";
}
 
//=============================================================================================================
 
RtSensorDataController::~RtSensorDataController()
{
    // Stop timer
    if (m_pTimer) {
        m_pTimer->stop();
    }
 
    // Stop the data worker thread
    if (m_pWorkerThread) {
        m_pWorkerThread->quit();
        m_pWorkerThread->wait();
    }
 
    // Stop the interpolation worker thread
    if (m_pInterpThread) {
        m_pInterpThread->quit();
        m_pInterpThread->wait();
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::addData(const Eigen::VectorXf &data)
{
    if (m_pWorker) {
        // Direct call is thread-safe because RtSensorDataWorker uses a mutex
        m_pWorker->addData(data);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setMappingMatrix(std::shared_ptr<Eigen::MatrixXf> mat)
{
    if (m_pWorker) {
        m_pWorker->setMappingMatrix(mat);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setStreamingState(bool state)
{
    m_bIsStreaming = state;
 
    if (state) {
        m_pTimer->start(m_iTimeInterval);
        qDebug() << "RtSensorDataController: Streaming started at" << m_iTimeInterval << "ms interval";
    } else {
        m_pTimer->stop();
        qDebug() << "RtSensorDataController: Streaming stopped";
    }
}
 
//=============================================================================================================
 
bool RtSensorDataController::isStreaming() const
{
    return m_bIsStreaming;
}
 
//=============================================================================================================
 
void RtSensorDataController::setTimeInterval(int msec)
{
    m_iTimeInterval = qMax(1, msec);
 
    if (m_bIsStreaming) {
        m_pTimer->setInterval(m_iTimeInterval);
    }
 
    qDebug() << "RtSensorDataController: Time interval set to" << m_iTimeInterval << "ms";
}
 
//=============================================================================================================
 
void RtSensorDataController::setNumberAverages(int numAvr)
{
    if (m_pWorker) {
        m_pWorker->setNumberAverages(numAvr);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setColormapType(const QString &name)
{
    if (m_pWorker) {
        m_pWorker->setColormapType(name);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setThresholds(double min, double max)
{
    if (m_pWorker) {
        m_pWorker->setThresholds(min, max);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setLoopState(bool enabled)
{
    if (m_pWorker) {
        m_pWorker->setLoopState(enabled);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setSFreq(double sFreq)
{
    if (m_pWorker) {
        m_pWorker->setSFreq(sFreq);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::clearData()
{
    if (m_pWorker) {
        m_pWorker->clear();
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setStreamSmoothedData(bool bStreamSmoothedData)
{
    if (m_pWorker) {
        m_pWorker->setStreamSmoothedData(bStreamSmoothedData);
    }
}
 
//=============================================================================================================
// ── On-the-fly interpolation matrix computation ────────────────────────
//=============================================================================================================
 
void RtSensorDataController::setEvoked(const FIFFLIB::FiffEvoked &evoked)
{
    if (m_pInterpWorker) {
        m_pInterpWorker->setEvoked(evoked);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setTransform(const FIFFLIB::FiffCoordTrans &trans,
                                            bool applySensorTrans)
{
    if (m_pInterpWorker) {
        m_pInterpWorker->setTransform(trans, applySensorTrans);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setMegFieldMapOnHead(bool onHead)
{
    if (m_pInterpWorker) {
        m_pInterpWorker->setMegFieldMapOnHead(onHead);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setMegSurface(const QString &surfaceKey,
                                            const Eigen::MatrixX3f &vertices,
                                            const Eigen::MatrixX3f &normals,
                                            const Eigen::MatrixX3i &triangles)
{
    if (m_pInterpWorker) {
        m_pInterpWorker->setMegSurface(surfaceKey, vertices, normals, triangles);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setEegSurface(const QString &surfaceKey,
                                            const Eigen::MatrixX3f &vertices)
{
    if (m_pInterpWorker) {
        m_pInterpWorker->setEegSurface(surfaceKey, vertices);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::setBadChannels(const QStringList &bads)
{
    if (m_pInterpWorker) {
        m_pInterpWorker->setBadChannels(bads);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::recomputeMapping()
{
    if (m_pInterpWorker) {
        // Use QMetaObject::invokeMethod with queued connection to ensure
        // computeMapping() runs on the interpolation worker thread.
        QMetaObject::invokeMethod(m_pInterpWorker, "computeMapping", Qt::QueuedConnection);
    }
}
 
//=============================================================================================================
 
void RtSensorDataController::onNewMegMapping(const QString &surfaceKey,
                                               std::shared_ptr<Eigen::MatrixXf> mappingMat,
                                               const QVector<int> &pick)
{
    // Auto-forward the new matrix to the data worker
    if (m_pWorker && mappingMat) {
        m_pWorker->setMappingMatrix(mappingMat);
    }
 
    // Re-emit for external listeners (e.g. BrainView)
    emit newMegMappingAvailable(surfaceKey, mappingMat, pick);
 
    qDebug() << "RtSensorDataController: New MEG mapping received and forwarded"
             << "(" << mappingMat->rows() << "x" << mappingMat->cols() << ")";
}
 
//=============================================================================================================
 
void RtSensorDataController::onNewEegMapping(const QString &surfaceKey,
                                               std::shared_ptr<Eigen::MatrixXf> mappingMat,
                                               const QVector<int> &pick)
{
    // Auto-forward the new matrix to the data worker
    if (m_pWorker && mappingMat) {
        m_pWorker->setMappingMatrix(mappingMat);
    }
 
    // Re-emit for external listeners (e.g. BrainView)
    emit newEegMappingAvailable(surfaceKey, mappingMat, pick);
 
    qDebug() << "RtSensorDataController: New EEG mapping received and forwarded"
             << "(" << mappingMat->rows() << "x" << mappingMat->cols() << ")";
}