JSBTDieBondH/View/die-bonder-ui/OriginalWnd/SingleCameraOperationWnd.cpp

#include "SingleCameraOperationWnd.h"
#include "ui_SingleCameraOperationWnd.h"
#include <QSettings>
#include <QCloseEvent>
#include <QVBoxLayout>
#include <QDebug>
#include <QTimer>
#include "CameraMaterialGroupWnd/CameraImage/CameraImageHandler.h"

SingleCameraOperationWnd::SingleCameraOperationWnd(QWidget* parent)
    : JOriginalMainWnd(parent)
    , ui(new Ui::SingleCameraOperationWnd), scaleFactor(1.0)
{
    ui->setupUi(this);
    ui->viewwidgetgroup->resizeSingleUI(true);
    ui->lightJoystickSwitchPage->resizeSingleUI();
    isShow = true;
    connect(ui->viewwidgetgroup, &ControlOperationPage::send_ComboBox_singal, this, &SingleCameraOperationWnd::HandleComboxchange);

    initFrom();
    m_timerMaterial = new QTimer(this);
    connect(m_timerMaterial, &QTimer::timeout, this, &SingleCameraOperationWnd::UpdateMaterialByTimer);
    m_pCViewInterface = ns_module::CViewInterface::GetInstance();
}


SingleCameraOperationWnd::~SingleCameraOperationWnd()
{
    UnCameraBind();

    delete ui;
}

void SingleCameraOperationWnd::initFrom()
{
    m_allGroup.clear();
    waferMap.clear();
    waffleMap.clear();
    materialBoxMap.clear();
    bondMap.clear();
    // 设置右上部分
    QWidget* viewport = ui->scrollArea->viewport();
    QWidget* container = new QWidget(viewport);
    QVBoxLayout* layout = new QVBoxLayout(container);

    layout->setSpacing(16); // 设置Group之间的间隔距离
    layout->setMargin(0);
    int nSize = 0;
    if (m_pMainCameraBind != nullptr)
    {
        //QList<int> numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };
        nSize = m_pMainCameraBind->m_vecCamera.size();
        if (nSize == 0) // 针对获取不到的情况
        {
            nSize = 5;
            //JMessageTip::Message_warning("a");
        }
        QList<int> numbers;

        for (int i = 1; i <= nSize; i++)
        {
            numbers.push_back(i);
        }


        for (int i = 0; i < numbers.size(); ++i) 
        {
            int num = numbers[i];

            CameraImageHandler* manager = nullptr;
            if (nSize == 5) // 测试数据
            {
                CameraInfo test;
                test.iCameraId = i;
                test.name = ("camera" + QString::number(i)).toStdString();
                test.eType = MATERIAL_WAFFLE;
                manager = new CameraImageHandler(num, test);
            }
            else
            {
                m_pMainCameraBind->m_vecCamera[i].eType = MATERIAL_BOX;
                manager = new CameraImageHandler(num, m_pMainCameraBind->m_vecCamera[i]);
            }
           
            Group* widget = manager->getGroup();
            if (m_pMainCameraBind->m_vecCamera.size() > 0)
            {
                widget->SetCameaInfo(m_pMainCameraBind->m_vecCamera[i]);
            }

            if (widget != nullptr)
            {
                CameraConnectUpdateImageFun(i, widget);
                connect(widget, &Group::sendUpdateGroupState,
                    this, &SingleCameraOperationWnd::checkSettings);
                connect(widget, &Group::send_ComboBox_singal,
                    this, &SingleCameraOperationWnd::GetGroupComboxChanged);
                layout->addWidget(widget);
                m_allGroup.append(widget);
                groupMap[num] = widget;
            }
            if (manager->getWafer()) 
            {
                waferMap.insert(num, manager->getWafer());
                ui->viewwidgetgroup->setWafer(waferMap.value(i + 1));
                m_allGroup[i]->setWaferWidget(ui->viewwidgetgroup->getWafer()->getGlobalPixmap());
            }
            if (manager->getWaffle()) 
            {
                waffleMap.insert(num, manager->getWaffle());
                ui->viewwidgetgroup->setWaffle(waffleMap.value(i + 1));
                m_allGroup[i]->setWaffleWidget(ui->viewwidgetgroup->getWaffle()->getGlobalPixmap());
            }
            if (manager->getMaterialBox()) 
            {
                materialBoxMap.insert(num, manager->getMaterialBox());
            }
            if (manager->getBond()) 
            {
                bondMap.insert(num, manager->getBond());
                ui->viewwidgetgroup->setBond(bondMap.value(i + 1));
                m_allGroup[i]->setBondWidget(ui->viewwidgetgroup->getBond()->getGlobalPixmap());
            }
            if (!manager->getFileList().isEmpty()) 
            {
                m_mapFileListMap.insert(num, manager->getFileList());
            }

            delete manager;
        }
        //清理ui->viewwidgetgroup
        int width = ui->viewwidgetgroup->width();
        int height = ui->viewwidgetgroup->height();
        QPixmap pixmap(width, height);
        pixmap.fill(Qt::white); // 白色背景
        GetGroupImageShowSignals(pixmap);

        // 设置控件的最小高度和最大宽度
        int minHeight = 162;
        int maxWidth = 244;
        for (Group* w : m_allGroup) {
            w->setMinimumHeight(minHeight);
            w->setMaximumWidth(maxWidth);
        }

        container->setLayout(layout);
        ui->scrollArea->setWidget(container);
        ui->scrollArea->resize(261, 700);
        initWidget();

    }
}
// 初始化静态成员
SingleCameraOperationWnd* SingleCameraOperationWnd::m_instance = nullptr;
SingleCameraOperationWnd* SingleCameraOperationWnd::GetInstance() {
    if (!m_instance) {
        m_instance = new SingleCameraOperationWnd();
    }
    return m_instance;
}

