You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
nmWTAI-Platform/Src/nmNum/nmSubWxs/nmWxPebiResultViewWidget.cpp

2622 lines
102 KiB
C++

#include "nmWxPebiResultViewWidget.h"
#include "nmVolumeImportTask.h"
#include "nmVolumeSceneController.h"
#include "nmVTKViewState.h"
#include <QFileDialog>
#include <QToolButton>
#include <QPainter>
#include <QPixmap>
#include <QPolygon>
#include <QPen>
#include "iUnitGroup.h"
#include "iUnitHelper.h"
#include "nmDataAnalyzeManager.h"
#include "nmFFmpegVideoWriter.h"
#include "nmPebiRegionPressureCalculator.h"
#include "nmPebiResultAnimationExporter.h"
#include "nmPebiResultDisplaySettings.h"
#include "nmPebiResultPlaybackController.h"
#include "nmPebiResultPropertyCatalog.h"
#include "nmPebiResultPropertyDisplayText.h"
#include "nmPebiResultSceneController.h"
#include "nmPebiResultSnapshot.h"
#include "nmVTKMeshLayer.h"
#include "nmVTKPlanarPolygonInteractorStyle.h"
#include "nmVTKPlanarPolygonLayer.h"
#include "nmVTKScene.h"
#include "nmVTKViewCommandController.h"
#include "nmWxPebiResultControlBar.h"
#include "nmWxPebiResultAnimationExportDlg.h"
#include "nmWxVTKRenderContainerWidget.h"
#include <QAction>
#include <QAtomicInt>
#include <QCheckBox>
#include <QComboBox>
#include <QCoreApplication>
#include <QDialog>
#include <QDir>
#include <QGridLayout>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QIcon>
#include <QLabel>
#include <QLineEdit>
#include <QLocale>
#include <QMenu>
#include <QMessageBox>
#include <QMetaObject>
#include <QPointer>
#include <QProgressDialog>
#include <QPushButton>
#include <QSize>
#include <QSizePolicy>
#include <QThread>
#include <QToolBar>
#include <QVBoxLayout>
#include <vtkCamera.h>
#include <vtkCallbackCommand.h>
#include <vtkMath.h>
#include <vtkObject.h>
#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <math.h>
#if !defined(_MSC_VER)
#include <cmath>
#endif
namespace {
QAtomicInt g_nPebiAnimationExportActive(0);
const char* const PEBI_REGION_PRESSURE_LAYER_ID =
"PebiResult.RegionPressurePolygon";
QString resultViewIconPath(const QString& sFileName)
{
const QString sApplicationDir = QCoreApplication::applicationDirPath();
return sApplicationDir.section('/', 0, -2) +
"/Res/Icon/" + sFileName;
}
bool isResultViewGuiThread()
{
QCoreApplication* pApplication = QCoreApplication::instance();
return pApplication == nullptr ||
pApplication->thread() == QThread::currentThread();
}
void setActionCheckedWithoutSignal(QAction* pAction, bool bChecked)
{
if(pAction == nullptr) {
return;
}
const bool bBlocked = pAction->blockSignals(true);
pAction->setChecked(bChecked);
pAction->blockSignals(bBlocked);
}
bool isFiniteFilterEditorValue(double dValue)
{
#if defined(_MSC_VER)
return _finite(dValue) != 0;
#else
return std::isfinite(dValue);
#endif
}
QString formatRegionValue(double dValue)
{
if(!isFiniteFilterEditorValue(dValue)) {
return QString();
}
return QLocale().toString(dValue, 'g', 10);
}
QLineEdit* addRegionStatisticsRow(QGridLayout* pLayout,
int nRow,
const QString& sName,
QWidget* pParent,
QWidget* pUnitWidget = nullptr)
{
QLabel* pNameLabel = new QLabel(sName, pParent);
QLineEdit* pValueEdit = new QLineEdit(pParent);
pNameLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
pValueEdit->setReadOnly(true);
pValueEdit->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
pValueEdit->setMinimumWidth(150);
pLayout->addWidget(pNameLabel, nRow, 0);
pLayout->addWidget(pValueEdit, nRow, 1);
if(pUnitWidget != nullptr) {
pLayout->addWidget(pUnitWidget, nRow, 2);
}
return pValueEdit;
}
QComboBox* createRegionUnitCombo(QWidget* pParent,
const QString& sUnit)
{
QComboBox* pCombo = new QComboBox(pParent);
pCombo->addItem(sUnit);
pCombo->setEnabled(false);
pCombo->setMinimumWidth(80);
pCombo->setMaximumWidth(140);
pCombo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
pCombo->setSizeAdjustPolicy(QComboBox::AdjustToContentsOnFirstShow);
return pCombo;
}
bool canProjectRegionOntoXyPlane(vtkRenderer* pRenderer)
{
vtkCamera* pCamera = pRenderer == nullptr
? nullptr : pRenderer->GetActiveCamera();
if(pCamera == nullptr) {
return false;
}
double dDirection[3];
pCamera->GetDirectionOfProjection(dDirection);
const double dLength = vtkMath::Norm(dDirection);
return vtkMath::IsFinite(dLength) && dLength > 0.0 &&
vtkMath::IsFinite(dDirection[2]) &&
qAbs(dDirection[2]) > 1.0e-10 * dLength;
}
class AnimationExportGuard
{
public:
explicit AnimationExportGuard(nmWxPebiResultControlBar* pControlBar)
: m_pControlBar(pControlBar),
m_bAcquired(g_nPebiAnimationExportActive.testAndSetOrdered(0, 1))
{
if(m_bAcquired && m_pControlBar != nullptr) {
m_pControlBar->setExportInProgress(true);
}
}
~AnimationExportGuard()
{
release();
}
void release()
{
if(!m_bAcquired) {
return;
}
if(m_pControlBar != nullptr) {
m_pControlBar->setExportInProgress(false);
}
g_nPebiAnimationExportActive.fetchAndStoreOrdered(0);
m_bAcquired = false;
}
bool isAcquired() const
{
return m_bAcquired;
}
private:
QPointer<nmWxPebiResultControlBar> m_pControlBar;
bool m_bAcquired;
};
}
class nmWxPebiResultRegionState
{
public:
enum State
{
State_Idle = 0,
State_Drawing,
State_Completed
};
enum PendingEvent
{
PendingEvent_None = 0,
PendingEvent_Completed,
PendingEvent_Cancelled,
PendingEvent_Invalid
};
nmWxPebiResultRegionState()
: m_eState(State_Idle),
m_ePendingEvent(PendingEvent_None),
m_bPendingEventQueued(false),
m_pLayer(nullptr),
m_nChangedObserverTag(0),
m_nCompletedObserverTag(0),
m_nCancelledObserverTag(0),
m_nInvalidObserverTag(0),
m_nFrozenBindingRevision(0),
m_nFrozenFrameIndex(-1),
m_nRegionBindingRevision(0),
m_nLastAttemptedFrameIndex(-1),
m_bStatisticsCalculated(false),
m_pDialog(nullptr),
m_pAveragePressureUnitCombo(nullptr),
m_pMinimumPressureUnitCombo(nullptr),
m_pMaximumPressureUnitCombo(nullptr),
m_pPressureTimeUnitCombo(nullptr),
m_pAveragePressureValue(nullptr),
m_pMinimumPressureValue(nullptr),
m_pMaximumPressureValue(nullptr),
m_pTimeValue(nullptr),
m_pSelectedCellValue(nullptr),
m_pWarningLabel(nullptr)
{
}
State m_eState; ///< 当前窗口区域工具状态。
PendingEvent m_ePendingEvent; ///< 等待 Qt 事件循环处理的 VTK 终止事件。
bool m_bPendingEventQueued; ///< 是否已有一次安全收尾被排队。
QVector<QPointF> m_vecPendingPoints; ///< 完成回调复制出的候选世界坐标。
nmPebiRegionPressureCalculator m_oCalculator; ///< 独占相交缓存和压力计算器。
nmVTKPlanarPolygonLayer* m_pLayer; ///< 业务 Scene 所有的区域轮廓观察指针。
vtkSmartPointer<nmVTKPlanarPolygonInteractorStyle> m_pStyle; ///< 临时绘制样式。
vtkSmartPointer<vtkCallbackCommand> m_pCallback; ///< 不拥有窗口的 VTK 回调命令。
unsigned long m_nChangedObserverTag; ///< 点集变化观察者标识。
unsigned long m_nCompletedObserverTag; ///< 绘制完成观察者标识。
unsigned long m_nCancelledObserverTag; ///< 绘制取消观察者标识。
unsigned long m_nInvalidObserverTag; ///< 无效完成观察者标识。
QSharedPointer<const nmPebiResultSnapshot> m_pFrozenSnapshot; ///< 绘制开始时的快照强引用。
quint64 m_nFrozenBindingRevision; ///< 绘制开始时的成功绑定序号。
QString m_sFrozenSnapshotId; ///< 绘制开始时的快照稳定 ID。
QString m_sFrozenPropertyId; ///< 绘制开始时的显示属性 ID。
int m_nFrozenFrameIndex; ///< 绘制开始时的 pressure 帧。
quint64 m_nRegionBindingRevision; ///< 已完成区域所属成功绑定序号。
QString m_sRegionSnapshotId; ///< 已完成区域所属快照 ID。
QString m_sLastObservedPropertyId; ///< 最近一次状态信号观察到的显示属性。
int m_nLastAttemptedFrameIndex; ///< 最近一次尝试统计的 pressure 帧。
bool m_bStatisticsCalculated; ///< 最近一次统计调用是否成功。
QString m_sStatisticsError; ///< 最近一次统计调用失败说明。
nmPebiRegionPressureStatistics m_oStatistics; ///< 最近一次成功统计结果。
QDialog* m_pDialog; ///< ViewWidget 子对象,关闭时同步结束本次统计。
QComboBox* m_pAveragePressureUnitCombo; ///< 固定显示 MPa 的禁用单位框。
QComboBox* m_pMinimumPressureUnitCombo; ///< 压力下限固定单位框。
QComboBox* m_pMaximumPressureUnitCombo; ///< 压力上限固定单位框。
QComboBox* m_pPressureTimeUnitCombo; ///< 固定显示 h 的禁用单位框。
QLineEdit* m_pAveragePressureValue; ///< 只读区域平均压力。
QLineEdit* m_pMinimumPressureValue; ///< 只读区域压力下限。
QLineEdit* m_pMaximumPressureValue; ///< 只读区域压力上限。
QLineEdit* m_pTimeValue; ///< 只读求解时间显示值。
QLineEdit* m_pSelectedCellValue; ///< 只读相交单元数。
QLabel* m_pWarningLabel; ///< 仅在无结果或有忽略单元时显示的说明。
};
nmWxPebiResultFilterSettingsDlg::nmWxPebiResultFilterSettingsDlg(
nmPebiResultSceneController* pSceneController,
nmWxPebiResultControlBar* pControlBar,
QWidget* pParent)
: iDlgBase(pParent),
m_pSceneController(pSceneController),
m_pControlBar(pControlBar),
m_nExpectedBindingRevision(0),
m_nExpectedDisplayFrameIndex(-1),
m_pUnitGroup(nullptr),
m_bInitialized(false),
m_pEnableCheck(nullptr),
m_pPropertyCombo(nullptr),
m_pMinimumCheck(nullptr),
m_pMinimumEdit(nullptr),
m_pMaximumCheck(nullptr),
m_pMaximumEdit(nullptr),
m_pUnitCombo(nullptr),
m_pApplyButton(nullptr),
m_pOkButton(nullptr)
{
createUi();
m_bInitialized = initializeFromScene();
if(!m_bInitialized) {
m_pApplyButton->setEnabled(false);
m_pOkButton->setEnabled(false);
QMessageBox::warning(
this, tr("Filtering settings"),
tr("Unable to read the current result filter settings."));
}
}
nmWxPebiResultFilterSettingsDlg::~nmWxPebiResultFilterSettingsDlg()
{
}
void nmWxPebiResultFilterSettingsDlg::createUi()
{
setWindowTitle(tr("Filtering settings"));
setModal(true);
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
m_pEnableCheck = new QCheckBox(tr("Enable filtering"), this);
m_pPropertyCombo = new QComboBox(this);
m_pPropertyCombo->setSizeAdjustPolicy(
QComboBox::AdjustToContentsOnFirstShow);
m_pPropertyCombo->setMinimumWidth(220);
m_pMinimumCheck = new QCheckBox(tr("Above min (>=)"), this);
m_pMinimumEdit = new QLineEdit(this);
m_pMinimumEdit->setAlignment(Qt::AlignRight);
m_pMaximumCheck = new QCheckBox(tr("Below max (<=)"), this);
m_pMaximumEdit = new QLineEdit(this);
m_pMaximumEdit->setAlignment(Qt::AlignRight);
m_pUnitCombo = new QComboBox(this);
m_pUnitCombo->setMinimumWidth(80);
m_pUnitCombo->setMaximumWidth(140);
m_pUnitCombo->hide();
m_pMinimumEdit->setMinimumWidth(150);
m_pMaximumEdit->setMinimumWidth(150);
QGridLayout* pFieldsLayout = new QGridLayout();
pFieldsLayout->setContentsMargins(0, 0, 0, 0);
pFieldsLayout->setHorizontalSpacing(8);
pFieldsLayout->setVerticalSpacing(6);
pFieldsLayout->addWidget(m_pEnableCheck, 0, 0, 1, 3);
QLabel* pPropertyLabel = new QLabel(tr("Filter on"), this);
pPropertyLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
pFieldsLayout->addWidget(pPropertyLabel, 1, 0);
pFieldsLayout->addWidget(m_pPropertyCombo, 1, 1, 1, 2);
pFieldsLayout->addWidget(m_pMinimumCheck, 2, 0);
pFieldsLayout->addWidget(m_pMinimumEdit, 2, 1);
pFieldsLayout->addWidget(m_pUnitCombo, 2, 2, 2, 1,
Qt::AlignVCenter);
pFieldsLayout->addWidget(m_pMaximumCheck, 3, 0);
pFieldsLayout->addWidget(m_pMaximumEdit, 3, 1);
pFieldsLayout->setColumnStretch(1, 1);
// 普通布局不受平台按钮顺序策略影响,始终保持应用、确定、取消。
QHBoxLayout* pButtonLayout = new QHBoxLayout();
pButtonLayout->addStretch();
m_pApplyButton = new QPushButton(tr("Apply"), this);
m_pOkButton = new QPushButton(tr("OK"), this);
QPushButton* pCancelButton = new QPushButton(tr("Cancel"), this);
const QSize oFooterIconSize(16, 16);
m_pOkButton->setIcon(QIcon(resultViewIconPath("OK.png")));
pCancelButton->setIcon(QIcon(resultViewIconPath("Cancel.png")));
m_pOkButton->setIconSize(oFooterIconSize);
pCancelButton->setIconSize(oFooterIconSize);
m_pApplyButton->setMinimumWidth(72);
m_pOkButton->setMinimumWidth(72);
pCancelButton->setMinimumWidth(72);
m_pApplyButton->setAutoDefault(false);
m_pOkButton->setDefault(true);
pCancelButton->setAutoDefault(false);
pButtonLayout->setContentsMargins(4, 2, 4, 5);
pButtonLayout->setSpacing(6);
pButtonLayout->addWidget(m_pApplyButton);
pButtonLayout->addWidget(m_pOkButton);
pButtonLayout->addWidget(pCancelButton);
QVBoxLayout* pMainLayout = new QVBoxLayout(this);
pMainLayout->setContentsMargins(12, 10, 12, 0);
pMainLayout->setSpacing(8);
pMainLayout->addLayout(pFieldsLayout);
pMainLayout->addLayout(pButtonLayout);
setMinimumWidth(430);
connect(m_pApplyButton, SIGNAL(clicked()),
this, SLOT(onApplyClicked()));
connect(m_pOkButton, SIGNAL(clicked()),
this, SLOT(onOkClicked()));
connect(pCancelButton, SIGNAL(clicked()),
this, SLOT(reject()));
connect(m_pPropertyCombo, SIGNAL(currentIndexChanged(int)),
this, SLOT(onPropertyChanged(int)));
connect(m_pUnitCombo, SIGNAL(currentIndexChanged(int)),
this, SLOT(onDisplayUnitChanged(int)));
connect(m_pEnableCheck, SIGNAL(toggled(bool)),
this, SLOT(refreshEditorEnabledState()));
connect(m_pMinimumCheck, SIGNAL(toggled(bool)),
this, SLOT(refreshEditorEnabledState()));
connect(m_pMaximumCheck, SIGNAL(toggled(bool)),
this, SLOT(refreshEditorEnabledState()));
}
bool nmWxPebiResultFilterSettingsDlg::initializeFromScene()
{
if(m_pSceneController == nullptr || m_pControlBar == nullptr ||
!m_pSceneController->hasSnapshot()) {
return false;
}
m_nExpectedBindingRevision =
m_pSceneController->getSnapshotBindingRevision();
m_sExpectedSnapshotId = m_pSceneController->getCurrentSnapshotId();
m_sExpectedDisplayPropertyId =
m_pSceneController->getCurrentPropertyId();
m_nExpectedDisplayFrameIndex =
m_pSceneController->getCurrentFrameIndex();
if(m_nExpectedBindingRevision == 0 ||
m_sExpectedSnapshotId.isEmpty() ||
m_sExpectedDisplayPropertyId.isEmpty() ||
m_nExpectedDisplayFrameIndex < 0 ||
!m_pSceneController->getFilterSettings(m_oBaselineSettings)) {
return false;
}
const bool bSignalsBlocked = m_pPropertyCombo->blockSignals(true);
const QStringList listPropertyIds =
m_pSceneController->getAvailablePropertyIds();
for(int nIndex = 0; nIndex < listPropertyIds.size(); ++nIndex) {
const QString& sPropertyId = listPropertyIds[nIndex];
double dRange[2] = { 0.0, 0.0 };
if(!m_pSceneController->getPropertyRange(sPropertyId, dRange)) {
m_pPropertyCombo->blockSignals(bSignalsBlocked);
return false;
}
m_mapPropertyRanges.insert(
sPropertyId, qMakePair(dRange[0], dRange[1]));
QString sDisplayName =
nmPebiResultPropertyDisplayText::getDisplayName(sPropertyId);
if(sDisplayName.isEmpty()) {
sDisplayName = sPropertyId;
}
m_pPropertyCombo->addItem(sDisplayName, sPropertyId);
}
m_pPropertyCombo->blockSignals(bSignalsBlocked);
if(m_pPropertyCombo->count() <= 0) {
return false;
}
if(m_oBaselineSettings.m_sPropertyId.isEmpty() ||
!m_mapPropertyRanges.contains(
m_oBaselineSettings.m_sPropertyId)) {
m_oBaselineSettings.m_sPropertyId =
m_sExpectedDisplayPropertyId;
const QPair<double, double> oRange =
m_mapPropertyRanges.value(
m_oBaselineSettings.m_sPropertyId);
m_oBaselineSettings.m_bMinimumEnabled = true;
m_oBaselineSettings.m_dMinimum = oRange.first;
m_oBaselineSettings.m_bMaximumEnabled = true;
m_oBaselineSettings.m_dMaximum = oRange.second;
}
return populateSettings(m_oBaselineSettings);
}
bool nmWxPebiResultFilterSettingsDlg::initializeUnitEditor(
const QString& sPropertyId)
{
nmPebiResultPropertyDescriptor oDescriptor;
if(!nmPebiResultPropertyCatalog::findDescriptor(
sPropertyId, oDescriptor)) {
return false;
}
const bool bSignalsBlocked = m_pUnitCombo->blockSignals(true);
m_pUnitCombo->clear();
m_pUnitGroup = nullptr;
m_sBaseUnit = oDescriptor.m_sBaseUnit;
m_sDisplayUnit = oDescriptor.m_sDefaultDisplayUnit.isEmpty()
? m_sBaseUnit : oDescriptor.m_sDefaultDisplayUnit;
if(m_sBaseUnit.isEmpty()) {
m_sDisplayUnit.clear();
m_pUnitCombo->setEnabled(false);
m_pUnitCombo->hide();
m_pUnitCombo->blockSignals(bSignalsBlocked);
return true;
}
m_pUnitGroup = iUnitHelper::getUnitGroupByUnit(m_sBaseUnit);
QStringList listUnits;
if(m_pUnitGroup != nullptr &&
m_pUnitGroup->indexOf(m_sBaseUnit) >= 0) {
listUnits = m_pUnitGroup->getAllUnitNames();
}
const bool bHasUnitGroup = !listUnits.isEmpty() &&
listUnits.contains(m_sBaseUnit);
if(!bHasUnitGroup) {
m_pUnitGroup = nullptr;
listUnits.clear();
listUnits.append(m_sBaseUnit);
m_sDisplayUnit = m_sBaseUnit;
} else if(!listUnits.contains(m_sDisplayUnit)) {
m_sDisplayUnit = m_sBaseUnit;
}
m_pUnitCombo->addItems(listUnits);
m_pUnitCombo->setCurrentIndex(
m_pUnitCombo->findText(m_sDisplayUnit));
m_pUnitCombo->setEnabled(bHasUnitGroup);
m_pUnitCombo->show();
m_pUnitCombo->blockSignals(bSignalsBlocked);
return true;
}
bool nmWxPebiResultFilterSettingsDlg::populateSettings(
const nmPebiResultFilterSettings& oSettings)
{
const bool bPropertySignalsBlocked =
m_pPropertyCombo->blockSignals(true);
const int nPropertyIndex = m_pPropertyCombo->findData(
oSettings.m_sPropertyId);
if(nPropertyIndex < 0 ||
!initializeUnitEditor(oSettings.m_sPropertyId)) {
m_pPropertyCombo->blockSignals(bPropertySignalsBlocked);
return false;
}
m_pPropertyCombo->setCurrentIndex(nPropertyIndex);
m_pPropertyCombo->blockSignals(bPropertySignalsBlocked);
double dDisplayMinimum = 0.0;
double dDisplayMaximum = 0.0;
if(!convertUnitValue(
oSettings.m_dMinimum, m_sBaseUnit,
m_sDisplayUnit, dDisplayMinimum) ||
!convertUnitValue(
oSettings.m_dMaximum, m_sBaseUnit,
m_sDisplayUnit, dDisplayMaximum)) {
return false;
}
m_pEnableCheck->setChecked(oSettings.m_bEnabled);
m_pMinimumCheck->setChecked(oSettings.m_bMinimumEnabled);
m_pMaximumCheck->setChecked(oSettings.m_bMaximumEnabled);
m_pMinimumEdit->setText(formatValue(dDisplayMinimum));
m_pMaximumEdit->setText(formatValue(dDisplayMaximum));
refreshEditorEnabledState();
return true;
}
void nmWxPebiResultFilterSettingsDlg::onApplyClicked()
{
applyEditor();
}
void nmWxPebiResultFilterSettingsDlg::onOkClicked()
{
if(applyEditor()) {
accept();
}
}
void nmWxPebiResultFilterSettingsDlg::onPropertyChanged(int nIndex)
{
if(nIndex >= 0 &&
!setPropertyRange(
m_pPropertyCombo->itemData(nIndex).toString())) {
QMessageBox::warning(
this, tr("Filtering settings"),
tr("Unable to convert the filter limits "
"to the selected unit."));
}
}
void nmWxPebiResultFilterSettingsDlg::onDisplayUnitChanged(int nIndex)
{
if(nIndex < 0) {
return;
}
const QString sNewUnit = m_pUnitCombo->itemText(nIndex);
if(sNewUnit == m_sDisplayUnit) {
return;
}
double dOldDisplayMinimum = 0.0;
double dOldDisplayMaximum = 0.0;
double dBaseMinimum = 0.0;
double dBaseMaximum = 0.0;
double dNewDisplayMinimum = 0.0;
double dNewDisplayMaximum = 0.0;
const bool bConverted =
parseFiniteValue(
m_pMinimumEdit->text(), dOldDisplayMinimum) &&
parseFiniteValue(
m_pMaximumEdit->text(), dOldDisplayMaximum) &&
convertUnitValue(
dOldDisplayMinimum, m_sDisplayUnit,
m_sBaseUnit, dBaseMinimum) &&
convertUnitValue(
dOldDisplayMaximum, m_sDisplayUnit,
m_sBaseUnit, dBaseMaximum) &&
convertUnitValue(
dBaseMinimum, m_sBaseUnit,
sNewUnit, dNewDisplayMinimum) &&
convertUnitValue(
dBaseMaximum, m_sBaseUnit,
sNewUnit, dNewDisplayMaximum);
if(!bConverted) {
const bool bSignalsBlocked = m_pUnitCombo->blockSignals(true);
m_pUnitCombo->setCurrentIndex(
m_pUnitCombo->findText(m_sDisplayUnit));
m_pUnitCombo->blockSignals(bSignalsBlocked);
QMessageBox::warning(
this, tr("Filtering settings"),
tr("Unable to convert the filter limits "
"to the selected unit."));
return;
}
m_sDisplayUnit = sNewUnit;
m_pMinimumEdit->setText(formatValue(dNewDisplayMinimum));
m_pMaximumEdit->setText(formatValue(dNewDisplayMaximum));
}
void nmWxPebiResultFilterSettingsDlg::refreshEditorEnabledState()
{
const bool bEnabled = m_pEnableCheck->isChecked();
m_pPropertyCombo->setEnabled(bEnabled);
m_pMinimumCheck->setEnabled(bEnabled);
m_pMaximumCheck->setEnabled(bEnabled);
m_pMinimumEdit->setEnabled(
bEnabled && m_pMinimumCheck->isChecked());
m_pMaximumEdit->setEnabled(
bEnabled && m_pMaximumCheck->isChecked());
m_pUnitCombo->setEnabled(
bEnabled && m_pUnitGroup != nullptr);
}
bool nmWxPebiResultFilterSettingsDlg::collectSettings(
nmPebiResultFilterSettings& oSettings,
QString& sError) const
{
sError.clear();
const int nPropertyIndex = m_pPropertyCombo->currentIndex();
if(nPropertyIndex < 0) {
sError = tr("A filter property must be selected.");
return false;
}
oSettings.m_bEnabled = m_pEnableCheck->isChecked();
oSettings.m_sPropertyId =
m_pPropertyCombo->itemData(nPropertyIndex).toString();
oSettings.m_bMinimumEnabled = m_pMinimumCheck->isChecked();
oSettings.m_bMaximumEnabled = m_pMaximumCheck->isChecked();
// 复选框只控制边界是否参与筛选;未启用边界的编辑值仍需保留,
// 避免重新打开对话框时退回设置对象的默认 0。
double dDisplayMinimum = 0.0;
double dDisplayMaximum = 0.0;
if(!parseFiniteValue(
m_pMinimumEdit->text(), dDisplayMinimum) ||
!parseFiniteValue(
m_pMaximumEdit->text(), dDisplayMaximum)) {
sError = tr("Filter limits must be finite numbers.");
return false;
}
if(!convertUnitValue(
dDisplayMinimum, m_sDisplayUnit,
m_sBaseUnit, oSettings.m_dMinimum) ||
!convertUnitValue(
dDisplayMaximum, m_sDisplayUnit,
m_sBaseUnit, oSettings.m_dMaximum)) {
sError = tr(
"Unable to convert the filter limits "
"to the selected unit.");
return false;
}
if(oSettings.m_bMinimumEnabled &&
oSettings.m_bMaximumEnabled &&
oSettings.m_dMinimum > oSettings.m_dMaximum) {
sError = tr("The minimum filter limit cannot exceed the maximum.");
return false;
}
return true;
}
bool nmWxPebiResultFilterSettingsDlg::applyEditor()
{
nmPebiResultPlaybackController* pPlaybackController =
m_pControlBar == nullptr ? nullptr :
m_pControlBar->getPlaybackController();
if(!m_bInitialized || m_pSceneController == nullptr ||
m_pControlBar == nullptr || pPlaybackController == nullptr ||
pPlaybackController->isPlaying() ||
m_pControlBar->isExportInProgress()) {
const QString sError = tr(
"Filtering is unavailable during playback or export.");
QMessageBox::warning(this, tr("Filtering settings"), sError);
return false;
}
nmPebiResultFilterSettings oSettings;
QString sError;
if(!collectSettings(oSettings, sError) ||
!m_pSceneController->applyFilterSettings(
m_nExpectedBindingRevision,
m_sExpectedSnapshotId,
m_sExpectedDisplayPropertyId,
m_nExpectedDisplayFrameIndex,
oSettings, &sError)) {
if(sError.isEmpty()) {
sError = tr("Unable to apply the filter settings.");
}
QMessageBox::warning(this, tr("Filtering settings"), sError);
return false;
}
m_oBaselineSettings = oSettings;
emit filterSettingsApplied();
return true;
}
bool nmWxPebiResultFilterSettingsDlg::setPropertyRange(
const QString& sPropertyId)
{
if(!m_mapPropertyRanges.contains(sPropertyId) ||
!initializeUnitEditor(sPropertyId)) {
return false;
}
const QPair<double, double> oRange =
m_mapPropertyRanges.value(sPropertyId);
double dDisplayMinimum = 0.0;
double dDisplayMaximum = 0.0;
if(!convertUnitValue(
oRange.first, m_sBaseUnit,
m_sDisplayUnit, dDisplayMinimum) ||
!convertUnitValue(
oRange.second, m_sBaseUnit,
m_sDisplayUnit, dDisplayMaximum)) {
return false;
}
m_pMinimumCheck->setChecked(true);
m_pMaximumCheck->setChecked(true);
m_pMinimumEdit->setText(formatValue(dDisplayMinimum));
m_pMaximumEdit->setText(formatValue(dDisplayMaximum));
refreshEditorEnabledState();
return true;
}
QString nmWxPebiResultFilterSettingsDlg::formatValue(double dValue) const
{
return QLocale::c().toString(dValue, 'g', 12);
}
bool nmWxPebiResultFilterSettingsDlg::parseFiniteValue(
const QString& sText,
double& dValue) const
{
bool bOk = false;
const double dCandidate = QLocale::c().toDouble(
sText.trimmed(), &bOk);
if(!bOk || !isFiniteFilterEditorValue(dCandidate)) {
return false;
}
dValue = dCandidate;
return true;
}
bool nmWxPebiResultFilterSettingsDlg::convertUnitValue(
double dSourceValue,
const QString& sSourceUnit,
const QString& sDestinationUnit,
double& dDestinationValue) const
{
if(!isFiniteFilterEditorValue(dSourceValue)) {
return false;
}
if(sSourceUnit == sDestinationUnit) {
dDestinationValue = dSourceValue;
return true;
}
if(sSourceUnit.isEmpty() || sDestinationUnit.isEmpty() ||
m_pUnitGroup == nullptr ||
m_pUnitGroup->indexOf(sSourceUnit) < 0 ||
m_pUnitGroup->indexOf(sDestinationUnit) < 0) {
return false;
}
int nDigit = 12;
double dCandidate = 0.0;
if(!m_pUnitGroup->convert(
sSourceUnit, dSourceValue,
sDestinationUnit, dCandidate, nDigit) ||
!isFiniteFilterEditorValue(dCandidate)) {
return false;
}
dDestinationValue = dCandidate;
return true;
}
/** @brief 外部三维模式的窗口私有状态,所有成员仅由 GUI 线程管理。 */
class nmWxPebiVolumeState
{
public:
/** @brief 初始化为空模式;控制器在通用渲染容器创建后绑定。 */
nmWxPebiVolumeState()
: m_pController(nullptr), m_pTask(nullptr), m_pProgress(nullptr),
m_pImportAction(nullptr), m_pReturnAction(nullptr), m_pButton(nullptr),
m_bImported(false), m_bPendingSync(false), m_bRegionVisible(false),
m_bRegionDialogVisible(false) {}
nmVolumeSceneController* m_pController; ///< 窗口独占,必须在渲染容器之前析构。
nmVolumeImportTask* m_pTask; ///< 当前唯一导入线程,结束后才允许读取结果。
QProgressDialog* m_pProgress; ///< 临时进度框,窗口对象树拥有。
QAction* m_pImportAction; ///< 按钮菜单和右键菜单共享的导入动作。
QAction* m_pReturnAction; ///< 仅外部模型模式启用的返回动作。
QToolButton* m_pButton; ///< 唯一新增的常驻切片工具按钮。
nmVTKViewState m_oSavedView; ///< 第一次进入外部模式前捕获的计算结果视图。
nmVTKViewCommandController::ViewCommands m_eSavedCommands; ///< 原结果提供的视图命令能力。
bool m_bImported; ///< 当前画面是否为外部三维模型。
bool m_bPendingSync; ///< 外部模式期间发生 Manager 变化,返回时重新读取。
bool m_bRegionVisible; ///< 原区域轮廓的实际可见状态。
bool m_bRegionDialogVisible; ///< 原区域统计面板是否可见。
};
nmWxPebiResultViewWidget::nmWxPebiResultViewWidget(
nmDataAnalyzeManager* pDataManager,
QWidget* pParent)
: QWidget(pParent),
m_pRenderContainer(nullptr),
m_pSceneController(nullptr),
m_pControlBar(nullptr),
m_pToolBar(nullptr),
m_pStatusLabel(nullptr),
m_pScalarBarAction(nullptr),
m_pScaleGridAction(nullptr),
m_pWellNamesAction(nullptr),
m_pFilterAction(nullptr),
m_pRegionPressureAction(nullptr),
m_pRegionState(new nmWxPebiResultRegionState),
m_pVolumeState(new nmWxPebiVolumeState),
m_bObservedSnapshotCurrent(false),
m_bObservedStateValid(false),
m_bSynchronizing(false),
m_bSyncPending(false)
{
createUi();
setDataManager(pDataManager);
}
nmWxPebiResultViewWidget::~nmWxPebiResultViewWidget()
{
// 先取消并断开队列回调,等待线程退出后才能释放窗口和相关 DLL 对象。
if(m_pVolumeState->m_pTask != nullptr) {
disconnect(m_pVolumeState->m_pTask, nullptr, this, nullptr);
m_pVolumeState->m_pTask->requestCancel();
m_pVolumeState->m_pTask->wait();
delete m_pVolumeState->m_pTask;
}
delete m_pVolumeState->m_pController;
delete m_pVolumeState;
m_pVolumeState = nullptr;
disconnectDataManager();
destroyRegionPressureState();
if(m_pControlBar != nullptr) {
m_pControlBar->stopPlayback();
delete m_pControlBar;
m_pControlBar = nullptr;
}
if(m_pSceneController != nullptr) {
m_pSceneController->clear();
delete m_pSceneController;
m_pSceneController = nullptr;
}
// 渲染容器、工具栏、状态栏和 QAction 最后由 QWidget 对象树统一释放。
}
void nmWxPebiResultViewWidget::setDataManager(
nmDataAnalyzeManager* pDataManager)
{
Q_ASSERT(isResultViewGuiThread());
Q_ASSERT(pDataManager == nullptr ||
pDataManager->thread() == QThread::currentThread());
if(!isResultViewGuiThread() ||
(pDataManager != nullptr &&
pDataManager->thread() != QThread::currentThread())) {
// 窗口会同步读取不可变快照引用,不能跨线程直接访问 Manager。
return;
}
if(m_pDataManager.data() == pDataManager) {
// 生产入口可能重复安装同一 Manager;这里只读最新状态,不能清空相机。
synchronizeFromDataManager();
return;
}
if(m_pVolumeState->m_pTask != nullptr) m_pVolumeState->m_pTask->requestCancel();
disconnectDataManager();
if(isImportedVolumeMode()) {
// 分析上下文换绑时丢弃旧计算结果,但保留用户正在检查的外部模型。
clearRegionPressureSelection(false);
m_pSceneController->clear();
m_pDisplayedSnapshot.clear();
m_sDisplayedSnapshotId.clear();
m_pVolumeState->m_oSavedView = nmVTKViewState();
m_pVolumeState->m_bRegionVisible = false;
m_pVolumeState->m_bRegionDialogVisible = false;
m_pVolumeState->m_bPendingSync = true;
} else {
clearSceneAndControls(tr("No result data."));
}
m_pDataManager = pDataManager;
if(!m_pDataManager.isNull()) {
connect(m_pDataManager.data(), SIGNAL(sigPebiResultStateChanged()),
this, SLOT(onPebiResultStateChanged()));
connect(m_pDataManager.data(), SIGNAL(destroyed(QObject*)),
this, SLOT(onDataManagerDestroyed(QObject*)));
}
synchronizeFromDataManager();
}
nmDataAnalyzeManager* nmWxPebiResultViewWidget::getDataManager() const
{
return m_pDataManager.data();
}
void nmWxPebiResultViewWidget::synchronizeFromDataManager()
{
Q_ASSERT(isResultViewGuiThread());
Q_ASSERT(m_pDataManager.isNull() ||
m_pDataManager->thread() == QThread::currentThread());
if(!isResultViewGuiThread() ||
(!m_pDataManager.isNull() &&
m_pDataManager->thread() != QThread::currentThread())) {
return;
}
if(m_bSynchronizing) {
// 同步期间只记录一次待处理请求,当前事务结束后重新读取 Manager 最新值。
m_bSyncPending = true;
return;
}
m_bSynchronizing = true;
do {
m_bSyncPending = false;
synchronizeOnce();
} while(m_bSyncPending);
m_bSynchronizing = false;
}
void nmWxPebiResultViewWidget::onPebiResultStateChanged()
{
synchronizeFromDataManager();
}
void nmWxPebiResultViewWidget::onDataManagerDestroyed(QObject* pObject)
{
Q_UNUSED(pObject);
// destroyed() 到达时 QPointer 可能已经清空,槽内绝不再读取 Manager。
m_pDataManager = nullptr;
if(isImportedVolumeMode()) {
m_pVolumeState->m_bPendingSync = true;
return;
}
if(m_bSynchronizing) {
// 极端嵌套事件下不得在快照提交栈内递归清场,退出当前事务后再读空状态。
m_bSyncPending = true;
return;
}
clearSceneAndControls(tr("No result data."));
// 记录稳定空状态,后续重复同步空 Manager 时不再清场或切换状态页。
rememberObservedState(
QSharedPointer<const nmPebiResultSnapshot>(),
QString(), false);
}
void nmWxPebiResultViewWidget::appendContextMenuActions(QMenu* pMenu)
{
if(pMenu == nullptr) {
return;
}
pMenu->addAction(m_pVolumeState->m_pImportAction);
pMenu->addAction(m_pVolumeState->m_pReturnAction);
pMenu->addSeparator();
pMenu->addAction(m_pFilterAction);
pMenu->addAction(m_pRegionPressureAction);
pMenu->addSeparator();
pMenu->addAction(m_pScalarBarAction);
pMenu->addAction(m_pScaleGridAction);
pMenu->addAction(m_pWellNamesAction);
if(m_pControlBar != nullptr &&
m_pControlBar->getExportAnimationAction() != nullptr) {
pMenu->addSeparator();
pMenu->addAction(m_pControlBar->getExportAnimationAction());
}
}
void nmWxPebiResultViewWidget::onControlOperationFailed(
const QString& sError)
{
// 绑定失败优先显示;输入修改不再提示,也不屏蔽后续真实操作错误。
if(!m_sBindingError.isEmpty()) {
return;
}
m_sOperationError = sError;
refreshStatusBar();
}
void nmWxPebiResultViewWidget::onControlOperationSucceeded()
{
if(m_sOperationError.isEmpty()) {
return;
}
// 这里只清除普通操作错误;刷新函数仍优先显示绑定失败。
m_sOperationError.clear();
refreshStatusBar();
}
void nmWxPebiResultViewWidget::onViewportSizeChanged(
int nWidth,
int nHeight)
{
if(m_pVolumeState->m_pController != nullptr) m_pVolumeState->m_pController->setViewportSize(nWidth, nHeight);
if(m_pSceneController != nullptr) {
// SceneController 缓存尺寸,即使当前尚未创建结果色标也不会丢失。
m_pSceneController->setViewportSize(nWidth, nHeight);
}
}
void nmWxPebiResultViewWidget::onShowFilterSettings()
{
if(isImportedVolumeMode()) return;
nmPebiResultPlaybackController* pPlaybackController =
m_pControlBar == nullptr ? nullptr :
m_pControlBar->getPlaybackController();
if(m_pSceneController == nullptr || m_pControlBar == nullptr ||
pPlaybackController == nullptr ||
!m_pSceneController->hasSnapshot() ||
pPlaybackController->isPlaying() ||
m_pControlBar->isExportInProgress() ||
m_pControlBar->isExternalInteractionLocked()) {
return;
}
nmWxPebiResultFilterSettingsDlg oDialog(
m_pSceneController, m_pControlBar, this);
connect(&oDialog, SIGNAL(filterSettingsApplied()),
this, SLOT(onControlOperationSucceeded()));
oDialog.exec();
synchronizeBusinessActions();
}
void nmWxPebiResultViewWidget::onRegionPressureStatisticsTriggered()
{
if(isImportedVolumeMode()) return;
if(m_pRegionState == nullptr || m_pControlBar == nullptr) {
return;
}
// 共享 QAction 根据当前状态分别表示:取消绘制、重显结果或开始新绘制。
if(isRegionPressureDrawing()) {
clearRegionPressureSelection(true);
onControlOperationSucceeded();
return;
}
if(m_pRegionState->m_eState ==
nmWxPebiResultRegionState::State_Completed) {
showRegionPressureStatisticsDialog();
return;
}
nmPebiResultPlaybackController* pPlaybackController =
m_pControlBar->getPlaybackController();
if(pPlaybackController == nullptr ||
pPlaybackController->isPlaying() ||
m_pControlBar->isExportInProgress() ||
m_pControlBar->isExternalInteractionLocked()) {
return;
}
if(m_pRenderContainer == nullptr ||
!canProjectRegionOntoXyPlane(
m_pRenderContainer->getRenderer())) {
onControlOperationFailed(tr(
"Switch to Top View or Isometric View before drawing a pressure region."));
return;
}
if(!startRegionPressureDrawing()) {
onControlOperationFailed(tr(
"Unable to start region pressure drawing."));
} else {
onControlOperationSucceeded();
}
}
void nmWxPebiResultViewWidget::handleRegionPolygonEvent(
vtkObject* pCaller,
unsigned long nEventId,
void* pClientData,
void* pCallData)
{
Q_UNUSED(pCallData);
nmWxPebiResultViewWidget* pView =
static_cast<nmWxPebiResultViewWidget*>(pClientData);
if(pView == nullptr || pView->m_pRegionState == nullptr ||
pView->m_pRegionState->m_eState !=
nmWxPebiResultRegionState::State_Drawing ||
pCaller != pView->m_pRegionState->m_pStyle.GetPointer()) {
return;
}
nmWxPebiResultRegionState* pState = pView->m_pRegionState;
if(nEventId ==
nmVTKPlanarPolygonInteractorStyle::PolygonChangedEvent) {
nmVTKScene* pScene = pView->m_pRenderContainer == nullptr
? nullptr : pView->m_pRenderContainer->getScene();
if(pScene != nullptr && pState->m_pLayer != nullptr &&
pScene->getLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID)) == pState->m_pLayer) {
pState->m_pLayer->setPolygon(
pState->m_pStyle->getPoints(),
pState->m_pStyle->isCompleted());
}
return;
}
// VTK 回调内只复制小量状态;场景切换、对话框和统计计算延后到 Qt 事件循环。
nmWxPebiResultRegionState::PendingEvent ePendingEvent =
nmWxPebiResultRegionState::PendingEvent_None;
if(nEventId ==
nmVTKPlanarPolygonInteractorStyle::PolygonCompletedEvent) {
ePendingEvent =
nmWxPebiResultRegionState::PendingEvent_Completed;
pState->m_vecPendingPoints = pState->m_pStyle->getPoints();
} else if(nEventId ==
nmVTKPlanarPolygonInteractorStyle::PolygonCancelledEvent) {
ePendingEvent =
nmWxPebiResultRegionState::PendingEvent_Cancelled;
} else if(nEventId ==
nmVTKPlanarPolygonInteractorStyle::PolygonInvalidEvent) {
ePendingEvent =
nmWxPebiResultRegionState::PendingEvent_Invalid;
} else {
return;
}
// 完成或取消优先于尚未处理的无效提示,且每次只排一个 Qt 收尾任务。
if(pState->m_bPendingEventQueued) {
if(pState->m_ePendingEvent ==
nmWxPebiResultRegionState::PendingEvent_Invalid &&
ePendingEvent !=
nmWxPebiResultRegionState::PendingEvent_Invalid) {
pState->m_ePendingEvent = ePendingEvent;
}
return;
}
pState->m_ePendingEvent = ePendingEvent;
pState->m_bPendingEventQueued = true;
QMetaObject::invokeMethod(
pView, "processPendingRegionInteractionEvent",
Qt::QueuedConnection);
}
void nmWxPebiResultViewWidget::processPendingRegionInteractionEvent()
{
if(m_pRegionState == nullptr) {
return;
}
const nmWxPebiResultRegionState::PendingEvent ePendingEvent =
m_pRegionState->m_ePendingEvent;
const QVector<QPointF> vecPoints =
m_pRegionState->m_vecPendingPoints;
m_pRegionState->m_ePendingEvent =
nmWxPebiResultRegionState::PendingEvent_None;
m_pRegionState->m_bPendingEventQueued = false;
m_pRegionState->m_vecPendingPoints.clear();
if(!isRegionPressureDrawing()) {
return;
}
if(ePendingEvent ==
nmWxPebiResultRegionState::PendingEvent_Invalid) {
onControlOperationFailed(tr(
"Draw a non-degenerate region with at least three points."));
return;
}
if(ePendingEvent ==
nmWxPebiResultRegionState::PendingEvent_Cancelled) {
clearRegionPressureSelection(true);
onControlOperationSucceeded();
return;
}
if(ePendingEvent !=
nmWxPebiResultRegionState::PendingEvent_Completed) {
return;
}
// 绘制期间快照、属性或帧发生变化时,不能把旧坐标区域提交到新结果。
const bool bIdentityMatches =
m_pSceneController != nullptr &&
m_pSceneController->hasSnapshot() &&
!m_pDisplayedSnapshot.isNull() &&
m_pDisplayedSnapshot.data() ==
m_pRegionState->m_pFrozenSnapshot.data() &&
m_pSceneController->getSnapshotBindingRevision() ==
m_pRegionState->m_nFrozenBindingRevision &&
m_pSceneController->getCurrentSnapshotId() ==
m_pRegionState->m_sFrozenSnapshotId &&
m_sDisplayedSnapshotId ==
m_pRegionState->m_sFrozenSnapshotId &&
m_pSceneController->getCurrentPropertyId() ==
m_pRegionState->m_sFrozenPropertyId &&
m_pSceneController->getCurrentFrameIndex() ==
m_pRegionState->m_nFrozenFrameIndex;
if(!bIdentityMatches) {
clearRegionPressureSelection(true);
onControlOperationFailed(tr(
"The displayed result changed while the region was drawn."));
return;
}
// Calculator::prepare() 事务式建立相交单元和静态权重缓存。
QString sError;
if(!m_pRegionState->m_oCalculator.prepare(
m_pRegionState->m_pFrozenSnapshot, vecPoints, &sError)) {
clearRegionPressureSelection(true);
onControlOperationFailed(tr(
"Unable to prepare the selected pressure region."));
return;
}
nmPebiRegionPressureStatistics oStatistics;
if(!m_pRegionState->m_oCalculator.calculateFrame(
m_pRegionState->m_nFrozenFrameIndex,
oStatistics, &sError)) {
clearRegionPressureSelection(true);
onControlOperationFailed(tr(
"Unable to calculate region pressure statistics."));
return;
}
nmVTKScene* pScene = m_pRenderContainer == nullptr
? nullptr : m_pRenderContainer->getScene();
if(pScene == nullptr || m_pRegionState->m_pLayer == nullptr ||
pScene->getLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID)) != m_pRegionState->m_pLayer ||
!m_pRegionState->m_pLayer->setPolygon(
m_pRegionState->m_oCalculator.getPolygonPoints(), true)) {
clearRegionPressureSelection(true);
onControlOperationFailed(tr(
"Unable to preserve the selected pressure region."));
return;
}
// 几何、计算和轮廓全部成功后才将窗口状态提交为 Completed。
m_pRegionState->m_nRegionBindingRevision =
m_pRegionState->m_nFrozenBindingRevision;
m_pRegionState->m_sRegionSnapshotId =
m_pRegionState->m_sFrozenSnapshotId;
m_pRegionState->m_nLastAttemptedFrameIndex =
m_pRegionState->m_nFrozenFrameIndex;
m_pRegionState->m_bStatisticsCalculated = true;
m_pRegionState->m_sStatisticsError.clear();
m_pRegionState->m_oStatistics = oStatistics;
m_pRegionState->m_sLastObservedPropertyId =
QString::fromLatin1("pressure");
m_pRegionState->m_eState =
nmWxPebiResultRegionState::State_Completed;
stopRegionPressureDrawing();
onControlOperationSucceeded();
showRegionPressureStatisticsDialog();
synchronizeBusinessActions();
}
void nmWxPebiResultViewWidget::onResultDisplayStateChanged()
{
if(isImportedVolumeMode()) return;
if(m_pRegionState != nullptr && m_pSceneController != nullptr &&
m_pRegionState->m_eState ==
nmWxPebiResultRegionState::State_Completed) {
const QString sCurrentPropertyId =
m_pSceneController->getCurrentPropertyId();
if(sCurrentPropertyId == QString::fromLatin1("pressure") &&
m_pRegionState->m_sLastObservedPropertyId !=
sCurrentPropertyId) {
// 从静态属性切回 pressure 时必须重新评估第 0 帧,即使曾统计过该帧。
m_pRegionState->m_nLastAttemptedFrameIndex = -1;
}
m_pRegionState->m_sLastObservedPropertyId = sCurrentPropertyId;
}
synchronizeBusinessActions();
updateRegionPressureStatistics();
}
void nmWxPebiResultViewWidget::onCloseRegionPressureStatistics()
{
if(m_pRegionState == nullptr) {
return;
}
clearRegionPressureSelection(true);
onControlOperationSucceeded();
}
void nmWxPebiResultViewWidget::onExportAnimationRequested()
{
if(isImportedVolumeMode()) return;
nmPebiResultPlaybackController* pPlaybackController =
m_pControlBar == nullptr ? nullptr :
m_pControlBar->getPlaybackController();
QString sBackendError;
if(m_pSceneController == nullptr || m_pRenderContainer == nullptr ||
pPlaybackController == nullptr ||
pPlaybackController->isPlaying() ||
(m_pControlBar != nullptr &&
m_pControlBar->isExternalInteractionLocked()) ||
!m_pSceneController->hasSnapshot() ||
m_pDisplayedSnapshot.isNull() ||
!nmFFmpegVideoWriter::isBackendAvailable(&sBackendError)) {
if(!sBackendError.isEmpty()) {
QMessageBox::warning(this, tr("Export Animation"), sBackendError);
}
return;
}
AnimationExportGuard oExportGuard(m_pControlBar);
if(!oExportGuard.isAcquired()) {
QMessageBox::information(
this, tr("Export Animation"),
tr("Another result animation export is already in progress."));
return;
}
const QSharedPointer<const nmPebiResultSnapshot> pFrozenSnapshot =
m_pDisplayedSnapshot;
const quint64 nFrozenBindingRevision =
m_pSceneController->getSnapshotBindingRevision();
const QString sFrozenSnapshotId =
m_pSceneController->getCurrentSnapshotId();
const QString sFrozenPropertyId =
m_pSceneController->getCurrentPropertyId();
const nmVTKMeshLayer::DisplayMode eFrozenMeshDisplayMode =
m_pSceneController->getMeshDisplayMode();
nmPebiResultDisplaySettings oFrozenDisplaySettings;
nmPebiResultFilterSettings oFrozenFilterSettings;
if(!m_pSceneController->getCurrentDisplaySettings(
oFrozenDisplaySettings) ||
!m_pSceneController->getFilterSettings(
oFrozenFilterSettings)) {
return;
}
const int nFrozenFilterFrameIndex =
m_pSceneController->getFilterFrameIndex();
const int nFrameCount = pFrozenSnapshot->getPropertyFrameCount(
sFrozenPropertyId);
if(nFrozenBindingRevision == 0 || sFrozenSnapshotId.isEmpty() ||
sFrozenPropertyId.isEmpty() || nFrameCount <= 1 ||
!nmVTKMeshLayer::isValidDisplayMode(eFrozenMeshDisplayMode) ||
(oFrozenFilterSettings.m_bEnabled &&
nFrozenFilterFrameIndex < 0) ||
!m_pSceneController->isPropertyTimeDependent(sFrozenPropertyId)) {
return;
}
QVector<double> vecFrameTimes;
vecFrameTimes.reserve(nFrameCount);
for(int nFrameIndex = 0; nFrameIndex < nFrameCount; ++nFrameIndex) {
double dTimeHours = 0.0;
if(!pFrozenSnapshot->getPropertyTimeAt(
sFrozenPropertyId, nFrameIndex, dTimeHours)) {
QMessageBox::warning(
this, tr("Export Animation"),
tr("Unable to read the result animation timeline."));
return;
}
vecFrameTimes.append(dTimeHours);
}
nmWxPebiResultAnimationExportDlg oSettingsDialog(
vecFrameTimes, m_pRenderContainer->getViewportSize(), this);
if(oSettingsDialog.exec() != QDialog::Accepted) {
return;
}
// 参数窗口内的文件浏览也会形成嵌套事件循环,开始前重新核对完整显示身份。
if(m_pDisplayedSnapshot.data() != pFrozenSnapshot.data() ||
m_pSceneController->getSnapshotBindingRevision() !=
nFrozenBindingRevision ||
m_pSceneController->getCurrentSnapshotId() != sFrozenSnapshotId ||
m_pSceneController->getCurrentPropertyId() != sFrozenPropertyId ||
m_pSceneController->getMeshDisplayMode() !=
eFrozenMeshDisplayMode) {
QMessageBox::warning(
this, tr("Export Animation"),
tr("The displayed result changed before export started."));
return;
}
nmPebiResultDisplaySettings oCurrentDisplaySettings;
nmPebiResultFilterSettings oCurrentFilterSettings;
if(!m_pSceneController->getCurrentDisplaySettings(
oCurrentDisplaySettings) ||
oCurrentDisplaySettings != oFrozenDisplaySettings ||
!m_pSceneController->getFilterSettings(oCurrentFilterSettings) ||
oCurrentFilterSettings != oFrozenFilterSettings ||
m_pSceneController->getFilterFrameIndex() !=
nFrozenFilterFrameIndex) {
QMessageBox::warning(
this, tr("Export Animation"),
tr("The displayed result changed before export started."));
return;
}
vtkRenderer* pRenderer = m_pRenderContainer->getRenderer();
if(pRenderer == nullptr || pRenderer->GetActiveCamera() == nullptr) {
QMessageBox::warning(
this, tr("Export Animation"),
tr("Unable to freeze the current result display."));
return;
}
nmPebiResultAnimationExporter::Request oRequest;
oRequest.m_pSnapshot = pFrozenSnapshot;
oRequest.m_sPropertyId = sFrozenPropertyId;
oRequest.m_oDisplaySettings = oFrozenDisplaySettings;
oRequest.m_eMeshDisplayMode = eFrozenMeshDisplayMode;
oRequest.m_oFilterSettings = oFrozenFilterSettings;
oRequest.m_nFilterFrameIndex = nFrozenFilterFrameIndex;
oRequest.m_oExportSettings = oSettingsDialog.getSettings();
oRequest.m_sTargetFilePath = oSettingsDialog.getTargetFilePath();
oRequest.m_bScalarBarVisible =
m_pSceneController->isScalarBarVisible();
oRequest.m_bScaleGridVisible =
m_pSceneController->isScaleGridVisible();
oRequest.m_bWellNamesVisible =
m_pSceneController->areWellNamesVisible();
pRenderer->GetBackground(oRequest.m_dBackground);
pRenderer->GetBackground2(oRequest.m_dBackground2);
oRequest.m_bGradientBackground =
pRenderer->GetGradientBackground() != 0;
oRequest.m_pCamera = vtkSmartPointer<vtkCamera>::New();
oRequest.m_pCamera->DeepCopy(pRenderer->GetActiveCamera());
QProgressDialog oProgressDialog(
tr("Exporting result animation..."), tr("Cancel"),
0, oRequest.m_oExportSettings.getOutputFrameCount(), this);
oProgressDialog.setWindowTitle(tr("Export Animation"));
oProgressDialog.setWindowModality(Qt::ApplicationModal);
oProgressDialog.setMinimumDuration(0);
oProgressDialog.setAutoClose(false);
oProgressDialog.setAutoReset(false);
nmPebiResultAnimationExporter oExporter;
connect(&oExporter, SIGNAL(progressChanged(int,int)),
&oProgressDialog, SLOT(setValue(int)));
connect(&oProgressDialog, SIGNAL(canceled()),
&oExporter, SLOT(cancel()));
oProgressDialog.show();
QString sExportError;
const nmPebiResultAnimationExporter::ExportResult eResult =
oExporter.exportAnimation(oRequest, &sExportError);
oProgressDialog.close();
oExportGuard.release();
if(eResult == nmPebiResultAnimationExporter::Export_Succeeded) {
onControlOperationSucceeded();
QMessageBox::information(
this, tr("Export Animation"),
tr("The result animation was saved to:\n%1")
.arg(QDir::toNativeSeparators(
oRequest.m_sTargetFilePath)));
} else if(eResult == nmPebiResultAnimationExporter::Export_Failed) {
QMessageBox::warning(
this, tr("Export Animation"),
sExportError.isEmpty()
? tr("Unable to export the result animation.")
: sExportError);
}
}
void nmWxPebiResultViewWidget::onScalarBarToggled(bool bVisible)
{
if(isImportedVolumeMode()) {
m_pVolumeState->m_pController->setScalarBarVisible(bVisible);
return;
}
if(m_pControlBar != nullptr &&
m_pControlBar->isExternalInteractionLocked()) {
synchronizeBusinessActions();
return;
}
if(m_pSceneController != nullptr && m_pSceneController->hasSnapshot()) {
m_pSceneController->setScalarBarVisible(bVisible);
}
}
void nmWxPebiResultViewWidget::onScaleGridToggled(bool bVisible)
{
if(isImportedVolumeMode()) {
m_pVolumeState->m_pController->setScaleGridVisible(bVisible);
return;
}
if(m_pControlBar != nullptr &&
m_pControlBar->isExternalInteractionLocked()) {
synchronizeBusinessActions();
return;
}
if(m_pSceneController != nullptr && m_pSceneController->hasSnapshot()) {
m_pSceneController->setScaleGridVisible(bVisible);
}
}
void nmWxPebiResultViewWidget::onWellNamesToggled(bool bVisible)
{
if(isImportedVolumeMode()) return;
if(m_pControlBar != nullptr &&
m_pControlBar->isExternalInteractionLocked()) {
synchronizeBusinessActions();
return;
}
if(m_pSceneController != nullptr && m_pSceneController->hasSnapshot()) {
m_pSceneController->setWellNamesVisible(bVisible);
}
}
void nmWxPebiResultViewWidget::createUi()
{
QVBoxLayout* pMainLayout = new QVBoxLayout(this);
pMainLayout->setContentsMargins(0, 0, 0, 0);
pMainLayout->setSpacing(0);
QWidget* pRenderArea = new QWidget(this);
QHBoxLayout* pRenderLayout = new QHBoxLayout(pRenderArea);
pRenderLayout->setContentsMargins(0, 0, 0, 0);
pRenderLayout->setSpacing(0);
// 通用容器是本窗口唯一创建 QVTKWidget、Renderer 和 RenderWindow 的对象。
m_pRenderContainer = new nmWxVTKRenderContainerWidget(pRenderArea);
m_pRenderContainer->setSizePolicy(
QSizePolicy::Expanding, QSizePolicy::Expanding);
m_pRenderContainer->setViewCommandCapabilities(
nmVTKViewCommandController::ViewCommand_ZoomIn |
nmVTKViewCommandController::ViewCommand_ZoomOut |
nmVTKViewCommandController::ViewCommand_Fit |
nmVTKViewCommandController::ViewCommand_Top |
nmVTKViewCommandController::ViewCommand_Front |
nmVTKViewCommandController::ViewCommand_SetRotationCenter |
nmVTKViewCommandController::
ViewCommand_ShowRotationCenterMarker |
nmVTKViewCommandController::ViewCommand_SaveImage |
nmVTKViewCommandController::ViewCommand_CopyImage |
nmVTKViewCommandController::ViewCommand_Print |
nmVTKViewCommandController::ViewCommand_PrintPreview);
m_pSceneController = new nmPebiResultSceneController(m_pRenderContainer);
m_pVolumeState->m_pController = new nmVolumeSceneController(m_pRenderContainer);
connect(m_pRenderContainer, SIGNAL(viewportSizeChanged(int,int)),
this, SLOT(onViewportSizeChanged(int,int)));
const QSize oInitialViewportSize =
m_pRenderContainer->getViewportSize();
onViewportSizeChanged(
oInitialViewportSize.width(), oInitialViewportSize.height());
m_pToolBar = new QToolBar(pRenderArea);
m_pToolBar->setOrientation(Qt::Vertical);
m_pToolBar->setMovable(false);
m_pToolBar->setFloatable(false);
m_pToolBar->setIconSize(QSize(32, 32));
m_pToolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_pToolBar->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
m_pScalarBarAction = new QAction(
QIcon(resultViewIconPath("NmColorScale.png")),
tr("Color Scale"), this);
m_pScaleGridAction = new QAction(
QIcon(resultViewIconPath("NmScaleGrid.png")),
tr("Scale Grid"), this);
m_pWellNamesAction = new QAction(
QIcon(resultViewIconPath("NmShowWellNames.png")),
tr("Well Names"), this);
m_pFilterAction = new QAction(
QIcon(resultViewIconPath("NmFilter.png")),
tr("Data Filtering..."), this);
m_pFilterAction->setToolTip(m_pFilterAction->text());
m_pRegionPressureAction = new QAction(
QIcon(resultViewIconPath("NmPolygon.png")),
tr("Region Average Pressure"), this);
m_pRegionPressureAction->setToolTip(
m_pRegionPressureAction->text());
QAction* const pBusinessActions[] = {
m_pScalarBarAction, m_pScaleGridAction, m_pWellNamesAction
};
for(int nIndex = 0; nIndex < 3; ++nIndex) {
pBusinessActions[nIndex]->setCheckable(true);
pBusinessActions[nIndex]->setToolTip(
pBusinessActions[nIndex]->text());
}
nmVTKViewCommandController* pCommandController =
m_pRenderContainer->getViewCommandController();
if(pCommandController != nullptr) {
QAction* pZoomOutAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_ZoomOut);
QAction* pFitAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_Fit);
QAction* pZoomInAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_ZoomIn);
QAction* pTopAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_Top);
QAction* pFrontAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_Front);
QAction* pPickCenterAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_SetRotationCenter);
QAction* pCopyAction = pCommandController->getAction(
nmVTKViewCommandController::ViewCommand_CopyImage);
if(pZoomOutAction != nullptr) m_pToolBar->addAction(pZoomOutAction);
if(pFitAction != nullptr) m_pToolBar->addAction(pFitAction);
if(pZoomInAction != nullptr) m_pToolBar->addAction(pZoomInAction);
m_pToolBar->addSeparator();
if(pTopAction != nullptr) m_pToolBar->addAction(pTopAction);
if(pFrontAction != nullptr) m_pToolBar->addAction(pFrontAction);
if(pPickCenterAction != nullptr) m_pToolBar->addAction(pPickCenterAction);
m_pToolBar->addSeparator();
m_pToolBar->addAction(m_pFilterAction);
m_pToolBar->addAction(m_pRegionPressureAction);
for(int nIndex = 0; nIndex < 3; ++nIndex) {
m_pToolBar->addAction(pBusinessActions[nIndex]);
}
m_pToolBar->addSeparator();
if(pCopyAction != nullptr) m_pToolBar->addAction(pCopyAction);
}
// 只增加一个常驻按钮。小图标直接绘制,避免部署时丢失额外资源文件。
QPixmap oSliceIcon(32, 32);
oSliceIcon.fill(Qt::transparent);
{
QPainter oPainter(&oSliceIcon);
oPainter.setRenderHint(QPainter::Antialiasing);
oPainter.setPen(QPen(QColor(65, 85, 105), 1.5));
oPainter.drawRect(7, 5, 18, 22);
oPainter.setBrush(QColor(60, 155, 215, 160));
QPolygon oPlane;
oPlane << QPoint(3, 20) << QPoint(20, 11) << QPoint(29, 14) << QPoint(12, 24);
oPainter.drawPolygon(oPlane);
}
m_pVolumeState->m_pButton = new QToolButton(m_pToolBar);
m_pVolumeState->m_pButton->setObjectName(QLatin1String("volumeSliceButton"));
m_pVolumeState->m_pButton->setIcon(QIcon(oSliceIcon));
m_pVolumeState->m_pButton->setIconSize(m_pToolBar->iconSize());
m_pVolumeState->m_pButton->setText(tr("Slice"));
m_pVolumeState->m_pButton->setToolTip(tr("Slice"));
m_pVolumeState->m_pButton->setAutoRaise(true);
m_pVolumeState->m_pButton->setPopupMode(QToolButton::InstantPopup);
QMenu* pSliceMenu = new QMenu(m_pVolumeState->m_pButton);
m_pVolumeState->m_pImportAction = new QAction(tr("Import 3D Model..."), this);
m_pVolumeState->m_pImportAction->setObjectName(QLatin1String("importVolumeAction"));
m_pVolumeState->m_pReturnAction = new QAction(tr("Return to Calculation Result"), this);
m_pVolumeState->m_pReturnAction->setObjectName(QLatin1String("returnCalculationAction"));
pSliceMenu->addAction(m_pVolumeState->m_pImportAction);
pSliceMenu->addAction(m_pVolumeState->m_pReturnAction);
m_pVolumeState->m_pButton->setMenu(pSliceMenu);
m_pToolBar->addWidget(m_pVolumeState->m_pButton);
connect(m_pVolumeState->m_pImportAction, SIGNAL(triggered()), this, SLOT(onImportVolumeRequested()));
connect(m_pVolumeState->m_pReturnAction, SIGNAL(triggered()), this, SLOT(onReturnToCalculationResult()));
connect(m_pScalarBarAction, SIGNAL(toggled(bool)),
this, SLOT(onScalarBarToggled(bool)));
connect(m_pScaleGridAction, SIGNAL(toggled(bool)),
this, SLOT(onScaleGridToggled(bool)));
connect(m_pWellNamesAction, SIGNAL(toggled(bool)),
this, SLOT(onWellNamesToggled(bool)));
connect(m_pFilterAction, SIGNAL(triggered()),
this, SLOT(onShowFilterSettings()));
connect(m_pRegionPressureAction, SIGNAL(triggered()),
this, SLOT(onRegionPressureStatisticsTriggered()));
connect(m_pRenderContainer, SIGNAL(contextMenuAboutToShow(QMenu*)),
this, SLOT(appendContextMenuActions(QMenu*)));
pRenderLayout->addWidget(m_pRenderContainer, 1);
pRenderLayout->addWidget(m_pToolBar);
pMainLayout->addWidget(pRenderArea, 1);
m_pStatusLabel = new QLabel(this);
m_pStatusLabel->setWordWrap(true);
m_pStatusLabel->setContentsMargins(8, 4, 8, 4);
m_pStatusLabel->hide();
pMainLayout->addWidget(m_pStatusLabel);
m_pControlBar = new nmWxPebiResultControlBar(
m_pSceneController, this);
connect(m_pControlBar, SIGNAL(operationFailed(QString)),
this, SLOT(onControlOperationFailed(QString)));
connect(m_pControlBar, SIGNAL(operationSucceeded()),
this, SLOT(onControlOperationSucceeded()));
connect(m_pControlBar, SIGNAL(exportAnimationRequested()),
this, SLOT(onExportAnimationRequested()));
connect(m_pControlBar, SIGNAL(exportInProgressChanged(bool)),
this, SLOT(synchronizeBusinessActions()));
if(m_pControlBar->getPlaybackController() != nullptr) {
connect(m_pControlBar->getPlaybackController(), SIGNAL(stateChanged()),
this, SLOT(onResultDisplayStateChanged()));
}
pMainLayout->addWidget(m_pControlBar);
synchronizeBusinessActions();
m_pRenderContainer->showEmptyState(tr("No result data."));
}
void nmWxPebiResultViewWidget::synchronizeOnce()
{
if(isImportedVolumeMode()) {
// 正式结果变化不能抢占正在查看的外部模型;返回时读取 Manager 最新快照。
m_pVolumeState->m_bPendingSync = true;
return;
}
if(m_pDataManager.isNull()) {
if(m_bObservedStateValid && m_pObservedSnapshot.isNull()) {
return;
}
clearSceneAndControls(tr("No result data."));
rememberObservedState(
QSharedPointer<const nmPebiResultSnapshot>(),
QString(), false);
return;
}
const QSharedPointer<const nmPebiResultSnapshot> pSnapshot =
m_pDataManager->getPebiResultSnapshot();
const QString sSnapshotId = pSnapshot.isNull()
? QString() : pSnapshot->getSnapshotId();
const bool bCurrent = !pSnapshot.isNull() &&
m_pDataManager->isPebiResultSnapshotCurrent();
const bool bSameIdentity = m_bObservedStateValid &&
m_pObservedSnapshot.data() == pSnapshot.data() &&
m_sObservedSnapshotId == sSnapshotId;
const bool bSameState = bSameIdentity &&
m_bObservedSnapshotCurrent == bCurrent;
if(bSameState) {
return;
}
const bool bBecameStale = bSameIdentity &&
m_bObservedSnapshotCurrent && !bCurrent;
m_sOperationError.clear();
if(pSnapshot.isNull()) {
clearSceneAndControls(tr("No result data."));
rememberObservedState(pSnapshot, sSnapshotId, false);
return;
}
if(!bSameIdentity) {
// 候选提交前停止本窗口 Timer;失败时旧 Scene 和最后压力帧记忆仍保留。
m_pControlBar->stopPlayback();
QString sError;
const bool bBound = m_pSceneController->setSnapshot(
pSnapshot, &sError);
rememberObservedState(pSnapshot, sSnapshotId, bCurrent);
if(bBound) {
m_pDisplayedSnapshot = pSnapshot;
m_sDisplayedSnapshotId = sSnapshotId;
m_sBindingError.clear();
// 只有新快照已经成功发布后才清旧区域;失败回滚必须完整保留旧统计。
clearRegionPressureSelection(true);
// 新成功绑定序号会让 Playback 和 ControlBar 同时重置各自缓存。
m_pControlBar->synchronizeFromScene();
synchronizeBusinessActions();
refreshStatusBar();
return;
}
m_sBindingError = sError.isEmpty()
? tr("Unable to display the latest result.")
: tr("Unable to display the latest result: %1").arg(sError);
if(!m_pSceneController->hasSnapshot()) {
m_pDisplayedSnapshot.clear();
m_sDisplayedSnapshotId.clear();
}
m_pControlBar->synchronizeFromScene();
synchronizeBusinessActions();
if(m_pSceneController->hasSnapshot()) {
// 旧画面保持 Ready;这里只显示红色非阻塞提示,不能追加 Render。
refreshStatusBar();
} else {
m_pStatusLabel->hide();
m_pRenderContainer->showErrorState(m_sBindingError);
}
return;
}
rememberObservedState(pSnapshot, sSnapshotId, bCurrent);
if(bBecameStale) {
// 只在“当前 -> 过期”的边沿暂停一次;用户之后可以手动重新播放旧结果。
m_pControlBar->stopPlayback();
}
refreshStatusBar();
}
void nmWxPebiResultViewWidget::clearSceneAndControls(
const QString& sEmptyMessage)
{
if(m_pControlBar != nullptr) {
m_pControlBar->stopPlayback();
}
clearRegionPressureSelection(false);
if(m_pSceneController != nullptr) {
m_pSceneController->clear();
}
m_pObservedSnapshot.clear();
m_sObservedSnapshotId.clear();
m_bObservedSnapshotCurrent = false;
m_bObservedStateValid = false;
m_pDisplayedSnapshot.clear();
m_sDisplayedSnapshotId.clear();
m_sBindingError.clear();
m_sOperationError.clear();
if(m_pControlBar != nullptr) {
m_pControlBar->synchronizeFromScene();
}
synchronizeBusinessActions();
if(m_pStatusLabel != nullptr) {
m_pStatusLabel->hide();
}
if(m_pRenderContainer != nullptr) {
m_pRenderContainer->showEmptyState(sEmptyMessage);
}
}
bool nmWxPebiResultViewWidget::startRegionPressureDrawing()
{
nmPebiResultPlaybackController* pPlaybackController =
m_pControlBar == nullptr ? nullptr :
m_pControlBar->getPlaybackController();
if(m_pRegionState == nullptr || m_pSceneController == nullptr ||
m_pRenderContainer == nullptr || m_pControlBar == nullptr ||
pPlaybackController == nullptr ||
m_pRegionState->m_eState !=
nmWxPebiResultRegionState::State_Idle ||
!m_pSceneController->hasSnapshot() ||
m_pDisplayedSnapshot.isNull() ||
m_pSceneController->getCurrentPropertyId() !=
QString::fromLatin1("pressure") ||
m_pSceneController->getCurrentFrameIndex() < 0 ||
pPlaybackController->isPlaying() ||
m_pControlBar->isExportInProgress() ||
m_pControlBar->isExternalInteractionLocked() ||
!canProjectRegionOntoXyPlane(
m_pRenderContainer->getRenderer()) ||
!ensureRegionPressureLayer()) {
return false;
}
// 冻结绘制起点的完整显示身份,完成时会逐项复核。
m_pRegionState->m_pFrozenSnapshot = m_pDisplayedSnapshot;
m_pRegionState->m_nFrozenBindingRevision =
m_pSceneController->getSnapshotBindingRevision();
m_pRegionState->m_sFrozenSnapshotId =
m_pSceneController->getCurrentSnapshotId();
m_pRegionState->m_sFrozenPropertyId =
m_pSceneController->getCurrentPropertyId();
m_pRegionState->m_nFrozenFrameIndex =
m_pSceneController->getCurrentFrameIndex();
if(m_pRegionState->m_nFrozenBindingRevision == 0 ||
m_pRegionState->m_sFrozenSnapshotId.isEmpty() ||
m_pRegionState->m_sFrozenSnapshotId != m_sDisplayedSnapshotId) {
m_pRegionState->m_pFrozenSnapshot.clear();
return false;
}
// 观察者只在本次绘制事务内有效,退出时必须在销毁回调前全部解除。
m_pRegionState->m_pStyle =
vtkSmartPointer<nmVTKPlanarPolygonInteractorStyle>::New();
m_pRegionState->m_pCallback =
vtkSmartPointer<vtkCallbackCommand>::New();
m_pRegionState->m_pCallback->SetClientData(this);
m_pRegionState->m_pCallback->SetCallback(
&nmWxPebiResultViewWidget::handleRegionPolygonEvent);
m_pRegionState->m_nChangedObserverTag =
m_pRegionState->m_pStyle->AddObserver(
nmVTKPlanarPolygonInteractorStyle::PolygonChangedEvent,
m_pRegionState->m_pCallback);
m_pRegionState->m_nCompletedObserverTag =
m_pRegionState->m_pStyle->AddObserver(
nmVTKPlanarPolygonInteractorStyle::PolygonCompletedEvent,
m_pRegionState->m_pCallback);
m_pRegionState->m_nCancelledObserverTag =
m_pRegionState->m_pStyle->AddObserver(
nmVTKPlanarPolygonInteractorStyle::PolygonCancelledEvent,
m_pRegionState->m_pCallback);
m_pRegionState->m_nInvalidObserverTag =
m_pRegionState->m_pStyle->AddObserver(
nmVTKPlanarPolygonInteractorStyle::PolygonInvalidEvent,
m_pRegionState->m_pCallback);
if(!m_pRenderContainer->installInteractionStyle(
m_pRegionState->m_pStyle)) {
stopRegionPressureDrawing();
return false;
}
m_pRegionState->m_oCalculator.clear();
m_pRegionState->m_pLayer->clear();
if(m_pRegionState->m_pDialog != nullptr) {
m_pRegionState->m_pDialog->hide();
}
// 交互样式安装成功后再锁定底栏,避免失败路径遗留禁用控件。
m_pRegionState->m_eState =
nmWxPebiResultRegionState::State_Drawing;
m_pControlBar->setExternalInteractionLocked(true);
synchronizeBusinessActions();
m_pRenderContainer->renderView();
return true;
}
void nmWxPebiResultViewWidget::stopRegionPressureDrawing()
{
if(m_pRegionState == nullptr) {
return;
}
// 先移除 VTK 观察者并清空 ClientData,再恢复默认相机交互。
if(m_pRegionState->m_pStyle != nullptr) {
if(m_pRegionState->m_nChangedObserverTag != 0) {
m_pRegionState->m_pStyle->RemoveObserver(
m_pRegionState->m_nChangedObserverTag);
}
if(m_pRegionState->m_nCompletedObserverTag != 0) {
m_pRegionState->m_pStyle->RemoveObserver(
m_pRegionState->m_nCompletedObserverTag);
}
if(m_pRegionState->m_nCancelledObserverTag != 0) {
m_pRegionState->m_pStyle->RemoveObserver(
m_pRegionState->m_nCancelledObserverTag);
}
if(m_pRegionState->m_nInvalidObserverTag != 0) {
m_pRegionState->m_pStyle->RemoveObserver(
m_pRegionState->m_nInvalidObserverTag);
}
}
if(m_pRegionState->m_pCallback != nullptr) {
m_pRegionState->m_pCallback->SetClientData(nullptr);
}
m_pRegionState->m_nChangedObserverTag = 0;
m_pRegionState->m_nCompletedObserverTag = 0;
m_pRegionState->m_nCancelledObserverTag = 0;
m_pRegionState->m_nInvalidObserverTag = 0;
if(m_pRenderContainer != nullptr &&
m_pRegionState->m_pStyle != nullptr) {
m_pRenderContainer->restoreDefaultInteraction();
}
m_pRegionState->m_pStyle = nullptr;
m_pRegionState->m_pCallback = nullptr;
m_pRegionState->m_ePendingEvent =
nmWxPebiResultRegionState::PendingEvent_None;
m_pRegionState->m_bPendingEventQueued = false;
m_pRegionState->m_vecPendingPoints.clear();
m_pRegionState->m_pFrozenSnapshot.clear();
m_pRegionState->m_nFrozenBindingRevision = 0;
m_pRegionState->m_sFrozenSnapshotId.clear();
m_pRegionState->m_sFrozenPropertyId.clear();
m_pRegionState->m_nFrozenFrameIndex = -1;
if(m_pControlBar != nullptr) {
m_pControlBar->setExternalInteractionLocked(false);
}
}
void nmWxPebiResultViewWidget::clearRegionPressureSelection(
bool bRenderView)
{
if(m_pRegionState == nullptr) {
return;
}
nmVTKScene* pScene = m_pRenderContainer == nullptr
? nullptr : m_pRenderContainer->getScene();
// 裸指针只在 Scene 仍持有同一图层时可用,失败回滚后不访问旧对象。
const bool bLayerIsCurrent = pScene != nullptr &&
m_pRegionState->m_pLayer != nullptr &&
pScene->getLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID)) ==
m_pRegionState->m_pLayer;
const bool bHadVisibleRegion =
m_pRegionState->m_eState !=
nmWxPebiResultRegionState::State_Idle ||
(bLayerIsCurrent &&
!m_pRegionState->m_pLayer->getPoints().isEmpty());
stopRegionPressureDrawing();
if(bLayerIsCurrent) {
m_pRegionState->m_pLayer->clear();
} else {
m_pRegionState->m_pLayer = nullptr;
}
m_pRegionState->m_oCalculator.clear();
m_pRegionState->m_eState =
nmWxPebiResultRegionState::State_Idle;
m_pRegionState->m_nRegionBindingRevision = 0;
m_pRegionState->m_sRegionSnapshotId.clear();
m_pRegionState->m_sLastObservedPropertyId.clear();
m_pRegionState->m_nLastAttemptedFrameIndex = -1;
m_pRegionState->m_bStatisticsCalculated = false;
m_pRegionState->m_sStatisticsError.clear();
m_pRegionState->m_oStatistics.clear();
if(m_pRegionState->m_pDialog != nullptr) {
m_pRegionState->m_pDialog->hide();
}
synchronizeBusinessActions();
if(bRenderView && bHadVisibleRegion &&
m_pRenderContainer != nullptr) {
m_pRenderContainer->renderView();
}
}
void nmWxPebiResultViewWidget::destroyRegionPressureState()
{
if(m_pRegionState == nullptr) {
return;
}
clearRegionPressureSelection(false);
nmVTKScene* pScene = m_pRenderContainer == nullptr
? nullptr : m_pRenderContainer->getScene();
if(pScene != nullptr && m_pRegionState->m_pLayer != nullptr &&
pScene->getLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID)) == m_pRegionState->m_pLayer) {
pScene->removeLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID));
}
m_pRegionState->m_pLayer = nullptr;
if(m_pRegionState->m_pDialog != nullptr) {
delete m_pRegionState->m_pDialog;
m_pRegionState->m_pDialog = nullptr;
}
delete m_pRegionState;
m_pRegionState = nullptr;
}
bool nmWxPebiResultViewWidget::ensureRegionPressureLayer()
{
if(m_pRegionState == nullptr || m_pRenderContainer == nullptr ||
m_pRenderContainer->getScene() == nullptr) {
return false;
}
nmVTKScene* pScene = m_pRenderContainer->getScene();
nmVTKRenderLayer* pExisting = pScene->getLayer(
QString::fromLatin1(PEBI_REGION_PRESSURE_LAYER_ID));
if(pExisting != nullptr) {
return m_pRegionState->m_pLayer != nullptr &&
pExisting == m_pRegionState->m_pLayer;
}
m_pRegionState->m_pLayer = nullptr;
nmVTKPlanarPolygonLayer* pCandidate =
new nmVTKPlanarPolygonLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID));
if(!pScene->addLayer(pCandidate)) {
delete pCandidate;
return false;
}
m_pRegionState->m_pLayer = pCandidate;
return true;
}
bool nmWxPebiResultViewWidget::isRegionPressureDrawing() const
{
return m_pRegionState != nullptr &&
m_pRegionState->m_eState ==
nmWxPebiResultRegionState::State_Drawing;
}
void nmWxPebiResultViewWidget::updateRegionPressureStatistics()
{
// 静态属性下冻结最后一帧结果;只有显示 pressure 时才跟随帧变化重算。
if(m_pRegionState == nullptr || m_pSceneController == nullptr ||
m_pRegionState->m_eState !=
nmWxPebiResultRegionState::State_Completed ||
!m_pRegionState->m_oCalculator.isPrepared() ||
!m_pSceneController->hasSnapshot() ||
m_pSceneController->getSnapshotBindingRevision() !=
m_pRegionState->m_nRegionBindingRevision ||
m_pSceneController->getCurrentSnapshotId() !=
m_pRegionState->m_sRegionSnapshotId ||
m_pSceneController->getCurrentPropertyId() !=
QString::fromLatin1("pressure")) {
return;
}
const int nFrameIndex = m_pSceneController->getCurrentFrameIndex();
if(nFrameIndex < 0 ||
nFrameIndex == m_pRegionState->m_nLastAttemptedFrameIndex) {
return;
}
// 先登记尝试帧,保证一个状态信号周期内同一帧最多进行一轮重计算。
m_pRegionState->m_nLastAttemptedFrameIndex = nFrameIndex;
nmPebiRegionPressureStatistics oStatistics;
QString sError;
m_pRegionState->m_bStatisticsCalculated =
m_pRegionState->m_oCalculator.calculateFrame(
nFrameIndex, oStatistics, &sError);
m_pRegionState->m_sStatisticsError = sError;
if(m_pRegionState->m_bStatisticsCalculated) {
m_pRegionState->m_oStatistics = oStatistics;
}
refreshRegionPressureStatisticsDialog();
}
void nmWxPebiResultViewWidget::ensureRegionPressureStatisticsDialog()
{
if(m_pRegionState == nullptr || m_pRegionState->m_pDialog != nullptr) {
return;
}
iDlgBase* pDialog = new iDlgBase(this);
pDialog->setWindowTitle(tr("Region Average Pressure"));
pDialog->setWindowModality(Qt::NonModal);
pDialog->setModal(false);
pDialog->setAttribute(Qt::WA_DeleteOnClose, false);
pDialog->setWindowFlags(
pDialog->windowFlags() &
~Qt::WindowContextHelpButtonHint);
QVBoxLayout* pMainLayout = new QVBoxLayout(pDialog);
pMainLayout->setContentsMargins(12, 10, 12, 10);
pMainLayout->setSpacing(8);
QGroupBox* pStatisticsGroup = new QGroupBox(
tr("Statistics"), pDialog);
QGridLayout* pStatisticsLayout = new QGridLayout(pStatisticsGroup);
pStatisticsLayout->setContentsMargins(8, 15, 8, 10);
pStatisticsLayout->setHorizontalSpacing(6);
pStatisticsLayout->setVerticalSpacing(6);
pStatisticsLayout->setColumnStretch(0, 0);
pStatisticsLayout->setColumnStretch(1, 8);
pStatisticsLayout->setColumnStretch(2, 5);
m_pRegionState->m_pAveragePressureUnitCombo =
createRegionUnitCombo(pStatisticsGroup,
QString::fromLatin1("MPa"));
m_pRegionState->m_pMinimumPressureUnitCombo =
createRegionUnitCombo(pStatisticsGroup,
QString::fromLatin1("MPa"));
m_pRegionState->m_pMaximumPressureUnitCombo =
createRegionUnitCombo(pStatisticsGroup,
QString::fromLatin1("MPa"));
m_pRegionState->m_pPressureTimeUnitCombo =
createRegionUnitCombo(pStatisticsGroup,
QString::fromLatin1("h"));
int nRow = 0;
m_pRegionState->m_pAveragePressureValue = addRegionStatisticsRow(
pStatisticsLayout, nRow++, tr("Region average pressure"),
pStatisticsGroup,
m_pRegionState->m_pAveragePressureUnitCombo);
m_pRegionState->m_pAveragePressureValue->setToolTip(tr(
"Weighted by cell area, thickness and porosity."));
m_pRegionState->m_pMinimumPressureValue = addRegionStatisticsRow(
pStatisticsLayout, nRow++, tr("Minimum pressure"),
pStatisticsGroup,
m_pRegionState->m_pMinimumPressureUnitCombo);
m_pRegionState->m_pMaximumPressureValue = addRegionStatisticsRow(
pStatisticsLayout, nRow++, tr("Maximum pressure"),
pStatisticsGroup,
m_pRegionState->m_pMaximumPressureUnitCombo);
m_pRegionState->m_pTimeValue = addRegionStatisticsRow(
pStatisticsLayout, nRow++, tr("Pressure time"),
pStatisticsGroup,
m_pRegionState->m_pPressureTimeUnitCombo);
m_pRegionState->m_pSelectedCellValue = addRegionStatisticsRow(
pStatisticsLayout, nRow++, tr("Selected cells"),
pStatisticsGroup);
m_pRegionState->m_pWarningLabel = new QLabel(pStatisticsGroup);
m_pRegionState->m_pWarningLabel->setWordWrap(true);
m_pRegionState->m_pWarningLabel->setStyleSheet(
"QLabel { color: #a32626; }");
m_pRegionState->m_pWarningLabel->hide();
pStatisticsLayout->addWidget(
m_pRegionState->m_pWarningLabel, nRow++, 0, 1, 3);
pMainLayout->addWidget(pStatisticsGroup);
QHBoxLayout* pButtonLayout = new QHBoxLayout;
pButtonLayout->setContentsMargins(0, 0, 0, 0);
pButtonLayout->setSpacing(6);
pButtonLayout->addStretch(1);
QPushButton* pCloseButton = new QPushButton(tr("Close"), pDialog);
const QSize oFooterIconSize(16, 16);
pCloseButton->setIcon(QIcon(resultViewIconPath("Close.png")));
pCloseButton->setIconSize(oFooterIconSize);
pCloseButton->setMinimumWidth(72);
pCloseButton->setDefault(true);
pButtonLayout->addWidget(pCloseButton);
pMainLayout->addLayout(pButtonLayout);
connect(pCloseButton, SIGNAL(clicked()),
this, SLOT(onCloseRegionPressureStatistics()));
connect(pDialog, SIGNAL(rejected()),
this, SLOT(onCloseRegionPressureStatistics()));
m_pRegionState->m_pDialog = pDialog;
pDialog->setMinimumWidth(460);
pDialog->adjustSize();
}
void nmWxPebiResultViewWidget::refreshRegionPressureStatisticsDialog()
{
if(m_pRegionState == nullptr || m_pRegionState->m_pDialog == nullptr) {
return;
}
const QString sUnavailable = QString::fromLatin1("--");
if(!m_pRegionState->m_bStatisticsCalculated) {
QLineEdit* const pValues[] = {
m_pRegionState->m_pAveragePressureValue,
m_pRegionState->m_pMinimumPressureValue,
m_pRegionState->m_pMaximumPressureValue,
m_pRegionState->m_pTimeValue,
m_pRegionState->m_pSelectedCellValue
};
const int nValueCount = sizeof(pValues) / sizeof(pValues[0]);
for(int nIndex = 0; nIndex < nValueCount; ++nIndex) {
pValues[nIndex]->setText(sUnavailable);
}
m_pRegionState->m_pWarningLabel->setText(
tr("Unable to calculate region average pressure."));
m_pRegionState->m_pWarningLabel->show();
return;
}
const nmPebiRegionPressureStatistics& oStatistics =
m_pRegionState->m_oStatistics;
m_pRegionState->m_pTimeValue->setText(
formatRegionValue(oStatistics.m_dPressureTimeHours));
m_pRegionState->m_pSelectedCellValue->setText(
QString::number(static_cast<qlonglong>(
oStatistics.m_nIntersectingCellCount)));
if(oStatistics.m_bAvailable) {
m_pRegionState->m_pAveragePressureValue->setText(
formatRegionValue(
oStatistics.m_dPoreVolumeWeightedPressureMpa));
m_pRegionState->m_pMinimumPressureValue->setText(
formatRegionValue(oStatistics.m_dMinimumPressureMpa));
m_pRegionState->m_pMaximumPressureValue->setText(
formatRegionValue(oStatistics.m_dMaximumPressureMpa));
} else {
m_pRegionState->m_pAveragePressureValue->setText(sUnavailable);
m_pRegionState->m_pMinimumPressureValue->setText(sUnavailable);
m_pRegionState->m_pMaximumPressureValue->setText(sUnavailable);
}
if(oStatistics.m_nIntersectingCellCount == 0) {
m_pRegionState->m_pWarningLabel->setText(
tr("No cells intersect the selected region."));
m_pRegionState->m_pWarningLabel->show();
} else if(!oStatistics.m_bAvailable) {
m_pRegionState->m_pWarningLabel->setText(tr(
"No valid cells are available for region average pressure."));
m_pRegionState->m_pWarningLabel->show();
} else if(oStatistics.m_nIgnoredCellCount > 0) {
m_pRegionState->m_pWarningLabel->setText(tr(
"%1 selected cells were excluded because their data is invalid.").arg(
static_cast<qlonglong>(
oStatistics.m_nIgnoredCellCount)));
m_pRegionState->m_pWarningLabel->show();
} else {
m_pRegionState->m_pWarningLabel->clear();
m_pRegionState->m_pWarningLabel->hide();
}
}
void nmWxPebiResultViewWidget::showRegionPressureStatisticsDialog()
{
nmVTKScene* pScene = m_pRenderContainer == nullptr
? nullptr : m_pRenderContainer->getScene();
if(m_pRegionState == nullptr || m_pSceneController == nullptr ||
m_pRegionState->m_eState !=
nmWxPebiResultRegionState::State_Completed ||
!m_pRegionState->m_oCalculator.isPrepared() ||
!m_pSceneController->hasSnapshot() ||
m_pSceneController->getSnapshotBindingRevision() !=
m_pRegionState->m_nRegionBindingRevision ||
m_pSceneController->getCurrentSnapshotId() !=
m_pRegionState->m_sRegionSnapshotId ||
pScene == nullptr || m_pRegionState->m_pLayer == nullptr ||
pScene->getLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID)) != m_pRegionState->m_pLayer) {
return;
}
ensureRegionPressureStatisticsDialog();
synchronizeBusinessActions();
refreshRegionPressureStatisticsDialog();
if(m_pRegionState->m_pDialog != nullptr) {
m_pRegionState->m_pDialog->show();
m_pRegionState->m_pDialog->raise();
m_pRegionState->m_pDialog->activateWindow();
}
}
void nmWxPebiResultViewWidget::rememberObservedState(
const QSharedPointer<const nmPebiResultSnapshot>& pSnapshot,
const QString& sSnapshotId,
bool bCurrent)
{
m_pObservedSnapshot = pSnapshot;
m_sObservedSnapshotId = sSnapshotId;
m_bObservedSnapshotCurrent = bCurrent;
m_bObservedStateValid = true;
}
void nmWxPebiResultViewWidget::synchronizeBusinessActions()
{
synchronizeVolumeActions();
if(isImportedVolumeMode()) return;
if(m_pSceneController == nullptr) {
return;
}
setActionCheckedWithoutSignal(
m_pScalarBarAction, m_pSceneController->isScalarBarVisible());
setActionCheckedWithoutSignal(
m_pScaleGridAction, m_pSceneController->isScaleGridVisible());
setActionCheckedWithoutSignal(
m_pWellNamesAction, m_pSceneController->areWellNamesVisible());
const bool bEnabled = m_pSceneController->hasSnapshot();
nmPebiResultPlaybackController* pPlaybackController =
m_pControlBar == nullptr ? nullptr :
m_pControlBar->getPlaybackController();
const bool bPlaying = pPlaybackController != nullptr &&
pPlaybackController->isPlaying();
const bool bExporting = m_pControlBar != nullptr &&
m_pControlBar->isExportInProgress();
const bool bExternallyLocked = m_pControlBar != nullptr &&
m_pControlBar->isExternalInteractionLocked();
const bool bDrawing = isRegionPressureDrawing();
nmVTKScene* pScene = m_pRenderContainer == nullptr
? nullptr : m_pRenderContainer->getScene();
const bool bCompleted = m_pRegionState != nullptr &&
m_pRegionState->m_eState ==
nmWxPebiResultRegionState::State_Completed &&
m_pRegionState->m_oCalculator.isPrepared() &&
bEnabled &&
m_pSceneController->getSnapshotBindingRevision() ==
m_pRegionState->m_nRegionBindingRevision &&
m_pSceneController->getCurrentSnapshotId() ==
m_pRegionState->m_sRegionSnapshotId &&
pScene != nullptr && m_pRegionState->m_pLayer != nullptr &&
pScene->getLayer(QString::fromLatin1(
PEBI_REGION_PRESSURE_LAYER_ID)) ==
m_pRegionState->m_pLayer;
const bool bBusinessVisibilityEnabled = bEnabled && !bDrawing;
m_pScalarBarAction->setEnabled(bBusinessVisibilityEnabled);
m_pScaleGridAction->setEnabled(bBusinessVisibilityEnabled);
m_pWellNamesAction->setEnabled(bBusinessVisibilityEnabled);
const bool bFilterEnabled = bEnabled &&
pPlaybackController != nullptr &&
!bPlaying && !bExporting && !bExternallyLocked && !bDrawing;
if(m_pFilterAction != nullptr) {
m_pFilterAction->setEnabled(bFilterEnabled);
}
if(m_pRegionPressureAction != nullptr) {
const bool bCanStart = bEnabled &&
m_pSceneController->getCurrentPropertyId() ==
QString::fromLatin1("pressure");
const bool bRegionEnabled = bDrawing || bCompleted ||
(!bExternallyLocked && !bPlaying && !bExporting &&
bCanStart);
m_pRegionPressureAction->setEnabled(bRegionEnabled);
const QString sActionText = bDrawing
? tr("Cancel Region Drawing")
: tr("Region Average Pressure");
m_pRegionPressureAction->setText(sActionText);
m_pRegionPressureAction->setToolTip(sActionText);
}
}
void nmWxPebiResultViewWidget::refreshStatusBar()
{
if(isImportedVolumeMode()) {
m_pStatusLabel->setStyleSheet("QLabel { color: #a32626; background: #fdecec; }");
m_pStatusLabel->setText(m_sOperationError);
m_pStatusLabel->setVisible(!m_sOperationError.isEmpty());
return;
}
if(m_pStatusLabel == nullptr || m_pSceneController == nullptr ||
!m_pSceneController->hasSnapshot()) {
if(m_pStatusLabel != nullptr) {
m_pStatusLabel->hide();
}
return;
}
if(!m_sBindingError.isEmpty()) {
m_pStatusLabel->setStyleSheet(
"QLabel { color: #a32626; background: #fdecec; } ");
m_pStatusLabel->setText(m_sBindingError);
m_pStatusLabel->show();
return;
}
if(!m_sOperationError.isEmpty()) {
m_pStatusLabel->setStyleSheet(
"QLabel { color: #a32626; background: #fdecec; } ");
m_pStatusLabel->setText(m_sOperationError);
m_pStatusLabel->show();
return;
}
m_pStatusLabel->hide();
}
void nmWxPebiResultViewWidget::disconnectDataManager()
{
nmDataAnalyzeManager* pDataManager = m_pDataManager.data();
if(pDataManager != nullptr) {
disconnect(pDataManager, SIGNAL(sigPebiResultStateChanged()),
this, SLOT(onPebiResultStateChanged()));
disconnect(pDataManager, SIGNAL(destroyed(QObject*)),
this, SLOT(onDataManagerDestroyed(QObject*)));
}
m_pDataManager = nullptr;
}
bool nmWxPebiResultViewWidget::isImportedVolumeMode() const
{
return m_pVolumeState != nullptr && m_pVolumeState->m_bImported;
}
bool nmWxPebiResultViewWidget::canImportVolume() const
{
if(m_pVolumeState == nullptr || m_pVolumeState->m_pTask != nullptr ||
m_pControlBar == nullptr || m_pControlBar->isExportInProgress() ||
isRegionPressureDrawing()) return false;
nmPebiResultPlaybackController* pPlayback = m_pControlBar->getPlaybackController();
return (pPlayback == nullptr || !pPlayback->isPlaying()) &&
(isImportedVolumeMode() || !m_pControlBar->isExternalInteractionLocked());
}
void nmWxPebiResultViewWidget::synchronizeVolumeActions()
{
if(m_pVolumeState == nullptr || m_pVolumeState->m_pImportAction == nullptr) return;
m_pVolumeState->m_pImportAction->setEnabled(canImportVolume());
m_pVolumeState->m_pImportAction->setText(isImportedVolumeMode()
? tr("Replace 3D Model...") : tr("Import 3D Model..."));
m_pVolumeState->m_pReturnAction->setEnabled(isImportedVolumeMode() && m_pVolumeState->m_pTask == nullptr);
if(!isImportedVolumeMode()) return;
nmVolumeSceneController* pVolume = m_pVolumeState->m_pController;
setActionCheckedWithoutSignal(m_pScalarBarAction, pVolume->isScalarBarVisible());
setActionCheckedWithoutSignal(m_pScaleGridAction, pVolume->isScaleGridVisible());
m_pScalarBarAction->setEnabled(pVolume->hasScalarProperty());
m_pScaleGridAction->setEnabled(pVolume->hasData());
m_pWellNamesAction->setEnabled(false);
m_pFilterAction->setEnabled(false);
m_pRegionPressureAction->setEnabled(false);
m_pControlBar->getExportAnimationAction()->setEnabled(false);
}
void nmWxPebiResultViewWidget::onImportVolumeRequested()
{
if(!canImportVolume()) return;
const QString sFilePath = QFileDialog::getOpenFileName(this, tr("Import 3D Model"),
QString(), tr("VTK Volume Mesh (*.vtk *.vtu)"));
if(!sFilePath.isEmpty()) importVolumeFile(sFilePath);
}
bool nmWxPebiResultViewWidget::importVolumeFile(const QString& sFilePath)
{
if(!isResultViewGuiThread() || sFilePath.isEmpty() || !canImportVolume()) return false;
m_pVolumeState->m_pTask = new nmVolumeImportTask(sFilePath, this);
m_pVolumeState->m_pProgress = new QProgressDialog(tr("Loading 3D model..."), tr("Cancel"), 0, 100, this);
m_pVolumeState->m_pProgress->setObjectName(QLatin1String("volumeImportProgress"));
m_pVolumeState->m_pProgress->setWindowModality(Qt::WindowModal);
m_pVolumeState->m_pProgress->setMinimumDuration(0);
m_pVolumeState->m_pProgress->setAutoClose(false);
m_pVolumeState->m_pProgress->setAutoReset(false);
connect(m_pVolumeState->m_pProgress, SIGNAL(canceled()), this, SLOT(onCancelVolumeImport()));
connect(m_pVolumeState->m_pTask, SIGNAL(progressChanged(int)),
m_pVolumeState->m_pProgress, SLOT(setValue(int)), Qt::QueuedConnection);
connect(m_pVolumeState->m_pTask, SIGNAL(finished()),
this, SLOT(onVolumeImportFinished()), Qt::QueuedConnection);
m_pVolumeState->m_pProgress->show();
synchronizeBusinessActions();
m_pVolumeState->m_pTask->start();
return true;
}
void nmWxPebiResultViewWidget::onCancelVolumeImport()
{
if(m_pVolumeState->m_pTask != nullptr) m_pVolumeState->m_pTask->requestCancel();
}
void nmWxPebiResultViewWidget::onVolumeImportFinished()
{
nmVolumeImportTask* pTask = m_pVolumeState->m_pTask;
if(pTask == nullptr || sender() != pTask) return;
// finished 发出后仍等待线程完全退出,确保结果和字符串已不再被工作线程改写。
pTask->wait();
const bool bCanceled = pTask->isCanceled();
const QSharedPointer<const nmVolumeData> pData = pTask->getResult();
QString sError = pTask->getError();
disconnect(pTask, nullptr, nullptr, nullptr);
delete pTask;
m_pVolumeState->m_pTask = nullptr;
// 模态进度更新可能嵌套处理 Qt 事件;延迟删除,避免在 setValue 栈内析构。
m_pVolumeState->m_pProgress->hide();
m_pVolumeState->m_pProgress->deleteLater();
m_pVolumeState->m_pProgress = nullptr;
if(bCanceled) {
synchronizeBusinessActions();
return;
}
nmVTKViewState oPreviousView;
m_pRenderContainer->captureViewState(oPreviousView);
if(pData.isNull() || !m_pVolumeState->m_pController->setData(pData, &sError)) {
m_sOperationError = sError.isEmpty() ? tr("Unable to display the 3D model.") : sError;
synchronizeBusinessActions();
// 空结果页也应显示导入错误,而不是把错误藏在不可见的旧结果状态中。
m_pStatusLabel->setStyleSheet("QLabel { color: #a32626; background: #fdecec; }");
m_pStatusLabel->setText(m_sOperationError);
m_pStatusLabel->show();
return;
}
if(!isImportedVolumeMode()) {
m_pVolumeState->m_oSavedView = oPreviousView;
m_pVolumeState->m_eSavedCommands = m_pRenderContainer->getViewCommandController()->getCapabilities();
m_pControlBar->stopPlayback();
stopRegionPressureDrawing();
// 区域图层由 Scene 所有;先核实对象身份,避免访问已被外部清理的观察指针。
nmVTKScene* pScene = m_pRenderContainer->getScene();
const bool bHasRegionLayer = pScene != nullptr && m_pRegionState->m_pLayer != nullptr &&
pScene->getLayer(QString::fromLatin1(PEBI_REGION_PRESSURE_LAYER_ID)) == m_pRegionState->m_pLayer;
m_pVolumeState->m_bRegionVisible = bHasRegionLayer && m_pRegionState->m_pLayer->isVisible();
m_pVolumeState->m_bRegionDialogVisible = m_pRegionState->m_pDialog != nullptr && m_pRegionState->m_pDialog->isVisible();
if(bHasRegionLayer) m_pRegionState->m_pLayer->setVisible(false);
if(m_pRegionState->m_pDialog != nullptr) m_pRegionState->m_pDialog->hide();
m_pSceneController->setSuspended(true);
}
m_pRenderContainer->setViewCommandCapabilities(m_pVolumeState->m_eSavedCommands |
nmVTKViewCommandController::ViewCommand_Right |
nmVTKViewCommandController::ViewCommand_Isometric);
m_pVolumeState->m_bImported = true;
m_pControlBar->setExternalInteractionLocked(true);
m_pControlBar->hide();
m_pRenderContainer->restoreDefaultInteraction();
m_pVolumeState->m_pController->activate(true);
m_sOperationError.clear();
synchronizeBusinessActions();
refreshStatusBar();
m_pRenderContainer->showReadyState();
}
void nmWxPebiResultViewWidget::onReturnToCalculationResult()
{
if(!isImportedVolumeMode() || m_pVolumeState->m_pTask != nullptr) return;
const QSharedPointer<const nmPebiResultSnapshot> pLatest = m_pDataManager.isNull()
? QSharedPointer<const nmPebiResultSnapshot>() : m_pDataManager->getPebiResultSnapshot();
const bool bSameSnapshot = !pLatest.isNull() && pLatest == m_pDisplayedSnapshot &&
pLatest->getSnapshotId() == m_sDisplayedSnapshotId && m_pSceneController->hasSnapshot();
if(!pLatest.isNull() && !bSameSnapshot) {
QString sError;
// PEBI 仍处于挂起状态,候选绑定既不显示图层,也不移动当前三维相机。
if(!m_pSceneController->setSnapshot(pLatest, &sError)) {
m_sOperationError = tr("Unable to return to the latest calculation result: %1").arg(sError);
refreshStatusBar();
return;
}
}
m_pVolumeState->m_pController->hide();
m_pRenderContainer->setRotationCenterPickTarget(nullptr);
m_pVolumeState->m_bImported = false;
m_pRenderContainer->setViewCommandCapabilities(m_pVolumeState->m_eSavedCommands);
if(pLatest.isNull()) {
m_pSceneController->setSuspended(false);
m_pVolumeState->m_pController->clear();
clearSceneAndControls(tr("No result data."));
} else {
if(!bSameSnapshot) clearRegionPressureSelection(false);
m_pSceneController->setSuspended(false);
if(bSameSnapshot) {
m_pRenderContainer->restoreViewState(m_pVolumeState->m_oSavedView);
nmVTKScene* pScene = m_pRenderContainer->getScene();
if(pScene != nullptr && m_pRegionState->m_pLayer != nullptr &&
pScene->getLayer(QString::fromLatin1(PEBI_REGION_PRESSURE_LAYER_ID)) == m_pRegionState->m_pLayer) {
m_pRegionState->m_pLayer->setVisible(m_pVolumeState->m_bRegionVisible);
}
if(m_pVolumeState->m_bRegionDialogVisible && m_pRegionState->m_pDialog != nullptr) m_pRegionState->m_pDialog->show();
} else {
m_pRenderContainer->fitTopViewWithoutRender();
m_pRenderContainer->resetRotationCenterWithoutRender();
}
m_pVolumeState->m_pController->clear();
m_pDisplayedSnapshot = pLatest;
m_sDisplayedSnapshotId = pLatest->getSnapshotId();
rememberObservedState(pLatest, m_sDisplayedSnapshotId, m_pDataManager->isPebiResultSnapshotCurrent());
m_sBindingError.clear();
m_sOperationError.clear();
m_pRenderContainer->showReadyState();
}
m_pVolumeState->m_bPendingSync = false;
m_pVolumeState->m_oSavedView = nmVTKViewState();
m_pControlBar->setExternalInteractionLocked(false);
m_pControlBar->show();
m_pControlBar->synchronizeFromScene();
synchronizeBusinessActions();
refreshStatusBar();
}