brainview.cpp

Go to the documentation of this file.

//=============================================================================================================
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
 
#include "brainview.h"
#include "brainrenderer.h"
#include "renderable/brainsurface.h"
#include "renderable/dipoleobject.h"
#include "renderable/networkobject.h"
#include "renderable/polylineobject.h"
#include "renderable/videooverlay.h"
#include "renderable/sliceobject.h"
#include "core/surfacekeys.h"
#include "core/dataloader.h"
#include "input/raypicker.h"
#include "geometry/meshfactory.h"
#include "model/braintreemodel.h"
#include "model/items/surfacetreeitem.h"
 
#include <rhi/qrhi.h>
#include "model/items/bemtreeitem.h"
#include "model/items/sensortreeitem.h"
#include "model/items/dipoletreeitem.h"
#include "model/items/sourcespacetreeitem.h"
#include "model/items/digitizertreeitem.h"
 
#include <Eigen/Dense>
#include <QMatrix4x4>
#include <QDebug>
#include <QLabel>
#include <QFrame>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QWheelEvent>
#include <QResizeEvent>
#include <QSettings>
#include <QTimer>
#include <QMenu>
#include <QStandardItem>
#include <QCoreApplication>
#include <QElapsedTimer>
#include <QDateTime>
#include <QDir>
#include <QFileInfo>
#include <algorithm>
#include <cmath>
 
#include <mne/mne_bem.h>
#include <mne/mne_source_spaces.h>
#include <fiff/fiff_evoked_set.h>
#include <fiff/fiff_constants.h>
#include <connectivity/network/network.h>
#include <connectivity/network/networknode.h>
#include <connectivity/network/networkedge.h>
 
using namespace FIFFLIB;
 
namespace DISP3DLIB
{
 
namespace
{
 
QColor itemColor(const AbstractTreeItem& item)
{
    QColor color = item.color();
    color.setAlphaF(color.alphaF() * item.alpha());
    return color;
}
 
} // namespace
 
// QSettings is constructed with its default ctor below; it picks up the
// organisation and application names that each host (mne_align,
// mne_inspect, ex_disp_3D, ...) sets on QCoreApplication in its main(),
// so persisted view state is naturally scoped per-application.
 
//=============================================================================================================
// DEFINE MEMBER METHODS
//=============================================================================================================
 
//=============================================================================================================
 
BrainView::BrainView(QWidget* parent)
: QRhiWidget(parent)
{
    setMinimumSize(800, 600);
    setSampleCount(1);
    setAutoRenderTarget(false); // We manage our own dual render targets
 
#if defined(WASMBUILD) || defined(__EMSCRIPTEN__)
    setApi(Api::OpenGL); // WebGL 2 (OpenGL ES 3.0) on WASM
#elif defined(Q_OS_MACOS) || defined(Q_OS_IOS)
    setApi(Api::Metal);
#elif defined(Q_OS_WIN)
    setApi(Api::Direct3D11);
#else
    setApi(Api::OpenGL);
#endif
 
    setMouseTracking(true); // Enable hover events
 
    // No periodic update timer — redraws are demand-driven via update().
    // Every setter that changes scene state calls m_sceneDirty = true
    // followed by update(), which coalesces into one render() per frame.
 
    m_fpsLabel = new QLabel(this);
    m_fpsLabel->setStyleSheet("color: white; font-weight: bold; font-family: monospace; font-size: 13px; background: transparent; padding: 5px;");
    m_fpsLabel->setAttribute(Qt::WA_TransparentForMouseEvents);
    m_fpsLabel->setAlignment(Qt::AlignRight | Qt::AlignTop);
    m_fpsLabel->setText("FPS: --.-\nVertices: 0");
    m_fpsLabel->adjustSize();
    m_fpsLabel->move(width() - m_fpsLabel->width() - 10, 10);
    m_fpsLabel->raise();
 
    m_singleViewInfoLabel = new QLabel(this);
    m_singleViewInfoLabel->setStyleSheet("color: white; font-family: monospace; font-size: 10px; background: rgba(0,0,0,110); border-radius: 3px; padding: 2px 4px;");
    m_singleViewInfoLabel->setAttribute(Qt::WA_TransparentForMouseEvents);
    m_singleViewInfoLabel->setAlignment(Qt::AlignLeft | Qt::AlignTop);
    m_singleViewInfoLabel->setText("");
    m_singleViewInfoLabel->adjustSize();
    m_singleViewInfoLabel->hide();
 
    m_fpsTimer.start();
 
    m_regionLabel = new QLabel(this);
    m_regionLabel->setStyleSheet("color: white; font-weight: bold; font-family: sans-serif; font-size: 16px; background: transparent; padding: 5px;");
    m_regionLabel->setText("");
    m_regionLabel->move(10, 10);
    m_regionLabel->resize(300, 30);
    m_regionLabel->hide();
 
    // ── Initialise viewport labels (sized to kDefaultViewportCount) ────────
    m_subViews.resize(kDefaultViewportCount);
    m_viewportNameLabels.resize(kDefaultViewportCount, nullptr);
    m_viewportInfoLabels.resize(kDefaultViewportCount, nullptr);
    for (int i = 0; i < kDefaultViewportCount; ++i) {
        m_subViews[i] = SubView::defaultForIndex(i);
 
        m_viewportNameLabels[i] = new QLabel(this);
        m_viewportNameLabels[i]->setStyleSheet("color: white; font-weight: bold; font-family: sans-serif; font-size: 12px; background: transparent; padding: 2px 4px;");
        m_viewportNameLabels[i]->setAttribute(Qt::WA_TransparentForMouseEvents);
        m_viewportNameLabels[i]->setText(multiViewPresetName(m_subViews[i].preset));
        m_viewportNameLabels[i]->adjustSize();
        m_viewportNameLabels[i]->hide();
 
        m_viewportInfoLabels[i] = new QLabel(this);
        m_viewportInfoLabels[i]->setStyleSheet("color: white; font-family: monospace; font-size: 10px; background: rgba(0,0,0,110); border-radius: 3px; padding: 2px 4px;");
        m_viewportInfoLabels[i]->setAttribute(Qt::WA_TransparentForMouseEvents);
        m_viewportInfoLabels[i]->setAlignment(Qt::AlignLeft | Qt::AlignTop);
        m_viewportInfoLabels[i]->setText("");
        m_viewportInfoLabels[i]->adjustSize();
        m_viewportInfoLabels[i]->hide();
    }
 
    m_verticalSeparator = new QFrame(this);
    m_verticalSeparator->setFrameShape(QFrame::NoFrame);
    m_verticalSeparator->setAttribute(Qt::WA_TransparentForMouseEvents);
    m_verticalSeparator->hide();
 
    m_horizontalSeparator = new QFrame(this);
    m_horizontalSeparator->setFrameShape(QFrame::NoFrame);
    m_horizontalSeparator->setAttribute(Qt::WA_TransparentForMouseEvents);
    m_horizontalSeparator->hide();
 
    QColor sepColor = palette().color(QPalette::Midlight);
    if (sepColor.alpha() == 255) {
        sepColor.setAlpha(180);
    }
    const QString sepStyle = QString("background-color: rgba(%1,%2,%3,%4);")
                                 .arg(sepColor.red())
                                 .arg(sepColor.green())
                                 .arg(sepColor.blue())
                                 .arg(sepColor.alpha());
    m_verticalSeparator->setStyleSheet(sepStyle);
    m_horizontalSeparator->setStyleSheet(sepStyle);
 
    loadMultiViewSettings();
    updateViewportSeparators();
    updateOverlayLayout();
 
    // Setup Debug Pointer: Semi-transparent sphere for subtle intersection indicator
    m_debugPointerSurface = MeshFactory::createSphere(QVector3D(0, 0, 0), 0.002f,
                                                      QColor(200, 255, 255, 160));
 
    // ── Connect SourceEstimateManager signals ─────────────────────────
    connect(&m_sourceManager, &SourceEstimateManager::loaded,
            this, &BrainView::onSourceEstimateLoaded);
    connect(&m_sourceManager, &SourceEstimateManager::thresholdsUpdated,
            this, &BrainView::sourceThresholdsUpdated);
    connect(&m_sourceManager, &SourceEstimateManager::timePointChanged,
            this, &BrainView::timePointChanged);
    connect(&m_sourceManager, &SourceEstimateManager::loadingProgress,
            this, &BrainView::stcLoadingProgress);
    connect(&m_sourceManager, &SourceEstimateManager::realtimeColorsAvailable,
            this, &BrainView::onRealtimeColorsAvailable);
 
    // RtSensorStreamManager → BrainView
    connect(&m_sensorStreamManager, &RtSensorStreamManager::colorsAvailable,
            this, &BrainView::onSensorStreamColorsAvailable);
 
    // Video overlay starts disabled with a default focus point near the
    // top of a typical FreeSurfer head; the application toggles it on.
    m_videoOverlay = std::make_unique<DISP3DLIB::VideoOverlay>();
}
 
//=============================================================================================================
 
BrainView::~BrainView()
{
    saveMultiViewSettings();
}
 
//=============================================================================================================
 
void BrainView::setModel(BrainTreeModel* model)
{
    if (model == m_model)
        return;
 
    if (m_model) {
        disconnect(m_model, nullptr, this, nullptr);
        for (auto it = m_itemSurfaceMap.cbegin(); it != m_itemSurfaceMap.cend(); ++it) {
            for (auto sit = m_surfaces.begin(); sit != m_surfaces.end();) {
                sit = (sit.value() == it.value()) ? m_surfaces.erase(sit) : std::next(sit);
            }
        }
        m_itemSurfaceMap.clear();
        m_itemDipoleMap.clear();
        m_hoveredItem = nullptr;
        m_activeSurface.reset();
    }
 
    m_model = model;
    if (!m_model) {
        updateSceneBounds();
        m_sceneDirty = true;
        update();
        return;
    }
    connect(m_model, &BrainTreeModel::rowsInserted, this, &BrainView::onRowsInserted);
    connect(m_model, &BrainTreeModel::dataChanged, this, &BrainView::onDataChanged);
 
    if (m_model->rowCount() > 0) {
        onRowsInserted(QModelIndex(), 0, m_model->rowCount() - 1);
    } else {
        updateSceneBounds();
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
void BrainView::setInitialCameraRotation(const QQuaternion& rotation)
{
    m_cameraRotation = rotation;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
void BrainView::onRowsInserted(const QModelIndex& parent, int first, int last)
{
    if (!m_model)
        return;
 
    for (int i = first; i <= last; ++i) {
        QModelIndex index = m_model->index(i, 0, parent);
        QStandardItem* item = m_model->itemFromIndex(index);
 
        AbstractTreeItem* absItem = dynamic_cast<AbstractTreeItem*>(item);
 
        // Handle FsSurface Items
        if (absItem && absItem->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::SurfaceItem)) {
            SurfaceTreeItem* surfItem = static_cast<SurfaceTreeItem*>(absItem);
            auto brainSurf = std::make_shared<BrainSurface>();
 
            // Load geometry from item
            brainSurf->fromSurface(surfItem->surfaceData());
 
            // Determine Hemisphere from Parent
            if (absItem->parent()) {
                QString parentText = absItem->parent()->text();
                if (parentText == "lh")
                    brainSurf->setHemi(0);
                else if (parentText == "rh")
                    brainSurf->setHemi(1);
            }
 
            // Set properties
            brainSurf->setVisible(surfItem->isVisible());
 
            // Brain surfaces (pial, white, inflated, etc.) are brain tissue
            brainSurf->setTissueType(BrainSurface::TissueBrain);
 
            m_itemSurfaceMap[item] = brainSurf;
 
            // Key generation: "hemi_type" e.g. "lh_pial"
            QString key;
            if (absItem->parent()) {
                key = absItem->parent()->text() + "_" + surfItem->text();
            } else {
                key = surfItem->text();
            }
            m_surfaces[key] = brainSurf;
 
            // Check for annotations
            if (!surfItem->annotationData().isEmpty()) {
                brainSurf->addAnnotation(surfItem->annotationData());
            }
 
            // Set active if first
            if (!m_activeSurface) {
                m_activeSurface = brainSurf;
                m_activeSurfaceType = surfItem->text();
            }
        }
        // Check for BEM Item (using dynamic_cast for safety)
        BemTreeItem* bemItem = dynamic_cast<BemTreeItem*>(absItem);
        if (bemItem) {
            const MNELIB::MNEBemSurface& bemSurfData = bemItem->bemSurfaceData();
 
            auto brainSurf = std::make_shared<BrainSurface>();
 
            // Load BEM geometry with color from item
            brainSurf->fromBemSurface(bemSurfData, itemColor(*bemItem));
 
            brainSurf->setVisible(bemItem->isVisible());
 
            // Set tissue type based on surface name
            QString surfName = bemItem->text().toLower();
            if (surfName.contains("head") || surfName.contains("skin") || surfName.contains("scalp")) {
                brainSurf->setTissueType(BrainSurface::TissueSkin);
            } else if (surfName.contains("outer") && surfName.contains("skull")) {
                brainSurf->setTissueType(BrainSurface::TissueOuterSkull);
            } else if (surfName.contains("inner") && surfName.contains("skull")) {
                brainSurf->setTissueType(BrainSurface::TissueInnerSkull);
            } else if (surfName.contains("skull")) {
                brainSurf->setTissueType(BrainSurface::TissueOuterSkull); // Default skull to outer
            } else if (surfName.contains("brain")) {
                brainSurf->setTissueType(BrainSurface::TissueBrain);
            }
 
            m_itemSurfaceMap[item] = brainSurf;
 
            // Legacy map support (Use item text e.g. "bem_head")
            m_surfaces["bem_" + bemItem->text()] = brainSurf;
        }
 
        // Handle Sensor Items
        if (absItem && absItem->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::SensorItem)) {
            SensorTreeItem* sensItem = static_cast<SensorTreeItem*>(absItem);
 
            std::shared_ptr<BrainSurface> brainSurf;
 
            QString parentText = "";
            if (sensItem->parent())
                parentText = sensItem->parent()->text();
 
            if (parentText.contains("MEG/Grad") && sensItem->hasOrientation()) {
                brainSurf = MeshFactory::createBarbell(sensItem->position(), sensItem->orientation(),
                                                       itemColor(*sensItem), sensItem->scale());
            } else if (parentText.contains("MEG/Mag") && sensItem->hasOrientation()) {
                brainSurf = MeshFactory::createPlate(sensItem->position(), sensItem->orientation(),
                                                     itemColor(*sensItem), sensItem->scale());
            } else {
                // EEG and other sensors: smooth icosphere
                brainSurf = MeshFactory::createSphere(sensItem->position(), sensItem->scale(),
                                                      itemColor(*sensItem));
            }
 
            brainSurf->setVisible(sensItem->isVisible());
            m_itemSurfaceMap[item] = brainSurf;
 
 
            // Legacy map support
            const QString keyPrefix = SURFACEKEYS::sensorParentToKeyPrefix(parentText);
 
            QString key = keyPrefix + sensItem->text() + "_" + QString::number((quintptr)sensItem);
            m_surfaces[key] = brainSurf;
        }
 
        // Handle Dipole Items
        if (absItem && absItem->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::DipoleItem)) {
            DipoleTreeItem* dipItem = static_cast<DipoleTreeItem*>(absItem);
            auto dipObject = std::make_shared<DipoleObject>();
            dipObject->load(dipItem->ecdSet());
            dipObject->setVisible(dipItem->isVisible());
            dipObject->applyTransform(itemTransform(item));
 
            m_itemDipoleMap[item] = dipObject;
        }
 
        // Handle Source Space Items (one item per hemisphere, batched mesh)
        if (absItem && absItem->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::SourceSpaceItem)) {
            SourceSpaceTreeItem* srcItem = static_cast<SourceSpaceTreeItem*>(absItem);
            const QVector<QVector3D>& positions = srcItem->positions();
            if (positions.isEmpty())
                continue;
 
            auto brainSurf = MeshFactory::createBatchedSpheres(positions, srcItem->scale(),
                                                               itemColor(*srcItem));
            brainSurf->setVisible(srcItem->isVisible());
            m_itemSurfaceMap[item] = brainSurf;
 
            QString key = "srcsp_" + srcItem->text();
            m_surfaces[key] = brainSurf;
        }
 
        // Handle Digitizer Items (batched sphere mesh per category)
        if (absItem && absItem->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::DigitizerItem)) {
            DigitizerTreeItem* digItem = static_cast<DigitizerTreeItem*>(absItem);
            const QVector<QVector3D>& positions = digItem->positions();
            if (positions.isEmpty())
                continue;
 
            auto brainSurf = MeshFactory::createBatchedSpheres(positions, digItem->scale(),
                                                               itemColor(*digItem));
            brainSurf->setVisible(digItem->isVisible());
 
            m_itemSurfaceMap[item] = brainSurf;
 
            // Category name for surface-map key.  A monotonic counter
            // suffix guarantees uniqueness so that multiple items of the
            // same PointKind each get their own entry in m_surfaces.
            // shouldRenderSurface() matches by prefix ("dig_cardinal",
            // "dig_hpi", …) so the suffix is transparent to visibility.
            static int s_digKeyCounter = 0;
            QString catName;
            switch (digItem->pointKind()) {
                case DigitizerTreeItem::Cardinal:
                    catName = "cardinal";
                    break;
                case DigitizerTreeItem::HPI:
                    catName = "hpi";
                    break;
                case DigitizerTreeItem::EEG:
                    catName = "eeg";
                    break;
                case DigitizerTreeItem::Extra:
                    catName = "extra";
                    break;
                default:
                    catName = digItem->text().toLower().replace(' ', '_');
                    break;
            }
            QString key = QStringLiteral("dig_%1_%2").arg(catName).arg(s_digKeyCounter++);
            m_surfaces[key] = brainSurf;
        }
 