void SingleCameraOperationWnd::closeEvent(QCloseEvent* event) {
    // 保存滑块状态
    // saveSliderStates();

    // 确保调用基类的 closeEvent 处理其他关闭逻辑
    QMainWindow::closeEvent(event);
}




void SingleCameraOperationWnd::checkSettings(int groupId, int index) {

    if (groupId != lastGroupId || index != lastIndex) {
        GetCurrentSelectSlots(groupId, index);
        lastGroupId = groupId;
        lastIndex = index;
        saveInfoOfLast();

    }
}



void SingleCameraOperationWnd::updateMaterialWidget(int materialWndType, int groupId)
{
    switch (materialWndType)
    {
    case 1: ui->viewwidgetgroup->setWafer(waferMap.value(groupId)); break;
    case 2: ui->viewwidgetgroup->setWaffle(waffleMap.value(groupId)); break;
    case 3: ui->viewwidgetgroup->setMaterialBox(materialBoxMap.value(groupId)); break;
    case 4: ui->viewwidgetgroup->setBond(bondMap.value(groupId)); break;
    }
}

void SingleCameraOperationWnd::InitMainCameraBind(CameraBind* pCameraBind)
{
    m_pMainCameraBind = pCameraBind;
    initFrom();
}

void SingleCameraOperationWnd::UnCameraBind()
{
    for (size_t i = 0; i < m_allGroup.size(); i++)
    {
        CameraConnectUpdateImageFun(i, m_allGroup[i], true);
    }
    //判断退出前的窗口是否是绑定相机
    if (m_veCurrentSelectGroup.isBond == true) {
        //解绑
        disconnect(m_veCurrentSelectGroup.pSelectGroup, &Group::SetUpDataImageShowSig,
            this, &SingleCameraOperationWnd::GetGroupImageShowSignals);
    }
}

void SingleCameraOperationWnd::CameraConnectUpdateImageFun(int nIndex, Group* widget, bool isUnCameraBind /*= false*/)
{
    auto BinCamerasImage = [&](void (SingleCameraOperationWnd::* pCamerasImage)(const QPixmap& imageData))
    {
        if (isUnCameraBind)
        {
           // disconnect(widget, &Group::SetCurrentSelectSig, this, &SingleCameraOperationWnd::checkSettings);
            disconnect(this, pCamerasImage, widget, &Group::UpDataImageShowSlots);
        }
        else
        {
            //共用函数
            //connect(widget, &Group::sendUpdateGroupState, this, &SingleCameraOperationWnd::checkSettings);
            connect(this, pCamerasImage, widget, &Group::UpDataImageShowSlots);
        }

    };

    if (nIndex == 0)
    {
        BinCamerasImage(&SingleCameraOperationWnd::UpDataImageShowSignals0);
    }
    else if (nIndex == 1)
    {
        BinCamerasImage(&SingleCameraOperationWnd::UpDataImageShowSignals1);
    }
    else if (nIndex == 2)
    {
        BinCamerasImage(&SingleCameraOperationWnd::UpDataImageShowSignals2);
    }
    else if (nIndex == 3)
    {
        BinCamerasImage(&SingleCameraOperationWnd::UpDataImageShowSignals3);
    }
    else if (nIndex == 4)
    {
        BinCamerasImage(&SingleCameraOperationWnd::UpDataImageShowSignals4);
    }
}

