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.
6010 lines
205 KiB
6010 lines
205 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany // |
|
// written by Christian Daniel // |
|
// Copyright (C) 2014 John Greb <hexameron@spam.no> // |
|
// Copyright (C) 2015-2023 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2015 Hoernchen <la@tfc-server.de> // |
|
// Copyright (C) 2018 beta-tester <alpha-beta-release@gmx.net> // |
|
// Copyright (C) 2022-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2022 Jiří Pinkava <jiri.pinkava@rossum.ai> // |
|
// Copyright (C) 2023 Arne Jünemann <das-iro@das-iro.de> // |
|
// // |
|
// 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 <algorithm> |
|
|
|
#include <QtAlgorithms> |
|
#include <QMouseEvent> |
|
#include <QOpenGLShaderProgram> |
|
#include <QOpenGLFunctions> |
|
#include <QPainter> |
|
#include <QFontDatabase> |
|
#include <QWindow> |
|
#include <QGestureEvent> |
|
#include <QPanGesture> |
|
#include <QPinchGesture> |
|
#include "maincore.h" |
|
#include "dsp/spectrumvis.h" |
|
#include "gui/glspectrumview.h" |
|
#include "gui/spectrummeasurements.h" |
|
#include "settings/mainsettings.h" |
|
#include "util/messagequeue.h" |
|
#include "util/db.h" |
|
#include "util/profiler.h" |
|
#include "util/csv.h" |
|
|
|
#include <QDebug> |
|
|
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportSampleRate, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportWaterfallShare, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportFFTOverlap, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportPowerScale, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportCalibrationShift, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportHistogramMarkersChange, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgReportWaterfallMarkersChange, Message) |
|
MESSAGE_CLASS_DEFINITION(GLSpectrumView::MsgFrequencyZooming, Message) |
|
|
|
const float GLSpectrumView::m_maxFrequencyZoom = 50.0f; |
|
const float GLSpectrumView::m_annotationMarkerHeight = 20.0f; |
|
|
|
GLSpectrumView::GLSpectrumView(QWidget* parent) : |
|
QOpenGLWidget(parent), |
|
m_markersDisplay(SpectrumSettings::MarkersDisplaySpectrum), |
|
m_histogramFindPeaks(false), |
|
m_cursorState(CSNormal), |
|
m_cursorChannel(0), |
|
m_spectrumVis(nullptr), |
|
m_fpsPeriodMs(50), |
|
m_mouseInside(false), |
|
m_changesPending(true), |
|
m_redrawAll(false), |
|
m_centerFrequency(100000000), |
|
m_referenceLevel(0.0f), |
|
m_minReferenceLevel(-120.0f), |
|
m_maxReferenceLevel(0.0f), |
|
m_powerRange(100.0), |
|
m_minPowerRange(1.0f), |
|
m_maxPowerRange(120.0f), |
|
m_linear(false), |
|
m_decay(1), |
|
m_sampleRate(500000), |
|
m_timingRate(1), |
|
m_fftOverlap(0), |
|
m_fftSize(512), |
|
m_nbBins(512), |
|
m_fftMin(0), |
|
m_fftMax(512), |
|
m_displayGrid(true), |
|
m_displayGridIntensity(5), |
|
m_displayTraceIntensity(50), |
|
m_invertedWaterfall(true), |
|
m_displayMaxHold(false), |
|
m_currentSpectrum(nullptr), |
|
m_displayCurrent(false), |
|
m_leftMargin(0), |
|
m_rightMargin(0), |
|
m_topMargin(0), |
|
m_frequencyScaleHeight(0), |
|
m_histogramHeight(80), |
|
m_waterfallHeight(0), |
|
m_bottomMargin(0), |
|
m_waterfallBuffer(nullptr), |
|
m_waterfallBufferPos(0), |
|
m_waterfallTextureHeight(-1), |
|
m_waterfallTexturePos(0), |
|
m_displayWaterfall(true), |
|
m_ssbSpectrum(false), |
|
m_lsbDisplay(false), |
|
m_3DSpectrogramBuffer(nullptr), |
|
m_3DSpectrogramBufferPos(0), |
|
m_3DSpectrogramTextureHeight(-1), |
|
m_3DSpectrogramTexturePos(0), |
|
m_display3DSpectrogram(false), |
|
m_rotate3DSpectrogram(false), |
|
m_pan3DSpectrogram(false), |
|
m_scaleZ3DSpectrogram(false), |
|
m_3DSpectrogramStyle(SpectrumSettings::Outline), |
|
m_spectrumColor(255, 255, 63), |
|
m_colorMapName("Angel"), |
|
m_scrollFrequency(false), |
|
m_scrollStartCenterFreq(0), |
|
m_pinching(false), |
|
m_pinching3D(false), |
|
m_frequencyRequested(false), |
|
m_nextFrequencyValid(false), |
|
m_histogramBuffer(nullptr), |
|
m_histogram(nullptr), |
|
m_displayHistogram(true), |
|
m_displayChanged(false), |
|
m_displaySourceOrSink(true), |
|
m_displayStreamIndex(0), |
|
m_matrixLoc(0), |
|
m_colorLoc(0), |
|
m_useCalibration(false), |
|
m_calibrationGain(1.0), |
|
m_calibrationShiftdB(0.0), |
|
m_calibrationInterpMode(SpectrumSettings::CalibInterpLinear), |
|
m_messageQueueToGUI(nullptr), |
|
m_openGLLogger(nullptr), |
|
m_isDeviceSpectrum(false), |
|
m_measurements(nullptr), |
|
m_measurement(SpectrumSettings::MeasurementNone), |
|
m_measurementCenterFrequencyOffset(0), |
|
m_measurementBandwidth(10000), |
|
m_measurementChSpacing(10000), |
|
m_measurementAdjChBandwidth(10000), |
|
m_measurementHarmonics(5), |
|
m_measurementPeaks(5), |
|
m_measurementHighlight(true), |
|
m_measurementPrecision(1), |
|
m_measurementMemMasks(0), |
|
m_maskTestCount(SpectrumSettings::m_maxSpectrumMemories), |
|
m_maskFailCount(SpectrumSettings::m_maxSpectrumMemories), |
|
m_maskFails(SpectrumSettings::m_maxSpectrumMemories), |
|
m_displayRBW(false), |
|
m_displayCursorStats(false), |
|
m_displayPeakStats(false), |
|
m_cursorOverSpectrum(false), |
|
m_cursorFrequency(0.0f), |
|
m_spectrumBuffer(0), |
|
m_spectrumBufferFFTSize(0), |
|
m_spectrumBufferMaxSize(100000), |
|
m_scrollBar(nullptr), |
|
m_scrollBarEnabled(false), |
|
m_scrollBarValue(0), |
|
m_waterfallTimeUnits(SpectrumSettings::TimeOffset), |
|
m_waterfallTimeFormat("hh:mm:ss"), |
|
m_spectrumMemory(SpectrumSettings::m_maxSpectrumMemories) |
|
{ |
|
// Enable multisampling anti-aliasing (MSAA) |
|
int multisamples = MainCore::instance()->getSettings().getMultisampling(); |
|
if (multisamples > 0) |
|
{ |
|
QSurfaceFormat format = QSurfaceFormat::defaultFormat(); |
|
format.setSamples(multisamples); |
|
setFormat(format); |
|
} |
|
|
|
setObjectName("GLSpectrum"); |
|
setAutoFillBackground(false); |
|
setAttribute(Qt::WA_OpaquePaintEvent, true); |
|
setAttribute(Qt::WA_NoSystemBackground, true); |
|
setMouseTracking(true); |
|
|
|
setMinimumSize(360, 200); |
|
|
|
m_waterfallShare = 0.5; |
|
|
|
for (int i = 0; i <= 239; i++) |
|
{ |
|
QColor c; |
|
c.setHsv(239 - i, 255, 15 + i); |
|
((quint8*)&m_waterfallPalette[i])[0] = c.red(); |
|
((quint8*)&m_waterfallPalette[i])[1] = c.green(); |
|
((quint8*)&m_waterfallPalette[i])[2] = c.blue(); |
|
((quint8*)&m_waterfallPalette[i])[3] = c.alpha(); |
|
} |
|
|
|
m_waterfallPalette[239] = 0xffffffff; |
|
m_histogramPalette[0] = 0; |
|
|
|
for (int i = 1; i < 240; i++) |
|
{ |
|
QColor c; |
|
int light = i < 60 ? 128 + (60-i) : 128; |
|
int sat = i < 60 ? 140 + i : i < 180 ? 200 : 200 - (i-180); |
|
c.setHsl(239 - i, sat, light); |
|
((quint8*)&m_histogramPalette[i])[0] = c.red(); |
|
((quint8*)&m_histogramPalette[i])[1] = c.green(); |
|
((quint8*)&m_histogramPalette[i])[2] = c.blue(); |
|
((quint8*)&m_histogramPalette[i])[3] = c.alpha(); |
|
} |
|
|
|
// 4.2.3 palette |
|
// for (int i = 1; i < 240; i++) |
|
// { |
|
// QColor c; |
|
// int val = i < 60 ? 255 : 200; |
|
// int sat = i < 60 ? 128 : i < 180 ? 255 : 180; |
|
// c.setHsv(239 - i, sat, val); |
|
// ((quint8*)&m_histogramPalette[i])[0] = c.red(); |
|
// ((quint8*)&m_histogramPalette[i])[1] = c.green(); |
|
// ((quint8*)&m_histogramPalette[i])[2] = c.blue(); |
|
// ((quint8*)&m_histogramPalette[i])[3] = c.alpha(); |
|
// } |
|
|
|
// Original palette: |
|
// for(int i = 16; i < 240; i++) { |
|
// QColor c; |
|
// c.setHsv(239 - i, 255 - ((i < 200) ? 0 : (i - 200) * 3), 150 + ((i < 100) ? i : 100)); |
|
// ((quint8*)&m_histogramPalette[i])[0] = c.red(); |
|
// ((quint8*)&m_histogramPalette[i])[1] = c.green(); |
|
// ((quint8*)&m_histogramPalette[i])[2] = c.blue(); |
|
// ((quint8*)&m_histogramPalette[i])[3] = c.alpha(); |
|
// } |
|
// for(int i = 1; i < 16; i++) { |
|
// QColor c; |
|
// c.setHsv(255, 128, 48 + i * 4); |
|
// ((quint8*)&m_histogramPalette[i])[0] = c.red(); |
|
// ((quint8*)&m_histogramPalette[i])[1] = c.green(); |
|
// ((quint8*)&m_histogramPalette[i])[2] = c.blue(); |
|
// ((quint8*)&m_histogramPalette[i])[3] = c.alpha(); |
|
// } |
|
|
|
m_decayDivisor = 1; |
|
m_decayDivisorCount = m_decayDivisor; |
|
m_histogramStroke = 30; |
|
|
|
m_timeScale.setFont(font()); |
|
m_timeScale.setOrientation(Qt::Vertical); |
|
m_timeScale.setRange(Unit::Time, 0, 1); |
|
m_powerScale.setFont(font()); |
|
m_powerScale.setOrientation(Qt::Vertical); |
|
m_frequencyScale.setFont(font()); |
|
m_frequencyScale.setOrientation(Qt::Horizontal); |
|
|
|
m_textOverlayFont = font(); // QFontDatabase::systemFont(QFontDatabase::FixedFont); |
|
m_textOverlayFont.setBold(true); |
|
// m_textOverlayFont.setPointSize(font().pointSize() - 1); |
|
resetFrequencyZoom(); |
|
|
|
m_timer.setTimerType(Qt::PreciseTimer); |
|
connect(&m_timer, SIGNAL(timeout()), this, SLOT(tick())); |
|
m_timer.start(m_fpsPeriodMs); |
|
|
|
// Handle KeyEvents |
|
setFocusPolicy(Qt::StrongFocus); |
|
installEventFilter(this); |
|
|
|
grabGesture(Qt::PinchGesture); |
|
} |
|
|
|
GLSpectrumView::~GLSpectrumView() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (m_waterfallBuffer) |
|
{ |
|
delete m_waterfallBuffer; |
|
m_waterfallBuffer = nullptr; |
|
} |
|
|
|
if (m_3DSpectrogramBuffer) |
|
{ |
|
delete m_3DSpectrogramBuffer; |
|
m_3DSpectrogramBuffer = nullptr; |
|
} |
|
|
|
if (m_histogramBuffer) |
|
{ |
|
delete m_histogramBuffer; |
|
m_histogramBuffer = nullptr; |
|
} |
|
|
|
if (m_histogram) |
|
{ |
|
delete[] m_histogram; |
|
m_histogram = nullptr; |
|
} |
|
|
|
if (m_openGLLogger) |
|
{ |
|
delete m_openGLLogger; |
|
m_openGLLogger = nullptr; |
|
} |
|
|
|
clearSpectrumBuffer(); |
|
} |
|
|
|
void GLSpectrumView::queueRequestCenterFrequency(qint64 frequency) |
|
{ |
|
if (!m_frequencyRequested) |
|
{ |
|
m_frequencyRequested = true; |
|
m_requestedFrequency = frequency; |
|
emit requestCenterFrequency(frequency); |
|
} |
|
else |
|
{ |
|
m_nextFrequencyValid = true; |
|
m_nextFrequency = frequency; |
|
} |
|
} |
|
|
|
void GLSpectrumView::setCenterFrequency(qint64 frequency) |
|
{ |
|
m_mutex.lock(); |
|
m_centerFrequency = frequency; |
|
|
|
// Handle queued frequency requests |
|
if (m_frequencyRequested && (frequency == m_requestedFrequency)) |
|
{ |
|
m_frequencyRequested = false; |
|
if (m_nextFrequencyValid) |
|
{ |
|
m_nextFrequencyValid = false; |
|
queueRequestCenterFrequency(m_nextFrequency); |
|
} |
|
} |
|
|
|
if (m_useCalibration) { |
|
updateCalibrationPoints(); |
|
} |
|
|
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setReferenceLevel(Real referenceLevel) |
|
{ |
|
m_mutex.lock(); |
|
m_referenceLevel = referenceLevel; |
|
m_changesPending = true; |
|
redrawWaterfallAnd3DSpectrogram(); |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setPowerRange(Real powerRange) |
|
{ |
|
m_mutex.lock(); |
|
m_powerRange = powerRange; |
|
m_changesPending = true; |
|
redrawWaterfallAnd3DSpectrogram(); |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDecay(int decay) |
|
{ |
|
m_decay = decay < 0 ? 0 : decay > 20 ? 20 : decay; |
|
} |
|
|
|
void GLSpectrumView::setDecayDivisor(int decayDivisor) |
|
{ |
|
m_decayDivisor = decayDivisor < 1 ? 1 : decayDivisor > 20 ? 20 : decayDivisor; |
|
} |
|
|
|
void GLSpectrumView::setHistoStroke(int stroke) |
|
{ |
|
m_histogramStroke = stroke < 1 ? 1 : stroke > 60 ? 60 : stroke; |
|
} |
|
|
|
void GLSpectrumView::setSampleRate(qint32 sampleRate) |
|
{ |
|
m_mutex.lock(); |
|
m_sampleRate = sampleRate; |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportSampleRate(sampleRate)); |
|
} |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setTimingRate(qint32 timingRate) |
|
{ |
|
m_mutex.lock(); |
|
m_timingRate = timingRate; |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setFFTOverlap(int overlap) |
|
{ |
|
m_mutex.lock(); |
|
m_fftOverlap = overlap; |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayWaterfall(bool display) |
|
{ |
|
bool notify = false; |
|
m_mutex.lock(); |
|
m_displayWaterfall = display; |
|
if (!display) |
|
{ |
|
m_waterfallMarkers.clear(); |
|
notify = true; |
|
} |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
if (m_messageQueueToGUI && notify) { |
|
m_messageQueueToGUI->push(new MsgReportWaterfallMarkersChange()); |
|
} |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplay3DSpectrogram(bool display) |
|
{ |
|
m_mutex.lock(); |
|
m_display3DSpectrogram = display; |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setSpectrumStyle(SpectrumSettings::SpectrumStyle style) |
|
{ |
|
m_spectrumStyle = style; |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::set3DSpectrogramStyle(SpectrumSettings::SpectrogramStyle style) |
|
{ |
|
m_3DSpectrogramStyle = style; |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setSpectrumColor(QRgb color) |
|
{ |
|
m_mutex.lock(); |
|
m_spectrumColor = QColor(color); |
|
m_changesPending = true; |
|
m_redrawAll = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setColorMapName(const QString &colorMapName) |
|
{ |
|
m_mutex.lock(); |
|
m_colorMapName = colorMapName; |
|
m_changesPending = true; |
|
m_redrawAll = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setSsbSpectrum(bool ssbSpectrum) |
|
{ |
|
m_ssbSpectrum = ssbSpectrum; |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setLsbDisplay(bool lsbDisplay) |
|
{ |
|
m_lsbDisplay = lsbDisplay; |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setInvertedWaterfall(bool inv) |
|
{ |
|
m_mutex.lock(); |
|
m_invertedWaterfall = inv; |
|
m_changesPending = true; |
|
stopDrag(); |
|
if (m_scrollBar) { |
|
m_scrollBar->setInvertedAppearance(!inv); |
|
} |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayMaxHold(bool display) |
|
{ |
|
bool notify = false; |
|
m_mutex.lock(); |
|
m_displayMaxHold = display; |
|
if (!m_displayMaxHold && !m_displayCurrent && !m_displayHistogram) |
|
{ |
|
m_histogramMarkers.clear(); |
|
notify = true; |
|
} |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
if (m_messageQueueToGUI && notify) { |
|
m_messageQueueToGUI->push(new MsgReportHistogramMarkersChange()); |
|
} |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayCurrent(bool display) |
|
{ |
|
bool notify = false; |
|
m_mutex.lock(); |
|
m_displayCurrent = display; |
|
if (!m_displayMaxHold && !m_displayCurrent && !m_displayHistogram) |
|
{ |
|
m_histogramMarkers.clear(); |
|
notify = true; |
|
} |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
if (m_messageQueueToGUI && notify) { |
|
m_messageQueueToGUI->push(new MsgReportHistogramMarkersChange()); |
|
} |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayHistogram(bool display) |
|
{ |
|
bool notify = false; |
|
m_mutex.lock(); |
|
m_displayHistogram = display; |
|
if (!m_displayMaxHold && !m_displayCurrent && !m_displayHistogram) |
|
{ |
|
m_histogramMarkers.clear(); |
|
notify = true; |
|
} |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
if (m_messageQueueToGUI && notify) { |
|
m_messageQueueToGUI->push(new MsgReportHistogramMarkersChange()); |
|
} |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayGrid(bool display) |
|
{ |
|
m_displayGrid = display; |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayGridIntensity(int intensity) |
|
{ |
|
m_displayGridIntensity = intensity; |
|
|
|
if (m_displayGridIntensity > 100) { |
|
m_displayGridIntensity = 100; |
|
} else if (m_displayGridIntensity < 0) { |
|
m_displayGridIntensity = 0; |
|
} |
|
|
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setDisplayTraceIntensity(int intensity) |
|
{ |
|
m_displayTraceIntensity = intensity; |
|
|
|
if (m_displayTraceIntensity > 100) { |
|
m_displayTraceIntensity = 100; |
|
} else if (m_displayTraceIntensity < 0) { |
|
m_displayTraceIntensity = 0; |
|
} |
|
|
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setFreqScaleTruncationMode(bool mode) |
|
{ |
|
m_frequencyScale.setTruncateMode(mode); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setLinear(bool linear) |
|
{ |
|
m_mutex.lock(); |
|
m_linear = linear; |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setUseCalibration(bool useCalibration) |
|
{ |
|
m_mutex.lock(); |
|
m_useCalibration = useCalibration; |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportCalibrationShift(m_useCalibration ? m_calibrationShiftdB : 0.0)); |
|
} |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setMeasurementParams( |
|
SpectrumSettings::Measurement measurement, |
|
int centerFrequencyOffset, |
|
int bandwidth, |
|
int chSpacing, |
|
int adjChBandwidth, |
|
int harmonics, |
|
int peaks, |
|
bool highlight, |
|
int precision, |
|
unsigned memoryMask |
|
) |
|
{ |
|
m_mutex.lock(); |
|
m_measurement = measurement; |
|
m_measurementCenterFrequencyOffset = centerFrequencyOffset; |
|
m_measurementBandwidth = bandwidth; |
|
m_measurementChSpacing = chSpacing; |
|
m_measurementAdjChBandwidth = adjChBandwidth; |
|
m_measurementHarmonics = harmonics; |
|
m_measurementPeaks = peaks; |
|
m_measurementHighlight = highlight; |
|
m_measurementPrecision = precision; |
|
m_measurementMemMasks = memoryMask; |
|
m_changesPending = true; |
|
if (m_measurements) { |
|
m_measurements->setMeasurementParams(measurement, peaks, precision, memoryMask); |
|
} |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::resetMeasurements() |
|
{ |
|
m_mutex.lock(); |
|
for (std::size_t i = 0; i < m_maskFails.size(); ++i) |
|
{ |
|
m_maskTestCount[i] = 0; |
|
m_maskFailCount[i] = 0; |
|
int s = std::min((int) m_maskFails[i].size(), (int) m_spectrumMemory[i].m_spectrum.size()); |
|
for (int j = 0; j < s; j++) { |
|
m_maskFails[i][j] = m_spectrumMemory[i].m_spectrum[j]; |
|
} |
|
} |
|
m_mutex.unlock(); |
|
} |
|
|
|
void GLSpectrumView::addChannelMarker(ChannelMarker* channelMarker) |
|
{ |
|
m_mutex.lock(); |
|
connect(channelMarker, SIGNAL(changedByAPI()), this, SLOT(channelMarkerChanged())); |
|
connect(channelMarker, SIGNAL(destroyed(QObject*)), this, SLOT(channelMarkerDestroyed(QObject*))); |
|
m_channelMarkerStates.append(new ChannelMarkerState(channelMarker)); |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::removeChannelMarker(ChannelMarker* channelMarker) |
|
{ |
|
m_mutex.lock(); |
|
|
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
if (m_channelMarkerStates[i]->m_channelMarker == channelMarker) |
|
{ |
|
channelMarker->disconnect(this); |
|
delete m_channelMarkerStates.takeAt(i); |
|
m_changesPending = true; |
|
stopDrag(); |
|
m_mutex.unlock(); |
|
update(); |
|
return; |
|
} |
|
} |
|
|
|
m_mutex.unlock(); |
|
} |
|
|
|
void GLSpectrumView::setHistogramMarkers(const QList<SpectrumHistogramMarker>& histogramMarkers) |
|
{ |
|
m_mutex.lock(); |
|
m_histogramMarkers = histogramMarkers; |
|
updateHistogramMarkers(); |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setWaterfallMarkers(const QList<SpectrumWaterfallMarker>& waterfallMarkers) |
|
{ |
|
m_mutex.lock(); |
|
m_waterfallMarkers = waterfallMarkers; |
|
updateWaterfallMarkers(); |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setAnnotationMarkers(const QList<SpectrumAnnotationMarker>& annotationMarkers) |
|
{ |
|
m_mutex.lock(); |
|
m_annotationMarkers = annotationMarkers; |
|
updateAnnotationMarkers(); |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setMarkersDisplay(SpectrumSettings::MarkersDisplay markersDisplay) |
|
{ |
|
m_mutex.lock(); |
|
m_markersDisplay = markersDisplay; |
|
updateMarkersDisplay(); |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setCalibrationPoints(const QList<SpectrumCalibrationPoint>& calibrationPoints) |
|
{ |
|
m_mutex.lock(); |
|
m_calibrationPoints = calibrationPoints; |
|
updateCalibrationPoints(); |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::setCalibrationInterpMode(SpectrumSettings::CalibrationInterpolationMode mode) |
|
{ |
|
m_mutex.lock(); |
|
m_calibrationInterpMode = mode; |
|
updateCalibrationPoints(); |
|
m_changesPending = true; |
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
float GLSpectrumView::getPowerMax() const |
|
{ |
|
return m_linear ? m_powerScale.getRangeMax() : CalcDb::powerFromdB(m_powerScale.getRangeMax()); |
|
} |
|
|
|
float GLSpectrumView::getTimeMax() const |
|
{ |
|
return m_timeScale.getRangeMax(); |
|
} |
|
|
|
void GLSpectrumView::setWaterfallTimeFormat(SpectrumSettings::WaterfallTimeUnits waterfallTimeUnits, const QString& format) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
m_waterfallTimeUnits = waterfallTimeUnits; |
|
m_waterfallTimeFormat = format; |
|
if (m_waterfallTimeUnits == SpectrumSettings::TimeOffset) { |
|
m_timeScale.setTickFormatter(nullptr); |
|
} else { |
|
m_timeScale.setTickFormatter(this); |
|
} |
|
m_changesPending = true; |
|
} |
|
|
|
void GLSpectrumView::setStatusLine(bool displayRBW, bool displayCursorStats, bool displayPeakStats) |
|
{ |
|
m_displayRBW = displayRBW; |
|
m_displayCursorStats = displayCursorStats; |
|
m_displayPeakStats = displayPeakStats; |
|
m_displayChanged = true; |
|
} |
|
|
|
void GLSpectrumView::setScrolling(bool enabled, int length) |
|
{ |
|
m_scrollBar->setVisible(enabled); // Must call before we lock mutex, otherwise we can deadlock |
|
|
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (!enabled) |
|
{ |
|
if (!m_spectrumBuffer.isEmpty()) { |
|
clearSpectrumBuffer(); |
|
} |
|
} |
|
else |
|
{ |
|
while (m_spectrumBuffer.size() > (std::size_t) length) |
|
{ |
|
if (m_currentSpectrum == m_spectrumBuffer.takeFirst().m_spectrum) { |
|
m_currentSpectrum = nullptr; |
|
} |
|
delete[] m_spectrumBuffer.takeFirst().m_spectrum; |
|
} |
|
} |
|
m_spectrumBuffer.resize(length); |
|
m_spectrumBufferMaxSize = length; |
|
m_scrollBarEnabled = enabled; |
|
} |
|
|
|
void GLSpectrumView::setScrollBar(QScrollBar* scrollBar) |
|
{ |
|
m_scrollBar = scrollBar; |
|
connect(m_scrollBar, &QScrollBar::valueChanged, this, &GLSpectrumView::scrollBarValueChanged); |
|
} |
|
|
|
void GLSpectrumView::updateScrollBar() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (m_scrollBar && m_waterfallBuffer) |
|
{ |
|
qint64 max = std::max<qint64>(0, (m_spectrumBuffer.size() - 1 - m_waterfallBuffer->height())); |
|
|
|
m_scrollBar->setMaximum(max); |
|
m_scrollBar->setPageStep(m_waterfallBuffer->height()); |
|
} |
|
} |
|
|
|
void GLSpectrumView::scrollBarValueChanged(int value) |
|
{ |
|
m_scrollBarValue = value; |
|
|
|
m_redrawAll = true; |
|
m_changesPending = true; // Update waterfall time scale |
|
m_displayChanged = true; |
|
} |
|
|
|
int GLSpectrumView::scrollBarValue() const |
|
{ |
|
// We keep a local copy of scroll bar value, so it can be accessed by any thread |
|
return m_scrollBarValue; |
|
} |
|
|
|
// Read spectrum from .csv file |
|
void GLSpectrumView::readCSV(QTextStream &in, bool append, QString &error) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (!append) |
|
{ |
|
clearSpectrumBuffer(); |
|
m_redrawAll = true; |
|
m_changesPending = true; |
|
} |
|
|
|
QHash<QString, int> colIndexes = CSV::readHeader(in, {}, error); |
|
|
|
if (error.isEmpty()) |
|
{ |
|
if (colIndexes.contains("Frequency") && colIndexes.contains("Power")) |
|
{ |
|
int frequencyCol = colIndexes.value("Frequency"); |
|
int powerCol = colIndexes.value("Power"); |
|
int maxCol = std::max({frequencyCol, powerCol}); |
|
QStringList cols; |
|
QVector<qint64> frequencies; |
|
QVector<float> power; |
|
|
|
while (CSV::readRow(in, &cols)) |
|
{ |
|
if (cols.size() > maxCol) |
|
{ |
|
frequencies.append(cols[frequencyCol].toLongLong()); |
|
power.append(cols[powerCol].toFloat()); |
|
} |
|
} |
|
if (power.size() != m_fftSize) { |
|
error = QString("CSV data does not contain expected number of points for current FFT size. (Points: %1 - FFT size: %2").arg(power.size()).arg(m_fftSize); |
|
} else { |
|
newSpectrum(power.data(), m_fftSize, m_sampleRate, frequencies[m_fftSize/2], QDateTime::currentDateTime()); |
|
} |
|
} |
|
else if (colIndexes.contains("Date and Time") && colIndexes.contains("Center Frequency (Hz)") && colIndexes.contains("Sample Rate (Hz)") && colIndexes.contains("Power")) |
|
{ |
|
int dateTimeCol = colIndexes.value("Date and Time"); |
|
int frequencyCol = colIndexes.value("Center Frequency (Hz)"); |
|
int sampleRateCol = colIndexes.value("Sample Rate (Hz)"); |
|
int powerCol = colIndexes.value("Power"); |
|
int maxCol = std::max({dateTimeCol, frequencyCol, sampleRateCol, powerCol}); |
|
QStringList cols; |
|
QVector<float> spectrum; |
|
|
|
while (CSV::readRow(in, &cols)) |
|
{ |
|
if (cols.size() > maxCol) |
|
{ |
|
QDateTime dateTime = QDateTime::fromString(cols[dateTimeCol], Qt::ISODateWithMs); |
|
qint64 centerFrequency = cols[frequencyCol].toLongLong(); |
|
quint32 sampleRate = cols[sampleRateCol].toUInt(); |
|
|
|
spectrum.clear(); |
|
for (int i = 0; i < m_fftSize; i++) |
|
{ |
|
if (powerCol + i < cols.size()) { |
|
spectrum.append(cols[powerCol + i].toFloat()); |
|
} |
|
} |
|
if (spectrum.size() != m_fftSize) |
|
{ |
|
error = QString("CSV data does not contain expected number of points for current FFT size. (Points: %1 - FFT size: %2").arg(spectrum.size()).arg(m_fftSize); |
|
break; |
|
} |
|
else |
|
{ |
|
newSpectrum(spectrum.data(), m_fftSize, sampleRate, centerFrequency, dateTime); |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
error = "CSV header does not contain required columns"; |
|
} |
|
} |
|
|
|
update(); |
|
} |
|
|
|
// Write spectrum to .csv file |
|
void GLSpectrumView::writeCSV(QTextStream &out) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (m_spectrumBuffer.isEmpty()) |
|
{ |
|
float frequency = getCenterFrequency() - (getSampleRate() / 2.0f); |
|
float rbw = getSampleRate() / (float) m_fftSize; |
|
out << "\"Frequency\",\"Power\"\n"; |
|
for (int i = 0; i < m_fftSize; i++) |
|
{ |
|
out << frequency << "," << m_currentSpectrum[i] << "\n"; |
|
frequency += rbw; |
|
} |
|
} |
|
else |
|
{ |
|
out << "\"Date and Time\",\"Center Frequency (Hz)\",\"Sample Rate (Hz)\",\"Power\"\n"; |
|
for (std::size_t j = 0; j < m_spectrumBuffer.size(); j++) |
|
{ |
|
out << m_spectrumBuffer[j].m_dateTime.toString(Qt::ISODateWithMs) << "," << m_spectrumBuffer[j].m_centerFrequency << "," << m_spectrumBuffer[j].m_sampleRate << ","; |
|
for (int i = 0; i < m_spectrumBufferFFTSize; i++) { |
|
out << m_spectrumBuffer[j].m_spectrum[i] << ","; |
|
} |
|
out << "\n"; |
|
} |
|
} |
|
} |
|
|
|
// Write spectrum/waterfall image to file |
|
bool GLSpectrumView::writeImage(const QString& filename) |
|
{ |
|
QImage image = grabFramebuffer(); |
|
|
|
return image.save(filename); |
|
} |
|
|
|
// Get center frequency for currently displayed spectrum (which is selected via the scroll bar) |
|
qint64 GLSpectrumView::getDisplayedCenterFrequency() const |
|
{ |
|
int idx = m_spectrumBuffer.size() - 1 - scrollBarValue(); |
|
|
|
if ((idx >= 0) && (idx < (int) m_spectrumBuffer.size())) { |
|
return m_spectrumBuffer[idx].m_centerFrequency; |
|
} else { |
|
return m_centerFrequency; |
|
} |
|
} |
|
|
|
// Get sample rate for currently displayed spectrum (which is selected via the scroll bar) |
|
quint32 GLSpectrumView::getDisplayedSampleRate() const |
|
{ |
|
int idx = m_spectrumBuffer.size() - 1 - scrollBarValue(); |
|
|
|
if ((idx >= 0) && (idx < (int) m_spectrumBuffer.size())) { |
|
return m_spectrumBuffer[idx].m_sampleRate; |
|
} else { |
|
return m_sampleRate; |
|
} |
|
} |
|
|
|
void GLSpectrumView::redrawSpectrum() |
|
{ |
|
if (m_spectrumBuffer.size() > 0) |
|
{ |
|
int idx = m_spectrumBuffer.size() - 1 - scrollBarValue(); |
|
|
|
if (idx >= 0 && idx < (int) m_spectrumBuffer.size()) |
|
{ |
|
updateHistogram(m_spectrumBuffer[idx].m_spectrum, m_fftMin, m_nbBins); |
|
m_currentSpectrum = m_spectrumBuffer[idx].m_spectrum; |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::redrawWaterfallAnd3DSpectrogram() |
|
{ |
|
if (m_waterfallBuffer && m_spectrumBuffer.size() > 0) |
|
{ |
|
int idx = m_spectrumBuffer.size() - 1 - m_waterfallBuffer->height() - scrollBarValue(); |
|
|
|
m_waterfallBufferPos = 0; |
|
m_waterfallTexturePos = 0; |
|
m_3DSpectrogramBufferPos = 0; |
|
m_3DSpectrogramTexturePos = 0; |
|
|
|
for (int i = 0; i < m_waterfallBuffer->height(); i++) |
|
{ |
|
if ((idx >= 0) && (idx < (int) m_spectrumBuffer.size())) |
|
{ |
|
updateWaterfall(m_spectrumBuffer[idx].m_spectrum, m_fftSize, m_fftMin, m_nbBins); |
|
update3DSpectrogram(m_spectrumBuffer[idx].m_spectrum, m_fftSize, m_fftMin, m_nbBins); |
|
} |
|
else |
|
{ |
|
clearWaterfallRow(m_nbBins); |
|
clear3DSpectrogramRow(m_nbBins); |
|
} |
|
idx++; |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::measure(const Real *spectrum, bool updateGUI) |
|
{ |
|
m_measurementResults.m_measurement = m_measurement; |
|
|
|
switch (m_measurement) |
|
{ |
|
case SpectrumSettings::MeasurementPeaks: |
|
if (updateGUI) { |
|
measurePeaks(spectrum); |
|
} |
|
break; |
|
case SpectrumSettings::MeasurementChannelPower: |
|
measureChannelPower(spectrum, updateGUI); |
|
break; |
|
case SpectrumSettings::MeasurementAdjacentChannelPower: |
|
measureAdjacentChannelPower(spectrum, updateGUI); |
|
break; |
|
case SpectrumSettings::MeasurementOccupiedBandwidth: |
|
measureOccupiedBandwidth(spectrum, updateGUI); |
|
break; |
|
case SpectrumSettings::Measurement3dBBandwidth: |
|
measure3dBBandwidth(spectrum, updateGUI); |
|
break; |
|
case SpectrumSettings::MeasurementSNR: |
|
measureSNR(spectrum, updateGUI); |
|
measureSFDR(spectrum, updateGUI); |
|
break; |
|
case SpectrumSettings::MeasurementMask: |
|
measureMask(spectrum, m_fftSize, updateGUI); |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
// Published from the displayed pass only, so that a caller reading the report sees the same |
|
// figures as the screen rather than a mixture of the zoomed and full span measurements |
|
if (updateGUI && m_spectrumVis) |
|
{ |
|
m_measurementResults.m_updated = QDateTime::currentDateTimeUtc(); |
|
m_spectrumVis->setMeasurementResults(m_measurementResults); |
|
} |
|
} |
|
|
|
// newSpectrum can be called at a much faster rate than paintGL for high sample rates |
|
// Will typically be called from device source engine thread, so shouldn't touch UI |
|
void GLSpectrumView::newSpectrum(const Real *spectrum, int fftSize) |
|
{ |
|
PROFILER_START(); |
|
|
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
newSpectrum(spectrum, fftSize, m_sampleRate, m_centerFrequency, QDateTime::currentDateTime()); |
|
|
|
PROFILER_STOP("newSpectrum"); |
|
} |
|
|
|
void GLSpectrumView::newSpectrum(const Real *spectrum, int fftSize, quint32 sampleRate, qint64 centerFrequency, const QDateTime &dateTime) |
|
{ |
|
int offset = 0; |
|
int idx; |
|
|
|
m_displayChanged = true; |
|
|
|
if (fftSize != m_fftSize) |
|
{ |
|
m_fftSize = fftSize; |
|
updateFFTLimits(true); |
|
m_changesPending = true; |
|
} |
|
|
|
if (m_scrollBarEnabled) |
|
{ |
|
updateSpectrumBuffer(&spectrum[0], m_fftSize, sampleRate, centerFrequency, dateTime); |
|
offset = scrollBarValue(); |
|
idx = m_spectrumBuffer.size() - 1 - offset; |
|
m_currentSpectrum = m_spectrumBuffer[idx].m_spectrum; |
|
} |
|
else |
|
{ |
|
updateSpectrumNoBuffer(&spectrum[0], m_fftSize); |
|
m_currentSpectrum = m_spectrumNoBuffer.data(); |
|
} |
|
|
|
measure(spectrum, false); |
|
|
|
if (m_changesPending) { |
|
return; |
|
} |
|
|
|
if (offset == 0) |
|
{ |
|
updateWaterfall(spectrum, m_fftSize, m_fftMin, m_nbBins); |
|
update3DSpectrogram(spectrum, m_fftSize, m_fftMin, m_nbBins); |
|
updateHistogram(spectrum, m_fftMin, m_nbBins); |
|
} |
|
else |
|
{ |
|
updateWaterfall(m_spectrumBuffer[idx].m_spectrum, m_fftSize, m_fftMin, m_nbBins); |
|
update3DSpectrogram(m_spectrumBuffer[idx].m_spectrum, m_fftSize, m_fftMin, m_nbBins); |
|
updateHistogram(m_spectrumBuffer[idx].m_spectrum, m_fftMin, m_nbBins); |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateSpectrumNoBuffer(const Real *spectrum, int fftSize) |
|
{ |
|
if (m_spectrumNoBuffer.size() != (std::size_t) fftSize) { |
|
m_spectrumNoBuffer.resize(fftSize); |
|
} |
|
|
|
std::copy(spectrum, spectrum + fftSize, m_spectrumNoBuffer.begin()); |
|
} |
|
|
|
void GLSpectrumView::clearSpectrumBuffer() |
|
{ |
|
m_currentSpectrum = nullptr; // Make sure we aren't pointing in to a buffer we're about to delete |
|
for (const auto& spectrumData : m_spectrumBuffer) { |
|
delete[] spectrumData.m_spectrum; |
|
} |
|
m_spectrumBuffer.clear(); |
|
} |
|
|
|
void GLSpectrumView::updateSpectrumBuffer(const Real *spectrum, int fftSize, quint32 sampleRate, qint64 centerFrequency, const QDateTime &dateTime) |
|
{ |
|
// Clear buffer when FFT size changes |
|
if (fftSize != m_spectrumBufferFFTSize) |
|
{ |
|
clearSpectrumBuffer(); |
|
m_spectrumBufferFFTSize = fftSize; |
|
} |
|
|
|
// Reuse old buffer if possible, otherwise allocate new buffer |
|
Real *buffer = nullptr; |
|
if (m_spectrumBuffer.size() >= (std::size_t) m_spectrumBufferMaxSize) { |
|
buffer = m_spectrumBuffer.takeFirst().m_spectrum; |
|
} |
|
if (!buffer) { |
|
buffer = new Real[fftSize]; |
|
} |
|
|
|
// Store copy of spectrum and current parameters in spectrum buffer |
|
std::copy(spectrum, spectrum + fftSize, buffer); |
|
Spectrum spectrumData = {buffer, sampleRate, centerFrequency, dateTime}; |
|
m_spectrumBuffer.append(spectrumData); |
|
} |
|
|
|
// We use the scroll buffer for the Web API's spectrum history |
|
bool GLSpectrumView::getSpectrumHistory(const QDateTime& since, int maxRows, const HistoryRowCallback& row) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (!m_scrollBarEnabled) { |
|
return false; |
|
} |
|
|
|
const int size = (int) m_spectrumBuffer.size(); |
|
int first = size; |
|
|
|
// Back from the newest to the oldest row still wanted |
|
while ((first > 0) && (m_spectrumBuffer[first - 1].m_dateTime >= since)) { |
|
first--; |
|
} |
|
|
|
// Every FFT is a row, hundreds a second, so a period is usually far more rows than asked |
|
// for. Consecutive rows are folded together by maximum rather than skipped, so a burst |
|
// shorter than the fold still shows, and a fold never mixes rows of different tunings |
|
const int candidates = size - first; |
|
const int fold = std::max(1, (candidates + std::max(1, maxRows) - 1) / std::max(1, maxRows)); |
|
std::vector<Real> combined; |
|
|
|
for (int i = first; i < size; ) |
|
{ |
|
const Spectrum& lead = m_spectrumBuffer[i]; |
|
int end = i + 1; |
|
|
|
while ((end < size) && (end - i < fold) |
|
&& (m_spectrumBuffer[end].m_sampleRate == lead.m_sampleRate) |
|
&& (m_spectrumBuffer[end].m_centerFrequency == lead.m_centerFrequency)) { |
|
end++; |
|
} |
|
|
|
if (end - i == 1) |
|
{ |
|
row(lead.m_spectrum, m_spectrumBufferFFTSize, lead.m_sampleRate, lead.m_centerFrequency, lead.m_dateTime); |
|
} |
|
else |
|
{ |
|
combined.assign(lead.m_spectrum, lead.m_spectrum + m_spectrumBufferFFTSize); |
|
|
|
for (int j = i + 1; j < end; j++) |
|
{ |
|
const Real *other = m_spectrumBuffer[j].m_spectrum; |
|
|
|
for (int k = 0; k < m_spectrumBufferFFTSize; k++) { |
|
combined[k] = std::max(combined[k], other[k]); |
|
} |
|
} |
|
|
|
row(combined.data(), m_spectrumBufferFFTSize, lead.m_sampleRate, lead.m_centerFrequency, m_spectrumBuffer[end - 1].m_dateTime); |
|
} |
|
|
|
i = end; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
void GLSpectrumView::clearWaterfallRow(int nbBins) |
|
{ |
|
if (m_waterfallBufferPos < m_waterfallBuffer->height()) |
|
{ |
|
quint32* pix = (quint32*)m_waterfallBuffer->scanLine(m_waterfallBufferPos); |
|
|
|
for (int i = 0; i <= nbBins; i++) { |
|
*pix++ = m_waterfallPalette[0]; |
|
} |
|
m_waterfallBufferPos++; |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateWaterfall(const Real *spectrum, int fftSize, int fftMin, int nbBins) |
|
{ |
|
if (m_waterfallBufferPos < m_waterfallBuffer->height()) |
|
{ |
|
quint32* pix = (quint32*)m_waterfallBuffer->scanLine(m_waterfallBufferPos); |
|
|
|
for (int i = 0; i < nbBins; i++) |
|
{ |
|
int v = (int)((spectrum[fftMin + i] - m_referenceLevel) * 2.4 * 100.0 / m_powerRange + 240.0); |
|
v = clampWaterfall(v); |
|
*pix++ = m_waterfallPalette[(int)v]; |
|
} |
|
|
|
int lastIdx = (fftMin + nbBins) % fftSize; |
|
int v = (int)((spectrum[lastIdx] - m_referenceLevel) * 2.4 * 100.0 / m_powerRange + 240.0); |
|
v = clampWaterfall(v); |
|
*pix++ = m_waterfallPalette[(int)v]; |
|
|
|
m_waterfallBufferPos++; |
|
} |
|
} |
|
|
|
void GLSpectrumView::clear3DSpectrogramRow(int nbBins) |
|
{ |
|
if (m_3DSpectrogramBufferPos < m_3DSpectrogramBuffer->height()) |
|
{ |
|
quint8* pix = (quint8*)m_3DSpectrogramBuffer->scanLine(m_3DSpectrogramBufferPos); |
|
|
|
for (int i = 0; i <= nbBins; i++) { |
|
*pix++ = 0; |
|
} |
|
m_3DSpectrogramBufferPos++; |
|
} |
|
} |
|
|
|
void GLSpectrumView::update3DSpectrogram(const Real *spectrum, int fftSize, int fftMin, int nbBins) |
|
{ |
|
if (m_3DSpectrogramBufferPos < m_3DSpectrogramBuffer->height()) |
|
{ |
|
quint8* pix = (quint8*)m_3DSpectrogramBuffer->scanLine(m_3DSpectrogramBufferPos); |
|
|
|
for (int i = 0; i < nbBins; i++) |
|
{ |
|
int v = (int)((spectrum[fftMin + i] - m_referenceLevel) * 2.4 * 100.0 / m_powerRange + 240.0); |
|
v = clampPixel(v); |
|
*pix++ = v; |
|
} |
|
|
|
int lastIdx = (fftMin + nbBins) % fftSize; |
|
int v = (int)((spectrum[lastIdx] - m_referenceLevel) * 2.4 * 100.0 / m_powerRange + 240.0); |
|
v = clampPixel(v); |
|
*pix++ = v; |
|
|
|
m_3DSpectrogramBufferPos++; |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateHistogram(const Real *spectrum, int fftMin, int nbBins) |
|
{ |
|
quint8* b = m_histogram; |
|
int fftMulSize = 100 * nbBins; |
|
|
|
if ((m_displayHistogram || m_displayMaxHold) && (m_decay != 0)) |
|
{ |
|
m_decayDivisorCount--; |
|
|
|
if ((m_decay > 1) || (m_decayDivisorCount <= 0)) |
|
{ |
|
for (int i = 0; i < fftMulSize; i++) |
|
{ |
|
if (*b > m_decay) { |
|
*b = *b - m_decay; |
|
} else { |
|
*b = 0; |
|
} |
|
|
|
b++; |
|
} |
|
|
|
m_decayDivisorCount = m_decayDivisor; |
|
} |
|
} |
|
|
|
#if 0 //def USE_SSE2 |
|
if(m_decay >= 0) { // normal |
|
const __m128 refl = {m_referenceLevel, m_referenceLevel, m_referenceLevel, m_referenceLevel}; |
|
const __m128 power = {m_powerRange, m_powerRange, m_powerRange, m_powerRange}; |
|
const __m128 mul = {100.0f, 100.0f, 100.0f, 100.0f}; |
|
|
|
for(int i = 0; i < m_fftSize; i += 4) { |
|
__m128 abc = _mm_loadu_ps (&spectrum[i]); |
|
abc = _mm_sub_ps(abc, refl); |
|
abc = _mm_mul_ps(abc, mul); |
|
abc = _mm_div_ps(abc, power); |
|
abc = _mm_add_ps(abc, mul); |
|
__m128i result = _mm_cvtps_epi32(abc); |
|
|
|
for(int j = 0; j < 4; j++) { |
|
int v = ((int*)&result)[j]; |
|
if((v >= 0) && (v <= 99)) { |
|
b = m_histogram + (i + j) * 100 + v; |
|
if(*b < 220) |
|
*b += m_histogramStroke; // was 4 |
|
else if(*b < 239) |
|
*b += 1; |
|
} |
|
} |
|
} |
|
} else { // draw double pixels |
|
int add = -m_decay * 4; |
|
const __m128 refl = {m_referenceLevel, m_referenceLevel, m_referenceLevel, m_referenceLevel}; |
|
const __m128 power = {m_powerRange, m_powerRange, m_powerRange, m_powerRange}; |
|
const __m128 mul = {100.0f, 100.0f, 100.0f, 100.0f}; |
|
|
|
for(int i = 0; i < m_fftSize; i += 4) { |
|
__m128 abc = _mm_loadu_ps (&spectrum[i]); |
|
abc = _mm_sub_ps(abc, refl); |
|
abc = _mm_mul_ps(abc, mul); |
|
abc = _mm_div_ps(abc, power); |
|
abc = _mm_add_ps(abc, mul); |
|
__m128i result = _mm_cvtps_epi32(abc); |
|
|
|
for(int j = 0; j < 4; j++) { |
|
int v = ((int*)&result)[j]; |
|
if((v >= 1) && (v <= 98)) { |
|
b = m_histogram + (i + j) * 100 + v; |
|
if(b[-1] < 220) |
|
b[-1] += add; |
|
else if(b[-1] < 239) |
|
b[-1] += 1; |
|
if(b[0] < 220) |
|
b[0] += add; |
|
else if(b[0] < 239) |
|
b[0] += 1; |
|
if(b[1] < 220) |
|
b[1] += add; |
|
else if(b[1] < 239) |
|
b[1] += 1; |
|
} else if((v >= 0) && (v <= 99)) { |
|
b = m_histogram + (i + j) * 100 + v; |
|
if(*b < 220) |
|
*b += add; |
|
else if(*b < 239) |
|
*b += 1; |
|
} |
|
} |
|
} |
|
} |
|
#else |
|
for (int i = 0; i < nbBins; i++) |
|
{ |
|
int v = (int)((spectrum[fftMin + i] - m_referenceLevel) * 100.0 / m_powerRange + 100.0); |
|
|
|
if ((v >= 0) && (v <= 99)) |
|
{ |
|
b = m_histogram + i * 100 + v; |
|
|
|
// capping to 239 as palette values are [0..239] |
|
if (*b + m_histogramStroke <= 239) { |
|
*b += m_histogramStroke; // was 4 |
|
} else { |
|
*b = 239; |
|
} |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
void GLSpectrumView::initializeGL() |
|
{ |
|
QOpenGLContext *glCurrentContext = QOpenGLContext::currentContext(); |
|
int majorVersion = 0; |
|
int minorVersion = 0; |
|
|
|
if (glCurrentContext) |
|
{ |
|
if (QOpenGLContext::currentContext()->isValid()) |
|
{ |
|
qDebug() << "GLSpectrumView::initializeGL: context:" |
|
<< " major: " << (QOpenGLContext::currentContext()->format()).majorVersion() |
|
<< " minor: " << (QOpenGLContext::currentContext()->format()).minorVersion() |
|
<< " ES: " << (QOpenGLContext::currentContext()->isOpenGLES() ? "yes" : "no"); |
|
majorVersion = (QOpenGLContext::currentContext()->format()).majorVersion(); |
|
minorVersion = (QOpenGLContext::currentContext()->format()).minorVersion(); |
|
} |
|
else { |
|
qDebug() << "GLSpectrumView::initializeGL: current context is invalid"; |
|
} |
|
|
|
// Enable OpenGL debugging |
|
// Disable for release, as some OpenGL drivers are quite verbose and output |
|
// info on every frame |
|
if (false) |
|
{ |
|
QSurfaceFormat format = glCurrentContext->format(); |
|
format.setOption(QSurfaceFormat::DebugContext); |
|
glCurrentContext->setFormat(format); |
|
|
|
if (glCurrentContext->hasExtension(QByteArrayLiteral("GL_KHR_debug"))) |
|
{ |
|
m_openGLLogger = new QOpenGLDebugLogger(this); |
|
m_openGLLogger->initialize(); |
|
connect(m_openGLLogger, &QOpenGLDebugLogger::messageLogged, this, &GLSpectrumView::openGLDebug); |
|
m_openGLLogger->startLogging(QOpenGLDebugLogger::SynchronousLogging); |
|
} |
|
else |
|
{ |
|
qDebug() << "GLSpectrumView::initializeGL: GL_KHR_debug not available"; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
qCritical() << "GLSpectrumView::initializeGL: no current context"; |
|
return; |
|
} |
|
|
|
QOpenGLFunctions *glFunctions = QOpenGLContext::currentContext()->functions(); |
|
glFunctions->initializeOpenGLFunctions(); |
|
|
|
//glDisable(GL_DEPTH_TEST); |
|
m_glShaderSimple.initializeGL(majorVersion, minorVersion); |
|
m_glShaderLeftScale.initializeGL(majorVersion, minorVersion); |
|
m_glShaderFrequencyScale.initializeGL(majorVersion, minorVersion); |
|
m_glShaderWaterfall.initializeGL(majorVersion, minorVersion); |
|
m_glShaderHistogram.initializeGL(majorVersion, minorVersion); |
|
m_glShaderColorMap.initializeGL(majorVersion, minorVersion); |
|
m_glShaderTextOverlay.initializeGL(majorVersion, minorVersion); |
|
m_glShaderInfo.initializeGL(majorVersion, minorVersion); |
|
m_glShaderSpectrogram.initializeGL(majorVersion, minorVersion); |
|
m_glShaderSpectrogramTimeScale.initializeGL(majorVersion, minorVersion); |
|
m_glShaderSpectrogramPowerScale.initializeGL(majorVersion, minorVersion); |
|
} |
|
|
|
void GLSpectrumView::openGLDebug(const QOpenGLDebugMessage &debugMessage) |
|
{ |
|
qDebug() << "GLSpectrumView::openGLDebug: " << debugMessage; |
|
} |
|
|
|
void GLSpectrumView::resizeGL(int width, int height) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
QOpenGLFunctions *glFunctions = QOpenGLContext::currentContext()->functions(); |
|
glFunctions->glViewport(0, 0, width, height); |
|
m_changesPending = true; |
|
} |
|
|
|
void GLSpectrumView::clearSpectrumHistogram() |
|
{ |
|
if (!m_mutex.tryLock(2)) { |
|
return; |
|
} |
|
|
|
memset(m_histogram, 0x00, 100 * m_nbBins); |
|
|
|
m_mutex.unlock(); |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::paintGL() |
|
{ |
|
PROFILER_START() |
|
|
|
if (!m_mutex.tryLock(3)) { // Give time for newSpectrum to complete |
|
return; |
|
} |
|
|
|
if (!m_changesPending && (m_waterfallTimeUnits != SpectrumSettings::TimeOffset)) |
|
{ |
|
// Waterfall timescale can change on every repaint when displaying real time |
|
m_timeScale.requestReCalc(); |
|
paintLeftScales(); |
|
if (!m_changesPending) { |
|
m_glShaderLeftScale.initTexture(m_leftMarginPixmap.toImage()); |
|
} |
|
} |
|
|
|
if (m_changesPending) |
|
{ |
|
applyChanges(); |
|
m_changesPending = false; |
|
} |
|
|
|
if (m_nbBins <= 0) |
|
{ |
|
m_mutex.unlock(); |
|
return; |
|
} |
|
|
|
QOpenGLFunctions *glFunctions = QOpenGLContext::currentContext()->functions(); |
|
glFunctions->glClearColor(0.0f, 0.0f, 0.0f, 1.0f); |
|
glFunctions->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
|
|
|
QMatrix4x4 spectrogramGridMatrix; |
|
float devicePixelRatio = 1.0f; |
|
|
|
if (m_display3DSpectrogram) |
|
{ |
|
m_glShaderSpectrogram.applyTransform(spectrogramGridMatrix); |
|
// paint 3D spectrogram |
|
if (m_3DSpectrogramTexturePos + m_3DSpectrogramBufferPos < m_3DSpectrogramTextureHeight) |
|
{ |
|
m_glShaderSpectrogram.subTexture(0, m_3DSpectrogramTexturePos, m_nbBins + 1, m_3DSpectrogramBufferPos, m_3DSpectrogramBuffer->scanLine(0)); |
|
m_3DSpectrogramTexturePos += m_3DSpectrogramBufferPos; |
|
} |
|
else |
|
{ |
|
int breakLine = m_3DSpectrogramTextureHeight - m_3DSpectrogramTexturePos; |
|
int linesLeft = m_3DSpectrogramTexturePos + m_3DSpectrogramBufferPos - m_3DSpectrogramTextureHeight; |
|
m_glShaderSpectrogram.subTexture(0, m_3DSpectrogramTexturePos, m_nbBins + 1, breakLine, m_3DSpectrogramBuffer->scanLine(0)); |
|
m_glShaderSpectrogram.subTexture(0, 0, m_nbBins + 1, linesLeft, m_3DSpectrogramBuffer->scanLine(breakLine)); |
|
m_3DSpectrogramTexturePos = linesLeft; |
|
} |
|
|
|
m_3DSpectrogramBufferPos = 0; |
|
|
|
// Temporarily reduce viewport to waterfall area so anything outside is clipped |
|
if (window()->windowHandle()) { |
|
devicePixelRatio = window()->windowHandle()->devicePixelRatio(); |
|
} |
|
glFunctions->glViewport(0, m_3DSpectrogramBottom*devicePixelRatio, width()*devicePixelRatio, m_waterfallHeight*devicePixelRatio); |
|
m_glShaderSpectrogram.drawSurface( |
|
m_3DSpectrogramStyle, |
|
spectrogramGridMatrix, |
|
m_3DSpectrogramTexturePos, |
|
m_invertedWaterfall); |
|
glFunctions->glViewport(0, 0, width()*devicePixelRatio, height()*devicePixelRatio); |
|
} |
|
else if (m_displayWaterfall) |
|
{ |
|
// paint 2D waterfall |
|
{ |
|
GLfloat vtx1[] = { |
|
0, m_invertedWaterfall ? 0.0f : 1.0f, |
|
1, m_invertedWaterfall ? 0.0f : 1.0f, |
|
1, m_invertedWaterfall ? 1.0f : 0.0f, |
|
0, m_invertedWaterfall ? 1.0f : 0.0f |
|
}; |
|
|
|
if (m_waterfallTexturePos + m_waterfallBufferPos < m_waterfallTextureHeight) |
|
{ |
|
m_glShaderWaterfall.subTexture(0, m_waterfallTexturePos, m_nbBins + 1, m_waterfallBufferPos, m_waterfallBuffer->scanLine(0)); |
|
m_waterfallTexturePos += m_waterfallBufferPos; |
|
} |
|
else |
|
{ |
|
int breakLine = m_waterfallTextureHeight - m_waterfallTexturePos; |
|
int linesLeft = m_waterfallTexturePos + m_waterfallBufferPos - m_waterfallTextureHeight; |
|
m_glShaderWaterfall.subTexture(0, m_waterfallTexturePos, m_nbBins + 1, breakLine, m_waterfallBuffer->scanLine(0)); |
|
m_glShaderWaterfall.subTexture(0, 0, m_nbBins + 1, linesLeft, m_waterfallBuffer->scanLine(breakLine)); |
|
m_waterfallTexturePos = linesLeft; |
|
} |
|
|
|
m_waterfallBufferPos = 0; |
|
|
|
float prop_y = m_waterfallTexturePos / (m_waterfallTextureHeight - 1.0); |
|
float off = 1.0 / (m_waterfallTextureHeight - 1.0); |
|
|
|
GLfloat tex1[] = { |
|
0, prop_y + 1 - off, |
|
1, prop_y + 1 - off, |
|
1, prop_y, |
|
0, prop_y |
|
}; |
|
|
|
m_glShaderWaterfall.drawSurface(m_glWaterfallBoxMatrix, tex1, vtx1, 4); |
|
} |
|
|
|
// paint channels |
|
if (m_mouseInside) |
|
{ |
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
ChannelMarkerState* dv = m_channelMarkerStates[i]; |
|
|
|
if (dv->m_channelMarker->getVisible() |
|
&& (dv->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink) |
|
&& dv->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
{ |
|
GLfloat q3[] { |
|
0, 0, |
|
1, 0, |
|
1, 1, |
|
0, 1, |
|
0.5, 0, |
|
0.5, 1, |
|
}; |
|
|
|
QVector4D color(dv->m_channelMarker->getColor().redF(), dv->m_channelMarker->getColor().greenF(), dv->m_channelMarker->getColor().blueF(), 0.3f); |
|
m_glShaderSimple.drawSurface(dv->m_glMatrixWaterfall, color, q3, 4); |
|
|
|
QVector4D colorLine(0.8f, 0.8f, 0.6f, 1.0f); |
|
m_glShaderSimple.drawSegments(dv->m_glMatrixDsbWaterfall, colorLine, &q3[8], 2); |
|
|
|
} |
|
} |
|
} |
|
} |
|
|
|
// draw rect around |
|
{ |
|
GLfloat q3[] { |
|
1, 1, |
|
0, 1, |
|
0, 0, |
|
1, 0 |
|
}; |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, 0.5f); |
|
m_glShaderSimple.drawContour(m_glWaterfallBoxMatrix, color, q3, 4); |
|
} |
|
} |
|
|
|
// When zoomed, use the next sample off screen. When not, replicate the Nyquist bin |
|
const int lastSampleIdx = (m_fftMin + m_nbBins) % m_fftSize; |
|
|
|
// paint histogram |
|
if (m_displayHistogram || m_displayMaxHold || m_displayCurrent) |
|
{ |
|
if (m_displayHistogram) |
|
{ |
|
{ |
|
// import new lines into the texture |
|
quint32* pix; |
|
quint8* bs = m_histogram; |
|
|
|
for (int y = 0; y < 100; y++) |
|
{ |
|
quint8* b = bs; |
|
pix = (quint32*)m_histogramBuffer->scanLine(99 - y); |
|
|
|
for (int x = 0; x < m_nbBins; x++) |
|
{ |
|
*pix = m_histogramPalette[*b]; |
|
pix++; |
|
b += 100; |
|
} |
|
|
|
bs++; |
|
} |
|
|
|
GLfloat vtx1[] = { |
|
0, 0, |
|
1, 0, |
|
1, 1, |
|
0, 1 |
|
}; |
|
GLfloat tex1[] = { |
|
0, 0, |
|
1, 0, |
|
1, 1, |
|
0, 1 |
|
}; |
|
|
|
m_glShaderHistogram.subTexture(0, 0, m_nbBins, 100, m_histogramBuffer->scanLine(0)); |
|
m_glShaderHistogram.drawSurface(m_glHistogramBoxMatrix, tex1, vtx1, 4); |
|
} |
|
} |
|
|
|
|
|
// paint channels |
|
if (m_mouseInside) |
|
{ |
|
// Effective BW overlays |
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
ChannelMarkerState* dv = m_channelMarkerStates[i]; |
|
|
|
if (dv->m_channelMarker->getVisible() |
|
&& (dv->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink) |
|
&& dv->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
{ |
|
GLfloat q3[] { |
|
0, 0, |
|
1, 0, |
|
1, 1, |
|
0, 1, |
|
0.5, 0, |
|
0.5, 1 |
|
}; |
|
|
|
QVector4D color(dv->m_channelMarker->getColor().redF(), dv->m_channelMarker->getColor().greenF(), dv->m_channelMarker->getColor().blueF(), 0.3f); |
|
m_glShaderSimple.drawSurface(dv->m_glMatrixHistogram, color, q3, 4); |
|
|
|
QVector4D colorLine(0.8f, 0.8f, 0.6f, 1.0f); |
|
|
|
if (dv->m_channelMarker->getSidebands() != ChannelMarker::dsb) { |
|
q3[6] = 0.5; |
|
} |
|
|
|
m_glShaderSimple.drawSegments(dv->m_glMatrixDsbHistogram, colorLine, &q3[8], 2); |
|
m_glShaderSimple.drawSegments(dv->m_glMatrixFreqScale, colorLine, q3, 2); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
// paint left scales (time and power) |
|
if (m_displayWaterfall || m_displayMaxHold || m_displayCurrent || m_displayHistogram ) |
|
{ |
|
{ |
|
GLfloat vtx1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderLeftScale.drawSurface(m_glLeftScaleBoxMatrix, tex1, vtx1, 4); |
|
} |
|
} |
|
|
|
// paint frequency scale |
|
if (m_displayWaterfall || m_displayMaxHold || m_displayCurrent || m_displayHistogram) |
|
{ |
|
{ |
|
GLfloat vtx1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderFrequencyScale.drawSurface(m_glFrequencyScaleBoxMatrix, tex1, vtx1, 4); |
|
} |
|
|
|
// paint channels |
|
|
|
// Effective bandwidth overlays |
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
ChannelMarkerState* dv = m_channelMarkerStates[i]; |
|
|
|
// frequency scale channel overlay |
|
if (dv->m_channelMarker->getVisible() |
|
&& (dv->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink) |
|
&& dv->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
{ |
|
GLfloat q3[] { |
|
1, 0.2, |
|
0, 0.2, |
|
0, 0, |
|
1, 0, |
|
0.5, 0, |
|
0.5, 1 |
|
}; |
|
|
|
QVector4D color(dv->m_channelMarker->getColor().redF(), dv->m_channelMarker->getColor().greenF(), dv->m_channelMarker->getColor().blueF(), 0.5f); |
|
m_glShaderSimple.drawSurface(dv->m_glMatrixFreqScale, color, q3, 4); |
|
|
|
if (dv->m_channelMarker->getHighlighted()) |
|
{ |
|
QVector4D colorLine(0.8f, 0.8f, 0.6f, 1.0f); |
|
m_glShaderSimple.drawSegments(dv->m_glMatrixDsbFreqScale, colorLine, &q3[8], 2); |
|
m_glShaderSimple.drawSegments(dv->m_glMatrixFreqScale, colorLine, &q3[4], 2); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
// paint 3D spectrogram scales |
|
if (m_display3DSpectrogram && m_displayGrid) |
|
{ |
|
glFunctions->glViewport(0, m_3DSpectrogramBottom*devicePixelRatio, width()*devicePixelRatio, m_waterfallHeight*devicePixelRatio); |
|
{ |
|
GLfloat l = m_spectrogramTimePixmap.width() / (GLfloat) width(); |
|
GLfloat r = m_rightMargin / (GLfloat) width(); |
|
GLfloat h = m_frequencyPixmap.height() / (GLfloat) m_waterfallHeight; |
|
|
|
GLfloat vtx1[] = { |
|
-l, - h, |
|
1.0f+r, -h, |
|
1.0f+r, 0.0f, |
|
-l, 0.0f |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderFrequencyScale.drawSurface(spectrogramGridMatrix, tex1, vtx1, 4); |
|
} |
|
|
|
{ |
|
GLfloat w = m_spectrogramTimePixmap.width() / (GLfloat) width(); |
|
GLfloat h = (m_bottomMargin/2) / (GLfloat) m_waterfallHeight; // m_bottomMargin is fm.ascent |
|
|
|
GLfloat vtx1[] = { |
|
-w, 0.0f-h, |
|
0.0f, 0.0f-h, |
|
0.0f, 1.0f+h, |
|
-w, 1.0f+h |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderSpectrogramTimeScale.drawSurface(spectrogramGridMatrix, tex1, vtx1, 4); |
|
} |
|
|
|
{ |
|
GLfloat w = m_spectrogramPowerPixmap.width() / (GLfloat) width(); |
|
GLfloat h = m_topMargin / (GLfloat) m_spectrogramPowerPixmap.height(); |
|
|
|
GLfloat vtx1[] = { |
|
-w, 1.0f, 0.0f, |
|
0.0f, 1.0f, 0.0f, |
|
0.0f, 1.0f, 1.0f+h, |
|
-w, 1.0f, 1.0f+h, |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderSpectrogramPowerScale.drawSurface(spectrogramGridMatrix, tex1, vtx1, 4, 3); |
|
} |
|
|
|
glFunctions->glViewport(0, 0, width()*devicePixelRatio, height()*devicePixelRatio); |
|
} |
|
|
|
// paint max hold lines on top of histogram |
|
if (m_displayMaxHold) |
|
{ |
|
if (m_maxHold.size() < (uint) m_nbBins) { |
|
m_maxHold.resize(m_nbBins); |
|
} |
|
|
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
int j; |
|
quint8* bs = m_histogram + i * 100; |
|
|
|
for (j = 99; j >= 0; j--) |
|
{ |
|
if (bs[j] > 0) { |
|
break; |
|
} |
|
} |
|
|
|
// m_referenceLevel : top |
|
// m_referenceLevel - m_powerRange : bottom |
|
m_maxHold[i] = ((j - 99) * m_powerRange) / 99.0 + m_referenceLevel; |
|
} |
|
// Fill under max hold line |
|
if (m_spectrumStyle != SpectrumSettings::Line) |
|
{ |
|
GLfloat *q3 = m_q3ColorMap.m_array; |
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
Real v = clampPower(m_maxHold[i] - m_referenceLevel); |
|
|
|
q3[4*i] = (GLfloat)i; |
|
q3[4*i+1] = -m_powerRange; |
|
q3[4*i+2] = (GLfloat)i; |
|
q3[4*i+3] = v; |
|
} |
|
q3[4*m_nbBins] = (GLfloat) m_nbBins; |
|
q3[4*m_nbBins+1] = -m_powerRange; |
|
q3[4*m_nbBins+2] = (GLfloat) m_nbBins; |
|
q3[4*m_nbBins+3] = clampPower(m_maxHold[lastSampleIdx] - m_referenceLevel); |
|
|
|
QVector4D color(0.5f, 0.0f, 0.0f, (float) m_displayTraceIntensity / 100.0f); |
|
m_glShaderSimple.drawSurfaceStrip(m_glHistogramSpectrumMatrix, color, q3, 2*(m_nbBins+1)); |
|
} |
|
// Max hold line |
|
{ |
|
GLfloat *q3 = m_q3FFT.m_array; |
|
|
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
Real v = clampPower(m_maxHold[i] - m_referenceLevel); |
|
|
|
q3[2*i] = (Real) i; |
|
q3[2*i+1] = v; |
|
} |
|
q3[2*m_nbBins] = (GLfloat) m_nbBins; |
|
q3[2*m_nbBins+1] = clampPower(m_maxHold[lastSampleIdx] - m_referenceLevel); |
|
|
|
QVector4D color(1.0f, 0.0f, 0.0f, (float) m_displayTraceIntensity / 100.0f); |
|
m_glShaderSimple.drawPolyline(m_glHistogramSpectrumMatrix, color, q3, m_nbBins+1); |
|
} |
|
} |
|
|
|
// paint mask violations |
|
if ((m_measurement == SpectrumSettings::MeasurementMask) && m_measurementHighlight) |
|
{ |
|
for (int m = 0; m < m_spectrumMemory.size(); m++) |
|
{ |
|
if ( (m_spectrumMemory[m].m_spectrum.size() == m_fftSize) |
|
&& (m_maskFails[m].size() == (std::size_t) m_fftSize) |
|
&& ((m_measurementMemMasks & (1 << m)) != 0) |
|
) |
|
{ |
|
GLfloat *q3 = m_q3ColorMap.m_array; |
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
Real v1 = clampPower(m_maskFails[m][m_fftMin+i] - m_referenceLevel); |
|
Real v2 = clampPower(m_spectrumMemory[m].m_spectrum[m_fftMin+i] - m_referenceLevel); |
|
|
|
q3[4*i] = (GLfloat)i; |
|
q3[4*i+1] = v2; |
|
q3[4*i+2] = (GLfloat)i; |
|
q3[4*i+3] = v1; |
|
} |
|
q3[4*m_nbBins] = (GLfloat) m_nbBins; |
|
q3[4*m_nbBins+1] = clampPower(m_maskFails[m][lastSampleIdx] - m_referenceLevel); |
|
q3[4*m_nbBins+2] = (GLfloat) m_nbBins; |
|
q3[4*m_nbBins+3] = q3[3]; |
|
|
|
QVector4D color(0.5f, 0.0f, 0.0f, (float) m_displayTraceIntensity / 100.0f); |
|
m_glShaderSimple.drawSurfaceStrip(m_glHistogramSpectrumMatrix, color, q3, 2*(m_nbBins+1)); |
|
} |
|
} |
|
} |
|
|
|
// paint memory spectrum as lines |
|
if (m_displayCurrent) |
|
{ |
|
for (const auto& memory : m_spectrumMemory) |
|
{ |
|
if (memory.m_display && (memory.m_spectrum.size() == m_fftSize)) |
|
{ |
|
QColor colorF = QColor::fromRgba(memory.m_color); |
|
|
|
// Draw label |
|
if (!memory.m_label.isEmpty()) |
|
{ |
|
float y = (m_powerScale.getRangeMax() - memory.m_spectrum[m_fftMin]) / m_powerScale.getRange() * m_histogramRect.height(); |
|
float h = m_topMargin / (float) height(); |
|
|
|
if ((y >= m_histogramRect.top()) && (y + h < m_histogramRect.bottom())) |
|
{ |
|
drawTextOverlay( |
|
memory.m_label, |
|
colorF, |
|
m_textOverlayFont, |
|
0.0f, |
|
y, |
|
true, |
|
false, // text above the line |
|
m_histogramRect); |
|
} |
|
} |
|
|
|
GLfloat *q3; |
|
|
|
// Draw line |
|
q3 = m_q3FFT.m_array; |
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
Real v = clampPower(memory.m_spectrum[m_fftMin+i] - m_referenceLevel); |
|
q3[2*i] = (Real) i; |
|
q3[2*i+1] = v; |
|
} |
|
q3[2*m_nbBins] = (GLfloat) m_nbBins; |
|
q3[2*m_nbBins+1] = clampPower(memory.m_spectrum[lastSampleIdx] - m_referenceLevel); |
|
|
|
QVector4D color; |
|
color = QVector4D(colorF.redF(), colorF.greenF(), colorF.blueF(), colorF.alphaF()); |
|
m_glShaderSimple.drawPolyline(m_glHistogramSpectrumMatrix, color, q3, m_nbBins+1); |
|
} |
|
} |
|
} |
|
|
|
// paint current spectrum line on top of histogram |
|
if (m_displayCurrent && m_currentSpectrum) |
|
{ |
|
Real bottom = -m_powerRange; |
|
GLfloat *q3; |
|
|
|
if (m_spectrumStyle != SpectrumSettings::Line) |
|
{ |
|
q3 = m_q3ColorMap.m_array; |
|
// Fill under line |
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
Real v = clampPower(m_currentSpectrum[m_fftMin + i] - m_referenceLevel); |
|
|
|
q3[4*i] = (GLfloat)i; |
|
q3[4*i+1] = bottom; |
|
q3[4*i+2] = (GLfloat)i; |
|
q3[4*i+3] = v; |
|
} |
|
|
|
q3[4*m_nbBins] = (GLfloat) m_nbBins; |
|
q3[4*m_nbBins+1] = bottom; |
|
q3[4*m_nbBins+2] = (GLfloat) m_nbBins; |
|
q3[4*m_nbBins+3] = clampPower(m_currentSpectrum[lastSampleIdx] - m_referenceLevel); |
|
|
|
QVector4D color(m_spectrumColor.redF(), m_spectrumColor.greenF(), m_spectrumColor.blueF(), (float) m_displayTraceIntensity / 100.0f); |
|
if (m_spectrumStyle == SpectrumSettings::Gradient) { |
|
m_glShaderColorMap.drawSurfaceStrip(m_glHistogramSpectrumMatrix, q3, 2*(m_nbBins+1), bottom, 0.75f); |
|
} else { |
|
m_glShaderSimple.drawSurfaceStrip(m_glHistogramSpectrumMatrix, color, q3, 2*(m_nbBins+1)); |
|
} |
|
} |
|
|
|
{ |
|
if (m_histogramFindPeaks) { |
|
m_peakFinder.init(m_currentSpectrum[m_fftMin]); |
|
} |
|
|
|
// Draw line |
|
q3 = m_q3FFT.m_array; |
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
Real v = clampPower(m_currentSpectrum[m_fftMin + i] - m_referenceLevel); |
|
|
|
q3[2*i] = (Real) i; |
|
q3[2*i+1] = v; |
|
|
|
if (m_histogramFindPeaks && (i > 0)) { |
|
m_peakFinder.push(m_currentSpectrum[m_fftMin + i], i == m_nbBins - 1); |
|
} |
|
} |
|
|
|
q3[2*m_nbBins] = (GLfloat) m_nbBins; |
|
q3[2*m_nbBins+1] = clampPower(m_currentSpectrum[lastSampleIdx] - m_referenceLevel); |
|
|
|
QVector4D color; |
|
if (m_spectrumStyle == SpectrumSettings::Gradient) { |
|
color = QVector4D(m_colorMap[255*3], m_colorMap[255*3+1], m_colorMap[255*3+2], (float) m_displayTraceIntensity / 100.0f); |
|
} else { |
|
color = QVector4D(m_spectrumColor.redF(), m_spectrumColor.greenF(), m_spectrumColor.blueF(), (float) m_displayTraceIntensity / 100.0f); |
|
} |
|
m_glShaderSimple.drawPolyline(m_glHistogramSpectrumMatrix, color, q3, m_nbBins+1); |
|
|
|
if (m_histogramFindPeaks) { |
|
m_peakFinder.sortPeaks(); |
|
} |
|
} |
|
} |
|
|
|
if (m_displayCurrent && m_currentSpectrum && (m_markersDisplay & SpectrumSettings::MarkersDisplaySpectrum)) |
|
{ |
|
if (m_histogramFindPeaks) { |
|
updateHistogramPeaks(); |
|
} |
|
|
|
drawSpectrumMarkers(); |
|
} |
|
|
|
if (m_markersDisplay & SpectrumSettings::MarkersDisplayAnnotations) { |
|
drawAnnotationMarkers(); |
|
} |
|
|
|
// paint waterfall grid |
|
if (m_displayWaterfall && m_displayGrid) |
|
{ |
|
const ScaleEngine::TickList* tickList; |
|
const ScaleEngine::Tick* tick; |
|
tickList = &m_timeScale.getTickList(); |
|
|
|
{ |
|
GLfloat *q3 = m_q3TickTime.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float y = tick->pos / m_timeScale.getSize(); |
|
q3[4*effectiveTicks] = 0; |
|
q3[4*effectiveTicks+1] = y; |
|
q3[4*effectiveTicks+2] = 1; |
|
q3[4*effectiveTicks+3] = y; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(m_glWaterfallBoxMatrix, color, q3, 2*effectiveTicks); |
|
} |
|
|
|
tickList = &m_frequencyScale.getTickList(); |
|
|
|
{ |
|
GLfloat *q3 = m_q3TickFrequency.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float x = tick->pos / m_frequencyScale.getSize(); |
|
q3[4*effectiveTicks] = x; |
|
q3[4*effectiveTicks+1] = 0; |
|
q3[4*effectiveTicks+2] = x; |
|
q3[4*effectiveTicks+3] = 1; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(m_glWaterfallBoxMatrix, color, q3, 2*effectiveTicks); |
|
} |
|
} |
|
|
|
// paint 3D spectrogram grid - this is drawn on top of signal, so that appears slightly transparent |
|
// x-axis is freq, y time and z power |
|
if (m_displayGrid && m_display3DSpectrogram) |
|
{ |
|
const ScaleEngine::TickList* tickList; |
|
const ScaleEngine::Tick* tick; |
|
|
|
glFunctions->glViewport(0, m_3DSpectrogramBottom*devicePixelRatio, width()*devicePixelRatio, m_waterfallHeight*devicePixelRatio); |
|
|
|
tickList = &m_powerScale.getTickList(); |
|
{ |
|
GLfloat *q3 = m_q3TickPower.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float y = tick->pos / m_powerScale.getSize(); |
|
q3[6*effectiveTicks] = 0.0; |
|
q3[6*effectiveTicks+1] = 1.0; |
|
q3[6*effectiveTicks+2] = y; |
|
q3[6*effectiveTicks+3] = 1.0; |
|
q3[6*effectiveTicks+4] = 1.0; |
|
q3[6*effectiveTicks+5] = y; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(spectrogramGridMatrix, color, q3, 2*effectiveTicks, 3); |
|
} |
|
|
|
tickList = &m_timeScale.getTickList(); |
|
{ |
|
GLfloat *q3 = m_q3TickTime.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float y = tick->pos / m_timeScale.getSize(); |
|
q3[4*effectiveTicks] = 0.0; |
|
q3[4*effectiveTicks+1] = 1.0 - y; |
|
q3[4*effectiveTicks+2] = 1.0; |
|
q3[4*effectiveTicks+3] = 1.0 - y; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(spectrogramGridMatrix, color, q3, 2*effectiveTicks); |
|
} |
|
|
|
tickList = &m_frequencyScale.getTickList(); |
|
{ |
|
GLfloat *q3 = m_q3TickFrequency.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float x = tick->pos / m_frequencyScale.getSize(); |
|
q3[4*effectiveTicks] = x; |
|
q3[4*effectiveTicks+1] = -0.0; |
|
q3[4*effectiveTicks+2] = x; |
|
q3[4*effectiveTicks+3] = 1.0; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(spectrogramGridMatrix, color, q3, 2*effectiveTicks); |
|
} |
|
{ |
|
GLfloat *q3 = m_q3TickFrequency.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float x = tick->pos / m_frequencyScale.getSize(); |
|
q3[6*effectiveTicks] = x; |
|
q3[6*effectiveTicks+1] = 1.0; |
|
q3[6*effectiveTicks+2] = 0.0; |
|
q3[6*effectiveTicks+3] = x; |
|
q3[6*effectiveTicks+4] = 1.0; |
|
q3[6*effectiveTicks+5] = 1.0; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(spectrogramGridMatrix, color, q3, 2*effectiveTicks, 3); |
|
} |
|
|
|
glFunctions->glViewport(0, 0, width()*devicePixelRatio, height()*devicePixelRatio); |
|
} |
|
|
|
// paint histogram grid |
|
if ((m_displayHistogram || m_displayMaxHold || m_displayCurrent) && (m_displayGrid)) |
|
{ |
|
const ScaleEngine::TickList* tickList; |
|
const ScaleEngine::Tick* tick; |
|
tickList = &m_powerScale.getTickList(); |
|
|
|
{ |
|
GLfloat *q3 = m_q3TickPower.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float y = tick->pos / m_powerScale.getSize(); |
|
q3[4*effectiveTicks] = 0; |
|
q3[4*effectiveTicks+1] = 1-y; |
|
q3[4*effectiveTicks+2] = 1; |
|
q3[4*effectiveTicks+3] = 1-y; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, color, q3, 2*effectiveTicks); |
|
} |
|
|
|
tickList = &m_frequencyScale.getTickList(); |
|
|
|
{ |
|
GLfloat *q3 = m_q3TickFrequency.m_array; |
|
int effectiveTicks = 0; |
|
|
|
for (int i= 0; i < tickList->count(); i++) |
|
{ |
|
tick = &(*tickList)[i]; |
|
|
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
{ |
|
float x = tick->pos / m_frequencyScale.getSize(); |
|
q3[4*effectiveTicks] = x; |
|
q3[4*effectiveTicks+1] = 0; |
|
q3[4*effectiveTicks+2] = x; |
|
q3[4*effectiveTicks+3] = 1; |
|
effectiveTicks++; |
|
} |
|
} |
|
} |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, (float) m_displayGridIntensity / 100.0f); |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, color, q3, 2*effectiveTicks); |
|
} |
|
} |
|
|
|
// paint rect around histogram (do last, so on top of filled spectrum) |
|
if (m_displayHistogram || m_displayMaxHold || m_displayCurrent) |
|
{ |
|
{ |
|
GLfloat q3[] { |
|
1, 1, |
|
0, 1, |
|
0, 0, |
|
1, 0 |
|
}; |
|
|
|
QVector4D color(1.0f, 1.0f, 1.0f, 0.5f); |
|
m_glShaderSimple.drawContour(m_glHistogramBoxMatrix, color, q3, 4); |
|
} |
|
} |
|
|
|
// Paint info line |
|
{ |
|
GLfloat vtx1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderInfo.drawSurface(m_glInfoBoxMatrix, tex1, vtx1, 4); |
|
} |
|
|
|
if (m_displayCursorStats || m_displayPeakStats) { |
|
paintStatusLineRight(); |
|
} |
|
|
|
if (m_currentSpectrum) { |
|
measure(&m_currentSpectrum[m_fftMin], true); |
|
} |
|
|
|
m_mutex.unlock(); |
|
|
|
#ifdef ENABLE_PROFILER |
|
if (m_profileName.isEmpty()) |
|
{ |
|
// Try to use the window name for the profile name |
|
QString windowTitle; |
|
for (QWidget *widget = parentWidget(); widget != nullptr; widget = widget->parentWidget()) |
|
{ |
|
windowTitle = widget->windowTitle(); |
|
if (!windowTitle.isEmpty()) { |
|
break; |
|
} |
|
} |
|
// Add this address so we get per-spectrum profile data |
|
if (windowTitle.isEmpty()) { |
|
m_profileName = QString("Spectrum @%1").arg((quint64)this, 0, 16); |
|
} else { |
|
m_profileName = QString("%1 @%2").arg(windowTitle).arg((quint64)this, 0, 16); |
|
} |
|
} |
|
#endif |
|
|
|
PROFILER_STOP(m_profileName) |
|
} // paintGL |
|
|
|
// Highlight power band for SFDR |
|
void GLSpectrumView::drawPowerBandMarkers(float max, float min, const QVector4D &color) |
|
{ |
|
float p1 = (m_powerScale.getRangeMax() - min) / m_powerScale.getRange(); |
|
float p2 = (m_powerScale.getRangeMax() - max) / m_powerScale.getRange(); |
|
|
|
GLfloat q3[] { |
|
1, p2, |
|
0, p2, |
|
0, p1, |
|
1, p1, |
|
0, p1, |
|
0, p2 |
|
}; |
|
|
|
m_glShaderSimple.drawSurface(m_glHistogramBoxMatrix, color, q3, 4); |
|
} |
|
|
|
// Highlight bandwidth being measured |
|
void GLSpectrumView::drawBandwidthMarkers(int64_t centerFrequency, int bandwidth, const QVector4D &color) |
|
{ |
|
float f1 = (centerFrequency - bandwidth / 2); |
|
float f2 = (centerFrequency + bandwidth / 2); |
|
float x1 = (f1 - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
float x2 = (f2 - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
|
|
GLfloat q3[] { |
|
x2, 1, |
|
x1, 1, |
|
x1, 0, |
|
x2, 0, |
|
x1, 0, |
|
x1, 1 |
|
}; |
|
|
|
m_glShaderSimple.drawSurface(m_glHistogramBoxMatrix, color, q3, 4); |
|
} |
|
|
|
// Highlight peak being measured. Note that the peak isn't always at the center |
|
void GLSpectrumView::drawPeakMarkers(int64_t startFrequency, int64_t endFrequency, const QVector4D &color) |
|
{ |
|
float x1 = (startFrequency - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
float x2 = (endFrequency - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
|
|
GLfloat q3[] { |
|
x2, 1, |
|
x1, 1, |
|
x1, 0, |
|
x2, 0, |
|
x1, 0, |
|
x1, 1 |
|
}; |
|
|
|
m_glShaderSimple.drawSurface(m_glHistogramBoxMatrix, color, q3, 4); |
|
} |
|
|
|
void GLSpectrumView::drawSpectrumMarkers() |
|
{ |
|
if (!m_currentSpectrum) { |
|
return; |
|
} |
|
|
|
QVector4D lineColor(1.0f, 1.0f, 1.0f, 0.3f); |
|
|
|
// paint histogram markers |
|
if (m_histogramMarkers.size() > 0) |
|
{ |
|
for (int i = 0; i < m_histogramMarkers.size(); i++) |
|
{ |
|
if (!m_histogramMarkers.at(i).m_show) { |
|
continue; |
|
} |
|
|
|
QPointF ypoint = m_histogramMarkers.at(i).m_point; |
|
QString powerStr = m_histogramMarkers.at(i).m_powerStr; |
|
|
|
if (m_histogramMarkers.at(i).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePower) |
|
{ |
|
float power = m_linear ? |
|
m_currentSpectrum[m_fftMin + m_histogramMarkers.at(i).m_fftBin] * (m_useCalibration ? m_calibrationGain : 1.0f): |
|
m_currentSpectrum[m_fftMin + m_histogramMarkers.at(i).m_fftBin] + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
ypoint.ry() = |
|
(m_powerScale.getRangeMax() - power) / m_powerScale.getRange(); |
|
ypoint.ry() = ypoint.ry() < 0 ? |
|
0 : |
|
ypoint.ry() > 1 ? 1 : ypoint.ry(); |
|
powerStr = displayPower( |
|
power, |
|
m_linear ? 'e' : 'f', |
|
m_linear ? 3 : 1 |
|
); |
|
} |
|
else if (m_histogramMarkers.at(i).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePowerMax) |
|
{ |
|
float power = m_currentSpectrum[m_fftMin + m_histogramMarkers.at(i).m_fftBin]; |
|
|
|
if ((m_histogramMarkers.at(i).m_holdReset) || (power > m_histogramMarkers[i].m_powerMax)) |
|
{ |
|
m_histogramMarkers[i].m_powerMax = power; |
|
m_histogramMarkers[i].m_holdReset = false; |
|
} |
|
|
|
float powerMax = m_linear ? |
|
m_histogramMarkers[i].m_powerMax * (m_useCalibration ? m_calibrationGain : 1.0f) : |
|
m_histogramMarkers[i].m_powerMax + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
|
|
ypoint.ry() = |
|
(m_powerScale.getRangeMax() - powerMax) / m_powerScale.getRange(); |
|
ypoint.ry() = ypoint.ry() < 0 ? |
|
0 : ypoint.ry() > 1 ? |
|
1 : ypoint.ry(); |
|
powerStr = displayPower( |
|
powerMax, |
|
m_linear ? 'e' : 'f', |
|
m_linear ? 3 : 1 |
|
); |
|
} |
|
|
|
// crosshairs |
|
GLfloat h[] { |
|
(float) m_histogramMarkers.at(i).m_point.x(), 0, |
|
(float) m_histogramMarkers.at(i).m_point.x(), 1 |
|
}; |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, lineColor, h, 2); |
|
GLfloat v[] { |
|
0, (float) ypoint.y(), |
|
1, (float) ypoint.y() |
|
}; |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, lineColor, v, 2); |
|
QColor textColor = m_histogramMarkers.at(i).m_markerColor; |
|
// text |
|
if (i == 0) |
|
{ |
|
drawTextOverlay( |
|
m_histogramMarkers.at(i).m_frequencyStr, |
|
textColor, |
|
m_textOverlayFont, |
|
m_histogramMarkers.at(i).m_point.x() * m_histogramRect.width(), |
|
(m_invertedWaterfall || (m_waterfallHeight == 0)) ? m_histogramRect.height() : 0, |
|
m_histogramMarkers.at(i).m_point.x() < 0.5f, |
|
!m_invertedWaterfall && (m_waterfallHeight != 0), |
|
m_histogramRect); |
|
drawTextOverlay( |
|
powerStr, |
|
textColor, |
|
m_textOverlayFont, |
|
0, |
|
ypoint.y() * m_histogramRect.height(), |
|
true, |
|
ypoint.y() < 0.5f, |
|
m_histogramRect); |
|
} |
|
else |
|
{ |
|
textColor.setAlpha(192); |
|
float power0, poweri; |
|
|
|
if (m_histogramMarkers.at(0).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePower) { |
|
power0 = m_currentSpectrum[m_fftMin + m_histogramMarkers.at(0).m_fftBin]; |
|
} else if (m_histogramMarkers.at(0).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePowerMax) { |
|
power0 = m_histogramMarkers.at(0).m_powerMax; |
|
} else { |
|
power0 = m_linear ? m_histogramMarkers.at(0).m_power : CalcDb::dbPower(m_histogramMarkers.at(0).m_power); |
|
} |
|
|
|
if (m_histogramMarkers.at(i).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePower) { |
|
poweri = m_currentSpectrum[m_fftMin + m_histogramMarkers.at(i).m_fftBin]; |
|
} else if (m_histogramMarkers.at(i).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePowerMax) { |
|
poweri = m_histogramMarkers.at(i).m_powerMax; |
|
} else { |
|
poweri = m_linear ? m_histogramMarkers.at(i).m_power : CalcDb::dbPower(m_histogramMarkers.at(i).m_power); |
|
} |
|
|
|
QString deltaPowerStr; |
|
|
|
if (m_linear) { |
|
deltaPowerStr = QString::number(poweri - power0, 'e', 3); |
|
} else { |
|
deltaPowerStr = QString::number(poweri - power0, 'f', 1); |
|
} |
|
|
|
drawTextOverlay( |
|
m_histogramMarkers.at(i).m_deltaFrequencyStr, |
|
textColor, |
|
m_textOverlayFont, |
|
m_histogramMarkers.at(i).m_point.x() * m_histogramRect.width(), |
|
(m_invertedWaterfall || (m_waterfallHeight == 0)) ? 0 : m_histogramRect.height(), |
|
m_histogramMarkers.at(i).m_point.x() < 0.5f, |
|
(m_invertedWaterfall || (m_waterfallHeight == 0)), |
|
m_histogramRect); |
|
drawTextOverlay( |
|
deltaPowerStr, |
|
textColor, |
|
m_textOverlayFont, |
|
m_histogramRect.width(), |
|
ypoint.y() * m_histogramRect.height(), |
|
false, |
|
ypoint.y() < 0.5f, |
|
m_histogramRect); |
|
} |
|
} |
|
} |
|
|
|
// paint waterfall markers |
|
if (m_waterfallMarkers.size() > 0) |
|
{ |
|
// crosshairs |
|
for (int i = 0; i < m_waterfallMarkers.size(); i++) |
|
{ |
|
if (!m_waterfallMarkers.at(i).m_show) { |
|
continue; |
|
} |
|
|
|
GLfloat h[] { |
|
(float) m_waterfallMarkers.at(i).m_point.x(), 0, |
|
(float) m_waterfallMarkers.at(i).m_point.x(), 1 |
|
}; |
|
m_glShaderSimple.drawSegments(m_glWaterfallBoxMatrix, lineColor, h, 2); |
|
GLfloat v[] { |
|
0, (float) m_waterfallMarkers.at(i).m_point.y(), |
|
1, (float) m_waterfallMarkers.at(i).m_point.y() |
|
}; |
|
m_glShaderSimple.drawSegments(m_glWaterfallBoxMatrix, lineColor, v, 2); |
|
// } |
|
// text |
|
// for (int i = 0; i < m_waterfallMarkers.size(); i++) |
|
// { |
|
QColor textColor = m_waterfallMarkers.at(i).m_markerColor; |
|
textColor.setAlpha(192); |
|
|
|
if (i == 0) |
|
{ |
|
drawTextOverlay( |
|
m_waterfallMarkers.at(i).m_frequencyStr, |
|
textColor, |
|
m_textOverlayFont, |
|
m_waterfallMarkers.at(i).m_point.x() * m_waterfallRect.width(), |
|
(!m_invertedWaterfall || (m_histogramHeight == 0)) ? m_waterfallRect.height() : 0, |
|
m_waterfallMarkers.at(i).m_point.x() < 0.5f, |
|
m_invertedWaterfall && (m_histogramHeight != 0), |
|
m_waterfallRect); |
|
drawTextOverlay( |
|
m_waterfallMarkers.at(i).m_timeStr, |
|
textColor, |
|
m_textOverlayFont, |
|
0, |
|
m_waterfallMarkers.at(i).m_point.y() * m_waterfallRect.height(), |
|
true, |
|
m_waterfallMarkers.at(i).m_point.y() < 0.5f, |
|
m_waterfallRect); |
|
} |
|
else |
|
{ |
|
drawTextOverlay( |
|
m_waterfallMarkers.at(i).m_deltaFrequencyStr, |
|
textColor, |
|
m_textOverlayFont, |
|
m_waterfallMarkers.at(i).m_point.x() * m_waterfallRect.width(), |
|
(!m_invertedWaterfall || (m_histogramHeight == 0)) ? 0 : m_waterfallRect.height(), |
|
m_waterfallMarkers.at(i).m_point.x() < 0.5f, |
|
!m_invertedWaterfall || (m_histogramHeight == 0), |
|
m_waterfallRect); |
|
drawTextOverlay( |
|
m_waterfallMarkers.at(i).m_deltaTimeStr, |
|
textColor, |
|
m_textOverlayFont, |
|
m_waterfallRect.width(), |
|
m_waterfallMarkers.at(i).m_point.y() * m_waterfallRect.height(), |
|
false, |
|
m_waterfallMarkers.at(i).m_point.y() < 0.5f, |
|
m_waterfallRect); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::drawAnnotationMarkers() |
|
{ |
|
if ((!m_currentSpectrum) || (m_visibleAnnotationMarkers.size() == 0)) { |
|
return; |
|
} |
|
|
|
float h = m_annotationMarkerHeight / (float) m_histogramHeight; |
|
float htop = 1.0f / (float) m_histogramHeight; |
|
|
|
for (const auto &marker : m_visibleAnnotationMarkers) |
|
{ |
|
if (marker->m_show == SpectrumAnnotationMarker::Hidden) { |
|
continue; |
|
} |
|
|
|
QVector4D color(marker->m_markerColor.redF(), marker->m_markerColor.greenF(), marker->m_markerColor.blueF(), 0.5f); |
|
|
|
if (marker->m_bandwidth == 0) |
|
{ |
|
GLfloat d[] { |
|
marker->m_startPos, htop, |
|
marker->m_startPos, h |
|
}; |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, color, d, 2); |
|
} |
|
else |
|
{ |
|
GLfloat q3[] { |
|
marker->m_stopPos, h, |
|
marker->m_startPos, h, |
|
marker->m_startPos, htop, |
|
marker->m_stopPos, htop |
|
}; |
|
m_glShaderSimple.drawSurface(m_glHistogramBoxMatrix, color, q3, 4); |
|
} |
|
|
|
// Always draw a line in the top area, so we can see where bands start/stop when contiguous |
|
// When show is ShowFull, we draw at full height of spectrum |
|
bool full = marker->m_show == SpectrumAnnotationMarker::ShowFull; |
|
|
|
GLfloat d1[] { |
|
marker->m_startPos, full ? 0 : htop, |
|
marker->m_startPos, full ? 1 : h, |
|
}; |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, color, d1, 2); |
|
|
|
if (marker->m_bandwidth != 0) |
|
{ |
|
GLfloat d2[] { |
|
marker->m_stopPos, full ? 0 : htop, |
|
marker->m_stopPos, full ? 1 : h, |
|
}; |
|
m_glShaderSimple.drawSegments(m_glHistogramBoxMatrix, color, d2, 2); |
|
} |
|
|
|
if ((marker->m_show == SpectrumAnnotationMarker::ShowFull) || (marker->m_show == SpectrumAnnotationMarker::ShowText)) |
|
{ |
|
float txtpos = marker->m_startPos < 0.5f ? |
|
marker->m_startPos : |
|
marker->m_stopPos; |
|
|
|
drawTextOverlay( |
|
marker->m_text, |
|
QColor(255, 255, 255, 192), |
|
m_textOverlayFont, |
|
txtpos * m_histogramRect.width(), |
|
0, |
|
marker->m_startPos < 0.5f, |
|
true, |
|
m_histogramRect); |
|
} |
|
} |
|
} |
|
|
|
// Find and display peaks |
|
void GLSpectrumView::measurePeaks(const Real *spectrum) |
|
{ |
|
// Rebuilt each pass rather than added to, so the report never carries stale peaks |
|
m_measurementResults.m_peaks.clear(); |
|
|
|
// Copy current spectrum so we can modify it |
|
Real *spectrumCopy = new Real[m_nbBins]; |
|
std::copy(spectrum, spectrum + m_nbBins, spectrumCopy); |
|
|
|
for (int i = 0; i < m_measurementPeaks; i++) |
|
{ |
|
// Find peak |
|
int peakBin = findPeakBin(spectrumCopy); |
|
int left, right; |
|
peakWidth(spectrumCopy, peakBin, left, right, 0, m_nbBins); |
|
left++; |
|
right--; |
|
|
|
float power = m_linear ? |
|
spectrumCopy[peakBin] * (m_useCalibration ? m_calibrationGain : 1.0f) : |
|
spectrumCopy[peakBin] + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
int64_t frequency = binToFrequency(peakBin); |
|
|
|
// Add to table |
|
if (m_measurements) { |
|
m_measurements->setPeak(i, frequency, power); |
|
} |
|
|
|
m_measurementResults.m_peaks.append(SpectrumMeasurementResults::Peak(frequency, power)); |
|
|
|
if (m_measurementHighlight) |
|
{ |
|
float x = peakBin / (float)m_nbBins; |
|
float y = (m_powerScale.getRangeMax() - power) / m_powerScale.getRange(); |
|
|
|
QString text = QString::number(i + 1); |
|
|
|
drawTextOverlayCentered( |
|
text, |
|
QColor(255, 255, 255), |
|
m_textOverlayFont, |
|
x * m_histogramRect.width(), |
|
y * m_histogramRect.height(), |
|
m_histogramRect); |
|
} |
|
|
|
// Remove peak from spectrum so not found on next pass |
|
for (int j = left; j <= right; j++) { |
|
spectrumCopy[j] = -std::numeric_limits<float>::max(); |
|
} |
|
} |
|
|
|
delete[] spectrumCopy; |
|
} |
|
|
|
// Calculate and display channel power |
|
void GLSpectrumView::measureChannelPower(const Real *spectrum, bool updateGUI) |
|
{ |
|
float power; |
|
qint64 centerFrequency = getDisplayedCenterFrequency(); |
|
|
|
power = calcChannelPower(spectrum, centerFrequency + m_measurementCenterFrequencyOffset, m_measurementBandwidth); |
|
m_measurementResults.m_channelPower = power; |
|
|
|
if (m_measurements) { |
|
m_measurements->setChannelPower(power, updateGUI); |
|
} |
|
if (m_measurementHighlight && updateGUI) { |
|
drawBandwidthMarkers(centerFrequency + m_measurementCenterFrequencyOffset, m_measurementBandwidth, m_measurementLightMarkerColor); |
|
} |
|
} |
|
|
|
// Calculate and display channel power and adjacent channel power |
|
void GLSpectrumView::measureAdjacentChannelPower(const Real *spectrum, bool updateGUI) |
|
{ |
|
float power, powerLeft, powerRight; |
|
qint64 centerFrequency = getDisplayedCenterFrequency(); |
|
|
|
power = calcChannelPower(spectrum, centerFrequency + m_measurementCenterFrequencyOffset, m_measurementBandwidth); |
|
powerLeft = calcChannelPower(spectrum, centerFrequency + m_measurementCenterFrequencyOffset - m_measurementChSpacing, m_measurementAdjChBandwidth); |
|
powerRight = calcChannelPower(spectrum, centerFrequency + m_measurementCenterFrequencyOffset + m_measurementChSpacing, m_measurementAdjChBandwidth); |
|
|
|
float leftDiff = powerLeft - power; |
|
float rightDiff = powerRight - power; |
|
|
|
m_measurementResults.m_adjChannelPowerLeft = powerLeft; |
|
m_measurementResults.m_adjChannelPowerLeftACPR = leftDiff; |
|
m_measurementResults.m_adjChannelPowerCentre = power; |
|
m_measurementResults.m_adjChannelPowerRight = powerRight; |
|
m_measurementResults.m_adjChannelPowerRightACPR = rightDiff; |
|
|
|
if (m_measurements) { |
|
m_measurements->setAdjacentChannelPower(powerLeft, leftDiff, power, powerRight, rightDiff, updateGUI); |
|
} |
|
if (m_measurementHighlight && updateGUI) |
|
{ |
|
drawBandwidthMarkers(centerFrequency + m_measurementCenterFrequencyOffset, m_measurementBandwidth, m_measurementLightMarkerColor); |
|
drawBandwidthMarkers(centerFrequency + m_measurementCenterFrequencyOffset - m_measurementChSpacing, m_measurementAdjChBandwidth, m_measurementDarkMarkerColor); |
|
drawBandwidthMarkers(centerFrequency + m_measurementCenterFrequencyOffset + m_measurementChSpacing, m_measurementAdjChBandwidth, m_measurementDarkMarkerColor); |
|
} |
|
} |
|
|
|
// Measure bandwidth that has 99% of power |
|
void GLSpectrumView::measureOccupiedBandwidth(const Real *spectrum, bool updateGUI) |
|
{ |
|
float hzPerBin = getDisplayedSampleRate() / (float) m_fftSize; |
|
qint64 centerFrequency = getDisplayedCenterFrequency(); |
|
int start = frequencyToBin(centerFrequency + m_measurementCenterFrequencyOffset); |
|
float totalPower, power = 0.0f; |
|
int step = 0; |
|
int width = 0; |
|
int idx = start; |
|
float gain = m_useCalibration ? m_calibrationGain : 1.0f; |
|
float shift = m_useCalibration ? m_calibrationShiftdB : 0.0f; |
|
|
|
totalPower = CalcDb::powerFromdB(calcChannelPower(spectrum, centerFrequency + m_measurementCenterFrequencyOffset, m_measurementBandwidth)); |
|
do |
|
{ |
|
if ((idx >= 0) && (idx < m_nbBins)) |
|
{ |
|
if (m_linear) { |
|
power += spectrum[idx] * gain; |
|
} else { |
|
power += CalcDb::powerFromdB(spectrum[idx]) + shift; |
|
} |
|
width++; |
|
} |
|
|
|
step++; |
|
if ((step & 1) == 1) { |
|
idx -= step; |
|
} else { |
|
idx += step; |
|
} |
|
} |
|
while (((power / totalPower) < 0.99f) && (step < m_nbBins)); |
|
|
|
float occupiedBandwidth = width * hzPerBin; |
|
m_measurementResults.m_occupiedBandwidth = occupiedBandwidth; |
|
|
|
if (m_measurements) { |
|
m_measurements->setOccupiedBandwidth(occupiedBandwidth, updateGUI); |
|
} |
|
if (m_measurementHighlight && updateGUI) |
|
{ |
|
qint64 centerFrequency = getDisplayedCenterFrequency(); |
|
drawBandwidthMarkers(centerFrequency + m_measurementCenterFrequencyOffset, m_measurementBandwidth, m_measurementDarkMarkerColor); |
|
drawBandwidthMarkers(centerFrequency + m_measurementCenterFrequencyOffset, occupiedBandwidth, m_measurementLightMarkerColor); |
|
} |
|
} |
|
|
|
// Measure bandwidth -3dB from peak |
|
void GLSpectrumView::measure3dBBandwidth(const Real *spectrum, bool updateGUI) |
|
{ |
|
// Find max peak and it's power in dB |
|
int peakBin = findPeakBin(spectrum); |
|
float peakPower = m_linear ? CalcDb::dbPower(spectrum[peakBin]) : spectrum[peakBin]; |
|
|
|
// Search right until 3dB from peak |
|
int rightBin = peakBin; |
|
for (int i = peakBin + 1; i < m_nbBins; i++) |
|
{ |
|
float power = m_linear ? CalcDb::dbPower(spectrum[i]) : spectrum[i]; |
|
if (peakPower - power > 3.0f) |
|
{ |
|
rightBin = i - 1; |
|
break; |
|
} |
|
} |
|
|
|
// Search left until 3dB from peak |
|
int leftBin = peakBin; |
|
for (int i = peakBin - 1; i >= 0; i--) |
|
{ |
|
float power = m_linear ? CalcDb::dbPower(spectrum[i]) : spectrum[i]; |
|
if (peakPower - power > 3.0f) |
|
{ |
|
leftBin = i + 1; |
|
break; |
|
} |
|
} |
|
|
|
// Calculate bandwidth |
|
int bins = rightBin - leftBin - 1; |
|
bins = std::max(1, bins); |
|
float hzPerBin = getDisplayedSampleRate() / (float) m_fftSize; |
|
float bandwidth = bins * hzPerBin; |
|
int centerBin = leftBin + (rightBin - leftBin) / 2; |
|
float centerFrequency = binToFrequency(centerBin); |
|
|
|
m_measurementResults.m_bandwidth3dB = bandwidth; |
|
|
|
if (m_measurements) { |
|
m_measurements->set3dBBandwidth(bandwidth, updateGUI); |
|
} |
|
if (m_measurementHighlight && updateGUI) { |
|
drawBandwidthMarkers(centerFrequency, bandwidth, m_measurementLightMarkerColor); |
|
} |
|
} |
|
|
|
const QVector4D GLSpectrumView::m_measurementLightMarkerColor = QVector4D(0.6f, 0.6f, 0.6f, 0.2f); |
|
const QVector4D GLSpectrumView::m_measurementDarkMarkerColor = QVector4D(0.6f, 0.6f, 0.6f, 0.15f); |
|
|
|
// Find the width of a peak, by seaching in either direction until |
|
// power is no longer falling |
|
void GLSpectrumView::peakWidth(const Real *spectrum, int center, int &left, int &right, int maxLeft, int maxRight) const |
|
{ |
|
float prevLeft = spectrum[center]; |
|
float prevRight = spectrum[center]; |
|
left = center - 1; |
|
right = center + 1; |
|
// Use <= as SSB spectrums have duplicated values |
|
while ((left > maxLeft) && (spectrum[left] <= prevLeft) && (right < maxRight) && (spectrum[right] <= prevRight)) |
|
{ |
|
prevLeft = spectrum[left]; |
|
left--; |
|
prevRight = spectrum[right]; |
|
right++; |
|
} |
|
} |
|
|
|
int GLSpectrumView::findPeakBin(const Real *spectrum) const |
|
{ |
|
int bin; |
|
float power; |
|
|
|
bin = 0; |
|
power = spectrum[0]; |
|
for (int i = 1; i < m_nbBins; i++) |
|
{ |
|
if (spectrum[i] > power) |
|
{ |
|
power = spectrum[i]; |
|
bin = i; |
|
} |
|
} |
|
return bin; |
|
} |
|
|
|
float GLSpectrumView::calPower(float power) const |
|
{ |
|
if (m_linear) { |
|
return power * (m_useCalibration ? m_calibrationGain : 1.0f); |
|
} else { |
|
return CalcDb::powerFromdB(power) + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
} |
|
} |
|
|
|
int GLSpectrumView::frequencyToBin(int64_t frequency) const |
|
{ |
|
float rbw = (m_ssbSpectrum ? (getDisplayedSampleRate()/2) : getDisplayedSampleRate()) / (float)m_fftSize; |
|
return (frequency - m_frequencyScale.getRangeMin()) / rbw; |
|
} |
|
|
|
int64_t GLSpectrumView::binToFrequency(int bin) const |
|
{ |
|
float rbw = (m_ssbSpectrum ? (getDisplayedSampleRate()/2) : getDisplayedSampleRate()) / (float)m_fftSize; |
|
return m_frequencyScale.getRangeMin() + bin * rbw; |
|
} |
|
|
|
// Find a peak and measure SNR / THD / SINAD |
|
void GLSpectrumView::measureSNR(const Real *spectrum, bool updateGUI) |
|
{ |
|
// Find bin with max peak - that will be our signal |
|
int sig = findPeakBin(spectrum); |
|
int sigLeft, sigRight; |
|
peakWidth(spectrum, sig, sigLeft, sigRight, 0, m_nbBins); |
|
int sigBins = sigRight - sigLeft - 1; |
|
int binsLeft = sig - sigLeft; |
|
int binsRight = sigRight - sig; |
|
|
|
// Highlight the signal |
|
float sigFreq = binToFrequency(sig); |
|
if (m_measurementHighlight && updateGUI) { |
|
drawPeakMarkers(binToFrequency(sigLeft+1), binToFrequency(sigRight-1), m_measurementLightMarkerColor); |
|
} |
|
|
|
// Find the harmonics and highlight them |
|
QList<int> hBinsLeft; |
|
QList<int> hBinsRight; |
|
QList<int> hBinsBins; |
|
for (int h = 2; h < m_measurementHarmonics + 2; h++) |
|
{ |
|
float hFreq = sigFreq * h; |
|
if (hFreq < m_frequencyScale.getRangeMax()) |
|
{ |
|
int hBin = frequencyToBin(hFreq); |
|
// Check if peak is an adjacent bin |
|
if (spectrum[hBin-1] > spectrum[hBin]) { |
|
hBin--; |
|
} else if (spectrum[hBin+1] > spectrum[hBin]) { |
|
hBin++; |
|
} |
|
hFreq = binToFrequency(hBin); |
|
int hLeft, hRight; |
|
peakWidth(spectrum, hBin, hLeft, hRight, hBin - binsLeft, hBin + binsRight); |
|
int hBins = hRight - hLeft - 1; |
|
if (m_measurementHighlight && updateGUI) { |
|
drawPeakMarkers(binToFrequency(hLeft+1), binToFrequency(hRight-1), m_measurementDarkMarkerColor); |
|
} |
|
hBinsLeft.append(hLeft); |
|
hBinsRight.append(hRight); |
|
hBinsBins.append(hBins); |
|
} |
|
} |
|
|
|
// Integrate signal, harmonic and noise power |
|
float sigPower = 0.0f; |
|
float noisePower = 0.0f; |
|
float harmonicPower = 0.0f; |
|
QList<float> noise; |
|
float gain = m_useCalibration ? m_calibrationGain : 1.0f; |
|
float shift = m_useCalibration ? m_calibrationShiftdB : 0.0f; |
|
|
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
float power; |
|
if (m_linear) { |
|
power = spectrum[i] * gain; |
|
} else { |
|
power = CalcDb::powerFromdB(spectrum[i]) + shift; |
|
} |
|
|
|
// Signal power |
|
if ((i > sigLeft) && (i < sigRight)) |
|
{ |
|
sigPower += power; |
|
continue; |
|
} |
|
|
|
// Harmonics |
|
for (int h = 0; h < hBinsLeft.size(); h++) |
|
{ |
|
if ((i > hBinsLeft[h]) && (i < hBinsRight[h])) |
|
{ |
|
harmonicPower += power; |
|
continue; |
|
} |
|
} |
|
|
|
// Noise |
|
noisePower += power; |
|
noise.append(power); |
|
} |
|
|
|
// Calculate median of noise |
|
float noiseMedian = 0.0; |
|
if (noise.size() > 0) |
|
{ |
|
auto m = noise.begin() + noise.size()/2; |
|
std::nth_element(noise.begin(), m, noise.end()); |
|
noiseMedian = noise[noise.size()/2]; |
|
} |
|
|
|
// Assume we have similar noise where the signal and harmonics are |
|
float inBandNoise = noiseMedian * sigBins; |
|
noisePower += inBandNoise; |
|
sigPower -= inBandNoise; |
|
for (auto hBins : hBinsBins) |
|
{ |
|
float hNoise = noiseMedian * hBins; |
|
noisePower += hNoise; |
|
harmonicPower -= hNoise; |
|
} |
|
|
|
if (m_measurements) |
|
{ |
|
// Calculate SNR in dB over full bandwidth |
|
float snr = CalcDb::dbPower(sigPower / noisePower); |
|
|
|
// Calculate SNR, where noise is median of noise summed over signal b/w |
|
float snfr = CalcDb::dbPower(sigPower / inBandNoise); |
|
|
|
// Calculate THD - Total harmonic distortion |
|
float thd = harmonicPower / sigPower; |
|
float thdDB = CalcDb::dbPower(thd); |
|
|
|
// Calculate THD+N - Total harmonic distortion plus noise |
|
float thdpn = CalcDb::dbPower((harmonicPower + noisePower) / sigPower); |
|
|
|
// Calculate SINAD - Signal to noise and distotion ratio (Should be -THD+N) |
|
float sinad = CalcDb::dbPower((sigPower + harmonicPower + noisePower) / (harmonicPower + noisePower)); |
|
|
|
m_measurementResults.m_snr = snr; |
|
m_measurementResults.m_snfr = snfr; |
|
m_measurementResults.m_thd = thdDB; |
|
m_measurementResults.m_thdPlusNoise = thdpn; |
|
m_measurementResults.m_sinad = sinad; |
|
|
|
m_measurements->setSNR(snr, snfr, thdDB, thdpn, sinad, updateGUI); |
|
} |
|
} |
|
|
|
void GLSpectrumView::measureSFDR(const Real *spectrum, bool updateGUI) |
|
{ |
|
// Find first peak which is our signal |
|
int peakBin = findPeakBin(spectrum); |
|
int peakLeft, peakRight; |
|
peakWidth(spectrum, peakBin, peakLeft, peakRight, 0, m_nbBins); |
|
|
|
// Find next largest peak, which is the spur |
|
int nextPeakBin = -1; |
|
float nextPeakPower = -std::numeric_limits<float>::max(); |
|
for (int i = 0; i < m_nbBins; i++) |
|
{ |
|
if ((i < peakLeft) || (i > peakRight)) |
|
{ |
|
if (spectrum[i] > nextPeakPower) |
|
{ |
|
nextPeakBin = i; |
|
nextPeakPower = spectrum[i]; |
|
} |
|
} |
|
} |
|
if (nextPeakBin != -1) |
|
{ |
|
// Calculate SFDR in dB from difference between two peaks |
|
float peakPower = calPower(spectrum[peakBin]); |
|
float nextPeakPower = calPower(spectrum[nextPeakBin]); |
|
float peakPowerDB = CalcDb::dbPower(peakPower); |
|
float nextPeakPowerDB = CalcDb::dbPower(nextPeakPower); |
|
float sfdr = peakPowerDB - nextPeakPowerDB; |
|
|
|
m_measurementResults.m_sfdr = sfdr; |
|
|
|
// Display |
|
if (m_measurements) { |
|
m_measurements->setSFDR(sfdr, updateGUI); |
|
} |
|
if (m_measurementHighlight && updateGUI) |
|
{ |
|
if (m_linear) { |
|
drawPowerBandMarkers(peakPower, nextPeakPower, m_measurementDarkMarkerColor); |
|
} else { |
|
drawPowerBandMarkers(peakPowerDB, nextPeakPowerDB, m_measurementDarkMarkerColor); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Find power and frequency of max peak in current spectrum |
|
void GLSpectrumView::findPeak(const Real *spectrum, float &power, float &frequency) const |
|
{ |
|
int bin; |
|
|
|
bin = 0; |
|
power = spectrum[0]; |
|
for (int i = 1; i < m_nbBins; i++) |
|
{ |
|
if (spectrum[i] > power) |
|
{ |
|
power = spectrum[i]; |
|
bin = i; |
|
} |
|
} |
|
|
|
power = m_linear ? |
|
power * (m_useCalibration ? m_calibrationGain : 1.0f) : |
|
power + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
frequency = binToFrequency(bin); |
|
} |
|
|
|
// Calculate channel power in dB |
|
float GLSpectrumView::calcChannelPower(const Real *spectrum, int64_t centerFrequency, int channelBandwidth) const |
|
{ |
|
float hzPerBin = getDisplayedSampleRate() / (float) m_fftSize; |
|
int bins = channelBandwidth / hzPerBin; |
|
int start = frequencyToBin(centerFrequency) - (bins / 2); |
|
int end = start + bins; |
|
float power = 0.0; |
|
|
|
start = std::max(start, 0); |
|
end = std::min(end, m_nbBins); |
|
|
|
if (m_linear) |
|
{ |
|
float gain = m_useCalibration ? m_calibrationGain : 1.0f; |
|
for (int i = start; i < end; i++) { |
|
power += spectrum[i] * gain; |
|
} |
|
} |
|
else |
|
{ |
|
float shift = m_useCalibration ? m_calibrationShiftdB : 0.0f; |
|
for (int i = start; i < end; i++) { |
|
power += CalcDb::powerFromdB(spectrum[i]) + shift; |
|
} |
|
} |
|
|
|
return CalcDb::dbPower(power); |
|
} |
|
|
|
// Test if current spectrum exceeds any of the masks held in spectrum memories |
|
void GLSpectrumView::measureMask(const Real *spectrum, int fftSize, bool updateGUI) |
|
{ |
|
if (!updateGUI) |
|
{ |
|
for (int m = 0; m < m_spectrumMemory.size(); m++) |
|
{ |
|
if ((m_measurementMemMasks & (1 << m)) != 0) |
|
{ |
|
if (m_maskFails[m].size() < (std::size_t) fftSize) { |
|
m_maskFails[m].resize(fftSize); |
|
} |
|
|
|
int s = std::min((int) m_spectrumMemory[m].m_spectrum.size(), fftSize); |
|
bool fail = false; |
|
|
|
for (int i = 0; i < s; i++) |
|
{ |
|
if (spectrum[i] > m_spectrumMemory[m].m_spectrum[i]) |
|
{ |
|
m_maskFails[m][i] = std::max(m_maskFails[m][i], spectrum[i]); |
|
fail = true; |
|
} |
|
} |
|
|
|
m_maskTestCount[m]++; |
|
if (fail) { |
|
m_maskFailCount[m]++; |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
for (int m = 0; m < m_spectrumMemory.size(); m++) |
|
{ |
|
if ((m_measurementMemMasks & (1 << m)) != 0) |
|
{ |
|
if (m_measurements && updateGUI) { |
|
m_measurements->setMaskTestResult(m, m_maskTestCount[m], m_maskFailCount[m]); |
|
} |
|
} |
|
} |
|
|
|
} |
|
} |
|
|
|
void GLSpectrumView::stopDrag() |
|
{ |
|
if (m_cursorState != CSNormal) |
|
{ |
|
if ((m_cursorState == CSSplitterMoving) || (m_cursorState == CSChannelMoving)) { |
|
releaseMouse(); |
|
} |
|
|
|
setCursor(Qt::ArrowCursor); |
|
m_cursorState = CSNormal; |
|
} |
|
} |
|
|
|
// Get text to display on waterfall vertical axis when displaying system time |
|
// value is [0,m_waterfallHeight], as set in setTimeScaleRange() |
|
QString GLSpectrumView::formatTick(double value) const |
|
{ |
|
int idx = value - scrollBarValue() + m_spectrumBuffer.size() - 1 - m_waterfallHeight; |
|
|
|
if ((idx >= 0) && (idx < (int) m_spectrumBuffer.size())) |
|
{ |
|
QDateTime dt = m_spectrumBuffer[idx].m_dateTime; |
|
|
|
if (m_waterfallTimeUnits == SpectrumSettings::LocalTime) { |
|
dt = dt.toLocalTime(); |
|
} else { |
|
dt = dt.toUTC(); |
|
} |
|
return dt.toString(m_waterfallTimeFormat); |
|
} |
|
else |
|
{ |
|
return ""; |
|
} |
|
} |
|
|
|
void GLSpectrumView::setTimeScaleRange() |
|
{ |
|
if (m_waterfallTimeUnits != SpectrumSettings::TimeOffset) |
|
{ |
|
// System clock times from when spectrum was captured - mapped to actual times in formatTick() |
|
if (m_invertedWaterfall) { |
|
m_timeScale.setRange(Unit::None, m_waterfallHeight, 0); |
|
} else { |
|
m_timeScale.setRange(Unit::None, 0, m_waterfallHeight); |
|
} |
|
} |
|
else if (getDisplayedSampleRate() > 0) |
|
{ |
|
float timeScaleDiv = ((float)getDisplayedSampleRate() / (float)m_timingRate); |
|
|
|
if (m_fftSize > m_fftOverlap) { |
|
timeScaleDiv *= m_fftSize / (float)(m_fftSize - m_fftOverlap); |
|
} |
|
|
|
int idx = scrollBarValue(); |
|
float timeMin = (idx * m_fftSize) / timeScaleDiv; |
|
float timeMax = ((idx + m_waterfallHeight) * m_fftSize) / timeScaleDiv; |
|
|
|
if (!m_invertedWaterfall) { |
|
m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, timeMax / timeScaleDiv, timeMin); |
|
} else { |
|
m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, timeMin, timeMax); |
|
} |
|
} |
|
else |
|
{ |
|
if (!m_invertedWaterfall) { |
|
m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, 0, 1); |
|
} else { |
|
m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, 1, 0); |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::paintLeftScales() |
|
{ |
|
QFontMetrics fm(font()); |
|
int M = fm.horizontalAdvance("-"); |
|
|
|
float maxSize = 0.0f; |
|
|
|
m_leftMarginPixmap = QPixmap(m_leftMargin - 1, height()); |
|
m_leftMarginPixmap.fill(Qt::transparent); |
|
{ |
|
QPainter painter(&m_leftMarginPixmap); |
|
painter.setPen(QColor(0xf0, 0xf0, 0xff)); |
|
painter.setFont(font()); |
|
const ScaleEngine::TickList* tickList; |
|
const ScaleEngine::Tick* tick; |
|
if (m_displayWaterfall) { |
|
tickList = &m_timeScale.getTickList(); |
|
for (int i = 0; i < tickList->count(); i++) { |
|
tick = &(*tickList)[i]; |
|
if (tick->major) |
|
{ |
|
if (tick->textSize > 0) |
|
painter.drawText(QPointF(m_leftMargin - M - tick->textSize, m_waterfallTop + fm.ascent() + tick->textPos), tick->text); |
|
maxSize = std::max(maxSize, tick->textSize); |
|
} |
|
} |
|
} |
|
if (m_displayHistogram || m_displayMaxHold || m_displayCurrent) { |
|
tickList = &m_powerScale.getTickList(); |
|
for (int i = 0; i < tickList->count(); i++) { |
|
tick = &(*tickList)[i]; |
|
if (tick->major) { |
|
if (tick->textSize > 0) |
|
painter.drawText(QPointF(m_leftMargin - M - tick->textSize, m_histogramTop + m_histogramHeight - tick->textPos - 1), tick->text); |
|
maxSize = std::max(maxSize, tick->textSize); |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (maxSize >= m_leftMargin) { |
|
m_changesPending = true; // Recalculate margin |
|
} |
|
} |
|
|
|
void GLSpectrumView::applyChanges() |
|
{ |
|
if (m_nbBins <= 0) { |
|
return; |
|
} |
|
|
|
qint64 centerFrequency = getDisplayedCenterFrequency(); |
|
|
|
QFontMetrics fm(font()); |
|
int M = fm.horizontalAdvance("-"); |
|
|
|
m_topMargin = fm.ascent() * 2; |
|
m_bottomMargin = fm.ascent() * 1; |
|
m_infoHeight = fm.height() * 3; |
|
|
|
m_waterfallTop = 0; |
|
m_frequencyScaleHeight = fm.height() * 3; // +1 line for marker frequency scale |
|
int frequencyScaleTop = 0; |
|
m_histogramTop = 0; |
|
//int m_leftMargin; |
|
m_rightMargin = fm.horizontalAdvance("000"); |
|
|
|
// displays both histogram and waterfall |
|
if ((m_displayWaterfall || m_display3DSpectrogram) && (m_displayHistogram || m_displayMaxHold || m_displayCurrent)) |
|
{ |
|
m_waterfallHeight = height() * m_waterfallShare - 1; |
|
|
|
if (m_waterfallHeight < 0) { |
|
m_waterfallHeight = 0; |
|
} |
|
|
|
if (m_invertedWaterfall) |
|
{ |
|
m_histogramTop = m_topMargin; |
|
m_histogramHeight = height() - m_topMargin - m_waterfallHeight - m_frequencyScaleHeight - m_bottomMargin; |
|
m_waterfallTop = m_histogramTop + m_histogramHeight + m_frequencyScaleHeight + 1; |
|
frequencyScaleTop = m_histogramTop + m_histogramHeight + 1; |
|
} |
|
else |
|
{ |
|
m_waterfallTop = m_topMargin; |
|
frequencyScaleTop = m_waterfallTop + m_waterfallHeight + 1; |
|
m_histogramTop = m_waterfallTop + m_waterfallHeight + m_frequencyScaleHeight + 1; |
|
m_histogramHeight = height() - m_topMargin - m_waterfallHeight - m_frequencyScaleHeight - m_bottomMargin; |
|
} |
|
|
|
m_timeScale.setSize(m_waterfallHeight); |
|
setTimeScaleRange(); |
|
|
|
m_leftMargin = m_timeScale.getScaleWidth(); |
|
|
|
setPowerScale(m_histogramHeight); |
|
|
|
m_leftMargin += 2 * M; |
|
|
|
setFrequencyScale(); |
|
|
|
m_glWaterfallBoxMatrix.setToIdentity(); |
|
m_glWaterfallBoxMatrix.translate( |
|
-1.0f + ((float)(2*m_leftMargin) / (float) width()), |
|
1.0f - ((float)(2*m_waterfallTop) / (float) height()) |
|
); |
|
m_glWaterfallBoxMatrix.scale( |
|
((float) 2 * (width() - m_leftMargin - m_rightMargin)) / (float) width(), |
|
(float) (-2*m_waterfallHeight) / (float) height() |
|
); |
|
|
|
m_glHistogramBoxMatrix.setToIdentity(); |
|
m_glHistogramBoxMatrix.translate( |
|
-1.0f + ((float)(2*m_leftMargin) / (float) width()), |
|
1.0f - ((float)(2*m_histogramTop) / (float) height()) |
|
); |
|
m_glHistogramBoxMatrix.scale( |
|
((float) 2 * (width() - m_leftMargin - m_rightMargin)) / (float) width(), |
|
(float) (-2*m_histogramHeight) / (float) height() |
|
); |
|
|
|
m_glHistogramSpectrumMatrix.setToIdentity(); |
|
m_glHistogramSpectrumMatrix.translate( |
|
-1.0f + ((float)(2*m_leftMargin) / (float) width()), |
|
1.0f - ((float)(2*m_histogramTop) / (float) height()) |
|
); |
|
m_glHistogramSpectrumMatrix.scale( |
|
((float) 2 * (width() - m_leftMargin - m_rightMargin)) / ((float) width() * (float)(m_nbBins)), |
|
((float) 2*m_histogramHeight / height()) / m_powerRange |
|
); |
|
|
|
// m_frequencyScaleRect = QRect( |
|
// 0, |
|
// frequencyScaleTop, |
|
// width(), |
|
// m_frequencyScaleHeight |
|
// ); |
|
|
|
m_glFrequencyScaleBoxMatrix.setToIdentity(); |
|
m_glFrequencyScaleBoxMatrix.translate ( |
|
-1.0f, |
|
1.0f - ((float) 2*frequencyScaleTop / (float) height()) |
|
); |
|
m_glFrequencyScaleBoxMatrix.scale ( |
|
2.0f, |
|
(float) -2*m_frequencyScaleHeight / (float) height() |
|
); |
|
|
|
m_glLeftScaleBoxMatrix.setToIdentity(); |
|
m_glLeftScaleBoxMatrix.translate(-1.0f, 1.0f); |
|
m_glLeftScaleBoxMatrix.scale( |
|
(float)(2*(m_leftMargin - 1)) / (float) width(), |
|
-2.0f |
|
); |
|
} |
|
// displays waterfall/3D spectrogram only |
|
else if (m_displayWaterfall || m_display3DSpectrogram) |
|
{ |
|
m_histogramHeight = 0; |
|
m_histogramTop = 0; |
|
m_bottomMargin = m_frequencyScaleHeight; |
|
m_waterfallHeight = height() - m_topMargin - m_frequencyScaleHeight; |
|
m_waterfallTop = m_topMargin; |
|
frequencyScaleTop = m_topMargin + m_waterfallHeight + 1; |
|
|
|
m_timeScale.setSize(m_waterfallHeight); |
|
setTimeScaleRange(); |
|
|
|
m_leftMargin = m_timeScale.getScaleWidth(); |
|
|
|
setPowerScale((height() - m_topMargin - m_bottomMargin) / 2.0); |
|
|
|
m_leftMargin += 2 * M; |
|
|
|
setFrequencyScale(); |
|
|
|
m_glWaterfallBoxMatrix.setToIdentity(); |
|
m_glWaterfallBoxMatrix.translate( |
|
-1.0f + ((float)(2*m_leftMargin) / (float) width()), |
|
1.0f - ((float)(2*m_topMargin) / (float) height()) |
|
); |
|
m_glWaterfallBoxMatrix.scale( |
|
((float) 2 * (width() - m_leftMargin - m_rightMargin)) / (float) width(), |
|
(float) (-2*m_waterfallHeight) / (float) height() |
|
); |
|
|
|
// m_frequencyScaleRect = QRect( |
|
// 0, |
|
// frequencyScaleTop, |
|
// width(), |
|
// m_frequencyScaleHeight |
|
// ); |
|
|
|
m_glFrequencyScaleBoxMatrix.setToIdentity(); |
|
m_glFrequencyScaleBoxMatrix.translate ( |
|
-1.0f, |
|
1.0f - ((float) 2*frequencyScaleTop / (float) height()) |
|
); |
|
m_glFrequencyScaleBoxMatrix.scale ( |
|
2.0f, |
|
(float) -2*m_frequencyScaleHeight / (float) height() |
|
); |
|
|
|
m_glLeftScaleBoxMatrix.setToIdentity(); |
|
m_glLeftScaleBoxMatrix.translate(-1.0f, 1.0f); |
|
m_glLeftScaleBoxMatrix.scale( |
|
(float)(2*(m_leftMargin - 1)) / (float) width(), |
|
-2.0f |
|
); |
|
} |
|
// displays histogram only |
|
else if (m_displayHistogram || m_displayMaxHold || m_displayCurrent) |
|
{ |
|
m_bottomMargin = m_frequencyScaleHeight; |
|
frequencyScaleTop = height() - m_bottomMargin; |
|
m_histogramTop = m_topMargin - 1; |
|
m_waterfallHeight = 0; |
|
m_histogramHeight = height() - m_topMargin - m_frequencyScaleHeight; |
|
|
|
m_leftMargin = 0; |
|
|
|
setPowerScale(m_histogramHeight); |
|
|
|
m_leftMargin += 2 * M; |
|
|
|
setFrequencyScale(); |
|
|
|
m_glHistogramSpectrumMatrix.setToIdentity(); |
|
m_glHistogramSpectrumMatrix.translate( |
|
-1.0f + ((float)(2*m_leftMargin) / (float) width()), |
|
1.0f - ((float)(2*m_histogramTop) / (float) height()) |
|
); |
|
m_glHistogramSpectrumMatrix.scale( |
|
((float) 2 * (width() - m_leftMargin - m_rightMargin)) / ((float) width() * (float)(m_nbBins)), |
|
((float) 2*(height() - m_topMargin - m_frequencyScaleHeight)) / (height()*m_powerRange) |
|
); |
|
|
|
m_glHistogramBoxMatrix.setToIdentity(); |
|
m_glHistogramBoxMatrix.translate( |
|
-1.0f + ((float)(2*m_leftMargin) / (float) width()), |
|
1.0f - ((float)(2*m_histogramTop) / (float) height()) |
|
); |
|
m_glHistogramBoxMatrix.scale( |
|
((float) 2 * (width() - m_leftMargin - m_rightMargin)) / (float) width(), |
|
(float) (-2*(height() - m_topMargin - m_frequencyScaleHeight)) / (float) height() |
|
); |
|
|
|
// m_frequencyScaleRect = QRect( |
|
// 0, |
|
// frequencyScaleTop, |
|
// width(), |
|
// m_frequencyScaleHeight |
|
// ); |
|
|
|
m_glFrequencyScaleBoxMatrix.setToIdentity(); |
|
m_glFrequencyScaleBoxMatrix.translate ( |
|
-1.0f, |
|
1.0f - ((float) 2*frequencyScaleTop / (float) height()) |
|
); |
|
m_glFrequencyScaleBoxMatrix.scale ( |
|
2.0f, |
|
(float) -2*m_frequencyScaleHeight / (float) height() |
|
); |
|
|
|
m_glLeftScaleBoxMatrix.setToIdentity(); |
|
m_glLeftScaleBoxMatrix.translate(-1.0f, 1.0f); |
|
m_glLeftScaleBoxMatrix.scale( |
|
(float)(2*(m_leftMargin - 1)) / (float) width(), |
|
-2.0f |
|
); |
|
} |
|
else |
|
{ |
|
m_leftMargin = 2; |
|
m_waterfallHeight = 0; |
|
} |
|
|
|
m_glShaderSpectrogram.setScaleX(((width() - m_leftMargin - m_rightMargin) / (float)m_waterfallHeight)); |
|
m_glShaderSpectrogram.setScaleZ((m_histogramHeight != 0 ? m_histogramHeight : m_waterfallHeight / 4) / (float)(width() - m_leftMargin - m_rightMargin)); |
|
|
|
// bounding boxes |
|
m_frequencyScaleRect = QRect( |
|
0, |
|
frequencyScaleTop, |
|
width(), |
|
m_frequencyScaleHeight |
|
); |
|
|
|
if ((m_invertedWaterfall) || (m_waterfallHeight == 0)) |
|
{ |
|
m_histogramRect = QRectF( |
|
(float) m_leftMargin / (float) width(), |
|
(float) m_topMargin / (float) height(), |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) (m_histogramHeight) / (float) height() |
|
); |
|
} |
|
else |
|
{ |
|
m_histogramRect = QRectF( |
|
(float) m_leftMargin / (float) width(), |
|
(float) (m_waterfallTop + m_waterfallHeight + m_frequencyScaleHeight) / (float) height(), |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_histogramHeight / (float) height() |
|
); |
|
} |
|
|
|
if (!m_invertedWaterfall || (m_histogramHeight == 0)) |
|
{ |
|
m_waterfallRect = QRectF( |
|
(float) m_leftMargin / (float) width(), |
|
(float) m_topMargin / (float) height(), |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_waterfallHeight / (float) height() |
|
); |
|
} |
|
else |
|
{ |
|
m_waterfallRect = QRectF( |
|
(float) m_leftMargin / (float) width(), |
|
(float) (m_topMargin + m_histogramHeight + m_frequencyScaleHeight) / (float) height(), |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) (m_waterfallHeight) / (float) height() |
|
); |
|
} |
|
|
|
m_glShaderSpectrogram.setAspectRatio((width() - m_leftMargin - m_rightMargin) / (float)m_waterfallHeight); |
|
|
|
m_3DSpectrogramBottom = m_bottomMargin; |
|
if (!m_invertedWaterfall) { |
|
m_3DSpectrogramBottom += m_histogramHeight + m_frequencyScaleHeight + 1; |
|
} |
|
|
|
// channel overlays |
|
int64_t centerFrequencyUnused; |
|
int frequencySpan; |
|
getFrequencyZoom(centerFrequencyUnused, frequencySpan); |
|
|
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
ChannelMarkerState* dv = m_channelMarkerStates[i]; |
|
|
|
qreal xc, pw, nw, dsbw; |
|
ChannelMarker::sidebands_t sidebands = dv->m_channelMarker->getSidebands(); |
|
xc = centerFrequency + dv->m_channelMarker->getCenterFrequency(); // marker center frequency |
|
dsbw = dv->m_channelMarker->getBandwidth(); |
|
|
|
if (sidebands == ChannelMarker::usb) |
|
{ |
|
nw = dv->m_channelMarker->getLowCutoff() + dv->m_channelMarker->getShift(); // negative bandwidth |
|
int bw = dv->m_channelMarker->getBandwidth() / 2; |
|
pw = (qreal) bw + dv->m_channelMarker->getShift(); // positive bandwidth |
|
} |
|
else if (sidebands == ChannelMarker::lsb) |
|
{ |
|
pw = dv->m_channelMarker->getLowCutoff() + dv->m_channelMarker->getShift(); |
|
int bw = dv->m_channelMarker->getBandwidth() / 2; |
|
nw = (qreal) bw + dv->m_channelMarker->getShift(); |
|
} |
|
else if (sidebands == ChannelMarker::vusb) |
|
{ |
|
nw = -dv->m_channelMarker->getOppositeBandwidth() + dv->m_channelMarker->getShift(); // negative bandwidth |
|
pw = dv->m_channelMarker->getBandwidth() + dv->m_channelMarker->getShift(); // positive bandwidth |
|
} |
|
else if (sidebands == ChannelMarker::vlsb) { |
|
pw = dv->m_channelMarker->getOppositeBandwidth() + dv->m_channelMarker->getShift(); // positive bandwidth |
|
nw = -dv->m_channelMarker->getBandwidth() + dv->m_channelMarker->getShift(); // negative bandwidth |
|
} |
|
else |
|
{ |
|
pw = (dsbw / 2) + dv->m_channelMarker->getShift(); |
|
nw = -(dsbw / 2) + dv->m_channelMarker->getShift(); |
|
} |
|
|
|
// draw the DSB rectangle |
|
|
|
QMatrix4x4 glMatrixDsb; |
|
glMatrixDsb.setToIdentity(); |
|
glMatrixDsb.translate( |
|
-1.0f + 2.0f * ((m_leftMargin + m_frequencyScale.getPosFromValue(xc - (dsbw/2))) / (float) width()), |
|
1.0f |
|
); |
|
glMatrixDsb.scale( |
|
2.0f * (dsbw / (float) frequencySpan), |
|
-2.0f |
|
); |
|
|
|
dv->m_glMatrixDsbWaterfall = glMatrixDsb; |
|
dv->m_glMatrixDsbWaterfall.translate( |
|
0.0f, |
|
(float) m_waterfallTop / (float) height() |
|
); |
|
dv->m_glMatrixDsbWaterfall.scale( |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_waterfallHeight / (float) height() |
|
); |
|
|
|
dv->m_glMatrixDsbHistogram = glMatrixDsb; |
|
dv->m_glMatrixDsbHistogram.translate( |
|
0.0f, |
|
(float) m_histogramTop / (float) height() |
|
); |
|
dv->m_glMatrixDsbHistogram.scale( |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_histogramHeight / (float) height() |
|
); |
|
|
|
dv->m_glMatrixDsbFreqScale = glMatrixDsb; |
|
dv->m_glMatrixDsbFreqScale.translate( |
|
0.0f, |
|
(float) frequencyScaleTop / (float) height() |
|
); |
|
dv->m_glMatrixDsbFreqScale.scale( |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_frequencyScaleHeight / (float) height() |
|
); |
|
|
|
// draw the effective BW rectangle |
|
|
|
QMatrix4x4 glMatrix; |
|
glMatrix.setToIdentity(); |
|
glMatrix.translate( |
|
-1.0f + 2.0f * ((m_leftMargin + m_frequencyScale.getPosFromValue(xc + nw)) / (float) width()), |
|
1.0f |
|
); |
|
glMatrix.scale( |
|
2.0f * ((pw-nw) / (float) frequencySpan), |
|
-2.0f |
|
); |
|
|
|
dv->m_glMatrixWaterfall = glMatrix; |
|
dv->m_glMatrixWaterfall.translate( |
|
0.0f, |
|
(float) m_waterfallTop / (float) height() |
|
); |
|
dv->m_glMatrixWaterfall.scale( |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_waterfallHeight / (float) height() |
|
); |
|
|
|
dv->m_glMatrixHistogram = glMatrix; |
|
dv->m_glMatrixHistogram.translate( |
|
0.0f, |
|
(float) m_histogramTop / (float) height() |
|
); |
|
dv->m_glMatrixHistogram.scale( |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_histogramHeight / (float) height() |
|
); |
|
|
|
dv->m_glMatrixFreqScale = glMatrix; |
|
dv->m_glMatrixFreqScale.translate( |
|
0.0f, |
|
(float) frequencyScaleTop / (float) height() |
|
); |
|
dv->m_glMatrixFreqScale.scale( |
|
(float) (width() - m_leftMargin - m_rightMargin) / (float) width(), |
|
(float) m_frequencyScaleHeight / (float) height() |
|
); |
|
|
|
|
|
/* |
|
dv->m_glRect.setRect( |
|
m_frequencyScale.getPosFromValue(centerFrequency + dv->m_channelMarker->getCenterFrequency() - dv->m_channelMarker->getBandwidth() / 2) / (float)(width() - m_leftMargin - m_rightMargin), |
|
0, |
|
(dv->m_channelMarker->getBandwidth() / (float)getDisplayedSampleRate()), |
|
1); |
|
*/ |
|
|
|
if (m_displayHistogram || m_displayMaxHold || m_displayCurrent || m_displayWaterfall) |
|
{ |
|
dv->m_rect.setRect(m_frequencyScale.getPosFromValue(xc) + m_leftMargin - 1, |
|
m_topMargin, |
|
5, |
|
height() - m_topMargin - m_bottomMargin); |
|
} |
|
|
|
/* |
|
if(m_displayHistogram || m_displayMaxHold || m_displayWaterfall) { |
|
dv->m_rect.setRect(m_frequencyScale.getPosFromValue(centerFrequency + dv->m_channelMarker->getCenterFrequency()) + m_leftMargin - 1, |
|
m_topMargin, |
|
5, |
|
height() - m_topMargin - m_bottomMargin); |
|
} |
|
*/ |
|
} |
|
|
|
// prepare left scales (time and power) |
|
paintLeftScales(); |
|
m_glShaderLeftScale.initTexture(m_leftMarginPixmap.toImage()); |
|
|
|
// prepare frequency scale |
|
if (m_displayWaterfall || m_display3DSpectrogram || m_displayHistogram || m_displayMaxHold || m_displayCurrent) { |
|
m_frequencyPixmap = QPixmap(width(), m_frequencyScaleHeight); |
|
m_frequencyPixmap.fill(Qt::transparent); |
|
{ |
|
QPainter painter(&m_frequencyPixmap); |
|
painter.setPen(Qt::NoPen); |
|
painter.setBrush(Qt::black); |
|
painter.setBrush(Qt::transparent); |
|
painter.drawRect(m_leftMargin, 0, width() - m_leftMargin, m_frequencyScaleHeight); |
|
painter.setPen(QColor(0xf0, 0xf0, 0xff)); |
|
painter.setFont(font()); |
|
const ScaleEngine::TickList* tickList = &m_frequencyScale.getTickList(); |
|
const ScaleEngine::Tick* tick; |
|
|
|
for (int i = 0; i < tickList->count(); i++) { |
|
tick = &(*tickList)[i]; |
|
if (tick->major) { |
|
if (tick->textSize > 0) |
|
painter.drawText(QPointF(m_leftMargin + tick->textPos, fm.height() + fm.ascent() / 2 - 1), tick->text); |
|
} |
|
} |
|
|
|
// Frequency overlay on highlighted marker |
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
ChannelMarkerState* dv = m_channelMarkerStates[i]; |
|
|
|
if (dv->m_channelMarker->getHighlighted() |
|
&& (dv->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink) |
|
&& dv->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
qreal xc; |
|
int shift; |
|
//ChannelMarker::sidebands_t sidebands = dv->m_channelMarker->getSidebands(); |
|
xc = centerFrequency + dv->m_channelMarker->getCenterFrequency(); // marker center frequency |
|
QString ftext; |
|
switch (dv->m_channelMarker->getFrequencyScaleDisplayType()) |
|
{ |
|
case ChannelMarker::FScaleDisplay_freq: |
|
ftext = QString::number((centerFrequency + dv->m_channelMarker->getCenterFrequency())/1e6, 'f', 6); |
|
break; |
|
case ChannelMarker::FScaleDisplay_title: |
|
ftext = dv->m_channelMarker->getTitle(); |
|
break; |
|
case ChannelMarker::FScaleDisplay_addressSend: |
|
ftext = dv->m_channelMarker->getDisplayAddressSend(); |
|
break; |
|
case ChannelMarker::FScaleDisplay_addressReceive: |
|
ftext = dv->m_channelMarker->getDisplayAddressReceive(); |
|
break; |
|
default: |
|
ftext = QString::number((centerFrequency + dv->m_channelMarker->getCenterFrequency())/1e6, 'f', 6); |
|
break; |
|
} |
|
if (dv->m_channelMarker->getCenterFrequency() < 0) { // left half of scale |
|
ftext = " " + ftext; |
|
shift = 0; |
|
} else { // right half of scale |
|
ftext = ftext + " "; |
|
shift = - fm.horizontalAdvance(ftext); |
|
} |
|
painter.drawText(QPointF(m_leftMargin + m_frequencyScale.getPosFromValue(xc) + shift, 2*fm.height() + fm.ascent() / 2 - 1), ftext); |
|
} |
|
} |
|
|
|
} |
|
|
|
m_glShaderFrequencyScale.initTexture(m_frequencyPixmap.toImage()); |
|
} |
|
// prepare left scale for spectrogram (time) |
|
{ |
|
m_spectrogramTimePixmap = QPixmap(m_leftMargin - 1, fm.ascent() + m_waterfallHeight); |
|
m_spectrogramTimePixmap.fill(Qt::transparent); |
|
{ |
|
QPainter painter(&m_spectrogramTimePixmap); |
|
painter.setPen(QColor(0xf0, 0xf0, 0xff)); |
|
painter.setFont(font()); |
|
const ScaleEngine::TickList* tickList; |
|
const ScaleEngine::Tick* tick; |
|
if (m_display3DSpectrogram) { |
|
tickList = &m_timeScale.getTickList(); |
|
for (int i = 0; i < tickList->count(); i++) { |
|
tick = &(*tickList)[i]; |
|
if (tick->major) { |
|
if (tick->textSize > 0) |
|
painter.drawText(QPointF(m_leftMargin - M - tick->textSize, fm.height() + tick->textPos), tick->text); |
|
} |
|
} |
|
} |
|
} |
|
|
|
m_glShaderSpectrogramTimeScale.initTexture(m_spectrogramTimePixmap.toImage()); |
|
} |
|
// prepare vertical scale for spectrogram (power) |
|
{ |
|
int h = m_histogramHeight != 0 ? m_histogramHeight : m_waterfallHeight / 4; |
|
m_spectrogramPowerPixmap = QPixmap(m_leftMargin - 1, m_topMargin + h); |
|
m_spectrogramPowerPixmap.fill(Qt::transparent); |
|
{ |
|
QPainter painter(&m_spectrogramPowerPixmap); |
|
painter.setPen(QColor(0xf0, 0xf0, 0xff)); |
|
painter.setFont(font()); |
|
const ScaleEngine::TickList* tickList; |
|
const ScaleEngine::Tick* tick; |
|
if (m_display3DSpectrogram) { |
|
tickList = &m_powerScale.getTickList(); |
|
for (int i = 0; i < tickList->count(); i++) { |
|
tick = &(*tickList)[i]; |
|
if (tick->major) { |
|
if (tick->textSize > 0) |
|
painter.drawText(QPointF(m_leftMargin - M - tick->textSize, m_topMargin + h - tick->textPos - 1), tick->text); |
|
} |
|
} |
|
} |
|
} |
|
|
|
m_glShaderSpectrogramPowerScale.initTexture(m_spectrogramPowerPixmap.toImage()); |
|
} |
|
|
|
// Top info line |
|
m_glInfoBoxMatrix.setToIdentity(); |
|
m_glInfoBoxMatrix.translate ( |
|
-1.0f, |
|
1.0f |
|
); |
|
m_glInfoBoxMatrix.scale ( |
|
2.0f, |
|
(float) -2*m_infoHeight / (float) height() |
|
); |
|
m_infoRect = QRect( |
|
0, |
|
0, |
|
width(), |
|
m_infoHeight |
|
); |
|
QString infoText; |
|
formatTextInfo(infoText); |
|
m_infoPixmap = QPixmap(width(), m_infoHeight); |
|
m_infoPixmap.fill(Qt::transparent); |
|
{ |
|
QPainter painter(&m_infoPixmap); |
|
painter.setPen(Qt::NoPen); |
|
painter.setBrush(Qt::black); |
|
painter.setBrush(Qt::transparent); |
|
painter.drawRect(m_leftMargin, 0, width() - m_leftMargin, m_infoHeight); |
|
painter.setPen(QColor(0xf0, 0xf0, 0xff)); |
|
painter.setFont(font()); |
|
painter.drawText(QPointF(m_leftMargin, fm.height() + fm.ascent() / 2 - 2), infoText); |
|
} |
|
m_glShaderInfo.initTexture(m_infoPixmap.toImage()); |
|
|
|
// Peak details in top info line |
|
QString minFrequencyStr = displayFull(centerFrequency - getDisplayedSampleRate()/2); // This can be wider if negative, while max is positive |
|
QString maxFrequencyStr = displayFull(centerFrequency + getDisplayedSampleRate()/2); |
|
m_peakFrequencyMaxStr = minFrequencyStr.size() > maxFrequencyStr.size() ? minFrequencyStr : maxFrequencyStr; |
|
m_peakFrequencyMaxStr = m_peakFrequencyMaxStr.append("Hz"); |
|
m_peakPowerMaxStr = m_linear ? "8.000e-10" : "-100.0"; |
|
m_peakPowerUnits = m_linear ? "" : "dB"; |
|
|
|
m_glShaderSpectrogram.initColorMapTexture(m_colorMapName); |
|
m_glShaderColorMap.initColorMapTexture(m_colorMapName); |
|
m_colorMap = ColorMap::getColorMap(m_colorMapName); |
|
// Why only 240 entries in the palette? |
|
for (int i = 0; i <= 239; i++) |
|
{ |
|
((quint8*)&m_waterfallPalette[i])[0] = (quint8)(m_colorMap[i*3] * 255.0); |
|
((quint8*)&m_waterfallPalette[i])[1] = (quint8)(m_colorMap[i*3+1] * 255.0); |
|
((quint8*)&m_waterfallPalette[i])[2] = (quint8)(m_colorMap[i*3+2] * 255.0); |
|
((quint8*)&m_waterfallPalette[i])[3] = 255; |
|
} |
|
|
|
bool waterfallFFTSizeChanged = true; |
|
|
|
if (m_waterfallBuffer) { |
|
waterfallFFTSizeChanged = m_waterfallBuffer->width() != m_nbBins + 1; |
|
} |
|
|
|
bool windowSizeChanged = m_waterfallTextureHeight != m_waterfallHeight; |
|
|
|
if (waterfallFFTSizeChanged || windowSizeChanged) |
|
{ |
|
if (m_waterfallBuffer) { |
|
delete m_waterfallBuffer; |
|
} |
|
|
|
m_waterfallBuffer = new QImage(m_nbBins + 1, m_waterfallHeight, QImage::Format_ARGB32); |
|
m_waterfallBuffer->fill(qRgb(0x00, 0x00, 0x00)); |
|
|
|
if (m_waterfallHeight > 0) { |
|
m_glShaderWaterfall.initTexture(*m_waterfallBuffer); |
|
} |
|
|
|
m_waterfallBufferPos = 0; |
|
|
|
if (m_3DSpectrogramBuffer) { |
|
delete m_3DSpectrogramBuffer; |
|
} |
|
|
|
m_3DSpectrogramBuffer = new QImage(m_nbBins + 1, m_waterfallHeight, QImage::Format_Grayscale8); |
|
m_3DSpectrogramBuffer->fill(qRgb(0x00, 0x00, 0x00)); |
|
|
|
if (m_waterfallHeight > 0) { |
|
m_glShaderSpectrogram.initTexture(*m_3DSpectrogramBuffer); |
|
} |
|
|
|
m_3DSpectrogramBufferPos = 0; |
|
|
|
m_waterfallTextureHeight = m_waterfallHeight; |
|
m_waterfallTexturePos = 0; |
|
m_3DSpectrogramTextureHeight = m_waterfallHeight; |
|
m_3DSpectrogramTexturePos = 0; |
|
} |
|
|
|
bool histogramFFTSizeChanged = true; |
|
|
|
if (m_histogramBuffer) { |
|
histogramFFTSizeChanged = m_histogramBuffer->width() != m_nbBins; |
|
} |
|
|
|
if (histogramFFTSizeChanged) |
|
{ |
|
if (m_histogramBuffer) { |
|
delete m_histogramBuffer; |
|
} |
|
|
|
m_histogramBuffer = new QImage(m_nbBins, 100, QImage::Format_RGB32); |
|
|
|
m_histogramBuffer->fill(qRgb(0x00, 0x00, 0x00)); |
|
m_glShaderHistogram.initTexture(*m_histogramBuffer, QOpenGLTexture::ClampToEdge); |
|
|
|
if (m_histogram) { |
|
delete[] m_histogram; |
|
} |
|
|
|
m_histogram = new quint8[100 * m_nbBins]; |
|
memset(m_histogram, 0x00, 100 * m_nbBins); |
|
|
|
m_q3FFT.allocate(2*(m_nbBins+1)); |
|
|
|
m_q3ColorMap.allocate(4*(m_nbBins+1)); |
|
std::fill(m_q3ColorMap.m_array, m_q3ColorMap.m_array+4*(m_nbBins+1), 0.0f); |
|
} |
|
|
|
if (m_redrawAll) |
|
{ |
|
redrawSpectrum(); |
|
redrawWaterfallAnd3DSpectrogram(); |
|
m_redrawAll = false; |
|
} |
|
else if (waterfallFFTSizeChanged || windowSizeChanged) |
|
{ |
|
redrawWaterfallAnd3DSpectrogram(); |
|
} |
|
else if (histogramFFTSizeChanged) |
|
{ |
|
redrawSpectrum(); |
|
} |
|
|
|
m_q3TickTime.allocate(4*m_timeScale.getTickList().count()); |
|
m_q3TickFrequency.allocate(4*m_frequencyScale.getTickList().count()); |
|
m_q3TickPower.allocate(6*m_powerScale.getTickList().count()); // 6 as we need 3d points for 3D spectrogram |
|
updateHistogramMarkers(); |
|
updateWaterfallMarkers(); |
|
updateSortedAnnotationMarkers(); |
|
} // applyChanges |
|
|
|
void GLSpectrumView::updateHistogramMarkers() |
|
{ |
|
if (getDisplayedSampleRate() == 0) { |
|
return; |
|
} |
|
int64_t centerFrequency; |
|
int frequencySpan; |
|
getFrequencyZoom(centerFrequency, frequencySpan); |
|
int effFftSize = m_fftSize * ((float) frequencySpan / (float) getDisplayedSampleRate()); |
|
|
|
for (int i = 0; i < m_histogramMarkers.size(); i++) |
|
{ |
|
float powerI = m_linear ? |
|
m_histogramMarkers.at(i).m_power * (m_useCalibration ? m_calibrationGain : 1.0f) : |
|
CalcDb::dbPower(m_histogramMarkers.at(i).m_power) + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
m_histogramMarkers[i].m_point.rx() = |
|
(m_histogramMarkers[i].m_frequency - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
m_histogramMarkers[i].m_point.ry() = |
|
(m_powerScale.getRangeMax() - powerI) / m_powerScale.getRange(); |
|
// m_histogramMarkers[i].m_fftBin = |
|
// (((m_histogramMarkers[i].m_frequency - centerFrequency) / (float) getDisplayedSampleRate()) + 0.5) * m_fftSize; |
|
m_histogramMarkers[i].m_fftBin = |
|
(((m_histogramMarkers[i].m_frequency - centerFrequency) / (float) frequencySpan) + 0.5) * effFftSize; |
|
m_histogramMarkers[i].m_point.rx() = m_histogramMarkers[i].m_point.rx() < 0 ? |
|
0 : m_histogramMarkers[i].m_point.rx() > 1 ? |
|
1 : m_histogramMarkers[i].m_point.rx(); |
|
m_histogramMarkers[i].m_point.ry() = m_histogramMarkers[i].m_point.ry() < 0 ? |
|
0 : m_histogramMarkers[i].m_point.ry() > 1 ? |
|
1 : m_histogramMarkers[i].m_point.ry(); |
|
m_histogramMarkers[i].m_fftBin = m_histogramMarkers[i].m_fftBin < 0 ? |
|
0 : m_histogramMarkers[i].m_fftBin > m_fftSize - 1 ? |
|
m_fftSize - 1 : m_histogramMarkers[i].m_fftBin; |
|
m_histogramMarkers[i].m_frequencyStr = displayScaled( |
|
m_histogramMarkers[i].m_frequency, |
|
'f', |
|
getPrecision((centerFrequency*1000)/getDisplayedSampleRate()), |
|
false); |
|
m_histogramMarkers[i].m_powerStr = displayPower( |
|
powerI, |
|
m_linear ? 'e' : 'f', |
|
m_linear ? 3 : 1); |
|
|
|
if (i > 0) |
|
{ |
|
int64_t deltaFrequency = m_histogramMarkers.at(i).m_frequency - m_histogramMarkers.at(0).m_frequency; |
|
m_histogramMarkers[i].m_deltaFrequencyStr = displayScaled( |
|
deltaFrequency, |
|
'f', |
|
getPrecision(deltaFrequency/getDisplayedSampleRate()), |
|
true); |
|
float power0 = m_linear ? |
|
m_histogramMarkers.at(0).m_power * (m_useCalibration ? m_calibrationGain : 1.0f) : |
|
CalcDb::dbPower(m_histogramMarkers.at(0).m_power) + (m_useCalibration ? m_calibrationShiftdB : 0.0f); |
|
m_histogramMarkers[i].m_deltaPowerStr = displayPower( |
|
powerI - power0, |
|
m_linear ? 'e' : 'f', |
|
m_linear ? 3 : 1); |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateHistogramPeaks() |
|
{ |
|
int j = 0; |
|
for (int i = 0; i < m_histogramMarkers.size(); i++) |
|
{ |
|
if (j >= (int) m_peakFinder.getPeaks().size()) { |
|
break; |
|
} |
|
|
|
int fftBin = m_peakFinder.getPeaks()[j].second; |
|
Real power = m_peakFinder.getPeaks()[j].first; |
|
// qDebug("GLSpectrumView::updateHistogramPeaks: %d %d %f", j, fftBin, power); |
|
|
|
if ((m_histogramMarkers.at(i).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePower) || |
|
((m_histogramMarkers.at(i).m_markerType == SpectrumHistogramMarker::SpectrumMarkerTypePowerMax) && |
|
(m_histogramMarkers.at(i).m_holdReset || (power > m_histogramMarkers.at(i).m_powerMax)))) |
|
{ |
|
float binSize = m_frequencyScale.getRange() / m_nbBins; |
|
m_histogramMarkers[i].m_fftBin = fftBin; |
|
m_histogramMarkers[i].m_frequency = m_frequencyScale.getRangeMin() + binSize*fftBin; |
|
m_histogramMarkers[i].m_point.rx() = binSize*fftBin / m_frequencyScale.getRange(); |
|
|
|
if (i == 0) |
|
{ |
|
m_histogramMarkers[i].m_frequencyStr = displayScaled( |
|
m_histogramMarkers[i].m_frequency, |
|
'f', |
|
getPrecision((getDisplayedCenterFrequency()*1000)/getDisplayedSampleRate()), |
|
false |
|
); |
|
} |
|
else |
|
{ |
|
int64_t deltaFrequency = m_histogramMarkers.at(i).m_frequency - m_histogramMarkers.at(0).m_frequency; |
|
m_histogramMarkers[i].m_deltaFrequencyStr = displayScaled( |
|
deltaFrequency, |
|
'f', |
|
getPrecision(deltaFrequency/getDisplayedSampleRate()), |
|
true |
|
); |
|
} |
|
} |
|
else |
|
{ |
|
continue; |
|
} |
|
|
|
j++; |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateWaterfallMarkers() |
|
{ |
|
for (int i = 0; i < m_waterfallMarkers.size(); i++) |
|
{ |
|
m_waterfallMarkers[i].m_point.rx() = |
|
(m_waterfallMarkers[i].m_frequency - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
m_waterfallMarkers[i].m_point.ry() = |
|
(m_waterfallMarkers[i].m_time - m_timeScale.getRangeMin()) / m_timeScale.getRange(); |
|
m_waterfallMarkers[i].m_point.rx() = m_waterfallMarkers[i].m_point.rx() < 0 ? |
|
0 : m_waterfallMarkers[i].m_point.rx() > 1 ? |
|
1 : m_waterfallMarkers[i].m_point.rx(); |
|
m_waterfallMarkers[i].m_point.ry() = m_waterfallMarkers[i].m_point.ry() < 0 ? |
|
0 : m_waterfallMarkers[i].m_point.ry() > 1 ? |
|
1 : m_waterfallMarkers[i].m_point.ry(); |
|
m_waterfallMarkers[i].m_frequencyStr = displayScaled( |
|
m_waterfallMarkers[i].m_frequency, |
|
'f', |
|
getPrecision((getDisplayedCenterFrequency()*1000)/getDisplayedSampleRate()), |
|
false); |
|
m_waterfallMarkers[i].m_timeStr = displayScaledF( |
|
m_waterfallMarkers[i].m_time, |
|
'f', |
|
3, |
|
true); |
|
|
|
if (i > 0) |
|
{ |
|
int64_t deltaFrequency = m_waterfallMarkers.at(i).m_frequency - m_waterfallMarkers.at(0).m_frequency; |
|
m_waterfallMarkers.back().m_deltaFrequencyStr = displayScaled( |
|
deltaFrequency, |
|
'f', |
|
getPrecision(deltaFrequency/getDisplayedSampleRate()), |
|
true); |
|
m_waterfallMarkers.back().m_deltaTimeStr = displayScaledF( |
|
m_waterfallMarkers.at(i).m_time - m_waterfallMarkers.at(0).m_time, |
|
'f', |
|
3, |
|
true); |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateAnnotationMarkers() |
|
{ |
|
emit updateAnnotations(); // Notify other plugins we have updated annotations |
|
|
|
if (!(m_markersDisplay & SpectrumSettings::MarkersDisplayAnnotations)) { |
|
return; |
|
} |
|
|
|
m_sortedAnnotationMarkers.clear(); |
|
|
|
for (auto &marker : m_annotationMarkers) { |
|
m_sortedAnnotationMarkers.push_back(&marker); |
|
} |
|
|
|
std::sort(m_sortedAnnotationMarkers.begin(), m_sortedAnnotationMarkers.end(), annotationDisplayLessThan); |
|
updateSortedAnnotationMarkers(); |
|
} |
|
|
|
void GLSpectrumView::updateSortedAnnotationMarkers() |
|
{ |
|
if (!(m_markersDisplay & SpectrumSettings::MarkersDisplayAnnotations)) { |
|
return; |
|
} |
|
|
|
m_visibleAnnotationMarkers.clear(); |
|
|
|
for (auto &marker : m_sortedAnnotationMarkers) |
|
{ |
|
float startPos = (marker->m_startFrequency - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
float stopPos = ((marker->m_startFrequency + marker->m_bandwidth) - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); |
|
|
|
if ((startPos > 1.0f) || (stopPos < 0.0f)) // out of range |
|
{ |
|
continue; |
|
} |
|
|
|
m_visibleAnnotationMarkers.push_back(marker); |
|
m_visibleAnnotationMarkers.back()->m_startPos = startPos < 0.0f ? 0.0f : startPos; |
|
m_visibleAnnotationMarkers.back()->m_stopPos = stopPos > 1.0f ? 1.0f : stopPos; |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateMarkersDisplay() |
|
{ |
|
if (m_markersDisplay & SpectrumSettings::MarkersDisplayAnnotations) { |
|
updateAnnotationMarkers(); |
|
} |
|
} |
|
|
|
void GLSpectrumView::updateCalibrationPoints() |
|
{ |
|
if (m_calibrationPoints.size() == 0) |
|
{ |
|
m_calibrationGain = 1.0; |
|
m_calibrationShiftdB = 0.0; |
|
} |
|
else if (m_calibrationPoints.size() == 1) |
|
{ |
|
m_calibrationGain = m_calibrationPoints.first().m_powerCalibratedReference / |
|
m_calibrationPoints.first().m_powerRelativeReference; |
|
m_calibrationShiftdB = CalcDb::dbPower(m_calibrationGain); |
|
} |
|
else |
|
{ |
|
QList<SpectrumCalibrationPoint> sortedCalibrationPoints = m_calibrationPoints; |
|
std::sort(sortedCalibrationPoints.begin(), sortedCalibrationPoints.end(), calibrationPointsLessThan); |
|
|
|
if (getDisplayedCenterFrequency() <= sortedCalibrationPoints.first().m_frequency) |
|
{ |
|
m_calibrationGain = m_calibrationPoints.first().m_powerCalibratedReference / |
|
m_calibrationPoints.first().m_powerRelativeReference; |
|
m_calibrationShiftdB = CalcDb::dbPower(m_calibrationGain); |
|
} |
|
else if (getDisplayedCenterFrequency() >= sortedCalibrationPoints.last().m_frequency) |
|
{ |
|
m_calibrationGain = m_calibrationPoints.last().m_powerCalibratedReference / |
|
m_calibrationPoints.last().m_powerRelativeReference; |
|
m_calibrationShiftdB = CalcDb::dbPower(m_calibrationGain); |
|
} |
|
else |
|
{ |
|
int lowIndex = 0; |
|
int highIndex = sortedCalibrationPoints.size() - 1; |
|
|
|
for (int index = 0; index < sortedCalibrationPoints.size(); index++) |
|
{ |
|
if (getDisplayedCenterFrequency() < sortedCalibrationPoints[index].m_frequency) |
|
{ |
|
highIndex = index; |
|
break; |
|
} |
|
else |
|
{ |
|
lowIndex = index; |
|
} |
|
} |
|
|
|
// frequency interpolation is always linear |
|
double deltaFrequency = sortedCalibrationPoints[highIndex].m_frequency - |
|
sortedCalibrationPoints[lowIndex].m_frequency; |
|
double shiftFrequency = getDisplayedCenterFrequency() - sortedCalibrationPoints[lowIndex].m_frequency; |
|
double interpolationRatio = shiftFrequency / deltaFrequency; |
|
|
|
// calculate low and high gains in linear mode |
|
double gainLow = sortedCalibrationPoints[lowIndex].m_powerCalibratedReference / |
|
sortedCalibrationPoints[lowIndex].m_powerRelativeReference; |
|
double gainHigh = sortedCalibrationPoints[highIndex].m_powerCalibratedReference / |
|
sortedCalibrationPoints[highIndex].m_powerRelativeReference; |
|
|
|
// power interpolation depends on interpolation options |
|
if (m_calibrationInterpMode == SpectrumSettings::CalibInterpLinear) |
|
{ |
|
m_calibrationGain = gainLow + interpolationRatio*(gainHigh - gainLow); // linear driven |
|
m_calibrationShiftdB = CalcDb::dbPower(m_calibrationGain); |
|
} |
|
else if (m_calibrationInterpMode == SpectrumSettings::CalibInterpLog) |
|
{ |
|
m_calibrationShiftdB = CalcDb::dbPower(gainLow) |
|
+ interpolationRatio*(CalcDb::dbPower(gainHigh) - CalcDb::dbPower(gainLow)); // log driven |
|
m_calibrationGain = CalcDb::powerFromdB(m_calibrationShiftdB); |
|
} |
|
} |
|
} |
|
|
|
updateHistogramMarkers(); |
|
|
|
if (m_messageQueueToGUI && m_useCalibration) { |
|
m_messageQueueToGUI->push(new MsgReportCalibrationShift(m_calibrationShiftdB)); |
|
} |
|
|
|
m_changesPending = true; |
|
} |
|
|
|
bool GLSpectrumView::event(QEvent* event) |
|
{ |
|
if (event->type() == QEvent::Gesture) |
|
{ |
|
QGestureEvent *gestureEvent = static_cast<QGestureEvent *>(event); |
|
|
|
if (QPanGesture *pan = static_cast<QPanGesture *>(gestureEvent->gesture(Qt::PanGesture))) |
|
{ |
|
if (pan->state() == Qt::GestureStarted) |
|
{ |
|
m_scrollStartCenterFreq = getDisplayedCenterFrequency(); |
|
} |
|
else if (pan->state() == Qt::GestureUpdated) |
|
{ |
|
QPointF offset = pan->offset(); |
|
float histogramWidth = width() - m_leftMargin - m_rightMargin; |
|
qint64 frequency = (qint64)(m_scrollStartCenterFreq + -offset.x()/histogramWidth * m_frequencyScale.getRange()); |
|
queueRequestCenterFrequency(frequency); |
|
} |
|
return true; |
|
} |
|
else if (QPinchGesture *pinch = static_cast<QPinchGesture *>(gestureEvent->gesture(Qt::PinchGesture))) |
|
{ |
|
// Don't get GestureStarted and startCenterPoint is always 0,0 |
|
// https://bugreports.qt.io/browse/QTBUG-109205 |
|
if (!m_pinching) |
|
{ |
|
m_scrollStartCenterFreq = getDisplayedCenterFrequency(); |
|
m_pinchStart = pinch->centerPoint(); |
|
m_pinching = true; |
|
m_pinching3D = m_display3DSpectrogram && pointInWaterfallOrSpectrogram(mapFromGlobal(m_pinchStart.toPoint())); |
|
} |
|
else |
|
{ |
|
if (pinch->changeFlags() & QPinchGesture::CenterPointChanged) |
|
{ |
|
if (!m_pinching3D) |
|
{ |
|
// Scroll frequency up or down |
|
QPointF offset = pinch->centerPoint() - m_pinchStart; |
|
float histogramWidth = width() - m_leftMargin - m_rightMargin; |
|
qint64 frequency = (qint64)(m_scrollStartCenterFreq + -offset.x()/histogramWidth * m_frequencyScale.getRange()); |
|
queueRequestCenterFrequency(frequency); |
|
} |
|
} |
|
if (pinch->changeFlags() & QPinchGesture::ScaleFactorChanged) |
|
{ |
|
if (!m_pinching3D) |
|
{ |
|
// Zoom in/out of spectrum |
|
QPoint p = mapFromGlobal(pinch->centerPoint().toPoint()); |
|
zoomFactor(p, pinch->scaleFactor()); |
|
} |
|
else |
|
{ |
|
// Scale Z axis of 3D spectragram |
|
m_glShaderSpectrogram.userScaleZ(pinch->scaleFactor()); |
|
} |
|
} |
|
if (pinch->state() == Qt::GestureFinished) |
|
{ |
|
m_pinching = false; |
|
m_pinching3D = false; |
|
} |
|
} |
|
return true; |
|
} |
|
} |
|
|
|
return QOpenGLWidget::event(event); |
|
} |
|
|
|
void GLSpectrumView::mouseMoveEvent(QMouseEvent* event) |
|
{ |
|
if (m_displayCursorStats) |
|
{ |
|
if ((m_displayMaxHold || m_displayCurrent || m_displayHistogram) && pointInHistogram(event->localPos())) |
|
{ |
|
m_cursorOverSpectrum = true; |
|
|
|
// Calculate frequency under the cursor |
|
const QPointF& ep = event->localPos(); |
|
QPointF pHis = ep; |
|
pHis.rx() = (ep.x()/width() - m_histogramRect.left()) / m_histogramRect.width(); |
|
pHis.ry() = (ep.y()/height() - m_histogramRect.top()) / m_histogramRect.height(); |
|
m_cursorFrequency = m_frequencyScale.getRangeMin() + pHis.x()*m_frequencyScale.getRange(); |
|
|
|
// Calculate FFT bin under the cursor |
|
float f = (m_cursorFrequency - m_frequencyScale.getRangeMin()) / m_frequencyScale.getRange(); // [0..1] fraction of zoomed frequency range |
|
f += 1.0f / (2.0f * m_nbBins); // Shift by half a bin to get center of bin rather than edge |
|
m_cursorFFTBin = (int) (m_fftMin + f * m_nbBins) % m_fftSize; |
|
|
|
m_displayChanged = true; |
|
} |
|
else |
|
{ |
|
m_cursorOverSpectrum = false; |
|
} |
|
} |
|
|
|
if (m_rotate3DSpectrogram && !m_pinching3D) |
|
{ |
|
// Rotate 3D Spectrogram |
|
QPointF delta = m_mousePrevLocalPos - event->localPos(); |
|
m_mousePrevLocalPos = event->localPos(); |
|
m_glShaderSpectrogram.rotateZ(-delta.x()/2.0f); |
|
m_glShaderSpectrogram.rotateX(-delta.y()/2.0f); |
|
repaint(); // Force repaint in case acquisition is stopped |
|
return; |
|
} |
|
if (m_pan3DSpectrogram) |
|
{ |
|
// Pan 3D Spectrogram |
|
QPointF delta = m_mousePrevLocalPos - event->localPos(); |
|
m_mousePrevLocalPos = event->localPos(); |
|
m_glShaderSpectrogram.translateX(-delta.x()/2.0f/500.0f); |
|
m_glShaderSpectrogram.translateY(delta.y()/2.0f/500.0f); |
|
repaint(); // Force repaint in case acquisition is stopped |
|
return; |
|
} |
|
|
|
if (m_scaleZ3DSpectrogram) |
|
{ |
|
// Scale 3D Spectrogram in Z dimension |
|
QPointF delta = m_mousePrevLocalPos - event->localPos(); |
|
m_mousePrevLocalPos = event->localPos(); |
|
m_glShaderSpectrogram.userScaleZ(1.0+(float)delta.y()/20.0); |
|
repaint(); // Force repaint in case acquisition is stopped |
|
return; |
|
} |
|
|
|
if (m_scrollFrequency) |
|
{ |
|
// Request containing widget to adjust center frequency |
|
// Not all containers will support this - mainly for MainSpectrumGUI |
|
// This can be a little slow on some SDRs, so we use delta from where |
|
// button was originally pressed rather than do it incrementally |
|
QPointF delta = m_mousePrevLocalPos - event->localPos(); |
|
float histogramWidth = width() - m_leftMargin - m_rightMargin; |
|
qint64 frequency = (qint64)(m_scrollStartCenterFreq + delta.x()/histogramWidth * m_frequencyScale.getRange()); |
|
queueRequestCenterFrequency(frequency); |
|
return; |
|
} |
|
|
|
if (m_displayWaterfall || m_displayHistogram || m_displayMaxHold || m_displayCurrent) |
|
{ |
|
if (m_frequencyScaleRect.contains(event->pos())) |
|
{ |
|
if (m_cursorState == CSNormal) |
|
{ |
|
setCursor(Qt::SizeVerCursor); |
|
m_cursorState = CSSplitter; |
|
return; |
|
} |
|
} |
|
else |
|
{ |
|
if (m_cursorState == CSSplitter) |
|
{ |
|
setCursor(Qt::ArrowCursor); |
|
m_cursorState = CSNormal; |
|
return; |
|
} |
|
} |
|
} |
|
|
|
if (m_cursorState == CSSplitterMoving) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
float newShare; |
|
|
|
if (!m_invertedWaterfall) { |
|
newShare = (float) (event->y() - m_frequencyScaleRect.height()) / (float) height(); |
|
} else { |
|
newShare = 1.0 - (float) (event->y() + m_frequencyScaleRect.height()) / (float) height(); |
|
} |
|
|
|
if (newShare < 0.1) { |
|
newShare = 0.1f; |
|
} else if (newShare > 0.8) { |
|
newShare = 0.8f; |
|
} |
|
|
|
m_waterfallShare = newShare; |
|
m_changesPending = true; |
|
|
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportWaterfallShare(m_waterfallShare)); |
|
} |
|
|
|
update(); |
|
return; |
|
} |
|
else if (m_cursorState == CSChannelMoving) |
|
{ |
|
// Determine if user is trying to move the channel outside of the current frequency range |
|
// and if so, request an adjustment to the center frequency |
|
// FIXME: This doesn't take zoom into account, so only works when zoomed out |
|
Real freqAbs = m_frequencyScale.getValueFromPos(event->x() - m_leftMarginPixmap.width() - 1); |
|
Real freqMin = getDisplayedCenterFrequency() - getDisplayedSampleRate() / 2.0f; |
|
Real freqMax = getDisplayedCenterFrequency() + getDisplayedSampleRate() / 2.0f; |
|
if (freqAbs < freqMin) { |
|
queueRequestCenterFrequency(getDisplayedCenterFrequency() - (freqMin - freqAbs)); |
|
} else if (freqAbs > freqMax) { |
|
queueRequestCenterFrequency(getDisplayedCenterFrequency() + (freqAbs - freqMax)); |
|
} |
|
|
|
Real freq = freqAbs - getDisplayedCenterFrequency(); |
|
if (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getMovable() |
|
&& (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink) |
|
&& m_channelMarkerStates[m_cursorChannel]->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
m_channelMarkerStates[m_cursorChannel]->m_channelMarker->setCenterFrequencyByCursor(freq); |
|
channelMarkerChanged(); |
|
} |
|
} |
|
|
|
if (m_displayWaterfall || m_displayHistogram || m_displayMaxHold || m_displayCurrent) |
|
{ |
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
if ((m_channelMarkerStates[i]->m_channelMarker->getSourceOrSinkStream() != m_displaySourceOrSink) |
|
|| !m_channelMarkerStates[i]->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
continue; |
|
} |
|
|
|
if (m_channelMarkerStates[i]->m_rect.contains(event->pos())) |
|
{ |
|
if (m_cursorState == CSNormal) |
|
{ |
|
setCursor(Qt::SizeHorCursor); |
|
m_cursorState = CSChannel; |
|
m_cursorChannel = i; |
|
m_channelMarkerStates[i]->m_channelMarker->setHighlightedByCursor(true); |
|
channelMarkerChanged(); |
|
|
|
return; |
|
} |
|
else if (m_cursorState == CSChannel) |
|
{ |
|
return; |
|
} |
|
} |
|
else if (m_channelMarkerStates[i]->m_channelMarker->getHighlighted()) |
|
{ |
|
// Don't clear highlight while dragging a channel, as we want the |
|
// frequency of the channel to be continuously displayed |
|
if (m_cursorState != CSChannelMoving) |
|
{ |
|
m_channelMarkerStates[i]->m_channelMarker->setHighlightedByCursor(false); |
|
channelMarkerChanged(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (m_cursorState == CSChannel) |
|
{ |
|
setCursor(Qt::ArrowCursor); |
|
m_cursorState = CSNormal; |
|
|
|
return; |
|
} |
|
|
|
event->setAccepted(false); |
|
} |
|
|
|
void GLSpectrumView::mousePressEvent(QMouseEvent* event) |
|
{ |
|
const QPointF& ep = event->localPos(); |
|
|
|
if ((event->button() == Qt::MiddleButton) && (m_displayMaxHold || m_displayCurrent || m_displayHistogram) && pointInHistogram(ep)) |
|
{ |
|
m_scrollFrequency = true; |
|
m_scrollStartCenterFreq = getDisplayedCenterFrequency(); |
|
m_mousePrevLocalPos = ep; |
|
return; |
|
} |
|
|
|
if ((event->button() == Qt::MiddleButton) && m_display3DSpectrogram && pointInWaterfallOrSpectrogram(ep)) |
|
{ |
|
m_pan3DSpectrogram = true; |
|
m_mousePrevLocalPos = ep; |
|
return; |
|
} |
|
|
|
if ((event->button() == Qt::RightButton) && m_display3DSpectrogram && pointInWaterfallOrSpectrogram(ep)) |
|
{ |
|
m_scaleZ3DSpectrogram = true; |
|
m_mousePrevLocalPos = ep; |
|
return; |
|
} |
|
|
|
if (event->button() == Qt::RightButton) |
|
{ |
|
QPointF pHis = ep; |
|
bool doUpdate = false; |
|
pHis.rx() = (ep.x()/width() - m_histogramRect.left()) / m_histogramRect.width(); |
|
pHis.ry() = (ep.y()/height() - m_histogramRect.top()) / m_histogramRect.height(); |
|
|
|
if (event->modifiers() & Qt::ShiftModifier) |
|
{ |
|
if ((pHis.x() >= 0) && (pHis.x() <= 1) && (pHis.y() >= 0) && (pHis.y() <= 1)) |
|
{ |
|
m_histogramMarkers.clear(); |
|
doUpdate = true; |
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportHistogramMarkersChange()); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if ((m_histogramMarkers.size() > 0) && (pHis.x() >= 0) && (pHis.x() <= 1) && (pHis.y() >= 0) && (pHis.y() <= 1)) |
|
{ |
|
m_histogramMarkers.pop_back(); |
|
doUpdate = true; |
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportHistogramMarkersChange()); |
|
} |
|
} |
|
} |
|
|
|
QPointF pWat = ep; |
|
pWat.rx() = (ep.x()/width() - m_waterfallRect.left()) / m_waterfallRect.width(); |
|
pWat.ry() = (ep.y()/height() - m_waterfallRect.top()) / m_waterfallRect.height(); |
|
|
|
if (event->modifiers() & Qt::ShiftModifier) |
|
{ |
|
if ((pWat.x() >= 0) && (pWat.x() <= 1) && (pWat.y() >= 0) && (pWat.y() <= 1)) |
|
{ |
|
m_waterfallMarkers.clear(); |
|
doUpdate = true; |
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportWaterfallMarkersChange()); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if ((m_waterfallMarkers.size() > 0) && (pWat.x() >= 0) && (pWat.x() <= 1) && (pWat.y() >= 0) && (pWat.y() <= 1)) |
|
{ |
|
m_waterfallMarkers.pop_back(); |
|
doUpdate = true; |
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportWaterfallMarkersChange()); |
|
} |
|
} |
|
} |
|
|
|
if (doUpdate) { |
|
update(); |
|
} |
|
} |
|
else if (event->button() == Qt::LeftButton) |
|
{ |
|
if (event->modifiers() & Qt::ShiftModifier) |
|
{ |
|
QPointF pHis = ep; |
|
bool doUpdate = false; |
|
pHis.rx() = (ep.x()/width() - m_histogramRect.left()) / m_histogramRect.width(); |
|
pHis.ry() = (ep.y()/height() - m_histogramRect.top()) / m_histogramRect.height(); |
|
float frequency = m_frequencyScale.getRangeMin() + pHis.x()*m_frequencyScale.getRange(); |
|
float powerVal = m_powerScale.getRangeMax() - pHis.y()*m_powerScale.getRange(); |
|
float power = m_linear ? powerVal : CalcDb::powerFromdB(powerVal); |
|
int fftBin = (((frequency - getDisplayedCenterFrequency()) / (float) getDisplayedSampleRate()) * m_fftSize) + (m_fftSize / 2); |
|
|
|
if ((pHis.x() >= 0) && (pHis.x() <= 1) && (pHis.y() >= 0) && (pHis.y() <= 1)) |
|
{ |
|
if (m_histogramMarkers.size() < SpectrumHistogramMarker::m_maxNbOfMarkers) |
|
{ |
|
m_histogramMarkers.push_back(SpectrumHistogramMarker()); |
|
m_histogramMarkers.back().m_point = pHis; |
|
m_histogramMarkers.back().m_frequency = frequency; |
|
m_histogramMarkers.back().m_fftBin = fftBin; |
|
m_histogramMarkers.back().m_frequencyStr = displayScaled( |
|
frequency, |
|
'f', |
|
getPrecision((getDisplayedCenterFrequency()*1000)/getDisplayedSampleRate()), |
|
false); |
|
m_histogramMarkers.back().m_power = power; |
|
m_histogramMarkers.back().m_powerStr = displayPower( |
|
powerVal, |
|
m_linear ? 'e' : 'f', |
|
m_linear ? 3 : 1); |
|
|
|
if (m_histogramMarkers.size() > 1) |
|
{ |
|
int64_t deltaFrequency = frequency - m_histogramMarkers.at(0).m_frequency; |
|
m_histogramMarkers.back().m_deltaFrequencyStr = displayScaled( |
|
deltaFrequency, |
|
'f', |
|
getPrecision(deltaFrequency/getDisplayedSampleRate()), |
|
true); |
|
float power0 = m_linear ? |
|
m_histogramMarkers.at(0).m_power : |
|
CalcDb::dbPower(m_histogramMarkers.at(0).m_power); |
|
m_histogramMarkers.back().m_deltaPowerStr = displayPower( |
|
power - power0, |
|
m_linear ? 'e' : 'f', |
|
m_linear ? 3 : 1); |
|
} |
|
|
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportHistogramMarkersChange()); |
|
} |
|
doUpdate = true; |
|
} |
|
} |
|
|
|
QPointF pWat = ep; |
|
pWat.rx() = (ep.x()/width() - m_waterfallRect.left()) / m_waterfallRect.width(); |
|
pWat.ry() = (ep.y()/height() - m_waterfallRect.top()) / m_waterfallRect.height(); |
|
frequency = m_frequencyScale.getRangeMin() + pWat.x()*m_frequencyScale.getRange(); |
|
float time = m_timeScale.getRangeMin() + pWat.y()*m_timeScale.getRange(); |
|
|
|
if ((pWat.x() >= 0) && (pWat.x() <= 1) && (pWat.y() >= 0) && (pWat.y() <= 1) && !m_display3DSpectrogram) |
|
{ |
|
if (m_waterfallMarkers.size() < SpectrumWaterfallMarker::m_maxNbOfMarkers) |
|
{ |
|
m_waterfallMarkers.push_back(SpectrumWaterfallMarker()); |
|
m_waterfallMarkers.back().m_point = pWat; |
|
m_waterfallMarkers.back().m_frequency = frequency; |
|
m_waterfallMarkers.back().m_frequencyStr = displayScaled( |
|
frequency, |
|
'f', |
|
getPrecision((getDisplayedCenterFrequency()*1000)/getDisplayedSampleRate()), |
|
false); |
|
m_waterfallMarkers.back().m_time = time; |
|
m_waterfallMarkers.back().m_timeStr = displayScaledF( |
|
time, |
|
'f', |
|
3, |
|
true); |
|
|
|
if (m_waterfallMarkers.size() > 1) |
|
{ |
|
int64_t deltaFrequency = frequency - m_waterfallMarkers.at(0).m_frequency; |
|
m_waterfallMarkers.back().m_deltaFrequencyStr = displayScaled( |
|
deltaFrequency, |
|
'f', |
|
getPrecision(deltaFrequency/getDisplayedSampleRate()), |
|
true); |
|
m_waterfallMarkers.back().m_deltaTimeStr = displayScaledF( |
|
time - m_waterfallMarkers.at(0).m_time, |
|
'f', |
|
3, |
|
true); |
|
} |
|
|
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportWaterfallMarkersChange()); |
|
} |
|
doUpdate = true; |
|
} |
|
} |
|
|
|
if (doUpdate) { |
|
update(); |
|
} |
|
} |
|
else if (event->modifiers() & Qt::AltModifier) |
|
{ |
|
frequencyPan(event); |
|
} |
|
else if (event->modifiers() & Qt::ControlModifier) |
|
{ |
|
if (!m_display3DSpectrogram && pointInWaterfallOrSpectrogram(ep)) |
|
{ |
|
QPointF pWat = ep; |
|
pWat.rx() = (ep.x()/width() - m_waterfallRect.left()) / m_waterfallRect.width(); |
|
pWat.ry() = (ep.y()/height() - m_waterfallRect.top()) / m_waterfallRect.height(); |
|
float time = m_timeScale.getRangeMin() + pWat.y()*m_timeScale.getRange(); |
|
emit timeSelected(time); |
|
} |
|
return; |
|
} |
|
else if (m_display3DSpectrogram) |
|
{ |
|
// Detect click and drag to rotate 3D spectrogram |
|
if (pointInWaterfallOrSpectrogram(ep)) |
|
{ |
|
m_rotate3DSpectrogram = true; |
|
m_mousePrevLocalPos = ep; |
|
return; |
|
} |
|
} |
|
|
|
if ((m_markersDisplay & SpectrumSettings::MarkersDisplayAnnotations) && |
|
(ep.y() <= m_histogramRect.top()*height() + m_annotationMarkerHeight + 2.0f)) |
|
{ |
|
QPointF pHis; |
|
pHis.rx() = (ep.x()/width() - m_histogramRect.left()) / m_histogramRect.width(); |
|
qint64 selectedFrequency = m_frequencyScale.getRangeMin() + pHis.x() * m_frequencyScale.getRange(); |
|
bool selected = false; |
|
|
|
for (auto iMarker = m_visibleAnnotationMarkers.rbegin(); iMarker != m_visibleAnnotationMarkers.rend(); ++iMarker) |
|
{ |
|
if ((*iMarker)->m_show == SpectrumAnnotationMarker::Hidden) { |
|
continue; |
|
} |
|
|
|
qint64 stopFrequency = (*iMarker)->m_startFrequency + |
|
((*iMarker)->m_bandwidth == 0 ? m_frequencyScale.getRange()*0.01f : (*iMarker)->m_bandwidth); |
|
|
|
if (((*iMarker)->m_startFrequency < selectedFrequency) && (selectedFrequency <= stopFrequency) && !selected) |
|
{ |
|
switch ((*iMarker)->m_show) |
|
{ |
|
case SpectrumAnnotationMarker::ShowTop: |
|
(*iMarker)->m_show = SpectrumAnnotationMarker::ShowText; |
|
break; |
|
case SpectrumAnnotationMarker::ShowText: |
|
(*iMarker)->m_show = SpectrumAnnotationMarker::ShowFull; |
|
break; |
|
case SpectrumAnnotationMarker::ShowFull: |
|
(*iMarker)->m_show = SpectrumAnnotationMarker::ShowTop; |
|
break; |
|
case SpectrumAnnotationMarker::Hidden: |
|
break; |
|
} |
|
selected = true; |
|
} |
|
} |
|
} |
|
|
|
if (m_cursorState == CSSplitter) |
|
{ |
|
grabMouse(); |
|
m_cursorState = CSSplitterMoving; |
|
return; |
|
} |
|
else if (m_cursorState == CSChannel) |
|
{ |
|
grabMouse(); |
|
m_cursorState = CSChannelMoving; |
|
return; |
|
} |
|
else if ((m_cursorState == CSNormal) && |
|
(m_channelMarkerStates.size() == 1) && |
|
!(event->modifiers() & Qt::ShiftModifier) && |
|
!(event->modifiers() & Qt::AltModifier) && |
|
!(event->modifiers() & Qt::ControlModifier) && |
|
(ep.y() > m_histogramRect.top()*height() + m_annotationMarkerHeight + 2.0f)) // out of annotation selection zone |
|
{ |
|
grabMouse(); |
|
setCursor(Qt::SizeHorCursor); |
|
m_cursorState = CSChannelMoving; |
|
m_cursorChannel = 0; |
|
Real freq = m_frequencyScale.getValueFromPos(event->x() - m_leftMarginPixmap.width() - 1) - getDisplayedCenterFrequency(); |
|
|
|
if (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getMovable() |
|
&& (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink) |
|
&& m_channelMarkerStates[m_cursorChannel]->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
m_channelMarkerStates[m_cursorChannel]->m_channelMarker->setCenterFrequencyByCursor(freq); |
|
channelMarkerChanged(); |
|
} |
|
|
|
return; |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::mouseReleaseEvent(QMouseEvent*) |
|
{ |
|
m_scrollFrequency = false; |
|
m_pan3DSpectrogram = false; |
|
m_rotate3DSpectrogram = false; |
|
m_scaleZ3DSpectrogram = false; |
|
if (m_cursorState == CSSplitterMoving) |
|
{ |
|
releaseMouse(); |
|
m_cursorState = CSSplitter; |
|
} |
|
else if (m_cursorState == CSChannelMoving) |
|
{ |
|
releaseMouse(); |
|
m_cursorState = CSChannel; |
|
} |
|
} |
|
|
|
void GLSpectrumView::wheelEvent(QWheelEvent *event) |
|
{ |
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0) |
|
const QPointF& ep = event->position(); |
|
#else |
|
const QPointF& ep = event->pos(); |
|
#endif |
|
if (m_display3DSpectrogram && pointInWaterfallOrSpectrogram(ep)) |
|
{ |
|
// Scale 3D spectrogram when mouse wheel moved |
|
// Some mice use delta in steps of 120 for 15 degrees |
|
// for one step of mouse wheel |
|
// Other mice/trackpads use smaller values |
|
int delta = event->angleDelta().y(); |
|
if (delta != 0) { |
|
m_glShaderSpectrogram.verticalAngle(-5.0*delta/120.0); |
|
} |
|
repaint(); // Force repaint in case acquisition is stopped |
|
} |
|
else |
|
{ |
|
if (event->modifiers() & Qt::ShiftModifier) { |
|
channelMarkerMove(event, 100); |
|
} else if (event->modifiers() & Qt::ControlModifier) { |
|
channelMarkerMove(event, 10); |
|
} else { |
|
channelMarkerMove(event, 1); |
|
} |
|
} |
|
event->accept(); |
|
} |
|
|
|
void GLSpectrumView::zoomFactor(const QPointF& p, float factor) |
|
{ |
|
float pwx = (p.x() - m_leftMargin) / (width() - m_leftMargin - m_rightMargin); // x position in window |
|
|
|
if ((pwx >= 0.0f) && (pwx <= 1.0f)) |
|
{ |
|
// When we zoom, we want the frequency under the cursor to remain the same |
|
|
|
// Determine frequency at cursor position |
|
float zoomFreq = m_frequencyScale.getRangeMin() + pwx*m_frequencyScale.getRange(); |
|
|
|
// Calculate current centre frequency |
|
float currentCF = (m_frequencyZoomFactor == 1) ? getDisplayedCenterFrequency() : ((m_frequencyZoomPos - 0.5) * getDisplayedSampleRate() + getDisplayedCenterFrequency()); |
|
|
|
// Calculate difference from frequency under cursor to centre frequency |
|
float freqDiff = (currentCF - zoomFreq); |
|
|
|
// Calculate what that difference would be if there was no zoom |
|
float freqDiffZoom1 = freqDiff * m_frequencyZoomFactor; |
|
|
|
m_frequencyZoomFactor *= factor; |
|
m_frequencyZoomFactor = std::min(m_frequencyZoomFactor, m_maxFrequencyZoom); |
|
m_frequencyZoomFactor = std::max(m_frequencyZoomFactor, 1.0f); |
|
|
|
// Calculate what frequency difference should be at new zoom |
|
float zoomedFreqDiff = freqDiffZoom1 / m_frequencyZoomFactor; |
|
// Then calculate what the center frequency should be |
|
float zoomedCF = zoomFreq + zoomedFreqDiff; |
|
|
|
// Calculate zoom position which will set the desired center frequency |
|
float zoomPos = (zoomedCF - getDisplayedCenterFrequency()) / getDisplayedSampleRate() + 0.5; |
|
zoomPos = std::max(0.0f, zoomPos); |
|
zoomPos = std::min(1.0f, zoomPos); |
|
|
|
frequencyZoom(zoomPos); |
|
} |
|
} |
|
|
|
void GLSpectrumView::zoom(const QPointF& p, int y) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); // Lock to ensure we don't try to redraw mid calculation of zoom and fftMin/fftMax |
|
|
|
float pwx = (p.x() - m_leftMargin) / (width() - m_leftMargin - m_rightMargin); // x position in window |
|
|
|
if ((pwx >= 0.0f) && (pwx <= 1.0f)) |
|
{ |
|
// When we zoom, we want the frequency under the cursor to remain the same |
|
|
|
// Determine frequency at cursor position |
|
float zoomFreq = m_frequencyScale.getRangeMin() + pwx*m_frequencyScale.getRange(); |
|
|
|
// Calculate current centre frequency |
|
int adjSampleRate = m_ssbSpectrum ? getDisplayedSampleRate()/2 : getDisplayedSampleRate(); |
|
qint64 adjCenterFrequency = getDisplayedCenterFrequency() + (m_ssbSpectrum ? getDisplayedSampleRate()/4 : 0); |
|
float currentCF = (m_frequencyZoomFactor == 1) ? |
|
adjCenterFrequency : (m_frequencyZoomPos - 0.5) * adjSampleRate + adjCenterFrequency; |
|
|
|
// Calculate difference from frequency under cursor to centre frequency |
|
float freqDiff = (currentCF - zoomFreq); |
|
|
|
// Calculate what that difference would be if there was no zoom |
|
float freqDiffZoom1 = freqDiff * m_frequencyZoomFactor; |
|
|
|
if (y > 0) // zoom in |
|
{ |
|
if (m_frequencyZoomFactor < m_maxFrequencyZoom) { |
|
m_frequencyZoomFactor += 0.5f; |
|
} else { |
|
return; |
|
} |
|
} |
|
else |
|
{ |
|
if (m_frequencyZoomFactor > 1.0f) { |
|
m_frequencyZoomFactor -= 0.5f; |
|
} else { |
|
return; |
|
} |
|
} |
|
|
|
// Calculate what frequency difference should be at new zoom |
|
float zoomedFreqDiff = freqDiffZoom1 / m_frequencyZoomFactor; |
|
// Then calculate what the center frequency should be |
|
float zoomedCF = zoomFreq + zoomedFreqDiff; |
|
|
|
// Calculate zoom position which will set the desired center frequency |
|
float zoomPos = (zoomedCF - adjCenterFrequency) / adjSampleRate + 0.5; |
|
zoomPos = std::max(0.0f, zoomPos); |
|
zoomPos = std::min(1.0f, zoomPos); |
|
|
|
frequencyZoom(zoomPos); |
|
} |
|
else |
|
{ |
|
float pwyh, pwyw; |
|
|
|
if (m_invertedWaterfall) // histo on top |
|
{ |
|
pwyh = (p.y() - m_topMargin) / m_histogramHeight; |
|
pwyw = (p.y() - m_topMargin - m_histogramHeight - m_frequencyScaleHeight) / m_waterfallHeight; |
|
} |
|
else // waterfall on top |
|
{ |
|
pwyw = (p.y() - m_topMargin) / m_waterfallHeight; |
|
pwyh = (p.y() - m_topMargin - m_waterfallHeight - m_frequencyScaleHeight) / m_histogramHeight; |
|
} |
|
|
|
//qDebug("GLSpectrumView::zoom: pwyh: %f pwyw: %f", pwyh, pwyw); |
|
|
|
if ((pwyw >= 0.0f) && (pwyw <= 1.0f)) { |
|
timeZoom(y > 0); |
|
} |
|
|
|
if ((pwyh >= 0.0f) && (pwyh <= 1.0f) && !m_linear) { |
|
powerZoom(pwyh, y > 0); |
|
} |
|
} |
|
} |
|
|
|
void GLSpectrumView::frequencyZoom(float zoomPos) |
|
{ |
|
m_frequencyZoomPos = zoomPos; |
|
updateFFTLimits(false); |
|
m_displayChanged = true; |
|
} |
|
|
|
void GLSpectrumView::frequencyPan(QMouseEvent *event) |
|
{ |
|
if (m_frequencyZoomFactor == 1.0f) { |
|
return; |
|
} |
|
|
|
const QPointF& p = event->pos(); |
|
float pw = (p.x() - m_leftMargin) / (width() - m_leftMargin - m_rightMargin); // position in window |
|
pw = pw < 0.0f ? 0.0f : pw > 1.0f ? 1.0 : pw; |
|
float dw = pw - 0.5f; |
|
m_frequencyZoomPos += dw * (1.0f / m_frequencyZoomFactor); |
|
float lim = 0.5f / m_frequencyZoomFactor; |
|
m_frequencyZoomPos = m_frequencyZoomPos < lim ? lim : m_frequencyZoomPos > 1 - lim ? 1 - lim : m_frequencyZoomPos; |
|
|
|
qDebug("GLSpectrumView::frequencyPan: pw: %f p: %f", pw, m_frequencyZoomPos); |
|
updateFFTLimits(false); |
|
} |
|
|
|
void GLSpectrumView::timeZoom(bool zoomInElseOut) |
|
{ |
|
if ((m_fftOverlap == 0) && !zoomInElseOut) { |
|
return; |
|
} |
|
|
|
if (zoomInElseOut && (m_fftOverlap == m_fftSize - 1)) { |
|
return; |
|
} |
|
|
|
m_fftOverlap = m_fftOverlap + (zoomInElseOut ? 1 : -1); |
|
m_changesPending = true; |
|
|
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportFFTOverlap(m_fftOverlap)); |
|
} |
|
} |
|
|
|
void GLSpectrumView::powerZoom(float pw, bool zoomInElseOut) |
|
{ |
|
m_powerRange = m_powerRange + (zoomInElseOut ? -2 : 2); |
|
|
|
if (pw > 2.0/3.0) { // bottom |
|
m_referenceLevel = m_referenceLevel + (zoomInElseOut ? -2 : 2); |
|
} else if (pw > 1.0/3.0) { // middle |
|
m_referenceLevel = m_referenceLevel + (zoomInElseOut ? -1 : 1); |
|
} // top |
|
|
|
m_powerRange = std::clamp(m_powerRange, m_minPowerRange, m_maxPowerRange); |
|
m_referenceLevel = std::clamp(m_referenceLevel, m_minReferenceLevel, m_maxReferenceLevel); |
|
m_changesPending = true; |
|
m_displayChanged = true; |
|
redrawWaterfallAnd3DSpectrogram(); |
|
|
|
if (m_messageQueueToGUI) { |
|
m_messageQueueToGUI->push(new MsgReportPowerScale(m_referenceLevel, m_powerRange)); |
|
} |
|
} |
|
|
|
void GLSpectrumView::resetFrequencyZoom() |
|
{ |
|
m_frequencyZoomFactor = 1.0f; |
|
m_frequencyZoomPos = 0.5f; |
|
|
|
updateFFTLimits(false); |
|
} |
|
|
|
void GLSpectrumView::updateFFTLimits(bool fftSizeChangedOnly) |
|
{ |
|
if (!fftSizeChangedOnly) |
|
{ |
|
if (m_messageQueueToGUI) |
|
{ |
|
m_messageQueueToGUI->push(GLSpectrumView::MsgFrequencyZooming::create( |
|
m_frequencyZoomFactor, m_frequencyZoomPos |
|
)); |
|
} |
|
} |
|
|
|
m_fftMin = m_frequencyZoomFactor == 1.0f ? 0 : (m_frequencyZoomPos - (0.5f / m_frequencyZoomFactor)) * m_fftSize; |
|
m_fftMax = m_frequencyZoomFactor == 1.0f ? m_fftSize : (m_frequencyZoomPos + (0.5f / m_frequencyZoomFactor)) * m_fftSize; |
|
if (m_fftMin < 0) { |
|
m_fftMin = 0; |
|
} |
|
if (m_fftMax > m_fftSize) { |
|
m_fftMax = m_fftSize; |
|
} |
|
m_nbBins = m_fftMax - m_fftMin; |
|
|
|
m_redrawAll = true; |
|
m_changesPending = true; |
|
} |
|
|
|
void GLSpectrumView::setFrequencyZooming(float frequencyZoomFactor, float frequencyZoomPos) |
|
{ |
|
m_frequencyZoomFactor = frequencyZoomFactor; |
|
frequencyZoom(frequencyZoomPos); |
|
} |
|
|
|
void GLSpectrumView::setReferenceLevelRange(Real minReferenceLevel, Real maxReferenceLevel) |
|
{ |
|
m_minReferenceLevel = minReferenceLevel; |
|
m_maxReferenceLevel = maxReferenceLevel; |
|
} |
|
|
|
void GLSpectrumView::setPowerRangeRange(Real minPowerRange, Real maxPowerRange) |
|
{ |
|
m_minPowerRange = minPowerRange; |
|
m_maxPowerRange = maxPowerRange; |
|
} |
|
|
|
void GLSpectrumView::setFrequencyScale() |
|
{ |
|
int frequencySpan; |
|
int64_t centerFrequency; |
|
|
|
getFrequencyZoom(centerFrequency, frequencySpan); |
|
m_frequencyScale.setSize(width() - m_leftMargin - m_rightMargin); |
|
m_frequencyScale.setRange(Unit::Frequency, centerFrequency - frequencySpan / 2.0, centerFrequency + frequencySpan / 2.0); |
|
m_frequencyScale.setMakeOpposite(m_lsbDisplay); |
|
} |
|
|
|
void GLSpectrumView::setPowerScale(int height) |
|
{ |
|
m_powerScale.setSize(height); |
|
|
|
if (m_linear) |
|
{ |
|
Real referenceLevel = m_useCalibration ? m_referenceLevel * m_calibrationGain : m_referenceLevel; |
|
m_powerScale.setRange(Unit::Scientific, 0.0f, referenceLevel); |
|
} |
|
else |
|
{ |
|
Real referenceLevel = m_useCalibration ? m_referenceLevel + m_calibrationShiftdB : m_referenceLevel; |
|
m_powerScale.setRange(Unit::Decibel, referenceLevel - m_powerRange, referenceLevel); |
|
} |
|
|
|
if (m_powerScale.getScaleWidth() > m_leftMargin) { |
|
m_leftMargin = m_powerScale.getScaleWidth(); |
|
} |
|
} |
|
|
|
void GLSpectrumView::getFrequencyZoom(int64_t& centerFrequency, int& frequencySpan) |
|
{ |
|
int adjSampleRate = m_ssbSpectrum ? getDisplayedSampleRate()/2 : getDisplayedSampleRate(); |
|
qint64 adjCenterFrequency = getDisplayedCenterFrequency() + (m_ssbSpectrum ? getDisplayedSampleRate()/4 : 0); |
|
frequencySpan = (m_frequencyZoomFactor == 1) ? |
|
adjSampleRate : adjSampleRate * (1.0 / m_frequencyZoomFactor); |
|
centerFrequency = (m_frequencyZoomFactor == 1) ? |
|
adjCenterFrequency : (m_frequencyZoomPos - 0.5) * adjSampleRate + adjCenterFrequency; |
|
} |
|
|
|
void GLSpectrumView::channelMarkerMove(QWheelEvent *event, int mul) |
|
{ |
|
for (int i = 0; i < m_channelMarkerStates.size(); ++i) |
|
{ |
|
if ((m_channelMarkerStates[i]->m_channelMarker->getSourceOrSinkStream() != m_displaySourceOrSink) |
|
|| !m_channelMarkerStates[i]->m_channelMarker->streamIndexApplies(m_displayStreamIndex)) |
|
{ |
|
continue; |
|
} |
|
|
|
if (m_channelMarkerStates[i]->m_rect.contains(event->position())) |
|
{ |
|
int freq = m_channelMarkerStates[i]->m_channelMarker->getCenterFrequency(); |
|
|
|
if (event->angleDelta().y() > 0) { |
|
freq += 10 * mul; |
|
} else if (event->angleDelta().y() < 0) { |
|
freq -= 10 * mul; |
|
} |
|
|
|
// calculate scale relative cursor position for new frequency |
|
float x_pos = m_frequencyScale.getPosFromValue(getDisplayedCenterFrequency() + freq); |
|
|
|
if ((x_pos >= 0.0) && (x_pos < m_frequencyScale.getSize())) // cursor must be in scale |
|
{ |
|
m_channelMarkerStates[i]->m_channelMarker->setCenterFrequencyByCursor(freq); |
|
m_channelMarkerStates[i]->m_channelMarker->setCenterFrequency(freq); |
|
|
|
// cursor follow-up |
|
int xd = x_pos + m_leftMargin; |
|
QCursor c = cursor(); |
|
QPoint cp_a = c.pos(); |
|
QPoint cp_w = mapFromGlobal(cp_a); |
|
cp_w.setX(xd); |
|
cp_a = mapToGlobal(cp_w); |
|
c.setPos(cp_a); |
|
setCursor(c); |
|
} |
|
|
|
return; |
|
} |
|
} |
|
|
|
zoom(event->position(), event->angleDelta().y()); |
|
} |
|
|
|
// Return if specified point is within the bounds of the waterfall / 3D spectrogram screen area |
|
bool GLSpectrumView::pointInWaterfallOrSpectrogram(const QPointF &point) const |
|
{ |
|
// m_waterfallRect is normalised to [0,1] |
|
QPointF pWat = point; |
|
pWat.rx() = (point.x()/width() - m_waterfallRect.left()) / m_waterfallRect.width(); |
|
pWat.ry() = (point.y()/height() - m_waterfallRect.top()) / m_waterfallRect.height(); |
|
|
|
return (pWat.x() >= 0) && (pWat.x() <= 1) && (pWat.y() >= 0) && (pWat.y() <= 1); |
|
} |
|
|
|
// Return if specified point is within the bounds of the histogram screen area |
|
bool GLSpectrumView::pointInHistogram(const QPointF &point) const |
|
{ |
|
// m_histogramRect is normalised to [0,1] |
|
QPointF p = point; |
|
p.rx() = (point.x()/width() - m_histogramRect.left()) / m_histogramRect.width(); |
|
p.ry() = (point.y()/height() - m_histogramRect.top()) / m_histogramRect.height(); |
|
|
|
return (p.x() >= 0) && (p.x() <= 1) && (p.y() >= 0) && (p.y() <= 1); |
|
} |
|
|
|
void GLSpectrumView::enterEvent(EnterEventType* event) |
|
{ |
|
m_mouseInside = true; |
|
update(); |
|
QOpenGLWidget::enterEvent(event); |
|
} |
|
|
|
void GLSpectrumView::leaveEvent(QEvent* event) |
|
{ |
|
m_mouseInside = false; |
|
update(); |
|
QOpenGLWidget::leaveEvent(event); |
|
} |
|
|
|
void GLSpectrumView::tick() |
|
{ |
|
// Update scroll bar to account for changes to m_spectrumBuffer and waterfall size changes. |
|
if (m_scrollBar && !m_scrollBar->visibleRegion().isEmpty()) { |
|
updateScrollBar(); |
|
} |
|
|
|
if (m_displayChanged) |
|
{ |
|
// Qt only skips painting widgets that are hidden, not ones that are covered, so |
|
// a spectrum behind another subwindow or under a floating workspace still gets |
|
// repainted at the full rate. The paint itself is not the expense: on a window |
|
// holding a QQuickWidget or QWebEngineView, every repaint makes Qt composite the |
|
// whole window through the RHI. |
|
if (!isVisible() || window()->isMinimized() || visibleRegion().isEmpty()) { |
|
return; |
|
} |
|
|
|
m_displayChanged = false; |
|
update(); |
|
} |
|
} |
|
|
|
void GLSpectrumView::channelMarkerChanged() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
m_changesPending = true; |
|
update(); |
|
} |
|
|
|
void GLSpectrumView::channelMarkerDestroyed(QObject* object) |
|
{ |
|
removeChannelMarker((ChannelMarker*)object); |
|
} |
|
|
|
void GLSpectrumView::setWaterfallShare(Real waterfallShare) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (waterfallShare < 0.1f) { |
|
m_waterfallShare = 0.1f; |
|
} else if (waterfallShare > 0.8f) { |
|
m_waterfallShare = 0.8f; |
|
} else { |
|
m_waterfallShare = waterfallShare; |
|
} |
|
|
|
m_changesPending = true; |
|
} |
|
|
|
void GLSpectrumView::setFPSPeriodMs(int fpsPeriodMs) |
|
{ |
|
if (fpsPeriodMs == 0) |
|
{ |
|
disconnect(&m_timer, SIGNAL(timeout()), this, SLOT(tick())); |
|
m_timer.stop(); |
|
} |
|
else |
|
{ |
|
connect(&m_timer, SIGNAL(timeout()), this, SLOT(tick())); |
|
m_timer.start(fpsPeriodMs); |
|
} |
|
|
|
m_fpsPeriodMs = fpsPeriodMs; |
|
} |
|
|
|
void GLSpectrumView::cleanup() |
|
{ |
|
//makeCurrent(); |
|
m_glShaderSimple.cleanup(); |
|
m_glShaderFrequencyScale.cleanup(); |
|
m_glShaderHistogram.cleanup(); |
|
m_glShaderLeftScale.cleanup(); |
|
m_glShaderWaterfall.cleanup(); |
|
m_glShaderTextOverlay.cleanup(); |
|
m_glShaderInfo.cleanup(); |
|
m_glShaderSpectrogram.cleanup(); |
|
m_glShaderSpectrogramTimeScale.cleanup(); |
|
m_glShaderSpectrogramPowerScale.cleanup(); |
|
//doneCurrent(); |
|
} |
|
|
|
// Display number with full precision, group separators and eng. unit suffixes |
|
// E.g: |
|
// -1.505,123,304G |
|
// 456.034,123M |
|
// 300.345k |
|
// 789 |
|
QString GLSpectrumView::displayFull(int64_t value) |
|
{ |
|
if (value == 0) { |
|
return "0"; |
|
} |
|
int64_t absValue = std::abs(value); |
|
|
|
QString digits = QString::number(absValue); |
|
int cnt = digits.size(); |
|
|
|
QString point = QLocale::system().decimalPoint(); |
|
QString group = QLocale::system().groupSeparator(); |
|
int i; |
|
for (i = cnt - 3; i >= 4; i -= 3) |
|
{ |
|
digits = digits.insert(i, group); |
|
} |
|
if (absValue >= 1000) { |
|
digits = digits.insert(i, point); |
|
} |
|
if (cnt > 9) { |
|
digits = digits.append("G"); |
|
} else if (cnt > 6) { |
|
digits = digits.append("M"); |
|
} else if (cnt > 3) { |
|
digits = digits.append("k"); |
|
} |
|
if (value < 0) { |
|
digits = digits.insert(0, "-"); |
|
} |
|
|
|
return digits; |
|
} |
|
|
|
QString GLSpectrumView::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)); |
|
} |
|
} |
|
|
|
QString GLSpectrumView::displayPower(float value, char type, int precision) |
|
{ |
|
return tr("%1").arg(QString::number(value, type, precision)); |
|
} |
|
|
|
QString GLSpectrumView::displayScaledF(float value, char type, int precision, bool showMult) |
|
{ |
|
float posValue = (value < 0) ? -value : value; |
|
|
|
if (posValue == 0) |
|
{ |
|
return tr("%1").arg(QString::number(value, 'f', precision)); |
|
} |
|
else if (posValue < 1) |
|
{ |
|
if (posValue > 0.001) { |
|
return tr("%1%2").arg(QString::number(value * 1000.0, type, precision)).arg(showMult ? "m" : ""); |
|
} else if (posValue > 0.000001) { |
|
return tr("%1%2").arg(QString::number(value * 1000000.0, type, precision)).arg(showMult ? "u" : ""); |
|
} else if (posValue > 1e-9) { |
|
return tr("%1%2").arg(QString::number(value * 1e9, type, precision)).arg(showMult ? "n" : ""); |
|
} else if (posValue > 1e-12) { |
|
return tr("%1%2").arg(QString::number(value * 1e12, type, precision)).arg(showMult ? "p" : ""); |
|
} else { |
|
return tr("%1").arg(QString::number(value, 'e', precision)); |
|
} |
|
} |
|
else |
|
{ |
|
if (posValue < 1e3) { |
|
return tr("%1").arg(QString::number(value, type, precision)); |
|
} else if (posValue < 1e6) { |
|
return tr("%1%2").arg(QString::number(value / 1000.0, type, precision)).arg(showMult ? "k" : ""); |
|
} else if (posValue < 1e9) { |
|
return tr("%1%2").arg(QString::number(value / 1000000.0, type, precision)).arg(showMult ? "M" : ""); |
|
} else if (posValue < 1e12) { |
|
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)); |
|
} |
|
} |
|
} |
|
|
|
int GLSpectrumView::getPrecision(int value) |
|
{ |
|
int posValue = (value < 0) ? -value : value; |
|
|
|
if (posValue < 1000) { |
|
return 3; |
|
} else if (posValue < 10000) { |
|
return 4; |
|
} else if (posValue < 100000) { |
|
return 5; |
|
} else { |
|
return 6; |
|
} |
|
} |
|
|
|
// Draw text right justified in top info bar - currently unused |
|
void GLSpectrumView::drawTextRight(const QString &text, const QString &value, const QString &max, const QString &units) |
|
{ |
|
drawTextsRight({text}, {value}, {max}, {units}); |
|
} |
|
|
|
void GLSpectrumView::drawTextsRight(const QStringList &text, const QStringList &value, const QStringList &max, const QStringList &units) |
|
{ |
|
QFontMetrics fm(font()); |
|
|
|
m_infoPixmap.fill(Qt::transparent); |
|
|
|
QPainter painter(&m_infoPixmap); |
|
painter.setPen(Qt::NoPen); |
|
painter.setBrush(Qt::black); |
|
painter.setBrush(Qt::transparent); |
|
painter.drawRect(m_leftMargin, 0, width() - m_leftMargin, m_infoHeight); |
|
painter.setPen(QColor(0xf0, 0xf0, 0xff)); |
|
painter.setFont(font()); |
|
|
|
int x = width() - m_rightMargin; |
|
int y = fm.height() + fm.ascent() / 2 - 2; |
|
int textWidth, maxWidth; |
|
for (int i = text.length() - 1; i >= 0; i--) |
|
{ |
|
if (!text[i].isEmpty() || !value[i].isEmpty()) |
|
{ |
|
textWidth = fm.horizontalAdvance(units[i]); |
|
painter.drawText(QPointF(x - textWidth, y), units[i]); |
|
x -= textWidth; |
|
|
|
textWidth = fm.horizontalAdvance(value[i]); |
|
maxWidth = fm.horizontalAdvance(max[i]); |
|
painter.drawText(QPointF(x - textWidth, y), value[i]); |
|
x -= maxWidth; |
|
|
|
textWidth = fm.horizontalAdvance(text[i]); |
|
painter.drawText(QPointF(x - textWidth, y), text[i]); |
|
x -= textWidth; |
|
} |
|
} |
|
|
|
m_glShaderTextOverlay.initTexture(m_infoPixmap.toImage()); |
|
|
|
GLfloat vtx1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0 |
|
}; |
|
|
|
m_glShaderTextOverlay.drawSurface(m_glInfoBoxMatrix, tex1, vtx1, 4); |
|
} |
|
|
|
void GLSpectrumView::drawTextOverlayCentered ( |
|
const QString &text, |
|
const QColor &color, |
|
const QFont& font, |
|
float shiftX, |
|
float shiftY, |
|
const QRectF &glRect) |
|
{ |
|
if (text.isEmpty()) { |
|
return; |
|
} |
|
|
|
QFontMetricsF metrics(font); |
|
QRectF textRect = metrics.boundingRect(text); |
|
QRectF overlayRect(0, 0, textRect.width() * 1.05f + 4.0f, textRect.height()); |
|
QPixmap channelOverlayPixmap = QPixmap(overlayRect.width(), overlayRect.height()); |
|
channelOverlayPixmap.fill(Qt::transparent); |
|
QPainter painter(&channelOverlayPixmap); |
|
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing, false); |
|
painter.fillRect(overlayRect, QColor(0, 0, 0, 0x80)); |
|
QColor textColor(color); |
|
textColor.setAlpha(0xC0); |
|
painter.setPen(textColor); |
|
painter.setFont(font); |
|
painter.drawText(QPointF(2.0f, overlayRect.height() - 4.0f), text); |
|
painter.end(); |
|
|
|
m_glShaderTextOverlay.initTexture(channelOverlayPixmap.toImage()); |
|
|
|
{ |
|
GLfloat vtx1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0}; |
|
|
|
float rectX = glRect.x() + shiftX - ((overlayRect.width()/2)/width()); |
|
float rectY = glRect.y() + shiftY + (4.0f / height()) - ((overlayRect.height()+5)/height()); |
|
float rectW = overlayRect.width() / (float) width(); |
|
float rectH = overlayRect.height() / (float) height(); |
|
|
|
QMatrix4x4 mat; |
|
mat.setToIdentity(); |
|
mat.translate(-1.0f + 2.0f * rectX, 1.0f - 2.0f * rectY); |
|
mat.scale(2.0f * rectW, -2.0f * rectH); |
|
m_glShaderTextOverlay.drawSurface(mat, tex1, vtx1, 4); |
|
} |
|
} |
|
|
|
void GLSpectrumView::drawTextOverlay( |
|
const QString &text, |
|
const QColor &color, |
|
const QFont& font, |
|
float shiftX, |
|
float shiftY, |
|
bool leftHalf, |
|
bool topHalf, |
|
const QRectF &glRect) |
|
{ |
|
if (text.isEmpty()) { |
|
return; |
|
} |
|
|
|
QFontMetricsF metrics(font); |
|
QRectF textRect = metrics.boundingRect(text); |
|
QRectF overlayRect(0, 0, textRect.width() * 1.05f + 4.0f, textRect.height()); |
|
QPixmap channelOverlayPixmap = QPixmap(overlayRect.width(), overlayRect.height()); |
|
channelOverlayPixmap.fill(Qt::transparent); |
|
QPainter painter(&channelOverlayPixmap); |
|
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing, false); |
|
painter.fillRect(overlayRect, QColor(0, 0, 0, 0x80)); |
|
QColor textColor(color); |
|
textColor.setAlpha(0xC0); |
|
painter.setPen(textColor); |
|
painter.setFont(font); |
|
painter.drawText(QPointF(2.0f, overlayRect.height() - 4.0f), text); |
|
painter.end(); |
|
|
|
m_glShaderTextOverlay.initTexture(channelOverlayPixmap.toImage()); |
|
|
|
{ |
|
GLfloat vtx1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0}; |
|
GLfloat tex1[] = { |
|
0, 1, |
|
1, 1, |
|
1, 0, |
|
0, 0}; |
|
|
|
// float shiftX = glRect.width() - ((overlayRect.width() + 4.0f) / width()); |
|
// float shiftY = 4.0f / height(); |
|
float rectX = glRect.x() + shiftX - (leftHalf ? 0 : (overlayRect.width()+1)/width()); |
|
float rectY = glRect.y() + shiftY + (4.0f / height()) - (topHalf ? 0 : (overlayRect.height()+5)/height()); |
|
float rectW = overlayRect.width() / (float) width(); |
|
float rectH = overlayRect.height() / (float) height(); |
|
|
|
QMatrix4x4 mat; |
|
mat.setToIdentity(); |
|
mat.translate(-1.0f + 2.0f * rectX, 1.0f - 2.0f * rectY); |
|
mat.scale(2.0f * rectW, -2.0f * rectH); |
|
m_glShaderTextOverlay.drawSurface(mat, tex1, vtx1, 4); |
|
} |
|
} |
|
|
|
void GLSpectrumView::formatTextInfo(QString& info) |
|
{ |
|
QString spacing = " "; |
|
|
|
if (m_useCalibration) { |
|
info.append(tr("CAL:%1dB%2").arg(QString::number(m_calibrationShiftdB, 'f', 1)).arg(spacing)); |
|
} |
|
|
|
if (m_frequencyZoomFactor != 1.0f) { |
|
info.append(tr("%1x%2").arg(QString::number(m_frequencyZoomFactor, 'f', 1)).arg(spacing)); |
|
} |
|
|
|
if (getDisplayedSampleRate() == 0) |
|
{ |
|
info.append(tr("CF:%1 SP:%2%3").arg(getDisplayedCenterFrequency()).arg(getDisplayedSampleRate()).arg(spacing)); |
|
} |
|
else |
|
{ |
|
int64_t centerFrequency; |
|
int frequencySpan; |
|
getFrequencyZoom(centerFrequency, frequencySpan); |
|
info.append(tr("CF:%1%2").arg(displayScaled(centerFrequency, 'f', getPrecision(centerFrequency/frequencySpan), true)).arg(spacing)); |
|
info.append(tr("SP:%1%2").arg(displayScaled(frequencySpan, 'f', 3, true)).arg(spacing)); |
|
} |
|
|
|
if (m_displayRBW) |
|
{ |
|
float rbw = getDisplayedSampleRate() / (float) m_fftSize; |
|
info.append(tr("RBW:%1%2").arg(displayScaled(rbw, 'f', 3, true)).arg(spacing)); |
|
} |
|
} |
|
|
|
// Paint right side of status line, which contains peak power/freq and power/freq under cursor |
|
void GLSpectrumView::paintStatusLineRight() |
|
{ |
|
QString cursorInfo; |
|
QString cursorPower; |
|
QString cursorFreq; |
|
QString cursorPowerUnits; |
|
QString cursorFreqUnits; |
|
|
|
if (m_displayCursorStats && m_cursorOverSpectrum && m_currentSpectrum && (m_cursorFFTBin < m_fftSize)) |
|
{ |
|
Real power = m_currentSpectrum[m_cursorFFTBin]; |
|
|
|
cursorInfo = tr("Cur: "); |
|
cursorPower = displayPower(power, m_linear ? 'e' : 'f', m_linear ? 3 : 1); |
|
cursorFreq = displayFull(m_cursorFrequency); |
|
cursorPowerUnits = m_peakPowerUnits; |
|
cursorFreqUnits = "Hz"; |
|
} |
|
|
|
QString peakInfo; |
|
QString peakPower; |
|
QString peakFreq; |
|
QString peakPowerUnits; |
|
QString peakFreqUnits; |
|
|
|
if (m_displayPeakStats && m_currentSpectrum) |
|
{ |
|
float peakPowerValue; |
|
float peakFreqValue; |
|
findPeak(&m_currentSpectrum[m_fftMin], peakPowerValue, peakFreqValue); |
|
peakInfo = tr("Pk: "); |
|
peakPower = displayPower(peakPowerValue, m_linear ? 'e' : 'f', m_linear ? 3 : 1); |
|
peakFreq = displayFull(peakFreqValue); |
|
peakPowerUnits = m_peakPowerUnits; |
|
peakFreqUnits = "Hz"; |
|
} |
|
|
|
if (m_displayCursorStats || m_displayPeakStats) |
|
{ |
|
QString spacing = m_displayCursorStats && m_displayPeakStats ? " " : ""; |
|
|
|
drawTextsRight( |
|
{ |
|
cursorInfo, |
|
"", |
|
spacing, |
|
peakInfo, |
|
"" |
|
}, |
|
{ |
|
cursorPower, |
|
cursorFreq, |
|
"", |
|
peakPower, |
|
peakFreq |
|
}, |
|
{ |
|
m_peakPowerMaxStr, |
|
m_peakFrequencyMaxStr, |
|
"", |
|
m_peakPowerMaxStr, |
|
m_peakFrequencyMaxStr |
|
}, |
|
{ |
|
cursorPowerUnits, |
|
cursorFreqUnits, |
|
"", |
|
peakPowerUnits, |
|
peakFreqUnits |
|
} |
|
); |
|
} |
|
|
|
} |
|
|
|
bool GLSpectrumView::eventFilter(QObject *object, QEvent *event) |
|
{ |
|
if (event->type() == QEvent::KeyPress) |
|
{ |
|
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event); |
|
switch (keyEvent->key()) |
|
{ |
|
case Qt::Key_Up: |
|
if (keyEvent->modifiers() & Qt::ShiftModifier) { |
|
m_glShaderSpectrogram.lightRotateX(-5.0f); |
|
} else if (keyEvent->modifiers() & Qt::AltModifier) { |
|
m_glShaderSpectrogram.lightTranslateY(0.05); |
|
} else if (keyEvent->modifiers() & Qt::ControlModifier) { |
|
m_glShaderSpectrogram.translateY(0.05); |
|
} else { |
|
m_glShaderSpectrogram.rotateX(-5.0f); |
|
} |
|
break; |
|
case Qt::Key_Down: |
|
if (keyEvent->modifiers() & Qt::ShiftModifier) { |
|
m_glShaderSpectrogram.lightRotateX(5.0f); |
|
} else if (keyEvent->modifiers() & Qt::AltModifier) { |
|
m_glShaderSpectrogram.lightTranslateY(-0.05); |
|
} else if (keyEvent->modifiers() & Qt::ControlModifier) { |
|
m_glShaderSpectrogram.translateY(-0.05); |
|
} else { |
|
m_glShaderSpectrogram.rotateX(5.0f); |
|
} |
|
break; |
|
case Qt::Key_Left: |
|
if (keyEvent->modifiers() & Qt::ShiftModifier) { |
|
m_glShaderSpectrogram.lightRotateZ(5.0f); |
|
} else if (keyEvent->modifiers() & Qt::AltModifier) { |
|
m_glShaderSpectrogram.lightTranslateX(-0.05); |
|
} else if (keyEvent->modifiers() & Qt::ControlModifier) { |
|
m_glShaderSpectrogram.translateX(-0.05); |
|
} else { |
|
m_glShaderSpectrogram.rotateZ(5.0f); |
|
} |
|
break; |
|
case Qt::Key_Right: |
|
if (keyEvent->modifiers() & Qt::ShiftModifier) { |
|
m_glShaderSpectrogram.lightRotateZ(-5.0f); |
|
} else if (keyEvent->modifiers() & Qt::AltModifier) { |
|
m_glShaderSpectrogram.lightTranslateX(0.05); |
|
} else if (keyEvent->modifiers() & Qt::ControlModifier) { |
|
m_glShaderSpectrogram.translateX(0.05); |
|
} else { |
|
m_glShaderSpectrogram.rotateZ(-5.0f); |
|
} |
|
break; |
|
case Qt::Key_Equal: // So you don't need to press shift |
|
case Qt::Key_Plus: |
|
if (keyEvent->modifiers() & Qt::ControlModifier) { |
|
m_glShaderSpectrogram.userScaleZ(1.1f); |
|
} else { |
|
m_glShaderSpectrogram.verticalAngle(-1.0f); |
|
} |
|
break; |
|
case Qt::Key_Minus: |
|
if (keyEvent->modifiers() & Qt::ControlModifier) { |
|
m_glShaderSpectrogram.userScaleZ(0.9f); |
|
} else { |
|
m_glShaderSpectrogram.verticalAngle(1.0f); |
|
} |
|
break; |
|
case Qt::Key_R: |
|
m_glShaderSpectrogram.reset(); |
|
break; |
|
case Qt::Key_F: |
|
// Project straight down and scale to view, so it's a bit like 2D |
|
m_glShaderSpectrogram.reset(); |
|
m_glShaderSpectrogram.rotateX(45.0f); |
|
m_glShaderSpectrogram.verticalAngle(-9.0f); |
|
m_glShaderSpectrogram.userScaleZ(0.0f); |
|
break; |
|
} |
|
repaint(); // Force repaint in case acquisition is stopped |
|
return true; |
|
} |
|
else |
|
{ |
|
return QOpenGLWidget::eventFilter(object, event); |
|
} |
|
} |
|
|
|
void GLSpectrumView::setMemory(int memoryIdx, const SpectrumSettings::SpectrumMemory &memory) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
m_spectrumMemory[memoryIdx] = memory; |
|
m_displayChanged = true; |
|
} |
|
|
|
void GLSpectrumView::getDisplayedSpectrumCopy(std::vector<Real>& copy, bool zoomed) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (m_currentSpectrum) |
|
{ |
|
if (zoomed) { |
|
copy.assign(m_currentSpectrum + m_fftMin, m_currentSpectrum + m_fftMax); |
|
} else { |
|
copy.assign(m_currentSpectrum, m_currentSpectrum + m_fftSize); |
|
} |
|
} |
|
}
|
|
|