rtfiffrawview.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "rtfiffrawview.h"
 
#include "helpers/rtfiffrawviewdelegate.h"
#include "helpers/rtfiffrawviewmodel.h"
 
#include <dsp/filterkernel.h>
#include <fiff/fiff_info.h>
#include <fiff/fiff_explain.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QGridLayout>
#include <QHeaderView>
#include <QTableView>
#include <QMenu>
#include <QSvgGenerator>
#include <QSettings>
#include <QScrollBar>
#include <QMouseEvent>
#include <QRhiWidget>
 
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace DISPLIB;
using namespace FIFFLIB;
using namespace Eigen;
using namespace RTPROCESSINGLIB;
using namespace UTILSLIB;
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
RtFiffRawView::RtFiffRawView(const QString& sSettingsPath,
                             QWidget* parent,
                             Qt::WindowFlags f)
: AbstractView(parent, f)
, m_iT(10)
, m_fSamplingRate(1024)
, m_fZoomFactor(1.0f)
, m_bHideBadChannels(false)
, m_iDistanceTimeSpacer(1)
, m_iClickPosX(0)
, m_bCrosshairEnabled(false)
{
    m_sSettingsPath = sSettingsPath;
    m_pTableView = new QTableView;
    updateViewport();
 
    // Set layout
    QVBoxLayout* neLayout = new QVBoxLayout(this);
    neLayout->addWidget(m_pTableView);
    neLayout->setContentsMargins(0, 0, 0, 0);
    this->setLayout(neLayout);
 
    loadSettings();
}
 
//=============================================================================================================
 
RtFiffRawView::~RtFiffRawView()
{
    saveSettings();
}
 
//=============================================================================================================
 
void RtFiffRawView::updateViewport()
{
    if (m_pTableView) {
        auto* rhiViewport = new QRhiWidget;
#if defined(WASMBUILD) || defined(__EMSCRIPTEN__)
        rhiViewport->setApi(QRhiWidget::Api::OpenGL);
#elif defined(Q_OS_MACOS) || defined(Q_OS_IOS)
        rhiViewport->setApi(QRhiWidget::Api::Metal);
#elif defined(Q_OS_WIN)
        rhiViewport->setApi(QRhiWidget::Api::Direct3D11);
#else
        rhiViewport->setApi(QRhiWidget::Api::OpenGL);
#endif
        m_pTableView->setViewport(rhiViewport);
 
        // Mouse moves drive the crosshair
        rhiViewport->installEventFilter(this);
        rhiViewport->setMouseTracking(true);
    }
}
 
//=============================================================================================================
 
void RtFiffRawView::setSettingsPath(const QString& sSettingsPath)
{
    m_sSettingsPath = sSettingsPath;
    loadSettings();
}
 
//=============================================================================================================
 
void RtFiffRawView::init(QSharedPointer<FIFFLIB::FiffInfo>& info)
{
    m_pFiffInfo = info;
    m_fSamplingRate = m_pFiffInfo->sfreq;
 
    //Init the model
    m_pModel = new RtFiffRawViewModel(this);
    m_pModel->setFiffInfo(m_pFiffInfo);
    m_pModel->setSamplingInfo(m_fSamplingRate, m_iT, true);
    connect(m_pModel.data(), &RtFiffRawViewModel::triggerDetected,
            this, &RtFiffRawView::triggerDetected);
    connect(this, &RtFiffRawView::addSampleAsEvent,
            m_pModel, &RtFiffRawViewModel::addEvent, Qt::UniqueConnection);
 
    //Init bad channel list
    m_qListBadChannels.clear();
    for (int i = 0; i < m_pModel->rowCount(); i++) {
        if (m_pModel->data(m_pModel->index(i, 2)).toBool()) {
            m_qListBadChannels << i;
        }
    }
 
    //Init the delegate
    m_pDelegate = new RtFiffRawViewDelegate(this);
    m_pDelegate->initPainterPaths(m_pModel);
 
    connect(this, &RtFiffRawView::markerMoved,
            m_pDelegate.data(), &RtFiffRawViewDelegate::markerMoved);
 
    //Init the view
    m_pTableView->setModel(m_pModel);
    m_pTableView->setItemDelegate(m_pDelegate);
    m_pTableView->setContextMenuPolicy(Qt::CustomContextMenu);
 
    connect(m_pTableView.data(), &QTableView::doubleClicked,
            m_pModel.data(), &RtFiffRawViewModel::toggleFreeze);
 
    connect(m_pTableView.data(), &QTableView::customContextMenuRequested,
            this, &RtFiffRawView::channelContextMenu);
 
    //set some size settings for m_pTableView
    m_pTableView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_pTableView->setShowGrid(false);
    m_pTableView->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch); //Stretch 2 column to maximal width
    m_pTableView->horizontalHeader()->hide();
    m_pTableView->verticalHeader()->setDefaultSectionSize(m_pTableView->height() / m_fZoomFactor); //Row Height
    m_pTableView->setAutoScroll(false);
    m_pTableView->setColumnHidden(0, true); //because content is plotted jointly with column=1
    m_pTableView->setColumnHidden(2, true);
    m_pTableView->resizeColumnsToContents();
    m_pTableView->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
    connect(m_pTableView->verticalScrollBar(), &QScrollBar::valueChanged,
            this, &RtFiffRawView::visibleRowsChanged);
}
 
