src/controllers/ViewerCoordinator.cpp - master - klischa/AstraScanner2

src/controllers/ViewerCoordinator.cpp
147 строк5 KB
k k
fix: viewer display, cloud counter, RGB preview, timer initialization
15 июл 2026, 12:58
15 июл 2026, 12:58cb20a77
#include "ViewerCoordinator.h"

#include <QVTKOpenGLNativeWidget.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <vtkRenderer.h>

ViewerCoordinator::ViewerCoordinator(QObject *parent) : QObject(parent)
{
}

void ViewerCoordinator::setupMainViewer(QVTKOpenGLNativeWidget *widget)
{
    if (!widget) return;
    m_mainWidget = widget;

    vtkObject::GlobalWarningDisplayOff();
    auto renderer = vtkSmartPointer<vtkRenderer>::New();
    auto renderWindow = m_mainWidget->renderWindow();
    renderWindow->AddRenderer(renderer);

    m_mainViewer.reset(new pcl::visualization::PCLVisualizer(renderer, renderWindow, "viewer", false));
    m_mainViewer->setupInteractor(m_mainWidget->interactor(), renderWindow);
    m_mainViewer->setBackgroundColor(0.1, 0.1, 0.1);
    m_mainViewer->addCoordinateSystem(0.2);
    m_mainViewer->initCameraParameters();
    m_mainViewer->setCameraPosition(0, 0, -2, 0, 0, 1, 0, -1, 0);
    m_mainViewer->getRenderWindow()->SetDesiredUpdateRate(0.0);
}

void ViewerCoordinator::setupProcessingViewer(QVTKOpenGLNativeWidget *widget)
{
    if (!widget) return;
    m_processingWidget = widget;

    vtkObject::GlobalWarningDisplayOff();
    auto procRenderer = vtkSmartPointer<vtkRenderer>::New();
    auto procRenderWindow = m_processingWidget->renderWindow();
    procRenderWindow->AddRenderer(procRenderer);
    m_processingViewer.reset(new pcl::visualization::PCLVisualizer(procRenderer, procRenderWindow, "proc_viewer", false));
    m_processingViewer->setupInteractor(m_processingWidget->interactor(), procRenderWindow);
    m_processingViewer->setBackgroundColor(0.15, 0.15, 0.15);
    m_processingViewer->addCoordinateSystem(0.2);
    m_processingViewer->initCameraParameters();
    m_processingViewer->setCameraPosition(0, 0, -2, 0, 0, 1, 0, -1, 0);
    m_processingViewer->getRenderWindow()->SetDesiredUpdateRate(0.0);
}

void ViewerCoordinator::close()
{
    if (m_mainViewer) {
        m_mainViewer->close();
    }
}

void ViewerCoordinator::clearMainViewer()
{
    if (!m_mainViewer) return;
    m_mainViewer->removeAllPointClouds();
    if (!m_meshViewerId.isEmpty()) {
        m_mainViewer->removePolygonMesh(m_meshViewerId.toStdString());
        m_meshViewerId.clear();
    }
    if (m_mainWidget) m_mainWidget->update();
}

void ViewerCoordinator::clearProcessingViewer()
{
    if (!m_processingViewer) return;
    m_processingViewer->removeAllPointClouds();
    if (m_processingWidget) m_processingWidget->update();
}

void ViewerCoordinator::updateAccumulatedCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Ptr &cloud)
{
    if (!m_mainViewer || !cloud || cloud->empty()) return;
    bool updated = m_mainViewer->updatePointCloud(cloud, "accumulated");
    if (!updated) {
        m_mainViewer->removeAllPointClouds();
        m_mainViewer->addPointCloud(cloud, "accumulated");
        m_mainViewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "accumulated");
        m_mainViewer->resetCamera();
    }
}

void ViewerCoordinator::showLivePreviewCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Ptr &cloud)
{
    if (!m_mainViewer || !cloud || cloud->empty()) return;
    m_mainViewer->removeAllPointClouds();
    m_mainViewer->addPointCloud(cloud, "live");
    m_mainViewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "live");
    if (m_mainWidget) m_mainWidget->update();
}

void ViewerCoordinator::showAccumulatedCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Ptr &cloud, bool removeMesh)
{
    if (removeMesh) {
        removeDisplayedMesh();
    }
    updateAccumulatedCloud(cloud);
    if (m_mainWidget && m_mainWidget->renderWindow()) {
        try {
            m_mainWidget->renderWindow()->Render();
            qInfo() << "[Viewer] Render ok, visible=" << m_mainWidget->isVisible()
                     << "size=" << m_mainWidget->size().width() << "x" << m_mainWidget->size().height()
                     << "rendererCount=" << m_mainWidget->renderWindow()->GetRenderers()->GetNumberOfItems();
        } catch (...) {
            qCritical() << "[Viewer] Exception during Render()";
        }
    } else {
        qWarning() << "[Viewer] renderWindow=" << (void*)m_mainWidget->renderWindow()
                   << " m_mainWidget=" << (void*)m_mainWidget;
    }
}

void ViewerCoordinator::showMesh(const pcl::PolygonMesh &mesh, const QString &meshId)
{
    if (!m_mainViewer) return;
    m_mainViewer->removeAllPointClouds();
    if (!m_meshViewerId.isEmpty()) {
        m_mainViewer->removePolygonMesh(m_meshViewerId.toStdString());
    }
    m_meshViewerId = meshId;
    m_mainViewer->addPolygonMesh(mesh, m_meshViewerId.toStdString());
    if (m_mainWidget) m_mainWidget->renderWindow()->Render();
}

void ViewerCoordinator::removeDisplayedMesh()
{
    if (!m_mainViewer || m_meshViewerId.isEmpty()) return;
    m_mainViewer->removePolygonMesh(m_meshViewerId.toStdString());
    m_meshViewerId.clear();
}

void ViewerCoordinator::updateProcessingCloud(const pcl::PointCloud<pcl::PointXYZRGB>::Ptr &cloud)
{
    if (!m_processingViewer || !m_processingWidget) return;
    if (!cloud || cloud->empty()) {
        m_processingViewer->removeAllPointClouds();
        m_processingWidget->update();
        return;
    }
    m_processingViewer->removeAllPointClouds();
    m_processingViewer->addPointCloud(cloud, "proc_cloud");
    m_processingViewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "proc_cloud");
    m_processingViewer->resetCamera();
    m_processingWidget->update();
}