1512 lines
46 KiB
C++
1512 lines
46 KiB
C++
#include <QHBoxLayout>
|
||
#include <QRandomGenerator>
|
||
#include <cmath>
|
||
#include <limits>
|
||
#include <qcustomplot.h>
|
||
#include <QMessageBox>
|
||
|
||
#include "analysisoperationrecorder.h"
|
||
#include "centralwidget.h"
|
||
#include "filemanager.h"
|
||
#include "pointcalculate.h"
|
||
#include "logger.h"
|
||
#include "xlsxhandler.h"
|
||
#include "itemmanager.h"
|
||
|
||
namespace AnaOpRecorder = AnalysisOperationRecorder;
|
||
using AnaOpRecorderOperation = AnalysisOperationRecorder::AnalysisOperation;
|
||
using namespace Global;
|
||
|
||
CentralWidget::CentralWidget(QWidget *parent)
|
||
: QWidget(parent)
|
||
,_customPlot(new LocalCustomPlot(this))
|
||
// ,_customPlot(new QCustomPlot(this))
|
||
,_analysisMode(AnalysisMode::Null)
|
||
,_currentCurve(nullptr)
|
||
{
|
||
setMouseTracking(true);
|
||
|
||
setStyleSheet("background-color: lightgray;");
|
||
resize(888, 666);
|
||
|
||
QHBoxLayout *layout = new QHBoxLayout();
|
||
layout->setMargin(0);
|
||
layout->addWidget(_customPlot);
|
||
this->setLayout(layout);
|
||
|
||
// 创建两条竖线
|
||
_line1 = new QCPItemStraightLine(_customPlot);
|
||
_line1->point1->setCoords(20, _customPlot->yAxis->range().lower);
|
||
_line1->point2->setCoords(20, _customPlot->yAxis->range().upper);
|
||
_line1->setPen(QPen(Qt::red));
|
||
_line1->setSelectable(true);
|
||
|
||
_line2 = new QCPItemStraightLine(_customPlot);
|
||
_line2->point1->setCoords(40, _customPlot->yAxis->range().lower);
|
||
_line2->point2->setCoords(40, _customPlot->yAxis->range().upper);
|
||
_line2->setPen(QPen(Qt::red));
|
||
_line2->setSelectable(true);
|
||
|
||
// 安装事件过滤器
|
||
// _graph = _customPlot->addGraph(0);
|
||
// _eventHandler = new EventHandler(_customPlot, _line1, _line2, _graph, nullptr);
|
||
|
||
_eventHandler = new EventHandler(_customPlot, _line1, _line2, nullptr);
|
||
_eventHandler->setEnable(true);
|
||
|
||
_customPlot->installEventFilter(_eventHandler);
|
||
_customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables);
|
||
// _customPlot->setInteractions( QCP::iRangeZoom | QCP::iSelectPlottables);
|
||
// _customPlot->setInteractions(QCP::iSelectPlottables);
|
||
|
||
connect(_eventHandler,&EventHandler::sigSendLineXCoord,
|
||
this,&CentralWidget::sigSendLineXCoord);
|
||
connect(_eventHandler,&EventHandler::sigDelCurve,
|
||
this,&CentralWidget::slotDelCurve);
|
||
|
||
connect(_customPlot, &QCustomPlot::selectionChangedByUser,
|
||
this,&CentralWidget::slotSelectionChangedByUser);
|
||
|
||
setEventHandlerEnable(false);
|
||
//
|
||
#if 0
|
||
// init data
|
||
QVector<double> x(101), y(101);
|
||
for (int i = 0; i < 101; i++) {
|
||
x[i] = i / 50.0 - 1;//设置x的范围为-1~1
|
||
y[i] = x[i] * x[i];
|
||
}
|
||
|
||
_customPlot->graph(0)->setData(x, y);
|
||
//设置坐标轴标签
|
||
_customPlot->xAxis->setLabel("x coordinates");
|
||
_customPlot->yAxis->setLabel("y coordinates");
|
||
//设置坐标轴范围，以便我们可以看到全部数据
|
||
_customPlot->xAxis->setRange(0, 1);
|
||
_customPlot->yAxis->setRange(0, 100);
|
||
_customPlot->replot();
|
||
#endif
|
||
|
||
// 设置坐标轴标签
|
||
_customPlot->xAxis->setLabel(AxisTemperature);
|
||
_customPlot->yAxis->setLabel(AxisDSC);
|
||
|
||
// 设置坐标轴范围，以便我们可以看到全部数据
|
||
_customPlot->xAxis->setRange(0,100);
|
||
_customPlot->yAxis->setRange(0,20);
|
||
|
||
// startTimer(300);
|
||
}
|
||
|
||
CentralWidget::~CentralWidget()
|
||
{
|
||
}
|
||
|
||
void CentralWidget::switchAxisMode()
|
||
{
|
||
if(Global::_mode != Global::Mode::Analysis){
|
||
return;
|
||
}
|
||
|
||
if(_axisMode == AxisMode::SingleY){
|
||
_axisMode = AxisMode::DoubleY;
|
||
}else{
|
||
_axisMode = AxisMode::SingleY;
|
||
}
|
||
|
||
clearData(ClearDataMode::JustUi);
|
||
|
||
uiLoadXlsxFileData();
|
||
}
|
||
|
||
bool CentralWidget::isCurrentCurve(QCPCurve *curve)
|
||
{
|
||
return _currentCurve == curve;
|
||
}
|
||
|
||
void CentralWidget::deleteCurrentCurve()
|
||
{
|
||
slotDelCurve(_currentCurve);
|
||
}
|
||
|
||
void CentralWidget::addSmoothnessCurveData(
|
||
const QVector<ExperimentData> &dataVtr,const QString objectName)
|
||
{
|
||
PointCalculate::setAnalysisData(dataVtr);
|
||
|
||
// Load data.
|
||
// QVector<Global::ExperimentData> dataVtr;
|
||
QVector<double> tVtr,xVtr, yVtr;
|
||
int index = 0;
|
||
for (const Global::ExperimentData &ed : dataVtr)
|
||
{
|
||
tVtr.push_back(index++);
|
||
if(_axisMode == AxisMode::SingleY){
|
||
xVtr.push_back(ed.sampleTemp);
|
||
}else{
|
||
xVtr.push_back(ed.runTime);
|
||
}
|
||
yVtr.push_back(ed.dsc);
|
||
}
|
||
|
||
_currentCurve = new QCPCurve(_customPlot->xAxis, _customPlot->yAxis);
|
||
_currentCurve->setData(tVtr, xVtr, yVtr);
|
||
_currentCurve->setSelectable(QCP::stWhole); // 设置曲线可选
|
||
_currentCurve->setLineStyle(QCPCurve::lsLine); // 线性连接
|
||
|
||
_currentCurve->setObjectName(objectName);
|
||
|
||
// Set axis range.
|
||
QPair<float, float> minMaxXAxisPair;
|
||
if(_axisMode == AxisMode::SingleY){
|
||
// Axis x is temperature value.
|
||
minMaxXAxisPair = PointCalculate::getMinAndMaxOfSampleTemp();
|
||
}else{
|
||
// Axis x is time value.
|
||
minMaxXAxisPair = PointCalculate::getMinAndMaxOfRunTime();
|
||
}
|
||
QPair<float, float>newXAxisPair = PointCalculate::getMinAndMaxOfAxis(
|
||
minMaxXAxisPair.first,minMaxXAxisPair.second);
|
||
_customPlot->xAxis->setRange(newXAxisPair.first, newXAxisPair.second);
|
||
|
||
QPair<float, float> minMaxYAxisPair = PointCalculate::getMinAndMaxOfDSC();
|
||
QPair<float, float>newYAxisPair = PointCalculate::getMinAndMaxOfAxis(
|
||
minMaxYAxisPair.first,minMaxYAxisPair.second);
|
||
_customPlot->yAxis->setRange(newYAxisPair.first ,
|
||
newYAxisPair.second);
|
||
//
|
||
// pti.curve = _currentCurve;
|
||
|
||
// Add analysis operation data.
|
||
#if 0
|
||
if(cfd.analysisOperationVtr.size() > 0){
|
||
for(AnaOpRecorder::AnalysisOperation& ao
|
||
:cfd.analysisOperationVtr){
|
||
loadAnalysisData(ao.mode,ao.x1,ao.x2,cfd.fileName);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// Refresh ui.
|
||
_customPlot->replot();
|
||
|
||
#if 0
|
||
// Save data.
|
||
CurveExperimentData ced;
|
||
ced.curve = _currentCurve;
|
||
ced.dataVtr = dataVtr;
|
||
|
||
// Global::_curveSmoothnessDataVtr.push_back(ced);
|
||
#endif
|
||
}
|
||
|
||
void CentralWidget::setAnalysisMode(const AnalysisMode mode)
|
||
{
|
||
_analysisMode = mode;
|
||
|
||
if(mode == AnalysisMode::Null){
|
||
_customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables);
|
||
}else{
|
||
_customPlot->setInteractions(QCP::iSelectPlottables);
|
||
setEventHandlerEnable(true);
|
||
}
|
||
|
||
#if 0
|
||
switch (mode)
|
||
{
|
||
case AnalysisMode::Null:
|
||
_customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables);
|
||
break;
|
||
case AnalysisMode::NumericalLabel:
|
||
case AnalysisMode::StartPoint:
|
||
case AnalysisMode::StopPoint:
|
||
case AnalysisMode::PeakSynthesisAnalysis:
|
||
case AnalysisMode::GlassTransition:
|
||
case AnalysisMode::OnsetTemperaturePoint:
|
||
case AnalysisMode::EndsetTemperaturePoint:
|
||
_customPlot->setInteractions(QCP::iSelectPlottables);
|
||
setEventHandlerEnable(true);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void CentralWidget::slotModeModify(const Global::Mode mode)
|
||
{
|
||
if (Global::Mode::Experiment == mode)
|
||
{
|
||
#if 0
|
||
if (_customPlot->graphCount() > 0 && _currentGraph)
|
||
{
|
||
// 清除第一个图表上的数据
|
||
_currentGraph->setData(QVector<double>(), QVector<double>());
|
||
}
|
||
#endif
|
||
|
||
// 创建画布,设置画布上的点数据
|
||
// _graph = _customPlot->addGraph();
|
||
|
||
// 设置坐标轴标签
|
||
_customPlot->xAxis->setLabel("Temp/℃");
|
||
_customPlot->yAxis->setLabel("DSC/mW");
|
||
// 设置坐标轴范围，以便我们可以看到全部数据
|
||
_customPlot->xAxis->setRange(0, 400);
|
||
_customPlot->yAxis->setRange(-20, 20);
|
||
}
|
||
else if (Global::Mode::Analysis == mode)
|
||
{
|
||
qDebug() << "file close...";
|
||
}
|
||
}
|
||
|
||
void CentralWidget::slotRecvCommonData(const CommonData &cd)
|
||
{
|
||
static double index = 0.0;
|
||
|
||
if(!_currentCurve){
|
||
logde<<"_currentCurve is nullptr";
|
||
_currentCurve = new QCPCurve(_customPlot->xAxis, _customPlot->yAxis);
|
||
_currentCurve->setObjectName(Global::objectNameExperiemnt);
|
||
}
|
||
|
||
// logde<<"temp:"<<cd.sample_temp<<",dsc:"<<cd.dsc;
|
||
_currentCurve->addData(index++,cd.sample_temp, cd.dsc);
|
||
|
||
// _customPlot->rescaleAxes();
|
||
_customPlot->replot();
|
||
|
||
// Record data.
|
||
if(!Global::_currentCurveExperimentDataPtr){
|
||
loger<<"_currentCurveExperimentDataPtr is nullptr.";
|
||
exit(0);
|
||
}else{
|
||
Global::ExperimentData ed;
|
||
ed.dsc = cd .dsc;
|
||
ed.sampleTemp = cd.sample_temp;
|
||
ed.runTime = cd.add_run_time;
|
||
ed.constantTempTime = cd.add_constan_temp_time;
|
||
|
||
Global::_currentCurveExperimentDataPtr->dataVtr.push_back(ed);
|
||
Global::_currentCurveExperimentDataPtr->curve = _currentCurve;
|
||
}
|
||
|
||
#if 0
|
||
logde<<"_curveExperimentDataVtr size:"
|
||
<<Global::_curveExperimentDataVtr.size();
|
||
|
||
logde<<"_currentCurveExperimentDataPtr dataVtr size:"
|
||
<<Global::_currentCurveExperimentDataPtr->dataVtr.size();
|
||
#endif
|
||
|
||
}
|
||
|
||
void CentralWidget::slotRecvAnalysisFileName(const QString &filePath)
|
||
{
|
||
if(_analysisFilePathVtr.contains(filePath)){
|
||
return;
|
||
}else{
|
||
_analysisFilePathVtr.push_back(filePath);
|
||
}
|
||
|
||
// Read xlsx file.
|
||
Global::CurveFileData cfd;
|
||
if(XlsxHandler::readFile(filePath,cfd) != 0){
|
||
QMessageBox::warning((QWidget*)this->parent(), "warnning", "File parse error.");
|
||
return;
|
||
}
|
||
// Add data to global parameter.
|
||
Global::_curveFileDataVtr.push_back(cfd);
|
||
|
||
//
|
||
uiLoadXlsxFileData();
|
||
}
|
||
|
||
void CentralWidget::slotAnalysisSettingApply()
|
||
{
|
||
//Set the analysis data corresponding current curve.
|
||
if(!_currentCurve){
|
||
logde<<"failed. current curve is nullptr.";
|
||
return;
|
||
}
|
||
|
||
// Set curve data to PointCalculate.
|
||
if(Global::_curveFileDataVtr.empty()){
|
||
// Load experiment data.
|
||
logde<<"experiment vtr size:"<<Global::_curveExperimentDataVtr.size();
|
||
for(Global::CurveExperimentData& ced:Global::_curveExperimentDataVtr){
|
||
if(ced.curve == _currentCurve){
|
||
logde<<"load experiment data.";
|
||
PointCalculate::setAnalysisData(ced.dataVtr);
|
||
break;
|
||
}
|
||
}
|
||
}else{
|
||
// Load xlsx file data.
|
||
for(Global::CurveFileData& cfd:Global::_curveFileDataVtr){
|
||
for(Global::PhaseTotalInfo& pti:cfd.phaseTotalVtr){
|
||
if(pti.curve == _currentCurve){
|
||
PointCalculate::setAnalysisData(pti.dataVtr);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#if 0
|
||
// Load smoothness data.
|
||
for(Global::CurveExperimentData& ced:Global::_curveSmoothnessDataVtr){
|
||
if(ced.curve == _currentCurve){
|
||
logde<<"load smoothness data.";
|
||
PointCalculate::setAnalysisData(ced.dataVtr);
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
//
|
||
double x1 = _line1->point1->coords().x();
|
||
double x2 = _line2->point1->coords().x();
|
||
|
||
if(_x1Record == x1 && _x2Record == x2){
|
||
return;
|
||
}else{
|
||
_x1Record = x1;
|
||
_x2Record = x2;
|
||
}
|
||
|
||
//
|
||
loadAnalysisData(_analysisMode,x1,x2,_currentCurve->objectName());
|
||
|
||
if(Global::_mode == Global::Mode::Analysis){
|
||
AnalysisOperation ao;
|
||
ao.mode = _analysisMode;
|
||
ao.x1 = x1;
|
||
ao.x2 = x2;
|
||
|
||
AnaOpRecorder::_analysisOperationVtr.push_back(ao);
|
||
}
|
||
}
|
||
|
||
void CentralWidget::slotAnalysisSettingConfirm()
|
||
{
|
||
ItemManager::confirm();
|
||
|
||
slotAnalysisSettingApply();
|
||
|
||
setAnalysisMode(AnalysisMode::Null);
|
||
|
||
_line1->setVisible(false);
|
||
_line2->setVisible(false);
|
||
|
||
emit sigRightDockWidgetHide();
|
||
}
|
||
|
||
void CentralWidget::slotAnalysisSettingUndo()
|
||
{
|
||
clearData(ClearDataMode::Undo);
|
||
|
||
_x1Record = 0.0;
|
||
_x2Record = 0.0;
|
||
}
|
||
|
||
void CentralWidget::slotAnalysisSettingCancel()
|
||
{
|
||
clearData(ClearDataMode::Undo);
|
||
|
||
setAnalysisMode(AnalysisMode::Null);
|
||
|
||
_line1->setVisible(false);
|
||
_line2->setVisible(false);
|
||
|
||
emit sigRightDockWidgetHide();
|
||
}
|
||
|
||
void CentralWidget::slotAnalysisSettingLineXPoint(const int index, const double)
|
||
{
|
||
|
||
}
|
||
|
||
void CentralWidget::slotDrawCustomText(const QString str)
|
||
{
|
||
QCPItemText* customLegendItem = new QCPItemText(_customPlot);
|
||
customLegendItem->position->setTypeX(QCPItemPosition::ptAbsolute);
|
||
customLegendItem->position->setTypeY(QCPItemPosition::ptAbsolute);
|
||
customLegendItem->position->setCoords(150, 50); // 稍微向下移动
|
||
customLegendItem->setText(str);
|
||
|
||
QFont font("Arial", 10);
|
||
customLegendItem->setFont(font);
|
||
|
||
// 设置边框和背景
|
||
customLegendItem->setPen(QPen(Qt::black));
|
||
customLegendItem->setBrush(QBrush(Qt::white));
|
||
|
||
// 禁止点选
|
||
customLegendItem->setSelectable(false);
|
||
customLegendItem->setObjectName("fixed");
|
||
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::slotDelCurve(QCPCurve *curve)
|
||
{
|
||
if(!curve){
|
||
logde<<"current curve is nullptr.";
|
||
return;
|
||
}
|
||
|
||
logde<<"deltel curve object name:"<<curve->objectName().toStdString();
|
||
|
||
deleteCurve(curve->objectName());
|
||
}
|
||
|
||
void CentralWidget::slotGetAxisInfo()
|
||
{
|
||
QVector<AxisInfo> vtr;
|
||
|
||
auto func = [&](QCPAxis* axis){
|
||
AxisInfo ai;
|
||
ai.visiable = axis->visible();
|
||
ai.lower = axis->range().lower;
|
||
ai.upper = axis->range().upper;
|
||
|
||
vtr.push_back(ai);
|
||
};
|
||
|
||
func(_customPlot->xAxis);
|
||
func(_customPlot->yAxis);
|
||
func(_customPlot->yAxis2);
|
||
|
||
emit sigGetAxisInfoWithData(vtr);
|
||
}
|
||
|
||
void CentralWidget::slotSetAxisSettings(const QVector<double>vtr)
|
||
{
|
||
_customPlot->xAxis->setRange(vtr.at(0),vtr.at(1));
|
||
_customPlot->yAxis->setRange(vtr.at(2),vtr.at(3));
|
||
|
||
if(_customPlot->yAxis2->visible()){
|
||
_customPlot->yAxis2->setRange(vtr.at(4),vtr.at(5));
|
||
}
|
||
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::timerEvent(QTimerEvent *event)
|
||
{
|
||
_customPlot->replot();
|
||
|
||
#if 0
|
||
// key的单位是秒
|
||
double key = QDateTime::currentDateTime().toMSecsSinceEpoch() / 1000.0;
|
||
// 添加数据
|
||
// 使用随机数产生一条曲线
|
||
// double value0 = realDataI();
|
||
double value0 = QRandomGenerator::global()->bounded(10.123);
|
||
_customPlot->graph(0)->addData(key, value0); // 添加数据到曲线
|
||
|
||
// 删除8秒之前的数据。这里的8要和下面设置横坐标宽度的8配合起来
|
||
// 才能起到想要的效果，可以调整这两个值，观察显示的效果。
|
||
_customPlot->graph(0)->data()->remove(key - 80);
|
||
// 自动设定graph(1)曲线y轴的范围，如果不设定，有可能看不到图像
|
||
// 也可以用ui->customPlot->yAxis->setRange(up,low)手动设定y轴范围
|
||
_customPlot->graph(0)->rescaleValueAxis(true);
|
||
|
||
// 这里的8，是指横坐标时间宽度为8秒，如果想要横坐标显示更多的时间
|
||
// 就把8调整为比较大到值，比如要显示60秒，那就改成60。
|
||
// 这时removeDataBefore(key-8)中的8也要改成60，否则曲线显示不完整。
|
||
|
||
_customPlot->yAxis->setRange(0, 20); // 设定x轴的范围
|
||
_customPlot->xAxis->setRange(key + 0.25, 80, Qt::AlignRight); // 设定x轴的范围
|
||
_customPlot->replot();
|
||
#endif
|
||
}
|
||
|
||
void CentralWidget::slotSelectionChangedByUser()
|
||
{
|
||
// 获取所有被选中的绘图对象
|
||
QList<QCPAbstractPlottable*> selectedPlottables = _customPlot->selectedPlottables();
|
||
|
||
// 遍历选中的绘图对象
|
||
for (QCPAbstractPlottable* plottable : selectedPlottables) {
|
||
// 检查是否是 QCPCurve
|
||
if (QCPCurve* curve = dynamic_cast<QCPCurve*>(plottable)) {
|
||
logde << "Selected Curve:" << curve->objectName().toStdString();
|
||
_currentCurve = curve; // 更新当前选中的曲线
|
||
}
|
||
}
|
||
|
||
#if 0
|
||
// 如果没有选中的曲线
|
||
if (selectedPlottables.isEmpty()) {
|
||
logde<< "No curve selected";
|
||
_currentCurve = nullptr; // 清空当前选中的曲线
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void CentralWidget::uiLoadXlsxFileData()
|
||
{
|
||
// Set axis.
|
||
_customPlot->yAxis->setVisible(true);
|
||
_customPlot->yAxis->setLabel(AxisDSC);
|
||
|
||
if(_axisMode == AxisMode::SingleY){
|
||
_customPlot->xAxis->setLabel(AxisTemperature);
|
||
|
||
_customPlot->yAxis2->setVisible(false);
|
||
}else{
|
||
_customPlot->xAxis->setLabel(AxisTime);
|
||
|
||
_customPlot->yAxis2->setVisible(true);
|
||
_customPlot->yAxis2->setLabel(AxisTemperature);
|
||
}
|
||
|
||
#if 1
|
||
// Load xlsx file data.
|
||
for(Global::CurveFileData& cfd:Global::_curveFileDataVtr){
|
||
for(int i = 0;i < cfd.phaseTotalVtr.size();i++){
|
||
Global::PhaseTotalInfo& pti = cfd.phaseTotalVtr[i];
|
||
|
||
PointCalculate::setAnalysisData(pti.dataVtr);
|
||
|
||
// Load data.
|
||
QVector<Global::ExperimentData> dataVtr;
|
||
QVector<double> tVtr,xVtr, yVtr;
|
||
int index = 0;
|
||
for (Global::ExperimentData &ed : pti.dataVtr)
|
||
{
|
||
tVtr.push_back(index++);
|
||
if(_axisMode == AxisMode::SingleY){
|
||
xVtr.push_back(ed.sampleTemp);
|
||
}else{
|
||
xVtr.push_back(ed.runTime);
|
||
}
|
||
yVtr.push_back(ed.dsc);
|
||
}
|
||
|
||
_currentCurve = new QCPCurve(_customPlot->xAxis, _customPlot->yAxis);
|
||
_currentCurve->setData(tVtr, xVtr, yVtr);
|
||
_currentCurve->setSelectable(QCP::stWhole); // 设置曲线可选
|
||
_currentCurve->setLineStyle(QCPCurve::lsLine); // 线性连接
|
||
|
||
_currentCurve->setObjectName(cfd.fileName);
|
||
|
||
// Set axis range.
|
||
QPair<float, float> minMaxXAxisPair;
|
||
if(_axisMode == AxisMode::SingleY){
|
||
// Axis x is temperature value.
|
||
minMaxXAxisPair = PointCalculate::getMinAndMaxOfSampleTemp();
|
||
}else{
|
||
// Axis x is time value.
|
||
minMaxXAxisPair = PointCalculate::getMinAndMaxOfRunTime();
|
||
}
|
||
QPair<float, float>newXAxisPair = PointCalculate::getMinAndMaxOfAxis(
|
||
minMaxXAxisPair.first,minMaxXAxisPair.second);
|
||
_customPlot->xAxis->setRange(newXAxisPair.first, newXAxisPair.second);
|
||
|
||
QPair<float, float> minMaxYAxisPair = PointCalculate::getMinAndMaxOfDSC();
|
||
QPair<float, float>newYAxisPair = PointCalculate::getMinAndMaxOfAxis(
|
||
minMaxYAxisPair.first,minMaxYAxisPair.second);
|
||
_customPlot->yAxis->setRange(newYAxisPair.first ,
|
||
newYAxisPair.second);
|
||
//
|
||
pti.curve = _currentCurve;
|
||
}
|
||
|
||
// Add analysis operation data.
|
||
if(cfd.analysisOperationVtr.size() > 0){
|
||
for(AnaOpRecorder::AnalysisOperation& ao
|
||
:cfd.analysisOperationVtr){
|
||
loadAnalysisData(ao.mode,ao.x1,ao.x2,cfd.fileName);
|
||
}
|
||
}
|
||
}
|
||
// Refresh ui.
|
||
_customPlot->replot();
|
||
#endif
|
||
}
|
||
|
||
#if 0
|
||
void CentralWidget::contextMenuEvent(QContextMenuEvent *event)
|
||
{
|
||
qDebug()<<"left menu...";
|
||
QPoint point = event->globalPos();
|
||
emit sigContextMenuShow(point);
|
||
}
|
||
#endif
|
||
|
||
void CentralWidget::glassTransitionHandle(const double x1,const double x2,const QString objectName)
|
||
{
|
||
QPointF point1 = PointCalculate::getClosestPointByX(x1);
|
||
QPointF point2 = PointCalculate::getClosestPointByX(x2);
|
||
|
||
logde<<"point1:"<<point1.x()<<","<<point1.y();
|
||
logde<<"point2:"<<point2.x()<<","<<point2.y();
|
||
|
||
QVector<QPointF> point1Vtr = PointCalculate::getNearbyPointGroupByX(point1.x());
|
||
QVector<QPointF> point2Vtr = PointCalculate::getNearbyPointGroupByX(point2.x());
|
||
|
||
QVector<double> xVtr,yVtr;
|
||
for(QPointF &p:point1Vtr){
|
||
xVtr.append(p.x());
|
||
yVtr.append(p.y());
|
||
}
|
||
|
||
PointCalculate::Line line1 = calculateLinearRegression(xVtr,yVtr);
|
||
|
||
#if 1
|
||
///line1
|
||
// QVector<double> xVtr,yVtr;
|
||
xVtr.clear();
|
||
yVtr.clear();
|
||
|
||
xVtr.push_back(point1.x());
|
||
yVtr.push_back(point1.y());
|
||
|
||
xVtr.push_back(point1.x() + 10);
|
||
double y1 = line1.slope * (point1.x() + 10) + line1.intercept;
|
||
yVtr.push_back(y1);
|
||
|
||
QCPGraph *lineGraph1 = _customPlot->addGraph();
|
||
lineGraph1->setData(xVtr, yVtr);
|
||
|
||
ItemManager::addTemporaryQCPGraph(lineGraph1,objectName);
|
||
|
||
QPen pen;
|
||
pen.setColor(Qt::darkGreen);
|
||
lineGraph1->setPen(pen);
|
||
|
||
#endif
|
||
|
||
xVtr.clear();
|
||
yVtr.clear();
|
||
for(QPointF &p:point2Vtr){
|
||
xVtr.append(p.x());
|
||
yVtr.append(p.y());
|
||
}
|
||
|
||
PointCalculate::Line line2 = calculateLinearRegression(xVtr,yVtr);
|
||
|
||
#if 1
|
||
///line2
|
||
QVector<double> xVtr2,yVtr2;
|
||
xVtr2.push_back(point2.x());
|
||
yVtr2.push_back(point2.y());
|
||
|
||
xVtr2.push_back(point2.x() - 10);
|
||
double y2 = line2.slope * (point2.x() - 10) + line2.intercept;
|
||
yVtr2.push_back(y2);
|
||
|
||
QCPGraph *lineGraph2 = _customPlot->addGraph();
|
||
lineGraph2->setData(xVtr2, yVtr2);
|
||
lineGraph2->setPen(pen);
|
||
|
||
ItemManager::addTemporaryQCPGraph(lineGraph2,objectName);
|
||
|
||
_customPlot->replot();
|
||
#endif
|
||
|
||
// inflection point.
|
||
QVector<QPointF> originalPointVtr = PointCalculate::getPointVtrInXRange(point1.x(),point2.x());
|
||
|
||
QVector<QPointF> pointVtr = originalPointVtr;
|
||
|
||
xVtr.clear();
|
||
yVtr.clear();
|
||
for(QPointF& p:pointVtr){
|
||
xVtr.append(p.x());
|
||
yVtr.append(p.y());
|
||
}
|
||
QMap<double, PointCalculate::Line> tangentLines =
|
||
PointCalculate::calculateTangentLine(xVtr,yVtr);
|
||
|
||
double targetX = 0.0;
|
||
PointCalculate::Line targetLine;
|
||
double maxSlopeAbs = 0.0; // 初始化最大斜率绝对值为0
|
||
|
||
#if 0
|
||
for (auto it = tangentLines.begin(); it != tangentLines.end(); ++it) {
|
||
if (std::fabs(it.value().slope) > maxSlopeAbs) {
|
||
maxSlopeAbs = std::fabs(it.value().slope); // 更新最大斜率绝对值
|
||
|
||
targetX = it.key();
|
||
targetLine = it.value();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// new method
|
||
for (auto it = tangentLines.begin(); it != tangentLines.end(); ++it) {
|
||
if (std::fabs(it.value().slope) > maxSlopeAbs) {
|
||
maxSlopeAbs = std::fabs(it.value().slope); // 更新最大斜率绝对值
|
||
|
||
targetX = it.key();
|
||
targetLine = it.value();
|
||
|
||
}
|
||
}
|
||
|
||
int index = 0;
|
||
QPointF prePoint,currentPoint,lastPoint;
|
||
for (int i = 0;i < pointVtr.size();i++) {
|
||
currentPoint = pointVtr[i];
|
||
if(currentPoint.x() == targetX){
|
||
index = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
prePoint = pointVtr[index - 1];
|
||
lastPoint = pointVtr[index + 1];
|
||
|
||
|
||
targetLine.slope = PointCalculate::calculateSlope(lastPoint.x(),lastPoint.y(),prePoint.x(),prePoint.y());
|
||
targetLine.intercept = currentPoint.y() - targetLine.slope * currentPoint.x();
|
||
//
|
||
#if 1
|
||
QPointF intersection1 = PointCalculate::getIntersection(targetLine,line1);
|
||
QPointF intersection2 = PointCalculate::getIntersection(targetLine,line2);
|
||
|
||
// graph 3
|
||
xVtr.clear();
|
||
yVtr.clear();
|
||
|
||
#if 0
|
||
xVtr.push_back(point1.x());
|
||
yVtr.push_back(point1.y());
|
||
|
||
xVtr.push_back(point1.x());
|
||
yVtr.push_back(point1.y());
|
||
#endif
|
||
|
||
#if 1
|
||
xVtr.push_back(intersection1.x());
|
||
yVtr.push_back(intersection1.y());
|
||
|
||
xVtr.push_back(intersection2.x());
|
||
yVtr.push_back(intersection2.y());
|
||
#endif
|
||
|
||
QCPGraph *lineGraph3 = _customPlot->addGraph();
|
||
lineGraph3->setData(xVtr, yVtr);
|
||
lineGraph3->setPen(pen);
|
||
|
||
ItemManager::addTemporaryQCPGraph(lineGraph3,objectName);
|
||
#endif
|
||
|
||
_customPlot->replot();
|
||
|
||
// point value
|
||
double averageY = (point1.y() + point2.y()) / 2;
|
||
|
||
QPointF averagePoint = PointCalculate::getClosestPointByY(point1.x(),point2.x(),averageY);
|
||
|
||
QString str = PointCalculate::textFormatGlassTranstion(intersection1.x(),
|
||
averagePoint.x(),
|
||
intersection2.x());
|
||
if(Global::_axisMode == Global::AxisMode::DoubleY){
|
||
Global::ExperimentData intersection1Ed =
|
||
PointCalculate::getClosestDataByTemperature(intersection1.x());
|
||
Global::ExperimentData averageEd =
|
||
PointCalculate::getClosestDataByTemperature(averagePoint.x());
|
||
Global::ExperimentData intersection2Ed =
|
||
PointCalculate::getClosestDataByTemperature(intersection2.x());
|
||
|
||
averagePoint = QPointF(averageEd.runTime,averageEd.dsc);
|
||
|
||
str = PointCalculate::textFormatGlassTranstionWithTime(
|
||
intersection1Ed.runTime,
|
||
averageEd.runTime,
|
||
intersection2Ed.runTime);
|
||
}
|
||
|
||
drawText(averagePoint,str);
|
||
}
|
||
// 使用最小二乘法计算线性回归
|
||
PointCalculate::Line CentralWidget::calculateLinearRegression(const QVector<double>& x, const QVector<double>& y) {
|
||
PointCalculate::Line line;
|
||
double sum_x = 0, sum_y = 0, sum_xy = 0, sum_xx = 0;
|
||
size_t n = x.size();
|
||
|
||
// 计算所需的总和
|
||
for (size_t i = 0; i < n; ++i) {
|
||
sum_x += x[i];
|
||
sum_y += y[i];
|
||
sum_xy += x[i] * y[i];
|
||
sum_xx += x[i] * x[i];
|
||
}
|
||
|
||
// 计算斜率和截距
|
||
double x_mean = sum_x / n;
|
||
double y_mean = sum_y / n;
|
||
double numerator = n * sum_xy - sum_x * sum_y;
|
||
double denominator = n * sum_xx - sum_x * sum_x;
|
||
line.slope = numerator / denominator;
|
||
line.intercept = y_mean - line.slope * x_mean;
|
||
|
||
return line;
|
||
}
|
||
|
||
QPointF CentralWidget::onsetTemperaturePointHandle(const double x1,const double x2)
|
||
{
|
||
Global::ExperimentData ed = PointCalculate::findOnSetDataByTemperature(x1,x2);
|
||
|
||
if(Global::_axisMode == Global::AxisMode::SingleY){
|
||
return QPointF(ed.sampleTemp,ed.dsc);
|
||
}else{
|
||
return QPointF(ed.runTime,ed.dsc);
|
||
}
|
||
}
|
||
|
||
QPointF CentralWidget::endSetTemperaturePointHandle(const double x1, const double x2)
|
||
{
|
||
Global::ExperimentData ed = PointCalculate::findEndSetDataByTemperature(x1,x2);
|
||
|
||
if(Global::_axisMode == Global::AxisMode::SingleY){
|
||
return QPointF(ed.sampleTemp,ed.dsc);
|
||
}else{
|
||
return QPointF(ed.runTime,ed.dsc);
|
||
}
|
||
}
|
||
|
||
// 二次多项式拟合函数
|
||
void CentralWidget::quadraticFit(const QVector<QPointF>& points, double& a, double& b, double& c) {
|
||
int n = points.size();
|
||
if (n < 3) {
|
||
throw std::invalid_argument("At least three points are required for quadratic fit.");
|
||
}
|
||
|
||
double sumX = 0, sumY = 0, sumXX = 0, sumXY = 0, sumX2Y = 0;
|
||
for (const QPointF& p : points) {
|
||
sumX += p.x();
|
||
sumY += p.y();
|
||
sumXX += p.x() * p.x();
|
||
sumXY += p.x() * p.y();
|
||
sumX2Y += p.x() * p.x() * p.y();
|
||
}
|
||
|
||
double det = n * (sumXX * sumY - sumX * sumXY) - sumX * sumX * sumY + sumX * sumX2Y;
|
||
a = (sumXX * sumY - sumX * sumXY) / det;
|
||
b = (sumX2Y - n * sumXY) / det;
|
||
c = (sumY - a * sumX - b * sumX) / n;
|
||
}
|
||
|
||
// 计算二次多项式拟合曲线的导数（切线斜率）
|
||
double CentralWidget::derivativeAt(const double a, const double b, const double x) {
|
||
return 2 * a * x + b;
|
||
}
|
||
|
||
|
||
void CentralWidget::setEventHandlerEnable(const bool flag)
|
||
{
|
||
logde<<"setEventHandlerEnable..."<<flag;
|
||
|
||
// line visiable func
|
||
auto lineVisiableFunc = [&](QCPItemStraightLine* line){
|
||
line->setSelected(flag);
|
||
line->setVisible(flag);
|
||
};
|
||
|
||
// todo. 当竖线隐藏时，需要设置不可选择模式。
|
||
// _eventHandler->setEnable(flag);
|
||
|
||
#if 1
|
||
// move line to suitable position.
|
||
double xMax = _customPlot->xAxis->range().upper;
|
||
double xMin = _customPlot->xAxis->range().lower;
|
||
|
||
// logde<<"xMax:"<<xMax;
|
||
|
||
// QVector<double> ticks = _customPlot->xAxis->tickVector();
|
||
// int numTicks = ticks.size();
|
||
// logde<<"ticks:"<<numTicks;
|
||
|
||
double range = xMax - xMin;
|
||
double xLeft = xMin + range / 3;
|
||
double xRight = xMin + range * 2 / 3;
|
||
|
||
_line1->point1->setCoords(xLeft,_line1->point1->coords().y());
|
||
_line1->point2->setCoords(xLeft,_line1->point2->coords().y());
|
||
|
||
_line2->point1->setCoords(xRight,_line2->point1->coords().y());
|
||
_line2->point2->setCoords(xRight,_line2->point2->coords().y());
|
||
#endif
|
||
|
||
lineVisiableFunc(_line1);
|
||
if(AnalysisMode::NumericalLabel != _analysisMode){
|
||
lineVisiableFunc(_line2);
|
||
}
|
||
//
|
||
_customPlot->replot();
|
||
}
|
||
|
||
QPointF CentralWidget::getTheCoordinatesOfTheTextBox(const QPointF point)
|
||
{
|
||
double xMax = _customPlot->xAxis->range().upper;
|
||
double xMin = _customPlot->xAxis->range().lower;
|
||
|
||
logde<<"xMax:"<<xMax;
|
||
|
||
QVector<double> ticks = _customPlot->xAxis->tickVector();
|
||
int numTicks = ticks.size();
|
||
// logde<<"ticks:"<<numTicks;
|
||
|
||
double distance = (xMax - xMin) / ticks.size();
|
||
|
||
return QPointF(point.x() + distance,point.y());
|
||
}
|
||
|
||
void CentralWidget::drawText(const QPointF point, const QString text,const QString objectName)
|
||
{
|
||
QPointF textBoxPoint = getTheCoordinatesOfTheTextBox(point);
|
||
|
||
// 创建标注文字（QCPItemText）
|
||
QCPItemText *textLabel = new QCPItemText(_customPlot);
|
||
textLabel->setPositionAlignment(Qt::AlignCenter); // 对齐方式
|
||
textLabel->position->setType(QCPItemPosition::ptPlotCoords); // 使用数据坐标
|
||
textLabel->position->setCoords(textBoxPoint.x(),textBoxPoint.y()); // 设置文本位置在指定点上方
|
||
|
||
textLabel->setText(text); // 设置文本内容
|
||
QFont font(QFont("Arial", 10));
|
||
textLabel->setFont(font);
|
||
textLabel->setSelectedFont(font);
|
||
textLabel->setSelectable(true); // 设置为可选
|
||
|
||
// 设置文本项的位置类型为屏幕坐标比例
|
||
textLabel->position->setTypeX(QCPItemPosition::ptAxisRectRatio);
|
||
textLabel->position->setTypeY(QCPItemPosition::ptAxisRectRatio);
|
||
|
||
ItemManager::addTemporaryQCPItemText(textLabel,objectName);
|
||
|
||
// 创建指向点的线段（QCPItemLine）
|
||
QCPItemLine *arrow = new QCPItemLine(_customPlot);
|
||
arrow->start->setParentAnchor(textLabel->left); // 线段起点绑定到标注文字底部
|
||
arrow->end->setCoords(point.x(),point.y()); // 线段终点设置为指定的点
|
||
arrow->setHead(QCPLineEnding::esSpikeArrow); // 添加箭头
|
||
arrow->setPen(QPen(Qt::red, 1));
|
||
|
||
ItemManager::addTemporaryQCPItemLine(arrow,objectName);
|
||
|
||
// 重绘图表以显示文本标签和箭头
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::fillGraph(const double x1, const double x2,const QString objectName)
|
||
{
|
||
#if 0
|
||
double y1 = PointCalculate::getClosestPointByX(x1).y();
|
||
double y2 = PointCalculate::getClosestPointByX(x2).y();
|
||
|
||
QVector<double> xVtr,yVtr;
|
||
xVtr.push_back(x1);
|
||
xVtr.push_back(x2);
|
||
|
||
yVtr.push_back(y1);
|
||
yVtr.push_back(y2);
|
||
#endif
|
||
|
||
Global::ExperimentData x1Ed = PointCalculate::getClosestDataByTemperature(x1);
|
||
Global::ExperimentData x2Ed = PointCalculate::getClosestDataByTemperature(x2);
|
||
QVector<double> xVtr,yVtr;
|
||
xVtr.push_back(x1Ed.sampleTemp);
|
||
xVtr.push_back(x2Ed.sampleTemp);
|
||
|
||
yVtr.push_back(x1Ed.dsc);
|
||
yVtr.push_back(x2Ed.dsc);
|
||
|
||
if(_axisMode == AxisMode::DoubleY){
|
||
xVtr.clear();
|
||
|
||
xVtr.push_back(x1Ed.runTime);
|
||
xVtr.push_back(x2Ed.runTime);
|
||
}
|
||
|
||
QCPGraph *mainGraph = _customPlot->addGraph();
|
||
mainGraph->setData(xVtr, yVtr);
|
||
mainGraph->setPen(QPen(Qt::red, 1));
|
||
|
||
//
|
||
QVector<Global::ExperimentData> curveDataVtr =
|
||
PointCalculate::getDataInXRange(x1,x2);
|
||
|
||
QCPGraph *fillGraph = _customPlot->addGraph();
|
||
QVector<double> fillX, fillY;
|
||
|
||
for(int i = 0;i < curveDataVtr.size();i++){
|
||
Global::ExperimentData &ed = curveDataVtr[i];
|
||
if(_axisMode == AxisMode::DoubleY){
|
||
fillX<<ed.runTime;
|
||
}else{
|
||
fillX<<ed.sampleTemp;
|
||
}
|
||
fillY<<ed.dsc;
|
||
}
|
||
|
||
fillGraph->setData(fillX, fillY);
|
||
|
||
fillGraph->setBrush(QBrush(Qt::green, Qt::SolidPattern));
|
||
fillGraph->setChannelFillGraph(mainGraph);
|
||
|
||
ItemManager::addTemporaryQCPGraph(mainGraph,objectName);
|
||
ItemManager::addTemporaryQCPGraph(fillGraph,objectName);
|
||
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::clearData(const CentralWidget::ClearDataMode mode)
|
||
{
|
||
switch (mode) {
|
||
case ClearDataMode::All:
|
||
_analysisFilePathVtr.clear();
|
||
// Clear data.
|
||
logde<<"clearExperimentData...";
|
||
Global::clearExperimentData();
|
||
|
||
Global::_curveFileDataVtr.clear();
|
||
|
||
AnalysisOperationRecorder::_analysisOperationVtr.clear();
|
||
|
||
// Set lines visiable false.
|
||
_line1->setVisible(false);
|
||
_line2->setVisible(false);
|
||
|
||
_currentCurve = nullptr;
|
||
|
||
Global::_smoothnessFlag = false;
|
||
case ClearDataMode::JustUi:
|
||
//ui
|
||
clearAllUiData();
|
||
break;
|
||
case ClearDataMode::Undo:
|
||
{
|
||
// Clear the data of graph.
|
||
for (int i = _customPlot->plottableCount() - 1; i >= 0; --i) {
|
||
QCPAbstractPlottable* plottable = _customPlot->plottable(i);
|
||
if (auto curve = dynamic_cast<QCPCurve*>(plottable)) {
|
||
logde<<"clear data,curve object Name:"<<curve->objectName().toStdString();
|
||
if(curve->objectName().contains( ItemManager::TemporaryStr)){
|
||
_customPlot->removePlottable(curve);
|
||
|
||
ItemManager::removeItem(curve);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Clear graph on plot.
|
||
for (int i = _customPlot->graphCount() - 1; i >= 0; --i) {
|
||
QCPGraph *graph = _customPlot->graph(i);
|
||
logde<<"clear data,graph object Name:"<<graph->objectName().toStdString();
|
||
if(graph && graph->objectName().contains(ItemManager::TemporaryStr)){
|
||
_customPlot->removeGraph(graph);
|
||
|
||
ItemManager::removeItem(graph);
|
||
}
|
||
}
|
||
|
||
// Delete items.
|
||
QList<QCPAbstractItem *> itemsToKeep;
|
||
itemsToKeep << _line1 << _line2;
|
||
|
||
for (int i = _customPlot->itemCount() - 1; i >= 0; --i) {
|
||
QCPAbstractItem *item = _customPlot->item(i);
|
||
logde<<"item data,graph object Name:"<<item->objectName().toStdString();
|
||
if(item && !itemsToKeep.contains(item)
|
||
&& item->objectName().contains(ItemManager::TemporaryStr)){
|
||
_customPlot->removeItem(item);
|
||
|
||
ItemManager::removeItem(item);
|
||
}
|
||
}
|
||
|
||
//
|
||
AnalysisOperationRecorder::removeTheLastAnalysisOperation();
|
||
}
|
||
break;
|
||
default:break;
|
||
}
|
||
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::clearAllUiData()
|
||
{
|
||
// Clear the data of graph.
|
||
for (int i = _customPlot->plottableCount() - 1; i >= 0; --i) {
|
||
QCPAbstractPlottable* plottable = _customPlot->plottable(i);
|
||
if (auto curve = dynamic_cast<QCPCurve*>(plottable)) {
|
||
_customPlot->removePlottable(curve);
|
||
|
||
ItemManager::removeItem(curve);
|
||
}
|
||
}
|
||
|
||
// Clear graph on plot.
|
||
for (int i = _customPlot->graphCount() - 1; i >= 0; --i) {
|
||
QCPGraph *graph = _customPlot->graph(i);
|
||
_customPlot->removeGraph(graph);
|
||
|
||
ItemManager::removeItem(graph);
|
||
}
|
||
|
||
// Delete items.
|
||
QList<QCPAbstractItem *> itemsToKeep;
|
||
itemsToKeep << _line1 << _line2;
|
||
|
||
for (int i = _customPlot->itemCount() - 1; i >= 0; --i) {
|
||
QCPAbstractItem *item = _customPlot->item(i);
|
||
if (!itemsToKeep.contains(item)) {
|
||
_customPlot->removeItem(item);
|
||
|
||
ItemManager::removeItem(item);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CentralWidget::deleteCurve(const QString objectName)
|
||
{
|
||
for (int i = _analysisFilePathVtr.size() - 1; i >= 0; --i) {
|
||
if (_analysisFilePathVtr[i].startsWith(objectName)) {
|
||
_analysisFilePathVtr.removeAt(i); // 从后往前删除避免索引错乱
|
||
}
|
||
}
|
||
|
||
ItemManager::removeItemsByObjectName(objectName);
|
||
|
||
AnalysisOperationRecorder::removeAnalysisOperationByObjectName(objectName);
|
||
|
||
// Clear the data of graph.
|
||
for (int i = _customPlot->plottableCount() - 1; i >= 0; --i) {
|
||
QCPAbstractPlottable* plottable = _customPlot->plottable(i);
|
||
if (auto curve = dynamic_cast<QCPCurve*>(plottable)) {
|
||
logde<<"clear data,curve object Name:"<<curve->objectName().toStdString();
|
||
if(curve->objectName().contains(objectName)){
|
||
_customPlot->removePlottable(curve);
|
||
|
||
ItemManager::removeItem(curve);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Clear graph on plot.
|
||
for (int i = _customPlot->graphCount() - 1; i >= 0; --i) {
|
||
QCPGraph *graph = _customPlot->graph(i);
|
||
logde<<"clear data,graph object Name:"<<graph->objectName().toStdString();
|
||
if(graph && graph->objectName().contains(objectName)){
|
||
_customPlot->removeGraph(graph);
|
||
|
||
ItemManager::removeItem(graph);
|
||
}
|
||
}
|
||
|
||
// Delete items.
|
||
QList<QCPAbstractItem *> itemsToKeep;
|
||
itemsToKeep << _line1 << _line2;
|
||
|
||
for (int i = _customPlot->itemCount() - 1; i >= 0; --i) {
|
||
QCPAbstractItem *item = _customPlot->item(i);
|
||
logde<<"item data,graph object Name:"<<item->objectName().toStdString();
|
||
if(item && !itemsToKeep.contains(item)
|
||
&& item->objectName().contains(objectName)){
|
||
_customPlot->removeItem(item);
|
||
|
||
ItemManager::removeItem(item);
|
||
}
|
||
}
|
||
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::loadAnalysisData(
|
||
const AnalysisMode mode,const double x1,const double x2,const QString objectName)
|
||
{
|
||
switch (mode) {
|
||
case AnalysisMode::NumericalLabel:
|
||
{
|
||
// QPointF selectPoint = PointCalculate::getClosestPointByX(x1);
|
||
|
||
Global::ExperimentData ed = PointCalculate::getClosestDataByTemperature(x1);
|
||
|
||
if(Global::isZero(ed.dsc)){
|
||
QMessageBox::warning((QWidget*)this->parent(), "warnning", "曲线选择错误.");
|
||
return;
|
||
}
|
||
|
||
QPointF selectPoint(ed.sampleTemp,ed.dsc);
|
||
QString str = PointCalculate::textFormatNumbericalLabel(selectPoint);
|
||
if(_axisMode == AxisMode::DoubleY){
|
||
selectPoint.setX(ed.runTime);
|
||
str = PointCalculate::textFormatNumbericalLabelWithTime(selectPoint);
|
||
}
|
||
|
||
drawText(selectPoint,str,objectName);
|
||
|
||
break;
|
||
}
|
||
case AnalysisMode::StartPoint:
|
||
case AnalysisMode::StopPoint:{
|
||
PointCalculate::setRegionPointX(x1,x2);
|
||
|
||
// QPair<QPointF, QPointF> startEndPointPair =
|
||
// PointCalculate::calculateStartAndEndPoint();
|
||
|
||
QPair<Global::ExperimentData,Global::ExperimentData>
|
||
startEndDataPair = PointCalculate::calculateStartAndEndData();
|
||
|
||
//
|
||
QPointF point;
|
||
QString str;
|
||
|
||
if(mode == AnalysisMode::StartPoint){
|
||
if(_axisMode == AxisMode::SingleY){
|
||
point = QPointF(startEndDataPair.first.sampleTemp,startEndDataPair.first.dsc);
|
||
str = PointCalculate::textFormatStartPoint(point);
|
||
}else{
|
||
point = QPointF(startEndDataPair.first.runTime,startEndDataPair.first.dsc);
|
||
str = PointCalculate::textFormatStartPointWithTime(point);
|
||
}
|
||
}else{
|
||
if(_axisMode == AxisMode::SingleY){
|
||
point = QPointF(startEndDataPair.second.sampleTemp,startEndDataPair.second.dsc);
|
||
str = PointCalculate::textFormatEndPoint(point);
|
||
}else{
|
||
point = QPointF(startEndDataPair.second.runTime,startEndDataPair.second.dsc);
|
||
str = PointCalculate::textFormatEndPointWithTime(point);
|
||
}
|
||
}
|
||
|
||
drawText(point,str,objectName);
|
||
|
||
//
|
||
break;
|
||
}
|
||
case AnalysisMode::PeakSynthesisAnalysis:
|
||
{
|
||
fillGraph(x1,x2,objectName);
|
||
|
||
PointCalculate::setRegionPointX(x1,x2);
|
||
|
||
//enthalpy
|
||
double sampleWeight = 1.0f;
|
||
for(Global::CurveFileData& cfd:Global::_curveFileDataVtr){
|
||
for(Global::PhaseTotalInfo& pti:cfd.phaseTotalVtr){
|
||
|
||
#if 0
|
||
if(_currentCurve && _currentCurve == pti.curve){
|
||
sampleWeight = cfd.ei.sampleWeight.toDouble();
|
||
}
|
||
#endif
|
||
if(_currentCurve){
|
||
if(_currentCurve == pti.curve){
|
||
sampleWeight = cfd.ei.sampleWeight.toDouble();
|
||
}else{
|
||
}
|
||
}else{
|
||
// logde<<"current curve nullptr.";
|
||
}
|
||
}
|
||
}
|
||
|
||
if(sampleWeight <= 0){
|
||
logde<<"sample weight set value 1,"<<sampleWeight;
|
||
sampleWeight = 1;
|
||
}
|
||
|
||
double enthalpyValue = PointCalculate::calculateArea() / sampleWeight;
|
||
|
||
logde<<"enthalpyValue:"<<enthalpyValue;
|
||
|
||
// peak
|
||
QPointF peakPoint = PointCalculate::getPeakPoint();
|
||
|
||
// start point and end point
|
||
QPair<QPointF, QPointF> startEndPointPair =
|
||
PointCalculate::calculateStartAndEndPoint();
|
||
|
||
logde<<"start,end:"<<startEndPointPair.first.x()<<","
|
||
<<startEndPointPair.second.x();
|
||
|
||
QString str;
|
||
if(_axisMode == AxisMode::DoubleY){
|
||
double peakPointTime = PointCalculate::obtainTimeValueBasedOnTemperatureValue(peakPoint.x());
|
||
double startPointTime = PointCalculate::obtainTimeValueBasedOnTemperatureValue(startEndPointPair.first.x());
|
||
double endPointTime = PointCalculate::obtainTimeValueBasedOnTemperatureValue(startEndPointPair.second.x());
|
||
|
||
str = PointCalculate::textFormatPeakPointWithTime(
|
||
enthalpyValue,
|
||
peakPointTime,
|
||
startPointTime,
|
||
endPointTime);
|
||
|
||
Global::ExperimentData peakPointEd =
|
||
PointCalculate::getClosestDataByTemperature(peakPoint.x());
|
||
|
||
peakPoint = QPointF(peakPointEd.runTime,peakPointEd.dsc);
|
||
|
||
drawText(peakPoint,str,objectName);
|
||
}
|
||
else if(Global::_displayTimeValue){
|
||
double peakPointTime = PointCalculate::obtainTimeValueBasedOnTemperatureValue(peakPoint.x());
|
||
double startPointTime = PointCalculate::obtainTimeValueBasedOnTemperatureValue(startEndPointPair.first.x());
|
||
double endPointTime = PointCalculate::obtainTimeValueBasedOnTemperatureValue(startEndPointPair.second.x());
|
||
|
||
str = PointCalculate::textFormatPeakPointWithTime(
|
||
enthalpyValue,
|
||
peakPointTime,
|
||
startPointTime,
|
||
endPointTime);
|
||
|
||
drawText(peakPoint,str,objectName);
|
||
|
||
}else{
|
||
str = PointCalculate::textFormatPeakPoint(enthalpyValue,
|
||
peakPoint.x(),
|
||
startEndPointPair.first.x(),
|
||
startEndPointPair.second.x());
|
||
drawText(peakPoint,str,objectName);
|
||
}
|
||
|
||
//
|
||
break;
|
||
}
|
||
case AnalysisMode::GlassTransition:
|
||
{
|
||
glassTransitionHandle(x1,x2,objectName);
|
||
|
||
//
|
||
break;
|
||
}
|
||
case AnalysisMode::OnsetTemperaturePoint:{
|
||
QPointF point = onsetTemperaturePointHandle(x1,x2);
|
||
logde<<"onset point:"<<point.x()<<","<<point.y();
|
||
|
||
QString str = QString::number(point.x(),'f',3);
|
||
drawText(point,str,objectName);
|
||
|
||
break;
|
||
}
|
||
case AnalysisMode::EndsetTemperaturePoint:{
|
||
QPointF point = endSetTemperaturePointHandle(x1,x2);
|
||
|
||
QString str = QString::number(point.x(),'f',3);
|
||
logde<<"object name:"<<objectName.toStdString();
|
||
drawText(point,str,objectName);
|
||
|
||
break;
|
||
}
|
||
case AnalysisMode::OIT:{
|
||
logde<<"oit x1,x2:"<<x1<<","<<x2;
|
||
|
||
Global::ExperimentData ed = PointCalculate::findOnSetDataByTime(x1,x2);
|
||
|
||
// Global::ExperimentData ed = PointCalculate::findOnSetDataByTemperature(x1,x2);
|
||
|
||
// PointCalculate::setRegionPointX(x1,x2);
|
||
|
||
Global::ExperimentData startData = PointCalculate::_dataVtr.first();
|
||
|
||
// QPair<Global::ExperimentData,Global::ExperimentData>
|
||
// startEndDataPair = PointCalculate::calculateStartAndEndData();
|
||
|
||
logde<<"start data time:"<<startData.runTime;
|
||
logde<<"end data time:"<<ed.runTime;
|
||
|
||
drawOITLine(startData,ed);
|
||
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
void CentralWidget::drawOITLine(const Global::ExperimentData startData,const Global::ExperimentData endData)
|
||
{
|
||
#if 0
|
||
// Draw start vertical line.
|
||
QVector<double> xVtr,yVtr;
|
||
xVtr.push_back(startData.runTime);
|
||
xVtr.push_back(startData.runTime);
|
||
|
||
yVtr.push_back(startData.dsc - 10);
|
||
yVtr.push_back(startData.dsc - 20);
|
||
|
||
QCPGraph *startLine = _customPlot->addGraph();
|
||
startLine->setData(xVtr, yVtr);
|
||
startLine->setPen(QPen(Qt::red, 1));
|
||
|
||
// Draw end vertical line.
|
||
xVtr.clear();
|
||
yVtr.clear();
|
||
xVtr.push_back(endData.runTime);
|
||
xVtr.push_back(endData.runTime);
|
||
|
||
yVtr.push_back(endData.dsc - 10);
|
||
yVtr.push_back(endData.dsc - 20);
|
||
|
||
QCPGraph *endLine = _customPlot->addGraph();
|
||
endLine->setData(xVtr, yVtr);
|
||
endLine->setPen(QPen(Qt::red, 1));
|
||
#endif
|
||
|
||
// Draw start line.
|
||
QCPItemLine *startLine = new QCPItemLine(_customPlot);
|
||
startLine->start->setCoords(startData.runTime,startData.dsc - 10);
|
||
startLine->end->setCoords(startData.runTime,startData.dsc - 20);
|
||
startLine->setPen(QPen(Qt::red, 1));
|
||
// Draw end line.
|
||
QCPItemLine *endLine = new QCPItemLine(_customPlot);
|
||
endLine->start->setCoords(endData.runTime,endData.dsc - 10);
|
||
endLine->end->setCoords(endData.runTime,endData.dsc - 20);
|
||
endLine->setPen(QPen(Qt::red, 1));
|
||
|
||
// Draw total line.
|
||
QCPItemLine *totalLine = new QCPItemLine(_customPlot);
|
||
totalLine->start->setCoords(startData.runTime,startData.dsc - 15);
|
||
totalLine->end->setCoords(endData.runTime,endData.dsc - 15);
|
||
totalLine->setPen(QPen(Qt::red, 1));
|
||
|
||
// Draw title.
|
||
double textX = (endData.runTime - startData.runTime) / 2 + endData.runTime;
|
||
|
||
QCPItemText *textLabel = new QCPItemText(_customPlot);
|
||
textLabel->setPositionAlignment(Qt::AlignCenter); // 对齐方式
|
||
textLabel->position->setType(QCPItemPosition::ptPlotCoords); // 使用数据坐标
|
||
textLabel->position->setCoords(textX,startData.dsc - 20); // 设置文本位置在指定点上方
|
||
|
||
textLabel->setText("OIT:123.44"); // 设置文本内容
|
||
QFont font(QFont("Arial", 10));
|
||
textLabel->setFont(font);
|
||
textLabel->setSelectedFont(font);
|
||
textLabel->setSelectable(true); // 设置为可选
|
||
|
||
_customPlot->replot();
|
||
}
|
||
|
||
void CentralWidget::clearAllData()
|
||
{
|
||
Global::_mode = Global::Mode::Analysis;
|
||
clearData(ClearDataMode::All);
|
||
}
|
||
|
||
QPixmap CentralWidget::getPixMap()
|
||
{
|
||
_customPlot->replot();
|
||
QApplication::processEvents();
|
||
return _customPlot->toPixmap();
|
||
}
|
||
|
||
void CentralWidget::slotAxisModify(const float temp)
|
||
{
|
||
_customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables);
|
||
|
||
float value = temp + 20;
|
||
|
||
_customPlot->xAxis->setRange(10,value);
|
||
_customPlot->yAxis->setRange(-5,5);
|
||
}
|
||
|
||
|
||
|