//=============================================================================================================
 
void RtFiffRawView::addData(const QList<Eigen::MatrixXd>& lMatData)
{
    if (!lMatData.isEmpty()) {
        m_pModel->addData(lMatData);
 
        if (m_qListBadChannels.size() != m_pFiffInfo->bads.size()) {
            m_qListBadChannels.clear();
            for (int i = 0; i < m_pModel->rowCount(); i++) {
                if (m_pModel->data(m_pModel->index(i, 2)).toBool()) {
                    m_qListBadChannels << i;
                }
            }
 
            //Hide non selected channels/rows in the lMatData views
            for (int i = 0; i < m_qListBadChannels.size(); i++) {
                if (m_bHideBadChannels) {
                    m_pTableView->hideRow(m_qListBadChannels.at(i));
                } else {
                    m_pTableView->showRow(m_qListBadChannels.at(i));
                }
            }
 
            //The set of visible rows changed, so the row height has to follow
            updateRowHeight();
        }
    } else {
        qWarning() << "[RtFiffRawView::addData] Received lMatData list is empty.";
    }
}
 
//=============================================================================================================
 
MatrixXd RtFiffRawView::getLastBlock()
{
    return m_pModel->getLastBlock();
}
 
//=============================================================================================================
 
bool RtFiffRawView::eventFilter(QObject* object, QEvent* event)
{
    if (m_bCrosshairEnabled && m_pModel && object == m_pTableView->viewport()) {
        if (event->type() == QEvent::MouseMove) {
            updateCrosshair(static_cast<QMouseEvent*>(event)->position().toPoint());
        } else if (event->type() == QEvent::Leave) {
            emit markerMoved(QPoint(), -1);
            m_pTableView->viewport()->update();
        }
    }
 
    return QWidget::eventFilter(object, event);
}
 
//=============================================================================================================
 
void RtFiffRawView::setCrosshairEnabled(bool enabled)
{
    m_bCrosshairEnabled = enabled;
 
    if (!enabled) {
        emit markerMoved(QPoint(), -1);
        m_pTableView->viewport()->update();
    }
}
 
//=============================================================================================================
 
bool RtFiffRawView::crosshairEnabled() const
{
    return m_bCrosshairEnabled;
}
 
//=============================================================================================================
 
int RtFiffRawView::columnAt(int iX) const
{
    const double dDx = static_cast<double>(m_pTableView->columnWidth(1)) / static_cast<double>(m_pModel->getMaxSamples());
 
    return static_cast<int>((iX - m_pTableView->columnViewportPosition(1)) / dDx);
}
 
//=============================================================================================================
 
void RtFiffRawView::updateCrosshair(const QPoint& position)
{
    const int iRow = m_pTableView->rowAt(position.y());
    emit markerMoved(position, iRow);
    m_pTableView->viewport()->update();
 
    const int iColumn = columnAt(position.x());
    const int iSample = m_pModel->getSampleAtColumn(iColumn);
    if (iRow < 0 || iSample < 0) {
        return;
    }
 
    // "NA" for unitless channels, as MNE-Python labels them
    const QString unit = FiffExplain::unit(m_pModel->getUnit(iRow));
    emit cursorDataChanged(static_cast<float>(iSample / static_cast<double>(m_fSamplingRate)),
                           static_cast<float>(m_pModel->getValueAtColumn(iRow, iColumn)),
                           m_pModel->data(m_pModel->index(iRow, 0)).toString(),
                           unit.isEmpty() ? QStringLiteral("NA") : unit);
}
 
//=============================================================================================================
 
void RtFiffRawView::setBackgroundColor(const QColor& backgroundColor)
{
    m_backgroundColor = backgroundColor;
 
    if (m_pModel) {
        m_pModel->setBackgroundColor(m_backgroundColor);
    }
 
    //    QPalette pal;
    //    pal.setColor(QPalette::Window, m_backgroundColor);
    //    m_pTableView->viewport()->setPalette(pal);
    //    m_pTableView->viewport()->setBackgroundRole(QPalette::Window);
}
 
