averagelayoutview.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "averagelayoutview.h"
 
#include "helpers/averagescene.h"
#include "helpers/evokedsetmodel.h"
#include "helpers/channelinfomodel.h"
#include "helpers/averagesceneitem.h"
#include "helpers/selectionsceneitem.h"
 
#include <fiff/fiff_info.h>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QLabel>
#include <QVBoxLayout>
#include <QGraphicsView>
#include <QSvgGenerator>
#include <QDebug>
#include <QGraphicsItem>
#include <QSettings>
#include <QRhiWidget>
 
 
//=============================================================================================================
// USED NAMESPACES
//=============================================================================================================
 
using namespace DISPLIB;
using namespace FIFFLIB;
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
AverageLayoutView::AverageLayoutView(const QString& sSettingsPath,
                                     QWidget* parent,
                                     Qt::WindowFlags f)
: AbstractView(parent, f)
, m_qMapAverageColor(QSharedPointer<QMap<QString, QColor>>::create())
, m_qMapAverageActivation(QSharedPointer<QMap<QString, bool>>::create())
{
    m_sSettingsPath = sSettingsPath;
    this->setWindowTitle("Average Layout");
 
    m_pAverageLayoutView = new QGraphicsView();
 
    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_pAverageLayoutView->setViewport(rhiViewport);
 
    m_pAverageLayoutView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    m_pAverageLayoutView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
    m_pAverageScene = AverageScene::SPtr(new AverageScene(m_pAverageLayoutView.data(), this));
    m_pAverageScene->setBackgroundBrush(QBrush(Qt::white));
 
    m_pAverageLayoutView->setScene(m_pAverageScene.data());
 
    //set layouts
    QVBoxLayout* neLayout = new QVBoxLayout(this);
    neLayout->setContentsMargins(0, 0, 0, 0);
    neLayout->addWidget(m_pAverageLayoutView);
    this->setLayout(neLayout);
    loadSettings();
}
 
//=============================================================================================================
 
AverageLayoutView::~AverageLayoutView()
{
    saveSettings();
}
 
//=============================================================================================================
 
void AverageLayoutView::updateViewport()
{
    if (m_pAverageLayoutView) {
        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_pAverageLayoutView->setViewport(rhiViewport);
    }
}
 
//=============================================================================================================
 
void AverageLayoutView::setChannelInfoModel(QSharedPointer<ChannelInfoModel>& pChannelInfoModel)
{
    m_pChannelInfoModel = pChannelInfoModel;
}
 
//=============================================================================================================
 
void AverageLayoutView::setEvokedSetModel(QSharedPointer<EvokedSetModel> pEvokedSetModel)
{
    if (pEvokedSetModel) {
        connect(pEvokedSetModel.data(), &EvokedSetModel::dataChanged,
                this, &AverageLayoutView::updateData, Qt::UniqueConnection);
    }
 
    m_pEvokedSetModel = pEvokedSetModel;
}
 
//=============================================================================================================
 
void AverageLayoutView::setBackgroundColor(const QColor& backgroundColor)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::setBackgroundColor - m_pAverageScene is NULL. Returning. ";
        return;
    }
 
    QBrush backgroundBrush = m_pAverageScene->backgroundBrush();
    backgroundBrush.setColor(backgroundColor);
    m_pAverageScene->setBackgroundBrush(backgroundBrush);
}
 
//=============================================================================================================
 
QColor AverageLayoutView::getBackgroundColor()
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::getBackgroundColor - m_pAverageScene is NULL. Returning. ";
        return QColor();
    }
 
    return m_pAverageScene->backgroundBrush().color();
}
 
//=============================================================================================================
 
void AverageLayoutView::takeScreenshot(const QString& fileName)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::takeScreenshot - m_pAverageScene is NULL. Returning. ";
        return;
    }
 
    if (fileName.contains(".svg", Qt::CaseInsensitive)) {
        // Generate screenshot
        QSvgGenerator svgGen;
        svgGen.setFileName(fileName);
        QRectF rect = m_pAverageScene->itemsBoundingRect();
        svgGen.setSize(QSize(rect.width(), rect.height()));
 
        QPainter painter(&svgGen);
        m_pAverageScene->render(&painter);
    }
 
    if (fileName.contains(".png", Qt::CaseInsensitive)) {
        QRect rect = m_pAverageLayoutView->frameRect();
        QPixmap pixMap = QWidget::grab(rect);
        pixMap.save(fileName);
    }
}
 
//=============================================================================================================
 