        if (m_itemSurfaceMap.contains(item))
            m_itemSurfaceMap[item]->applyTransform(itemTransform(item));
 
        // Check children recursively
        if (m_model->hasChildren(index)) {
            onRowsInserted(index, 0, m_model->rowCount(index) - 1);
        }
    }
    updateInflatedSurfaceTransforms();
    updateSceneBounds();
    m_vertexCountDirty = true;
    m_sceneDirty = true;
    update();
}
 
void BrainView::onDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
{
    bool transformChanged = false;
    for (int i = topLeft.row(); i <= bottomRight.row(); ++i) {
        QModelIndex index = m_model->index(i, 0, topLeft.parent());
        QStandardItem* item = m_model->itemFromIndex(index);
 
        if (m_itemSurfaceMap.contains(item)) {
            auto surf = m_itemSurfaceMap[item];
 
            AbstractTreeItem* absItem = dynamic_cast<AbstractTreeItem*>(item);
            if (absItem) {
                if (roles.contains(AbstractTreeItem::VisibleRole)) {
                    surf->setVisible(absItem->isVisible());
                    m_vertexCountDirty = true;
                }
                if ((roles.contains(AbstractTreeItem::ColorRole) || roles.contains(AbstractTreeItem::AlphaRole)) && absItem->color().isValid()) {
                    surf->setColor(itemColor(*absItem));
                }
                if (roles.contains(AbstractTreeItem::TransformRole)) {
                    surf->applyTransform(itemTransform(item));
                    transformChanged = true;
                }
                if (roles.contains(SurfaceTreeItem::AnnotationDataRole)) {
                    SurfaceTreeItem* sItem = static_cast<SurfaceTreeItem*>(absItem);
                    if (!sItem->annotationData().isEmpty()) {
                        surf->addAnnotation(sItem->annotationData());
                    }
                }
            }
        }
 
        if (m_itemDipoleMap.contains(item)) {
            auto* absItem = dynamic_cast<AbstractTreeItem*>(item);
            if (absItem && roles.contains(AbstractTreeItem::VisibleRole))
                m_itemDipoleMap[item]->setVisible(absItem->isVisible());
            if (roles.contains(AbstractTreeItem::TransformRole))
                m_itemDipoleMap[item]->applyTransform(itemTransform(item));
        }
    }
    if (transformChanged) {
        updateInflatedSurfaceTransforms();
        m_vertexCountDirty = true;
    }
    updateSceneBounds();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setActiveSurface(const QString& type)
{
    subViewForTarget(m_visualizationEditTarget).surfaceType = type;
 
    m_activeSurfaceType = type;
 
    // Update m_activeSurface pointer to one of the matching surfaces for stats/helpers
    QString key = "lh_" + type;
    if (m_surfaces.contains(key))
        m_activeSurface = m_surfaces[key];
    else {
        key = "rh_" + type;
        if (m_surfaces.contains(key))
            m_activeSurface = m_surfaces[key];
    }
 
    updateInflatedSurfaceTransforms();
    saveMultiViewSettings();
 
    updateSceneBounds();
    m_vertexCountDirty = true;
    m_sceneDirty = true;
    update();
}
 
void BrainView::updateSceneBounds()
{
    QVector3D min(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
    QVector3D max(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());
    bool hasContent = false;
 
    // Iterate over all surfaces
    for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
        if (it.value()->isVisible()) {
            QVector3D sMin, sMax;
            it.value()->boundingBox(sMin, sMax);
 
            min.setX(std::min(min.x(), sMin.x()));
            min.setY(std::min(min.y(), sMin.y()));
            min.setZ(std::min(min.z(), sMin.z()));
 
            max.setX(std::max(max.x(), sMax.x()));
            max.setY(std::max(max.y(), sMax.y()));
            max.setZ(std::max(max.z(), sMax.z()));
            hasContent = true;
        }
    }
 
    for (auto it = m_itemDipoleMap.cbegin(); it != m_itemDipoleMap.cend(); ++it) {
        QVector3D dMin, dMax;
        if (it.value()->isVisible() && it.value()->boundingBox(dMin, dMax)) {
            min = QVector3D(std::min(min.x(), dMin.x()), std::min(min.y(), dMin.y()), std::min(min.z(), dMin.z()));
            max = QVector3D(std::max(max.x(), dMax.x()), std::max(max.y(), dMax.y()), std::max(max.z(), dMax.z()));
            hasContent = true;
        }
    }
 
    if (hasContent) {
        m_sceneCenter = (min + max) * 0.5f;
 
        QVector3D diag = max - min;
        m_sceneSize = std::max(diag.x(), std::max(diag.y(), diag.z()));
 
        // Ensure non-zero size
        if (m_sceneSize < 0.01f)
            m_sceneSize = 0.3f;
 
    } else {
        // Default
        m_sceneCenter = QVector3D(0, 0, 0);
        m_sceneSize = 0.3f;
    }
}
 
//=============================================================================================================
 
void BrainView::setShaderMode(const QString& modeName)
{
    const BrainRenderer::ShaderMode mode = shaderModeFromName(modeName);
    subViewForTarget(m_visualizationEditTarget).brainShader = mode;
 
    m_brainShaderMode = mode;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
    emit shaderModeChanged(shaderModeName(mode));
}
 
//=============================================================================================================
 
void BrainView::setVisualizationEditTarget(int target)
{
    const int prev = m_visualizationEditTarget;
    m_visualizationEditTarget = normalizedVisualizationTarget(target, static_cast<int>(m_subViews.size()) - 1);
 
    const SubView& sv = subViewForTarget(m_visualizationEditTarget);
    m_activeSurfaceType = sv.surfaceType;
    m_brainShaderMode = sv.brainShader;
    m_bemShaderMode = sv.bemShader;
    m_currentVisMode = sv.overlayMode;
    const ViewVisibilityProfile& visibility = sv.visibility;
 
    const bool remapMegSurface = (m_fieldMapper.megFieldMapOnHead() != visibility.megFieldMapOnHead);
    m_fieldMapper.setMegFieldMapOnHead(visibility.megFieldMapOnHead);
    m_dipolesVisible = visibility.dipoles;
    m_networkVisible = visibility.network;
 
    // Note: we intentionally do NOT call setVisualizationMode() on surfaces
    // here.  Each viewport's overlay mode is sent as a per-draw shader
    // uniform (sceneData.overlayMode), so the surface objects must keep
    // their vertex data intact — in particular the STC colour channel —
    // regardless of which viewport is currently selected for editing.
 
    if (m_fieldMapper.isLoaded()) {
        if (remapMegSurface) {
            m_fieldMapper.buildMapping(m_surfaces, m_headToMriTrans, m_applySensorTrans);
        }
        m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
    }
 
    // Update viewport label highlighting
    updateViewportLabelHighlight();
 
    saveMultiViewSettings();
 
    if (prev != m_visualizationEditTarget) {
        emit visualizationEditTargetChanged(m_visualizationEditTarget);
    }
}
 
//=============================================================================================================
 
int BrainView::visualizationEditTarget() const
{
    return m_visualizationEditTarget;
}
 
//=============================================================================================================
 
QString BrainView::activeSurfaceForTarget(int target) const
{
    return subViewForTarget(target).surfaceType;
}
 
//=============================================================================================================
 
QString BrainView::shaderModeForTarget(int target) const
{
    return shaderModeName(subViewForTarget(target).brainShader);
}
 
//=============================================================================================================
 
QString BrainView::bemShaderModeForTarget(int target) const
{
    return shaderModeName(subViewForTarget(target).bemShader);
}
 
//=============================================================================================================
 
QString BrainView::overlayModeForTarget(int target) const
{
    return visualizationModeName(subViewForTarget(target).overlayMode);
}
 
//=============================================================================================================
 
ViewVisibilityProfile& BrainView::visibilityProfileForTarget(int target)
{
    return subViewForTarget(target).visibility;
}
 
//=============================================================================================================
 
const ViewVisibilityProfile& BrainView::visibilityProfileForTarget(int target) const
{
    return subViewForTarget(target).visibility;
}
 
//=============================================================================================================
 
SubView& BrainView::subViewForTarget(int target)
{
    const int normalized = normalizedVisualizationTarget(target, static_cast<int>(m_subViews.size()) - 1);
    return (normalized < 0) ? m_singleView : m_subViews[normalized];
}
 
//=============================================================================================================
 
const SubView& BrainView::subViewForTarget(int target) const
{
    const int normalized = normalizedVisualizationTarget(target, static_cast<int>(m_subViews.size()) - 1);
    return (normalized < 0) ? m_singleView : m_subViews[normalized];
}
 
//=============================================================================================================
 
// Note: SubView::isBrainSurfaceKey, matchesSurfaceType, shouldRenderSurface,
// and applyOverlayToSurfaces are defined in core/viewstate.cpp.
 
//=============================================================================================================
 
bool BrainView::objectVisibleForTarget(const QString& object, int target) const
{
    return visibilityProfileForTarget(target).isObjectVisible(object);
}
 
//=============================================================================================================
 
bool BrainView::megFieldMapOnHeadForTarget(int target) const
{
    return visibilityProfileForTarget(target).megFieldMapOnHead;
}
 
//=============================================================================================================
 
void BrainView::updateInflatedSurfaceTransforms()
{
    const bool needsInflated = (m_singleView.surfaceType == "inflated") || std::any_of(m_subViews.cbegin(), m_subViews.cend(), [](const SubView& sv) { return sv.surfaceType == "inflated"; });
 
    const QString lhKey = "lh_inflated";
    const QString rhKey = "rh_inflated";
 
    if (!m_surfaces.contains(lhKey) || !m_surfaces.contains(rhKey)) {
        return;
    }
 
    auto lhSurf = m_surfaces[lhKey];
    auto rhSurf = m_surfaces[rhKey];
 
    lhSurf->applyTransform(itemTransform(m_itemSurfaceMap.key(lhSurf)));
    rhSurf->applyTransform(itemTransform(m_itemSurfaceMap.key(rhSurf)));
 
    if (!needsInflated) {
        return;
    }
 
    const float lhMaxX = lhSurf->maxX();
    const float rhMinX = rhSurf->minX();
 
    const float gap = 0.005f;
    const float lhOffset = -gap / 2.0f - lhMaxX;
    const float rhOffset = gap / 2.0f - rhMinX;
 
    lhSurf->translateX(lhOffset);
    rhSurf->translateX(rhOffset);
}
 
void BrainView::setBemShaderMode(const QString& modeName)
{
    const BrainRenderer::ShaderMode mode = shaderModeFromName(modeName);
 
    subViewForTarget(m_visualizationEditTarget).bemShader = mode;
 
    m_bemShaderMode = mode;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::syncBemShadersToBrainShaders()
{
    m_singleView.bemShader = m_singleView.brainShader;
    for (int i = 0; i < m_subViews.size(); ++i) {
        m_subViews[i].bemShader = m_subViews[i].brainShader;
    }
 
    m_bemShaderMode = subViewForTarget(m_visualizationEditTarget).bemShader;
 
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
void BrainView::setSensorVisible(const QString& type, bool visible)
{
    const QString object = SURFACEKEYS::sensorTypeToObjectKey(type);
    if (object.isEmpty())
        return;
 
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    profile.setObjectVisible(object, visible);
 
    // Cascade parent toggle to child sub-types so that e.g. "MEG" also
    // enables/disables MEG/Grad and MEG/Mag sub-types.
    // Note: MEG Helmet has its own independent checkbox and is NOT cascaded.
    if (type == QLatin1String("MEG")) {
        profile.sensMegGrad = visible;
        profile.sensMegMag = visible;
    } else if (type == QLatin1String("EEG")) {
        // No sub-types for EEG currently, but keep symmetric.
    } else if (type == QLatin1String("Digitizer")) {
        profile.digCardinal = visible;
        profile.digHpi = visible;
        profile.digEeg = visible;
        profile.digExtra = visible;
    }
 
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
void BrainView::setSensorTransEnabled(bool enabled)
{
    if (m_applySensorTrans != enabled) {
        m_applySensorTrans = enabled;
        refreshSensorTransforms();
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
void BrainView::setMegHelmetOverride(const QString& path)
{
    m_megHelmetOverridePath = path;
}
 
void BrainView::setDipoleVisible(bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    profile.dipoles = visible;
    m_dipolesVisible = visible;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setVisualizationMode(const QString& modeName)
{
    const BrainSurface::VisualizationMode mode = visualizationModeFromName(modeName);
    SubView& sv = subViewForTarget(m_visualizationEditTarget);
    sv.overlayMode = mode;
 
    m_currentVisMode = mode;
 
    // Propagate the mode to brain hemisphere surfaces only (lh_*, rh_*)
    // so that the primary colour channel holds the right data: curvature
    // grays for Scientific or STC colours for SourceEstimate.
    // BEM, sensor, and source-space surfaces are left untouched.
    for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
        const QString& key = it.key();
        if (key.startsWith("lh_") || key.startsWith("rh_")) {
            it.value()->setVisualizationMode(mode);
        }
    }
 
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setHemiVisible(int hemiIdx, bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    if (hemiIdx == 0) {
        profile.lh = visible;
    } else if (hemiIdx == 1) {
        profile.rh = visible;
    }
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setBemVisible(const QString& name, bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    profile.setObjectVisible("bem_" + name, visible);
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
void BrainView::setBemHighContrast(bool enabled)
{
    for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
        if (it.key().startsWith("bem_")) {
            it.value()->setUseDefaultColor(enabled);
        }
    }
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setLightingEnabled(bool enabled)
{
    m_lightingEnabled = enabled;
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setAutomatedRotation(bool enabled)
{
    if (!enabled) {
        if (m_pAutoRotateTimer) {
            m_pAutoRotateTimer->stop();
        }
        return;
    }
 
    if (!m_pAutoRotateTimer) {
        m_pAutoRotateTimer = new QTimer(this);
        m_pAutoRotateTimer->setInterval(33);
 
        connect(m_pAutoRotateTimer, &QTimer::timeout, this, [this]() {
            // Rotate the camera rather than the objects, so that every surface
            // keeps its own coregistration transform and head and sensors stay
            // aligned with each other.
            const QPoint step(2, 0);
 
            if (m_viewMode == MultiView) {
                for (int i = 0; i < m_subViews.size(); ++i) {
                    if (multiViewPresetIsPerspective(std::clamp(m_subViews[i].preset, 0, 6))) {
                        CameraController::applyMouseRotation(step, m_subViews[i].perspectiveRotation);
                    }
                }
            } else {
                CameraController::applyMouseRotation(step, m_cameraRotation);
            }
 
            m_sceneDirty = true;
            update();
        });
    }
 
    m_pAutoRotateTimer->start();
}
 
//=============================================================================================================
 
bool BrainView::automatedRotation() const
{
    return m_pAutoRotateTimer && m_pAutoRotateTimer->isActive();
}
 
//=============================================================================================================
 
void BrainView::setHeadMovementPath(const QVector<Eigen::Vector3f>& vecPositions)
{
    // A path needs at least one segment to be meaningful.
    if (vecPositions.size() < 2) {
        clearHeadMovementPath();
        return;
    }
 
    if (!m_headPath) {
        m_headPath = std::make_unique<PolylineObject>();
    }
 
    m_headPath->setPoints(vecPositions);
    m_headPath->setVisible(true);
 
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::clearHeadMovementPath()
{
    if (!m_headPath) {
        return;
    }
 
    m_headPath.reset();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
bool BrainView::saveSnapshot()
{
    const QDateTime now = QDateTime::currentDateTime();
    return takeScreenshot(QStringLiteral("./Screenshots/%1-%2-3DView.png").arg(now.toString(QStringLiteral("yyyy_MM_dd")), now.toString(QStringLiteral("hh_mm_ss"))));
}
 
//=============================================================================================================
 
bool BrainView::takeScreenshot(const QString& fileName)
{
    const QImage frame = grabFramebuffer();
    if (frame.isNull()) {
        qWarning() << "[BrainView::takeScreenshot] No rendered frame - nothing written to" << fileName;
        return false;
    }
    if (!QDir().mkpath(QFileInfo(fileName).absolutePath()) || !frame.save(fileName)) {
        qWarning() << "[BrainView::takeScreenshot] Cannot write" << fileName;
        return false;
    }
    return true;
}
 
//=============================================================================================================
 
bool BrainView::savePng(const QString& path, int width, int height,
                        const QString& surfaceType)
{
    // Realise the widget off-screen — QRhi init still runs because
    // the widget is technically "shown", but no window-manager surface
    // is created.  Same pattern as skigen-plot Figure::save().
    setAttribute(Qt::WA_DontShowOnScreen, true);
    resize(width, height);
 
    // Set the surface type filter so the render loop matches the
    // loaded surface names (e.g. "white" vs default "pial").
    m_singleView.surfaceType = surfaceType;
 
    show();
 
    // Spin the event loop until QRhi is initialised, at least one
    // frame has been rendered (m_renderer becomes non-null), and the
    // surface map is populated.
    QElapsedTimer timer;
    timer.start();
    while (timer.elapsed() < 5000) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 16);
        if (m_renderer && !m_surfaces.isEmpty())
            break;
    }
 
    if (!m_renderer) {
        hide();
        setAttribute(Qt::WA_DontShowOnScreen, false);
        return false;
    }
 
    // Force a dirty scene so the next grab renders everything.
    m_sceneDirty = true;
    updateSceneBounds();
 
    // Pump a few more frames so pipeline resources are fully created.
    for (int i = 0; i < 5; ++i)
        QCoreApplication::processEvents(QEventLoop::AllEvents, 16);
 
    // QRhiWidget::grabFramebuffer() internally creates an offscreen
    // frame, calls render(), and reads back the texture.
    QImage img = grabFramebuffer();
 
    hide();
    setAttribute(Qt::WA_DontShowOnScreen, false);
 
    if (img.isNull())
        return false;
 
    return img.save(path, "PNG");
}
 
//=============================================================================================================
 
void BrainView::showSingleView()
{
    m_viewMode = SingleView;
    m_isDraggingSplitter = false;
    m_activeSplitter = SplitterHit::None;
    unsetCursor();
    saveMultiViewSettings();
    updateViewportSeparators();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::showMultiView()
{
    m_viewMode = MultiView;
    saveMultiViewSettings();
    updateViewportSeparators();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setViewCount(int count)
{
    count = std::clamp(count, 1, static_cast<int>(m_subViews.size()));
    m_viewCount = count;
 
    if (count == 1) {
        m_viewMode = SingleView;
        m_isDraggingSplitter = false;
        m_activeSplitter = SplitterHit::None;
        unsetCursor();
        setVisualizationEditTarget(-1);
    } else {
        m_viewMode = MultiView;
        // Default edit target to first pane when entering multi-view
        if (m_visualizationEditTarget < 0)
            setVisualizationEditTarget(0);
    }
 
    // Enable first N sub-views, disable the rest
    for (int i = 0; i < m_subViews.size(); ++i)
        m_subViews[i].enabled = (i < count);
 
    saveMultiViewSettings();
    updateViewportSeparators();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
    emit viewCountChanged(m_viewCount);
}
 
//=============================================================================================================
 
void BrainView::resetMultiViewLayout()
{
    m_layout.resetSplits();
    m_multiSplitX = m_layout.splitX();
    m_multiSplitY = m_layout.splitY();
    saveMultiViewSettings();
    updateViewportSeparators();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
}
 
bool BrainView::isViewportEnabled(int index) const
{
    if (index < 0 || index >= m_subViews.size()) {
        return false;
    }
 
    return m_subViews[index].enabled;
}
 
//=============================================================================================================
 
int BrainView::enabledViewportCount() const
{
    if (m_viewMode != MultiView) {
        return 1;
    }
 
    int numEnabled = 0;
    for (int i = 0; i < m_subViews.size(); ++i) {
        if (m_subViews[i].enabled) {
            ++numEnabled;
        }
    }
 
    return numEnabled > 0 ? numEnabled : 1;
}
 
//=============================================================================================================
 
QVector<int> BrainView::enabledViewportIndices() const
{
    QVector<int> vps;
    if (m_viewMode == MultiView) {
        for (int i = 0; i < m_subViews.size(); ++i) {
            if (m_subViews[i].enabled)
                vps.append(i);
        }
        if (vps.isEmpty())
            vps.append(0);
    } else {
        vps.append(0);
    }
    return vps;
}
 
//=============================================================================================================
 
int BrainView::viewportIndexAt(const QPoint& pos) const
{
    if (m_viewMode != MultiView) {
        return 0;
    }
 
    const auto enabledViewports = enabledViewportIndices();
    return m_layout.viewportIndexAt(pos, enabledViewports, size());
}
 
//=============================================================================================================
 
QRect BrainView::multiViewSlotRect(int slot, int numEnabled, const QSize& outputSize) const
{
    return m_layout.slotRect(slot, numEnabled, outputSize);
}
 
//=============================================================================================================
 
SplitterHit BrainView::hitTestSplitter(const QPoint& pos, int numEnabled, const QSize& outputSize) const
{
    if (m_viewMode != MultiView || numEnabled <= 1) {
        return SplitterHit::None;
    }
    return m_layout.hitTestSplitter(pos, numEnabled, outputSize);
}
 
//=============================================================================================================
 
void BrainView::updateSplitterCursor(const QPoint& pos)
{
    const SplitterHit hit = hitTestSplitter(pos, enabledViewportCount(), size());
    const Qt::CursorShape shape = MultiViewLayout::cursorForHit(hit);
    if (shape == Qt::ArrowCursor) {
        unsetCursor();
    } else {
        setCursor(shape);
    }
}
 
//=============================================================================================================
 
void BrainView::updateViewportSeparators()
{
    if (!m_verticalSeparator || !m_horizontalSeparator) {
        return;
    }
 
    m_verticalSeparator->hide();
    m_horizontalSeparator->hide();
 
    const int numEnabled = enabledViewportCount();
    if (m_viewMode != MultiView || numEnabled <= 1) {
        return;
    }
 
    QRect vRect, hRect;
    m_layout.separatorGeometries(numEnabled, size(), vRect, hRect);
 
    if (!vRect.isEmpty()) {
        m_verticalSeparator->setGeometry(vRect);
        m_verticalSeparator->show();
        m_verticalSeparator->raise();
    }
    if (!hRect.isEmpty()) {
        m_horizontalSeparator->setGeometry(hRect);
        m_horizontalSeparator->show();
        m_horizontalSeparator->raise();
    }
 
    updateOverlayLayout();
}
 
//=============================================================================================================
 
void BrainView::updateOverlayLayout()
{
    const auto enabledViewports = enabledViewportIndices();
 
    if (m_fpsLabel) {
        m_fpsLabel->setVisible(m_infoPanelVisible);
        m_fpsLabel->adjustSize();
        const int perfBottomMargin = 2;
 
        if (m_viewMode == MultiView) {
            m_fpsLabel->move(width() - m_fpsLabel->width() - 10,
                             height() - m_fpsLabel->height() - perfBottomMargin);
        } else {
            m_fpsLabel->move(width() - m_fpsLabel->width() - 10,
                             height() - m_fpsLabel->height() - perfBottomMargin);
        }
 
        m_fpsLabel->raise();
    }
 
    if (m_singleViewInfoLabel) {
        const bool showSingleInfo = (m_viewMode == SingleView) && m_infoPanelVisible;
        m_singleViewInfoLabel->setVisible(showSingleInfo);
        if (showSingleInfo) {
            m_singleViewInfoLabel->adjustSize();
            m_singleViewInfoLabel->move(width() - m_singleViewInfoLabel->width() - 8, 8);
            m_singleViewInfoLabel->raise();
        }
    }
 
    if (m_regionLabel) {
        const int regionY = (m_viewMode == MultiView) ? 38 : 10;
        m_regionLabel->move(10, regionY);
        if (!m_regionLabel->text().isEmpty()) {
            m_regionLabel->raise();
        }
    }
 
    for (int i = 0; i < m_viewportNameLabels.size(); ++i) {
        if (m_viewportNameLabels[i]) {
            m_viewportNameLabels[i]->hide();
        }
        if (m_viewportInfoLabels[i]) {
            m_viewportInfoLabels[i]->hide();
        }
    }
 
    if (m_viewMode != MultiView) {
        return;
    }
 
    const int numEnabled = enabledViewports.size();
    const QSize overlaySize = size();
    for (int slot = 0; slot < numEnabled; ++slot) {
        const int vp = enabledViewports[slot];
        QLabel* label = m_viewportNameLabels[vp];
        QLabel* infoLabel = m_viewportInfoLabels[vp];
        if (!label) {
            continue;
        }
 
        const int preset = std::clamp(m_subViews[vp].preset, 0, 6);
        label->setText(multiViewPresetName(preset));
 
        const QRect pane = multiViewSlotRect(slot, numEnabled, overlaySize);
        label->adjustSize();
        label->move(pane.x() + 8, pane.y() + 8);
        label->setVisible(true);
        label->raise();
 
        if (infoLabel) {
            infoLabel->adjustSize();
            infoLabel->move(pane.x() + pane.width() - infoLabel->width() - 8,
                            pane.y() + 8);
            infoLabel->setVisible(m_infoPanelVisible);
            infoLabel->raise();
        }
    }
 
    updateViewportLabelHighlight();
}
 
//=============================================================================================================
 
void BrainView::updateViewportLabelHighlight()
{
    static const QString normalStyle =
        QStringLiteral("color: white; font-weight: bold; font-family: sans-serif; "
                       "font-size: 12px; background: transparent; padding: 2px 4px;");
    static const QString selectedStyle =
        QStringLiteral("color: #FFD54F; font-weight: bold; font-family: sans-serif; "
                       "font-size: 13px; background: rgba(255,213,79,40); "
                       "border: 1px solid #FFD54F; border-radius: 3px; padding: 2px 6px;");
 
    for (int i = 0; i < m_viewportNameLabels.size(); ++i) {
        if (!m_viewportNameLabels[i])
            continue;
        const bool selected = (m_viewMode == MultiView && m_visualizationEditTarget == i);
        m_viewportNameLabels[i]->setStyleSheet(selected ? selectedStyle : normalStyle);
        m_viewportNameLabels[i]->adjustSize();
    }
}
 
//=============================================================================================================
 
void BrainView::logPerspectiveRotation(const QString& context) const
{
    Q_UNUSED(context);
}
 
//=============================================================================================================
 
void BrainView::loadMultiViewSettings()
{
    QSettings settings;
    settings.beginGroup(QStringLiteral("BrainView"));
 
    m_multiSplitX = settings.value("multiSplitX", 0.5f).toFloat();
    m_multiSplitY = settings.value("multiSplitY", 0.5f).toFloat();
 
    const int savedViewMode = settings.value("viewMode", static_cast<int>(SingleView)).toInt();
    m_viewCount = std::clamp(settings.value("viewCount", 1).toInt(), 1, static_cast<int>(m_subViews.size()));
    // showSingleView keeps the pane count for the next showMultiView; one pane is always the single view
    m_viewMode = (savedViewMode == static_cast<int>(MultiView) && m_viewCount > 1) ? MultiView : SingleView;
 
    const bool hasCameraQuat = settings.contains("cameraRotW") && settings.contains("cameraRotX") && settings.contains("cameraRotY") && settings.contains("cameraRotZ");
    if (hasCameraQuat) {
        const float w = settings.value("cameraRotW", 1.0f).toFloat();
        const float x = settings.value("cameraRotX", 0.0f).toFloat();
        const float y = settings.value("cameraRotY", 0.0f).toFloat();
        const float z = settings.value("cameraRotZ", 0.0f).toFloat();
        m_cameraRotation = QQuaternion(w, x, y, z);
        if (m_cameraRotation.lengthSquared() <= std::numeric_limits<float>::epsilon()) {
            m_cameraRotation = QQuaternion();
        } else {
            m_cameraRotation.normalize();
        }
    }
 
    // Reset per-index defaults, then load saved state on top
    for (int i = 0; i < m_subViews.size(); ++i) {
        m_subViews[i] = SubView::defaultForIndex(i);
        m_subViews[i].enabled = (i < m_viewCount);
    }
 
    // Delegate per-SubView serialization
    m_singleView.load(settings, "single_", m_cameraRotation);
    for (int i = 0; i < m_subViews.size(); ++i)
        m_subViews[i].load(settings, QStringLiteral("multi%1_").arg(i), m_cameraRotation);
 
    const int maxIdx = static_cast<int>(m_subViews.size()) - 1;
    m_visualizationEditTarget = normalizedVisualizationTarget(
        settings.value("visualizationEditTarget", -1).toInt(), maxIdx);
 
    m_infoPanelVisible = settings.value("infoPanelVisible", true).toBool();
 
    settings.endGroup();
 
    m_multiSplitX = std::clamp(m_multiSplitX, 0.15f, 0.85f);
    m_multiSplitY = std::clamp(m_multiSplitY, 0.15f, 0.85f);
    m_layout.setSplitX(m_multiSplitX);
    m_layout.setSplitY(m_multiSplitY);
 
    setVisualizationEditTarget(m_visualizationEditTarget);
 
    // Notify observers that persisted state has been restored. Defer to
    // the next event-loop tick so that callers constructing BrainView
    // and connecting to these signals immediately afterwards still
    // receive the initial state — direct emits from inside the ctor
    // chain would fire before any external connect() call.
    QTimer::singleShot(0, this, [this]() {
        emit viewCountChanged(m_viewCount);
        emit shaderModeChanged(shaderModeName(m_brainShaderMode));
    });
}
 
//=============================================================================================================
 
void BrainView::saveMultiViewSettings() const
{
    QSettings settings;
    settings.beginGroup(QStringLiteral("BrainView"));
    settings.setValue("multiSplitX", m_multiSplitX);
    settings.setValue("multiSplitY", m_multiSplitY);
    settings.setValue("viewMode", static_cast<int>(m_viewMode));
    settings.setValue("viewCount", m_viewCount);
    settings.setValue("cameraRotW", m_cameraRotation.scalar());
    settings.setValue("cameraRotX", m_cameraRotation.x());
    settings.setValue("cameraRotY", m_cameraRotation.y());
    settings.setValue("cameraRotZ", m_cameraRotation.z());
    for (int i = 0; i < m_subViews.size(); ++i)
        settings.setValue(QStringLiteral("viewportEnabled%1").arg(i), m_subViews[i].enabled);
    settings.setValue("visualizationEditTarget", m_visualizationEditTarget);
    settings.setValue("infoPanelVisible", m_infoPanelVisible);
 
    // Delegate per-SubView serialization
    m_singleView.save(settings, "single_");
    for (int i = 0; i < m_subViews.size(); ++i)
        m_subViews[i].save(settings, QStringLiteral("multi%1_").arg(i));
 
    settings.endGroup();
}
 
//=============================================================================================================
 
void BrainView::setViewportEnabled(int index, bool enabled)
{
    if (index >= 0 && index < m_subViews.size()) {
        m_subViews[index].enabled = enabled;
        saveMultiViewSettings();
        updateViewportSeparators();
        updateOverlayLayout();
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
void BrainView::setViewportCameraPreset(int index, int preset)
{
    if (index < 0 || index >= static_cast<int>(m_subViews.size()))
        return;
    preset = std::clamp(preset, 0, 6);
    if (m_subViews[index].preset == preset)
        return;
    m_subViews[index].preset = preset;
    saveMultiViewSettings();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::resetSingleViewCameraState()
{
    m_cameraRotation = QQuaternion();
    m_singleView.zoom = 0.0f;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::resetViewportCameraState(int index)
{
    if (index < 0 || index >= static_cast<int>(m_subViews.size())) {
        return;
    }
 
    m_subViews[index].zoom = 0.0f;
    m_subViews[index].pan = QVector2D();
    m_subViews[index].perspectiveRotation = QQuaternion();
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::resetAllSubViewState()
{
    m_singleView = SubView{};
    for (int i = 0; i < m_subViews.size(); ++i) {
        const bool wasEnabled = m_subViews[i].enabled;
        m_subViews[i] = SubView::defaultForIndex(i);
        m_subViews[i].enabled = wasEnabled;
    }
    m_cameraRotation = QQuaternion();
    saveMultiViewSettings();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
int BrainView::viewportCameraPreset(int index) const
{
    if (index < 0 || index >= static_cast<int>(m_subViews.size()))
        return -1;
    return std::clamp(m_subViews[index].preset, 0, 6);
}
 
//=============================================================================================================
 
void BrainView::setInfoPanelVisible(bool visible)
{
    m_infoPanelVisible = visible;
    saveMultiViewSettings();
    updateOverlayLayout();
}
 
//=============================================================================================================
 
void BrainView::resizeEvent(QResizeEvent* event)
{
    QRhiWidget::resizeEvent(event);
    updateViewportSeparators();
    updateOverlayLayout();
}
 
//=============================================================================================================
 
void BrainView::initialize(QRhiCommandBuffer* cb)
{
    Q_UNUSED(cb);
 
    m_renderer = std::make_unique<BrainRenderer>();
 
    // Create dual render targets (clearing + preserving) sharing this
    // widget's color texture.  Must be done here because colorTexture()
    // is only valid inside initialize()/render().
    m_renderer->ensureRenderTargets(rhi(), colorTexture(), colorTexture()->pixelSize());
}
 
//=============================================================================================================
 
void BrainView::render(QRhiCommandBuffer* cb)
{
    // Check if there is anything to render
    bool hasSurfaces = !m_surfaces.isEmpty();
    bool hasDipoles = !m_itemDipoleMap.isEmpty() || m_dipoles; // Check managed dipoles too
 
    // If absolutely nothing is loaded, render black background
    if (!hasSurfaces && !hasDipoles) {
        // No surface loaded: render a black background instead of leaving the widget uninitialized
        if (!m_renderer) {
            m_renderer = std::make_unique<BrainRenderer>();
        }
        m_renderer->ensureRenderTargets(rhi(), colorTexture(), colorTexture()->pixelSize());
        m_renderer->initialize(rhi(), m_renderer->rtClear()->renderPassDescriptor(), sampleCount());
        m_renderer->beginFrame(cb);
        m_renderer->endPass(cb);
        return;
    }
 
    // Ensure active surface pointer is valid if possible, otherwise just use first available for stats
    if (!m_activeSurface && !m_surfaces.isEmpty()) {
        m_activeSurface = m_surfaces.begin().value();
    }
 
 
    m_frameCount++;
    if (m_fpsTimer.elapsed() >= 500) {
        float fps = m_frameCount / (m_fpsTimer.elapsed() / 1000.0f);
 
        // Recount vertices only when surface list/visibility changed
        if (m_vertexCountDirty) {
            auto countVerticesForSubView = [this](const SubView& sv) -> qint64 {
                qint64 total = 0;
                for (auto it = m_surfaces.cbegin(); it != m_surfaces.cend(); ++it) {
                    const QString& key = it.key();
                    auto surface = it.value();
                    if (!surface)
                        continue;
                    if (!sv.shouldRenderSurface(key))
                        continue;
                    if (SubView::isBrainSurfaceKey(key)) {
                        if (!sv.matchesSurfaceType(key))
                            continue;
                    } else {
                        if (!surface->isVisible())
                            continue;
                    }
                    total += surface->vertexCount();
                }
                return total;
            };
 
            qint64 vCount = 0;
            if (m_viewMode == MultiView) {
                for (int vp : enabledViewportIndices()) {
                    vCount += countVerticesForSubView(m_subViews[vp]);
                }
            } else {
                vCount = countVerticesForSubView(m_singleView);
            }
            m_cachedVertexCount = vCount;
            m_vertexCountDirty = false;
        }
 
        m_fpsLabel->setText(QString("FPS: %1\nVertices: %2").arg(fps, 0, 'f', 1).arg(m_cachedVertexCount));
        updateOverlayLayout();
        m_fpsLabel->raise();
        m_frameCount = 0;
        m_fpsTimer.restart();
    }
 
    // Initialize renderer
    m_renderer->ensureRenderTargets(rhi(), colorTexture(), colorTexture()->pixelSize());
    m_renderer->initialize(rhi(), m_renderer->rtClear()->renderPassDescriptor(), sampleCount());
 
    // Determine viewport configuration
    QSize outputSize = m_renderer->rtClear()->pixelSize();
 
    // Build list of enabled viewports
    const auto enabledViewports = enabledViewportIndices();
    int numEnabled = enabledViewports.size();
 
    // ── Pre-render phase ────────────────────────────────────────────────
    // Pre-upload ALL Immutable GPU buffers BEFORE the render pass starts.
    // On Metal, uploading an Immutable buffer during an active render pass
    // forces an encoder restart which resets the viewport state.  On
    // WebGL/GLES2, buffer create()/upload calls invoke glBindBuffer() which
    // silently modifies the currently-bound VAO's element-buffer binding,
    // corrupting previously drawn surfaces.
    //
    // By doing all static uploads here (outside any render pass), we
    // guarantee that the draw loop below only records Dynamic uniform
    // updates — those never interrupt the pass.
 
    // Pre-upload every surface and dipole buffer that is dirty or new.
    // NOTE: Overlay modes are applied per-pane inside the render loop below
    // (not here), because different panes can have different overlays on the
    // same shared BrainSurface objects.  Applying all pane overlays
    // sequentially here would leave only the last pane's vertex colours.
    {
        QRhiResourceUpdateBatch* preUpload = rhi()->nextResourceUpdateBatch();
#ifndef __EMSCRIPTEN__
        // WORKAROUND(QRhi-GLES2): WASM draws all geometry from merged per-category buffers;
        // per-surface uploads would pollute the GLES2 element-buffer bindings.
        for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
            it.value()->updateBuffers(rhi(), preUpload);
        }
        if (m_debugPointerSurface) {
            m_debugPointerSurface->updateBuffers(rhi(), preUpload);
        }
        for (auto it = m_itemDipoleMap.begin(); it != m_itemDipoleMap.end(); ++it) {
            it.value()->updateBuffers(rhi(), preUpload);
        }
        if (m_dipoles) {
            m_dipoles->updateBuffers(rhi(), preUpload);
        }
#endif
        if (m_videoOverlay && m_videoOverlay->isEnabled()) {
            m_renderer->prepareVideoOverlay(rhi(), preUpload, m_videoOverlay.get());
        }
 
        // Prepare MRI slice textures and vertex data
        for (int i = 0; i < kMaxSliceSlots; ++i) {
            if (m_slices[i] && m_sliceVisible[i]) {
                m_renderer->prepareSlice(rhi(), preUpload, m_slices[i], i);
            } else {
                m_renderer->prepareSlice(rhi(), preUpload, nullptr, i);
            }
        }
 
#ifdef __EMSCRIPTEN__
        // WORKAROUND(QRhi-GLES2): Single merged buffer for ALL surfaces.
        // The Qt QRhi GLES2/WebGL backend only renders the first
        // drawIndexed() per render pass.  Multi-pass compositing via
        // PreserveColorContents is unreliable across WebGL implementations.
        // Merge everything into one VBO/IBO and issue one drawIndexed().
        {
            const SubView& sv = (m_viewMode == MultiView) ? m_subViews[0] : m_singleView;
 
            QVector<BrainSurface*> allSurfaces;
 
            // Brain surfaces (opaque, drawn first for depth)
            for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
                if (!SubView::isBrainSurfaceKey(it.key()))
                    continue;
                if (!sv.matchesSurfaceType(it.key()))
                    continue;
                if (!sv.shouldRenderSurface(it.key()))
                    continue;
                allSurfaces.append(it.value().get());
            }
 
            // Source space points
            for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
                if (!it.key().startsWith("srcsp_"))
                    continue;
                if (!sv.shouldRenderSurface(it.key()))
                    continue;
                if (!it.value()->isVisible())
                    continue;
                allSurfaces.append(it.value().get());
            }
 
            // Digitizer points
            for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
                if (!it.key().startsWith("dig_"))
                    continue;
                if (!sv.shouldRenderSurface(it.key()))
                    continue;
                if (!it.value()->isVisible())
                    continue;
                allSurfaces.append(it.value().get());
            }
 
            // BEM + sensors (transparent — appended last for correct blending order)
            for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
                bool isSensor = it.key().startsWith("sens_");
                bool isBem = it.key().startsWith("bem_");
                if (!isSensor && !isBem)
                    continue;
                if (!sv.shouldRenderSurface(it.key()))
                    continue;
                if (!it.value()->isVisible())
                    continue;
                allSurfaces.append(it.value().get());
            }
 
            m_renderer->prepareMergedSurfaces(rhi(), preUpload, allSurfaces, QStringLiteral("default"));
        }
#endif
 
        // Network buffers are updated inside renderNetwork() via updateNodeBuffers/updateEdgeBuffers
        cb->resourceUpdate(preUpload);
    }
 
    // ── Render passes ───────────────────────────────────────────────────
    m_renderer->beginFrame(cb);
 
    for (int slot = 0; slot < numEnabled; ++slot) {
        int vp = (m_viewMode == MultiView) ? enabledViewports[slot] : 0;
        const SubView& sv = (m_viewMode == MultiView) ? m_subViews[vp] : m_singleView;
 
        const QRect paneRect = (m_viewMode == MultiView)
            ? multiViewSlotRect(slot, numEnabled, outputSize)
            : QRect(0, 0, outputSize.width(), outputSize.height());
 
        QRect renderRect = paneRect;
        if (m_viewMode == MultiView && numEnabled > 1) {
            constexpr int separatorPx = 2;
 
            if (numEnabled == 2) {
                if (slot == 0) {
                    renderRect.setWidth(std::max(1, renderRect.width() - separatorPx));
                }
            } else if (numEnabled == 3) {
                // 3-view: slot 0 = full top row, slots 1&2 = bottom row
                if (slot == 0) {
                    // Top pane: no right neighbor, has bottom neighbor
                    renderRect.setHeight(std::max(1, renderRect.height() - separatorPx));
                } else if (slot == 1) {
                    // Bottom-left: has right neighbor, no bottom neighbor
                    renderRect.setWidth(std::max(1, renderRect.width() - separatorPx));
                }
                // slot 2 (bottom-right): no insets needed
            } else {
                const int col = slot % 2;
                const int row = slot / 2;
 
                const bool hasRightNeighbor = (col == 0) && (slot + 1 < numEnabled) && ((slot / 2) == ((slot + 1) / 2));
                const bool hasBottomNeighbor = (row == 0) && (slot + 2 < numEnabled);
 
                if (hasRightNeighbor) {
                    renderRect.setWidth(std::max(1, renderRect.width() - separatorPx));
                }
                if (hasBottomNeighbor) {
                    renderRect.setHeight(std::max(1, renderRect.height() - separatorPx));
                }
            }
        }
 
        const int viewX = renderRect.x();
        const int viewY = outputSize.height() - (renderRect.y() + renderRect.height());
        const int viewW = std::max(1, renderRect.width());
        const int viewH = std::max(1, renderRect.height());
 
        QRhiViewport viewport(viewX, viewY, viewW, viewH);
        QRhiScissor scissor(viewX, viewY, viewW, viewH);
        const float aspectRatio = float(viewW) / float(viewH);
 
        // Set viewport and scissor
        cb->setViewport(viewport);
        cb->setScissor(scissor);
 
        // Calculate camera for this viewport
        const QVector3D effectiveCenter = m_cameraFocusOverride ? m_cameraFocusCenter : m_sceneCenter;
        const float effectiveSize = m_cameraFocusOverride ? m_cameraFocusSize : m_sceneSize;
        m_camera.setSceneCenter(effectiveCenter);
        m_camera.setSceneSize(effectiveSize);
        m_camera.setRotation(m_cameraRotation);
        m_camera.setZoom(m_singleView.zoom);
        const CameraResult cam = (m_viewMode == MultiView)
            ? m_camera.computeMultiView(sv, aspectRatio)
            : m_camera.computeSingleView(aspectRatio);
 
        BrainRenderer::SceneData sceneData;
        sceneData.mvp = rhi()->clipSpaceCorrMatrix();
        sceneData.mvp *= cam.projection;
        sceneData.mvp *= cam.view;
        sceneData.mvp *= cam.model;
 
        sceneData.cameraPos = cam.cameraPos;
        sceneData.lightDir = cam.cameraPos.normalized();
        sceneData.lightingEnabled = m_lightingEnabled;
        sceneData.viewportX = viewX;
        sceneData.viewportY = viewY;
        sceneData.viewportW = viewW;
        sceneData.viewportH = viewH;
        sceneData.scissorX = viewX;
        sceneData.scissorY = viewY;
        sceneData.scissorW = viewW;
        sceneData.scissorH = viewH;
 
        // Per-draw overlayMode uniform — the shader selects the vertex colour
        // channel (curvature / annotation) so no per-pane vertex buffer
        // re-uploads are needed.
        sceneData.overlayMode = static_cast<float>(sv.overlayMode);
 
        // Pass 1: Opaque Surfaces (Brain surfaces)
        // Use viewport-specific shader from subview
        BrainRenderer::ShaderMode currentShader = sv.brainShader;
        const QString overlayName = visualizationModeName(sv.overlayMode);
 
        // Collect matched brain surface keys for this pane's info panel
#ifndef __EMSCRIPTEN__
        QStringList drawnKeys;
#else
        const QString drawnInfo = QStringLiteral("merged");
#endif
 
        if (m_viewMode == MultiView && m_viewportInfoLabels[vp]) {
            m_viewportInfoLabels[vp]->setText(
                QString("Shader: %1\nSurface: %2\nOverlay: %3")
                    .arg(shaderModeName(currentShader), sv.surfaceType, overlayName));
        } else if (m_viewMode == SingleView && m_singleViewInfoLabel) {
            m_singleViewInfoLabel->setText(
                QString("Shader: %1\nSurface: %2\nOverlay: %3")
                    .arg(shaderModeName(currentShader), sv.surfaceType, overlayName));
        }
 
#ifndef __EMSCRIPTEN__
        // WORKAROUND(QRhi-GLES2): WASM draws brain surfaces from a merged per-category buffer below.
        for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
            if (!sv.matchesSurfaceType(it.key()))
                continue;
            if (!sv.shouldRenderSurface(it.key()))
                continue;
            drawnKeys << it.key();
            m_renderer->renderSurface(cb, rhi(), sceneData, it.value().get(), currentShader);
        }
#endif
 
#ifndef __EMSCRIPTEN__
        // Update info panel with drawn brain surface keys after rendering
        {
            const QString drawnInfo = drawnKeys.isEmpty() ? QStringLiteral("none") : drawnKeys.join(QStringLiteral(", "));
            if (m_viewMode == MultiView && m_viewportInfoLabels[vp]) {
                m_viewportInfoLabels[vp]->setText(m_viewportInfoLabels[vp]->text() + QStringLiteral("\nDrawn: ") + drawnInfo);
            } else if (m_viewMode == SingleView && m_singleViewInfoLabel) {
                m_singleViewInfoLabel->setText(m_singleViewInfoLabel->text() + QStringLiteral("\nDrawn: ") + drawnInfo);
            }
        }
#endif
 
#ifdef __EMSCRIPTEN__
        // ══════════════════════════════════════════════════════════════════════
        // WORKAROUND(QRhi-GLES2): Single-pass merged rendering.
        // The Qt QRhi GLES2/WebGL backend only renders the first drawIndexed()
        // per render pass, AND multi-pass compositing via PreserveColorContents
        // is unreliable.  All visible surfaces (brain, BEM, sensors, source
        // space, digitizers) are merged into one VBO/IBO and drawn in a single
        // drawIndexed() call in the clearing pass.
        //
        // Remove when upstream Qt fixes the QRhi GLES2 drawIndexed bug.
        // ══════════════════════════════════════════════════════════════════════
        m_renderer->drawMergedSurfaces(cb, rhi(), sceneData, currentShader, QStringLiteral("default"));
 
#else
 
        // ── Batched desktop rendering ───────────────────────────────────────
        // Single pass over m_surfaces categorises non-brain items into opaque
        // and transparent draw lists.  All uniform uploads are batched into
        // one QRhiResourceUpdateBatch and submitted once, eliminating per-
        // surface batch allocation and redundant viewport/scissor reassertion.
 
        // Determine per-viewport field-map visibility
        const bool megFieldVisible = sv.visibility.megFieldMap;
        const bool eegFieldVisible = sv.visibility.eegFieldMap;
        const BrainRenderer::ShaderMode currentBemShader = sv.bemShader;
        const QString& megFieldKey = m_fieldMapper.megSurfaceKey();
        const QString& eegFieldKey = m_fieldMapper.eegSurfaceKey();
 
        struct DrawItem
        {
            BrainSurface* surface;
            BrainRenderer::ShaderMode mode;
            float overlayMode;
            float distSq;      // for transparent back-to-front sort
            int uniformOffset; // filled by prepareSurfaceDraw
        };
 
        QVector<DrawItem> opaqueDraws;
        QVector<DrawItem> transparentDraws;
 
        for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
            const QString& key = it.key();
            BrainSurface* surf = it.value().get();
 
            if (SubView::isBrainSurfaceKey(key)) {
                // Brain surfaces already rendered above
                continue;
            } else if (key.startsWith("srcsp_") || key.startsWith("dig_")) {
                if (!sv.shouldRenderSurface(key))
                    continue;
                if (!surf->isVisible())
                    continue;
                if (key.startsWith(QLatin1String("dig_live_t_")) || key.startsWith(QLatin1String("dig_ray_")) || key.startsWith(QLatin1String("dig_probe_"))) {
                    QVector3D bmin, bmax;
                    surf->boundingBox(bmin, bmax);
                    QVector3D ctr = (bmin + bmax) * 0.5f;
                    float dist = (sceneData.cameraPos - ctr).lengthSquared();
                    transparentDraws.append({surf, BrainRenderer::Holographic,
                                             static_cast<float>(BrainSurface::ModeScientific),
                                             dist, -1});
                } else {
                    opaqueDraws.append({surf, currentShader,
                                        static_cast<float>(BrainSurface::ModeScientific),
                                        0.0f, -1});
                }
            } else {
                bool isSensor = key.startsWith("sens_");
                bool isBem = key.startsWith("bem_");
                if (!isSensor && !isBem)
                    continue;
                if (!sv.shouldRenderSurface(key))
                    continue;
                if (!surf->isVisible())
                    continue;
 
                QVector3D bmin, bmax;
                surf->boundingBox(bmin, bmax);
                QVector3D center = (bmin + bmax) * 0.5f;
                float dist = (sceneData.cameraPos - center).lengthSquared();
 
                auto mode = isBem ? currentBemShader : BrainRenderer::Holographic;
                float itemOverlay = static_cast<float>(BrainSurface::ModeScientific);
                if (key == megFieldKey && !megFieldVisible)
                    itemOverlay = static_cast<float>(BrainSurface::ModeSurface);
                else if (key == eegFieldKey && !eegFieldVisible)
                    itemOverlay = static_cast<float>(BrainSurface::ModeSurface);
 
                transparentDraws.append({surf, mode, itemOverlay, dist, -1});
            }
        }
 
        // Sort transparent items back-to-front for correct alpha blending
        std::sort(transparentDraws.begin(), transparentDraws.end(),
                  [](const DrawItem& a, const DrawItem& b) { return a.distSq > b.distSq; });
 
        // Batch all uniform uploads into a single resource update
        QRhiResourceUpdateBatch* surfBatch = rhi()->nextResourceUpdateBatch();
        BrainRenderer::SceneData batchData = sceneData;
 
        for (auto& item : opaqueDraws) {
            batchData.overlayMode = item.overlayMode;
            item.uniformOffset = m_renderer->prepareSurfaceDraw(surfBatch, batchData, item.surface);
        }
        for (auto& item : transparentDraws) {
            batchData.overlayMode = item.overlayMode;
            item.uniformOffset = m_renderer->prepareSurfaceDraw(surfBatch, batchData, item.surface);
        }
 
        // Batch MRI slice uniform uploads into the same batch
        int sliceOffsets[kMaxSliceSlots] = {-1, -1, -1};
        if (sv.visibility.mriSlices) {
            for (int i = 0; i < kMaxSliceSlots; ++i) {
                if (m_slices[i] && m_sliceVisible[i]) {
                    sliceOffsets[i] = m_renderer->prepareSliceDraw(surfBatch, sceneData, i);
                }
            }
        }
 
        cb->resourceUpdate(surfBatch);
 
        // Set viewport/scissor once for all batched draws
        cb->setViewport(viewport);
        cb->setScissor(scissor);
 
        // Issue all draw calls — no resource updates or state resets between them
        for (const auto& item : opaqueDraws)
            m_renderer->issueSurfaceDraw(cb, item.surface, item.mode, item.uniformOffset);
 
        // Issue MRI slice draws after opaque surfaces but before the holographic
        // brain.  Background voxels are discarded in the shader; remaining anatomy
        // alpha-blends into the framebuffer.  The subsequent holographic additive
        // pass (SrcAlpha + One) adds its glow on top without being dimmed.
        // depthTest=true, depthWrite=false keeps slices behind opaque geometry.
        for (int i = 0; i < kMaxSliceSlots; ++i) {
            if (sliceOffsets[i] >= 0) {
                m_renderer->issueSliceDraw(cb, i, sliceOffsets[i]);
            }
        }
 
        BrainSurface* videoOverlayTargetSurface = nullptr;
        const bool hasVideoOverlay = m_videoOverlay && m_videoOverlay->isEnabled() && m_videoOverlay->hasFrame();
        if (hasVideoOverlay) {
            // Target is always the head surface (BEM head or TissueSkin).
            if (m_surfaces.contains(QStringLiteral("bem_head"))) {
                videoOverlayTargetSurface = m_surfaces[QStringLiteral("bem_head")].get();
            } else {
                for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
                    if (it.value() && it.value()->tissueType() == BrainSurface::TissueSkin) {
                        videoOverlayTargetSurface = it.value().get();
                        break;
                    }
                }
            }
        }
 
        bool videoOverlayDrawn = false;
        auto drawVideoOverlay = [&]() {
            if (videoOverlayDrawn)
                return;
            if (videoOverlayTargetSurface) {
                m_renderer->renderVideoOverlayOnSurface(cb, rhi(), sceneData,
                                                        m_videoOverlay.get(), videoOverlayTargetSurface);
            } else if (hasVideoOverlay) {
                m_renderer->renderVideoOverlay(cb, rhi(), sceneData, m_videoOverlay.get());
            }
            videoOverlayDrawn = true;
        };
 
        for (const auto& item : transparentDraws) {
            m_renderer->issueSurfaceDraw(cb, item.surface, item.mode, item.uniformOffset);
            if (item.surface == videoOverlayTargetSurface) {
                drawVideoOverlay();
            }
        }
        drawVideoOverlay();
 
        // Render Dipoles
        for (auto it = m_itemDipoleMap.begin(); it != m_itemDipoleMap.end(); ++it) {
            if (it.value()->isVisible() && sv.visibility.dipoles) {
                m_renderer->renderDipoles(cb, rhi(), sceneData, it.value().get());
            }
        }
 
        if (sv.visibility.dipoles && m_dipoles) {
            m_renderer->renderDipoles(cb, rhi(), sceneData, m_dipoles.get());
        }
 
        // Render Connectivity Network
        if (sv.visibility.network && m_network) {
            m_renderer->renderNetwork(cb, rhi(), sceneData, m_network.get());
        }
 
        // Render the head movement path. It is not connectivity data, so it is not
        // tied to the network visibility flag.
        if (m_headPath) {
            m_renderer->renderPolyline(cb, rhi(), sceneData, m_headPath.get());
        }
 
        // Intersection Pointer
        if (m_hasIntersection && m_debugPointerSurface) {
            BrainRenderer::SceneData debugSceneData = sceneData;
            debugSceneData.overlayMode = 0.0f; // pass-through for holographic shell
 
            QMatrix4x4 translation;
            translation.translate(m_lastIntersectionPoint);
 
            debugSceneData.mvp = rhi()->clipSpaceCorrMatrix() * cam.projection * cam.view * cam.model * translation;
 
            m_renderer->renderSurface(cb, rhi(), debugSceneData, m_debugPointerSurface.get(), BrainRenderer::Holographic);
        }
 
#endif // !__EMSCRIPTEN__ — end of per-surface draw path
 
    } // End of viewport loop
 
    m_renderer->endPass(cb);
 
    // On WASM, all surfaces are drawn in the single clearing pass above
    // via the merged "default" group.  No additional preserving passes needed.
}
 
//=============================================================================================================
 
void BrainView::mousePressEvent(QMouseEvent* e)
{
    if (e->button() == Qt::LeftButton) {
        m_perspectiveRotatedSincePress = false;
        m_draggedSincePress = false;
    }
 
    if (e->button() == Qt::LeftButton && m_viewMode == MultiView) {
        const int clickedVp = viewportIndexAt(e->pos());
        if (clickedVp >= 0 && m_viewportNameLabels[clickedVp] && m_viewportNameLabels[clickedVp]->isVisible()) {
            if (m_viewportNameLabels[clickedVp]->geometry().contains(e->pos())) {
                if (clickedVp != m_visualizationEditTarget) {
                    setVisualizationEditTarget(clickedVp);
                }
                showViewportPresetMenu(clickedVp, mapToGlobal(e->pos()));
                m_lastMousePos = e->pos();
                return;
            }
        }
 
        const int numEnabled = enabledViewportCount();
        const SplitterHit hit = hitTestSplitter(e->pos(), numEnabled, size());
        if (hit != SplitterHit::None) {
            m_isDraggingSplitter = true;
            m_activeSplitter = hit;
            m_lastMousePos = e->pos();
            updateSplitterCursor(e->pos());
            return;
        }
 
        // Select the clicked viewport as the active edit target
        const int clickedVpForSelection = viewportIndexAt(e->pos());
        if (clickedVpForSelection >= 0 && clickedVpForSelection != m_visualizationEditTarget) {
            setVisualizationEditTarget(clickedVpForSelection);
        }
    }
 
    m_lastMousePos = e->pos();
}
 
//=============================================================================================================
 
void BrainView::mouseMoveEvent(QMouseEvent* event)
{
    if (m_isDraggingSplitter && (event->buttons() & Qt::LeftButton)) {
        m_layout.dragSplitter(event->pos(), m_activeSplitter, size());
        m_multiSplitX = m_layout.splitX();
        m_multiSplitY = m_layout.splitY();
 
        m_lastMousePos = event->pos();
        updateViewportSeparators();
        m_sceneDirty = true;
        update();
        return;
    }
 
    if (event->buttons() & Qt::LeftButton) {
        if (m_viewMode == MultiView) {
            const int activeVp = viewportIndexAt(event->pos());
            const int activePreset = (activeVp >= 0 && activeVp < m_subViews.size())
                ? std::clamp(m_subViews[activeVp].preset, 0, 6)
                : 1;
 
            if (activeVp >= 0 && !multiViewPresetIsPerspective(activePreset)) {
                // Planar views (Top/Front/Left): pan along the view plane
                const QPoint diff = event->pos() - m_lastMousePos;
                CameraController::applyMousePan(diff, m_subViews[activeVp].pan, m_sceneSize);
                m_draggedSincePress = true;
                m_lastMousePos = event->pos();
                m_sceneDirty = true;
                update();
                return;
            }
 
            if (activeVp >= 0 && multiViewPresetIsPerspective(activePreset)) {
                // Perspective view: rotate
                QPoint diff = event->pos() - m_lastMousePos;
                CameraController::applyMouseRotation(diff, m_subViews[activeVp].perspectiveRotation);
 
                m_perspectiveRotatedSincePress = true;
                m_draggedSincePress = true;
                m_lastMousePos = event->pos();
                m_sceneDirty = true;
                update();
                return;
            }
 
            m_lastMousePos = event->pos();
            return;
        }
 
        // Single-view rotation
        QPoint diff = event->pos() - m_lastMousePos;
        CameraController::applyMouseRotation(diff, m_cameraRotation);
        m_draggedSincePress = true;
 
        m_lastMousePos = event->pos();
        m_sceneDirty = true;
        update();
    } else {
        if (m_viewMode == MultiView) {
            updateSplitterCursor(event->pos());
        } else {
            unsetCursor();
        }
        castRay(event->pos());
    }
}
 
//=============================================================================================================
 
void BrainView::mouseReleaseEvent(QMouseEvent* event)
{
    if (event->button() == Qt::LeftButton && m_isDraggingSplitter) {
        m_isDraggingSplitter = false;
        m_activeSplitter = SplitterHit::None;
        saveMultiViewSettings();
        updateSplitterCursor(event->pos());
        return;
    }
 
    if (event->button() == Qt::LeftButton && m_viewMode == MultiView && m_perspectiveRotatedSincePress) {
        m_perspectiveRotatedSincePress = false;
        saveMultiViewSettings();
    }
 
    // Save pan offset after dragging in a planar viewport
    if (event->button() == Qt::LeftButton && m_viewMode == MultiView && !m_perspectiveRotatedSincePress) {
        saveMultiViewSettings();
    }
 
    // Emit surface click if a clean left-click (no rotate or pan drag) landed on geometry
    if (event->button() == Qt::LeftButton && !m_draggedSincePress) {
        castRay(event->pos());
        if (m_hasIntersection) {
            emit surfacePointClicked(m_lastIntersectionPoint);
        }
    }
 
    if (m_viewMode == MultiView) {
        updateSplitterCursor(event->pos());
    } else {
        unsetCursor();
    }
}
 
//=============================================================================================================
 
void BrainView::mouseDoubleClickEvent(QMouseEvent* event)
{
    if (event->button() == Qt::LeftButton) {
        castRay(event->pos());
        if (m_hasIntersection) {
            emit surfacePointDoubleClicked(m_lastIntersectionPoint);
            return;
        }
    }
    QRhiWidget::mouseDoubleClickEvent(event);
}
 
//=============================================================================================================
 
void BrainView::wheelEvent(QWheelEvent* event)
{
    const float delta = event->angleDelta().y() / 120.0f;
 
    if (m_viewMode == MultiView) {
        const int vp = viewportIndexAt(event->position().toPoint());
        if (vp >= 0 && vp < m_subViews.size()) {
            m_subViews[vp].zoom += delta;
            saveMultiViewSettings();
        }
    } else {
        m_singleView.zoom += delta;
        saveMultiViewSettings();
    }
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::keyPressEvent(QKeyEvent* event)
{
    if (event->key() == Qt::Key_S) {
        saveSnapshot();
    } else if (event->key() == Qt::Key_R) {
        m_cameraRotation = QQuaternion();
        logPerspectiveRotation("reset-initial");
        saveMultiViewSettings();
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
bool BrainView::loadSourceEstimate(const QString& lhPath, const QString& rhPath)
{
    return m_sourceManager.load(lhPath, rhPath, m_surfaces, m_activeSurfaceType);
}
 
//=============================================================================================================
 
void BrainView::onSourceEstimateLoaded(int numTimePoints)
{
    setVisualizationMode("Source Estimate");
    emit sourceEstimateLoaded(numTimePoints);
    setTimePoint(0);
}
 
//=============================================================================================================
 
void BrainView::setTimePoint(int index)
{
    m_sourceManager.setTimePoint(index, m_surfaces, m_singleView, m_subViews);
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setSourceColormap(const QString& name)
{
    m_sourceManager.setColormap(name);
    setTimePoint(m_sourceManager.currentTimePoint());
}
 
//=============================================================================================================
 
void BrainView::setSourceThresholds(float min, float mid, float max)
{
    m_sourceManager.setThresholds(min, mid, max);
    setTimePoint(m_sourceManager.currentTimePoint());
}
 
//=============================================================================================================
 
void BrainView::startRealtimeStreaming()
{
    setVisualizationMode("Source Estimate");
    m_sourceManager.startStreaming(m_surfaces, m_singleView, m_subViews);
}
 
//=============================================================================================================
 
void BrainView::stopRealtimeStreaming()
{
    m_sourceManager.stopStreaming();
}
 
//=============================================================================================================
 
bool BrainView::isRealtimeStreaming() const
{
    return m_sourceManager.isStreaming();
}
 
//=============================================================================================================
 
void BrainView::pushRealtimeSourceData(const Eigen::VectorXd& matData)
{
    m_sourceManager.pushData(matData);
}
 
//=============================================================================================================
 
void BrainView::setRealtimeInterval(int msec)
{
    m_sourceManager.setInterval(msec);
}
 
//=============================================================================================================
 
void BrainView::setRealtimeLooping(bool enabled)
{
    m_sourceManager.setLooping(enabled);
}
 
//=============================================================================================================
 
void BrainView::onRealtimeColorsAvailable(const QVector<uint32_t>& colorsLh,
                                          const QVector<uint32_t>& colorsRh)
{
    // Apply colors to all brain surfaces matching active surface types
    QSet<QString> activeTypes;
    activeTypes.insert(m_singleView.surfaceType);
    for (int i = 0; i < m_subViews.size(); ++i) {
        activeTypes.insert(m_subViews[i].surfaceType);
    }
 
    for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
        if (!it.value() || it.value()->tissueType() != BrainSurface::TissueBrain)
            continue;
 
        for (const QString& type : activeTypes) {
            if (it.key().endsWith(type)) {
                int hemi = it.value()->hemi();
                const QVector<uint32_t>& colors = (hemi == 0) ? colorsLh : colorsRh;
                if (!colors.isEmpty()) {
                    it.value()->applySourceEstimateColors(colors);
                }
                break;
            }
        }
    }
 
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
bool BrainView::loadSensorField(const QString& evokedPath, int aveIndex)
{
    auto evoked = DataLoader::loadEvoked(evokedPath, aveIndex);
    if (evoked.isEmpty())
        return false;
 
    // Preserve the current time point when switching between evoked sets
    // that share the same sensor configuration (same file, different condition).
    const int previousTimePoint = m_fieldMapper.timePoint();
    const bool canReuse = m_fieldMapper.hasMappingFor(evoked);
 
    m_fieldMapper.setEvoked(evoked);
 
    if (!canReuse) {
        // Sensor config changed — full rebuild required (also precomputes global range)
        if (!m_fieldMapper.buildMapping(m_surfaces, m_headToMriTrans, m_applySensorTrans)) {
            m_fieldMapper.setEvoked(FIFFLIB::FiffEvoked()); // Clear state on failure
            return false;
        }
    } else {
        // Mapping reused — recompute normalization for new evoked data
        m_fieldMapper.computeNormRange();
    }
 
    // Clamp preserved time point to the range of the new evoked data
    const int numTimes = static_cast<int>(m_fieldMapper.evoked().times.size());
    const int tp = qBound(0, previousTimePoint, numTimes - 1);
 
    emit sensorFieldLoaded(numTimes, tp);
    setSensorFieldTimePoint(tp);
    return true;
}
 
//=============================================================================================================
 
QStringList BrainView::probeEvokedSets(const QString& evokedPath)
{
    return DataLoader::probeEvokedSets(evokedPath);
}
 
//=============================================================================================================
 
void BrainView::setSensorFieldTimePoint(int index)
{
    if (!m_fieldMapper.isLoaded() || m_fieldMapper.evoked().isEmpty()) {
        return;
    }
 
    int maxIdx = static_cast<int>(m_fieldMapper.evoked().times.size()) - 1;
    if (maxIdx < 0) {
        return;
    }
 
    m_fieldMapper.setTimePoint(qBound(0, index, maxIdx));
    m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
    emit sensorFieldTimePointChanged(m_fieldMapper.timePoint(), m_fieldMapper.evoked().times(m_fieldMapper.timePoint()));
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setSensorFieldVisible(const QString& type, bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    if (type == "MEG") {
        profile.megFieldMap = visible;
    } else if (type == "EEG") {
        profile.eegFieldMap = visible;
    } else {
        return;
    }
 
    saveMultiViewSettings();
    m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setSensorFieldContourVisible(const QString& type, bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    if (type == "MEG") {
        profile.megFieldContours = visible;
    } else if (type == "EEG") {
        profile.eegFieldContours = visible;
    } else {
        return;
    }
 
    saveMultiViewSettings();
    m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setMegFieldMapOnHead(bool useHead)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    if (profile.megFieldMapOnHead == useHead && m_fieldMapper.megFieldMapOnHead() == useHead) {
        return;
    }
 
    profile.megFieldMapOnHead = useHead;
    m_fieldMapper.setMegFieldMapOnHead(useHead);
    saveMultiViewSettings();
    if (m_fieldMapper.isLoaded()) {
        m_fieldMapper.buildMapping(m_surfaces, m_headToMriTrans, m_applySensorTrans);
        m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
void BrainView::setSensorFieldColormap(const QString& name)
{
    if (m_fieldMapper.colormap() == name) {
        return;
    }
    m_fieldMapper.setColormap(name);
    m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
float BrainView::stcStep() const
{
    return m_sourceManager.tstep();
}
 
//=============================================================================================================
 
float BrainView::stcTmin() const
{
    return m_sourceManager.tmin();
}
 
//=============================================================================================================
 
int BrainView::stcNumTimePoints() const
{
    return m_sourceManager.numTimePoints();
}
 
//=============================================================================================================
 
int BrainView::closestSensorFieldIndex(float timeSec) const
{
    if (!m_fieldMapper.isLoaded() || m_fieldMapper.evoked().nave == -1 || m_fieldMapper.evoked().times.size() == 0) {
        return -1;
    }
 
    int bestIdx = 0;
    float bestDist = std::abs(m_fieldMapper.evoked().times(0) - timeSec);
    for (int i = 1; i < m_fieldMapper.evoked().times.size(); ++i) {
        float dist = std::abs(m_fieldMapper.evoked().times(i) - timeSec);
        if (dist < bestDist) {
            bestDist = dist;
            bestIdx = i;
        }
    }
    return bestIdx;
}
 
//=============================================================================================================
 
int BrainView::closestStcIndex(float timeSec) const
{
    return m_sourceManager.closestIndex(timeSec);
}
 
//=============================================================================================================
 
bool BrainView::sensorFieldTimeRange(float& tmin, float& tmax) const
{
    if (!m_fieldMapper.isLoaded() || m_fieldMapper.evoked().nave == -1 || m_fieldMapper.evoked().times.size() == 0) {
        return false;
    }
    tmin = m_fieldMapper.evoked().times(0);
    tmax = m_fieldMapper.evoked().times(m_fieldMapper.evoked().times.size() - 1);
    return true;
}
 
//=============================================================================================================
// ── Real-time sensor data streaming ────────────────────────────────────
//=============================================================================================================
 
void BrainView::startRealtimeSensorStreaming(const QString& modality)
{
    m_sensorStreamManager.startStreaming(modality, m_fieldMapper, m_surfaces);
}
 
//=============================================================================================================
 
void BrainView::stopRealtimeSensorStreaming()
{
    m_sensorStreamManager.stopStreaming();
}
 
//=============================================================================================================
 
bool BrainView::isRealtimeSensorStreaming() const
{
    return m_sensorStreamManager.isStreaming();
}
 
//=============================================================================================================
 
void BrainView::pushRealtimeSensorData(const Eigen::VectorXf& vecData)
{
    m_sensorStreamManager.pushData(vecData);
}
 
//=============================================================================================================
 
void BrainView::setRealtimeSensorInterval(int msec)
{
    m_sensorStreamManager.setInterval(msec);
}
 
//=============================================================================================================
 
void BrainView::setRealtimeSensorLooping(bool enabled)
{
    m_sensorStreamManager.setLooping(enabled);
}
 
//=============================================================================================================
 
void BrainView::setRealtimeSensorAverages(int numAvr)
{
    m_sensorStreamManager.setAverages(numAvr);
}
 
//=============================================================================================================
 
void BrainView::setRealtimeSensorColormap(const QString& name)
{
    m_sensorStreamManager.setColormap(name);
}
 
//=============================================================================================================
 
void BrainView::onSensorStreamColorsAvailable(const QString& surfaceKey,
                                              const QVector<uint32_t>& colors)
{
    if (surfaceKey.isEmpty() || !m_surfaces.contains(surfaceKey)) {
        return;
    }
 
    auto surface = m_surfaces[surfaceKey];
    if (surface && !colors.isEmpty()) {
        surface->applySourceEstimateColors(colors);
    }
 
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
bool BrainView::loadSensors(const QString& fifPath)
{
    if (!m_model)
        return false;
 
    auto r = DataLoader::loadSensors(fifPath, m_megHelmetOverridePath);
    if (!r.hasInfo && !r.hasDigitizer)
        return false;
 
    // Store Device→Head transform for later helmet surface reloads
    m_devHeadTrans = r.devHeadTrans;
    m_hasDevHead = r.hasDevHead;
 
    if (!r.megGradItems.isEmpty())
        m_model->addSensors("MEG/Grad", r.megGradItems);
    if (!r.megMagItems.isEmpty())
        m_model->addSensors("MEG/Mag", r.megMagItems);
    if (!r.eegItems.isEmpty())
        m_model->addSensors("EEG", r.eegItems);
 
    if (r.helmetSurface) {
        m_surfaces["sens_surface_meg"] = r.helmetSurface;
    } else {
        qWarning() << "BrainView::loadSensors: NO helmet surface returned from DataLoader!";
    }
 
    if (!r.digitizerPoints.isEmpty())
        m_model->addDigitizerData(r.digitizerPoints);
 
    // Extract cardinal dig points for later fiducial queries
    m_cardinalDigPoints.clear();
    for (const auto& dp : r.digitizerPoints) {
        if (dp.kind == FIFFV_POINT_CARDINAL)
            m_cardinalDigPoints.append(dp);
    }
 
    return true;
}
 
//=============================================================================================================
 
QMap<int, QVector3D> BrainView::cardinalFiducialsInMri() const
{
    QMap<int, QVector3D> result;
    if (m_cardinalDigPoints.isEmpty())
        return result;
 
    // Cardinal points are in Head coordinates; transform to MRI if available
    const bool haveTrans = (m_headToMriTrans.from != 0 || m_headToMriTrans.to != 0);
    QMatrix4x4 headToMri;
    headToMri.setToIdentity();
    if (haveTrans)
        headToMri = SURFACEKEYS::toQMatrix4x4(m_headToMriTrans.trans);
 
    for (const auto& dp : m_cardinalDigPoints) {
        const QVector3D posHead(dp.r[0], dp.r[1], dp.r[2]);
        result[dp.ident] = haveTrans ? headToMri.map(posHead) : posHead;
    }
    return result;
}
 
//=============================================================================================================
 
bool BrainView::bemTopVertexInMri(QVector3D& pos) const
{
    auto it = m_surfaces.find(QStringLiteral("bem_head"));
    if (it == m_surfaces.end() || !it.value())
        return false;
 
    const BrainSurface* surf = it.value().get();
    QVector3D bmin, bmax;
    surf->boundingBox(bmin, bmax);
 
    // Top of head = max Z in MRI/surface-RAS (Z = superior)
    pos = QVector3D((bmin.x() + bmax.x()) * 0.5f,
                    (bmin.y() + bmax.y()) * 0.5f,
                    bmax.z());
    return true;
}
 
//=============================================================================================================
 
bool BrainView::loadMegHelmetSurface(const QString& helmetFilePath)
{
    auto surface = DataLoader::loadHelmetSurface(helmetFilePath, m_devHeadTrans, m_hasDevHead);
    if (!surface) {
        qWarning() << "BrainView::loadMegHelmetSurface: DataLoader returned nullptr!";
        return false;
    }
 
    m_surfaces["sens_surface_meg"] = surface;
    refreshSensorTransforms();
    updateSceneBounds();
    m_sceneDirty = true;
    update();
    return true;
}
 
//=============================================================================================================
 
bool BrainView::loadDipoles(const QString& dipPath)
{
    if (!m_model)
        return false;
 
    auto ecdSet = DataLoader::loadDipoles(dipPath);
    if (ecdSet.size() == 0)
        return false;
    m_model->addDipoles(ecdSet);
    return true;
}
 
//=============================================================================================================
 
bool BrainView::loadNetwork(const CONNECTIVITYLIB::Network& network, const QString& name)
{
    if (network.getNodes().isEmpty())
        return false;
 
    m_network = std::make_unique<NetworkObject>();
    m_network->load(network);
    m_network->setVisible(true);
 
    // Also register in the tree model
    if (m_model)
        m_model->addNetwork(network, name);
 
    m_sceneDirty = true;
    update();
    return true;
}
 
//=============================================================================================================
 
void BrainView::setNetworkVisible(bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    profile.network = visible;
    m_networkVisible = visible;
    if (m_network)
        m_network->setVisible(visible);
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setNetworkThreshold(double threshold)
{
    if (m_network) {
        m_network->setThreshold(threshold);
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
void BrainView::setNetworkColormap(const QString& name)
{
    if (m_network) {
        m_network->setColormap(name);
        m_sceneDirty = true;
        update();
    }
}
 
//=============================================================================================================
 
bool BrainView::loadSourceSpace(const QString& fwdPath)
{
    if (!m_model)
        return false;
 
    auto srcSpace = DataLoader::loadSourceSpace(fwdPath);
    if (srcSpace.isEmpty())
        return false;
    m_model->addSourceSpace(srcSpace);
    return true;
}
 
//=============================================================================================================
 
void BrainView::setSourceSpaceVisible(bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    profile.sourceSpace = visible;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
bool BrainView::loadTransformation(const QString& transPath)
{
    FiffCoordTrans trans;
    if (!DataLoader::loadHeadToMriTransform(transPath, trans))
        return false;
 
    m_headToMriTrans = trans;
    refreshSensorTransforms();
    return true;
}
 
//==============================================================================
 
QMatrix4x4 BrainView::itemTransform(const QStandardItem* item) const
{
    const auto* absItem = dynamic_cast<const AbstractTreeItem*>(item);
    if (!absItem)
        return {};
    QMatrix4x4 trans = absItem->transform();
    // Sensors, digitizer points and dipoles are in head coordinates
    const int type = absItem->type();
    const bool inHead = type == AbstractTreeItem::itemTypeId(AbstractTreeItem::SensorItem) || type == AbstractTreeItem::itemTypeId(AbstractTreeItem::DigitizerItem) || type == AbstractTreeItem::itemTypeId(AbstractTreeItem::DipoleItem);
    if (inHead && m_applySensorTrans && !m_headToMriTrans.isEmpty())
        trans = SURFACEKEYS::toQMatrix4x4(m_headToMriTrans.trans) * trans;
    return trans;
}
 
//==============================================================================
 
void BrainView::refreshSensorTransforms()
{
    QMatrix4x4 qmat;
    if (m_applySensorTrans && !m_headToMriTrans.isEmpty()) {
        qmat = SURFACEKEYS::toQMatrix4x4(m_headToMriTrans.trans);
    }
 
    for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
        if ((it.key().startsWith("sens_") || it.key().startsWith("dig_")) && it.value()) {
            const QStandardItem* item = m_itemSurfaceMap.key(it.value());
            it.value()->applyTransform(item ? itemTransform(item) : qmat);
        }
    }
    for (auto it = m_itemDipoleMap.cbegin(); it != m_itemDipoleMap.cend(); ++it) {
        it.value()->applyTransform(itemTransform(it.key()));
    }
 
    if (m_fieldMapper.isLoaded()) {
        m_fieldMapper.buildMapping(m_surfaces, m_headToMriTrans, m_applySensorTrans);
        m_fieldMapper.apply(m_surfaces, m_singleView, m_subViews);
    }
}
 
//=============================================================================================================
 
void BrainView::castRay(const QPoint& pos)
{
    // 1. Setup Matrix Stack (Must match render exactly, including multiview pane layout)
    const QSize outputSize = size();
 
    const auto enabledViewports = enabledViewportIndices();
 
    const int numEnabled = enabledViewports.size();
    int activeSlot = 0;
    QRect activePane(0, 0, outputSize.width(), outputSize.height());
 
    bool hasValidPane = true;
    if (m_viewMode == MultiView && numEnabled > 1) {
        bool foundSlot = false;
        for (int slot = 0; slot < numEnabled; ++slot) {
            const QRect pane = multiViewSlotRect(slot, numEnabled, outputSize);
            if (pane.contains(pos)) {
                activeSlot = slot;
                activePane = pane;
                foundSlot = true;
                break;
            }
        }
 
        hasValidPane = foundSlot;
    }
 
    const int vp = (m_viewMode == MultiView) ? enabledViewports[activeSlot] : 0;
    const SubView& sv = (m_viewMode == MultiView) ? m_subViews[vp] : m_singleView;
 
    const QVector3D effectiveCenter2 = m_cameraFocusOverride ? m_cameraFocusCenter : m_sceneCenter;
    const float effectiveSize2 = m_cameraFocusOverride ? m_cameraFocusSize : m_sceneSize;
    m_camera.setSceneCenter(effectiveCenter2);
    m_camera.setSceneSize(effectiveSize2);
    m_camera.setRotation(m_cameraRotation);
    m_camera.setZoom(m_singleView.zoom);
    const float aspect = float(std::max(1, activePane.width())) / float(std::max(1, activePane.height()));
    const CameraResult cam = (m_viewMode == MultiView)
        ? m_camera.computeMultiView(sv, aspect)
        : m_camera.computeSingleView(aspect);
    QMatrix4x4 pvm = cam.projection * cam.view * cam.model;
 
    // ── Unproject screen position to world-space ray ───────────────────
    QVector3D rayOrigin, rayDir;
    if (!RayPicker::unproject(pos, activePane, pvm, rayOrigin, rayDir))
        return;
 
    // ── Pick against all scene geometry ────────────────────────────────
    RayHit pickResult;
    if (hasValidPane) {
        pickResult = RayPicker::pick(rayOrigin, rayDir, sv, m_surfaces, m_itemSurfaceMap, m_itemDipoleMap);
    }
    m_hasIntersection = pickResult.hit;
    if (pickResult.hit) {
        m_lastIntersectionPoint = pickResult.hitPoint;
    }
 
    QStandardItem* hitItem = pickResult.item;
    int hitIndex = pickResult.vertexIndex;
 
    // ── Build hover label ──────────────────────────────────────────────
    const QString displayLabel = RayPicker::buildLabel(pickResult, m_itemSurfaceMap, m_surfaces);
    const QString& hitKey = pickResult.surfaceKey;
    int currentRegionId = pickResult.regionId;
 
    if (displayLabel != m_hoveredRegion) {
        m_hoveredRegion = displayLabel;
        emit hoveredRegionChanged(m_hoveredRegion);
        if (m_regionLabel) {
            if (m_hoveredRegion.isEmpty()) {
                m_regionLabel->hide();
            } else {
                m_regionLabel->setText(m_hoveredRegion);
                m_regionLabel->show();
            }
        }
    }
 
    QString hoveredSurfaceKey;
    if (hitKey.startsWith("sens_surface_meg")) {
        hoveredSurfaceKey = hitKey;
    }
 
    if (hitItem != m_hoveredItem || hitIndex != m_hoveredIndex || hoveredSurfaceKey != m_hoveredSurfaceKey) {
        // Deselect previous
        if (m_hoveredItem) {
            if (m_itemSurfaceMap.contains(m_hoveredItem)) {
                m_itemSurfaceMap[m_hoveredItem]->setSelected(false);
                m_itemSurfaceMap[m_hoveredItem]->setSelectedRegion(-1);
                m_itemSurfaceMap[m_hoveredItem]->setSelectedVertexRange(-1, 0);
            } else if (m_itemDipoleMap.contains(m_hoveredItem)) {
                m_itemDipoleMap[m_hoveredItem]->setSelected(m_hoveredIndex, false);
            }
        }
        if (!m_hoveredSurfaceKey.isEmpty() && m_surfaces.contains(m_hoveredSurfaceKey)) {
            m_surfaces[m_hoveredSurfaceKey]->setSelected(false);
            m_surfaces[m_hoveredSurfaceKey]->setSelectedRegion(-1);
            m_surfaces[m_hoveredSurfaceKey]->setSelectedVertexRange(-1, 0);
        }
 
        m_hoveredItem = hitItem;
        m_hoveredIndex = hitIndex;
        m_hoveredSurfaceKey = hoveredSurfaceKey;
 
        if (m_hoveredItem) {
            // Select new
            if (m_itemSurfaceMap.contains(m_hoveredItem)) {
                // Check if this is a digitizer batched mesh — highlight single sphere
                AbstractTreeItem* absHitSel = dynamic_cast<AbstractTreeItem*>(m_hoveredItem);
                bool isDigitizer = absHitSel &&
                    (absHitSel->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::DigitizerItem));
 
                if (isDigitizer && m_hoveredIndex >= 0) {
                    const int vertsPerSphere = MeshFactory::sphereVertexCount();
                    int sphereIdx = m_hoveredIndex / vertsPerSphere;
                    m_itemSurfaceMap[m_hoveredItem]->setSelectedVertexRange(
                        sphereIdx * vertsPerSphere, vertsPerSphere);
                } else if (currentRegionId != -1) {
                    m_itemSurfaceMap[m_hoveredItem]->setSelectedRegion(currentRegionId);
                    // Keep the surface selected so the shader gold glow
                    // activates.  The old CPU vertex-color region highlight
                    // was removed to avoid buffer re-uploads on WASM.
                    m_itemSurfaceMap[m_hoveredItem]->setSelected(true);
                } else {
                    m_itemSurfaceMap[m_hoveredItem]->setSelected(true);
                    m_itemSurfaceMap[m_hoveredItem]->setSelectedRegion(-1);
                }
            } else if (m_itemDipoleMap.contains(m_hoveredItem)) {
                m_itemDipoleMap[m_hoveredItem]->setSelected(m_hoveredIndex, true);
            }
        } else if (!m_hoveredSurfaceKey.isEmpty() && m_surfaces.contains(m_hoveredSurfaceKey)) {
            m_surfaces[m_hoveredSurfaceKey]->setSelected(true);
            m_surfaces[m_hoveredSurfaceKey]->setSelectedRegion(-1);
        }
    } else if (m_hoveredItem && m_itemSurfaceMap.contains(m_hoveredItem)) {
        AbstractTreeItem* absHitUpd = dynamic_cast<AbstractTreeItem*>(m_hoveredItem);
        bool isDigitizer = absHitUpd &&
            (absHitUpd->type() == AbstractTreeItem::itemTypeId(AbstractTreeItem::DigitizerItem));
 
        if (isDigitizer && m_hoveredIndex >= 0) {
            const int vertsPerSphere = MeshFactory::sphereVertexCount();
            int sphereIdx = m_hoveredIndex / vertsPerSphere;
            m_itemSurfaceMap[m_hoveredItem]->setSelectedVertexRange(
                sphereIdx * vertsPerSphere, vertsPerSphere);
        } else if (currentRegionId != -1) {
            m_itemSurfaceMap[m_hoveredItem]->setSelectedRegion(currentRegionId);
            m_itemSurfaceMap[m_hoveredItem]->setSelected(true);
        } else {
            m_itemSurfaceMap[m_hoveredItem]->setSelectedRegion(-1);
            m_itemSurfaceMap[m_hoveredItem]->setSelected(true);
        }
    } else if (!m_hoveredSurfaceKey.isEmpty() && m_surfaces.contains(m_hoveredSurfaceKey)) {
        m_surfaces[m_hoveredSurfaceKey]->setSelected(true);
    }
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::showViewportPresetMenu(int viewport, const QPoint& globalPos)
{
    if (viewport < 0 || viewport >= m_subViews.size()) {
        return;
    }
 
    QMenu menu;
    QAction* topAction = menu.addAction("Top");
    QAction* perspectiveAction = menu.addAction("Perspective");
    QAction* frontAction = menu.addAction("Front");
    QAction* leftAction = menu.addAction("Left");
    menu.addSeparator();
    QAction* bottomAction = menu.addAction("Bottom");
    QAction* backAction = menu.addAction("Back");
    QAction* rightAction = menu.addAction("Right");
 
    const int currentPreset = std::clamp(m_subViews[viewport].preset, 0, 6);
    topAction->setCheckable(true);
    perspectiveAction->setCheckable(true);
    frontAction->setCheckable(true);
    leftAction->setCheckable(true);
    bottomAction->setCheckable(true);
    backAction->setCheckable(true);
    rightAction->setCheckable(true);
 
    topAction->setChecked(currentPreset == 0);
    perspectiveAction->setChecked(currentPreset == 1);
    frontAction->setChecked(currentPreset == 2);
    leftAction->setChecked(currentPreset == 3);
    bottomAction->setChecked(currentPreset == 4);
    backAction->setChecked(currentPreset == 5);
    rightAction->setChecked(currentPreset == 6);
 
    QAction* selected = menu.exec(globalPos);
    if (!selected) {
        return;
    }
 
    int newPreset = currentPreset;
    if (selected == topAction) {
        newPreset = 0;
    } else if (selected == perspectiveAction) {
        newPreset = 1;
    } else if (selected == frontAction) {
        newPreset = 2;
    } else if (selected == leftAction) {
        newPreset = 3;
    } else if (selected == bottomAction) {
        newPreset = 4;
    } else if (selected == backAction) {
        newPreset = 5;
    } else if (selected == rightAction) {
        newPreset = 6;
    }
 
    if (newPreset == currentPreset) {
        return;
    }
 
    m_subViews[viewport].preset = newPreset;
    saveMultiViewSettings();
    updateOverlayLayout();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
// Data removal
//=============================================================================================================
 
void BrainView::removeSurfacesByPrefix(const QStringList& prefixes)
{
    // Remove the tree rows first: they are found through the surfaces being removed
    for (auto it = m_itemSurfaceMap.begin(); it != m_itemSurfaceMap.end();) {
        const QString key = m_surfaces.key(it.value());
        const bool remove = std::any_of(prefixes.cbegin(), prefixes.cend(), [&key](const QString& prefix) { return key.startsWith(prefix); });
        if (!remove) {
            ++it;
            continue;
        }
        if (m_model) {
            QStandardItem* item = const_cast<QStandardItem*>(it.key());
            if (item->parent())
                item->parent()->removeRow(item->row());
            else
                m_model->removeRow(item->row());
        }
        it = m_itemSurfaceMap.erase(it);
    }
    for (auto it = m_surfaces.begin(); it != m_surfaces.end();) {
        const QString& key = it.key();
        if (std::any_of(prefixes.cbegin(), prefixes.cend(), [&key](const QString& prefix) { return key.startsWith(prefix); }))
            it = m_surfaces.erase(it);
        else
            ++it;
    }
    updateSceneBounds();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::clearSurfaces()
{
    m_activeSurface.reset();
    m_activeSurfaceType.clear();
    removeSurfacesByPrefix({QStringLiteral("lh_"), QStringLiteral("rh_")});
}
 
//=============================================================================================================
 
void BrainView::clearBem()
{
    removeSurfacesByPrefix({QStringLiteral("bem_")});
}
 
//=============================================================================================================
 
void BrainView::clearSourceEstimate()
{
    m_sourceManager.stopStreaming();
    for (auto it = m_surfaces.begin(); it != m_surfaces.end(); ++it) {
        if (it.key().startsWith("lh_") || it.key().startsWith("rh_")) {
            it.value()->clearSourceEstimateColors();
        }
    }
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::clearDipoles()
{
    m_dipoles.reset();
 
    // Remove dipole items from model and maps
    for (auto it = m_itemDipoleMap.begin(); it != m_itemDipoleMap.end();) {
        if (m_model) {
            QStandardItem* mutableItem = const_cast<QStandardItem*>(it.key());
            if (mutableItem->parent())
                mutableItem->parent()->removeRow(mutableItem->row());
            else
                m_model->removeRow(mutableItem->row());
        }
        it = m_itemDipoleMap.erase(it);
    }
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::clearSourceSpace()
{
    removeSurfacesByPrefix({QStringLiteral("srcsp_")});
}
 
//=============================================================================================================
 
void BrainView::setLiveMarkers(const QVector<LiveMarker>& markers)
{
    // Remove previous live surfaces (no scene-bounds update).
    for (auto it = m_surfaces.begin(); it != m_surfaces.end();) {
        if (it.key().startsWith(QLatin1String("dig_live_")))
            it = m_surfaces.erase(it);
        else
            ++it;
    }
 
    for (int i = 0; i < markers.size(); ++i) {
        auto surf = MeshFactory::createBatchedSpheres(
            {markers[i].position}, markers[i].radius, markers[i].color);
        surf->setVisible(true);
        const QString prefix = markers[i].transparent
            ? QStringLiteral("dig_live_t_%1")
            : QStringLiteral("dig_live_%1");
        m_surfaces[prefix.arg(i)] = surf;
    }
 
    // Intentionally NO updateSceneBounds() — the camera stays locked.
    m_sceneDirty = true;
    update();
}
 
void BrainView::clearLiveMarkers()
{
    bool removed = false;
    for (auto it = m_surfaces.begin(); it != m_surfaces.end();) {
        if (it.key().startsWith(QLatin1String("dig_live_"))) {
            it = m_surfaces.erase(it);
            removed = true;
        } else {
            ++it;
        }
    }
    if (removed) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setLiveRay(const QVector3D& from, const QVector3D& to,
                           const QColor& color, float radius)
{
    // Remove previous ray surface
    m_surfaces.remove(QLatin1String("dig_ray_0"));
 
    auto surf = MeshFactory::createCylinder(from, to, radius, color);
    surf->setVisible(true);
    m_surfaces[QStringLiteral("dig_ray_0")] = surf;
 
    m_sceneDirty = true;
    update();
}
 
void BrainView::clearLiveRay()
{
    if (m_surfaces.remove(QLatin1String("dig_ray_0"))) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setProbeVisualization(const QVector3D& tip, const QVector3D& direction,
                                      float length, const QColor& color,
                                      const QColor& glowColor,
                                      const QQuaternion& orientation)
{
    // Remove previous probe surfaces
    m_surfaces.remove(QLatin1String("dig_probe_shaft"));
    m_surfaces.remove(QLatin1String("dig_probe_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_tipglow"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_x"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_y"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_z"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_x_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_y_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_z_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_xn_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_yn_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_axis_zn_tip"));
    m_surfaces.remove(QLatin1String("dig_probe_cross_x"));
    m_surfaces.remove(QLatin1String("dig_probe_cross_y"));
    m_surfaces.remove(QLatin1String("dig_probe_cross_z"));
 
    // Shaft: only drawn when length > 0
    if (length > 0.0f && !direction.isNull()) {
        const QVector3D shaftEnd = tip - direction * length;
        constexpr float kShaftRadius = 0.0015f;
        auto shaft = MeshFactory::createCylinder(tip, shaftEnd, kShaftRadius, color);
        shaft->setVisible(true);
        m_surfaces[QStringLiteral("dig_probe_shaft")] = shaft;
    }
 
    // Tip: the focal point of the probe
    constexpr float kTipRadius = 0.0010f; // 1.0 mm
    auto tipSurf = MeshFactory::createBatchedSpheres({tip}, kTipRadius, color);
    tipSurf->setVisible(true);
    m_surfaces[QStringLiteral("dig_probe_tip")] = tipSurf;
 
    // Glow aura: subtle halo around the tip
    if (glowColor.alpha() > 0) {
        constexpr float kGlowTipRadius = 0.003f; // 3 mm glow
        auto tipGlow = MeshFactory::createBatchedSpheres({tip}, kGlowTipRadius, glowColor);
        tipGlow->setVisible(true);
        m_surfaces[QStringLiteral("dig_probe_tipglow")] = tipGlow;
    }
 
    // --- Crosshair rotated with probe orientation (X=red, Y=green, Z=blue) ---
    if (!orientation.isNull()) {
        constexpr float kCrossLen = 0.008f;     // 8 mm per arm
        constexpr float kCrossRadius = 0.0002f; // 0.2 mm — hair-thin
 
        const QVector3D xDir = orientation.rotatedVector(QVector3D(1, 0, 0)).normalized();
        const QVector3D yDir = orientation.rotatedVector(QVector3D(0, 1, 0)).normalized();
        const QVector3D zDir = orientation.rotatedVector(QVector3D(0, 0, 1)).normalized();
 
        struct CrossDef
        {
            QVector3D dir;
            QColor color;
            QString key;
        };
        const CrossDef cross[] = {
            {xDir, QColor(255, 50, 50, 160), QStringLiteral("dig_probe_cross_x")},
            {yDir, QColor(50, 220, 50, 160), QStringLiteral("dig_probe_cross_y")},
            {zDir, QColor(80, 140, 255, 160), QStringLiteral("dig_probe_cross_z")},
        };
        for (const auto& c : cross) {
            const QVector3D from = tip - c.dir * kCrossLen;
            const QVector3D to = tip + c.dir * kCrossLen;
            auto cyl = MeshFactory::createCylinder(from, to, kCrossRadius, c.color);
            cyl->setVisible(true);
            m_surfaces[c.key] = cyl;
        }
    }
 
    // --- Debug coordinate frame (X=red, Y=green, Z=blue) ---
    if (!orientation.isNull()) {
        constexpr float kAxisLen = 0.012f;     // 12 mm per axis arm
        constexpr float kAxisRadius = 0.0004f; // 0.4 mm — thin axis lines
        constexpr float kPosTipR = 0.0012f;    // 1.2 mm — positive-end sphere
        constexpr float kNegTipR = 0.0006f;    // 0.6 mm — negative-end dot (smaller)
 
        const QVector3D xDir = orientation.rotatedVector(QVector3D(1, 0, 0)).normalized();
        const QVector3D yDir = orientation.rotatedVector(QVector3D(0, 1, 0)).normalized();
        const QVector3D zDir = orientation.rotatedVector(QVector3D(0, 0, 1)).normalized();
 
        struct AxisDef
        {
            QVector3D dir;
            QColor color;
            QString cylKey, posTipKey, negTipKey;
        };
        const AxisDef axes[] = {
            {xDir, QColor(255, 50, 50), QStringLiteral("dig_probe_axis_x"),
             QStringLiteral("dig_probe_axis_x_tip"), QStringLiteral("dig_probe_axis_xn_tip")},
            {yDir, QColor(50, 220, 50), QStringLiteral("dig_probe_axis_y"),
             QStringLiteral("dig_probe_axis_y_tip"), QStringLiteral("dig_probe_axis_yn_tip")},
            {zDir, QColor(80, 140, 255), QStringLiteral("dig_probe_axis_z"),
             QStringLiteral("dig_probe_axis_z_tip"), QStringLiteral("dig_probe_axis_zn_tip")},
        };
 
        for (const auto& a : axes) {
            const QVector3D posEnd = tip + a.dir * kAxisLen;
            const QVector3D negEnd = tip - a.dir * kAxisLen;
 
            // Full axis cylinder from -axis to +axis through the tip
            auto cyl = MeshFactory::createCylinder(negEnd, posEnd, kAxisRadius, a.color);
            cyl->setVisible(true);
            m_surfaces[a.cylKey] = cyl;
 
            // Positive tip: larger sphere (the "+" end)
            auto posTip = MeshFactory::createBatchedSpheres({posEnd}, kPosTipR, a.color);
            posTip->setVisible(true);
            m_surfaces[a.posTipKey] = posTip;
 
            // Negative tip: smaller dot (the "-" end)
            QColor dimColor = a.color;
            dimColor.setAlpha(120);
            auto negTip = MeshFactory::createBatchedSpheres({negEnd}, kNegTipR, dimColor);
            negTip->setVisible(true);
            m_surfaces[a.negTipKey] = negTip;
        }
    }
 
    m_sceneDirty = true;
    update();
}
 
void BrainView::clearProbeVisualization()
{
    // QMap::remove returns the number of entries removed, not a bool, so sum
    // the counts rather than OR-ing an integer into a bool.
    qsizetype nRemoved = 0;
    for (const char* key : {"dig_probe_shaft",
                            "dig_probe_tip",
                            "dig_probe_tipglow",
                            "dig_probe_axis_x",
                            "dig_probe_axis_y",
                            "dig_probe_axis_z",
                            "dig_probe_axis_x_tip",
                            "dig_probe_axis_y_tip",
                            "dig_probe_axis_z_tip",
                            "dig_probe_axis_xn_tip",
                            "dig_probe_axis_yn_tip",
                            "dig_probe_axis_zn_tip",
                            "dig_probe_cross_x",
                            "dig_probe_cross_y",
                            "dig_probe_cross_z"}) {
        nRemoved += m_surfaces.remove(QLatin1String(key));
    }
 
    const bool removed = nRemoved > 0;
    if (removed) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setStaticMarkers(const QVector<LiveMarker>& markers)
{
    for (auto it = m_surfaces.begin(); it != m_surfaces.end();) {
        if (it.key().startsWith(QLatin1String("dig_static_")))
            it = m_surfaces.erase(it);
        else
            ++it;
    }
 
    for (int i = 0; i < markers.size(); ++i) {
        auto surf = MeshFactory::createBatchedSpheres(
            {markers[i].position}, markers[i].radius, markers[i].color);
        surf->setVisible(true);
        m_surfaces[QStringLiteral("dig_static_%1").arg(i)] = surf;
    }
 
    m_sceneDirty = true;
    update();
}
 
void BrainView::clearStaticMarkers()
{
    bool removed = false;
    for (auto it = m_surfaces.begin(); it != m_surfaces.end();) {
        if (it.key().startsWith(QLatin1String("dig_static_"))) {
            it = m_surfaces.erase(it);
            removed = true;
        } else {
            ++it;
        }
    }
    if (removed) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setCameraFocusOverride(const QVector3D& center, float size)
{
    m_cameraFocusOverride = true;
    m_cameraFocusCenter = center;
    m_cameraFocusSize = size;
    m_sceneDirty = true;
    update();
}
 
void BrainView::clearCameraFocusOverride()
{
    if (!m_cameraFocusOverride)
        return;
    m_cameraFocusOverride = false;
    updateSceneBounds();
    m_sceneDirty = true;
    update();
}
 
void BrainView::clearSensors()
{
    m_devHeadTrans = QMatrix4x4();
    m_hasDevHead = false;
    removeSurfacesByPrefix({QStringLiteral("sens_"), QStringLiteral("dig_")});
}
 
//=============================================================================================================
 
void BrainView::clearEvoked()
{
    m_fieldMapper.setEvoked(FIFFLIB::FiffEvoked());
    m_sensorStreamManager.stopStreaming();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::clearTransformation()
{
    m_headToMriTrans = FIFFLIB::FiffCoordTrans();
    refreshSensorTransforms();
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::clearNetwork()
{
    m_network.reset();
    m_networkVisible = false;
 
    // Remove network items from model
    if (m_model) {
        for (int r = m_model->rowCount() - 1; r >= 0; --r) {
            QStandardItem* item = m_model->item(r);
            if (item && item->text() == "Networks") {
                m_model->removeRow(r);
                break;
            }
        }
    }
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::stopAllStreaming()
{
    m_sourceManager.cancelLoading();
    m_sourceManager.stopStreaming();
    m_sensorStreamManager.stopStreaming();
}
 
//=============================================================================================================
// Video overlay public API
//=============================================================================================================
 
void BrainView::setVideoOverlayEnabled(bool enabled)
{
    if (!m_videoOverlay)
        return;
    if (m_videoOverlay->isEnabled() == enabled)
        return;
    m_videoOverlay->setEnabled(enabled);
    m_sceneDirty = true;
    update();
}
 
bool BrainView::isVideoOverlayEnabled() const
{
    return m_videoOverlay && m_videoOverlay->isEnabled();
}
 
void BrainView::setVideoOverlayFocusPosition(const QVector3D& position)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setFocusPosition(position);
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setVideoOverlayUpHint(const QVector3D& dir)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setUpHint(dir);
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setVideoOverlaySize(float meters)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setSizeMeters(std::max(0.001f, meters));
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setVideoOverlayOpacity(float opacity)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setOpacity(std::clamp(opacity, 0.0f, 1.0f));
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::pushVideoOverlayFrame(const QImage& frame)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setFrame(frame);
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setVideoDepthEnabled(bool enabled)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setDepthEnabled(enabled);
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setVideoDepthScale(float scale)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setDepthScale(std::clamp(scale, 0.0f, 1.0f));
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::setVideoDepthSteps(int steps)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setDepthSteps(std::clamp(steps, 8, 64));
    if (m_videoOverlay->isEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
void BrainView::pushVideoDepthFrame(const QImage& depthFrame)
{
    if (!m_videoOverlay)
        return;
    m_videoOverlay->setDepthFrame(depthFrame);
    if (m_videoOverlay->isEnabled() && m_videoOverlay->isDepthEnabled()) {
        m_sceneDirty = true;
        update();
    }
}
 
bool BrainView::intersectWorldRay(const QVector3D& origin, const QVector3D& direction, QVector3D& hitPoint) const
{
    // Test against ALL surfaces (no SubView visibility filter) so
    // the optical ray always finds the head even if it's hidden in
    // the first SubView of a multi-view layout.
    float closestDist = std::numeric_limits<float>::max();
    bool found = false;
 
    // Always test the BEM head surface first (even when hidden) — the
    // optical projection cares about the outermost physical shell.
    auto headIt = m_surfaces.constFind(QStringLiteral("bem_head"));
    if (headIt != m_surfaces.cend() && headIt.value()) {
        float dist = 0.0f;
        int vertexIdx = -1;
        if (headIt.value()->intersects(origin, direction, dist, vertexIdx) && dist < closestDist) {
            closestDist = dist;
            hitPoint = origin + dist * direction;
            found = true;
        }
    }
 
    // Fall back to any other visible surface if the head wasn't hit.
    if (!found) {
        for (auto it = m_surfaces.cbegin(); it != m_surfaces.cend(); ++it) {
            const auto& surf = it.value();
            if (!surf || !surf->isVisible())
                continue;
            float dist = 0.0f;
            int vertexIdx = -1;
            if (surf->intersects(origin, direction, dist, vertexIdx) && dist < closestDist) {
                closestDist = dist;
                hitPoint = origin + dist * direction;
                found = true;
            }
        }
    }
    return found;
}
 
//=============================================================================================================
// MRI slice rendering
//=============================================================================================================
 
void BrainView::setSlice(int slotIndex, DISP3DLIB::SliceObject* slice)
{
    if (slotIndex < 0 || slotIndex >= kMaxSliceSlots)
        return;
    m_slices[slotIndex] = slice;
    m_sceneDirty = true;
    update();
}
 
void BrainView::setSliceVisible(int slotIndex, bool visible)
{
    if (slotIndex < 0 || slotIndex >= kMaxSliceSlots)
        return;
    m_sliceVisible[slotIndex] = visible;
    m_sceneDirty = true;
    update();
}
 
//=============================================================================================================
 
void BrainView::setMriSlicesVisible(bool visible)
{
    auto& profile = visibilityProfileForTarget(m_visualizationEditTarget);
    profile.mriSlices = visible;
    saveMultiViewSettings();
    m_sceneDirty = true;
    update();
}
 
} // namespace DISP3DLIB