//=============================================================================================================
 
QColor RtFiffRawView::getBackgroundColor()
{
    return m_backgroundColor;
}
 
//=============================================================================================================
 
QMap<qint32, float> RtFiffRawView::getScalingMap()
{
    return m_qMapChScaling;
}
 
//=============================================================================================================
 
void RtFiffRawView::setScalingMap(const QMap<qint32, float>& scaleMap)
{
    m_qMapChScaling = scaleMap;
    m_pModel->setScaling(scaleMap);
}
 
//=============================================================================================================
 
void RtFiffRawView::setSignalColor(const QColor& signalColor)
{
    m_pDelegate->setSignalColor(signalColor);
}
 
//=============================================================================================================
 
QColor RtFiffRawView::getSignalColor()
{
    return m_pDelegate->getSignalColor();
}
 
//=============================================================================================================
 
void RtFiffRawView::hideBadChannels()
{
    if (m_bHideBadChannels) {
        m_bHideBadChannels = false;
    } else {
        m_bHideBadChannels = true;
    }
 
    //Hide non selected channels/rows in the data views
    for (int i = 0; i < m_qListBadChannels.size(); i++) {
        if (m_bHideBadChannels) {
            m_pTableView->hideRow(m_qListBadChannels.at(i));
        } else {
            m_pTableView->showRow(m_qListBadChannels.at(i));
        }
    }
 
    //The rows that remain have to share the freed space
    updateRowHeight();
 
    //Update the visible channel list which are to be filtered
    visibleRowsChanged();
}
 
//=============================================================================================================
 
void RtFiffRawView::updateRowHeight()
{
    if (!m_pTableView || !m_pModel) {
        return;
    }
 
    //
    // The row height is derived from the height of the whole view, so it has to
    // be recomputed whenever rows appear or disappear. Otherwise hiding a
    // channel leaves the remaining rows at their previous height and the view
    // no longer fills the widget.
    //
    int iVisibleRows = 0;
    for (int i = 0; i < m_pModel->rowCount(); ++i) {
        if (!m_pTableView->isRowHidden(i)) {
            ++iVisibleRows;
        }
    }
 
    if (iVisibleRows <= 0) {
        return;
    }
 
    const int iHeight = static_cast<int>(static_cast<float>(m_pTableView->height() * m_pModel->rowCount()) / (static_cast<float>(iVisibleRows) * m_fZoomFactor));
 
    m_pTableView->verticalHeader()->setDefaultSectionSize(iHeight);
}
 
//=============================================================================================================
 
bool RtFiffRawView::getBadChannelHideStatus()
{
    return m_bHideBadChannels;
}
 
//=============================================================================================================
 
void RtFiffRawView::showSelectedChannelsOnly(const QStringList& selectedChannels)
{
    m_slSelectedChannels = selectedChannels;
 
    //Hide non selected channels/rows in the data views
    for (int i = 0; i < m_pModel->rowCount(); i++) {
        QString channel = m_pModel->data(m_pModel->index(i, 0), Qt::DisplayRole).toString();
 
        //if channel is a bad channel and bad channels are to be hidden -> do not show
        if (!selectedChannels.contains(channel) || (m_qListBadChannels.contains(i) && m_bHideBadChannels)) {
            m_pTableView->hideRow(i);
        } else {
            m_pTableView->showRow(i);
        }
    }
 
    //The rows that remain have to share the freed space
    updateRowHeight();
 
    //Update the visible channel list which are to be filtered
    visibleRowsChanged();
}
 
//=============================================================================================================
 
void RtFiffRawView::setZoom(double zoomFac)
{
    m_fZoomFactor = zoomFac;
 
    updateRowHeight();
}
 
//=============================================================================================================
 
double RtFiffRawView::getZoom()
{
    return m_fZoomFactor;
}
 
//=============================================================================================================
 
void RtFiffRawView::setWindowSize(int T)
{
    m_iT = T;
 
    m_pModel->setSamplingInfo(m_fSamplingRate, T);
}
 
//=============================================================================================================
 
int RtFiffRawView::getWindowSize()
{
    return m_iT;
}
 
//=============================================================================================================
 
float RtFiffRawView::getSamplingFreq() const
{
    return m_fSamplingRate;
}
 
//=============================================================================================================
 