void AverageLayoutView::setScaleMap(const QMap<qint32, float>& scaleMap)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::setScaleMap - m_pAverageScene is NULL. Returning. ";
        return;
    }
 
    m_scaleMap = scaleMap;
 
    m_pAverageScene->setScaleMap(scaleMap);
 
    updateData();
}
 
//=============================================================================================================
 
QSharedPointer<QMap<QString, QColor>> AverageLayoutView::getAverageColor() const
{
    return m_qMapAverageColor;
}
 
//=============================================================================================================
 
QSharedPointer<QMap<QString, bool>> AverageLayoutView::getAverageActivation() const
{
    return m_qMapAverageActivation;
}
 
//=============================================================================================================
 
void AverageLayoutView::setAverageColor(const QSharedPointer<QMap<QString, QColor>> qMapAverageColor)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::setAverageColor - m_pAverageScene is NULL. Returning. ";
        return;
    }
 
    m_qMapAverageColor = qMapAverageColor;
    m_pAverageScene->setColorPerAverage(m_qMapAverageColor);
}
 
//=============================================================================================================
 
void AverageLayoutView::setSingleAverageColor(const QColor& avgColor)
{
    for (QString mapKey : m_qMapAverageColor->keys()) {
        m_qMapAverageColor->insert(mapKey, avgColor);
    }
 
    m_pAverageScene->setColorPerAverage(m_qMapAverageColor);
    m_pAverageScene->setSignalItemColor(avgColor);
}
 
//=============================================================================================================
 
void AverageLayoutView::setAverageActivation(const QSharedPointer<QMap<QString, bool>> qMapAverageActivation)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::setAverageActivation - m_pAverageScene is NULL. Returning. ";
        return;
    }
 
    m_qMapAverageActivation = qMapAverageActivation;
    m_pAverageScene->setActivationPerAverage(qMapAverageActivation);
}
 
//=============================================================================================================
 
void AverageLayoutView::channelSelectionManagerChanged(const QList<QGraphicsItem*>& selectedChannelItems)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::channelSelectionManagerChanged - m_pAverageScene is NULL. Returning. ";
        return;
    }
    //Repaint the average items in the average scene based on the input parameter selectedChannelItems and update them with current data
    m_pAverageScene->repaintItems(selectedChannelItems);
    setAverageColor(m_qMapAverageColor);
    setAverageActivation(m_qMapAverageActivation);
    setScaleMap(m_scaleMap);
    updateData();
}
 
//=============================================================================================================
 
void AverageLayoutView::channelSelectionChanged(const QVariant& selectionData)
{
    if (!m_pAverageScene) {
        qDebug() << "AverageLayoutView::channelSelectionManagerChanged - m_pAverageScene is NULL. Returning. ";
        return;
    }
 
    SelectionItem* pSelectionItem = selectionData.value<DISPLIB::SelectionItem*>();
 
    //Repaint the average items in the average scene based on the input parameter selectedChannelItems and update them with current selectionData
    m_pAverageScene->repaintSelectionItems(*pSelectionItem);
    setAverageColor(m_qMapAverageColor);
    setAverageActivation(m_qMapAverageActivation);
    setScaleMap(m_scaleMap);
    updateData();
}
 
//=============================================================================================================
 