void SingleCameraOperationWnd::UpdateCameraDisplay0(int iCameraId, JVision::ImageInfo imageData)
{
    QImage image(imageData.data, imageData.width, imageData.height, QImage::Format_Indexed8);
    emit UpDataImageShowSignals0(QPixmap::fromImage(image));
}

void SingleCameraOperationWnd::UpdateCameraDisplay1(int iCameraId, JVision::ImageInfo imageData)
{
    QImage image(imageData.data, imageData.width, imageData.height, QImage::Format_Indexed8);
    emit UpDataImageShowSignals1(QPixmap::fromImage(image));
}

void SingleCameraOperationWnd::UpdateCameraDisplay2(int iCameraId, JVision::ImageInfo imageData)
{
    QImage image(imageData.data, imageData.width, imageData.height, QImage::Format_Indexed8);
    emit UpDataImageShowSignals2(QPixmap::fromImage(image));
}

void SingleCameraOperationWnd::UpdateCameraDisplay3(int iCameraId, JVision::ImageInfo imageData)
{
    QImage image(imageData.data, imageData.width, imageData.height, QImage::Format_Indexed8);
    emit UpDataImageShowSignals3(QPixmap::fromImage(image));
}

void SingleCameraOperationWnd::UpdateCameraDisplay4(int iCameraId, JVision::ImageInfo imageData)
{
    QImage image(imageData.data, imageData.width, imageData.height, QImage::Format_Indexed8);
    emit UpDataImageShowSignals4(QPixmap::fromImage(image));
}

void SingleCameraOperationWnd::wheelEvent(QWheelEvent* event)
{
    //mousePos = ui->viewwidgetgroup->getOperatewidget()->mapFromGlobal(event->globalPos());

    //if (ui->viewwidgetgroup->getOperatewidget()->rect().contains(ui->viewwidgetgroup->getOperatewidget()->mapFromGlobal(event->globalPos()))) {
    //    if (event->angleDelta().y() > 0) {
    //        ui->viewwidgetgroup->updateScale(scaleFactor * 1.1); // 放大
    //    } else {
    //        ui->viewwidgetgroup->updateScale(scaleFactor * 0.9); // 缩小
    //    }
    //}
    //if (ui->scrollArea->rect().contains(ui->scrollArea->mapFromGlobal(event->globalPos()))) {
    //    // 获取 QScrollArea 的横向滚动条
    //    QScrollBar *scrollBar = ui->scrollArea->horizontalScrollBar();
    //    // 根据滚轮滚动方向改变滚动条的值
    //    if (event->angleDelta().y() > 0) {
    //        scrollBar->setValue(scrollBar->value() - 50);
    //    } else {
    //        scrollBar->setValue(scrollBar->value() + 50);
    //    }
    //}

    QMainWindow::wheelEvent(event);

}


QString SingleCameraOperationWnd::getImagePathFromIndex(int index) {
    QStringList imagePaths = {
        ":/images/test_image/image.png",
        ":/images/test_image/image_2.png",
    };
    if (index >= 0 && index < imagePaths.size()) {
        return imagePaths[index];
    }
    return ":/images/test_image/image.png";
}

void SingleCameraOperationWnd::showEvent(QShowEvent* event) {
    QMainWindow::showEvent(event);
}

void SingleCameraOperationWnd::hideEvent(QHideEvent* event) {
    QMainWindow::hideEvent(event);
}




#if 0
void SingleCameraOperationWnd::on_DatacomboBox_currentIndexChanged(int index) {
    QSettings settings("YourCompany", "YourApplication_");
    int groupId = settings.value("GroupId", 0).toInt();
    if (groupMap.contains(groupId)) {
        Group* group = groupMap[groupId];
        // 修改属性

        group->setDatacomboBox(index);
    }
    else {
        qDebug() << "Group with id" << groupId << "not found.";
    }

}
#endif