void RtFiffRawView::takeScreenshot(const QString& fileName)
{
    // m_pTableView is a QPointer and is only created once a model has been set.
    // Taking a screenshot before that, or after the view was destroyed, would
    // otherwise dereference a null pointer.
    if (m_pTableView.isNull()) {
        qWarning() << "[RtFiffRawView::takeScreenshot] No data view available yet"
                   << "- no screenshot was taken.";
        return;
    }
 
    if (fileName.contains(".svg", Qt::CaseInsensitive)) {
        // Generate screenshot
        QSvgGenerator svgGen;
        svgGen.setFileName(fileName);
        svgGen.setSize(m_pTableView->size());
        svgGen.setViewBox(m_pTableView->rect());
 
        m_pTableView->render(&svgGen);
    }
 
    if (fileName.contains(".png", Qt::CaseInsensitive)) {
        QPixmap pixMap(m_pTableView->grab());
        pixMap.save(fileName);
    }
}
 
//=============================================================================================================
 
void RtFiffRawView::updateProjection(const QList<FIFFLIB::FiffProj>& projs)
{
    m_pModel->updateProjection(projs);
}
 
//=============================================================================================================
 
void RtFiffRawView::updateCompensator(int to)
{
    m_pModel->updateCompensator(to);
}
 
//=============================================================================================================
 
void RtFiffRawView::updateSpharaActivation(bool state)
{
    m_pModel->updateSpharaActivation(state);
}
 
//=============================================================================================================
 
void RtFiffRawView::updateSpharaOptions(const QString& sSytemType, int nBaseFctsFirst, int nBaseFctsSecond)
{
    m_pModel->updateSpharaOptions(sSytemType, nBaseFctsFirst, nBaseFctsSecond);
}
 
//=============================================================================================================
 
void RtFiffRawView::setFilter(const FilterKernel& filterData)
{
    m_pModel->setFilter(QList<FilterKernel>() << filterData);
}
 
//=============================================================================================================
 
void RtFiffRawView::setFilterActive(bool state)
{
    m_pModel->setFilterActive(state);
}
 
//=============================================================================================================
 
void RtFiffRawView::setFilterChannelType(const QString& channelType)
{
    m_pModel->setFilterChannelType(channelType);
}
 
//=============================================================================================================
 
void RtFiffRawView::triggerInfoChanged(const QMap<double, QColor>& colorMap,
                                       bool active,
                                       const QString& triggerCh,
                                       double threshold)
{
    m_pModel->triggerInfoChanged(colorMap, active, triggerCh, threshold);
}
 
//=============================================================================================================
 
void RtFiffRawView::setDistanceTimeSpacer(int value)
{
    m_iDistanceTimeSpacer = value;
    m_pModel->distanceTimeSpacerChanged(value);
}
 
//=============================================================================================================
 
int RtFiffRawView::getDistanceTimeSpacer()
{
    return m_iDistanceTimeSpacer;
}
 
//=============================================================================================================
 
void RtFiffRawView::resetTriggerCounter()
{
    m_pModel->resetTriggerCounter();
}
 
//=============================================================================================================
 
void RtFiffRawView::saveSettings()
{
    if (m_sSettingsPath.isEmpty()) {
        return;
    }
 
    QSettings settings("MNECPP");
}
 
//=============================================================================================================
 
void RtFiffRawView::loadSettings()
{
    if (m_sSettingsPath.isEmpty()) {
        return;
    }
 
    QSettings settings("MNECPP");
}
 
//=============================================================================================================
 
void RtFiffRawView::updateGuiMode(GuiMode mode)
{
    switch (mode) {
        case GuiMode::Clinical:
            break;
        default: // default is research mode
            break;
    }
}
 
//=============================================================================================================
 
void RtFiffRawView::updateProcessingMode(ProcessingMode mode)
{
    switch (mode) {
        case ProcessingMode::Offline:
            break;
        default: // default is realtime mode
            break;
    }
}
 
//=============================================================================================================
 
