|
|
#include "nmWxPebiResultViewWidget.h"
|
|
|
|
|
|
#include "iUnitGroup.h"
|
|
|
#include "iUnitHelper.h"
|
|
|
#include "nmDataAnalyzeManager.h"
|
|
|
#include "nmFFmpegVideoWriter.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 "nmVTKViewCommandController.h"
|
|
|
#include "nmWxPebiResultControlBar.h"
|
|
|
#include "nmWxPebiResultAnimationExportDlg.h"
|
|
|
#include "nmWxVTKRenderContainerWidget.h"
|
|
|
|
|
|
#include <QAction>
|
|
|
#include <QAtomicInt>
|
|
|
#include <QCheckBox>
|
|
|
#include <QComboBox>
|
|
|
#include <QCoreApplication>
|
|
|
#include <QDir>
|
|
|
#include <QGridLayout>
|
|
|
#include <QHBoxLayout>
|
|
|
#include <QIcon>
|
|
|
#include <QLabel>
|
|
|
#include <QLineEdit>
|
|
|
#include <QLocale>
|
|
|
#include <QMenu>
|
|
|
#include <QMessageBox>
|
|
|
#include <QPointer>
|
|
|
#include <QProgressDialog>
|
|
|
#include <QPushButton>
|
|
|
#include <QSize>
|
|
|
#include <QSizePolicy>
|
|
|
#include <QThread>
|
|
|
#include <QToolBar>
|
|
|
#include <QVBoxLayout>
|
|
|
|
|
|
#include <vtkCamera.h>
|
|
|
#include <vtkRenderer.h>
|
|
|
|
|
|
#include <math.h>
|
|
|
|
|
|
#if !defined(_MSC_VER)
|
|
|
#include <cmath>
|
|
|
#endif
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
QAtomicInt g_nPebiAnimationExportActive(0);
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
};
|
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
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_bObservedSnapshotCurrent(false),
|
|
|
m_bObservedStateValid(false),
|
|
|
m_bSynchronizing(false),
|
|
|
m_bSyncPending(false)
|
|
|
{
|
|
|
createUi();
|
|
|
setDataManager(pDataManager);
|
|
|
}
|
|
|
|
|
|
nmWxPebiResultViewWidget::~nmWxPebiResultViewWidget()
|
|
|
{
|
|
|
disconnectDataManager();
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
disconnectDataManager();
|
|
|
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(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_pFilterAction);
|
|
|
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_pSceneController != nullptr) {
|
|
|
// SceneController 缓存尺寸，即使当前尚未创建结果色标也不会丢失。
|
|
|
m_pSceneController->setViewportSize(nWidth, nHeight);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultViewWidget::onShowFilterSettings()
|
|
|
{
|
|
|
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()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
nmWxPebiResultFilterSettingsDlg oDialog(
|
|
|
m_pSceneController, m_pControlBar, this);
|
|
|
connect(&oDialog, SIGNAL(filterSettingsApplied()),
|
|
|
this, SLOT(onControlOperationSucceeded()));
|
|
|
oDialog.exec();
|
|
|
synchronizeBusinessActions();
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultViewWidget::onExportAnimationRequested()
|
|
|
{
|
|
|
nmPebiResultPlaybackController* pPlaybackController =
|
|
|
m_pControlBar == nullptr ? nullptr :
|
|
|
m_pControlBar->getPlaybackController();
|
|
|
QString sBackendError;
|
|
|
if(m_pSceneController == nullptr || m_pRenderContainer == nullptr ||
|
|
|
pPlaybackController == nullptr ||
|
|
|
pPlaybackController->isPlaying() ||
|
|
|
!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(m_pSceneController != nullptr && m_pSceneController->hasSnapshot()) {
|
|
|
m_pSceneController->setScalarBarVisible(bVisible);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultViewWidget::onScaleGridToggled(bool bVisible)
|
|
|
{
|
|
|
if(m_pSceneController != nullptr && m_pSceneController->hasSnapshot()) {
|
|
|
m_pSceneController->setScaleGridVisible(bVisible);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultViewWidget::onWellNamesToggled(bool bVisible)
|
|
|
{
|
|
|
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);
|
|
|
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());
|
|
|
|
|
|
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);
|
|
|
for(int nIndex = 0; nIndex < 3; ++nIndex) {
|
|
|
m_pToolBar->addAction(pBusinessActions[nIndex]);
|
|
|
}
|
|
|
m_pToolBar->addSeparator();
|
|
|
if(pCopyAction != nullptr) m_pToolBar->addAction(pCopyAction);
|
|
|
}
|
|
|
|
|
|
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_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(synchronizeBusinessActions()));
|
|
|
}
|
|
|
pMainLayout->addWidget(m_pControlBar);
|
|
|
|
|
|
synchronizeBusinessActions();
|
|
|
m_pRenderContainer->showEmptyState(tr("No result data."));
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultViewWidget::synchronizeOnce()
|
|
|
{
|
|
|
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();
|
|
|
// 新成功绑定序号会让 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();
|
|
|
}
|
|
|
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);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
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()
|
|
|
{
|
|
|
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();
|
|
|
m_pScalarBarAction->setEnabled(bEnabled);
|
|
|
m_pScaleGridAction->setEnabled(bEnabled);
|
|
|
m_pWellNamesAction->setEnabled(bEnabled);
|
|
|
nmPebiResultPlaybackController* pPlaybackController =
|
|
|
m_pControlBar == nullptr ? nullptr :
|
|
|
m_pControlBar->getPlaybackController();
|
|
|
const bool bFilterEnabled = bEnabled &&
|
|
|
pPlaybackController != nullptr &&
|
|
|
!pPlaybackController->isPlaying() &&
|
|
|
!m_pControlBar->isExportInProgress();
|
|
|
if(m_pFilterAction != nullptr) {
|
|
|
m_pFilterAction->setEnabled(bFilterEnabled);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxPebiResultViewWidget::refreshStatusBar()
|
|
|
{
|
|
|
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;
|
|
|
}
|