void AverageLayoutView::updateData()
{
    if (m_pFiffInfo) {
        QList<QGraphicsItem*> currentAverageSceneItems = m_pAverageScene->items();
 
        //Set new data for all averageSceneItems
        for (int i = 0; i < currentAverageSceneItems.size(); i++) {
            AverageSceneItem* averageSceneItemTemp = static_cast<AverageSceneItem*>(currentAverageSceneItems.at(i));
 
            averageSceneItemTemp->m_lAverageData.clear();
 
            if (m_pEvokedSetModel) {
                //Get only the necessary data from the average model (use column 2)
                QList<QPair<QString, DISPLIB::RowVectorPair>> averageData = m_pEvokedSetModel->data(0, 2, EvokedSetModelRoles::GetAverageData).value<QList<QPair<QString, DISPLIB::RowVectorPair>>>();
 
                //Get the averageScenItem specific data row
                int channelNumber = averageSceneItemTemp->m_iChannelNumber;
 
                if (channelNumber != -1) {
                    averageSceneItemTemp->m_iChannelKind = m_pFiffInfo->chs.at(channelNumber).kind;
                    averageSceneItemTemp->m_iChannelUnit = m_pFiffInfo->chs.at(channelNumber).unit;
                    averageSceneItemTemp->m_firstLastSample.first = (-1) * m_pEvokedSetModel->getNumPreStimSamples();
 
                    if (!averageData.isEmpty()) {
                        averageSceneItemTemp->m_firstLastSample.second = averageData.first().second.second - m_pEvokedSetModel->getNumPreStimSamples();
                    }
 
                    averageSceneItemTemp->m_iTotalNumberChannels = m_pEvokedSetModel->rowCount();
                    averageSceneItemTemp->m_lAverageData = averageData;
                    averageSceneItemTemp->m_bIsBad = m_pEvokedSetModel->getIsChannelBad(channelNumber);
                }
            }
        }
 
        m_pAverageScene->updateScene();
        return;
    }
 
    if (!m_pAverageScene || !m_pEvokedSetModel || !m_pChannelInfoModel) {
        qDebug() << "AverageLayoutView::updateData - m_pAverageScene, m_pEvokedSetModel or m_pChannelInfoModel are NULL. Returning. ";
        return;
    }
    //Get current items from the average scene
    QList<QGraphicsItem*> currentAverageSceneItems = m_pAverageScene->items();
 
    //Set new data for all averageSceneItems
    for (int i = 0; i < currentAverageSceneItems.size(); i++) {
        AverageSceneItem* averageSceneItemTemp = static_cast<AverageSceneItem*>(currentAverageSceneItems.at(i));
 
        averageSceneItemTemp->m_lAverageData.clear();
 
        //Get only the necessary data from the average model (use column 2)
        QList<QPair<QString, DISPLIB::RowVectorPair>> averageData = m_pEvokedSetModel->data(0, 2, EvokedSetModelRoles::GetAverageData).value<QList<QPair<QString, DISPLIB::RowVectorPair>>>();
 
        //Get the averageScenItem specific data row
        int channelNumber = m_pChannelInfoModel->getIndexFromMappedChName(averageSceneItemTemp->m_sChannelName);
 
        if (channelNumber != -1) {
            //qDebug() << "Change data for" << channelNumber << "" << averageSceneItemTemp->m_sChannelName;
 
            averageSceneItemTemp->m_iChannelKind = m_pChannelInfoModel->data(m_pChannelInfoModel->index(channelNumber, 4), ChannelInfoModelRoles::GetChKind).toInt();
            averageSceneItemTemp->m_iChannelUnit = m_pChannelInfoModel->data(m_pChannelInfoModel->index(channelNumber, 6), ChannelInfoModelRoles::GetChUnit).toInt();
            averageSceneItemTemp->m_firstLastSample.first = (-1) * m_pEvokedSetModel->getNumPreStimSamples();
 
            if (!averageData.isEmpty()) {
                averageSceneItemTemp->m_firstLastSample.second = averageData.first().second.second - m_pEvokedSetModel->getNumPreStimSamples();
            }
 
            averageSceneItemTemp->m_iChannelNumber = channelNumber;
            averageSceneItemTemp->m_iTotalNumberChannels = m_pEvokedSetModel->rowCount();
            averageSceneItemTemp->m_lAverageData = averageData;
            averageSceneItemTemp->m_bIsBad = m_pEvokedSetModel->getIsChannelBad(channelNumber);
        }
    }
 
    m_pAverageScene->updateScene();
}
 
//=============================================================================================================
 
void AverageLayoutView::saveSettings()
{
    if (m_sSettingsPath.isEmpty()) {
        return;
    }
 
    QSettings settings("MNECPP");
}
 
//=============================================================================================================
 
void AverageLayoutView::loadSettings()
{
    if (m_sSettingsPath.isEmpty()) {
        return;
    }
 
    QSettings settings("MNECPP");
}
 
//=============================================================================================================
 
void AverageLayoutView::updateGuiMode(GuiMode mode)
{
    switch (mode) {
        case GuiMode::Clinical:
            break;
        default: // default is research mode
            break;
    }
}
 
//=============================================================================================================
 
void AverageLayoutView::updateProcessingMode(ProcessingMode mode)
{
    switch (mode) {
        case ProcessingMode::Offline:
            break;
        default: // default is realtime mode
            break;
    }
}
 
//=============================================================================================================
 
void AverageLayoutView::setFiffInfo(const QSharedPointer<FIFFLIB::FiffInfo> pFiffInfo)
{
    m_pFiffInfo = pFiffInfo;
}
 
//=============================================================================================================
 
QSharedPointer<EvokedSetModel> AverageLayoutView::getEvokedSetModel()
{
    return m_pEvokedSetModel;
}
 
//=============================================================================================================
 
void AverageLayoutView::clearView()
{
    setEvokedSetModel(Q_NULLPTR);
    updateData();
}