void SingleCameraOperationWnd::updateImage(const QImage& image) {
    QPixmap pixmap = QPixmap::fromImage(image);
    QSize size = ui->viewwidgetgroup->getOperatewidget()->size();
    // QPixmap scaledPixmap = pixmap.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    QPixmap scaledPixmap = pixmap.scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    ui->viewwidgetgroup->getOperatewidget()->setPixmap(scaledPixmap);

}



void SingleCameraOperationWnd::GetGroupImageShowSignals(const QPixmap& imageData) {
    QSize size = ui->viewwidgetgroup->getOperatewidget()->size();
    QPixmap scaledPixmap = imageData.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    ui->viewwidgetgroup->setScaleFactorSize(scaledPixmap);
    // m_lastRightPixmap = imageData;
}

void SingleCameraOperationWnd::BindImageOrMaterial(int index) {

    if (index == m_nImageIndex) {

        m_veCurrentSelectGroup.isBond = true;
        connect(m_veCurrentSelectGroup.pSelectGroup, &Group::SetUpDataImageShowSig,
            this, &SingleCameraOperationWnd::GetGroupImageShowSignals);
        UpdataLightJoystickSwitchPage(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId, true);

    }
    else {
        QSettings settings("YourOrganization", "YourApplication");
        settings.beginGroup(QString::number(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId));
        int materialWndType = settings.value("MaterialWndType").toInt();
        settings.endGroup();
        m_veCurrentSelectGroup.isBond = false;
        UpdataLightJoystickSwitchPage(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId, false);
        updateMaterialWidget(materialWndType, m_veCurrentSelectGroup.pSelectGroup->m_nGroupId);

    }

}

void SingleCameraOperationWnd::initWidget() {
    //初始化当前页面的信息

    QSettings settings("YourOrganization", "YourApplication");
    lastIndex = settings.value("SingleLastIndex", 1).toInt();
    lastGroupId = settings.value("SingleLastGroupId", 1).toInt();

    //处理各种情况的初始化
    if (m_pMainCameraBind == nullptr || m_allGroup.size() == 0)
    {
        return;
    }

    //当lastGroupId大于m_allGroup.size()时，初始化lastGroupId为1
    if (m_allGroup.size() < lastGroupId) {

        lastGroupId = 1;
        lastIndex = 1;
        m_veCurrentSelectGroup.isInitialed = true;
        m_veCurrentSelectGroup.pSelectGroup = m_allGroup.at(lastGroupId - 1);
        m_veCurrentSelectGroup.pSelectGroup->initBorderStyle(lastIndex, 1);
        //初始化下拉框内容同步小窗口索引
        int currentComboBoxIndex = m_veCurrentSelectGroup.pSelectGroup->getCurrentComboBoxIndex();
        ui->viewwidgetgroup->setEnableControls(true);
        ui->viewwidgetgroup->setComboBox(m_mapFileListMap[m_veCurrentSelectGroup.pSelectGroup->m_nGroupId], currentComboBoxIndex);
        BindImageOrMaterial(m_nImageIndex);

    }
    else {
    }
    m_veCurrentSelectGroup.isInitialed = true;
    m_veCurrentSelectGroup.pSelectGroup = m_allGroup.at(lastGroupId - 1);
    m_veCurrentSelectGroup.pSelectGroup->initBorderStyle(lastIndex, 1);
    //初始化下拉框内容同步小窗口索引
    int currentComboBoxIndex = m_veCurrentSelectGroup.pSelectGroup->getCurrentComboBoxIndex();
    ui->viewwidgetgroup->setComboBox(m_mapFileListMap[m_veCurrentSelectGroup.pSelectGroup->m_nGroupId], currentComboBoxIndex);
    BindImageOrMaterial(m_nImageIndex);
    if (lastIndex == 1) {
        ui->viewwidgetgroup->setEnableControls(true);
        BindImageOrMaterial(m_nImageIndex);
        QPixmap pixmap = ui->viewwidgetgroup->getCurrentComboBoxPixmap(currentComboBoxIndex);
        GetGroupImageShowSignals(pixmap);

    }
    else {
        ui->viewwidgetgroup->setEnableControls(false);
        BindImageOrMaterial(m_nMaterialIndex);

    }
    m_timerMaterial->start(10000);

}