void RtFiffRawView::channelContextMenu(QPoint pos)
{
    m_iClickPosX = pos.x();
 
    //obtain index where index was clicked
    QModelIndex index = m_pTableView->indexAt(pos);
 
    //get selected items
    QModelIndexList selected = m_pTableView->selectionModel()->selectedIndexes();
 
    //create custom context menu and actions
    QMenu* menu = new QMenu(this);
    menu->setAttribute(Qt::WA_DeleteOnClose);
 
    menu->addSection("Events");
 
    QAction* addEventMarker = menu->addAction(tr("Add event"));
    connect(addEventMarker, &QAction::triggered,
            this, &RtFiffRawView::onAddEvent);
 
    //Marking
 
    menu->addSection("Channel Marking");
 
    if (!m_qListBadChannels.contains(index.row())) {
        QAction* doMarkChBad = menu->addAction(tr("Mark as bad"));
        connect(doMarkChBad, &QAction::triggered,
                this, &RtFiffRawView::markChBad);
    } else {
        QAction* doMarkChGood = menu->addAction(tr("Mark as good"));
        connect(doMarkChGood, &QAction::triggered,
                this, &RtFiffRawView::markChBad);
    }
 
    // non C++11 alternative
    m_qListCurrentSelection.clear();
    for (qint32 i = 0; i < selected.size(); ++i)
        if (selected[i].column() == 1)
            m_qListCurrentSelection.append(m_pModel->getIdxSelMap()[selected[i].row()]);
 
    menu->addSection("Selection");
 
    QAction* doSelection = menu->addAction(tr("Only show selection"));
    connect(doSelection, &QAction::triggered,
            this, &RtFiffRawView::applySelection);
 
    //select channels
    QAction* hideSelection = menu->addAction(tr("Hide selection"));
    connect(hideSelection, &QAction::triggered, this,
            &RtFiffRawView::hideSelection);
 
    //undo selection
    QAction* resetAppliedSelection = menu->addAction(tr("Reset selection"));
    connect(resetAppliedSelection, &QAction::triggered,
            m_pModel.data(), &RtFiffRawViewModel::resetSelection);
    connect(resetAppliedSelection, &QAction::triggered,
            this, &RtFiffRawView::resetSelection);
 
    //show context menu
    menu->popup(m_pTableView->viewport()->mapToGlobal(pos));
}
 
//=============================================================================================================
 
void RtFiffRawView::applySelection()
{
    //Hide non selected channels/rows in the data views
    for (int i = 0; i < m_pModel->rowCount(); i++) {
        //if channel is a bad channel and bad channels are to be hidden -> do not show
        if (m_qListCurrentSelection.contains(i)) {
            m_pTableView->showRow(i);
        } else {
            m_pTableView->hideRow(i);
        }
    }
 
    //Update the visible channel list which are to be filtered
    //visibleRowsChanged();
 
    //m_pModel->selectRows(m_qListCurrentSelection);
}
 
//=============================================================================================================
 
void RtFiffRawView::hideSelection()
{
    for (int i = 0; i < m_qListCurrentSelection.size(); i++) {
        m_pTableView->hideRow(m_qListCurrentSelection.at(i));
    }
 
    //Update the visible channel list which are to be filtered
    //visibleRowsChanged();
}
 
//=============================================================================================================
 
void RtFiffRawView::resetSelection()
{
    for (qint32 i = 0; i < m_pFiffInfo->chs.size(); ++i) {
        if (m_qListBadChannels.contains(i)) {
            if (!m_bHideBadChannels) {
                m_pTableView->showRow(i);
            }
        } else {
            m_pTableView->showRow(i);
        }
    }
}
 
//=============================================================================================================
 
void RtFiffRawView::visibleRowsChanged()
{
    if (!m_pTableView || !m_pModel || !m_pDelegate) {
        return;
    }
 
    m_pDelegate->setUpperItemIndex(m_pTableView->rowAt(0));
}
 
//=============================================================================================================
 
void RtFiffRawView::markChBad()
{
    QModelIndexList selected = m_pTableView->selectionModel()->selectedIndexes();
 
    for (int i = 0; i < selected.size(); i++) {
        if (m_qListBadChannels.contains(selected[i].row())) { //mark as good
            m_pModel->markChBad(selected[i], false);
            m_qListBadChannels.removeAll(selected[i].row());
        } else {
            m_pModel->markChBad(selected[i], true);
            m_qListBadChannels.append(selected[i].row());
        }
    }
 
    m_pModel->updateProjection(m_pFiffInfo->projs);
 
    //Hide non selected channels/rows in the data views
    for (int i = 0; i < m_qListBadChannels.size(); i++) {
        if (m_bHideBadChannels) {
            m_pTableView->hideRow(m_qListBadChannels.at(i));
        } else {
            m_pTableView->showRow(m_qListBadChannels.at(i));
        }
    }
 
    emit channelMarkingChanged();
}
 
//=============================================================================================================
 
void RtFiffRawView::clearView()
{
}
 
//=============================================================================================================
 
void RtFiffRawView::onAddEvent(bool bChecked)
{
    Q_UNUSED(bChecked)
 
    // No events on the blank space before the first sweep has filled the window
    const int iSample = m_pModel->getSampleAtColumn(columnAt(m_iClickPosX));
    if (iSample >= 0) {
        emit addSampleAsEvent(iSample);
    }
}