You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1683 lines
60 KiB
1683 lines
60 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany // |
|
// written by Christian Daniel // |
|
// Copyright (C) 2014 John Greb <karikoa@One.greyskull> // |
|
// Copyright (C) 2015, 2017-2023 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2018 beta-tester <alpha-beta-release@gmx.net> // |
|
// Copyright (C) 2022-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2023 Arne Jünemann <das-iro@das-iro.de> // |
|
// Copyright (C) 2023 Daniele Forsi <iu5hkx@gmail.com> // |
|
// // |
|
// OpenGL interface modernization. // |
|
// See: http://doc.qt.io/qt-5/qopenglshaderprogram.html // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <QLineEdit> |
|
#include <QToolTip> |
|
#include <QFileDialog> |
|
#include <QInputDialog> |
|
#include <QMessageBox> |
|
#include <QScreen> |
|
|
|
#include "gui/glspectrumgui.h" |
|
#include "dsp/fftwindow.h" |
|
#include "dsp/spectrumvis.h" |
|
#include "gui/glspectrum.h" |
|
#include "gui/glspectrumview.h" |
|
#include "gui/crightclickenabler.h" |
|
#include "gui/wsspectrumsettingsdialog.h" |
|
#include "gui/spectrummarkersdialog.h" |
|
#include "gui/spectrumcalibrationpointsdialog.h" |
|
#include "gui/spectrummeasurementsdialog.h" |
|
#include "gui/spectrummeasurements.h" |
|
#include "gui/spectrumdisplaysettingsdialog.h" |
|
#include "gui/flowlayout.h" |
|
#include "gui/dialogpositioner.h" |
|
#include "gui/dialpopup.h" |
|
#include "util/colormap.h" |
|
#include "util/db.h" |
|
#include "util/csv.h" |
|
#include "util/units.h" |
|
#include "ui_glspectrumgui.h" |
|
|
|
const int GLSpectrumGUI::m_fpsMs[] = {500, 200, 100, 50, 20, 10, 5}; |
|
|
|
GLSpectrumGUI::GLSpectrumGUI(QWidget* parent) : |
|
QWidget(parent), |
|
ui(new Ui::GLSpectrumGUI), |
|
m_spectrumVis(nullptr), |
|
m_glSpectrum(nullptr), |
|
m_doApplySettings(true), |
|
m_calibrationShiftdB(0.0), |
|
m_markersDialog(nullptr), |
|
m_contextMenu(nullptr) |
|
{ |
|
ui->setupUi(this); |
|
|
|
// Use the custom flow layout for the 3 main horizontal layouts (lines) |
|
ui->verticalLayout->removeItem(ui->Line7Layout); |
|
ui->verticalLayout->removeItem(ui->Line6Layout); |
|
ui->verticalLayout->removeItem(ui->Line5Layout); |
|
ui->verticalLayout->removeItem(ui->Line4Layout); |
|
ui->verticalLayout->removeItem(ui->Line3Layout); |
|
ui->verticalLayout->removeItem(ui->Line2Layout); |
|
ui->verticalLayout->removeItem(ui->Line1Layout); |
|
FlowLayout *flowLayout = new FlowLayout(nullptr, 1, 1, 1); |
|
flowLayout->addItem(ui->Line1Layout); |
|
flowLayout->addItem(ui->Line2Layout); |
|
flowLayout->addItem(ui->Line3Layout); |
|
flowLayout->addItem(ui->Line4Layout); |
|
flowLayout->addItem(ui->Line5Layout); |
|
flowLayout->addItem(ui->Line6Layout); |
|
flowLayout->addItem(ui->Line7Layout); |
|
ui->verticalLayout->addItem(flowLayout); |
|
|
|
on_linscale_toggled(false); |
|
//displayMeasurementGUI(); |
|
|
|
QString levelStyle = QString( |
|
"QSpinBox {background-color: rgb(79, 79, 79);}" |
|
"QLineEdit {color: white; background-color: rgb(79, 79, 79); border: 1px solid gray; border-radius: 4px;}" |
|
"QTooltip {color: white; background-color: black;}" |
|
); |
|
ui->refLevel->setStyleSheet(levelStyle); |
|
ui->levelRange->setStyleSheet(levelStyle); |
|
ui->fftOverlap->setStyleSheet(levelStyle); |
|
|
|
ui->colorMap->addItems(ColorMap::getColorMapNames()); |
|
ui->colorMap->setCurrentText("Angel"); |
|
|
|
connect(&m_messageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages())); |
|
|
|
CRightClickEnabler *wsSpectrumRightClickEnabler = new CRightClickEnabler(ui->wsSpectrum); |
|
connect(wsSpectrumRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openWebsocketSpectrumSettingsDialog(const QPoint &))); |
|
|
|
CRightClickEnabler *calibrationPointsRightClickEnabler = new CRightClickEnabler(ui->calibration); |
|
connect(calibrationPointsRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openCalibrationPointsDialog(const QPoint &))); |
|
|
|
m_contextMenu = new QMenu(this); |
|
ui->mem1->setContextMenuPolicy(Qt::CustomContextMenu); |
|
connect(ui->mem1, &QWidget::customContextMenuRequested, this, &GLSpectrumGUI::mem1ContextMenu); |
|
ui->mem2->setContextMenuPolicy(Qt::CustomContextMenu); |
|
connect(ui->mem2, &QWidget::customContextMenuRequested, this, &GLSpectrumGUI::mem2ContextMenu); |
|
|
|
connect(ui->mathAvgCount->lineEdit(), &QLineEdit::editingFinished, this, &GLSpectrumGUI::on_mathAvgCount_editingFinished); |
|
|
|
DialPopup::addPopupsToChildDials(this); |
|
|
|
displaySettings(); |
|
setAveragingCombo(); |
|
} |
|
|
|
GLSpectrumGUI::~GLSpectrumGUI() |
|
{ |
|
if (m_markersDialog) { |
|
delete m_markersDialog; |
|
} |
|
|
|
delete ui; |
|
} |
|
|
|
void GLSpectrumGUI::setBuddies(SpectrumVis* spectrumVis, GLSpectrum* glSpectrum) |
|
{ |
|
m_spectrumVis = spectrumVis; |
|
m_glSpectrum = glSpectrum; |
|
// Asked for through the web API: the arithmetic and the annotation markers live here |
|
connect(m_glSpectrum, &GLSpectrum::requestAutoscale, this, [this]() { on_autoscale_clicked(false); }); |
|
connect(m_glSpectrum, &GLSpectrum::requestGotoMarker, this, [this](int index) { on_gotoMarker_currentIndexChanged(index + 1); }); |
|
m_glSpectrum->setSpectrumVis(spectrumVis); |
|
m_glSpectrum->setMessageQueueToGUI(&m_messageQueue); |
|
m_spectrumVis->setMessageQueueToGUI(&m_messageQueue); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::resetToDefaults() |
|
{ |
|
m_settings.resetToDefaults(); |
|
displaySettings(); |
|
applySettings(); |
|
} |
|
|
|
QByteArray GLSpectrumGUI::serialize() const |
|
{ |
|
const_cast<GLSpectrumGUI*>(this)->m_settings.getHistogramMarkers() = m_glSpectrum->getHistogramMarkers(); |
|
const_cast<GLSpectrumGUI*>(this)->m_settings.getWaterfallMarkers() = m_glSpectrum->getWaterfallMarkers(); |
|
return m_settings.serialize(); |
|
} |
|
|
|
bool GLSpectrumGUI::deserialize(const QByteArray& data) |
|
{ |
|
if (m_settings.deserialize(data)) |
|
{ |
|
m_glSpectrum->setHistogramMarkers(m_settings.getHistogramMarkers()); |
|
m_glSpectrum->setWaterfallMarkers(m_settings.getWaterfallMarkers()); |
|
m_glSpectrum->setFrequencyZooming(m_settings.m_frequencyZoomFactor, m_settings.m_frequencyZoomPos); |
|
setAveragingCombo(); |
|
displaySettings(); // restores the blocked state it found |
|
applySettings(); |
|
return true; |
|
} |
|
else |
|
{ |
|
resetToDefaults(); |
|
return false; |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::formatTo(SWGSDRangel::SWGObject *swgObject) const |
|
{ |
|
m_settings.formatTo(swgObject); |
|
} |
|
|
|
void GLSpectrumGUI::updateFrom(const QStringList& keys, const SWGSDRangel::SWGObject *swgObject) |
|
{ |
|
m_settings.updateFrom(keys, swgObject); |
|
} |
|
|
|
void GLSpectrumGUI::updateSettings() |
|
{ |
|
displaySettings(); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::displaySettings() |
|
{ |
|
bool blocked = blockApplySettings(true); |
|
ui->showControls->setCurrentIndex((int) m_settings.m_showControls); |
|
setPowerAndRefRange(); |
|
ui->refLevel->setValue(m_settings.m_refLevel + m_calibrationShiftdB); |
|
ui->levelRange->setValue(m_settings.m_powerRange); |
|
ui->decay->setSliderPosition(m_settings.m_decay); |
|
ui->decayDivisor->setSliderPosition(m_settings.m_decayDivisor); |
|
ui->stroke->setSliderPosition(m_settings.m_histogramStroke); |
|
ui->waterfall->blockSignals(true); |
|
ui->spectrogram->blockSignals(true); |
|
ui->waterfall->setChecked(m_settings.m_displayWaterfall); |
|
ui->spectrogram->setChecked(m_settings.m_display3DSpectrogram); |
|
ui->waterfall->blockSignals(false); |
|
ui->spectrogram->blockSignals(false); |
|
ui->spectrogramStyle->setCurrentIndex((int) m_settings.m_3DSpectrogramStyle); |
|
ui->spectrogramStyle->setVisible(m_settings.m_display3DSpectrogram && (m_settings.m_showControls == SpectrumSettings::ShowAll)); |
|
ui->colorMap->setCurrentText(m_settings.m_colorMap); |
|
ui->currentLine->blockSignals(true); |
|
ui->currentFill->blockSignals(true); |
|
ui->currentGradient->blockSignals(true); |
|
ui->currentLine->setChecked(m_settings.m_displayCurrent && (m_settings.m_spectrumStyle == SpectrumSettings::SpectrumStyle::Line)); |
|
ui->currentFill->setChecked(m_settings.m_displayCurrent && (m_settings.m_spectrumStyle == SpectrumSettings::SpectrumStyle::Fill)); |
|
ui->currentGradient->setChecked(m_settings.m_displayCurrent && (m_settings.m_spectrumStyle == SpectrumSettings::SpectrumStyle::Gradient)); |
|
ui->currentLine->blockSignals(false); |
|
ui->currentFill->blockSignals(false); |
|
ui->currentGradient->blockSignals(false); |
|
ui->maxHold->setChecked(m_settings.m_displayMaxHold); |
|
ui->histogram->setChecked(m_settings.m_displayHistogram); |
|
ui->invertWaterfall->setChecked(m_settings.m_invertedWaterfall); |
|
ui->grid->setChecked(m_settings.m_displayGrid); |
|
ui->gridIntensity->setSliderPosition(m_settings.m_displayGridIntensity); |
|
ui->truncateScale->setChecked(m_settings.m_truncateFreqScale); |
|
|
|
ui->decay->setToolTip(QString("Decay: %1").arg(m_settings.m_decay)); |
|
ui->decayDivisor->setToolTip(QString("Decay divisor: %1").arg(m_settings.m_decayDivisor)); |
|
ui->stroke->setToolTip(QString("Stroke: %1").arg(m_settings.m_histogramStroke)); |
|
ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_settings.m_displayGridIntensity)); |
|
ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_settings.m_displayTraceIntensity)); |
|
|
|
ui->fftWindow->blockSignals(true); |
|
ui->averaging->blockSignals(true); |
|
ui->averagingMode->blockSignals(true); |
|
ui->linscale->blockSignals(true); |
|
ui->mathMode->blockSignals(true); |
|
ui->mathAvgCount->blockSignals(true); |
|
|
|
ui->fftWindow->setCurrentIndex(m_settings.m_fftWindow); |
|
|
|
for (int i = SpectrumSettings::m_log2FFTSizeMin; i <= SpectrumSettings::m_log2FFTSizeMax; i++) |
|
{ |
|
if (m_settings.m_fftSize == (1 << i)) |
|
{ |
|
ui->fftSize->setCurrentIndex(i - SpectrumSettings::m_log2FFTSizeMin); |
|
break; |
|
} |
|
} |
|
|
|
setFFTSizeToolitp(); |
|
unsigned int i = 0; |
|
|
|
for (; i < sizeof(m_fpsMs)/sizeof(m_fpsMs[0]); i++) |
|
{ |
|
if (m_settings.m_fpsPeriodMs >= m_fpsMs[i]) { |
|
break; |
|
} |
|
} |
|
|
|
ui->fps->setCurrentIndex(i); |
|
|
|
ui->fftOverlap->setValue(m_settings.m_fftOverlap); |
|
setMaximumOverlap(); |
|
ui->averaging->setCurrentIndex(m_settings.m_averagingIndex); |
|
ui->averagingMode->setCurrentIndex((int) m_settings.m_averagingMode); |
|
ui->linscale->setChecked(m_settings.m_linear); |
|
setAveragingToolitp(); |
|
ui->mathMode->setCurrentIndex((int) m_settings.m_mathMode); |
|
int idx = findEquivalentText(ui->mathAvgCount, m_settings.m_mathAvgCount); |
|
if (idx >= 0) { |
|
ui->mathAvgCount->setCurrentIndex(idx); |
|
} else { |
|
ui->mathAvgCount->setCurrentText(QString::number(m_settings.m_mathAvgCount)); |
|
} |
|
ui->mathAvgCount->setVisible(m_settings.mathAverageUsed()); |
|
ui->calibration->setChecked(m_settings.m_useCalibration); |
|
ui->resetMeasurements->setVisible(m_settings.m_measurement >= SpectrumSettings::MeasurementChannelPower); |
|
displayGotoMarkers(); |
|
displayControls(); |
|
|
|
ui->mem1->setChecked(m_settings.m_spectrumMemory[0].m_display); |
|
ui->mem2->setChecked(m_settings.m_spectrumMemory[1].m_display); |
|
|
|
ui->fftWindow->blockSignals(false); |
|
ui->averaging->blockSignals(false); |
|
ui->averagingMode->blockSignals(false); |
|
ui->linscale->blockSignals(false); |
|
ui->mathMode->blockSignals(false); |
|
ui->mathAvgCount->blockSignals(false); |
|
blockApplySettings(blocked); |
|
|
|
updateMeasurements(); |
|
} |
|
|
|
void GLSpectrumGUI::displayControls() |
|
{ |
|
ui->grid->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->gridIntensity->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->truncateScale->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->clearSpectrum->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->histogram->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->maxHold->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->decay->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->decayDivisor->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->stroke->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->currentLine->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->currentFill->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->currentGradient->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->traceIntensity->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->colorMap->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->invertWaterfall->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->waterfall->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->spectrogram->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->spectrogramStyle->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll && m_settings.m_display3DSpectrogram); |
|
ui->fftWindow->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->fftSize->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->fftOverlap->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->mathMode->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->mathAvgCount->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll && m_settings.mathAverageUsed()); |
|
ui->fps->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->linscale->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->mem1->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->mem2->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->load->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->save->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->saveImage->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->wsSpectrum->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowAll); |
|
ui->calibration->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->markers->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
ui->measure->setVisible(m_settings.m_showControls >= SpectrumSettings::ShowStandard); |
|
} |
|
|
|
void GLSpectrumGUI::displayGotoMarkers() |
|
{ |
|
ui->gotoMarker->clear(); |
|
ui->gotoMarker->addItem("Go to..."); |
|
|
|
for (auto marker : m_settings.m_annoationMarkers) |
|
{ |
|
if (marker.m_show != SpectrumAnnotationMarker::Hidden) |
|
{ |
|
qint64 freq = marker.m_startFrequency + marker.m_bandwidth/2; |
|
QString freqString = displayScaled(freq, 'f', 3, true); |
|
ui->gotoMarker->addItem(QString("%1 - %2").arg(marker.m_text).arg(freqString)); |
|
} |
|
} |
|
|
|
ui->gotoMarker->setVisible(m_glSpectrum && m_glSpectrum->isDeviceSpectrum() && (ui->gotoMarker->count() > 1)); |
|
} |
|
|
|
QString GLSpectrumGUI::displayScaled(int64_t value, char type, int precision, bool showMult) |
|
{ |
|
int64_t posValue = (value < 0) ? -value : value; |
|
|
|
if (posValue < 1000) { |
|
return tr("%1").arg(QString::number(value, type, precision)); |
|
} else if (posValue < 1000000) { |
|
return tr("%1%2").arg(QString::number(value / 1000.0, type, precision)).arg(showMult ? "k" : ""); |
|
} else if (posValue < 1000000000) { |
|
return tr("%1%2").arg(QString::number(value / 1000000.0, type, precision)).arg(showMult ? "M" : ""); |
|
} else if (posValue < 1000000000000) { |
|
return tr("%1%2").arg(QString::number(value / 1000000000.0, type, precision)).arg(showMult ? "G" : ""); |
|
} else { |
|
return tr("%1").arg(QString::number(value, 'e', precision)); |
|
} |
|
} |
|
|
|
bool GLSpectrumGUI::blockApplySettings(bool block) |
|
{ |
|
bool blocked = !m_doApplySettings; |
|
m_doApplySettings = !block; |
|
return blocked; |
|
} |
|
|
|
void GLSpectrumGUI::applySettings() |
|
{ |
|
if (!m_doApplySettings) { |
|
return; |
|
} |
|
|
|
if (m_spectrumVis) |
|
{ |
|
SpectrumVis::MsgConfigureSpectrumVis *msg = SpectrumVis::MsgConfigureSpectrumVis::create(m_settings, false); |
|
m_spectrumVis->getInputMessageQueue()->push(msg); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::applySpectrumSettings() |
|
{ |
|
m_glSpectrum->setDisplayWaterfall(m_settings.m_displayWaterfall); |
|
m_glSpectrum->setDisplay3DSpectrogram(m_settings.m_display3DSpectrogram); |
|
m_glSpectrum->set3DSpectrogramStyle(m_settings.m_3DSpectrogramStyle); |
|
m_glSpectrum->setSpectrumColor(m_settings.m_spectrumColor); |
|
m_glSpectrum->setColorMapName(m_settings.m_colorMap); |
|
m_glSpectrum->setSpectrumStyle(m_settings.m_spectrumStyle); |
|
m_glSpectrum->setInvertedWaterfall(m_settings.m_invertedWaterfall); |
|
m_glSpectrum->setDisplayMaxHold(m_settings.m_displayMaxHold); |
|
m_glSpectrum->setDisplayCurrent(m_settings.m_displayCurrent); |
|
m_glSpectrum->setDisplayHistogram(m_settings.m_displayHistogram); |
|
m_glSpectrum->setDecay(m_settings.m_decay); |
|
m_glSpectrum->setDecayDivisor(m_settings.m_decayDivisor); |
|
m_glSpectrum->setHistoStroke(m_settings.m_histogramStroke); |
|
m_glSpectrum->setDisplayGrid(m_settings.m_displayGrid); |
|
m_glSpectrum->setDisplayGridIntensity(m_settings.m_displayGridIntensity); |
|
m_glSpectrum->setDisplayTraceIntensity(m_settings.m_displayTraceIntensity); |
|
m_glSpectrum->setWaterfallShare(m_settings.m_waterfallShare); |
|
|
|
if ((m_settings.m_averagingMode == SpectrumSettings::AvgModeFixed) || (m_settings.m_averagingMode == SpectrumSettings::AvgModeMax)) { |
|
m_glSpectrum->setTimingRate(SpectrumSettings::getAveragingValue(m_settings.m_averagingIndex, m_settings.m_averagingMode) == 0 ? |
|
1 : |
|
SpectrumSettings::getAveragingValue(m_settings.m_averagingIndex, m_settings.m_averagingMode)); |
|
} else { |
|
m_glSpectrum->setTimingRate(1); |
|
} |
|
|
|
Real refLevel = m_settings.m_linear ? pow(10.0, m_settings.m_refLevel/10.0) : m_settings.m_refLevel; |
|
Real powerRange = m_settings.m_linear ? pow(10.0, m_settings.m_refLevel/10.0) : m_settings.m_powerRange; |
|
qDebug("GLSpectrumGUI::applySpectrumSettings: refLevel: %e powerRange: %e", refLevel, powerRange); |
|
m_glSpectrum->setReferenceLevel(refLevel); |
|
m_glSpectrum->setReferenceLevelRange(ui->refLevel->minimum(), ui->refLevel->maximum()); |
|
m_glSpectrum->setPowerRange(powerRange); |
|
m_glSpectrum->setPowerRangeRange(ui->levelRange->minimum(), ui->levelRange->maximum()); |
|
m_glSpectrum->setFPSPeriodMs(m_settings.m_fpsPeriodMs); |
|
m_glSpectrum->setFreqScaleTruncationMode(m_settings.m_truncateFreqScale); |
|
m_glSpectrum->setLinear(m_settings.m_linear); |
|
m_glSpectrum->setUseCalibration(m_settings.m_useCalibration); |
|
|
|
m_glSpectrum->setHistogramMarkers(m_settings.m_histogramMarkers); |
|
m_glSpectrum->setWaterfallMarkers(m_settings.m_waterfallMarkers); |
|
m_glSpectrum->setAnnotationMarkers(m_settings.m_annoationMarkers); |
|
m_glSpectrum->setMarkersDisplay(m_settings.m_markersDisplay); |
|
m_glSpectrum->setCalibrationPoints(m_settings.m_calibrationPoints); |
|
m_glSpectrum->setCalibrationInterpMode(m_settings.m_calibrationInterpMode); |
|
|
|
m_glSpectrum->setScrolling(m_settings.m_scrollBar, m_settings.m_scrollLength); |
|
m_glSpectrum->setWaterfallTimeFormat(m_settings.m_waterfallTimeUnits, m_settings.m_waterfallTimeFormat); |
|
m_glSpectrum->setStatusLine(m_settings.m_displayRBW, m_settings.m_displayCursorStats, m_settings.m_displayPeakStats); |
|
|
|
for (int i = 0; i < m_settings.m_spectrumMemory.size(); i++) { |
|
m_glSpectrum->setMemory(i, m_settings.m_spectrumMemory[i]); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::setPowerAndRefRange() |
|
{ |
|
const Real maxSignal = 120.0f; // 20-bits |
|
|
|
if ( (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusAvgDB) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusM1DB) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusM2DB) |
|
) |
|
{ |
|
ui->levelRange->setRange(1.0f, 2.0f * maxSignal); |
|
ui->refLevel->setRange(-maxSignal, maxSignal); |
|
} |
|
else if ( (m_settings.m_mathMode == SpectrumSettings::MathModeAbsXMinusAvgDB) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeAbsXMinusM1DB) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeAbsXMinusM2DB) |
|
) |
|
{ |
|
ui->levelRange->setRange(1.0f, maxSignal); |
|
ui->refLevel->setRange(0.0f, maxSignal); |
|
} |
|
else |
|
{ |
|
ui->levelRange->setRange(1.0f, maxSignal); |
|
ui->refLevel->setRange(-maxSignal, 0.0f); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_fftWindow_currentIndexChanged(int index) |
|
{ |
|
qDebug("GLSpectrumGUI::on_fftWindow_currentIndexChanged: %d", index); |
|
m_settings.m_fftWindow = (FFTWindow::Function) index; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_fftSize_currentIndexChanged(int index) |
|
{ |
|
qDebug("GLSpectrumGUI::on_fftSize_currentIndexChanged: %d", index); |
|
m_settings.m_fftSize = 1 << (SpectrumSettings::m_log2FFTSizeMin + index); |
|
setAveragingCombo(); |
|
setMaximumOverlap(); |
|
applySettings(); |
|
setAveragingToolitp(); |
|
setFFTSizeToolitp(); |
|
} |
|
|
|
void GLSpectrumGUI::on_fftOverlap_valueChanged(int value) |
|
{ |
|
qDebug("GLSpectrumGUI::on_fftOverlap_valueChanged: %d", value); |
|
m_settings.m_fftOverlap = value; |
|
setMaximumOverlap(); |
|
applySettings(); |
|
setAveragingToolitp(); |
|
} |
|
|
|
void GLSpectrumGUI::on_autoscale_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
// Autoscale according to currently displayed spectrum (which may be old, if scrolling enabled) |
|
|
|
if (!m_glSpectrum) { |
|
return; |
|
} |
|
|
|
std::vector<Real> psd; |
|
m_glSpectrum->getDisplayedSpectrumCopy(psd, true); |
|
int avgRange = m_settings.m_fftSize / 32; |
|
|
|
if (psd.size() < (unsigned int) avgRange) { |
|
return; |
|
} |
|
|
|
std::sort(psd.begin(), psd.end()); |
|
float max = psd[psd.size() - 1]; |
|
float minSum = 0.0f; |
|
|
|
for (int i = 0; i < avgRange; i++) { |
|
minSum += psd[i]; |
|
} |
|
|
|
float minAvg = minSum / avgRange; |
|
int minLvl; |
|
int maxLvl; |
|
if (m_settings.m_linear) |
|
{ |
|
minLvl = CalcDb::dbPower(minAvg*2); |
|
maxLvl = CalcDb::dbPower(max*10); |
|
} |
|
else |
|
{ |
|
minLvl = minAvg + 3; |
|
maxLvl = max + 10; |
|
} |
|
|
|
m_settings.m_refLevel = maxLvl; |
|
m_settings.m_powerRange = maxLvl - minLvl; |
|
ui->refLevel->setValue(m_settings.m_refLevel + m_calibrationShiftdB); |
|
ui->levelRange->setValue(m_settings.m_powerRange); |
|
// qDebug("GLSpectrumGUI::on_autoscale_clicked: max: %d min %d max: %e min: %e", |
|
// maxLvl, minLvl, maxAvg, minAvg); |
|
|
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_averagingMode_currentIndexChanged(int index) |
|
{ |
|
qDebug("GLSpectrumGUI::on_averagingMode_currentIndexChanged: %d", index); |
|
m_settings.m_averagingMode = index < 0 ? |
|
SpectrumSettings::AvgModeNone : |
|
(SpectrumSettings::AveragingMode) index; |
|
|
|
setAveragingCombo(); |
|
applySettings(); |
|
setAveragingToolitp(); |
|
} |
|
|
|
void GLSpectrumGUI::on_averaging_currentIndexChanged(int index) |
|
{ |
|
qDebug("GLSpectrumGUI::on_averaging_currentIndexChanged: %d", index); |
|
m_settings.m_averagingIndex = index; |
|
applySettings(); |
|
setAveragingToolitp(); |
|
} |
|
|
|
void GLSpectrumGUI::on_mathMode_currentIndexChanged(int index) |
|
{ |
|
m_settings.m_mathMode = (SpectrumSettings::MathMode) index; |
|
ui->mathAvgCount->setVisible((m_settings.m_showControls >= SpectrumSettings::ShowAll) && m_settings.mathAverageUsed()); |
|
setMathMemory(); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_mathAvgCount_currentIndexChanged(int index) |
|
{ |
|
(void) index; |
|
|
|
int value = Units::engUnitsToPosInt(ui->mathAvgCount->currentText(), 2); |
|
m_settings.m_mathAvgCount = std::min(std::max(2, value), 1000000); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_mathAvgCount_editingFinished() |
|
{ |
|
int value = Units::engUnitsToPosInt(ui->mathAvgCount->currentText(), 2); |
|
m_settings.m_mathAvgCount = std::min(std::max(2, value), 1000000); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_linscale_toggled(bool checked) |
|
{ |
|
qDebug("GLSpectrumGUI::on_averaging_currentIndexChanged: %s", checked ? "lin" : "log"); |
|
m_settings.m_linear = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_wsSpectrum_toggled(bool checked) |
|
{ |
|
if (m_spectrumVis) |
|
{ |
|
SpectrumVis::MsgConfigureWSpectrumOpenClose *msg = SpectrumVis::MsgConfigureWSpectrumOpenClose::create(checked); |
|
m_spectrumVis->getInputMessageQueue()->push(msg); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_markers_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
if (!m_glSpectrum || m_markersDialog) { |
|
return; |
|
} |
|
|
|
m_markersDialog = new SpectrumMarkersDialog( |
|
m_glSpectrum->getHistogramMarkers(), |
|
m_glSpectrum->getWaterfallMarkers(), |
|
m_glSpectrum->getAnnotationMarkers(), |
|
m_glSpectrum->getMarkersDisplay(), |
|
m_glSpectrum->getHistogramFindPeaks(), |
|
m_calibrationShiftdB, |
|
this |
|
); |
|
|
|
m_markersDialog->setCenterFrequency(m_glSpectrum->getCenterFrequency()); |
|
m_markersDialog->setPower(m_glSpectrum->getPowerMax() / 2.0f); |
|
m_markersDialog->setTime(m_glSpectrum->getTimeMax() / 2.0f); |
|
|
|
connect(m_markersDialog, SIGNAL(updateHistogram()), this, SLOT(updateHistogramMarkers())); |
|
connect(m_markersDialog, SIGNAL(updateWaterfall()), this, SLOT(updateWaterfallMarkers())); |
|
connect(m_markersDialog, SIGNAL(updateAnnotations()), this, SLOT(updateAnnotationMarkers())); |
|
connect(m_markersDialog, SIGNAL(updateMarkersDisplay()), this, SLOT(updateMarkersDisplay())); |
|
connect(m_markersDialog, SIGNAL(finished(int)), this, SLOT(closeMarkersDialog())); |
|
|
|
QPoint globalCursorPos = QCursor::pos(); |
|
QScreen *screen = QGuiApplication::screenAt(globalCursorPos); |
|
QRect mouseScreenGeometry = screen->geometry(); |
|
QPoint localCursorPos = globalCursorPos - mouseScreenGeometry.topLeft(); |
|
m_markersDialog->move(localCursorPos); |
|
new DialogPositioner(m_markersDialog, false); |
|
|
|
m_markersDialog->show(); |
|
} |
|
|
|
void GLSpectrumGUI::closeMarkersDialog() |
|
{ |
|
m_settings.m_histogramMarkers = m_glSpectrum->getHistogramMarkers(); |
|
m_settings.m_waterfallMarkers = m_glSpectrum->getWaterfallMarkers(); |
|
m_settings.m_annoationMarkers = m_glSpectrum->getAnnotationMarkers(); |
|
m_settings.m_markersDisplay = m_glSpectrum->getMarkersDisplay(); |
|
|
|
displayGotoMarkers(); |
|
applySettings(); |
|
|
|
delete m_markersDialog; |
|
m_markersDialog = nullptr; |
|
} |
|
|
|
// Load spectrum data to a CSV file |
|
void GLSpectrumGUI::on_load_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
QString filename = QFileDialog::getSaveFileName(this, "Select file to read data from", "", "*.csv"); |
|
if (!filename.isEmpty()) |
|
{ |
|
QFile file(filename); |
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) |
|
{ |
|
QTextStream in(&file); |
|
QString error; |
|
|
|
// Read in all data |
|
m_glSpectrum->readCSV(in, false, error); |
|
|
|
if (!error.isEmpty()) { |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to read file %1: %2").arg(filename).arg(error)); |
|
} |
|
|
|
file.close(); |
|
} |
|
else |
|
{ |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to open file %1").arg(filename)); |
|
} |
|
} |
|
} |
|
|
|
// Save spectrum data to a CSV file |
|
void GLSpectrumGUI::on_save_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
QString filename = QFileDialog::getSaveFileName(this, "Select file to save data to", "", "*.csv"); |
|
if (!filename.isEmpty()) |
|
{ |
|
QFile file(filename); |
|
if (file.open(QIODevice::WriteOnly | QIODevice::Text)) |
|
{ |
|
QTextStream out(&file); |
|
|
|
// Write out all data in scroll buffer |
|
m_glSpectrum->writeCSV(out); |
|
|
|
file.close(); |
|
} |
|
else |
|
{ |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to open file %1").arg(filename)); |
|
} |
|
} |
|
} |
|
|
|
// Save spectrum/waterfall image to file |
|
void GLSpectrumGUI::on_saveImage_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
QString filename = QFileDialog::getSaveFileName(this, "Select file to save image to", "", "*.jpg *.png"); |
|
if (!filename.isEmpty()) |
|
{ |
|
if (!m_glSpectrum->writeImage(filename)) { |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to save image to file %1").arg(filename)); |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_refLevel_valueChanged(int value) |
|
{ |
|
m_settings.m_refLevel = value - m_calibrationShiftdB; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_levelRange_valueChanged(int value) |
|
{ |
|
m_settings.m_powerRange = value; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_fps_currentIndexChanged(int index) |
|
{ |
|
m_settings.m_fpsPeriodMs = m_fpsMs[index]; |
|
qDebug("GLSpectrumGUI::on_fps_currentIndexChanged: %d ms", m_settings.m_fpsPeriodMs); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_decay_valueChanged(int index) |
|
{ |
|
m_settings.m_decay = index; |
|
ui->decay->setToolTip(QString("Decay: %1").arg(m_settings.m_decay)); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_decayDivisor_valueChanged(int index) |
|
{ |
|
m_settings.m_decayDivisor = index; |
|
ui->decayDivisor->setToolTip(QString("Decay divisor: %1").arg(m_settings.m_decayDivisor)); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_stroke_valueChanged(int index) |
|
{ |
|
m_settings.m_histogramStroke = index; |
|
ui->stroke->setToolTip(QString("Stroke: %1").arg(m_settings.m_histogramStroke)); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_spectrogramStyle_currentIndexChanged(int index) |
|
{ |
|
m_settings.m_3DSpectrogramStyle = (SpectrumSettings::SpectrogramStyle)index; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_colorMap_currentIndexChanged(int index) |
|
{ |
|
(void) index; |
|
m_settings.m_colorMap = ui->colorMap->currentText(); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_waterfall_toggled(bool checked) |
|
{ |
|
m_settings.m_displayWaterfall = checked; |
|
if (checked) |
|
{ |
|
bool blocked = blockApplySettings(true); |
|
ui->spectrogram->setChecked(false); |
|
blockApplySettings(blocked); |
|
} |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_spectrogram_toggled(bool checked) |
|
{ |
|
m_settings.m_display3DSpectrogram = checked; |
|
if (checked) |
|
{ |
|
bool blocked = blockApplySettings(true); |
|
ui->waterfall->setChecked(false); |
|
blockApplySettings(blocked); |
|
} |
|
ui->spectrogramStyle->setVisible(m_settings.m_display3DSpectrogram && (m_settings.m_showControls >= SpectrumSettings::ShowAll)); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_histogram_toggled(bool checked) |
|
{ |
|
m_settings.m_displayHistogram = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_maxHold_toggled(bool checked) |
|
{ |
|
m_settings.m_displayMaxHold = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_currentLine_toggled(bool checked) |
|
{ |
|
ui->currentFill->blockSignals(true); |
|
ui->currentGradient->blockSignals(true); |
|
ui->currentFill->setChecked(false); |
|
ui->currentGradient->setChecked(false); |
|
ui->currentFill->blockSignals(false); |
|
ui->currentGradient->blockSignals(false); |
|
m_settings.m_spectrumStyle = SpectrumSettings::SpectrumStyle::Line; |
|
m_settings.m_displayCurrent = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_currentFill_toggled(bool checked) |
|
{ |
|
ui->currentLine->blockSignals(true); |
|
ui->currentGradient->blockSignals(true); |
|
ui->currentLine->setChecked(false); |
|
ui->currentGradient->setChecked(false); |
|
ui->currentLine->blockSignals(false); |
|
ui->currentGradient->blockSignals(false); |
|
m_settings.m_spectrumStyle = SpectrumSettings::SpectrumStyle::Fill; |
|
m_settings.m_displayCurrent = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_currentGradient_toggled(bool checked) |
|
{ |
|
ui->currentLine->blockSignals(true); |
|
ui->currentFill->blockSignals(true); |
|
ui->currentLine->setChecked(false); |
|
ui->currentFill->setChecked(false); |
|
ui->currentLine->blockSignals(false); |
|
ui->currentFill->blockSignals(false); |
|
m_settings.m_spectrumStyle = SpectrumSettings::SpectrumStyle::Gradient; |
|
m_settings.m_displayCurrent = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_invertWaterfall_toggled(bool checked) |
|
{ |
|
m_settings.m_invertedWaterfall = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_showControls_currentIndexChanged(int index) |
|
{ |
|
m_settings.m_showControls = (SpectrumSettings::ShowControls) index; |
|
displayControls(); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_grid_toggled(bool checked) |
|
{ |
|
m_settings.m_displayGrid = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_gridIntensity_valueChanged(int index) |
|
{ |
|
m_settings.m_displayGridIntensity = index; |
|
ui->gridIntensity->setToolTip(QString("Grid intensity: %1").arg(m_settings.m_displayGridIntensity)); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_truncateScale_toggled(bool checked) |
|
{ |
|
m_settings.m_truncateFreqScale = checked; |
|
qDebug("GLSpectrumGUI::on_truncateScale_toggled: m_truncateFreqScale: %s", (m_settings.m_truncateFreqScale ? "on" : "off")); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_traceIntensity_valueChanged(int index) |
|
{ |
|
m_settings.m_displayTraceIntensity = index; |
|
ui->traceIntensity->setToolTip(QString("Trace intensity: %1").arg(m_settings.m_displayTraceIntensity)); |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_clearSpectrum_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
if (m_glSpectrum) { |
|
m_glSpectrum->clearSpectrumHistogram(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_freeze_toggled(bool checked) |
|
{ |
|
SpectrumVis::MsgStartStop *msg = SpectrumVis::MsgStartStop::create(!checked); |
|
m_spectrumVis->getInputMessageQueue()->push(msg); |
|
} |
|
|
|
void GLSpectrumGUI::on_calibration_toggled(bool checked) |
|
{ |
|
m_settings.m_useCalibration = checked; |
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::on_gotoMarker_currentIndexChanged(int index) |
|
{ |
|
if (index <= 0) { |
|
return; |
|
} |
|
int i = 1; |
|
for (auto marker : m_settings.m_annoationMarkers) |
|
{ |
|
if (marker.m_show != SpectrumAnnotationMarker::Hidden) |
|
{ |
|
if (i == index) |
|
{ |
|
emit requestCenterFrequency(marker.m_startFrequency + marker.m_bandwidth/2); |
|
break; |
|
} |
|
i++; |
|
} |
|
} |
|
ui->gotoMarker->setCurrentIndex(0); // Redisplay "Goto..." |
|
} |
|
|
|
void GLSpectrumGUI::setAveragingCombo() |
|
{ |
|
int index = ui->averaging->currentIndex(); |
|
ui->averaging->blockSignals(true); |
|
ui->averaging->clear(); |
|
ui->averaging->addItem(QString("1")); |
|
uint64_t maxAveraging = SpectrumSettings::getMaxAveragingValue(m_settings.m_fftSize, m_settings.m_averagingMode); |
|
|
|
for (int i = 0; i <= SpectrumSettings::getAveragingMaxScale(m_settings.m_averagingMode); i++) |
|
{ |
|
QString s; |
|
int m = pow(10.0, i); |
|
uint64_t x = 2*m; |
|
if (x > maxAveraging) { |
|
break; |
|
} |
|
setNumberStr(x, s); |
|
ui->averaging->addItem(s); |
|
x = 5*m; |
|
if (x > maxAveraging) { |
|
break; |
|
} |
|
setNumberStr(x, s); |
|
ui->averaging->addItem(s); |
|
x = 10*m; |
|
if (x > maxAveraging) { |
|
break; |
|
} |
|
setNumberStr(x, s); |
|
ui->averaging->addItem(s); |
|
} |
|
|
|
ui->averaging->setCurrentIndex(index >= ui->averaging->count() ? ui->averaging->count() - 1 : index); |
|
ui->averaging->blockSignals(false); |
|
} |
|
|
|
void GLSpectrumGUI::setNumberStr(int n, QString& s) |
|
{ |
|
if (n < 1000) { |
|
s = tr("%1").arg(n); |
|
} else if (n < 100000) { |
|
s = tr("%1k").arg(n/1000); |
|
} else if (n < 1000000) { |
|
s = tr("%1e5").arg(n/100000); |
|
} else if (n < 1000000000) { |
|
s = tr("%1M").arg(n/1000000); |
|
} else { |
|
s = tr("%1G").arg(n/1000000000); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::setNumberStr(float v, int decimalPlaces, QString& s) |
|
{ |
|
if (v < 1e-6) { |
|
s = tr("%1n").arg(v*1e9, 0, 'f', decimalPlaces); |
|
} else if (v < 1e-3) { |
|
s = tr("%1µ").arg(v*1e6, 0, 'f', decimalPlaces); |
|
} else if (v < 1.0) { |
|
s = tr("%1m").arg(v*1e3, 0, 'f', decimalPlaces); |
|
} else if (v < 1e3) { |
|
s = tr("%1").arg(v, 0, 'f', decimalPlaces); |
|
} else if (v < 1e6) { |
|
s = tr("%1k").arg(v*1e-3, 0, 'f', decimalPlaces); |
|
} else if (v < 1e9) { |
|
s = tr("%1M").arg(v*1e-6, 0, 'f', decimalPlaces); |
|
} else { |
|
s = tr("%1G").arg(v*1e-9, 0, 'f', decimalPlaces); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::setAveragingToolitp() |
|
{ |
|
if (m_glSpectrum) |
|
{ |
|
QString s; |
|
int averagingIndex = m_settings.m_averagingMode == SpectrumSettings::AvgModeNone ? 0 : m_settings.m_averagingIndex; |
|
float overlapFactor = (m_settings.m_fftSize - m_settings.m_fftOverlap) / (float)m_settings.m_fftSize; |
|
float averagingTime = (m_settings.m_fftSize * (SpectrumSettings::getAveragingValue(averagingIndex, m_settings.m_averagingMode) == 0 ? |
|
1 : |
|
SpectrumSettings::getAveragingValue(averagingIndex, m_settings.m_averagingMode))) / (float) m_glSpectrum->getSampleRate(); |
|
setNumberStr(averagingTime*overlapFactor, 2, s); |
|
ui->averaging->setToolTip(QString("Number of averaging samples (avg time: %1s)").arg(s)); |
|
} |
|
else |
|
{ |
|
ui->averaging->setToolTip(QString("Number of averaging samples")); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::setFFTSizeToolitp() |
|
{ |
|
if (m_glSpectrum) |
|
{ |
|
QString s; |
|
setNumberStr((float) m_glSpectrum->getSampleRate() / m_settings.m_fftSize, 2, s); |
|
ui->fftSize->setToolTip(QString("FFT size (resolution: %1Hz)").arg(s)); |
|
} |
|
else |
|
{ |
|
ui->fftSize->setToolTip(QString("FFT size")); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::setFFTSize(int log2FFTSize) |
|
{ |
|
ui->fftSize->setCurrentIndex( |
|
log2FFTSize < SpectrumSettings::m_log2FFTSizeMin ? |
|
0 |
|
: log2FFTSize > SpectrumSettings::m_log2FFTSizeMax ? |
|
SpectrumSettings::m_log2FFTSizeMax - SpectrumSettings::m_log2FFTSizeMin |
|
: log2FFTSize - SpectrumSettings::m_log2FFTSizeMin |
|
); |
|
} |
|
|
|
void GLSpectrumGUI::setMaximumOverlap() |
|
{ |
|
ui->fftOverlap->setMaximum(m_settings.m_fftSize -1); |
|
int value = ui->fftOverlap->value(); |
|
ui->fftOverlap->setValue(value); |
|
ui->fftOverlap->setToolTip(tr("FFT overlap %1 %").arg((value/(float)m_settings.m_fftSize)*100.0f)); |
|
|
|
if (m_glSpectrum) { |
|
m_glSpectrum->setFFTOverlap(value); |
|
} |
|
} |
|
|
|
bool GLSpectrumGUI::handleMessage(const Message& message) |
|
{ |
|
if (GLSpectrumView::MsgReportSampleRate::match(message)) |
|
{ |
|
setAveragingToolitp(); |
|
setFFTSizeToolitp(); |
|
return true; |
|
} |
|
else if (SpectrumVis::MsgConfigureSpectrumVis::match(message)) |
|
{ |
|
SpectrumVis::MsgConfigureSpectrumVis& cfg = (SpectrumVis::MsgConfigureSpectrumVis&) message; |
|
m_settings = cfg.getSettings(); |
|
displaySettings(); |
|
|
|
if (m_glSpectrum) { |
|
applySpectrumSettings(); |
|
} |
|
|
|
return true; |
|
} |
|
else if (SpectrumVis::MsgConfigureWSpectrumOpenClose::match(message)) |
|
{ |
|
SpectrumVis::MsgConfigureWSpectrumOpenClose& notif = (SpectrumVis::MsgConfigureWSpectrumOpenClose&) message; |
|
ui->wsSpectrum->blockSignals(true); |
|
ui->wsSpectrum->doToggle(notif.getOpenClose()); |
|
ui->wsSpectrum->blockSignals(false); |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgReportWaterfallShare::match(message)) |
|
{ |
|
const GLSpectrumView::MsgReportWaterfallShare& report = (const GLSpectrumView::MsgReportWaterfallShare&) message; |
|
m_settings.m_waterfallShare = report.getWaterfallShare(); |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgReportFFTOverlap::match(message)) |
|
{ |
|
const GLSpectrumView::MsgReportFFTOverlap& report = (const GLSpectrumView::MsgReportFFTOverlap&) message; |
|
m_settings.m_fftOverlap = report.getOverlap(); |
|
ui->fftOverlap->blockSignals(true); |
|
ui->fftOverlap->setValue(m_settings.m_fftOverlap); |
|
ui->fftOverlap->blockSignals(false); |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgReportPowerScale::match(message)) |
|
{ |
|
const GLSpectrumView::MsgReportPowerScale& report = (const GLSpectrumView::MsgReportPowerScale&) message; |
|
m_settings.m_refLevel = report.getRefLevel(); |
|
m_settings.m_powerRange = report.getRange(); |
|
ui->refLevel->blockSignals(true); |
|
ui->levelRange->blockSignals(true); |
|
ui->refLevel->setValue(m_settings.m_refLevel + m_calibrationShiftdB); |
|
ui->levelRange->setValue(m_settings.m_powerRange); |
|
ui->levelRange->blockSignals(false); |
|
ui->refLevel->blockSignals(false); |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgReportCalibrationShift::match(message)) |
|
{ |
|
const GLSpectrumView::MsgReportCalibrationShift& report = (GLSpectrumView::MsgReportCalibrationShift&) message; |
|
m_calibrationShiftdB = report.getCalibrationShiftdB(); |
|
ui->refLevel->blockSignals(true); |
|
ui->refLevel->setValue(m_settings.m_refLevel + m_calibrationShiftdB); |
|
ui->refLevel->blockSignals(false); |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgReportHistogramMarkersChange::match(message)) |
|
{ |
|
if (m_markersDialog) { |
|
m_markersDialog->updateHistogramMarkersDisplay(); |
|
} |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgReportWaterfallMarkersChange::match(message)) |
|
{ |
|
if (m_markersDialog) { |
|
m_markersDialog->updateWaterfallMarkersDisplay(); |
|
} |
|
return true; |
|
} |
|
else if (GLSpectrumView::MsgFrequencyZooming::match(message)) |
|
{ |
|
const GLSpectrumView::MsgFrequencyZooming& report = (const GLSpectrumView::MsgFrequencyZooming&) message; |
|
m_settings.m_frequencyZoomFactor = report.getFrequencyZoomFactor(); |
|
m_settings.m_frequencyZoomPos = report.getFrequencyZoomPos(); |
|
return true; |
|
} |
|
else if (SpectrumVis::MsgStartStop::match(message)) |
|
{ |
|
const SpectrumVis::MsgStartStop& msg = (SpectrumVis::MsgStartStop&) message; |
|
ui->freeze->blockSignals(true); |
|
ui->freeze->doToggle(!msg.getStartStop()); // this is a freeze so stop is true |
|
ui->freeze->blockSignals(false); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void GLSpectrumGUI::handleInputMessages() |
|
{ |
|
Message* message; |
|
|
|
while ((message = m_messageQueue.pop())) |
|
{ |
|
if (!handleMessage(*message)) |
|
{ |
|
qDebug("%s: unhandled message: %s", Q_FUNC_INFO, message->getIdentifier()); |
|
} |
|
delete message; |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::openWebsocketSpectrumSettingsDialog(const QPoint& p) |
|
{ |
|
WebsocketSpectrumSettingsDialog dialog(this); |
|
dialog.setAddress(m_settings.m_wsSpectrumAddress); |
|
dialog.setPort(m_settings.m_wsSpectrumPort); |
|
|
|
dialog.move(p); |
|
new DialogPositioner(&dialog, false); |
|
dialog.exec(); |
|
|
|
if (dialog.hasChanged()) |
|
{ |
|
m_settings.m_wsSpectrumAddress = dialog.getAddress(); |
|
m_settings.m_wsSpectrumPort = dialog.getPort(); |
|
|
|
applySettings(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::openCalibrationPointsDialog(const QPoint& p) |
|
{ |
|
SpectrumCalibrationPointsDialog dialog( |
|
m_glSpectrum->getCalibrationPoints(), |
|
m_glSpectrum->getCalibrationInterpMode(), |
|
m_glSpectrum->getHistogramMarkers().size() > 0 ? &m_glSpectrum->getHistogramMarkers()[0] : nullptr, |
|
this |
|
); |
|
|
|
dialog.setCenterFrequency(m_glSpectrum->getCenterFrequency()); |
|
connect(&dialog, SIGNAL(updateCalibrationPoints()), this, SLOT(updateCalibrationPoints())); |
|
dialog.move(p); |
|
new DialogPositioner(&dialog, false); |
|
dialog.exec(); |
|
|
|
m_settings.m_histogramMarkers = m_glSpectrum->getHistogramMarkers(); |
|
m_settings.m_waterfallMarkers = m_glSpectrum->getWaterfallMarkers(); |
|
m_settings.m_annoationMarkers = m_glSpectrum->getAnnotationMarkers(); |
|
m_settings.m_markersDisplay = m_glSpectrum->getMarkersDisplay(); |
|
m_settings.m_calibrationPoints = m_glSpectrum->getCalibrationPoints(); |
|
m_settings.m_calibrationInterpMode = m_glSpectrum->getCalibrationInterpMode(); |
|
|
|
applySettings(); |
|
} |
|
|
|
void GLSpectrumGUI::updateHistogramMarkers() |
|
{ |
|
if (m_glSpectrum) { |
|
m_glSpectrum->updateHistogramMarkers(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::updateWaterfallMarkers() |
|
{ |
|
if (m_glSpectrum) { |
|
m_glSpectrum->updateWaterfallMarkers(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::updateAnnotationMarkers() |
|
{ |
|
if (m_glSpectrum) { |
|
m_glSpectrum->updateAnnotationMarkers(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::updateMarkersDisplay() |
|
{ |
|
if (m_glSpectrum) { |
|
m_glSpectrum->updateMarkersDisplay(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::updateCalibrationPoints() |
|
{ |
|
if (m_glSpectrum) { |
|
m_glSpectrum->updateCalibrationPoints(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_measure_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
SpectrumMeasurementsDialog measurementsDialog( |
|
m_glSpectrum, |
|
&m_settings, |
|
this |
|
); |
|
|
|
connect(&measurementsDialog, &SpectrumMeasurementsDialog::updateMeasurements, this, &GLSpectrumGUI::updateMeasurements); |
|
|
|
measurementsDialog.exec(); |
|
} |
|
|
|
void GLSpectrumGUI::on_resetMeasurements_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
if (m_glSpectrum) { |
|
m_glSpectrum->resetMeasurements(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::updateMeasurements() |
|
{ |
|
ui->resetMeasurements->setVisible(m_settings.m_measurement >= SpectrumSettings::MeasurementChannelPower); |
|
if (m_glSpectrum) |
|
{ |
|
m_glSpectrum->setMeasurementsVisible(m_settings.m_measurement != SpectrumSettings::MeasurementNone); |
|
m_glSpectrum->setMeasurementsPosition(m_settings.m_measurementsPosition); |
|
m_glSpectrum->setMeasurementParams( |
|
m_settings.m_measurement, |
|
m_settings.m_measurementCenterFrequencyOffset, |
|
m_settings.m_measurementBandwidth, |
|
m_settings.m_measurementChSpacing, |
|
m_settings.m_measurementAdjChBandwidth, |
|
m_settings.m_measurementHarmonics, |
|
m_settings.m_measurementPeaks, |
|
m_settings.m_measurementHighlight, |
|
m_settings.m_measurementPrecision, |
|
m_settings.m_measurementMemMasks |
|
); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_showSettingsDialog_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
|
|
SpectrumDisplaySettingsDialog dialog(m_glSpectrum, &m_settings, m_glSpectrum->getSampleRate(), this); |
|
|
|
if (dialog.exec() == QDialog::Accepted) { |
|
applySpectrumSettings(); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_mem1_clicked(bool checked) |
|
{ |
|
m_settings.m_spectrumMemory[0].m_display = checked; |
|
if (m_glSpectrum) { |
|
m_glSpectrum->setMemory(0, m_settings.m_spectrumMemory[0]); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::on_mem2_clicked(bool checked) |
|
{ |
|
m_settings.m_spectrumMemory[1].m_display = checked; |
|
if (m_glSpectrum) { |
|
m_glSpectrum->setMemory(1, m_settings.m_spectrumMemory[1]); |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::mem1ContextMenu(const QPoint &p) |
|
{ |
|
memContextMenu(0, ui->mem1->mapToGlobal(p)); |
|
} |
|
|
|
void GLSpectrumGUI::mem2ContextMenu(const QPoint &p) |
|
{ |
|
memContextMenu(1, ui->mem2->mapToGlobal(p)); |
|
} |
|
|
|
// Show memory context menu |
|
void GLSpectrumGUI::memContextMenu(int memoryIdx, const QPoint &p) |
|
{ |
|
if (m_glSpectrum && m_spectrumVis) |
|
{ |
|
m_contextMenu->clear(); |
|
|
|
bool memNotEmpty = m_settings.m_spectrumMemory[memoryIdx].m_spectrum.size() > 0; |
|
|
|
// Clear memory |
|
QAction* clearAction = new QAction(QString("Clear M%1").arg(memoryIdx+1), m_contextMenu); |
|
connect(clearAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum.clear(); |
|
updateMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(clearAction); |
|
clearAction->setEnabled(memNotEmpty); |
|
|
|
// Copy currently displayed spectrum to memory |
|
QAction* copyCurrentSpectrumAction = new QAction(QString("Set M%1 to current spectrum").arg(memoryIdx+1), m_contextMenu); |
|
connect(copyCurrentSpectrumAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
std::vector<Real> copy; |
|
m_glSpectrum->getDisplayedSpectrumCopy(copy, false); |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum = QList<Real>(copy.begin(), copy.end()); |
|
updateMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(copyCurrentSpectrumAction); |
|
|
|
// Copy math moving average to memory |
|
QAction* copyMovingAverageAction = new QAction(QString("Set M%1 to moving average").arg(memoryIdx+1), m_contextMenu); |
|
connect(copyMovingAverageAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
QList<Real> copy; |
|
bool mathDB = m_settings.mathUsesDB(); |
|
m_spectrumVis->getMathMovingAverageCopy(copy); |
|
convertSpectrum(copy, mathDB, !m_settings.m_linear); |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum = QList<Real>(copy.begin(), copy.end()); |
|
updateMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(copyMovingAverageAction); |
|
copyMovingAverageAction->setEnabled(m_settings.mathAverageUsed()); |
|
|
|
// Add offset |
|
QAction* applyOffsetAction = new QAction(QString("Add offset to M%1").arg(memoryIdx+1), m_contextMenu); |
|
connect(applyOffsetAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
applyOffsetToMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(applyOffsetAction); |
|
applyOffsetAction->setEnabled(memNotEmpty); |
|
|
|
// Smooth |
|
QAction* smoothAction = new QAction(QString("Smooth M%1").arg(memoryIdx+1), m_contextMenu); |
|
connect(smoothAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
smoothMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(smoothAction); |
|
smoothAction->setEnabled(memNotEmpty); |
|
|
|
bool memAAndBNotEmpty = (m_settings.m_spectrumMemory[0].m_spectrum.size() > 0) |
|
&& (m_settings.m_spectrumMemory[1].m_spectrum.size() > 0); |
|
|
|
// Add mems |
|
QAction* addMemAction = new QAction(QString("Set M%1 to M1+M2").arg(memoryIdx+1), m_contextMenu); |
|
connect(addMemAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
addMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(addMemAction); |
|
addMemAction->setEnabled(memAAndBNotEmpty); |
|
|
|
// Diff mems |
|
QAction* diffMemAction = new QAction(QString("Set M%1 to M1-M2").arg(memoryIdx+1), m_contextMenu); |
|
connect(diffMemAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
diffMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(diffMemAction); |
|
diffMemAction->setEnabled(memAAndBNotEmpty); |
|
|
|
m_contextMenu->addSeparator(); |
|
|
|
// Load memory from .csv |
|
QAction* loadSpectrumAction = new QAction(QString("Load M%1 from .csv").arg(memoryIdx+1), m_contextMenu); |
|
connect(loadSpectrumAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
loadMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(loadSpectrumAction); |
|
|
|
// Save memory to .csv |
|
QAction* saveSpectrumAction = new QAction(QString("Save M%1 to .csv").arg(memoryIdx+1), m_contextMenu); |
|
connect(saveSpectrumAction, &QAction::triggered, this, [this, memoryIdx]()->void { |
|
saveMem(memoryIdx); |
|
}); |
|
m_contextMenu->addAction(saveSpectrumAction); |
|
saveSpectrumAction->setEnabled(memNotEmpty); |
|
|
|
m_contextMenu->addSeparator(); |
|
|
|
QAction* infoAction = new QAction(QString("M%1 has %2 elements").arg(memoryIdx+1).arg(m_settings.m_spectrumMemory[memoryIdx].m_spectrum.size()), m_contextMenu); |
|
m_contextMenu->addAction(infoAction); |
|
infoAction->setEnabled(false); |
|
|
|
m_contextMenu->popup(p); |
|
} |
|
} |
|
|
|
// Convert spectrum from dB to linear or vice-versa |
|
void GLSpectrumGUI::convertSpectrum(QList<Real> &spectrum, bool fromDB, bool toDB) const |
|
{ |
|
if (toDB && !fromDB) |
|
{ |
|
for (int i = 0; i < spectrum.size(); i++) { |
|
spectrum[i] = CalcDb::dbPower(spectrum[i]); |
|
} |
|
} |
|
else if (!toDB && fromDB) |
|
{ |
|
for (int i = 0; i < spectrum.size(); i++) { |
|
spectrum[i] = CalcDb::powerFromdB(spectrum[i]); |
|
} |
|
} |
|
} |
|
|
|
// Set math memory in SpectrumVis to selected memory |
|
void GLSpectrumGUI::setMathMemory() |
|
{ |
|
if (m_spectrumVis) |
|
{ |
|
QList<Real> spectrum; |
|
|
|
if ( (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusM1) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusM1DB) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeAbsXMinusM1DB) |
|
) |
|
{ |
|
spectrum = m_settings.m_spectrumMemory[0].m_spectrum; |
|
} else if ( (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusM2) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeXMinusM2DB) |
|
|| (m_settings.m_mathMode == SpectrumSettings::MathModeAbsXMinusM2DB) |
|
) |
|
{ |
|
spectrum = m_settings.m_spectrumMemory[1].m_spectrum; |
|
} |
|
else |
|
{ |
|
return; |
|
} |
|
|
|
convertSpectrum(spectrum, !m_settings.m_linear, m_settings.mathUsesDB()); |
|
m_spectrumVis->setMathMemory(spectrum); |
|
} |
|
} |
|
|
|
// Load from .csv file in to specified memory |
|
void GLSpectrumGUI::loadMem(int memoryIdx) |
|
{ |
|
QFileDialog fileDialog(nullptr, "Select file to load data from", "", "*.csv"); |
|
fileDialog.setDefaultSuffix("csv"); |
|
fileDialog.setAcceptMode(QFileDialog::AcceptOpen); |
|
if (fileDialog.exec()) |
|
{ |
|
QStringList fileNames = fileDialog.selectedFiles(); |
|
if (fileNames.size() > 0) |
|
{ |
|
// Read from csv file |
|
QFile file(fileNames[0]); |
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) |
|
{ |
|
QTextStream in(&file); |
|
QString error; |
|
QHash<QString, int> colIndexes = CSV::readHeader(in, {"Power"}, error); |
|
QList<Real> spectrum; |
|
|
|
if (error.isEmpty()) |
|
{ |
|
int powerCol = colIndexes.value("Power"); |
|
int maxCol = std::max({powerCol}); |
|
QStringList cols; |
|
|
|
while (CSV::readRow(in, &cols) && error.isEmpty()) |
|
{ |
|
if (cols.size() > maxCol) |
|
{ |
|
bool ok; |
|
float value = cols[powerCol].toFloat(&ok); |
|
if (ok) { |
|
spectrum.push_back(value); |
|
} else { |
|
error = QString("Failed to convert %1 to float").arg(cols[powerCol]); |
|
} |
|
} |
|
} |
|
} |
|
if (error.isEmpty()) |
|
{ |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum = spectrum; |
|
updateMem(memoryIdx); |
|
|
|
if (spectrum.size() != m_settings.m_fftSize) { |
|
QMessageBox::warning(this, "Spectrum", QString("Loaded data size (%1) does not match FFT size (%2)").arg(spectrum.size()).arg(m_settings.m_fftSize)); |
|
} |
|
} |
|
else |
|
{ |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to read file %1\n%2").arg(fileNames[0]).arg(error)); |
|
} |
|
} |
|
else |
|
{ |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to open file %1").arg(fileNames[0])); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Save from specified memory to .csv file |
|
void GLSpectrumGUI::saveMem(int memoryIdx) |
|
{ |
|
// Get filename to write |
|
QFileDialog fileDialog(nullptr, "Select file to save data to", "", "*.csv"); |
|
|
|
fileDialog.setDefaultSuffix("csv"); |
|
fileDialog.setAcceptMode(QFileDialog::AcceptSave); |
|
if (fileDialog.exec()) |
|
{ |
|
QStringList fileNames = fileDialog.selectedFiles(); |
|
|
|
if (fileNames.size() > 0) |
|
{ |
|
// Write to csv file |
|
QFile file(fileNames[0]); |
|
|
|
if (file.open(QIODevice::WriteOnly | QIODevice::Text)) |
|
{ |
|
QTextStream out(&file); |
|
|
|
out << "\"Power\"\n"; |
|
for (int i = 0; i < m_settings.m_spectrumMemory[memoryIdx].m_spectrum.size(); i++) { |
|
out << m_settings.m_spectrumMemory[memoryIdx].m_spectrum[i] << "\n"; |
|
} |
|
|
|
file.close(); |
|
} |
|
else |
|
{ |
|
QMessageBox::critical(this, "Spectrum", QString("Failed to open file %1").arg(fileNames[0])); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumGUI::applyOffsetToMem(int memoryIdx) |
|
{ |
|
double offset = QInputDialog::getDouble(this, "Enter offset to apply", "Offset"); |
|
|
|
for (int i = 0; i < m_settings.m_spectrumMemory[memoryIdx].m_spectrum.size(); i++) { |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum[i] += offset; |
|
} |
|
|
|
updateMem(memoryIdx); |
|
} |
|
|
|
void GLSpectrumGUI::smoothMem(int memoryIdx) |
|
{ |
|
int n = 5; |
|
int l = n / 2; |
|
std::size_t size1 = m_settings.m_spectrumMemory[memoryIdx].m_spectrum.size(); |
|
std::size_t size2 = size1 + (n - 1); |
|
Real *temp = new Real[size2]; |
|
|
|
// Copy and replicate sample at each end |
|
for (int i = 0; i < l; i++) |
|
{ |
|
temp[i] = m_settings.m_spectrumMemory[memoryIdx].m_spectrum[0]; |
|
temp[size2-1-i] = m_settings.m_spectrumMemory[memoryIdx].m_spectrum[size1 - 1]; |
|
} |
|
std::copy(m_settings.m_spectrumMemory[memoryIdx].m_spectrum.begin(), m_settings.m_spectrumMemory[memoryIdx].m_spectrum.end(), &temp[l]); |
|
|
|
// Average n consequtive samples |
|
for (std::size_t i = 0; i < size1; i++) |
|
{ |
|
Real sum = 0.0; |
|
for (int j = 0; j < n; j++) { |
|
sum += temp[i+j]; |
|
} |
|
Real avg = sum / (Real) n; |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum[i] = avg; |
|
} |
|
|
|
delete[] temp; |
|
|
|
updateMem(memoryIdx); |
|
} |
|
|
|
void GLSpectrumGUI::addMem(int memoryIdx) |
|
{ |
|
std::size_t s = std::min(m_settings.m_spectrumMemory[0].m_spectrum.size(), m_settings.m_spectrumMemory[1].m_spectrum.size()); |
|
|
|
for (std::size_t i = 0; i < s; i++) |
|
{ |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum[i] = |
|
m_settings.m_spectrumMemory[0].m_spectrum[i] |
|
+ m_settings.m_spectrumMemory[1].m_spectrum[i]; |
|
} |
|
|
|
updateMem(memoryIdx); |
|
} |
|
|
|
void GLSpectrumGUI::diffMem(int memoryIdx) |
|
{ |
|
std::size_t s = std::min(m_settings.m_spectrumMemory[0].m_spectrum.size(), m_settings.m_spectrumMemory[1].m_spectrum.size()); |
|
|
|
for (std::size_t i = 0; i < s; i++) |
|
{ |
|
m_settings.m_spectrumMemory[memoryIdx].m_spectrum[i] = |
|
m_settings.m_spectrumMemory[0].m_spectrum[i] |
|
- m_settings.m_spectrumMemory[1].m_spectrum[i]; |
|
} |
|
|
|
updateMem(memoryIdx); |
|
} |
|
|
|
void GLSpectrumGUI::updateMem(int memoryIdx) |
|
{ |
|
// Update in GLSpectrum |
|
m_glSpectrum->setMemory(memoryIdx, m_settings.m_spectrumMemory[memoryIdx]); |
|
// Update in SpectrumVIS |
|
setMathMemory(); |
|
} |
|
|
|
// Look through items of numerical values using engineering units in a combo box, looking for text with equivalent value. E.g. 1000 == 1k |
|
int GLSpectrumGUI::findEquivalentText(QComboBox *combo, int value) |
|
{ |
|
for (int i = 0; i < combo->count(); i++) |
|
{ |
|
int itemValue = Units::engUnitsToPosInt(combo->itemText(i)); |
|
if (itemValue == value) { |
|
return i; |
|
} |
|
} |
|
return -1; |
|
}
|
|
|