void SingleCameraOperationWnd::saveInfoOfLast() {
    QSettings settings("YourOrganization", "YourApplication");
    settings.setValue("SingleLastIndex", lastIndex);
    settings.setValue("SingleLastGroupId", lastGroupId);
}

void SingleCameraOperationWnd::GetCurrentSelectSlots(int groupId, int nIndex) {
    int nOnClickGroupId = groupId - 1;
    if (m_pMainCameraBind == nullptr || m_allGroup.size() < groupId)
    {
        return;
    }

    //判断更新前的窗口是否是绑定相机
    if (m_veCurrentSelectGroup.isBond == true) {
        //解绑
        disconnect(m_veCurrentSelectGroup.pSelectGroup, &Group::SetUpDataImageShowSig,
            this, &SingleCameraOperationWnd::GetGroupImageShowSignals);
    }
    m_veCurrentSelectGroup.pSelectGroup = m_allGroup.at(nOnClickGroupId);
    //判断index是相机还是物料
    //更新下拉框内容同步小窗口索引
    int currentComboBoxIndex = m_veCurrentSelectGroup.pSelectGroup->getCurrentComboBoxIndex();
    ui->viewwidgetgroup->setComboBox(m_mapFileListMap[m_veCurrentSelectGroup.pSelectGroup->m_nGroupId], currentComboBoxIndex);
    if (nIndex == 2) {
        
        BindImageOrMaterial(m_nMaterialIndex);
        ui->viewwidgetgroup->setEnableControls(false);
    }
    else if (nIndex == 1) {

        ui->viewwidgetgroup->setEnableControls(true);
        BindImageOrMaterial(m_nImageIndex);
        QPixmap pixmap = ui->viewwidgetgroup->getCurrentComboBoxPixmap(currentComboBoxIndex);
        GetGroupImageShowSignals(pixmap);
    }
}

void SingleCameraOperationWnd::UpdataLightJoystickSwitchPage(int groupId, bool isShow)
{
    auto Fun = [&](Group* pGroup, LightJoystickSwitchPage* p, ControlOperationPage* pContPage, bool bShow)
    {
        p->UpdatemPageGroup(pGroup);
        p->InitMainCameraBind(m_pMainCameraBind, bShow);
        p->HideOrShowPage(bShow);
        if (bShow)
        {
            pContPage->UpDateCameraBind(m_pMainCameraBind);
        }
        else
        {
            pContPage->setSwitchJoystickButEnable(bShow);
        }

    };


        disconnect(ui->viewwidgetgroup, &ControlOperationPage::SendModuleTypeSignals,
            ui->lightJoystickSwitchPage, &LightJoystickSwitchPage::GetModuleTypeSlots);
        Group* currGroup = m_allGroup.at(groupId - 1);
        Fun(currGroup, ui->lightJoystickSwitchPage, ui->viewwidgetgroup, isShow);
        connect(ui->viewwidgetgroup, &ControlOperationPage::SendModuleTypeSignals,
            ui->lightJoystickSwitchPage, &LightJoystickSwitchPage::GetModuleTypeSlots);


}
void SingleCameraOperationWnd::GetGroupComboxChanged(int groupId, int comboxIndex) {

    m_allGroup.at(groupId - 1);
    if (comboxIndex == 0) {
        CameraConnectUpdateImageFun(groupId - 1, m_allGroup.at(groupId - 1), false);

    }
    else {
        CameraConnectUpdateImageFun(groupId - 1, m_allGroup.at(groupId - 1), true);

    }
    m_allGroup.at(groupId - 1)->setCurrentCombox(comboxIndex);

    if (groupId == m_veCurrentSelectGroup.pSelectGroup->m_nGroupId && lastIndex == 1) {

        if (comboxIndex != 0) {//图片
            QPixmap updatePixmap = ui->viewwidgetgroup->getCurrentComboBoxPixmap(comboxIndex);
            m_veCurrentSelectGroup.pSelectGroup->UpDataImageShowSlots(updatePixmap);
        }
    }

}

void SingleCameraOperationWnd::HandleComboxchange(int index) {
    if (index == 0) {
        CameraConnectUpdateImageFun(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId - 1, m_allGroup.at(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId - 1), false);
    }
    else {
        CameraConnectUpdateImageFun(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId - 1, m_allGroup.at(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId - 1), true);
        QPixmap updatePixmap = ui->viewwidgetgroup->getCurrentComboBoxPixmap(index);
        m_veCurrentSelectGroup.pSelectGroup->UpDataImageShowSlots(updatePixmap);
    }
}

