|
|
#include "nmWxTimeDependentSkin.h"
|
|
|
#include "nmWxPerforationClosing.h"
|
|
|
#include "nmWxPressFlowChartWidget.h"
|
|
|
#include "nmWxChartWidget.h"
|
|
|
|
|
|
#include <QVector>
|
|
|
#include <QTableWidget>
|
|
|
#include <QPushButton>
|
|
|
#include <QHBoxLayout>
|
|
|
#include <QVBoxLayout>
|
|
|
#include <QGridLayout>
|
|
|
#include <QHeaderView>
|
|
|
#include <QLabel>
|
|
|
#include <QMessageBox>
|
|
|
#include <QToolBar>
|
|
|
#include <QIcon>
|
|
|
#include <QApplication>
|
|
|
#include <QRadioButton>
|
|
|
#include <QComboBox>
|
|
|
#include <QLineEdit>
|
|
|
#include <QGroupBox>
|
|
|
#include <QCheckBox>
|
|
|
#include <QDateTime>
|
|
|
#include <QSpacerItem>
|
|
|
#include <QSplitter>
|
|
|
#include <QToolButton>
|
|
|
#include <QDebug>
|
|
|
#include <QFile>
|
|
|
#include <QDir>
|
|
|
#include <QFileInfo>
|
|
|
#include <QPixmap>
|
|
|
#include <QStyle>
|
|
|
#include <QWidget>
|
|
|
|
|
|
#include <QCoreApplication>
|
|
|
|
|
|
// 静态成员变量定义
|
|
|
nmWxTimeDependentSkin* nmWxTimeDependentSkin::s_instance = nullptr;
|
|
|
QString nmWxTimeDependentSkin::s_currentWellName = "";
|
|
|
nmDataWellBase* nmWxTimeDependentSkin::s_currentWellData = nullptr;
|
|
|
|
|
|
void nmWxTimeDependentSkin::showForCurrentWell(nmDataWellBase* pSpecificWellData, QWidget* parent)
|
|
|
{
|
|
|
QString currentWellName;
|
|
|
if (pSpecificWellData) currentWellName = pSpecificWellData->getWellName();
|
|
|
else {
|
|
|
auto* cur = nmDataAnalyzeManager::getCurrentInstance()->getCurWellData();
|
|
|
if (!cur) return;
|
|
|
currentWellName = cur->getWellName();
|
|
|
}
|
|
|
if (currentWellName.isEmpty()) return;
|
|
|
|
|
|
if (s_instance && s_currentWellName == currentWellName) {
|
|
|
bool isSameDataSource = (pSpecificWellData && s_currentWellData == pSpecificWellData)
|
|
|
|| (!pSpecificWellData && !s_currentWellData);
|
|
|
if (isSameDataSource) {
|
|
|
// 同步父子关系和模态
|
|
|
if (parent && s_instance->parent() != parent)
|
|
|
s_instance->setParent(parent, Qt::Dialog);
|
|
|
|
|
|
// 刷新数据
|
|
|
s_instance->reloadFromDataSource(pSpecificWellData);
|
|
|
|
|
|
s_instance->show();
|
|
|
s_instance->raise();
|
|
|
s_instance->activateWindow();
|
|
|
return;
|
|
|
}
|
|
|
s_instance->close();
|
|
|
delete s_instance;
|
|
|
}
|
|
|
|
|
|
// 新建实例
|
|
|
s_instance = new nmWxTimeDependentSkin(pSpecificWellData, parent);
|
|
|
s_currentWellName = currentWellName;
|
|
|
s_currentWellData = pSpecificWellData;
|
|
|
|
|
|
s_instance->show();
|
|
|
s_instance->raise();
|
|
|
s_instance->activateWindow();
|
|
|
}
|
|
|
|
|
|
nmWxTimeDependentSkin::nmWxTimeDependentSkin(nmDataWellBase* pWellData, QWidget *parent)
|
|
|
: QDialog(parent)
|
|
|
, m_pChartWidget(nullptr)
|
|
|
, m_pOriginalPressureChart(nullptr)
|
|
|
, m_pOriginalFlowRateChart(nullptr)
|
|
|
, m_isAddMode(false)
|
|
|
, m_isRemoveMode(false)
|
|
|
, m_currentPerforationIndex(0)
|
|
|
, m_pPressureChart(nullptr)
|
|
|
, m_pFlowRateChart(nullptr)
|
|
|
, m_timeDisplayUnit("hr")
|
|
|
, m_dSdQDisplayUnit("1/B/D")
|
|
|
, m_pTimeUnitCombo(nullptr)
|
|
|
, m_pDSdQUnitCombo(nullptr)
|
|
|
, m_rateDependentState(false)
|
|
|
{
|
|
|
// 根据传入的井数据决定使用哪个数据源
|
|
|
if (pWellData != nullptr) {
|
|
|
// 使用传入的特定井数据, 来自nmWxEditWellPlot
|
|
|
m_currentWell = pWellData;
|
|
|
} else {
|
|
|
// 使用当前井数据, 来自nmWxNumericalDesign
|
|
|
m_currentWell = nmDataAnalyzeManager::getCurrentInstance()->getCurWellData();
|
|
|
}
|
|
|
|
|
|
if(m_currentWell != nullptr) {
|
|
|
// 获取压力和流量数据
|
|
|
pressurePoints = m_currentWell->getPressurePoints();
|
|
|
QVector<QPointF> rawFlowData = m_currentWell->getFlowPoints();
|
|
|
flowPoints = processFlowData(rawFlowData);
|
|
|
|
|
|
// 默认选择第一个射孔段
|
|
|
m_currentPerforationIndex = 0;
|
|
|
m_perforationData = m_currentWell->getPerforationCopy(m_currentPerforationIndex);
|
|
|
}
|
|
|
|
|
|
if(m_currentWell != nullptr) {
|
|
|
// 获取压力和流量数据
|
|
|
pressurePoints = m_currentWell->getPressurePoints();
|
|
|
QVector<QPointF> rawFlowData = m_currentWell->getFlowPoints();
|
|
|
flowPoints = processFlowData(rawFlowData);
|
|
|
|
|
|
// 默认选择第一个射孔段
|
|
|
m_currentPerforationIndex = 0;
|
|
|
m_perforationData = m_currentWell->getPerforationCopy(m_currentPerforationIndex);
|
|
|
}
|
|
|
|
|
|
// 如果副本为空，初始化默认数据
|
|
|
if(m_perforationData.getFlowSegments().isEmpty()) {
|
|
|
initializeDefaultFlowSegment();
|
|
|
}
|
|
|
|
|
|
// 确保副本有默认的表皮系数数据
|
|
|
if(m_perforationData.getSkin0().getValue().toString().isEmpty()) {
|
|
|
m_perforationData.getSkin0().setValue("0.0");
|
|
|
}
|
|
|
|
|
|
if(m_perforationData.getdSkindq().getValue().toString().isEmpty()) {
|
|
|
m_perforationData.getdSkindq().setValue("0.0");
|
|
|
}
|
|
|
|
|
|
// 确保线条位置有默认值
|
|
|
double x1, y1, x2, y2;
|
|
|
m_perforationData.getLinePositions(x1, y1, x2, y2);
|
|
|
|
|
|
if(x1 == -999.0 || y1 == -999.0 || x2 == -999.0 || y2 == -999.0) {
|
|
|
m_perforationData.setLinePositions(100.0, 0.0, 200.0, 0.0);
|
|
|
}
|
|
|
|
|
|
setWindowTitle(tr("Time Dependent Skin"));
|
|
|
setMinimumSize(1150, 800);
|
|
|
|
|
|
// 初始化UI
|
|
|
initUI();
|
|
|
|
|
|
// 初始化射孔段下拉框数据
|
|
|
if(m_currentWell != nullptr) {
|
|
|
// 获取射孔段个数并添加到下拉框
|
|
|
int perforationCount = m_currentWell->getPerforationCount();
|
|
|
for(int i = 0; i < perforationCount; ++i) {
|
|
|
nmDataPerforation* perforation = m_currentWell->getPerforation(i);
|
|
|
if(perforation) {
|
|
|
QString name = perforation->getName().getValue().toString();
|
|
|
m_pComboBox->addItem(name);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 设置当前选中项为当前射孔段索引
|
|
|
if(m_currentPerforationIndex < perforationCount) {
|
|
|
m_pComboBox->setCurrentIndex(m_currentPerforationIndex);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 更新图表
|
|
|
updateCharts();
|
|
|
|
|
|
// 初始化表格数据
|
|
|
updateTableFromFlowSegments();
|
|
|
|
|
|
// 设置信号和槽
|
|
|
connect(m_pAddBtn, SIGNAL(clicked()), this, SLOT(onAddClicked()));
|
|
|
connect(m_pRemoveBtn, SIGNAL(clicked()), this, SLOT(onRemoveClicked()));
|
|
|
connect(m_pSplitStepsBtn, SIGNAL(clicked()), this, SLOT(onSplitStepsClicked()));
|
|
|
connect(m_pComputeBtn, SIGNAL(clicked()), this, SLOT(onComputeClicked()));
|
|
|
connect(m_pPerforationClosingBtn, SIGNAL(clicked()), this, SLOT(onPerforationClosingBtnClicked()));
|
|
|
connect(m_pSkinVsRateBtn, SIGNAL(clicked()), this, SLOT(onSkinVsRateClicked()));
|
|
|
connect(m_pOkBtn, SIGNAL(clicked()), this, SLOT(onAccept()));
|
|
|
connect(m_pCancelBtn, SIGNAL(clicked()), this, SLOT(onReject()));
|
|
|
connect(m_pDataTable, SIGNAL(cellChanged(int, int)), this, SLOT(onTableDataChanged(int, int)));
|
|
|
connect(m_pDataTable, SIGNAL(cellClicked(int, int)), this, SLOT(onTableRowClicked(int, int)));
|
|
|
|
|
|
// 右侧按钮信号连接
|
|
|
connect(m_pRightAddBtn, SIGNAL(clicked()), this, SLOT(onRightAddClicked()));
|
|
|
connect(m_pRightInsertBtn, SIGNAL(clicked()), this, SLOT(onRightInsertClicked()));
|
|
|
connect(m_pRightDeleteBtn, SIGNAL(clicked()), this, SLOT(onRightDeleteClicked()));
|
|
|
|
|
|
// 流动段操作
|
|
|
connect(m_pPressureChart, SIGNAL(flowSegmentClicked(int)), this, SLOT(onFlowSegmentSelected(int)));
|
|
|
connect(m_pFlowRateChart, SIGNAL(flowSegmentClicked(int)), this, SLOT(onFlowSegmentSelected(int)));
|
|
|
connect(m_pPressureChart, SIGNAL(chartPointClicked(double)), this, SLOT(onChartPointClicked(double)));
|
|
|
connect(m_pFlowRateChart, SIGNAL(chartPointClicked(double)), this, SLOT(onChartPointClicked(double)));
|
|
|
|
|
|
// 拖动相关的信号连接
|
|
|
connect(m_pPressureChart, SIGNAL(boundaryMoved(int, double)), this, SLOT(onBoundaryMoved(int, double)));
|
|
|
connect(m_pFlowRateChart, SIGNAL(boundaryMoved(int, double)), this, SLOT(onBoundaryMoved(int, double)));
|
|
|
connect(m_pPressureChart, SIGNAL(segmentsMerged(int)), this, SLOT(onSegmentsMerged(int)));
|
|
|
connect(m_pFlowRateChart, SIGNAL(segmentsMerged(int)), this, SLOT(onSegmentsMerged(int)));
|
|
|
|
|
|
connect(m_pSnapToRateChangesCheckBox, SIGNAL(toggled(bool)), this, SLOT(onSnapToRateChangesToggled(bool)));
|
|
|
|
|
|
connect(m_pPressureChart, SIGNAL(boundaryMovedFinal(int, double)), this, SLOT(onBoundaryMovedFinal(int, double)));
|
|
|
connect(m_pFlowRateChart, SIGNAL(boundaryMovedFinal(int, double)), this, SLOT(onBoundaryMovedFinal(int, double)));
|
|
|
|
|
|
connect(m_pAddRateDependentCheckBox, SIGNAL(toggled(bool)), this, SLOT(onAddRateDependentToggled(bool)));
|
|
|
|
|
|
connect(m_pShowDatesCheckBox, SIGNAL(toggled(bool)), this, SLOT(onShowDatesToggled(bool)));
|
|
|
|
|
|
connect(m_pComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onPerforationChanged(int)));
|
|
|
}
|
|
|
|
|
|
nmWxTimeDependentSkin::~nmWxTimeDependentSkin()
|
|
|
{
|
|
|
// 如果静态实例指针指向当前对象，清空静态变量
|
|
|
if (s_instance == this) {
|
|
|
s_instance = nullptr;
|
|
|
s_currentWellName = "";
|
|
|
s_currentWellData = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::reloadFromDataSource(nmDataWellBase* pWellData)
|
|
|
{
|
|
|
// 1) 重新决定数据源
|
|
|
m_currentWell = (pWellData != nullptr)
|
|
|
? pWellData
|
|
|
: nmDataAnalyzeManager::getCurrentInstance()->getCurWellData();
|
|
|
|
|
|
if (!m_currentWell) return;
|
|
|
|
|
|
// 2) 重新抓取并处理数据
|
|
|
pressurePoints = m_currentWell->getPressurePoints();
|
|
|
QVector<QPointF> rawFlowData = m_currentWell->getFlowPoints();
|
|
|
flowPoints = processFlowData(rawFlowData);
|
|
|
|
|
|
// 3) 重新取选中射孔段的副本（保留索引边界）
|
|
|
int perfCount = m_currentWell->getPerforationCount();
|
|
|
if (m_currentPerforationIndex >= perfCount) m_currentPerforationIndex = 0;
|
|
|
m_perforationData = m_currentWell->getPerforationCopy(m_currentPerforationIndex);
|
|
|
|
|
|
// 4) 做一次与构造期相同的默认值兜底
|
|
|
if (m_perforationData.getFlowSegments().isEmpty()) initializeDefaultFlowSegment();
|
|
|
if (m_perforationData.getSkin0().getValue().toString().isEmpty()) m_perforationData.getSkin0().setValue("0.0");
|
|
|
if (m_perforationData.getdSkindq().getValue().toString().isEmpty()) m_perforationData.getdSkindq().setValue("0.0");
|
|
|
double x1,y1,x2,y2; m_perforationData.getLinePositions(x1,y1,x2,y2);
|
|
|
if (x1==-999.0 || y1==-999.0 || x2==-999.0 || y2==-999.0) m_perforationData.setLinePositions(100.0,0.0,200.0,0.0);
|
|
|
|
|
|
// 5) 刷新UI
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::initUI()
|
|
|
{
|
|
|
// 创建主布局
|
|
|
QVBoxLayout* mainLayout = new QVBoxLayout(this);
|
|
|
|
|
|
// 创建工具栏容器
|
|
|
QWidget* toolbarContainer = new QWidget(this);
|
|
|
toolbarContainer->setFixedHeight(70); // 固定工具栏高度
|
|
|
m_pToolbarLayout = new QHBoxLayout(toolbarContainer); // 保存布局指针
|
|
|
|
|
|
// 创建按钮并设置统一样式
|
|
|
auto createButton = [&](QPushButton*& button, const QString & iconPath, const QString & text) {
|
|
|
QWidget* buttonContainer = new QWidget(this);
|
|
|
QVBoxLayout* containerLayout = new QVBoxLayout(buttonContainer);
|
|
|
containerLayout->setSpacing(0);
|
|
|
containerLayout->setContentsMargins(2, 2, 2, 2); // 减小边距
|
|
|
|
|
|
// 图标按钮
|
|
|
button = new QPushButton(buttonContainer);
|
|
|
button->setIcon(QIcon(iconPath));
|
|
|
button->setIconSize(QSize(36, 36));
|
|
|
button->setFixedSize(40, 40);
|
|
|
|
|
|
// 文字标签
|
|
|
QLabel* textLabel = new QLabel(text, buttonContainer);
|
|
|
textLabel->setAlignment(Qt::AlignCenter);
|
|
|
|
|
|
// 将按钮和文字添加到容器
|
|
|
containerLayout->addWidget(button, 0, Qt::AlignHCenter);
|
|
|
containerLayout->addWidget(textLabel);
|
|
|
|
|
|
// 设置容器的大小策略和固定高度
|
|
|
buttonContainer->setFixedSize(100, 70); // 固定宽度和高度
|
|
|
|
|
|
m_pToolbarLayout->addWidget(buttonContainer);
|
|
|
};
|
|
|
|
|
|
QString appDir = QCoreApplication::applicationDirPath();
|
|
|
appDir = appDir.section('/', 0, -2); // 获取上一级目录
|
|
|
|
|
|
// 创建所有按钮
|
|
|
createButton(m_pSkinVsRateBtn, appDir + "/Res/Icon/nmTimeDepSkin1.png", tr("Skin vs Rate"));
|
|
|
createButton(m_pAddBtn, appDir + "/Res/Icon/nmTimeDepSkin2.png", tr("Add"));
|
|
|
createButton(m_pRemoveBtn, appDir + "/Res/Icon/nmTimeDepSkin3.png", tr("Remove"));
|
|
|
createButton(m_pSplitStepsBtn, appDir + "/Res/Icon/nmTimeDepSkin4.png", tr("Split Steps"));
|
|
|
createButton(m_pComputeBtn, appDir + "/Res/Icon/nmTimeDepSkin5.png", tr("Compute"));
|
|
|
createButton(m_pPerforationClosingBtn, appDir + "/Res/Icon/nmTimeDepSkin6.png", tr("Perforation Closing"));
|
|
|
|
|
|
m_pToolbarLayout->addStretch();
|
|
|
|
|
|
// 创建复选框区域
|
|
|
QWidget* checkboxContainer = new QWidget(this);
|
|
|
QHBoxLayout* checkboxLayout = new QHBoxLayout(checkboxContainer);
|
|
|
checkboxLayout->setSpacing(15); // 设置复选框之间的间距
|
|
|
checkboxLayout->setContentsMargins(10, 5, 10, 5);
|
|
|
|
|
|
// 创建三个复选框
|
|
|
m_pSnapToRateChangesCheckBox = new QCheckBox(tr("Snap to rate changes"));
|
|
|
m_pShowDatesCheckBox = new QCheckBox(tr("Show dates"));
|
|
|
m_pAddRateDependentCheckBox = new QCheckBox(tr("Add rate dependent"));
|
|
|
|
|
|
// 将复选框水平添加到布局
|
|
|
checkboxLayout->addWidget(m_pSnapToRateChangesCheckBox);
|
|
|
checkboxLayout->addWidget(m_pShowDatesCheckBox);
|
|
|
checkboxLayout->addWidget(m_pAddRateDependentCheckBox);
|
|
|
|
|
|
// 设置复选框容器的合适宽度以容纳三个复选框
|
|
|
checkboxContainer->setFixedWidth(450); // 增加宽度以容纳水平排列的复选框
|
|
|
checkboxContainer->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
|
|
|
|
|
|
// 将复选框容器添加到工具栏布局
|
|
|
m_pToolbarLayout->addWidget(checkboxContainer);
|
|
|
|
|
|
// 将工具栏容器添加到主布局
|
|
|
mainLayout->addWidget(toolbarContainer);
|
|
|
|
|
|
// 创建分割器，用于调整三个区域的大小
|
|
|
QSplitter* splitter = new QSplitter(Qt::Horizontal, this);
|
|
|
splitter->setChildrenCollapsible(false);
|
|
|
splitter->setHandleWidth(1);
|
|
|
|
|
|
// 创建左侧区域（图表+下拉框）
|
|
|
QWidget* leftWidget = new QWidget();
|
|
|
QVBoxLayout* leftLayout = new QVBoxLayout(leftWidget);
|
|
|
|
|
|
// 创建图表区域容器
|
|
|
QWidget* chartWidget = new QWidget();
|
|
|
m_pChartLayout = new QVBoxLayout(chartWidget);
|
|
|
m_pChartLayout->setSpacing(0); // 移除布局间距，让分割器来控制间距
|
|
|
m_pChartLayout->setContentsMargins(0, 0, 0, 0); // 移除边距
|
|
|
|
|
|
// 创建垂直分割器用于调整两个图表的比例
|
|
|
m_pChartSplitter = new QSplitter(Qt::Vertical, chartWidget);
|
|
|
m_pChartSplitter->setChildrenCollapsible(false); // 防止子控件被完全折叠
|
|
|
m_pChartSplitter->setHandleWidth(3); // 设置分割线宽度
|
|
|
|
|
|
// 创建压力图表
|
|
|
m_pPressureChart = new nmWxPressFlowChartWidget(m_pChartSplitter);
|
|
|
m_pPressureChart->setAxisLabels(tr(""), tr("Pressure"));
|
|
|
m_pPressureChart->setAxisUnits(tr("hr"), tr("MPa"));
|
|
|
m_pPressureChart->setLineColor(QColor(50, 200, 50)); // 绿色
|
|
|
m_pPressureChart->setChartType(CHART_TYPE_LINE);
|
|
|
m_pPressureChart->setMinimumHeight(150); // 设置最小高度防止过度压缩
|
|
|
m_pPressureChart->setShowXAxisLabels(false); // 压力图不显示X轴标签
|
|
|
|
|
|
// 创建流量图表
|
|
|
m_pFlowRateChart = new nmWxPressFlowChartWidget(m_pChartSplitter);
|
|
|
m_pFlowRateChart->setAxisLabels(tr("Time"), tr("Flow"));
|
|
|
m_pFlowRateChart->setAxisUnits(tr("hr"), tr("m3/d"));
|
|
|
m_pFlowRateChart->setLineColor(QColor(255, 0, 0)); // 红色
|
|
|
m_pFlowRateChart->setChartType(CHART_TYPE_STEP);
|
|
|
m_pFlowRateChart->setMinimumHeight(150); // 设置最小高度防止过度压缩
|
|
|
|
|
|
// 保存原始图表的引用
|
|
|
m_pOriginalPressureChart = m_pPressureChart;
|
|
|
m_pOriginalFlowRateChart = m_pFlowRateChart;
|
|
|
|
|
|
// 将图表添加到分割器
|
|
|
m_pChartSplitter->addWidget(m_pPressureChart);
|
|
|
m_pChartSplitter->addWidget(m_pFlowRateChart);
|
|
|
|
|
|
// 设置初始比例 (1:1)
|
|
|
m_pChartSplitter->setStretchFactor(0, 1);
|
|
|
m_pChartSplitter->setStretchFactor(1, 1);
|
|
|
|
|
|
// 将分割器添加到布局中
|
|
|
m_pChartLayout->addWidget(m_pChartSplitter, 1);
|
|
|
|
|
|
// 创建图表下方的下拉框
|
|
|
m_pComboBox = new QComboBox();
|
|
|
m_pComboBox->setFixedWidth(200); // 增加宽度以容纳射孔段名称
|
|
|
|
|
|
// 将图表和下拉框添加到左侧布局
|
|
|
leftLayout->addWidget(chartWidget, 1); // 图表占据大部分空间
|
|
|
leftLayout->addWidget(m_pComboBox); // 下拉框固定高度
|
|
|
|
|
|
// 创建中间区域（表格+确定取消按钮）
|
|
|
QWidget* middleWidget = new QWidget();
|
|
|
QVBoxLayout* middleLayout = new QVBoxLayout(middleWidget);
|
|
|
|
|
|
// 创建数据表格
|
|
|
m_pDataTable = new QTableWidget(0, 3);
|
|
|
|
|
|
// 设置列标题
|
|
|
QStringList headers;
|
|
|
headers << tr("") << tr("Start time") << tr("Skin");
|
|
|
m_pDataTable->setHorizontalHeaderLabels(headers);
|
|
|
|
|
|
m_pDataTable->verticalHeader()->setVisible(false);
|
|
|
m_pDataTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
|
|
|
m_pDataTable->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
|
|
|
|
|
|
QHeaderView* header = m_pDataTable->horizontalHeader();
|
|
|
header->setResizeMode(0, QHeaderView::Fixed); // 第一列（箭头列）固定宽度
|
|
|
header->setResizeMode(1, QHeaderView::Stretch); // 第二列（时间列）拉伸
|
|
|
header->setResizeMode(2, QHeaderView::Stretch); // 第三列（Skin列）拉伸
|
|
|
|
|
|
// 表头下的“单位”行
|
|
|
m_pDataTable->insertRow(0);
|
|
|
// 第二列：时间单位下拉框（统一用小写，匹配 convertTimeUnit）
|
|
|
m_pTimeUnitCombo = new QComboBox(m_pDataTable);
|
|
|
QStringList units;
|
|
|
units << "sec" << "min" << "hr" << "day" << "week" << "month" << "year";
|
|
|
|
|
|
if(m_timeDisplayUnit.isEmpty()) m_timeDisplayUnit = "hr";
|
|
|
|
|
|
int idx = units.indexOf(m_timeDisplayUnit);
|
|
|
m_pTimeUnitCombo->addItems(units);
|
|
|
m_pTimeUnitCombo->setCurrentIndex(idx >= 0 ? idx : units.indexOf("hr"));
|
|
|
m_pTimeUnitCombo->setEditable(true);
|
|
|
m_pTimeUnitCombo->lineEdit()->setAlignment(Qt::AlignCenter);
|
|
|
m_pTimeUnitCombo->lineEdit()->setReadOnly(true);
|
|
|
m_pTimeUnitCombo->setStyleSheet(
|
|
|
"QComboBox { border: none; background: transparent; padding-left: 4px; }"
|
|
|
"QComboBox::drop-down { border: none; }"
|
|
|
);
|
|
|
m_pDataTable->setCellWidget(0, 1, m_pTimeUnitCombo);
|
|
|
|
|
|
// 第三列：占位（Skin 无单位）
|
|
|
QTableWidgetItem* empty = new QTableWidgetItem("");
|
|
|
empty->setFlags(Qt::ItemIsEnabled);
|
|
|
m_pDataTable->setItem(0, 2, empty);
|
|
|
|
|
|
// 行高
|
|
|
m_pDataTable->setRowHeight(0, 24);
|
|
|
|
|
|
// 信号连接
|
|
|
connect(m_pTimeUnitCombo, SIGNAL(currentIndexChanged(const QString &)),
|
|
|
this, SLOT(onTimeUnitChanged(const QString &)));
|
|
|
|
|
|
// 设置第一列的固定宽度
|
|
|
m_pDataTable->setColumnWidth(0, 20);
|
|
|
|
|
|
// 表格设置
|
|
|
m_pDataTable->setSelectionMode(QAbstractItemView::NoSelection); // 禁用默认选中
|
|
|
m_pDataTable->setFocusPolicy(Qt::NoFocus); // 禁用焦点
|
|
|
|
|
|
// 创建表格下方的确定取消按钮
|
|
|
QHBoxLayout* tableBottomLayout = new QHBoxLayout();
|
|
|
tableBottomLayout->addStretch();
|
|
|
|
|
|
m_pOkBtn = new QPushButton(tr("OK"));
|
|
|
m_pCancelBtn = new QPushButton(tr("Cancel"));
|
|
|
m_pOkBtn->setFixedSize(100, 30);
|
|
|
m_pCancelBtn->setFixedSize(100, 30);
|
|
|
|
|
|
tableBottomLayout->addWidget(m_pOkBtn);
|
|
|
tableBottomLayout->addWidget(m_pCancelBtn);
|
|
|
|
|
|
// 将表格和按钮添加到中间布局
|
|
|
middleLayout->addWidget(m_pDataTable, 1); // 表格占据大部分空间
|
|
|
middleLayout->addLayout(tableBottomLayout); // 确定取消按钮
|
|
|
|
|
|
// 创建右侧按钮区域
|
|
|
QWidget* rightButtonWidget = new QWidget();
|
|
|
QVBoxLayout* rightButtonLayout = new QVBoxLayout(rightButtonWidget);
|
|
|
|
|
|
// 创建三个垂直排布的按钮
|
|
|
m_pRightAddBtn = new QPushButton(tr("Add"));
|
|
|
m_pRightInsertBtn = new QPushButton(tr("Insert"));
|
|
|
m_pRightDeleteBtn = new QPushButton(tr("Delete"));
|
|
|
|
|
|
// 设置按钮的固定大小
|
|
|
m_pRightAddBtn->setFixedSize(100, 30);
|
|
|
m_pRightInsertBtn->setFixedSize(100, 30);
|
|
|
m_pRightDeleteBtn->setFixedSize(100, 30);
|
|
|
|
|
|
// 添加按钮到垂直布局
|
|
|
rightButtonLayout->addWidget(m_pRightAddBtn);
|
|
|
rightButtonLayout->addWidget(m_pRightInsertBtn);
|
|
|
rightButtonLayout->addWidget(m_pRightDeleteBtn);
|
|
|
rightButtonLayout->addStretch(); // 添加弹性空间，将按钮推到顶部
|
|
|
|
|
|
// 将三个区域直接添加到分割器
|
|
|
splitter->addWidget(leftWidget); // 左侧区域（图表+下拉框）
|
|
|
splitter->addWidget(middleWidget); // 中间区域（表格+确定取消按钮）
|
|
|
splitter->addWidget(rightButtonWidget); // 右侧区域（Add/Insert/Delete按钮）
|
|
|
|
|
|
// 设置比例
|
|
|
splitter->setStretchFactor(0, 6); // 左侧区域占7份
|
|
|
splitter->setStretchFactor(1, 3); // 中间区域占2份
|
|
|
splitter->setStretchFactor(2, 1); // 右侧区域占1份
|
|
|
|
|
|
mainLayout->addWidget(splitter);
|
|
|
|
|
|
// 设置主布局
|
|
|
setLayout(mainLayout);
|
|
|
|
|
|
// 工具栏按钮默认状态
|
|
|
m_pSkinVsRateBtn->setEnabled(false);
|
|
|
m_pAddBtn->setEnabled(true);
|
|
|
m_pRemoveBtn->setEnabled(true);
|
|
|
m_pSplitStepsBtn->setEnabled(true);
|
|
|
m_pComputeBtn->setEnabled(false);
|
|
|
m_pPerforationClosingBtn->setEnabled(true);
|
|
|
|
|
|
// 复选框默认状态
|
|
|
m_pSnapToRateChangesCheckBox->setChecked(true);
|
|
|
|
|
|
// 从数据中读取"对齐到流量段"的状态
|
|
|
bool snapToRateEnabled = m_perforationData.isSnapToRateChangesEnabled();
|
|
|
m_pSnapToRateChangesCheckBox->setChecked(snapToRateEnabled);
|
|
|
|
|
|
// 从数据中读取"显示日期"的状态
|
|
|
bool showDatesEnabled = m_perforationData.isShowDatesEnabled();
|
|
|
m_pShowDatesCheckBox->setChecked(showDatesEnabled);
|
|
|
|
|
|
// 从数据中读取"添加流量相关"的状态
|
|
|
bool rateDependentEnabled = m_perforationData.isRateDependentEnabled();
|
|
|
m_pAddRateDependentCheckBox->setChecked(rateDependentEnabled);
|
|
|
m_rateDependentState = rateDependentEnabled; // 保存初始状态
|
|
|
|
|
|
// 右侧按钮默认状态
|
|
|
m_pRightAddBtn->setEnabled(true);
|
|
|
m_pRightInsertBtn->setEnabled(true);
|
|
|
m_pRightDeleteBtn->setEnabled(true);
|
|
|
|
|
|
// 为右侧按钮也设置样式
|
|
|
QString buttonStyle =
|
|
|
"QPushButton {"
|
|
|
" border: 1px solid #ccc;"
|
|
|
" background-color: #f8f8f8;"
|
|
|
" border-radius: 3px;"
|
|
|
" padding: 2px;"
|
|
|
"}"
|
|
|
"QPushButton:hover {"
|
|
|
" background-color: #e8e8e8;"
|
|
|
" border-color: #999;"
|
|
|
"}"
|
|
|
"QPushButton:pressed {"
|
|
|
" background-color: #d8d8d8;"
|
|
|
"}"
|
|
|
"QPushButton:disabled {"
|
|
|
" background-color: #f0f0f0;"
|
|
|
" color: #aaa;"
|
|
|
" border-color: #ddd;"
|
|
|
"}";
|
|
|
|
|
|
m_pRightAddBtn->setStyleSheet(buttonStyle);
|
|
|
m_pRightInsertBtn->setStyleSheet(buttonStyle);
|
|
|
m_pRightDeleteBtn->setStyleSheet(buttonStyle);
|
|
|
m_pOkBtn->setStyleSheet(buttonStyle);
|
|
|
m_pCancelBtn->setStyleSheet(buttonStyle);
|
|
|
|
|
|
|
|
|
// 在初始化时创建图表模式按钮但不显示
|
|
|
createChartModeBtn();
|
|
|
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::updateCharts()
|
|
|
{
|
|
|
if(!m_pPressureChart || !m_pFlowRateChart) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 同步对齐设置
|
|
|
bool snapToRateChanges = m_pSnapToRateChangesCheckBox->isChecked();
|
|
|
m_pPressureChart->setSnapToRateChanges(snapToRateChanges);
|
|
|
m_pFlowRateChart->setSnapToRateChanges(snapToRateChanges);
|
|
|
|
|
|
// 更新压力数据
|
|
|
if(!pressurePoints.isEmpty()) {
|
|
|
m_pPressureChart->setData(pressurePoints);
|
|
|
// 使用本地副本数据而不是从管理器获取
|
|
|
m_pPressureChart->setFlowSegmentData(m_perforationData);
|
|
|
}
|
|
|
|
|
|
// 更新流量数据
|
|
|
if(!flowPoints.isEmpty()) {
|
|
|
m_pFlowRateChart->setData(flowPoints);
|
|
|
// 使用本地副本数据而不是从管理器获取
|
|
|
m_pFlowRateChart->setFlowSegmentData(m_perforationData);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::updateTableFromFlowSegments()
|
|
|
{
|
|
|
if(!m_pDataTable) return;
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segments.isEmpty()) return;
|
|
|
|
|
|
const bool enableRateDep = m_perforationData.isRateDependentEnabled();
|
|
|
const int requiredCols = enableRateDep ? 4 : 3;
|
|
|
|
|
|
// 只有在列数真正改变时才重建表格结构
|
|
|
bool needRefreshStructure = (m_pDataTable->columnCount() != requiredCols);
|
|
|
|
|
|
if(needRefreshStructure) {
|
|
|
refreshTableStructure();
|
|
|
} else {
|
|
|
// 确保单位行存在但不重建ComboBox
|
|
|
ensureHeaderRowExists();
|
|
|
// 更新时间单位显示
|
|
|
updateTimeUnitComboVisibility();
|
|
|
}
|
|
|
|
|
|
// 屏蔽信号，防止填充过程中触发
|
|
|
bool oldTblBlocked = m_pDataTable->blockSignals(true);
|
|
|
bool oldTimeBlocked = false;
|
|
|
bool oldQBlocked = false;
|
|
|
|
|
|
if(m_pTimeUnitCombo) oldTimeBlocked = m_pTimeUnitCombo->blockSignals(true);
|
|
|
|
|
|
if(m_pDSdQUnitCombo) oldQBlocked = m_pDSdQUnitCombo->blockSignals(true);
|
|
|
|
|
|
// 设置总行数
|
|
|
m_pDataTable->setRowCount(segments.size() + 1);
|
|
|
|
|
|
// 填充数据行（从第1行开始，第0行是单位行）
|
|
|
for(int i = 0; i < segments.size(); ++i) {
|
|
|
const int row = i + 1;
|
|
|
const FlowSegmentData& segment = segments[i];
|
|
|
|
|
|
// 更新选择箭头
|
|
|
QTableWidgetItem* arrowItem = m_pDataTable->item(row, 0);
|
|
|
|
|
|
if(!arrowItem) {
|
|
|
arrowItem = new QTableWidgetItem();
|
|
|
arrowItem->setFlags(Qt::ItemIsEnabled);
|
|
|
m_pDataTable->setItem(row, 0, arrowItem);
|
|
|
}
|
|
|
|
|
|
arrowItem->setIcon(segment.isSelected ? createTriangleIcon() : QIcon());
|
|
|
arrowItem->setText("");
|
|
|
|
|
|
// 更新时间
|
|
|
double startHr = segment.segmentStart.getValue().toDouble();
|
|
|
QString timeDisplay = formatTimeDisplay(startHr, i);
|
|
|
|
|
|
QTableWidgetItem* timeItem = m_pDataTable->item(row, 1);
|
|
|
|
|
|
if(!timeItem) {
|
|
|
timeItem = new QTableWidgetItem();
|
|
|
timeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
// 如果显示日期，时间列设为只读
|
|
|
bool showDates = m_perforationData.isShowDatesEnabled();
|
|
|
Qt::ItemFlags flags = Qt::ItemIsEnabled;
|
|
|
|
|
|
if(!showDates && i > 0) {
|
|
|
flags |= Qt::ItemIsEditable;
|
|
|
}
|
|
|
|
|
|
timeItem->setFlags(flags);
|
|
|
m_pDataTable->setItem(row, 1, timeItem);
|
|
|
}
|
|
|
|
|
|
timeItem->setText(timeDisplay);
|
|
|
|
|
|
// 更新Skin值
|
|
|
double skinValue = segment.skinValue.getValue().toDouble();
|
|
|
QTableWidgetItem* skinItem = m_pDataTable->item(row, 2);
|
|
|
|
|
|
if(!skinItem) {
|
|
|
skinItem = new QTableWidgetItem();
|
|
|
skinItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
skinItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
|
|
m_pDataTable->setItem(row, 2, skinItem);
|
|
|
}
|
|
|
|
|
|
skinItem->setText(QString::number(skinValue, 'f', 5));
|
|
|
|
|
|
// 更新dS/dQ值（如果启用）
|
|
|
if(enableRateDep) {
|
|
|
double base = segment.dSdQ.getValue().toDouble();
|
|
|
double disp = convertDSdQ(base, "1/B/D", m_dSdQDisplayUnit);
|
|
|
QTableWidgetItem* dsdqItem = m_pDataTable->item(row, 3);
|
|
|
|
|
|
if(!dsdqItem) {
|
|
|
dsdqItem = new QTableWidgetItem();
|
|
|
dsdqItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
dsdqItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
|
|
m_pDataTable->setItem(row, 3, dsdqItem);
|
|
|
}
|
|
|
|
|
|
dsdqItem->setText(QString::number(disp, 'f', 5));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 恢复信号状态
|
|
|
if(m_pTimeUnitCombo) m_pTimeUnitCombo->blockSignals(oldTimeBlocked);
|
|
|
|
|
|
if(m_pDSdQUnitCombo) m_pDSdQUnitCombo->blockSignals(oldQBlocked);
|
|
|
|
|
|
m_pDataTable->blockSignals(oldTblBlocked);
|
|
|
|
|
|
// 更新按钮状态
|
|
|
m_pSkinVsRateBtn->setEnabled(segments.size() >= 2);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::ensureHeaderRowExists()
|
|
|
{
|
|
|
// 确保第0行存在，但不重建ComboBox
|
|
|
if(m_pDataTable->rowCount() == 0) {
|
|
|
m_pDataTable->insertRow(0);
|
|
|
m_pDataTable->setRowHeight(0, 24);
|
|
|
}
|
|
|
|
|
|
// 如果ComboBox不存在才创建（只在首次或结构改变时）
|
|
|
if(!m_pTimeUnitCombo) {
|
|
|
createTimeUnitCombo();
|
|
|
}
|
|
|
|
|
|
const bool enableRateDep = m_perforationData.isRateDependentEnabled();
|
|
|
|
|
|
if(enableRateDep && !m_pDSdQUnitCombo) {
|
|
|
createDSdQUnitCombo();
|
|
|
} else if(!enableRateDep && m_pDSdQUnitCombo) {
|
|
|
// 如果禁用了rate dependent，删除dS/dQ ComboBox
|
|
|
m_pDSdQUnitCombo->disconnect(this);
|
|
|
delete m_pDSdQUnitCombo;
|
|
|
m_pDSdQUnitCombo = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::createTimeUnitCombo()
|
|
|
{
|
|
|
bool showDates = m_perforationData.isShowDatesEnabled();
|
|
|
|
|
|
if(showDates) {
|
|
|
// 如果显示日期，创建一个标签而不是下拉框
|
|
|
QLabel* dateTimeLabel = new QLabel(tr("Date Time"), m_pDataTable);
|
|
|
dateTimeLabel->setAlignment(Qt::AlignCenter);
|
|
|
dateTimeLabel->setStyleSheet("QLabel { color: #333; font-size: 12px; }");
|
|
|
m_pDataTable->setCellWidget(0, 1, dateTimeLabel);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 原有的创建时间单位下拉框的代码
|
|
|
m_pTimeUnitCombo = new QComboBox(m_pDataTable);
|
|
|
QStringList units;
|
|
|
units << "sec" << "min" << "hr" << "day" << "week" << "month" << "year";
|
|
|
|
|
|
if(m_timeDisplayUnit.isEmpty()) m_timeDisplayUnit = "hr";
|
|
|
|
|
|
int idx = units.indexOf(m_timeDisplayUnit);
|
|
|
m_pTimeUnitCombo->addItems(units);
|
|
|
m_pTimeUnitCombo->setCurrentIndex(idx >= 0 ? idx : units.indexOf("hr"));
|
|
|
m_pTimeUnitCombo->setEditable(true);
|
|
|
m_pTimeUnitCombo->lineEdit()->setAlignment(Qt::AlignCenter);
|
|
|
m_pTimeUnitCombo->lineEdit()->setReadOnly(true);
|
|
|
m_pTimeUnitCombo->setStyleSheet(
|
|
|
"QComboBox { border: none; background: transparent; padding-left: 4px; }"
|
|
|
"QComboBox::drop-down { border: none; }"
|
|
|
);
|
|
|
m_pDataTable->setCellWidget(0, 1, m_pTimeUnitCombo);
|
|
|
|
|
|
connect(m_pTimeUnitCombo, SIGNAL(currentIndexChanged(const QString &)),
|
|
|
this, SLOT(onTimeUnitChanged(const QString &)));
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::createDSdQUnitCombo()
|
|
|
{
|
|
|
m_pDSdQUnitCombo = new QComboBox(m_pDataTable);
|
|
|
QStringList qUnits;
|
|
|
qUnits << "1/B/D" << "1/MMm^3/D" << "1/Mcf/D" << "1/Mm^3/D" << "1/Mm^3/hr";
|
|
|
m_pDSdQUnitCombo->addItems(qUnits);
|
|
|
|
|
|
if(m_dSdQDisplayUnit.isEmpty()) m_dSdQDisplayUnit = "1/B/D";
|
|
|
|
|
|
int qIdx = qUnits.indexOf(m_dSdQDisplayUnit);
|
|
|
m_pDSdQUnitCombo->setCurrentIndex(qIdx >= 0 ? qIdx : qUnits.indexOf("1/B/D"));
|
|
|
m_pDSdQUnitCombo->setStyleSheet(
|
|
|
"QComboBox { border: none; background: transparent; padding-left: 4px; }"
|
|
|
"QComboBox::drop-down { border: none; }"
|
|
|
);
|
|
|
m_pDataTable->setCellWidget(0, 3, m_pDSdQUnitCombo);
|
|
|
|
|
|
connect(m_pDSdQUnitCombo, SIGNAL(currentIndexChanged(const QString&)),
|
|
|
this, SLOT(onDSdQUnitChanged(const QString&)));
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onFlowSegmentSelected(int segmentIndex)
|
|
|
{
|
|
|
// 如果在移除模式，执行合并操作
|
|
|
if(m_isRemoveMode) {
|
|
|
// 尝试与左侧段合并
|
|
|
bool success = mergeSegmentWithPrevious(segmentIndex);
|
|
|
|
|
|
// 无论成功与否，都退出移除模式
|
|
|
m_isRemoveMode = false;
|
|
|
|
|
|
if(success) {
|
|
|
// 如果成功，更新图表和表格显示
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 如果在添加模式，不处理段选择
|
|
|
if(m_isAddMode) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 正常的选择流动段
|
|
|
selectFlowSegment(segmentIndex);
|
|
|
|
|
|
// 更新图表显示
|
|
|
updateCharts();
|
|
|
|
|
|
// 更新表格显示
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::addFlowSegmentAtExactTime(double timePoint)
|
|
|
{
|
|
|
// 找到包含该时间点的流动段
|
|
|
int segmentIndex = m_perforationData.findFlowSegmentByTime(timePoint);
|
|
|
|
|
|
if(segmentIndex < 0) {
|
|
|
return false; // 没有找到对应的流动段
|
|
|
}
|
|
|
|
|
|
// 直接在该时间点分割流动段
|
|
|
return splitFlowSegmentAtTime(segmentIndex, timePoint);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onChartPointClicked(double timePoint)
|
|
|
{
|
|
|
if(!m_isAddMode) {
|
|
|
return; // 不在添加模式，忽略此事件
|
|
|
}
|
|
|
|
|
|
bool success = false;
|
|
|
|
|
|
// 检查"Snap to rate changes"复选框状态
|
|
|
bool snapToRateChanges = m_pSnapToRateChangesCheckBox->isChecked();
|
|
|
|
|
|
if(snapToRateChanges) {
|
|
|
// 勾选状态：使用现有逻辑，在点击位置所在阶梯段的结束边界添加流动段
|
|
|
success = addFlowSegmentAtTime(timePoint);
|
|
|
} else {
|
|
|
// 未勾选状态：直接在点击位置分割流动段
|
|
|
success = addFlowSegmentAtExactTime(timePoint);
|
|
|
}
|
|
|
|
|
|
// 无论成功与否，都退出添加模式
|
|
|
m_isAddMode = false;
|
|
|
|
|
|
if(success) {
|
|
|
// 如果成功，更新图表和表格显示
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onAddClicked()
|
|
|
{
|
|
|
if(m_isAddMode) {
|
|
|
// 如果已经在添加模式，退出添加模式
|
|
|
m_isAddMode = false;
|
|
|
} else {
|
|
|
// 进入添加模式，同时退出移除模式
|
|
|
m_isAddMode = true;
|
|
|
m_isRemoveMode = false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onRemoveClicked()
|
|
|
{
|
|
|
if(m_isRemoveMode) {
|
|
|
// 如果已经在移除模式，退出移除模式
|
|
|
m_isRemoveMode = false;
|
|
|
} else {
|
|
|
// 进入移除模式，同时退出添加模式
|
|
|
m_isRemoveMode = true;
|
|
|
m_isAddMode = false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onSplitStepsClicked()
|
|
|
{
|
|
|
// 一次性分割所有流动段
|
|
|
splitAllFlowSegments();
|
|
|
|
|
|
// 更新图表显示
|
|
|
updateCharts();
|
|
|
|
|
|
// 更新表格数据
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onComputeClicked()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onPerforationClosingBtnClicked()
|
|
|
{
|
|
|
nmWxPerforationClosing* dlg = new nmWxPerforationClosing(m_currentWell, this);
|
|
|
dlg->show();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onSkinVsRateClicked()
|
|
|
{
|
|
|
// 如果已经显示了图表，就恢复原始状态
|
|
|
if(m_pChartWidget != nullptr) {
|
|
|
restoreOriginalCharts();
|
|
|
restoreToolbarState();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 进入SkinVsRate模式前，保存当前完整状态
|
|
|
saveStateBeforeSkinVsRate();
|
|
|
|
|
|
// 创建交互式图表
|
|
|
showInteractiveChart();
|
|
|
hideToolbarButtons();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::saveStateBeforeSkinVsRate()
|
|
|
{
|
|
|
// 保存完整的流动段数据副本（包括所有dSdQ值）
|
|
|
m_savedFlowSegmentData = m_perforationData;
|
|
|
|
|
|
// 保存"添加流量相关"复选框状态
|
|
|
m_savedRateDependentState = m_pAddRateDependentCheckBox ?
|
|
|
m_pAddRateDependentCheckBox->isChecked() : false;
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::restoreStateAfterSkinVsRate()
|
|
|
{
|
|
|
// 只恢复dSdQ值，保留skin值的修改
|
|
|
QVector<FlowSegmentData> currentSegments = m_perforationData.getFlowSegments();
|
|
|
const QVector<FlowSegmentData>& savedSegments = m_savedFlowSegmentData.getFlowSegments();
|
|
|
|
|
|
// 确保两个数组大小一致
|
|
|
if(currentSegments.size() == savedSegments.size()) {
|
|
|
for(int i = 0; i < currentSegments.size(); ++i) {
|
|
|
// 只恢复dSdQ值，保留当前的skin值
|
|
|
currentSegments[i].dSdQ = savedSegments[i].dSdQ;
|
|
|
// skin值保持不变：currentSegments[i].skinValue 不修改
|
|
|
}
|
|
|
|
|
|
// 更新流动段数据
|
|
|
m_perforationData.setFlowSegments(currentSegments);
|
|
|
}
|
|
|
|
|
|
// 恢复RateDependent状态
|
|
|
m_perforationData.setRateDependentEnabled(m_savedRateDependentState);
|
|
|
|
|
|
// 恢复"添加流量相关"复选框状态
|
|
|
if(m_pAddRateDependentCheckBox) {
|
|
|
bool wasBlocked = m_pAddRateDependentCheckBox->blockSignals(true);
|
|
|
m_pAddRateDependentCheckBox->setChecked(m_savedRateDependentState);
|
|
|
m_pAddRateDependentCheckBox->blockSignals(wasBlocked);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::showInteractiveChart()
|
|
|
{
|
|
|
if(m_pChartSplitter == nullptr) return;
|
|
|
|
|
|
// 隐藏分割器
|
|
|
m_pChartSplitter->hide();
|
|
|
|
|
|
// 创建交互式图表widget
|
|
|
m_pChartWidget = new nmWxChartWidget(this);
|
|
|
m_pChartWidget->setMinimumSize(400, 400);
|
|
|
|
|
|
// 连接信号槽
|
|
|
connect(m_pChartWidget, SIGNAL(skinValuesChanged(double, double)),
|
|
|
this, SLOT(onSkinValuesChanged(double, double)));
|
|
|
|
|
|
// 连接过滤完成信号
|
|
|
connect(m_pChartWidget, SIGNAL(crossMarksFiltered()),
|
|
|
this, SLOT(onCrossMarksFiltered()));
|
|
|
|
|
|
// 添加到布局
|
|
|
m_pChartLayout->addWidget(m_pChartWidget, 1);
|
|
|
m_pChartWidget->show();
|
|
|
|
|
|
// 设置对齐到流量段的初始状态
|
|
|
bool snapToRateChanges = m_pSnapToRateChangesCheckBox->isChecked();
|
|
|
m_pChartWidget->setSnapToRateChanges(snapToRateChanges);
|
|
|
|
|
|
m_pChartWidget->setFlowSegmentData(m_perforationData);
|
|
|
|
|
|
// 传递原始流量数据
|
|
|
if(m_currentWell != nullptr) {
|
|
|
QVector<QPointF> rawFlowData = m_currentWell->getFlowPoints();
|
|
|
m_pChartWidget->setRawFlowData(rawFlowData);
|
|
|
}
|
|
|
|
|
|
m_pChartWidget->calculateDataRange();
|
|
|
|
|
|
// 在数据传递完成后，检查是否需要加载已保存的线条位置
|
|
|
// 这里会被延迟执行，确保初始拟合先完成
|
|
|
QTimer::singleShot(10, this, SLOT(loadSavedLinePositionsIfValid()));
|
|
|
|
|
|
// 初始化编辑框
|
|
|
updateEditBoxesFromData();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::loadSavedLinePositionsIfValid()
|
|
|
{
|
|
|
if(m_pChartWidget == nullptr) return;
|
|
|
|
|
|
// 直接检查数据类中是否有有效的线条位置
|
|
|
double x1, y1, x2, y2;
|
|
|
m_perforationData.getLinePositions(x1, y1, x2, y2);
|
|
|
|
|
|
// 检查是否为有效数据（-999表示未设置，或者是默认值100,0,200,0）
|
|
|
bool hasValidData = (x1 != -999.0 && y1 != -999.0 && x2 != -999.0 && y2 != -999.0);
|
|
|
|
|
|
// 额外检查：如果是默认值(100,0,200,0)，也认为是无效数据
|
|
|
bool isDefaultValue = (qAbs(x1 - 100.0) < 1e-6 && qAbs(y1 - 0.0) < 1e-6 &&
|
|
|
qAbs(x2 - 200.0) < 1e-6 && qAbs(y2 - 0.0) < 1e-6);
|
|
|
|
|
|
if(hasValidData && !isDefaultValue) {
|
|
|
// 有有效且非默认的数据，加载保存的位置（用户之前调整过的位置）
|
|
|
loadChartPositionsFromData();
|
|
|
updateEditBoxesFromData();
|
|
|
} else {
|
|
|
// 没有有效数据或是默认值，图表组件的初始拟合结果已经生效
|
|
|
// 不需要再次保存，因为 onSkinValuesChanged 已经保存过了
|
|
|
updateEditBoxesFromData();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
void nmWxTimeDependentSkin::initializeChartFromData()
|
|
|
{
|
|
|
if(m_pChartWidget == nullptr) return;
|
|
|
|
|
|
// 从 m_skinVsRateData 获取当前值
|
|
|
bool skin0Ok, dSkinDqOk;
|
|
|
double skin0Value = m_perforationData.getSkin0().getValue().toString().toDouble(&skin0Ok);
|
|
|
double dSkinDqValue = m_perforationData.getdSkindq().getValue().toString().toDouble(&dSkinDqOk);
|
|
|
|
|
|
// 如果数据无效，使用默认值
|
|
|
if(!skin0Ok) {
|
|
|
skin0Value = 0.0;
|
|
|
}
|
|
|
|
|
|
if(!dSkinDqOk) {
|
|
|
dSkinDqValue = 0.0;
|
|
|
}
|
|
|
|
|
|
// 设置图表的初始值和线条位置
|
|
|
m_pChartWidget->setSkinValues(skin0Value, dSkinDqValue);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::loadChartPositionsFromData()
|
|
|
{
|
|
|
if(m_pChartWidget == nullptr) return;
|
|
|
|
|
|
// 获取保存的线条位置
|
|
|
double x1, y1, x2, y2;
|
|
|
m_perforationData.getLinePositions(x1, y1, x2, y2);
|
|
|
|
|
|
// 检查是否有有效数据（-999表示未设置）
|
|
|
if(x1 == -999.0 || y1 == -999.0 || x2 == -999.0 || y2 == -999.0) {
|
|
|
// 没有有效数据，不执行加载
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 设置图表的线条位置
|
|
|
m_pChartWidget->setLinePositions(x1, y1, x2, y2);
|
|
|
}
|
|
|
|
|
|
|
|
|
void nmWxTimeDependentSkin::saveChartPositionsToData()
|
|
|
{
|
|
|
if(m_pChartWidget == nullptr) return;
|
|
|
|
|
|
// 获取当前图表的线条位置
|
|
|
double x1, y1, x2, y2;
|
|
|
m_pChartWidget->getLinePositions(x1, y1, x2, y2);
|
|
|
|
|
|
// 保存到数据对象
|
|
|
m_perforationData.setLinePositions(x1, y1, x2, y2);
|
|
|
|
|
|
// 同时更新skin0和dSkin/dq值
|
|
|
double skin0Value = m_pChartWidget->getSkin0Value();
|
|
|
double dSkinDqValue = m_pChartWidget->getDSkinDqValue();
|
|
|
m_perforationData.getSkin0().setValue(QString::number(skin0Value, 'f', 5));
|
|
|
m_perforationData.getdSkindq().setValue(QString::number(dSkinDqValue, 'f', 5));
|
|
|
}
|
|
|
|
|
|
|
|
|
void nmWxTimeDependentSkin::onSkinValuesChanged(double skin0Value, double dSkinDqValue)
|
|
|
{
|
|
|
// 实时保存图表位置到数据对象
|
|
|
saveChartPositionsToData();
|
|
|
|
|
|
// 更新编辑框显示
|
|
|
updateEditBoxesFromData();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onCrossMarksFiltered()
|
|
|
{
|
|
|
// 过滤完成后，自动保存图表位置
|
|
|
saveChartPositionsToData();
|
|
|
|
|
|
// 更新编辑框显示
|
|
|
updateEditBoxesFromData();
|
|
|
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::updateEditBoxesFromData()
|
|
|
{
|
|
|
if(m_pSkinEdit && m_pDSkinDqEdit) {
|
|
|
QString skin0Text = m_perforationData.getSkin0().getValue().toString();
|
|
|
QString dSkinDqText = m_perforationData.getdSkindq().getValue().toString();
|
|
|
|
|
|
m_pSkinEdit->setText(skin0Text);
|
|
|
m_pDSkinDqEdit->setText(dSkinDqText);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::restoreOriginalCharts()
|
|
|
{
|
|
|
if(m_pChartLayout == nullptr || m_pChartSplitter == nullptr) return;
|
|
|
|
|
|
// 如果图表widget存在且处于套索模式，先退出
|
|
|
if(m_pChartWidget != nullptr) {
|
|
|
if(m_pChartWidget->getLassoMode()) {
|
|
|
m_pChartWidget->setLassoMode(false);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 移除交互式图表
|
|
|
if(m_pChartWidget != nullptr) {
|
|
|
m_pChartLayout->removeWidget(m_pChartWidget);
|
|
|
m_pChartWidget->deleteLater();
|
|
|
m_pChartWidget = nullptr;
|
|
|
}
|
|
|
|
|
|
// 重新显示分割器（包含原始的两个图表）
|
|
|
m_pChartSplitter->show();
|
|
|
|
|
|
// 确保原始图表在分割器中是可见的
|
|
|
if(m_pOriginalPressureChart != nullptr) {
|
|
|
m_pOriginalPressureChart->show();
|
|
|
}
|
|
|
|
|
|
if(m_pOriginalFlowRateChart != nullptr) {
|
|
|
m_pOriginalFlowRateChart->show();
|
|
|
}
|
|
|
|
|
|
// 恢复默认比例 (1:1)
|
|
|
m_pChartSplitter->setStretchFactor(0, 1);
|
|
|
m_pChartSplitter->setStretchFactor(1, 1);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::hideToolbarButtons()
|
|
|
{
|
|
|
// 通过按钮的父容器隐藏原有按钮
|
|
|
if(m_pAddBtn && m_pAddBtn->parentWidget()) {
|
|
|
m_pAddBtn->parentWidget()->setVisible(false);
|
|
|
}
|
|
|
|
|
|
if(m_pRemoveBtn && m_pRemoveBtn->parentWidget()) {
|
|
|
m_pRemoveBtn->parentWidget()->setVisible(false);
|
|
|
}
|
|
|
|
|
|
if(m_pSplitStepsBtn && m_pSplitStepsBtn->parentWidget()) {
|
|
|
m_pSplitStepsBtn->parentWidget()->setVisible(false);
|
|
|
}
|
|
|
|
|
|
if(m_pComputeBtn && m_pComputeBtn->parentWidget()) {
|
|
|
m_pComputeBtn->parentWidget()->setVisible(false);
|
|
|
}
|
|
|
|
|
|
if(m_pPerforationClosingBtn && m_pPerforationClosingBtn->parentWidget()) {
|
|
|
m_pPerforationClosingBtn->parentWidget()->setVisible(false);
|
|
|
}
|
|
|
|
|
|
// 显示图表模式下的新按钮
|
|
|
if(m_pFilterContainer) {
|
|
|
m_pFilterContainer->setVisible(true);
|
|
|
}
|
|
|
|
|
|
if(m_pResetFilterContainer) {
|
|
|
m_pResetFilterContainer->setVisible(true);
|
|
|
}
|
|
|
|
|
|
if(m_pResetLinesContainer) {
|
|
|
m_pResetLinesContainer->setVisible(true);
|
|
|
}
|
|
|
|
|
|
// 显示编辑框容器
|
|
|
if(m_pEditContainer) {
|
|
|
m_pEditContainer->setVisible(true);
|
|
|
}
|
|
|
|
|
|
// 隐藏"显示日期"复选框
|
|
|
if(m_pShowDatesCheckBox) {
|
|
|
m_pShowDatesCheckBox->setStyleSheet(
|
|
|
"QCheckBox { color: transparent; }"
|
|
|
"QCheckBox::indicator { width: 0px; height: 0px; }"
|
|
|
"QCheckBox::indicator:unchecked { image: none; }"
|
|
|
"QCheckBox::indicator:checked { image: none; }"
|
|
|
);
|
|
|
m_pShowDatesCheckBox->setEnabled(false);
|
|
|
}
|
|
|
|
|
|
// 保存并禁用"添加流量相关"复选框
|
|
|
if(m_pAddRateDependentCheckBox) {
|
|
|
// 阻止信号触发
|
|
|
bool wasBlocked = m_pAddRateDependentCheckBox->blockSignals(true);
|
|
|
m_pAddRateDependentCheckBox->setChecked(false);
|
|
|
m_pAddRateDependentCheckBox->blockSignals(wasBlocked);
|
|
|
m_pAddRateDependentCheckBox->setEnabled(false);
|
|
|
|
|
|
// 临时禁用数据的RateDependent状态（不会清零dSdQ值，因为我们有备份）
|
|
|
m_perforationData.setRateDependentEnabled(false);
|
|
|
|
|
|
// 刷新表格显示（会自动隐藏dSdQ列）
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::restoreToolbarState()
|
|
|
{
|
|
|
// 显示所有隐藏的按钮容器
|
|
|
if(m_pAddBtn && m_pAddBtn->parentWidget()) {
|
|
|
m_pAddBtn->parentWidget()->setVisible(true);
|
|
|
}
|
|
|
|
|
|
if(m_pRemoveBtn && m_pRemoveBtn->parentWidget()) {
|
|
|
m_pRemoveBtn->parentWidget()->setVisible(true);
|
|
|
}
|
|
|
|
|
|
if(m_pSplitStepsBtn && m_pSplitStepsBtn->parentWidget()) {
|
|
|
m_pSplitStepsBtn->parentWidget()->setVisible(true);
|
|
|
}
|
|
|
|
|
|
if(m_pComputeBtn && m_pComputeBtn->parentWidget()) {
|
|
|
m_pComputeBtn->parentWidget()->setVisible(true);
|
|
|
}
|
|
|
|
|
|
if(m_pPerforationClosingBtn && m_pPerforationClosingBtn->parentWidget()) {
|
|
|
m_pPerforationClosingBtn->parentWidget()->setVisible(true);
|
|
|
}
|
|
|
|
|
|
// 隐藏图表模式下的按钮
|
|
|
if(m_pFilterContainer) {
|
|
|
m_pFilterContainer->setVisible(false);
|
|
|
}
|
|
|
|
|
|
if(m_pResetFilterContainer) {
|
|
|
m_pResetFilterContainer->setVisible(false);
|
|
|
}
|
|
|
|
|
|
if(m_pResetLinesContainer) {
|
|
|
m_pResetLinesContainer->setVisible(false);
|
|
|
}
|
|
|
|
|
|
// 隐藏编辑框容器
|
|
|
if(m_pEditContainer) {
|
|
|
m_pEditContainer->setVisible(false);
|
|
|
}
|
|
|
|
|
|
// 恢复"显示日期"复选框
|
|
|
if(m_pShowDatesCheckBox) {
|
|
|
m_pShowDatesCheckBox->setStyleSheet(""); // 清除样式
|
|
|
m_pShowDatesCheckBox->setEnabled(true);
|
|
|
}
|
|
|
|
|
|
restoreStateAfterSkinVsRate();
|
|
|
|
|
|
// 启用"添加流量相关"复选框
|
|
|
if(m_pAddRateDependentCheckBox) {
|
|
|
m_pAddRateDependentCheckBox->setEnabled(true);
|
|
|
}
|
|
|
|
|
|
// 刷新表格显示
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::createChartModeBtn()
|
|
|
{
|
|
|
// 创建Filter按钮
|
|
|
m_pFilterContainer = new QWidget(this);
|
|
|
QVBoxLayout* filterLayout = new QVBoxLayout(m_pFilterContainer);
|
|
|
filterLayout->setSpacing(0);
|
|
|
filterLayout->setContentsMargins(2, 2, 2, 2);
|
|
|
|
|
|
m_pFilterBtn = new QPushButton(m_pFilterContainer);
|
|
|
m_pFilterBtn->setIcon(QIcon("D:/01-Projects/01-CNPC/01-nmWTAI-gitea/Bin/Res/Icon/NmFilter.png"));
|
|
|
m_pFilterBtn->setIconSize(QSize(36, 36));
|
|
|
m_pFilterBtn->setFixedSize(40, 40);
|
|
|
m_pFilterBtn->setEnabled(true);
|
|
|
|
|
|
QLabel* filterLabel = new QLabel(tr("Filter"), m_pFilterContainer);
|
|
|
filterLabel->setAlignment(Qt::AlignCenter);
|
|
|
|
|
|
filterLayout->addWidget(m_pFilterBtn, 0, Qt::AlignHCenter);
|
|
|
filterLayout->addWidget(filterLabel);
|
|
|
m_pFilterContainer->setFixedSize(100, 70);
|
|
|
m_pFilterContainer->setVisible(false);
|
|
|
m_pToolbarLayout->insertWidget(1, m_pFilterContainer);
|
|
|
|
|
|
// 创建Reset Filter按钮
|
|
|
m_pResetFilterContainer = new QWidget(this);
|
|
|
QVBoxLayout* resetFilterLayout = new QVBoxLayout(m_pResetFilterContainer);
|
|
|
resetFilterLayout->setSpacing(0);
|
|
|
resetFilterLayout->setContentsMargins(2, 2, 2, 2);
|
|
|
|
|
|
m_pResetFilterBtn = new QPushButton(m_pResetFilterContainer);
|
|
|
m_pResetFilterBtn->setIcon(QIcon("D:/01-Projects/01-CNPC/01-nmWTAI-gitea/Bin/Res/Icon/NmResetFilter.png"));
|
|
|
m_pResetFilterBtn->setIconSize(QSize(36, 36));
|
|
|
m_pResetFilterBtn->setFixedSize(40, 40);
|
|
|
m_pResetFilterBtn->setEnabled(true);
|
|
|
|
|
|
QLabel* resetFilterLabel = new QLabel(tr("Reset Filter"), m_pResetFilterContainer);
|
|
|
resetFilterLabel->setAlignment(Qt::AlignCenter);
|
|
|
|
|
|
resetFilterLayout->addWidget(m_pResetFilterBtn, 0, Qt::AlignHCenter);
|
|
|
resetFilterLayout->addWidget(resetFilterLabel);
|
|
|
m_pResetFilterContainer->setFixedSize(100, 70);
|
|
|
m_pResetFilterContainer->setVisible(false);
|
|
|
m_pToolbarLayout->insertWidget(2, m_pResetFilterContainer);
|
|
|
|
|
|
// 创建Reset Lines按钮
|
|
|
m_pResetLinesContainer = new QWidget(this);
|
|
|
QVBoxLayout* resetLinesLayout = new QVBoxLayout(m_pResetLinesContainer);
|
|
|
resetLinesLayout->setSpacing(0);
|
|
|
resetLinesLayout->setContentsMargins(2, 2, 2, 2);
|
|
|
|
|
|
m_pResetLinesBtn = new QPushButton(m_pResetLinesContainer);
|
|
|
m_pResetLinesBtn->setIcon(QIcon("D:/01-Projects/01-CNPC/01-nmWTAI-gitea/Bin/Res/Icon/NmResetLines.png"));
|
|
|
m_pResetLinesBtn->setIconSize(QSize(36, 36));
|
|
|
m_pResetLinesBtn->setFixedSize(40, 40);
|
|
|
|
|
|
QLabel* resetLinesLabel = new QLabel(tr("Reset Lines"), m_pResetLinesContainer);
|
|
|
resetLinesLabel->setAlignment(Qt::AlignCenter);
|
|
|
|
|
|
resetLinesLayout->addWidget(m_pResetLinesBtn, 0, Qt::AlignHCenter);
|
|
|
resetLinesLayout->addWidget(resetLinesLabel);
|
|
|
m_pResetLinesContainer->setFixedSize(100, 70);
|
|
|
m_pResetLinesContainer->setVisible(false);
|
|
|
m_pToolbarLayout->insertWidget(3, m_pResetLinesContainer);
|
|
|
|
|
|
// 创建编辑框容器
|
|
|
createEditBoxes();
|
|
|
|
|
|
// 连接信号槽（暂时为空实现）
|
|
|
connect(m_pFilterBtn, SIGNAL(clicked()), this, SLOT(onFilterClicked()));
|
|
|
connect(m_pResetFilterBtn, SIGNAL(clicked()), this, SLOT(onResetFilterClicked()));
|
|
|
connect(m_pResetLinesBtn, SIGNAL(clicked()), this, SLOT(onResetLinesClicked()));
|
|
|
}
|
|
|
|
|
|
QVector<QPointF> nmWxTimeDependentSkin::processFlowData(const QVector<QPointF>& rawFlowData)
|
|
|
{
|
|
|
QVector<QPointF> processedData;
|
|
|
|
|
|
if(rawFlowData.isEmpty()) {
|
|
|
return processedData;
|
|
|
}
|
|
|
|
|
|
double totalTime = 0.0;
|
|
|
|
|
|
// 预期的阶梯图应该是：
|
|
|
// 每个时间段内保持恒定流量，在时间段边界处跳跃到新流量值
|
|
|
|
|
|
for(int i = 0; i < rawFlowData.size(); ++i) {
|
|
|
const QPointF& currentSegment = rawFlowData[i];
|
|
|
|
|
|
if(i == 0) {
|
|
|
// 第一个数据点 - 设置初始流量
|
|
|
processedData.append(QPointF(totalTime, currentSegment.y()));
|
|
|
}
|
|
|
|
|
|
// 添加时间间隔到总时间
|
|
|
totalTime += currentSegment.x();
|
|
|
|
|
|
// 添加当前时间段结束时的点（保持当前流量）
|
|
|
processedData.append(QPointF(totalTime, currentSegment.y()));
|
|
|
|
|
|
// 如果有下一个时间段且流量不同，添加垂直跳跃
|
|
|
if(i < rawFlowData.size() - 1) {
|
|
|
double nextFlowRate = rawFlowData[i + 1].y();
|
|
|
|
|
|
if(qAbs(nextFlowRate - currentSegment.y()) > 1e-6) {
|
|
|
processedData.append(QPointF(totalTime, nextFlowRate));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return processedData;
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::createEditBoxes()
|
|
|
{
|
|
|
// 创建一个容器来垂直排布编辑框
|
|
|
QWidget* editContainer = new QWidget(this);
|
|
|
QVBoxLayout* editLayout = new QVBoxLayout(editContainer);
|
|
|
editLayout->setSpacing(3);
|
|
|
editLayout->setContentsMargins(8, 8, 8, 8);
|
|
|
|
|
|
// 创建第一行：Skin标签和编辑框
|
|
|
QHBoxLayout* skinLayout = new QHBoxLayout();
|
|
|
skinLayout->setSpacing(5);
|
|
|
|
|
|
QLabel* skinLabel = new QLabel(tr("Skin0:"), editContainer);
|
|
|
skinLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
skinLabel->setFixedWidth(60);
|
|
|
skinLabel->setStyleSheet("QLabel { color: #333; font-size: 12px; }");
|
|
|
|
|
|
m_pSkinEdit = new QLineEdit(editContainer);
|
|
|
m_pSkinEdit->setText("0.00000");
|
|
|
m_pSkinEdit->setFixedSize(100, 22);
|
|
|
m_pSkinEdit->setReadOnly(true); // 设置为只读
|
|
|
m_pSkinEdit->setStyleSheet(
|
|
|
"QLineEdit {"
|
|
|
"border: 1px solid #aaa;"
|
|
|
"border-radius: 2px;"
|
|
|
"padding: 2px 4px;"
|
|
|
"background-color: #f5f5f5;" // 只读背景色
|
|
|
"font-size: 12px;"
|
|
|
"color: #333;"
|
|
|
"}"
|
|
|
);
|
|
|
|
|
|
skinLayout->addWidget(skinLabel);
|
|
|
skinLayout->addWidget(m_pSkinEdit);
|
|
|
skinLayout->addStretch();
|
|
|
|
|
|
// 创建第二行：dSkin/dq标签和编辑框
|
|
|
QHBoxLayout* dSkinLayout = new QHBoxLayout();
|
|
|
dSkinLayout->setSpacing(5);
|
|
|
|
|
|
QLabel* dSkinLabel = new QLabel(tr("dSkin/dq:"), editContainer);
|
|
|
dSkinLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
dSkinLabel->setFixedWidth(60);
|
|
|
dSkinLabel->setStyleSheet("QLabel { color: #333; font-size: 12px; }");
|
|
|
|
|
|
m_pDSkinDqEdit = new QLineEdit(editContainer);
|
|
|
m_pDSkinDqEdit->setText("0.00000");
|
|
|
m_pDSkinDqEdit->setFixedSize(100, 22);
|
|
|
m_pDSkinDqEdit->setReadOnly(true); // 设置为只读
|
|
|
m_pDSkinDqEdit->setStyleSheet(
|
|
|
"QLineEdit {"
|
|
|
"border: 1px solid #aaa;"
|
|
|
"border-radius: 2px;"
|
|
|
"padding: 2px 4px;"
|
|
|
"background-color: #f5f5f5;" // 只读背景色
|
|
|
"font-size: 12px;"
|
|
|
"color: #333;"
|
|
|
"}"
|
|
|
);
|
|
|
|
|
|
dSkinLayout->addWidget(dSkinLabel);
|
|
|
dSkinLayout->addWidget(m_pDSkinDqEdit);
|
|
|
dSkinLayout->addStretch();
|
|
|
|
|
|
// 将两行添加到垂直布局
|
|
|
editLayout->addLayout(skinLayout);
|
|
|
editLayout->addLayout(dSkinLayout);
|
|
|
|
|
|
// 设置容器大小
|
|
|
editContainer->setFixedSize(180, 60);
|
|
|
editContainer->setStyleSheet(
|
|
|
"QWidget {"
|
|
|
"background-color: transparent;"
|
|
|
"border: none;"
|
|
|
"}"
|
|
|
);
|
|
|
|
|
|
// 将容器添加到工具栏布局，在复选框之前
|
|
|
int checkboxIndex = m_pToolbarLayout->count() - 1;
|
|
|
m_pToolbarLayout->insertWidget(checkboxIndex, editContainer);
|
|
|
|
|
|
// 保存引用以便后续控制显示/隐藏
|
|
|
m_pEditContainer = editContainer;
|
|
|
m_pSkinLabel = skinLabel;
|
|
|
m_pDSkinLabel = dSkinLabel;
|
|
|
|
|
|
// 初始时隐藏
|
|
|
editContainer->setVisible(false);
|
|
|
}
|
|
|
|
|
|
QIcon nmWxTimeDependentSkin::createTriangleIcon()
|
|
|
{
|
|
|
QPixmap trianglePixmap(16, 16);
|
|
|
trianglePixmap.fill(Qt::transparent);
|
|
|
|
|
|
QPainter painter(&trianglePixmap);
|
|
|
painter.setRenderHint(QPainter::Antialiasing, true);
|
|
|
|
|
|
// 绘制小三角形（指向右的箭头）
|
|
|
QPolygon triangle;
|
|
|
triangle << QPoint(4, 6) << QPoint(4, 10) << QPoint(10, 8);
|
|
|
painter.setBrush(QBrush(QColor(0, 0, 0))); // 黑色三角形
|
|
|
painter.setPen(QPen(QColor(0, 0, 0), 1));
|
|
|
painter.drawPolygon(triangle);
|
|
|
|
|
|
return QIcon(trianglePixmap);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onTableDataChanged(int row, int column)
|
|
|
{
|
|
|
if(row == 0) return;
|
|
|
|
|
|
// 如果显示日期模式，禁止编辑时间列
|
|
|
if(column == 1 && m_perforationData.isShowDatesEnabled()) {
|
|
|
// 恢复原值
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
int segRow = row - 1;
|
|
|
|
|
|
if(segRow >= 0 && segRow < segments.size()) {
|
|
|
double startHr = segments[segRow].segmentStart.getValue().toDouble();
|
|
|
QString timeDisplay = formatTimeDisplay(startHr, segRow);
|
|
|
QTableWidgetItem* item = m_pDataTable->item(row, column);
|
|
|
|
|
|
if(item) {
|
|
|
item->setText(timeDisplay);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
int segRow = row - 1;
|
|
|
|
|
|
if(segRow < 0 || segRow >= segments.size()) return;
|
|
|
|
|
|
QTableWidgetItem* item = m_pDataTable->item(row, column);
|
|
|
|
|
|
if(!item) return;
|
|
|
|
|
|
if(column == 1) {
|
|
|
if(segRow == 0) {
|
|
|
// 第一个段不允许改：按“秒量化”后的原值回显
|
|
|
double origHr = segments[segRow].segmentStart.getValue().toDouble();
|
|
|
double origSec = toSeconds(origHr, "hr");
|
|
|
double origDisp = fromSeconds(origSec, m_timeDisplayUnit);
|
|
|
item->setText(QString::number(origDisp, 'f', 5));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
bool ok = false;
|
|
|
double newStartDisp = item->text().toDouble(&ok);
|
|
|
|
|
|
if(!ok || newStartDisp < 0) {
|
|
|
double origHr = segments[segRow].segmentStart.getValue().toDouble();
|
|
|
double origSec = toSeconds(origHr, "hr");
|
|
|
double origDisp = fromSeconds(origSec, m_timeDisplayUnit);
|
|
|
item->setText(QString::number(origDisp, 'f', 5));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// —— 把用户输入的“显示单位”量值 -> 秒，并四舍五入到整数秒 ——
|
|
|
double newStartSec = toSeconds(newStartDisp, m_timeDisplayUnit);
|
|
|
|
|
|
// 邻接边界（以秒为基准）并做最小/最大约束
|
|
|
double minHr = (segRow > 1) ? segments[segRow - 1].segmentStart.getValue().toDouble() + 0.001 : 0.001;
|
|
|
double maxHr = (segRow < segments.size() - 1)
|
|
|
? segments[segRow + 1].segmentStart.getValue().toDouble() - 0.001
|
|
|
: m_currentWell->getTotalTimeRange();
|
|
|
|
|
|
double minSec = toSeconds(minHr, "hr");
|
|
|
double maxSec = toSeconds(maxHr, "hr");
|
|
|
|
|
|
if(newStartSec <= minSec || newStartSec >= maxSec) {
|
|
|
double origHr = segments[segRow].segmentStart.getValue().toDouble();
|
|
|
double origSec = toSeconds(origHr, "hr");
|
|
|
double origDisp = fromSeconds(origSec, m_timeDisplayUnit);
|
|
|
item->setText(QString::number(origDisp, 'f', 5));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// “吸附到流量阶梯边界”的逻辑仍使用小时接口，但最终回到“秒并量化”
|
|
|
double finalSec = newStartSec;
|
|
|
|
|
|
if(m_pSnapToRateChangesCheckBox->isChecked()) {
|
|
|
double guessHr = fromSeconds(newStartSec, "hr");
|
|
|
double snappedHr = m_currentWell->findSmartFlowStepBoundary(guessHr);
|
|
|
|
|
|
// 如果吸附点越界，选择最合适的边界
|
|
|
double snappedSec = toSeconds(snappedHr, "hr");
|
|
|
|
|
|
if(snappedSec <= minSec || snappedSec >= maxSec) {
|
|
|
QVector<double> boundaries = m_currentWell->getAllFlowStepBoundaries();
|
|
|
double bestSec = newStartSec, minDist = 1e20;
|
|
|
|
|
|
for(int i = 0; i < boundaries.size(); ++i) {
|
|
|
double bSec = toSeconds(boundaries[i], "hr");
|
|
|
|
|
|
if(bSec > minSec && bSec < maxSec) {
|
|
|
double d = qAbs(bSec - newStartSec);
|
|
|
|
|
|
if(d < minDist) {
|
|
|
minDist = d;
|
|
|
bestSec = bSec;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
snappedSec = bestSec;
|
|
|
}
|
|
|
|
|
|
finalSec = snappedSec;
|
|
|
}
|
|
|
|
|
|
// 夹逼（保险）
|
|
|
finalSec = qMax(minSec, qMin(maxSec, finalSec));
|
|
|
|
|
|
if(moveFlowSegmentBoundarySec(segRow, finalSec)) {
|
|
|
double finalDisp = fromSeconds(finalSec, m_timeDisplayUnit);
|
|
|
item->setText(QString::number(finalDisp, 'f', 5));
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
} else {
|
|
|
double origHr = segments[segRow].segmentStart.getValue().toDouble();
|
|
|
double origSec = toSeconds(origHr, "hr");
|
|
|
double origDisp = fromSeconds(origSec, m_timeDisplayUnit);
|
|
|
item->setText(QString::number(origDisp, 'f', 5));
|
|
|
}
|
|
|
|
|
|
if(m_pChartWidget) m_pChartWidget->regenerateCrossMarkPoints();
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
|
|
|
if(column == 2) {
|
|
|
bool ok;
|
|
|
double newSkinValue = item->text().toDouble(&ok);
|
|
|
|
|
|
if(!ok) {
|
|
|
double originalValue = segments[segRow].skinValue.getValue().toDouble();
|
|
|
item->setText(QString::number(originalValue, 'f', 5));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
segments[segRow].skinValue.setValue(QString::number(newSkinValue, 'f', 5));
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
item->setText(QString::number(newSkinValue, 'f', 5));
|
|
|
|
|
|
if(m_pChartWidget) m_pChartWidget->regenerateCrossMarkPoints();
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const bool enableRateDep = m_perforationData.isRateDependentEnabled();
|
|
|
const int dsdqCol = enableRateDep ? 3 : -1;
|
|
|
|
|
|
if(enableRateDep && column == dsdqCol) {
|
|
|
bool ok = false;
|
|
|
double dispVal = item->text().toDouble(&ok);
|
|
|
|
|
|
if(!ok) {
|
|
|
// 回退显示
|
|
|
double base = segments[segRow].dSdQ.getValue().toDouble();
|
|
|
double disp = convertDSdQ(base, "1/B/D", m_dSdQDisplayUnit);
|
|
|
item->setText(QString::number(disp, 'f', 5));
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 转回“内部基准单位 1/B/D”存储
|
|
|
double base = convertDSdQ(dispVal, m_dSdQDisplayUnit, "1/B/D");
|
|
|
segments[segRow].dSdQ.setValue(QString::number(base, 'f', 5));
|
|
|
// 强制其单位为基准（可选：不设置也行，因为我们按基准解读）
|
|
|
segments[segRow].dSdQ.setUnit("1/B/D");
|
|
|
|
|
|
// 写回数据类
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
|
|
|
// 再把显示值（按当前显示单位）回填一次，确保格式
|
|
|
double disp = convertDSdQ(base, "1/B/D", m_dSdQDisplayUnit);
|
|
|
item->setText(QString::number(disp, 'f', 5));
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onTableRowClicked(int row, int column)
|
|
|
{
|
|
|
if(row == 0 || m_isAddMode || m_isRemoveMode) return;
|
|
|
|
|
|
int segRow = row - 1;
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segRow < 0 || segRow >= segments.size() || segments[segRow].isSelected) return;
|
|
|
|
|
|
selectFlowSegment(segRow);
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onRightInsertClicked()
|
|
|
{
|
|
|
// 获取当前选中的流动段索引（从本地副本）
|
|
|
int selectedIndex = m_perforationData.getSelectedSegmentIndex();
|
|
|
const QVector<FlowSegmentData>& segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
// 检查是否有有效的选中段
|
|
|
if(selectedIndex < 0 || selectedIndex >= segments.size()) {
|
|
|
return; // 没有选中有效的段
|
|
|
}
|
|
|
|
|
|
// 检查是否为第一个段（第一个段之前无法插入）
|
|
|
if(selectedIndex == 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
bool success = false;
|
|
|
|
|
|
// 检查"Snap to rate changes"复选框状态
|
|
|
bool snapToRateChanges = m_pSnapToRateChangesCheckBox->isChecked();
|
|
|
|
|
|
if(snapToRateChanges) {
|
|
|
// 勾选状态：在前一个段中的流量阶梯边界处插入
|
|
|
success = insertFlowSegmentBeforeSegment(selectedIndex);
|
|
|
} else {
|
|
|
// 未勾选状态：在前一个段的中间位置插入
|
|
|
success = insertFlowSegmentAtMiddle(selectedIndex);
|
|
|
}
|
|
|
|
|
|
if(success) {
|
|
|
// 更新图表和表格显示
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
|
|
|
// 如果交互式图表存在，更新×标记
|
|
|
if(m_pChartWidget != nullptr) {
|
|
|
m_pChartWidget->regenerateCrossMarkPoints();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onRightAddClicked()
|
|
|
{
|
|
|
// 检查"Snap to rate changes"复选框状态
|
|
|
bool snapToRateChanges = m_pSnapToRateChangesCheckBox->isChecked();
|
|
|
|
|
|
// 执行添加流动段的操作
|
|
|
addLastFlowSegmentIfMissing(snapToRateChanges);
|
|
|
|
|
|
// 更新图表和表格显示
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onRightDeleteClicked()
|
|
|
{
|
|
|
// 获取当前选中的流动段索引（从本地副本）
|
|
|
int selectedIndex = m_perforationData.getSelectedSegmentIndex();
|
|
|
const QVector<FlowSegmentData>& segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
// 检查是否有有效的选中段
|
|
|
if(selectedIndex < 0 || selectedIndex >= segments.size()) {
|
|
|
return; // 没有选中有效的段
|
|
|
}
|
|
|
|
|
|
// 检查是否为第一个段
|
|
|
if(selectedIndex == 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 检查是否只剩一个段
|
|
|
if(segments.size() <= 1) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 执行向左合并操作
|
|
|
bool success = mergeSegmentWithPrevious(selectedIndex);
|
|
|
|
|
|
if(success) {
|
|
|
// 更新图表和表格显示
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onPerforationChanged(int index)
|
|
|
{
|
|
|
if(!m_currentWell || index < 0 || index >= m_currentWell->getPerforationCount()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 如果选择的是当前射孔段，无需切换
|
|
|
if(index == m_currentPerforationIndex) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 保存当前射孔段的修改到井数据中
|
|
|
m_currentWell->updatePerforation(m_currentPerforationIndex, m_perforationData);
|
|
|
|
|
|
// 切换到新的射孔段
|
|
|
m_currentPerforationIndex = index;
|
|
|
m_perforationData = m_currentWell->getPerforationCopy(index);
|
|
|
|
|
|
// 如果副本为空，初始化默认数据
|
|
|
if(m_perforationData.getFlowSegments().isEmpty()) {
|
|
|
initializeDefaultFlowSegment();
|
|
|
}
|
|
|
|
|
|
// 确保副本有默认的表皮系数数据
|
|
|
if(m_perforationData.getSkin0().getValue().toString().isEmpty()) {
|
|
|
m_perforationData.getSkin0().setValue("0.0");
|
|
|
}
|
|
|
|
|
|
if(m_perforationData.getdSkindq().getValue().toString().isEmpty()) {
|
|
|
m_perforationData.getdSkindq().setValue("0.0");
|
|
|
}
|
|
|
|
|
|
// 确保线条位置有默认值
|
|
|
double x1, y1, x2, y2;
|
|
|
m_perforationData.getLinePositions(x1, y1, x2, y2);
|
|
|
|
|
|
if(x1 == -999.0 || y1 == -999.0 || x2 == -999.0 || y2 == -999.0) {
|
|
|
m_perforationData.setLinePositions(100.0, 0.0, 200.0, 0.0);
|
|
|
}
|
|
|
|
|
|
// 更新UI显示
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onBoundaryMoved(int segmentIndex, double newTime)
|
|
|
{
|
|
|
// 获取信号发送者
|
|
|
QObject* sender = QObject::sender();
|
|
|
|
|
|
// 根据发送者决定需要更新哪个图表
|
|
|
if(sender == m_pPressureChart && m_pFlowRateChart) {
|
|
|
// 压力图发送的信号，更新流量图的外部拖动状态
|
|
|
m_pFlowRateChart->setExternalDragState(true, segmentIndex, newTime);
|
|
|
} else if(sender == m_pFlowRateChart && m_pPressureChart) {
|
|
|
// 流量图发送的信号，更新压力图的外部拖动状态
|
|
|
m_pPressureChart->setExternalDragState(true, segmentIndex, newTime);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onBoundaryMovedFinal(int segmentIndex, double newTime)
|
|
|
{
|
|
|
// 先转成秒并四舍五入
|
|
|
double newSec = toSeconds(newTime, "hr");
|
|
|
bool success = moveFlowSegmentBoundarySec(segmentIndex, newSec);
|
|
|
|
|
|
if(success) {
|
|
|
if(m_pPressureChart) m_pPressureChart->clearExternalDragState();
|
|
|
|
|
|
if(m_pFlowRateChart) m_pFlowRateChart->clearExternalDragState();
|
|
|
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
} else {
|
|
|
if(m_pPressureChart) m_pPressureChart->clearExternalDragState();
|
|
|
|
|
|
if(m_pFlowRateChart) m_pFlowRateChart->clearExternalDragState();
|
|
|
|
|
|
updateCharts();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::insertFlowSegmentAtMiddle(int segmentIndex)
|
|
|
{
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segmentIndex <= 0 || segmentIndex >= segments.size()) {
|
|
|
return false; // 第一个段或无效索引，无法在前面插入
|
|
|
}
|
|
|
|
|
|
// 获取前一个段的信息
|
|
|
int prevSegmentIndex = segmentIndex - 1;
|
|
|
const FlowSegmentData& prevSegment = segments[prevSegmentIndex];
|
|
|
double prevSegmentStartTime = prevSegment.segmentStart.getValue().toDouble();
|
|
|
double prevSegmentEndTime = prevSegment.segmentEnd.getValue().toDouble();
|
|
|
|
|
|
// 检查前一个段是否足够大可以分割（最小间隔0.001小时）
|
|
|
if(prevSegmentEndTime - prevSegmentStartTime <= 0.002) {
|
|
|
return false; // 前一个段太小，无法分割
|
|
|
}
|
|
|
|
|
|
// 计算前一个段的中间时间点
|
|
|
double middleTime = (prevSegmentStartTime + prevSegmentEndTime) / 2.0;
|
|
|
|
|
|
// 保存前一个段的原始属性
|
|
|
double originalSkinValue = prevSegment.skinValue.getValue().toDouble();
|
|
|
double originalDSdQValue = prevSegment.dSdQ.getValue().toDouble();
|
|
|
bool wasSelected = prevSegment.isSelected;
|
|
|
|
|
|
// 创建第一个流动段（前一个段的前半部分，保留原值）
|
|
|
nmDataAttribute newStartTime1("StartTime", prevSegmentStartTime, "hr");
|
|
|
nmDataAttribute newSkinValue1("SkinValue", originalSkinValue, ""); // 保留原来的skin值
|
|
|
nmDataAttribute newSegmentStart1("SegmentStartTime", prevSegmentStartTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd1("SegmentEndTime", middleTime, "hr");
|
|
|
|
|
|
// 创建第二个流动段（前一个段的后半部分，这是新插入的段，值设为0）
|
|
|
nmDataAttribute newStartTime2("StartTime", middleTime, "hr");
|
|
|
nmDataAttribute newSkinValue2("SkinValue", 0.0, ""); // 新插入的段默认skin值为0
|
|
|
nmDataAttribute newSegmentStart2("SegmentStartTime", middleTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd2("SegmentEndTime", prevSegmentEndTime, "hr");
|
|
|
|
|
|
FlowSegmentData segment1, segment2;
|
|
|
|
|
|
// 根据是否启用流量相关功能来决定如何创建段
|
|
|
if(m_perforationData.isRateDependentEnabled()) {
|
|
|
// 启用了流量相关功能，需要处理dSdQ值
|
|
|
nmDataAttribute newDSdQ1("dSdQ", originalDSdQValue, "1/B/D"); // 第一个段保留原来的dSdQ值
|
|
|
nmDataAttribute newDSdQ2("dSdQ", 0.0, "1/B/D"); // 第二个段的dSdQ值为0
|
|
|
|
|
|
segment1 = FlowSegmentData(newStartTime1, newSkinValue1, newSegmentStart1, newSegmentEnd1, newDSdQ1, wasSelected);
|
|
|
segment2 = FlowSegmentData(newStartTime2, newSkinValue2, newSegmentStart2, newSegmentEnd2, newDSdQ2, false); // 新段不选中
|
|
|
} else {
|
|
|
// 未启用流量相关功能，使用不包含dSdQ的构造函数
|
|
|
segment1 = FlowSegmentData(newStartTime1, newSkinValue1, newSegmentStart1, newSegmentEnd1, wasSelected);
|
|
|
segment2 = FlowSegmentData(newStartTime2, newSkinValue2, newSegmentStart2, newSegmentEnd2, false); // 新段不选中
|
|
|
}
|
|
|
|
|
|
// 替换前一个段为两个新段
|
|
|
segments.remove(prevSegmentIndex);
|
|
|
segments.insert(prevSegmentIndex, segment1);
|
|
|
segments.insert(prevSegmentIndex + 1, segment2);
|
|
|
|
|
|
// 更新流动段数据
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
|
|
|
// 选中新插入的段（segment2）
|
|
|
selectFlowSegment(prevSegmentIndex + 1);
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onSegmentsMerged(int segmentIndex)
|
|
|
{
|
|
|
bool success = mergeSegmentWithPrevious(segmentIndex);
|
|
|
|
|
|
if(success) {
|
|
|
if(m_pPressureChart) m_pPressureChart->clearExternalDragState();
|
|
|
|
|
|
if(m_pFlowRateChart) m_pFlowRateChart->clearExternalDragState();
|
|
|
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onSnapToRateChangesToggled(bool checked)
|
|
|
{
|
|
|
// 保存状态到数据对象
|
|
|
m_perforationData.setSnapToRateChangesEnabled(checked);
|
|
|
|
|
|
// 原来的同步设置
|
|
|
if(m_pPressureChart) m_pPressureChart->setSnapToRateChanges(checked);
|
|
|
|
|
|
if(m_pFlowRateChart) m_pFlowRateChart->setSnapToRateChanges(checked);
|
|
|
|
|
|
if(m_pChartWidget) m_pChartWidget->setSnapToRateChanges(checked);
|
|
|
|
|
|
// 当勾选时，立即把现有所有分界线吸附到阶梯，并自动合并重复
|
|
|
if(checked) {
|
|
|
snapAllBoundariesToFlowStepsAndMerge();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
void nmWxTimeDependentSkin::onFilterClicked()
|
|
|
{
|
|
|
// 只在图表模式下才能使用filter功能
|
|
|
if(m_pChartWidget == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 如果已经在套索模式，忽略点击（防止重复操作）
|
|
|
if(m_pChartWidget->getLassoMode()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 进入套索模式（一次性操作）
|
|
|
m_pChartWidget->setLassoMode(true);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
void nmWxTimeDependentSkin::onResetFilterClicked()
|
|
|
{
|
|
|
// 只在图表模式下才能使用reset filter功能
|
|
|
if(m_pChartWidget == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 调用图表widget的重置所有×标记点方法
|
|
|
m_pChartWidget->resetAllCrossMarks();
|
|
|
|
|
|
// 保存重置后的位置到数据对象
|
|
|
saveChartPositionsToData();
|
|
|
|
|
|
// 更新编辑框显示
|
|
|
updateEditBoxesFromData();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onResetLinesClicked()
|
|
|
{
|
|
|
if(m_pChartWidget != nullptr) {
|
|
|
// 调用图表widget的重置方法，让它自己决定重置位置
|
|
|
m_pChartWidget->resetLinesToInitialPositions();
|
|
|
|
|
|
// 保存重置后的位置
|
|
|
saveChartPositionsToData();
|
|
|
|
|
|
// 更新编辑框显示
|
|
|
updateEditBoxesFromData();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onAccept()
|
|
|
{
|
|
|
if(!m_currentWell) {
|
|
|
accept();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 副本数据同步回原始射孔段
|
|
|
m_currentWell->updatePerforation(m_currentPerforationIndex, m_perforationData);
|
|
|
|
|
|
accept();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onReject()
|
|
|
{
|
|
|
reject();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::initializeDefaultFlowSegment()
|
|
|
{
|
|
|
if(m_currentWell == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QVector<QPointF> flowPoints = m_currentWell->getFlowPoints();
|
|
|
|
|
|
if(flowPoints.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 计算总时间
|
|
|
double totalTime = m_currentWell->getTotalTimeRange();
|
|
|
|
|
|
// 创建一个覆盖整个时间范围的默认流动段，初始状态为选中
|
|
|
QVector<FlowSegmentData> segments;
|
|
|
nmDataAttribute startTime("StartTime", 0.0, "hr");
|
|
|
nmDataAttribute skinValue("SkinValue", 0.0, "");
|
|
|
nmDataAttribute segmentStart("SegmentStartTime", 0.0, "hr");
|
|
|
nmDataAttribute segmentEnd("SegmentEndTime", totalTime, "hr");
|
|
|
|
|
|
FlowSegmentData defaultSegment;
|
|
|
|
|
|
// 根据是否启用流量相关功能来决定如何创建默认段
|
|
|
if(m_perforationData.isRateDependentEnabled()) {
|
|
|
nmDataAttribute dSdQ("dSdQ", 0.0, "1/B/D");
|
|
|
defaultSegment = FlowSegmentData(startTime, skinValue, segmentStart, segmentEnd, dSdQ, true);
|
|
|
} else {
|
|
|
defaultSegment = FlowSegmentData(startTime, skinValue, segmentStart, segmentEnd, true);
|
|
|
}
|
|
|
|
|
|
segments.append(defaultSegment);
|
|
|
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
m_perforationData.setSelectedSegmentIndex(0);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::splitSelectedFlowSegment()
|
|
|
{
|
|
|
int selectedIndex = m_perforationData.getSelectedSegmentIndex();
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(selectedIndex < 0 || selectedIndex >= segments.size()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 检查选中的流动段是否可以分割
|
|
|
if(!m_currentWell->canFlowSegmentBeSplit(selectedIndex, m_currentPerforationIndex)) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const FlowSegmentData& selectedSegment = segments[selectedIndex];
|
|
|
double segmentStartTime = selectedSegment.segmentStart.getValue().toDouble();
|
|
|
double segmentEndTime = selectedSegment.segmentEnd.getValue().toDouble();
|
|
|
|
|
|
// 获取该段内的流量阶梯
|
|
|
QVector<QPointF> flowSteps = m_currentWell->getFlowStepsInTimeRange(segmentStartTime, segmentEndTime);
|
|
|
|
|
|
if(flowSteps.size() <= 1) {
|
|
|
return; // 只有一个或没有阶梯段，无法分割
|
|
|
}
|
|
|
|
|
|
// 第一个阶梯段的结束时间就是分割点
|
|
|
double firstStepDuration = flowSteps[0].x();
|
|
|
double splitTime = segmentStartTime + firstStepDuration;
|
|
|
|
|
|
// 创建第一个流动段（第一个阶梯段）
|
|
|
nmDataAttribute newStartTime1("StartTime", segmentStartTime, "hr");
|
|
|
nmDataAttribute newSkinValue1("SkinValue", 0.0, "");
|
|
|
nmDataAttribute newSegmentStart1("SegmentStartTime", segmentStartTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd1("SegmentEndTime", splitTime, "hr");
|
|
|
FlowSegmentData segment1(newStartTime1, newSkinValue1, newSegmentStart1, newSegmentEnd1, true); // 新分离的段自动选中
|
|
|
|
|
|
// 创建第二个流动段（剩余的阶梯段）
|
|
|
nmDataAttribute newStartTime2("StartTime", splitTime, "hr");
|
|
|
nmDataAttribute newSkinValue2("SkinValue", 0.0, "");
|
|
|
nmDataAttribute newSegmentStart2("SegmentStartTime", splitTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd2("SegmentEndTime", segmentEndTime, "hr");
|
|
|
FlowSegmentData segment2(newStartTime2, newSkinValue2, newSegmentStart2, newSegmentEnd2, false);
|
|
|
|
|
|
// 替换原来的段
|
|
|
segments[selectedIndex] = segment1;
|
|
|
segments.insert(selectedIndex + 1, segment2);
|
|
|
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
m_perforationData.setSelectedSegmentIndex(selectedIndex); // 选中新分离出来的第一段
|
|
|
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::selectFlowSegment(int segmentIndex)
|
|
|
{
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segmentIndex < 0 || segmentIndex >= segments.size()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 取消所有段的选中状态
|
|
|
for(int i = 0; i < segments.size(); ++i) {
|
|
|
segments[i].isSelected = (i == segmentIndex);
|
|
|
}
|
|
|
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
m_perforationData.setSelectedSegmentIndex(segmentIndex);
|
|
|
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::splitAllFlowSegments()
|
|
|
{
|
|
|
QVector<double> flowStepBoundaries = m_currentWell->getAllFlowStepBoundaries();
|
|
|
|
|
|
if(flowStepBoundaries.isEmpty()) return;
|
|
|
|
|
|
// 统一量化
|
|
|
for(int i = 0; i < flowStepBoundaries.size(); ++i) {
|
|
|
double sec = toSeconds(flowStepBoundaries[i], "hr");
|
|
|
flowStepBoundaries[i] = fromSeconds(sec, "hr");
|
|
|
}
|
|
|
|
|
|
qSort(flowStepBoundaries);
|
|
|
|
|
|
// 按"秒"去重：把<=1秒的间隔视为重复
|
|
|
const double dedupEpsSec = 1.0;
|
|
|
QVector<double> uniq;
|
|
|
|
|
|
for(int i = 0; i < flowStepBoundaries.size(); ++i) {
|
|
|
if(uniq.isEmpty()) {
|
|
|
uniq.push_back(flowStepBoundaries[i]);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
double lastSec = toSeconds(uniq.back(), "hr");
|
|
|
double curSec = toSeconds(flowStepBoundaries[i], "hr");
|
|
|
|
|
|
if(qAbs(curSec - lastSec) > dedupEpsSec) uniq.push_back(flowStepBoundaries[i]);
|
|
|
}
|
|
|
|
|
|
if(uniq.size() < 2) return;
|
|
|
|
|
|
QVector<FlowSegmentData> newSegments;
|
|
|
|
|
|
for(int i = 0; i < uniq.size() - 1; ++i) {
|
|
|
double startTime = uniq[i];
|
|
|
double endTime = uniq[i + 1];
|
|
|
|
|
|
// 额外再做一次量化保险
|
|
|
double startSec = toSeconds(startTime, "hr");
|
|
|
double endSec = toSeconds(endTime, "hr");
|
|
|
startTime = fromSeconds(startSec, "hr");
|
|
|
endTime = fromSeconds(endSec, "hr");
|
|
|
|
|
|
// 修改：所有skin值都重置为0，不再保留原值
|
|
|
double resetSkinValue = 0.0;
|
|
|
|
|
|
nmDataAttribute newStartTime("StartTime", startTime, "hr");
|
|
|
nmDataAttribute newSkinValue("SkinValue", resetSkinValue, "");
|
|
|
nmDataAttribute newSegmentStart("SegmentStartTime", startTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd("SegmentEndTime", endTime, "hr");
|
|
|
bool selected = (i == 0);
|
|
|
|
|
|
FlowSegmentData newSegment;
|
|
|
|
|
|
// 根据是否启用流量相关功能来决定如何创建段
|
|
|
if(m_perforationData.isRateDependentEnabled()) {
|
|
|
// 启用了流量相关功能，需要创建带有dSdQ的段，并将dSdQ重置为0
|
|
|
nmDataAttribute newDSdQ("dSdQ", 0.0, "1/B/D"); // dSdQ也重置为0
|
|
|
newSegment = FlowSegmentData(newStartTime, newSkinValue, newSegmentStart, newSegmentEnd, newDSdQ, selected);
|
|
|
} else {
|
|
|
// 未启用流量相关功能，使用不包含dSdQ的构造函数
|
|
|
newSegment = FlowSegmentData(newStartTime, newSkinValue, newSegmentStart, newSegmentEnd, selected);
|
|
|
}
|
|
|
|
|
|
newSegments.append(newSegment);
|
|
|
}
|
|
|
|
|
|
for(int i = 0; i < newSegments.size(); ++i) newSegments[i].isSelected = (i == 0);
|
|
|
|
|
|
m_perforationData.setFlowSegments(newSegments);
|
|
|
m_perforationData.setSelectedSegmentIndex(0);
|
|
|
}
|
|
|
|
|
|
int nmWxTimeDependentSkin::splitFlowSegmentAtIndex(int segmentIndex)
|
|
|
{
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segmentIndex < 0 || segmentIndex >= segments.size()) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 检查该段是否可以分割
|
|
|
if(!m_currentWell->canFlowSegmentBeSplit(segmentIndex, m_currentPerforationIndex)) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
const FlowSegmentData& selectedSegment = segments[segmentIndex];
|
|
|
double segmentStartTime = selectedSegment.segmentStart.getValue().toDouble();
|
|
|
|
|
|
// 获取该段内所有流量阶梯的分界点
|
|
|
QVector<double> boundaries = m_currentWell->getFlowStepBoundariesInSegment(segmentIndex, m_currentPerforationIndex);
|
|
|
|
|
|
if(boundaries.size() <= 1) {
|
|
|
return 0; // 没有分界点或只有一个分界点，无法分割
|
|
|
}
|
|
|
|
|
|
// 移除原来的段
|
|
|
segments.remove(segmentIndex);
|
|
|
|
|
|
// 根据分界点创建新的流动段
|
|
|
int newSegmentsCount = 0;
|
|
|
|
|
|
for(int i = 0; i < boundaries.size(); ++i) {
|
|
|
double currentStart = (i == 0) ? segmentStartTime : boundaries[i - 1];
|
|
|
double currentEnd = boundaries[i];
|
|
|
|
|
|
// 创建新的流动段
|
|
|
nmDataAttribute newStartTime("StartTime", currentStart, "hr");
|
|
|
nmDataAttribute newSkinValue("SkinValue", 0.0, "");
|
|
|
nmDataAttribute newSegmentStart("SegmentStartTime", currentStart, "hr");
|
|
|
nmDataAttribute newSegmentEnd("SegmentEndTime", currentEnd, "hr");
|
|
|
|
|
|
// 第一个新段保持选中状态，其他取消选中
|
|
|
bool isSelected = (i == 0 && selectedSegment.isSelected);
|
|
|
FlowSegmentData newSegment(newStartTime, newSkinValue, newSegmentStart, newSegmentEnd, isSelected);
|
|
|
|
|
|
// 插入到正确的位置
|
|
|
segments.insert(segmentIndex + i, newSegment);
|
|
|
newSegmentsCount++;
|
|
|
}
|
|
|
|
|
|
// 更新流动段数据
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
|
|
|
return newSegmentsCount - 1; // 返回新增的段数量
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::addFlowSegmentAtTime(double timePoint)
|
|
|
{
|
|
|
int segmentIndex = m_perforationData.findFlowSegmentByTime(timePoint);
|
|
|
|
|
|
if(segmentIndex < 0) return false;
|
|
|
|
|
|
// 先找“阶梯结束边界（单位：小时）”
|
|
|
double stepBoundaryTime = m_currentWell->findFlowStepBoundaryAtTime(timePoint);
|
|
|
|
|
|
if(stepBoundaryTime < 0) return false;
|
|
|
|
|
|
// 量化
|
|
|
double stepBoundarySec = toSeconds(stepBoundaryTime, "hr");
|
|
|
stepBoundaryTime = fromSeconds(stepBoundarySec, "hr");
|
|
|
|
|
|
// 再取该段的结束时间做边界校验
|
|
|
const QVector<FlowSegmentData>& segments = m_perforationData.getFlowSegments();
|
|
|
double segmentEndTime = segments.at(segmentIndex).segmentEnd.getValue().toDouble();
|
|
|
|
|
|
if(stepBoundaryTime <= segments.at(segmentIndex).segmentStart.getValue().toDouble()
|
|
|
|| stepBoundaryTime >= segmentEndTime) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
return splitFlowSegmentAtTime(segmentIndex, stepBoundaryTime);
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::splitFlowSegmentAtTime(int segmentIndex, double splitTimeHr)
|
|
|
{
|
|
|
// 统一量化到整秒，再回到小时
|
|
|
double splitSec = toSeconds(splitTimeHr, "hr");
|
|
|
double splitTime = fromSeconds(splitSec, "hr");
|
|
|
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segmentIndex < 0 || segmentIndex >= segments.count()) return false;
|
|
|
|
|
|
const FlowSegmentData& originalSegment = segments.at(segmentIndex);
|
|
|
double segmentStartTime = originalSegment.segmentStart.getValue().toDouble();
|
|
|
double segmentEndTime = originalSegment.segmentEnd.getValue().toDouble();
|
|
|
|
|
|
if(splitTime <= segmentStartTime || splitTime >= segmentEndTime) return false;
|
|
|
|
|
|
// 获取原段的skin值和dSdQ值，用于保留给第一个新段
|
|
|
double originalSkinValue = originalSegment.skinValue.getValue().toDouble();
|
|
|
double originalDSdQValue = originalSegment.dSdQ.getValue().toDouble();
|
|
|
|
|
|
// 第一个新段（保留原段的值，选中）
|
|
|
nmDataAttribute newStartTime1("StartTime", segmentStartTime, "hr");
|
|
|
nmDataAttribute newSkinValue1("SkinValue", originalSkinValue, ""); // 保留原来的skin值
|
|
|
nmDataAttribute newSegmentStart1("SegmentStartTime", segmentStartTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd1("SegmentEndTime", splitTime, "hr");
|
|
|
|
|
|
// 第二个新段（新增段，值设为0，不选中）
|
|
|
nmDataAttribute newStartTime2("StartTime", splitTime, "hr");
|
|
|
nmDataAttribute newSkinValue2("SkinValue", 0.0, ""); // 新增段的skin值为0
|
|
|
nmDataAttribute newSegmentStart2("SegmentStartTime", splitTime, "hr");
|
|
|
nmDataAttribute newSegmentEnd2("SegmentEndTime", segmentEndTime, "hr");
|
|
|
|
|
|
FlowSegmentData segment1, segment2;
|
|
|
|
|
|
// 根据是否启用流量相关功能来决定如何创建段
|
|
|
if(m_perforationData.isRateDependentEnabled()) {
|
|
|
// 启用了流量相关功能，需要处理dSdQ值
|
|
|
nmDataAttribute newDSdQ1("dSdQ", originalDSdQValue, "1/B/D"); // 第一个段保留原来的dSdQ值
|
|
|
nmDataAttribute newDSdQ2("dSdQ", 0.0, "1/B/D"); // 第二个段的dSdQ值为0
|
|
|
|
|
|
segment1 = FlowSegmentData(newStartTime1, newSkinValue1, newSegmentStart1, newSegmentEnd1, newDSdQ1, true);
|
|
|
segment2 = FlowSegmentData(newStartTime2, newSkinValue2, newSegmentStart2, newSegmentEnd2, newDSdQ2, false);
|
|
|
} else {
|
|
|
// 未启用流量相关功能，使用不包含dSdQ的构造函数
|
|
|
segment1 = FlowSegmentData(newStartTime1, newSkinValue1, newSegmentStart1, newSegmentEnd1, true);
|
|
|
segment2 = FlowSegmentData(newStartTime2, newSkinValue2, newSegmentStart2, newSegmentEnd2, false);
|
|
|
}
|
|
|
|
|
|
segments.remove(segmentIndex);
|
|
|
segments.insert(segmentIndex, segment1);
|
|
|
segments.insert(segmentIndex + 1, segment2);
|
|
|
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
selectFlowSegment(segmentIndex);
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::mergeSegmentWithPrevious(int segmentIndex)
|
|
|
{
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
// 检查索引有效性
|
|
|
if(segmentIndex <= 0 || segmentIndex >= segments.size()) {
|
|
|
return false; // 第一个段无法与前段合并
|
|
|
}
|
|
|
|
|
|
// 获取要合并的段和前一个段
|
|
|
const FlowSegmentData& currentSegment = segments[segmentIndex];
|
|
|
const FlowSegmentData& prevSegment = segments[segmentIndex - 1];
|
|
|
|
|
|
// 创建合并后的新段
|
|
|
double newStartTime = prevSegment.segmentStart.getValue().toDouble();
|
|
|
double newEndTime = currentSegment.segmentEnd.getValue().toDouble();
|
|
|
double prevSkinValue = prevSegment.skinValue.getValue().toDouble();
|
|
|
|
|
|
// 判断选中状态：如果任一段被选中，则合并后的段被选中
|
|
|
bool mergedIsSelected = prevSegment.isSelected || currentSegment.isSelected;
|
|
|
|
|
|
// 创建新的流动段属性
|
|
|
nmDataAttribute mergedStartTime("StartTime", newStartTime, "hr");
|
|
|
nmDataAttribute mergedSkinValue("SkinValue", prevSkinValue, "");
|
|
|
nmDataAttribute mergedSegmentStart("SegmentStartTime", newStartTime, "hr");
|
|
|
nmDataAttribute mergedSegmentEnd("SegmentEndTime", newEndTime, "hr");
|
|
|
|
|
|
FlowSegmentData mergedSegment;
|
|
|
|
|
|
// 根据是否启用流量相关功能来决定如何处理dSdQ
|
|
|
if(m_perforationData.isRateDependentEnabled()) {
|
|
|
// 启用了流量相关功能，需要处理dSdQ值
|
|
|
nmDataAttribute mergedDSdQ;
|
|
|
|
|
|
if(currentSegment.isSelected && !prevSegment.isSelected) {
|
|
|
// 当前段被选中，前一个段未选中 -> 保留左边(前一个段)的dSdQ
|
|
|
mergedDSdQ = prevSegment.dSdQ;
|
|
|
} else if(prevSegment.isSelected && !currentSegment.isSelected) {
|
|
|
// 前一个段被选中，当前段未选中 -> 保留选中段(前一个段)的dSdQ
|
|
|
mergedDSdQ = prevSegment.dSdQ;
|
|
|
} else if(prevSegment.isSelected && currentSegment.isSelected) {
|
|
|
// 两个段都被选中 -> 这可能是拖动合并，优先保留前一个段的dSdQ
|
|
|
mergedDSdQ = prevSegment.dSdQ;
|
|
|
} else {
|
|
|
// 两个段都未选中 -> 默认保留前一个段的dSdQ
|
|
|
mergedDSdQ = prevSegment.dSdQ;
|
|
|
}
|
|
|
|
|
|
// 使用包含dSdQ的构造函数
|
|
|
mergedSegment = FlowSegmentData(mergedStartTime, mergedSkinValue,
|
|
|
mergedSegmentStart, mergedSegmentEnd, mergedDSdQ, mergedIsSelected);
|
|
|
} else {
|
|
|
// 未启用流量相关功能，使用不包含dSdQ的构造函数（dSdQ会使用默认值）
|
|
|
mergedSegment = FlowSegmentData(mergedStartTime, mergedSkinValue,
|
|
|
mergedSegmentStart, mergedSegmentEnd, mergedIsSelected);
|
|
|
}
|
|
|
|
|
|
// 移除原来的两个段（从后往前移除，避免索引变化）
|
|
|
segments.remove(segmentIndex); // 先移除当前段
|
|
|
segments.remove(segmentIndex - 1); // 再移除前一个段
|
|
|
|
|
|
// 在原前一个段的位置插入合并后的段
|
|
|
segments.insert(segmentIndex - 1, mergedSegment);
|
|
|
|
|
|
// 更新流动段数据
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
|
|
|
// 设置选中索引为合并后的段
|
|
|
if(mergedIsSelected) {
|
|
|
m_perforationData.setSelectedSegmentIndex(segmentIndex - 1);
|
|
|
} else {
|
|
|
// 如果合并后的段没有被选中，选择第一个段（如果存在）
|
|
|
if(segments.size() > 0) {
|
|
|
selectFlowSegment(0);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::insertFlowSegmentBeforeSegment(int segmentIndex)
|
|
|
{
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segmentIndex <= 0 || segmentIndex >= segments.size()) return false;
|
|
|
|
|
|
double insertTime = m_currentWell->findNearestFlowStepBoundaryBeforeSegment(segmentIndex, m_currentPerforationIndex);
|
|
|
|
|
|
if(insertTime < 0) return false;
|
|
|
|
|
|
// 量化
|
|
|
double insertSec = toSeconds(insertTime, "hr");
|
|
|
insertTime = fromSeconds(insertSec, "hr");
|
|
|
|
|
|
int prevSegmentIndex = segmentIndex - 1;
|
|
|
bool success = splitFlowSegmentAtTime(prevSegmentIndex, insertTime);
|
|
|
|
|
|
if(success) selectFlowSegment(prevSegmentIndex + 1);
|
|
|
|
|
|
return success;
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::addLastFlowSegmentIfMissing(bool snapToRateChanges)
|
|
|
{
|
|
|
double totalTime = m_currentWell->getTotalTimeRange();
|
|
|
|
|
|
if(totalTime <= 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 如果没有任何段，初始化默认段并返回
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segments.isEmpty()) {
|
|
|
initializeDefaultFlowSegment();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 找到最后一个理想的100间隔分割点
|
|
|
double lastIdealSplitTime = -1.0;
|
|
|
|
|
|
for(double time = 100.0; time < totalTime; time += 100.0) {
|
|
|
double actualTime = time;
|
|
|
|
|
|
if(snapToRateChanges) {
|
|
|
actualTime = m_currentWell->findNearestFlowStepBoundary(time);
|
|
|
}
|
|
|
|
|
|
if(actualTime > 0 && actualTime < totalTime) {
|
|
|
lastIdealSplitTime = actualTime;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果没有找到理想分割点，说明总时间小于100，不需要添加
|
|
|
if(lastIdealSplitTime < 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 检查这个最后的理想分割点是否已经存在
|
|
|
bool exists = false;
|
|
|
|
|
|
for(int i = 0; i < segments.size(); ++i) {
|
|
|
double startTime = segments[i].segmentStart.getValue().toDouble();
|
|
|
|
|
|
if(qAbs(startTime - lastIdealSplitTime) < 1e-6) {
|
|
|
exists = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果不存在，则添加这个分割点
|
|
|
if(!exists) {
|
|
|
int segmentIndex = m_perforationData.findFlowSegmentByTime(lastIdealSplitTime);
|
|
|
|
|
|
if(segmentIndex >= 0) {
|
|
|
splitFlowSegmentAtTime(segmentIndex, lastIdealSplitTime);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::snapAllBoundariesToFlowStepsAndMerge()
|
|
|
{
|
|
|
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(segments.size() <= 1) return;
|
|
|
|
|
|
const double totalTimeHr = m_currentWell->getTotalTimeRange();
|
|
|
const double totalTimeSec = toSeconds(totalTimeHr, "hr");
|
|
|
const double epsSec = 1.0; // 以 1 秒为“重合”阈值
|
|
|
|
|
|
// 1) 吸附所有内部分界线（结果量化到秒后再回写）
|
|
|
for(int i = 1; i < segments.size(); ++i) {
|
|
|
double curBoundaryHr = segments[i].segmentStart.getValue().toDouble();
|
|
|
double snappedHr = m_currentWell->findNearestFlowStepBoundary(curBoundaryHr);
|
|
|
|
|
|
// 量化
|
|
|
double snappedSec = toSeconds(snappedHr, "hr");
|
|
|
// 边界保护
|
|
|
double nextStartHr = (i < segments.size() - 1)
|
|
|
? segments[i + 1].segmentStart.getValue().toDouble()
|
|
|
: totalTimeHr;
|
|
|
double nextStartSec = toSeconds(nextStartHr, "hr");
|
|
|
|
|
|
if(snappedSec > nextStartSec) snappedSec = nextStartSec;
|
|
|
|
|
|
if(snappedSec < 0.0) snappedSec = 0.0;
|
|
|
|
|
|
if(snappedSec > totalTimeSec) snappedSec = totalTimeSec;
|
|
|
|
|
|
double snappedHrQuant = fromSeconds(snappedSec, "hr");
|
|
|
segments[i].segmentStart.setValue(QString::number(snappedHrQuant, 'f', 5));
|
|
|
segments[i].startTime .setValue(QString::number(snappedHrQuant, 'f', 5));
|
|
|
segments[i - 1].segmentEnd.setValue(QString::number(snappedHrQuant, 'f', 5));
|
|
|
}
|
|
|
|
|
|
// 2) 清洗与合并：按“秒”判断 0 长度段
|
|
|
int selectedIdx = m_perforationData.getSelectedSegmentIndex();
|
|
|
|
|
|
for(int i = segments.size() - 1; i >= 0; --i) {
|
|
|
double stSec = toSeconds(segments[i].segmentStart.getValue().toDouble(), "hr");
|
|
|
double edSec = toSeconds(segments[i].segmentEnd.getValue().toDouble(), "hr");
|
|
|
|
|
|
if(edSec - stSec <= epsSec) {
|
|
|
if(i > 0) {
|
|
|
bool leftOrSelfSelected = segments[i - 1].isSelected || segments[i].isSelected;
|
|
|
segments.remove(i);
|
|
|
|
|
|
if(leftOrSelfSelected) selectedIdx = qMax(0, i - 1);
|
|
|
else if(selectedIdx > i) selectedIdx -= 1;
|
|
|
else if(selectedIdx == i) selectedIdx = qMax(0, i - 1);
|
|
|
} else if(segments.size() > 1) {
|
|
|
bool rightOrSelfSelected = segments[0].isSelected || segments[1].isSelected;
|
|
|
segments.remove(0);
|
|
|
// 把右段起点置 0（量化一致）
|
|
|
segments[0].segmentStart.setValue(QString::number(0.0, 'f', 5));
|
|
|
segments[0].startTime .setValue(QString::number(0.0, 'f', 5));
|
|
|
|
|
|
if(rightOrSelfSelected) selectedIdx = 0;
|
|
|
else selectedIdx = qMin(selectedIdx, segments.size() - 1);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if(segments.isEmpty()) {
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if(selectedIdx < 0 || selectedIdx >= segments.size()) selectedIdx = 0;
|
|
|
|
|
|
for(int i = 0; i < segments.size(); ++i) segments[i].isSelected = (i == selectedIdx);
|
|
|
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
m_perforationData.setSelectedSegmentIndex(selectedIdx);
|
|
|
|
|
|
if(m_pPressureChart) m_pPressureChart->clearExternalDragState();
|
|
|
|
|
|
if(m_pFlowRateChart) m_pFlowRateChart->clearExternalDragState();
|
|
|
|
|
|
updateCharts();
|
|
|
updateTableFromFlowSegments();
|
|
|
|
|
|
if(m_pChartWidget) m_pChartWidget->regenerateCrossMarkPoints();
|
|
|
}
|
|
|
|
|
|
|
|
|
double nmWxTimeDependentSkin::convertTime(double value, const QString& fromUnit, const QString& toUnit) const
|
|
|
{
|
|
|
nmDataAttribute a;
|
|
|
a.setAttributeUnitType(UNIT_TYPE_TIME);
|
|
|
return a.convertValueByUnitType(value, fromUnit, toUnit);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onTimeUnitChanged(const QString& unit)
|
|
|
{
|
|
|
if(unit == m_timeDisplayUnit) return;
|
|
|
|
|
|
m_timeDisplayUnit = unit;
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
for(int i = 0; i < segments.size(); ++i) {
|
|
|
int row = i + 1;
|
|
|
double startHr = segments[i].segmentStart.getValue().toDouble();
|
|
|
double startSec = toSeconds(startHr, "hr"); // 量化
|
|
|
double startDisp = fromSeconds(startSec, m_timeDisplayUnit); // 按新单位显示
|
|
|
QTableWidgetItem* item = m_pDataTable->item(row, 1);
|
|
|
|
|
|
if(item) item->setText(QString::number(startDisp, 'f', 5));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
double nmWxTimeDependentSkin::toSeconds(double value, const QString& unit)
|
|
|
{
|
|
|
nmDataAttribute a;
|
|
|
a.setAttributeUnitType(UNIT_TYPE_TIME);
|
|
|
double sec = a.convertValueByUnitType(value, unit, "sec");
|
|
|
// 四舍五入到整数秒
|
|
|
return static_cast<double>(qRound(sec));
|
|
|
}
|
|
|
|
|
|
double nmWxTimeDependentSkin::fromSeconds(double sec, const QString& unit)
|
|
|
{
|
|
|
nmDataAttribute a;
|
|
|
a.setAttributeUnitType(UNIT_TYPE_TIME);
|
|
|
return a.convertValueByUnitType(sec, "sec", unit);
|
|
|
}
|
|
|
|
|
|
bool nmWxTimeDependentSkin::moveFlowSegmentBoundarySec(int segmentIndex, double newBoundarySec)
|
|
|
{
|
|
|
QVector<FlowSegmentData> segments = m_perforationData.getFlowSegments();
|
|
|
|
|
|
// 索引合法性
|
|
|
if(segmentIndex <= 0 || segmentIndex >= segments.size()) return false;
|
|
|
|
|
|
// 取相邻边界（都转成“秒并四舍五入”后比较）
|
|
|
double prevStartHr = (segmentIndex > 1) ? segments[segmentIndex - 1].segmentStart.getValue().toDouble() : 0.0;
|
|
|
double nextStartHr = (segmentIndex < segments.size() - 1)
|
|
|
? segments[segmentIndex + 1].segmentStart.getValue().toDouble()
|
|
|
: m_currentWell->getTotalTimeRange();
|
|
|
|
|
|
double prevStartSec = toSeconds(prevStartHr, "hr");
|
|
|
double nextStartSec = toSeconds(nextStartHr, "hr");
|
|
|
|
|
|
// 夹逼
|
|
|
if(newBoundarySec <= prevStartSec || newBoundarySec >= nextStartSec) return false;
|
|
|
|
|
|
// 写回：内部仍然存“小时”，但用“秒”为准再转换，保证显示不会抖动
|
|
|
double boundaryHr = fromSeconds(newBoundarySec, "hr");
|
|
|
|
|
|
segments[segmentIndex].segmentStart.setValue(QString::number(boundaryHr, 'f', 5));
|
|
|
segments[segmentIndex].startTime .setValue(QString::number(boundaryHr, 'f', 5));
|
|
|
segments[segmentIndex - 1].segmentEnd.setValue(QString::number(boundaryHr, 'f', 5));
|
|
|
|
|
|
m_perforationData.setFlowSegments(segments);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
double nmWxTimeDependentSkin::convertDSdQ(double value, const QString& fromUnit, const QString& toUnit) const
|
|
|
{
|
|
|
nmDataAttribute a;
|
|
|
a.setAttributeUnitType(UNIT_TYPE_FLOW_RATE_RECIPROCAL);
|
|
|
return a.convertValueByUnitType(value, fromUnit, toUnit);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onAddRateDependentToggled(bool checked)
|
|
|
{
|
|
|
// 记录到数据类（它会在禁用时把所有 dSdQ 复位为 0）
|
|
|
m_perforationData.setRateDependentEnabled(checked);
|
|
|
|
|
|
// 重建表头/单位行，并刷新数据
|
|
|
updateTableFromFlowSegments();
|
|
|
// 更新保存的状态
|
|
|
m_rateDependentState = checked;
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onDSdQUnitChanged(const QString& unit)
|
|
|
{
|
|
|
if(unit == m_dSdQDisplayUnit) return;
|
|
|
|
|
|
m_dSdQDisplayUnit = unit;
|
|
|
|
|
|
const QVector<FlowSegmentData>& segs = m_perforationData.getFlowSegments();
|
|
|
|
|
|
if(!m_perforationData.isRateDependentEnabled()) return;
|
|
|
|
|
|
for(int i = 0; i < segs.size(); ++i) {
|
|
|
int row = i + 1;
|
|
|
const FlowSegmentData& s = segs[i];
|
|
|
|
|
|
// 内部一律以 "1/B/D" 存储，这里只负责回显
|
|
|
double base = s.dSdQ.getValue().toDouble(); // unit 视为 "1/B/D"
|
|
|
double disp = convertDSdQ(base, "1/B/D", m_dSdQDisplayUnit);
|
|
|
|
|
|
QTableWidgetItem* item = m_pDataTable->item(row, 3);
|
|
|
|
|
|
if(!item) {
|
|
|
item = new QTableWidgetItem();
|
|
|
m_pDataTable->setItem(row, 3, item);
|
|
|
}
|
|
|
|
|
|
item->setText(QString::number(disp, 'f', 5));
|
|
|
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
|
|
|
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::refreshTableStructure()
|
|
|
{
|
|
|
// 1) 屏蔽表格信号
|
|
|
bool oldTblBlocked = m_pDataTable->blockSignals(true);
|
|
|
|
|
|
// 2) 清理旧的ComboBox
|
|
|
if(m_pTimeUnitCombo) {
|
|
|
m_pTimeUnitCombo->disconnect(this);
|
|
|
delete m_pTimeUnitCombo;
|
|
|
m_pTimeUnitCombo = nullptr;
|
|
|
}
|
|
|
|
|
|
if(m_pDSdQUnitCombo) {
|
|
|
m_pDSdQUnitCombo->disconnect(this);
|
|
|
delete m_pDSdQUnitCombo;
|
|
|
m_pDSdQUnitCombo = nullptr;
|
|
|
}
|
|
|
|
|
|
// 3) 重建表头/列
|
|
|
m_pDataTable->clear();
|
|
|
|
|
|
const bool enableRateDep = m_perforationData.isRateDependentEnabled();
|
|
|
const int colCount = enableRateDep ? 4 : 3;
|
|
|
m_pDataTable->setColumnCount(colCount);
|
|
|
|
|
|
QStringList headers;
|
|
|
headers << tr("") << tr("Start time") << tr("Skin");
|
|
|
|
|
|
if(enableRateDep) headers << tr("dS/dQ");
|
|
|
|
|
|
m_pDataTable->setHorizontalHeaderLabels(headers);
|
|
|
|
|
|
QHeaderView* header = m_pDataTable->horizontalHeader();
|
|
|
header->setResizeMode(0, QHeaderView::Fixed);
|
|
|
header->setResizeMode(1, QHeaderView::Stretch);
|
|
|
header->setResizeMode(2, QHeaderView::Stretch);
|
|
|
|
|
|
if(enableRateDep) header->setResizeMode(3, QHeaderView::Stretch);
|
|
|
|
|
|
m_pDataTable->setColumnWidth(0, 20);
|
|
|
|
|
|
// 4) 创建单位行和ComboBox
|
|
|
if(m_pDataTable->rowCount() == 0) {
|
|
|
m_pDataTable->insertRow(0);
|
|
|
m_pDataTable->setRowHeight(0, 24);
|
|
|
}
|
|
|
|
|
|
createTimeUnitCombo();
|
|
|
|
|
|
// Skin列占位
|
|
|
QTableWidgetItem* emptySkin = new QTableWidgetItem("");
|
|
|
emptySkin->setFlags(Qt::ItemIsEnabled);
|
|
|
m_pDataTable->setItem(0, 2, emptySkin);
|
|
|
|
|
|
if(enableRateDep) {
|
|
|
createDSdQUnitCombo();
|
|
|
}
|
|
|
|
|
|
// 5) 恢复表格信号
|
|
|
m_pDataTable->blockSignals(oldTblBlocked);
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::onShowDatesToggled(bool checked)
|
|
|
{
|
|
|
// 更新数据状态
|
|
|
m_perforationData.setShowDatesEnabled(checked);
|
|
|
|
|
|
// 如果启用日期显示，设置默认开始时间
|
|
|
if(checked && m_perforationData.getStartDateTime().isNull()) {
|
|
|
m_perforationData.setStartDateTime(QDateTime::currentDateTime());
|
|
|
}
|
|
|
|
|
|
// 更新时间单位下拉框的可见性
|
|
|
updateTimeUnitComboVisibility();
|
|
|
|
|
|
// 刷新表格显示
|
|
|
updateTableFromFlowSegments();
|
|
|
}
|
|
|
|
|
|
void nmWxTimeDependentSkin::updateTimeUnitComboVisibility()
|
|
|
{
|
|
|
bool showDates = m_perforationData.isShowDatesEnabled();
|
|
|
|
|
|
if(showDates) {
|
|
|
// 在使用setCellWidget替换控件前，先将指针置空
|
|
|
if(m_pTimeUnitCombo) {
|
|
|
m_pTimeUnitCombo->disconnect(this);
|
|
|
m_pTimeUnitCombo = nullptr; // 关键：置空指针
|
|
|
}
|
|
|
|
|
|
// 创建并设置标签（setCellWidget会自动删除旧控件）
|
|
|
QLabel* dateTimeLabel = new QLabel(tr("Date Time"), m_pDataTable);
|
|
|
dateTimeLabel->setAlignment(Qt::AlignCenter);
|
|
|
dateTimeLabel->setStyleSheet("QLabel { color: #333; font-size: 12px; }");
|
|
|
m_pDataTable->setCellWidget(0, 1, dateTimeLabel);
|
|
|
} else {
|
|
|
// 恢复ComboBox显示
|
|
|
if(!m_pTimeUnitCombo) {
|
|
|
createTimeUnitCombo();
|
|
|
} else {
|
|
|
m_pTimeUnitCombo->setVisible(true);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QString nmWxTimeDependentSkin::formatTimeDisplay(double timeInHours, int segmentIndex) const
|
|
|
{
|
|
|
bool showDates = m_perforationData.isShowDatesEnabled();
|
|
|
|
|
|
if(showDates) {
|
|
|
// 显示绝对时间
|
|
|
QDateTime startDateTime = m_perforationData.getStartDateTime();
|
|
|
QDateTime segmentDateTime = startDateTime.addSecs(static_cast<int>(timeInHours * 3600));
|
|
|
return segmentDateTime.toString("yyyy-MM-dd hh:mm:ss");
|
|
|
} else {
|
|
|
// 显示相对时间
|
|
|
double startSec = toSeconds(timeInHours, "hr");
|
|
|
double startDisp = fromSeconds(startSec, m_timeDisplayUnit);
|
|
|
return QString::number(startDisp, 'f', 5);
|
|
|
}
|
|
|
}
|