596 lines
27 KiB
C++
596 lines
27 KiB
C++
#include "MeasureAnalysisParticleCountPlotView.h"
|
|
#include "CustomQwtPlot.h"
|
|
#include "csv.h"
|
|
#include <GlobalDefine.h>
|
|
#include <QHBoxLayout>
|
|
#include <QPen>
|
|
#include <QRegularExpression>
|
|
#include <QVector>
|
|
#include <QwtLegend>
|
|
#include <QwtPlotCanvas>
|
|
#include <QwtPlotCurve>
|
|
#include <QMenu>
|
|
#include <QAction>
|
|
#include <QCheckBox>
|
|
#include <QDialog>
|
|
#include <QwtText>
|
|
#include <QPushButton>
|
|
#include "MeasureAnalysisProjectModel.h"
|
|
#include <QDir>
|
|
#include "DataProcessWorkPool.h"
|
|
#include <QLabel>
|
|
#include <QComboBox>
|
|
#include <QTableWidget>
|
|
#include <QSpinBox>
|
|
#include <fstream>
|
|
#include <QHeaderView>
|
|
#include <QwtPlotMarker>
|
|
#include <QwtPlotZoneItem>
|
|
#include <QwtScaleMap>
|
|
|
|
static auto extractNumber = [](const QString& str) {
|
|
int ret_num = 0;
|
|
QRegularExpression regex("\\d+");
|
|
QRegularExpressionMatch match = regex.match(str);
|
|
if (match.hasMatch()) {
|
|
ret_num = match.captured().toInt();
|
|
}
|
|
return ret_num;
|
|
};
|
|
|
|
MeasureAnalysisParticleCountPlotView::MeasureAnalysisParticleCountPlotView(QWidget* parent)
|
|
: MeasureAnalysisView { parent }
|
|
{
|
|
this->setViewType(PlotFrame);
|
|
|
|
QHBoxLayout* layout = new QHBoxLayout(this);
|
|
this->_plot = new CustomQwtPlot(this);
|
|
layout->addWidget(this->_plot);
|
|
|
|
setupPlot();
|
|
|
|
this->_menu = new QMenu(this);
|
|
setupMenu();
|
|
}
|
|
|
|
MeasureAnalysisParticleCountPlotView::~MeasureAnalysisParticleCountPlotView()
|
|
{
|
|
LOG_DEBUG(QStringLiteral(u"%1析构.").arg(this->GetViewName()));
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::InitViewWorkspace(const QString &project_name)
|
|
{
|
|
if (project_name.isEmpty()) {
|
|
return;
|
|
}
|
|
auto project_model = ProjectList::Instance()->GetProjectModel(project_name);
|
|
if ( !project_model ) {
|
|
return;
|
|
}
|
|
QDir project_dir(project_model->GetProjectDir());
|
|
QString workspace = project_dir.filePath("AddressCountSpectrumView");
|
|
if ( QDir(workspace).exists() ) {
|
|
this->_workspace = workspace;
|
|
} else if (project_dir.mkpath(workspace) ) {
|
|
this->_workspace = workspace;
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::SetAnalyzeDataFilename(const QMap<QString, QVariant>& data_files_set)
|
|
{
|
|
QStringList ch_count_data_name = data_files_set.keys();
|
|
std::sort(ch_count_data_name.begin(), ch_count_data_name.end(), [](const QString& a, const QString& b) {
|
|
int num_a = extractNumber(a);
|
|
int num_b = extractNumber(b);
|
|
return num_a < num_b;
|
|
});
|
|
for (const QString& ch_count_data_name : ch_count_data_name) {
|
|
if (ch_count_data_name.contains(ch_count_data_name)) {
|
|
const QString ch_count_data_filename = data_files_set[ch_count_data_name].toString();
|
|
loadDataFromFile(ch_count_data_name, ch_count_data_filename);
|
|
}
|
|
}
|
|
_data_files_set_ptr = data_files_set;
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::setupMenu()
|
|
{
|
|
this->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(this, &MeasureAnalysisParticleCountPlotView::customContextMenuRequested, [this](const QPoint &pos){
|
|
this->_menu->exec(this->mapToGlobal(pos));
|
|
});
|
|
QAction* action_plot_reset = this->_menu->addAction(QStringLiteral(u"还原"));
|
|
action_plot_reset->setObjectName("curve_show_setting");
|
|
connect(action_plot_reset, &QAction::triggered, [this](){
|
|
this->_plot->ResetPlot();
|
|
});
|
|
this->_menu->addSeparator();
|
|
QAction* action_set_curve_show = this->_menu->addAction(QStringLiteral(u"选择曲线"));
|
|
action_set_curve_show->setObjectName("curve_show_setting");
|
|
connect(action_set_curve_show, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onCurveShowSetting);
|
|
QMenu* menu_find_peaks = this->_menu->addMenu(QStringLiteral(u"寻峰"));
|
|
QAction* action_find_peaks_result = menu_find_peaks->addAction(QStringLiteral(u"寻峰结果"));
|
|
action_find_peaks_result->setObjectName("manual_find_peaks");
|
|
connect(action_find_peaks_result, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onFindPeaksResult);
|
|
QAction* action_auto_find_peaks = menu_find_peaks->addAction(QStringLiteral(u"自动寻峰"));
|
|
action_auto_find_peaks->setObjectName("auto_find_peaks");
|
|
connect(action_auto_find_peaks, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onAutoFindPeaks);
|
|
QAction* action_manual_find_peaks = menu_find_peaks->addAction(QStringLiteral(u"手动寻峰"));
|
|
action_manual_find_peaks->setObjectName("manual_find_peaks");
|
|
connect(action_auto_find_peaks, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onManualFindPeaks);
|
|
QAction* action_set_energy_scale = this->_menu->addAction(QStringLiteral(u"能量刻度"));
|
|
action_set_energy_scale->setObjectName("energy_scale");
|
|
connect(action_set_energy_scale, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onEneryScale);
|
|
QAction* action_plot_config = this->_menu->addAction(QStringLiteral(u"图表配置"));
|
|
action_plot_config->setObjectName("plot_config");
|
|
connect(action_plot_config, &QAction::triggered, this, &MeasureAnalysisParticleCountPlotView::onPlotConfigure);
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::setupPlot()
|
|
{
|
|
_plot->setTitle(QString(QStringLiteral(u"粒子计数谱")));
|
|
|
|
_plot->setCanvasBackground(Qt::white);
|
|
QwtPlotCanvas* canvas = qobject_cast<QwtPlotCanvas*>(_plot->canvas());
|
|
canvas->setFrameStyle(QFrame::NoFrame);
|
|
|
|
_plot->setAxisTitle(QwtPlot::xBottom, QString(QStringLiteral(u"道址")));
|
|
_plot->setAxisTitle(QwtPlot::yLeft, QString(QStringLiteral(u"计数")));
|
|
// set axis auto scale
|
|
_plot->setAxisAutoScale(QwtPlot::xBottom, true);
|
|
_plot->setAxisAutoScale(QwtPlot::yLeft, true);
|
|
// 启用网格线
|
|
_plot->enableAxis(QwtPlot::xBottom);
|
|
_plot->enableAxis(QwtPlot::yLeft);
|
|
|
|
// 设置QWT图例
|
|
QwtLegend* legend = new QwtLegend();
|
|
legend->setDefaultItemMode(QwtLegendData::ReadOnly);
|
|
_plot->insertLegend(legend, QwtPlot::RightLegend);
|
|
|
|
// new CustomQwtPlotXaxisPanner(_plot->canvas());
|
|
new CustomQwtPlotXaxisMagnifier(_plot->canvas());
|
|
_plot->SetXaxisDragScale(true);
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::loadDataFromFile(const QString& data_name, const QString& filename)
|
|
{
|
|
std::string address_str = QString(QStringLiteral(u"道址")).toStdString();
|
|
std::string count_str = QString(QStringLiteral(u"计数")).toStdString();
|
|
|
|
io::CSVReader<
|
|
2,
|
|
io::trim_chars<' ', '\t'>,
|
|
io::double_quote_escape<',', '"'>,
|
|
io::throw_on_overflow,
|
|
io::empty_line_comment>
|
|
reader(QStrToSysPath(filename));
|
|
reader.read_header(io::ignore_extra_column, address_str, count_str);
|
|
|
|
int address;
|
|
int particle_count;
|
|
QVector<float> x, y;
|
|
|
|
while (reader.read_row(address, particle_count)) {
|
|
x.push_back(address);
|
|
y.push_back(particle_count);
|
|
}
|
|
|
|
// 绘制曲线
|
|
QwtPlotCurve* curve = new QwtPlotCurve(data_name);
|
|
curve->setSamples(x, y);
|
|
_plot->AddCurve(curve);
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::loadPeaksResultToTable(QTableWidget *peaks_result_table)
|
|
{
|
|
this->_plot->CleanMarkers();
|
|
this->_plot->replot();
|
|
if (!peaks_result_table)
|
|
return;
|
|
peaks_result_table->setCurrentItem(nullptr);
|
|
peaks_result_table->setProperty("WatchItemChanged", false);
|
|
|
|
auto row_count = peaks_result_table->rowCount();
|
|
for (int i = row_count - 1; i >= 0; i--) {
|
|
peaks_result_table->removeRow(i);
|
|
}
|
|
const QString& channel_col_name = QString(QStringLiteral(u"通道"));
|
|
const QString& peak_pos_col_name = QString(QStringLiteral(u"峰位"));
|
|
const QString& left_bound_col_name = QString(QStringLiteral(u"左边界"));
|
|
const QString& right_bound_col_name = QString(QStringLiteral(u"右边界"));
|
|
const QString& peak_width_col_name = QString(QStringLiteral(u"峰宽"));
|
|
const QString& peaks_result_filename = QDir(this->_workspace).filePath("AutoFindPeaksResult.csv");
|
|
io::CSVReader<
|
|
5,
|
|
io::trim_chars<' ', '\t'>,
|
|
io::double_quote_escape<',', '"'>,
|
|
io::throw_on_overflow,
|
|
io::empty_line_comment
|
|
> reader(QStrToSysPath(peaks_result_filename));
|
|
reader.read_header(io::ignore_extra_column,
|
|
channel_col_name.toStdString(),
|
|
peak_pos_col_name.toStdString(),
|
|
left_bound_col_name.toStdString(),
|
|
right_bound_col_name.toStdString(),
|
|
peak_width_col_name.toStdString()
|
|
);
|
|
std::string ch_name; int peak_pos; int left_bound, right_bound, peak_width;
|
|
while (reader.read_row(ch_name, peak_pos, left_bound, right_bound, peak_width))
|
|
{
|
|
if (!ch_name.empty()) {
|
|
int row = peaks_result_table->rowCount();
|
|
peaks_result_table->insertRow(row);
|
|
peaks_result_table->setItem(row, 0, new QTableWidgetItem(QString::fromStdString(ch_name)));
|
|
peaks_result_table->item(row, 0)->setCheckState(Qt::Unchecked);
|
|
peaks_result_table->setItem(row, 1, new QTableWidgetItem(QString::number(peak_pos)));
|
|
peaks_result_table->setItem(row, 2, new QTableWidgetItem(QString::number(left_bound)));
|
|
peaks_result_table->setItem(row, 3, new QTableWidgetItem(QString::number(right_bound)));
|
|
peaks_result_table->setItem(row, 4, new QTableWidgetItem(QString::number(peak_width)));
|
|
QTableWidgetItem* item = new QTableWidgetItem;
|
|
peaks_result_table->setItem(row, 5, item);
|
|
QPushButton* btn_remove_row = new QPushButton(QStringLiteral(u"删除"));
|
|
connect(btn_remove_row, &QPushButton::clicked, [this, peaks_result_table, item, btn_remove_row](){
|
|
item->setCheckState(Qt::Unchecked);
|
|
this->updatePlotPeakInfoByTableItem(item, false);
|
|
int remove_row = item->row();
|
|
peaks_result_table->removeRow(remove_row);
|
|
btn_remove_row->deleteLater();
|
|
});
|
|
peaks_result_table->setCellWidget(row, 5, btn_remove_row);
|
|
}
|
|
}
|
|
peaks_result_table->setProperty("WatchItemChanged", true);
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::updatePlotPeakInfo(QVariantMap peak_infos)
|
|
{
|
|
const QString& channel = peak_infos["channel"].toString();
|
|
int peak_pos = peak_infos["peak_pos"].toInt();
|
|
int left_bound = peak_infos["left_bound"].toInt();
|
|
int right_bound = peak_infos["right_bound"].toInt();
|
|
int peak_width = peak_infos["peak_width"].toInt();
|
|
bool is_checked = peak_infos["checked"].toBool();
|
|
bool is_show_peak_area = peak_infos["show_peak_area"].toBool();
|
|
const QString& postion = QString::number(peak_pos);
|
|
|
|
QwtPlotMarker* peak_marker = this->_plot->GetMarker(channel, postion);
|
|
if ((!peak_marker) && is_checked) {
|
|
peak_marker = new QwtPlotMarker();
|
|
peak_marker->setLineStyle(QwtPlotMarker::VLine);
|
|
peak_marker->setValue(peak_pos, 0.0);
|
|
peak_marker->setLabelAlignment(Qt::AlignTop | Qt::AlignRight);
|
|
const QString& label_text = QStringLiteral(u"峰位:%1\n峰宽:%2\n左界:%3\n右界:%4\n").arg(postion).arg(peak_width).arg(left_bound).arg(right_bound);
|
|
peak_marker->setLabel(label_text);
|
|
this->_plot->AddMarker(peak_marker, channel, postion);
|
|
} else if (!is_checked) {
|
|
this->_plot->RemoveMarker(channel, postion);
|
|
}
|
|
QwtPlotZoneItem* peak_area_zone_item = this->_plot->GetZoneItem(channel);
|
|
if (!peak_area_zone_item && is_show_peak_area) {
|
|
peak_area_zone_item = new QwtPlotZoneItem;
|
|
peak_area_zone_item->setOrientation(Qt::Vertical);
|
|
peak_area_zone_item->setInterval(left_bound, right_bound);
|
|
this->_plot->AddZoneItem(peak_area_zone_item, channel);
|
|
} else if ((!is_checked) || (!is_show_peak_area)) {
|
|
this->_plot->RemoveZoneItem(channel);
|
|
}
|
|
this->_plot->replot();
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::updatePlotPeakInfoByTableItem(QTableWidgetItem *item, bool checked, bool show_peak_area)
|
|
{
|
|
if (item) {
|
|
auto peaks_result_table = item->tableWidget();
|
|
int row = item->row();
|
|
bool is_checked = bool(peaks_result_table->item(row, 0)->checkState() == Qt::Checked);
|
|
const QString& channel = peaks_result_table->item(row, 0)->text();
|
|
int peak_pos = peaks_result_table->item(row, 1)->text().toInt();
|
|
int left_bound = peaks_result_table->item(row, 2)->text().toInt();
|
|
int right_bound = peaks_result_table->item(row, 3)->text().toInt();
|
|
int peak_width = peaks_result_table->item(row, 4)->text().toInt();
|
|
QVariantMap peak_infos;
|
|
peak_infos["channel"] = channel;
|
|
peak_infos["peak_pos"] = peak_pos;
|
|
peak_infos["left_bound"] = left_bound;
|
|
peak_infos["right_bound"] = right_bound;
|
|
peak_infos["peak_width"] = peak_width;
|
|
peak_infos["checked"] = is_checked || checked;
|
|
peak_infos["show_peak_area"] = show_peak_area || checked;
|
|
this->updatePlotPeakInfo(peak_infos);
|
|
qDebug() << channel << ", " << peak_pos << ", " << bool(is_checked || checked);
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onAutoFindPeaksFinished(const QString &project_name)
|
|
{
|
|
Q_UNUSED(project_name);
|
|
if (_find_peaks_result_dlg) {
|
|
for (const auto& child_obj : _find_peaks_result_dlg->children()) {
|
|
if ( "peaks_result_table" == child_obj->objectName() ) {
|
|
QTableWidget* table = qobject_cast<QTableWidget*>(child_obj);
|
|
if ( table ) {
|
|
loadPeaksResultToTable(table);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
onFindPeaksResult();
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onCurveShowSetting()
|
|
{
|
|
if (!_curve_show_setting_dlg) {
|
|
_curve_show_setting_dlg = new QDialog(this, Qt::Dialog | Qt::WindowCloseButtonHint);
|
|
_curve_show_setting_dlg->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
|
|
_curve_show_setting_dlg->setSizeGripEnabled(false);
|
|
_curve_show_setting_dlg->setWindowTitle(QString(QStringLiteral(u"选择%1曲线显示").arg(this->_plot->title().text())));
|
|
_curve_show_setting_dlg->setWindowModality(Qt::WindowModal);
|
|
_curve_show_setting_dlg->setModal(false);
|
|
QVBoxLayout* layout = new QVBoxLayout(_curve_show_setting_dlg);
|
|
// 自动计算多列排布
|
|
QMap<QwtPlotCurve*, QCheckBox*> curve_checkbox_map;
|
|
int num_columns = std::sqrt(this->_plot->GetCurveList().size());
|
|
if (num_columns == 0) num_columns = 1;
|
|
QVBoxLayout* checkbox_layout = new QVBoxLayout();
|
|
QHBoxLayout* checkbox_column_layout = new QHBoxLayout();
|
|
QStringList list_ch_names;
|
|
for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
|
|
list_ch_names.append(curve->title().text());
|
|
}
|
|
std::sort(list_ch_names.begin(), list_ch_names.end(), [](const QString& a, const QString& b) {
|
|
int num_a = extractNumber(a);
|
|
int num_b = extractNumber(b);
|
|
return num_a < num_b;
|
|
});
|
|
for (const QString& ch_name : list_ch_names) {
|
|
QwtPlotCurve* curve = this->_plot->GetCurve(ch_name);
|
|
QCheckBox* check_box = new QCheckBox(curve->title().text());
|
|
check_box->setChecked(curve->isVisible());
|
|
checkbox_column_layout->addWidget(check_box);
|
|
connect(check_box, &QCheckBox::stateChanged, [curve](int state){
|
|
curve->setVisible(state == Qt::Checked);
|
|
curve->plot()->replot();
|
|
});
|
|
curve_checkbox_map[curve] = check_box;
|
|
if (checkbox_column_layout->count() >= num_columns) {
|
|
checkbox_layout->addLayout(checkbox_column_layout);
|
|
checkbox_column_layout = new QHBoxLayout();
|
|
}
|
|
}
|
|
if (checkbox_column_layout->count() < num_columns) {
|
|
checkbox_column_layout->addStretch();
|
|
}
|
|
checkbox_layout->addLayout(checkbox_column_layout);
|
|
// 全选和反选
|
|
auto curveCheckboxUpdate = [this, curve_checkbox_map](){
|
|
for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
|
|
curve_checkbox_map[curve]->setChecked(curve->isVisible());
|
|
}
|
|
};
|
|
QHBoxLayout* button_layout = new QHBoxLayout();
|
|
QPushButton* btn_all_select = new QPushButton(QString(QStringLiteral(u"全选")));
|
|
connect(btn_all_select, &QPushButton::clicked, [this, curveCheckboxUpdate](){
|
|
for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
|
|
curve->setVisible(true);
|
|
}
|
|
curveCheckboxUpdate();
|
|
this->_plot->replot();
|
|
});
|
|
button_layout->addWidget(btn_all_select);
|
|
QPushButton* btn_reserve_select = new QPushButton(QString(QStringLiteral(u"反选")));
|
|
connect(btn_reserve_select, &QPushButton::clicked, [this, curveCheckboxUpdate](){
|
|
for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
|
|
curve->setVisible(!curve->isVisible());
|
|
}
|
|
curveCheckboxUpdate();
|
|
this->_plot->replot();
|
|
});
|
|
button_layout->addWidget(btn_reserve_select);
|
|
|
|
layout->addLayout(button_layout);
|
|
layout->addLayout(checkbox_layout);
|
|
}
|
|
_curve_show_setting_dlg->show();
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onFindPeaksResult()
|
|
{
|
|
if (!_find_peaks_result_dlg) {
|
|
_find_peaks_result_dlg = new QDialog(this, Qt::Dialog | Qt::WindowCloseButtonHint);
|
|
_find_peaks_result_dlg->setWindowTitle(QString(QStringLiteral(u"寻峰结果")));
|
|
_find_peaks_result_dlg->setWindowModality(Qt::WindowModal);
|
|
_find_peaks_result_dlg->setModal(false);
|
|
|
|
QPushButton* btn_all_select = new QPushButton(QString(QStringLiteral(u"全选")));
|
|
QPushButton* btn_reserve_select = new QPushButton(QString(QStringLiteral(u"反选")));
|
|
QLabel* filter_channel_label = new QLabel(QString(QStringLiteral(u"筛选通道:")));
|
|
QComboBox* filter_channel_combo_box = new QComboBox();
|
|
filter_channel_combo_box->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
|
|
filter_channel_combo_box->addItem(QString(QStringLiteral(u"所有通道")));
|
|
QStringList list_ch_names;
|
|
for (QwtPlotCurve* curve : this->_plot->GetCurveList()) {
|
|
list_ch_names.append(curve->title().text());
|
|
}
|
|
std::sort(list_ch_names.begin(), list_ch_names.end(), [](const QString& a, const QString& b) {
|
|
int num_a = extractNumber(a);
|
|
int num_b = extractNumber(b);
|
|
return num_a < num_b;
|
|
});
|
|
filter_channel_combo_box->addItems(list_ch_names);
|
|
filter_channel_combo_box->setMaxVisibleItems(10);
|
|
filter_channel_combo_box->view()->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
|
|
QPushButton* btn_save = new QPushButton(QString(QStringLiteral(u"保存")));
|
|
QHBoxLayout* top_layout = new QHBoxLayout();
|
|
top_layout->addWidget(btn_all_select);
|
|
top_layout->addWidget(btn_reserve_select);
|
|
top_layout->addSpacing(10);
|
|
top_layout->addWidget(filter_channel_label);
|
|
top_layout->addWidget(filter_channel_combo_box);
|
|
top_layout->addSpacing(10);
|
|
top_layout->addWidget(btn_save);
|
|
|
|
const QString& channel_col_name = QString(QStringLiteral(u"通道"));
|
|
const QString& peak_pos_col_name = QString(QStringLiteral(u"峰位"));
|
|
const QString& left_bound_col_name = QString(QStringLiteral(u"左边界"));
|
|
const QString& right_bound_col_name = QString(QStringLiteral(u"右边界"));
|
|
const QString& peak_width_col_name = QString(QStringLiteral(u"峰宽"));
|
|
const QString& operation_col_name = QString(QStringLiteral(u"操作"));
|
|
QTableWidget* peaks_result_table = new QTableWidget();
|
|
peaks_result_table->setObjectName("peaks_result_table");
|
|
peaks_result_table->setColumnCount(6);
|
|
peaks_result_table->setHorizontalHeaderLabels({
|
|
channel_col_name, peak_pos_col_name, left_bound_col_name, right_bound_col_name, peak_width_col_name, operation_col_name
|
|
});
|
|
peaks_result_table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
|
|
peaks_result_table->horizontalHeader()->setSectionResizeMode(peaks_result_table->columnCount() -1, QHeaderView::ResizeToContents);
|
|
peaks_result_table->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft|Qt::AlignVCenter);
|
|
peaks_result_table->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
peaks_result_table->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
peaks_result_table->setEditTriggers(QTableWidget::NoEditTriggers);
|
|
this->loadPeaksResultToTable(peaks_result_table);
|
|
|
|
connect(filter_channel_combo_box, &QComboBox::currentTextChanged, [this, peaks_result_table](const QString& text){
|
|
peaks_result_table->setCurrentItem(nullptr);
|
|
auto row_count = peaks_result_table->rowCount();
|
|
if (text == QString(QStringLiteral(u"所有通道"))) {
|
|
for (int i = 0; i < row_count - 1; i++) {
|
|
peaks_result_table->setRowHidden(i, false);
|
|
}
|
|
} else {
|
|
for (int i = row_count - 1; i >= 0 ; i--) {
|
|
const QString& channel = peaks_result_table->item(i, 0)->text();
|
|
bool is_hidden = text == channel ? false : true;
|
|
peaks_result_table->setRowHidden(i, is_hidden);
|
|
}
|
|
}
|
|
});
|
|
connect(btn_all_select, &QPushButton::clicked, [peaks_result_table](){
|
|
peaks_result_table->setCurrentItem(nullptr);
|
|
auto row_count = peaks_result_table->rowCount();
|
|
for (int i = 0; i < row_count - 1; i++) {
|
|
if (peaks_result_table->isRowHidden(i)) {
|
|
continue;
|
|
}
|
|
auto item = peaks_result_table->item(i, 0);
|
|
if (item) {
|
|
item->setCheckState(Qt::Checked);
|
|
}
|
|
}
|
|
});
|
|
connect(btn_reserve_select, &QPushButton::clicked, [peaks_result_table](){
|
|
peaks_result_table->setCurrentItem(nullptr);
|
|
auto row_count = peaks_result_table->rowCount();
|
|
for (int i = 0; i < row_count - 1; i++) {
|
|
if (peaks_result_table->isRowHidden(i)) {
|
|
continue;
|
|
}
|
|
auto item = peaks_result_table->item(i, 0);
|
|
if (item) {
|
|
Qt::CheckState check_state = (item->checkState() == Qt::Checked) ? Qt::Unchecked : Qt::Checked;
|
|
item->setCheckState(check_state);
|
|
}
|
|
}
|
|
});
|
|
connect(btn_save, &QPushButton::clicked, [peaks_result_table, this](){
|
|
const QString& peaks_result_filename = QDir(this->_workspace).filePath("AutoFindPeaksResult.csv");
|
|
std::ofstream out_file(QStrToSysPath(peaks_result_filename));
|
|
|
|
std::string channel_str = QString(QStringLiteral(u"通道")).toStdString();
|
|
std::string addr_str = QString(QStringLiteral(u"峰位")).toStdString();
|
|
std::string left_addr_str = QString(QStringLiteral(u"左边界")).toStdString();
|
|
std::string lright_addr_str = QString(QStringLiteral(u"右边界")).toStdString();
|
|
std::string width_str = QString(QStringLiteral(u"峰宽")).toStdString();
|
|
out_file << channel_str << "," << addr_str << "," << left_addr_str << "," << lright_addr_str << "," << width_str << "\n";
|
|
|
|
auto row_count = peaks_result_table->rowCount();
|
|
for (int i = 0; i < row_count - 1; i++) {
|
|
std::string channel = peaks_result_table->item(i, 0)->text().toStdString();
|
|
int peak_pos = peaks_result_table->item(i, 1)->text().toInt();
|
|
int left_bound = peaks_result_table->item(i, 2)->text().toInt();
|
|
int right_bound = peaks_result_table->item(i, 3)->text().toInt();
|
|
int peak_width = peaks_result_table->item(i, 4)->text().toInt();
|
|
out_file << channel << "," << peak_pos << "," << left_bound << "," << right_bound << "," << peak_width << "\n";
|
|
}
|
|
LOG_INFO(QStringLiteral(u"保存峰信息完成."));
|
|
});
|
|
connect(peaks_result_table, &QTableWidget::itemChanged, [this, peaks_result_table](QTableWidgetItem *item){
|
|
bool is_watch_item_changed = peaks_result_table->property("WatchItemChanged").toBool();
|
|
if (is_watch_item_changed && bool(item->column() == 0)) {
|
|
this->updatePlotPeakInfoByTableItem(item);
|
|
}
|
|
});
|
|
connect(peaks_result_table, &QTableWidget::currentItemChanged, [this, peaks_result_table](QTableWidgetItem *current, QTableWidgetItem *previous){
|
|
bool is_watch_item_changed = peaks_result_table->property("WatchItemChanged").toBool();
|
|
if (is_watch_item_changed) {
|
|
this->updatePlotPeakInfoByTableItem(previous, false, false);
|
|
this->updatePlotPeakInfoByTableItem(current, true, true);
|
|
}
|
|
});
|
|
|
|
QVBoxLayout* layout = new QVBoxLayout(_find_peaks_result_dlg);
|
|
layout->addLayout(top_layout);
|
|
layout->addWidget(peaks_result_table);
|
|
}
|
|
_find_peaks_result_dlg->show();
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onAutoFindPeaks()
|
|
{
|
|
QDialog set_find_peak_step_win_width_dlg(this, Qt::Dialog | Qt::WindowCloseButtonHint);
|
|
set_find_peak_step_win_width_dlg.setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
|
|
set_find_peak_step_win_width_dlg.setFixedSize(300, 50);
|
|
set_find_peak_step_win_width_dlg.setSizeGripEnabled(false);
|
|
set_find_peak_step_win_width_dlg.setWindowTitle(QString(QStringLiteral(u"设置自动寻峰步宽")));
|
|
|
|
QLabel* set_step_width_label = new QLabel(QString(QStringLiteral(u"自动寻峰步宽:")));
|
|
QSpinBox * spinbox_set_step_width = new QSpinBox();
|
|
spinbox_set_step_width->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
|
|
spinbox_set_step_width->setRange(7, 65535);
|
|
QHBoxLayout* layout_input = new QHBoxLayout();
|
|
layout_input->addWidget(set_step_width_label);
|
|
layout_input->addWidget(spinbox_set_step_width);
|
|
|
|
QPushButton* btn_ok = new QPushButton(QStringLiteral(u"确认"));
|
|
connect(btn_ok, &QPushButton::clicked, &set_find_peak_step_win_width_dlg, &QDialog::accept);
|
|
QPushButton* btn_cancel = new QPushButton(QStringLiteral(u"取消"));
|
|
connect(btn_cancel, &QPushButton::clicked, &set_find_peak_step_win_width_dlg, &QDialog::reject);
|
|
QHBoxLayout* layout_btns = new QHBoxLayout();
|
|
layout_btns->addStretch();
|
|
layout_btns->addWidget(btn_ok);
|
|
layout_btns->addWidget(btn_cancel);
|
|
|
|
QVBoxLayout* layout = new QVBoxLayout(&set_find_peak_step_win_width_dlg);
|
|
layout->addLayout(layout_input);
|
|
layout->addStretch();
|
|
layout->addLayout(layout_btns);
|
|
|
|
if (QDialog::Accepted == set_find_peak_step_win_width_dlg.exec() ) {
|
|
int step_width = spinbox_set_step_width->value();
|
|
const QString& project_name = GetProjectName();
|
|
auto auto_find_peaks_task = new DataProcessWorkPool::AutoFindPeaksTask;
|
|
auto_find_peaks_task->SetAnalysisType(this->GetAnalyzeType());
|
|
auto_find_peaks_task->SetDataFileList(this->_data_files_set_ptr);
|
|
auto_find_peaks_task->SetFindPeakSetpWinWidth(step_width);
|
|
auto_find_peaks_task->SetResultDir(this->_workspace);
|
|
auto_find_peaks_task->SetFinishedNotifier(this, "onAutoFindPeaksFinished", project_name);
|
|
auto_find_peaks_task->StartTask();
|
|
}
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onManualFindPeaks()
|
|
{
|
|
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onEneryScale()
|
|
{
|
|
|
|
}
|
|
|
|
void MeasureAnalysisParticleCountPlotView::onPlotConfigure()
|
|
{
|
|
|
|
}
|