void SingleCameraOperationWnd::UpdateMaterialByTimer() {
    //判断当前大窗口是否是物料窗口
    if (lastIndex == 2) {
        QSettings settings("YourOrganization", "YourApplication");
        settings.beginGroup(QString::number(m_veCurrentSelectGroup.pSelectGroup->m_nGroupId));
        int MaterialWndType = settings.value("MaterialWndType").toInt();
        settings.endGroup();
        switch (MaterialWndType) {
        case 1:
        {
            UpdateWafer(lastGroupId);
            ui->viewwidgetgroup->setWafer(waferMap.value(lastGroupId));
            m_allGroup[lastGroupId - 1]->setWaferWidget(ui->viewwidgetgroup->getWafer()->getGlobalPixmap());
            break;
        }
        case 2:
        {
            UpdateWaffle(lastGroupId);
            ui->viewwidgetgroup->setWaffle(waffleMap.value(lastGroupId));
            m_allGroup[lastGroupId - 1]->setWaffleWidget(ui->viewwidgetgroup->getWaffle()->getGlobalPixmap());
            break;
        }
        case 3:
        {
            UpdateMaterialBox(lastGroupId);
            ui->viewwidgetgroup->setMaterialBox(materialBoxMap.value(lastGroupId));
            m_allGroup[lastGroupId - 1]->MaterialBoxWidget();
            break;
        }
        case 4:
        {
            UpdateBond(lastGroupId);
            ui->viewwidgetgroup->setBond(bondMap.value(lastGroupId));
            m_allGroup[lastGroupId - 1]->setBondWidget(ui->viewwidgetgroup->getBond()->getGlobalPixmap());
            break;
        }
        }

    }

}

void SingleCameraOperationWnd::UpdateWafer(int groupId) {
    if (m_pCViewInterface != nullptr)
    {
        std::vector<ns_mat::WAFER_MATRIX_POINT_INFO_STRUCT> veWafer;
        m_pCViewInterface->GetViewMatrix()->GetWaferAllPointInfo(veWafer);
        waferMap.value(groupId)->UpdataVal(veWafer);
        waferMap.value(groupId)->setWaferInfo(m_pCViewInterface);
    }
    else
    {
        waferMap.value(groupId)->UpdataGenerateTestData();
    }
}
void SingleCameraOperationWnd::UpdateWaffle(int groupId) {
    if (m_pCViewInterface != nullptr)
    {
        std::vector<ns_mat::WAFFLE_MATRIX_POINT_STRUCT> veWaffle;
        m_pCViewInterface->GetViewMatrix()->GetWafflePackAllPointInfo(veWaffle);
        waffleMap.value(groupId)->UpdataVal(veWaffle);
    }
    else
    {
        waffleMap.value(groupId)->UpdataGenerateTestData();
    }
}
void SingleCameraOperationWnd::UpdateBond(int groupId) {
    if (m_pCViewInterface != nullptr)
    {
        std::vector<ns_mat::POINT_INFO_STRUCT> stPointInfo;
        m_pCViewInterface->GetViewMatrix()->GetBondAllPointInfo(stPointInfo);
        bondMap.value(groupId)->UpdataVal(stPointInfo);
        bondMap.value(groupId)->setBondInfo(m_pCViewInterface);
    }
    else
    {
        bondMap.value(groupId)->UpdataGenerateTestData();
    }
}
void SingleCameraOperationWnd::UpdateMaterialBox(int groupId) {
    if (m_pCViewInterface != nullptr)
    {
        std::vector<ns_module::MATERIAL_BOX_STRUCT> veMaterial;

        m_pCViewInterface->GetViewMatrix()->GetMaterialBoxAllPointInfo(veMaterial);
        materialBoxMap.value(groupId)->UpdataVal(veMaterial);
        materialBoxMap.value(groupId)->setMaterialBoxInfo(m_pCViewInterface);
    }
    else
    {
        materialBoxMap.value(groupId)->UpdataGenerateTestData();
    }
}

void SingleCameraOperationWnd::TimerMaterialStart() {

    if (m_timerMaterial != nullptr) {
        m_timerMaterial->start();
    }

}

void SingleCameraOperationWnd::TimerMaterialStop() {
    if (m_timerMaterial != nullptr) {
        m_timerMaterial->stop();
    }

}