#include <glspectrum.h>

Inherits QGLWidget.

Collaboration diagram for GLSpectrum:

Classes
struct	ChannelMarkerState

class	MsgReportSampleRate

Public Member Functions
	GLSpectrum (QWidget *parent=NULL)

	~GLSpectrum ()

void	setCenterFrequency (qint64 frequency)

void	setSampleRate (qint32 sampleRate)

void	setTimingRate (qint32 timingRate)

void	setReferenceLevel (Real referenceLevel)

void	setPowerRange (Real powerRange)

void	setDecay (int decay)

void	setDecayDivisor (int decayDivisor)

void	setHistoStroke (int stroke)

void	setDisplayWaterfall (bool display)

void	setSsbSpectrum (bool ssbSpectrum)

void	setLsbDisplay (bool lsbDisplay)

void	setInvertedWaterfall (bool inv)

void	setDisplayMaxHold (bool display)

void	setDisplayCurrent (bool display)

void	setDisplayHistogram (bool display)

void	setDisplayGrid (bool display)

void	setDisplayGridIntensity (int intensity)

void	setDisplayTraceIntensity (int intensity)

void	setLinear (bool linear)

qint32	getSampleRate () const

void	addChannelMarker (ChannelMarker *channelMarker)

void	removeChannelMarker (ChannelMarker *channelMarker)

void	setMessageQueueToGUI (MessageQueue *messageQueue)

void	newSpectrum (const std::vector< Real > &spectrum, int fftSize)

void	clearSpectrumHistogram ()

Real	getWaterfallShare () const

void	setWaterfallShare (Real waterfallShare)

void	connectTimer (const QTimer &timer)

void	setDisplayedStream (bool sourceOrSink, int streamIndex)

Private Types
enum	CursorState { CSNormal, CSSplitter, CSSplitterMoving, CSChannel, CSChannelMoving }

Private Slots
void	cleanup ()

void	tick ()

void	channelMarkerChanged ()

void	channelMarkerDestroyed (QObject *object)

Private Member Functions
void	updateWaterfall (const std::vector< Real > &spectrum)

void	updateHistogram (const std::vector< Real > &spectrum)

void	initializeGL ()

void	resizeGL (int width, int height)

void	paintGL ()

void	stopDrag ()

void	applyChanges ()

void	mouseMoveEvent (QMouseEvent *event)

void	mousePressEvent (QMouseEvent *event)

void	mouseReleaseEvent (QMouseEvent *event)

void	wheelEvent (QWheelEvent *)

void	enterEvent (QEvent *event)

void	leaveEvent (QEvent *event)

Private Attributes
QList< ChannelMarkerState * >	m_channelMarkerStates

CursorState	m_cursorState

int	m_cursorChannel

QTimer	m_timer

QMutex	m_mutex

bool	m_mouseInside

bool	m_changesPending

qint64	m_centerFrequency

Real	m_referenceLevel

Real	m_powerRange

bool	m_linear

int	m_decay

quint32	m_sampleRate

quint32	m_timingRate

int	m_fftSize

bool	m_displayGrid

int	m_displayGridIntensity

int	m_displayTraceIntensity

bool	m_invertedWaterfall

std::vector< Real >	m_maxHold

bool	m_displayMaxHold

const std::vector< Real > *	m_currentSpectrum

bool	m_displayCurrent

Real	m_waterfallShare

int	m_leftMargin

QPixmap	m_leftMarginPixmap

QPixmap	m_frequencyPixmap

ScaleEngine	m_timeScale

ScaleEngine	m_powerScale

ScaleEngine	m_frequencyScale

QRect	m_frequencyScaleRect

QMatrix4x4	m_glFrequencyScaleBoxMatrix

QMatrix4x4	m_glLeftScaleBoxMatrix

QRgb	m_waterfallPalette [240]

QImage *	m_waterfallBuffer

int	m_waterfallBufferPos

int	m_waterfallTextureHeight

int	m_waterfallTexturePos

QMatrix4x4	m_glWaterfallBoxMatrix

bool	m_displayWaterfall

bool	m_ssbSpectrum

bool	m_lsbDisplay

QRgb	m_histogramPalette [240]

QImage *	m_histogramBuffer

quint8 *	m_histogram
	Spectrum phosphor matrix of FFT width and PSD height scaled to 100. values [0..239]. More...

int	m_decayDivisor

int	m_decayDivisorCount

int	m_histogramStroke

QMatrix4x4	m_glHistogramSpectrumMatrix

QMatrix4x4	m_glHistogramBoxMatrix

bool	m_displayHistogram

bool	m_displayChanged

bool	m_displaySourceOrSink

int	m_displayStreamIndex

GLShaderSimple	m_glShaderSimple

GLShaderTextured	m_glShaderLeftScale

GLShaderTextured	m_glShaderFrequencyScale

GLShaderTextured	m_glShaderWaterfall

GLShaderTextured	m_glShaderHistogram

int	m_matrixLoc

int	m_colorLoc

IncrementalArray< GLfloat >	m_q3TickTime

IncrementalArray< GLfloat >	m_q3TickFrequency

IncrementalArray< GLfloat >	m_q3TickPower

IncrementalArray< GLfloat >	m_q3FFT

MessageQueue *	m_messageQueueToGUI

Static Private Attributes
static const int	m_waterfallBufferHeight = 256

Detailed Description

Definition at line 43 of file glspectrum.h.

Member Enumeration Documentation

◆ CursorState

enum GLSpectrum::CursorState

private

Enumerator
CSNormal
CSSplitter
CSSplitterMoving
CSChannel
CSChannelMoving

Definition at line 122 of file glspectrum.h.

                      {
         CSNormal,
         CSSplitter,
         CSSplitterMoving,
         CSChannel,
         CSChannelMoving
     };

Constructor & Destructor Documentation

◆ GLSpectrum()

GLSpectrum::GLSpectrum ( QWidget * parent = NULL )

Definition at line 34 of file glspectrum.cpp.

References i, and Unit::Time.

                                       :
     QGLWidget(parent),
     m_cursorState(CSNormal),
     m_cursorChannel(0),
     m_mouseInside(false),
     m_changesPending(true),
     m_centerFrequency(100000000),
     m_referenceLevel(0),
     m_powerRange(100),
     m_linear(false),
     m_decay(1),
     m_sampleRate(500000),
     m_timingRate(1),
     m_fftSize(512),
     m_displayGrid(true),
     m_displayGridIntensity(5),
     m_displayTraceIntensity(50),
     m_invertedWaterfall(false),
     m_displayMaxHold(false),
     m_currentSpectrum(0),
     m_displayCurrent(false),
     m_leftMargin(0),
     m_waterfallBuffer(0),
     m_waterfallBufferPos(0),
     m_waterfallTextureHeight(-1),
     m_waterfallTexturePos(0),
     m_displayWaterfall(true),
     m_ssbSpectrum(false),
     m_lsbDisplay(false),
     m_histogramBuffer(0),
     m_histogram(0),
     m_displayHistogram(true),
     m_displayChanged(false),
     m_displaySourceOrSink(true),
     m_displayStreamIndex(0),
     m_matrixLoc(0),
     m_colorLoc(0),
     m_messageQueueToGUI(0)
 {
     setAutoFillBackground(false);
     setAttribute(Qt::WA_OpaquePaintEvent, true);
     setAttribute(Qt::WA_NoSystemBackground, true);
     setMouseTracking(true);
 
     setMinimumSize(200, 200);
 
     m_waterfallShare = 0.66;
 
     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);
 
     connect(&m_timer, SIGNAL(timeout()), this, SLOT(tick()));
     m_timer.start(50);
 }

◆ ~GLSpectrum()

GLSpectrum::~GLSpectrum ( )

Definition at line 153 of file glspectrum.cpp.

References cleanup(), m_changesPending, m_histogram, m_histogramBuffer, m_mutex, and m_waterfallBuffer.

 {
     cleanup();
 
     QMutexLocker mutexLocker(&m_mutex);
 
     m_changesPending = true;
 
     if(m_waterfallBuffer != NULL) {
         delete m_waterfallBuffer;
         m_waterfallBuffer = NULL;
     }
     if(m_histogramBuffer != NULL) {
         delete m_histogramBuffer;
         m_histogramBuffer = NULL;
     }
     if(m_histogram != NULL) {
         delete[] m_histogram;
         m_histogram = NULL;
     }
 }

Here is the call graph for this function:

Member Function Documentation

◆ addChannelMarker()

void GLSpectrum::addChannelMarker ( ChannelMarker * channelMarker )

Definition at line 315 of file glspectrum.cpp.

References channelMarkerChanged(), channelMarkerDestroyed(), m_changesPending, m_channelMarkerStates, m_mutex, and stopDrag().

Referenced by DeviceUISet::addChannelMarker().

 {
     QMutexLocker mutexLocker(&m_mutex);
 
     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();
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyChanges()

void GLSpectrum::applyChanges ( )

private

Definition at line 1031 of file glspectrum.cpp.

Referenced by paintGL().

 {
     m_changesPending = false;
 
     if(m_fftSize <= 0)
         return;
 
     QFontMetrics fm(font());
     int M = fm.width("-");
 
     int topMargin = fm.ascent() * 1.5;
     int bottomMargin = fm.ascent() * 1.5;
 
     int waterfallHeight = 0;
     int waterfallTop = 0;
     int frequencyScaleHeight = fm.height() * 3; // +1 line for marker frequency scale
     int frequencyScaleTop = 0;
     int histogramTop = 0;
     int histogramHeight = 20;
     //int m_leftMargin;
     int rightMargin = fm.width("000");
 
     // displays both histogram and waterfall
     if(m_displayWaterfall && (m_displayHistogram | m_displayMaxHold | m_displayCurrent))
     {
         waterfallHeight = height() * m_waterfallShare - 1;
 
         if(waterfallHeight < 0)
         {
             waterfallHeight = 0;
         }
 
         if(!m_invertedWaterfall)
         {
             waterfallTop = topMargin;
             frequencyScaleTop = waterfallTop + waterfallHeight + 1;
             histogramTop = waterfallTop + waterfallHeight + frequencyScaleHeight + 1;
             histogramHeight = height() - topMargin - waterfallHeight - frequencyScaleHeight - bottomMargin;
         }
         else
         {
             histogramTop = topMargin;
             histogramHeight = height() - topMargin - waterfallHeight - frequencyScaleHeight - bottomMargin;
             waterfallTop = histogramTop + histogramHeight + frequencyScaleHeight + 1;
             frequencyScaleTop = histogramTop + histogramHeight + 1;
         }
 
         m_timeScale.setSize(waterfallHeight);
 
         if(m_sampleRate > 0)
         {
             float scaleDiv = ((float)m_sampleRate / (float)m_timingRate) * (m_ssbSpectrum ? 2 : 1);
 
             if(!m_invertedWaterfall)
             {
                 m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, (waterfallHeight * m_fftSize) / scaleDiv, 0);
             }
             else
             {
                 m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, 0, (waterfallHeight * m_fftSize) / scaleDiv);
             }
         }
         else
         {
             m_timeScale.setRange(Unit::Time, 0, 1);
         }
 
         m_powerScale.setSize(histogramHeight);
 
         if (m_linear) {
             m_powerScale.setRange(Unit::Scientific, m_referenceLevel - m_powerRange, m_referenceLevel);
         } else {
             m_powerScale.setRange(Unit::Decibel, m_referenceLevel - m_powerRange, m_referenceLevel);
         }
 
         m_leftMargin = m_timeScale.getScaleWidth();
 
         if(m_powerScale.getScaleWidth() > m_leftMargin)
         {
             m_leftMargin = m_powerScale.getScaleWidth();
         }
 
         m_leftMargin += 2 * M;
 
         m_frequencyScale.setSize(width() - m_leftMargin - rightMargin);
         m_frequencyScale.setRange(Unit::Frequency, m_centerFrequency - m_sampleRate / 2, m_centerFrequency + m_sampleRate / 2);
         m_frequencyScale.setMakeOpposite(m_lsbDisplay);
 
         m_glWaterfallBoxMatrix.setToIdentity();
         m_glWaterfallBoxMatrix.translate(
             -1.0f + ((float)(2*m_leftMargin)   / (float) width()),
              1.0f - ((float)(2*waterfallTop) / (float) height())
         );
         m_glWaterfallBoxMatrix.scale(
             ((float) 2 * (width() - m_leftMargin - rightMargin)) / (float) width(),
             (float) (-2*waterfallHeight) / (float) height()
         );
 
         m_glHistogramBoxMatrix.setToIdentity();
         m_glHistogramBoxMatrix.translate(
             -1.0f + ((float)(2*m_leftMargin)   / (float) width()),
              1.0f - ((float)(2*histogramTop) / (float) height())
         );
         m_glHistogramBoxMatrix.scale(
             ((float) 2 * (width() - m_leftMargin - rightMargin)) / (float) width(),
             (float) (-2*histogramHeight) / (float) height()
         );
 
         m_glHistogramSpectrumMatrix.setToIdentity();
         m_glHistogramSpectrumMatrix.translate(
             -1.0f + ((float)(2*m_leftMargin)   / (float) width()),
              1.0f - ((float)(2*histogramTop) / (float) height())
         );
         m_glHistogramSpectrumMatrix.scale(
             ((float) 2 * (width() - m_leftMargin - rightMargin)) / ((float) width() * (float)(m_fftSize - 1)),
             ((float) 2*histogramHeight / height()) / m_powerRange
         );
 
         m_frequencyScaleRect = QRect(
             0,
             frequencyScaleTop,
             width(),
             frequencyScaleHeight
         );
 
         m_glFrequencyScaleBoxMatrix.setToIdentity();
         m_glFrequencyScaleBoxMatrix.translate (
             -1.0f,
              1.0f - ((float) 2*frequencyScaleTop / (float) height())
         );
         m_glFrequencyScaleBoxMatrix.scale (
             2.0f,
             (float) -2*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 only
     else if(m_displayWaterfall)
     {
         bottomMargin = frequencyScaleHeight;
         waterfallTop = topMargin;
         waterfallHeight = height() - topMargin - frequencyScaleHeight;
         frequencyScaleTop = topMargin + waterfallHeight + 1;
         histogramTop = 0;
 
         m_timeScale.setSize(waterfallHeight);
 
         if(m_sampleRate > 0)
         {
             float scaleDiv = ((float)m_sampleRate / (float)m_timingRate) * (m_ssbSpectrum ? 2 : 1);
 
             if(!m_invertedWaterfall)
             {
                 m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, (waterfallHeight * m_fftSize) / scaleDiv, 0);
             }
             else
             {
                 m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, 0, (waterfallHeight * m_fftSize) / scaleDiv);
             }
         }
         else
         {
             if(!m_invertedWaterfall)
             {
                 m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, 10, 0);
             }
             else
             {
                 m_timeScale.setRange(m_timingRate > 1 ? Unit::TimeHMS : Unit::Time, 0, 10);
             }
         }
 
         m_leftMargin = m_timeScale.getScaleWidth();
         m_leftMargin += 2 * M;
 
         m_frequencyScale.setSize(width() - m_leftMargin - rightMargin);
         m_frequencyScale.setRange(Unit::Frequency, m_centerFrequency - m_sampleRate / 2.0, m_centerFrequency + m_sampleRate / 2.0);
         m_frequencyScale.setMakeOpposite(m_lsbDisplay);
 
         m_glWaterfallBoxMatrix.setToIdentity();
         m_glWaterfallBoxMatrix.translate(
             -1.0f + ((float)(2*m_leftMargin)   / (float) width()),
              1.0f - ((float)(2*topMargin) / (float) height())
         );
         m_glWaterfallBoxMatrix.scale(
             ((float) 2 * (width() - m_leftMargin - rightMargin)) / (float) width(),
             (float) (-2*waterfallHeight) / (float) height()
         );
 
         m_frequencyScaleRect = QRect(
             0,
             frequencyScaleTop,
             width(),
             frequencyScaleHeight
         );
 
         m_glFrequencyScaleBoxMatrix.setToIdentity();
         m_glFrequencyScaleBoxMatrix.translate (
             -1.0f,
              1.0f - ((float) 2*frequencyScaleTop / (float) height())
         );
         m_glFrequencyScaleBoxMatrix.scale (
             2.0f,
             (float) -2*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)
     {
         bottomMargin = frequencyScaleHeight;
         frequencyScaleTop = height() - bottomMargin;
         histogramTop = topMargin - 1;
         waterfallHeight = 0;
         histogramHeight = height() - topMargin - frequencyScaleHeight;
 
         m_powerScale.setSize(histogramHeight);
         m_powerScale.setRange(Unit::Decibel, m_referenceLevel - m_powerRange, m_referenceLevel);
         m_leftMargin = m_powerScale.getScaleWidth();
         m_leftMargin += 2 * M;
 
         m_frequencyScale.setSize(width() - m_leftMargin - rightMargin);
         m_frequencyScale.setRange(Unit::Frequency, m_centerFrequency - m_sampleRate / 2, m_centerFrequency + m_sampleRate / 2);
         m_frequencyScale.setMakeOpposite(m_lsbDisplay);
 
         m_glHistogramSpectrumMatrix.setToIdentity();
         m_glHistogramSpectrumMatrix.translate(
             -1.0f + ((float)(2*m_leftMargin)   / (float) width()),
              1.0f - ((float)(2*histogramTop) / (float) height())
         );
         m_glHistogramSpectrumMatrix.scale(
             ((float) 2 * (width() - m_leftMargin - rightMargin)) / ((float) width() * (float)(m_fftSize - 1)),
             ((float) 2*(height() - topMargin - frequencyScaleHeight) / height()) / m_powerRange
         );
 
         m_glHistogramBoxMatrix.setToIdentity();
         m_glHistogramBoxMatrix.translate(
             -1.0f + ((float)(2*m_leftMargin)   / (float) width()),
              1.0f - ((float)(2*histogramTop) / (float) height())
         );
         m_glHistogramBoxMatrix.scale(
             ((float) 2 * (width() - m_leftMargin - rightMargin)) / (float) width(),
             (float) (-2*(height() - topMargin - frequencyScaleHeight)) / (float) height()
         );
 
         m_frequencyScaleRect = QRect(
             0,
             frequencyScaleTop,
             width(),
             frequencyScaleHeight
         );
 
         m_glFrequencyScaleBoxMatrix.setToIdentity();
         m_glFrequencyScaleBoxMatrix.translate (
             -1.0f,
              1.0f - ((float) 2*frequencyScaleTop / (float) height())
         );
         m_glFrequencyScaleBoxMatrix.scale (
             2.0f,
             (float) -2*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;
         waterfallHeight = 0;
     }
 
     // channel overlays
     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 = m_centerFrequency + dv->m_channelMarker->getCenterFrequency(); // marker center frequency
         dsbw = dv->m_channelMarker->getBandwidth();
 
         if (sidebands == ChannelMarker::usb) {
             nw = dv->m_channelMarker->getLowCutoff();     // negative bandwidth
             int bw = dv->m_channelMarker->getBandwidth() / 2;
             pw = (qreal) bw; // positive bandwidth
         } else if (sidebands == ChannelMarker::lsb) {
             pw = dv->m_channelMarker->getLowCutoff();
             int bw = dv->m_channelMarker->getBandwidth() / 2;
             nw = (qreal) bw;
         } else if (sidebands == ChannelMarker::vusb) {
             nw = -dv->m_channelMarker->getOppositeBandwidth(); // negative bandwidth
             pw = dv->m_channelMarker->getBandwidth(); // positive bandwidth
         } else if (sidebands == ChannelMarker::vlsb) {
             pw = dv->m_channelMarker->getOppositeBandwidth(); // positive bandwidth
             nw = -dv->m_channelMarker->getBandwidth(); // negative bandwidth
         } else {
             pw = dsbw / 2;
             nw = -pw;
         }
 
         // 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)m_sampleRate),
             -2.0f
         );
 
         dv->m_glMatrixDsbWaterfall = glMatrixDsb;
         dv->m_glMatrixDsbWaterfall.translate(
              0.0f,
              (float) waterfallTop / (float) height()
         );
         dv->m_glMatrixDsbWaterfall.scale(
             (float) (width() - m_leftMargin - rightMargin) / (float) width(),
             (float) waterfallHeight / (float) height()
         );
 
         dv->m_glMatrixDsbHistogram = glMatrixDsb;
         dv->m_glMatrixDsbHistogram.translate(
              0.0f,
              (float) histogramTop / (float) height()
         );
         dv->m_glMatrixDsbHistogram.scale(
             (float) (width() - m_leftMargin - rightMargin) / (float) width(),
             (float) 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 - rightMargin) / (float) width(),
             (float) 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)m_sampleRate),
             -2.0f
         );
 
         dv->m_glMatrixWaterfall = glMatrix;
         dv->m_glMatrixWaterfall.translate(
              0.0f,
              (float) waterfallTop / (float) height()
         );
         dv->m_glMatrixWaterfall.scale(
             (float) (width() - m_leftMargin - rightMargin) / (float) width(),
             (float) waterfallHeight / (float) height()
         );
 
         dv->m_glMatrixHistogram = glMatrix;
         dv->m_glMatrixHistogram.translate(
              0.0f,
              (float) histogramTop / (float) height()
         );
         dv->m_glMatrixHistogram.scale(
             (float) (width() - m_leftMargin - rightMargin) / (float) width(),
             (float) 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 - rightMargin) / (float) width(),
             (float) frequencyScaleHeight / (float) height()
         );
 
 
         /*
         dv->m_glRect.setRect(
             m_frequencyScale.getPosFromValue(m_centerFrequency + dv->m_channelMarker->getCenterFrequency() - dv->m_channelMarker->getBandwidth() / 2) / (float)(width() - m_leftMargin - rightMargin),
             0,
             (dv->m_channelMarker->getBandwidth() / (float)m_sampleRate),
             1);
         */
 
         if(m_displayHistogram || m_displayMaxHold || m_displayCurrent || m_displayWaterfall)
         {
             dv->m_rect.setRect(m_frequencyScale.getPosFromValue(xc) + m_leftMargin - 1,
             topMargin,
             5,
             height() - topMargin - bottomMargin);
         }
 
         /*
         if(m_displayHistogram || m_displayMaxHold || m_displayWaterfall) {
             dv->m_rect.setRect(m_frequencyScale.getPosFromValue(m_centerFrequency + dv->m_channelMarker->getCenterFrequency()) + m_leftMargin - 1,
             topMargin,
             5,
             height() - topMargin - bottomMargin);
         }
         */
     }
 
     // prepare left scales (time and power)
     {
         m_leftMarginPixmap = QPixmap(m_leftMargin - 1, height());
         m_leftMarginPixmap.fill(Qt::black);
         {
             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, waterfallTop + fm.ascent() + tick->textPos), tick->text);
                     }
                 }
             }
             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, histogramTop + histogramHeight - tick->textPos - 1), tick->text);
                     }
                 }
             }
         }
 
         m_glShaderLeftScale.initTexture(m_leftMarginPixmap.toImage());
     }
     // prepare frequency scale
     if(m_displayWaterfall || m_displayHistogram || m_displayMaxHold || m_displayCurrent){
         m_frequencyPixmap = QPixmap(width(), 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, 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->getStreamIndex() == m_displayStreamIndex))
                 {
                     qreal xc;
                     int shift;
                     //ChannelMarker::sidebands_t sidebands = dv->m_channelMarker->getSidebands();
                     xc = m_centerFrequency + dv->m_channelMarker->getCenterFrequency(); // marker center frequency
                     QString ftext;
                     switch (dv->m_channelMarker->getFrequencyScaleDisplayType())
                     {
                     case ChannelMarker::FScaleDisplay_freq:
                         ftext = QString::number((m_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((m_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.width(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());
     }
 
     bool fftSizeChanged = true;
 
     if(m_waterfallBuffer != NULL) {
         fftSizeChanged = m_waterfallBuffer->width() != m_fftSize;
     }
 
     bool windowSizeChanged = m_waterfallTextureHeight != waterfallHeight;
 
     if (fftSizeChanged || windowSizeChanged)
     {
         if(m_waterfallBuffer != 0) {
             delete m_waterfallBuffer;
         }
 
         m_waterfallBuffer = new QImage(m_fftSize, waterfallHeight, QImage::Format_ARGB32);
 
         m_waterfallBuffer->fill(qRgb(0x00, 0x00, 0x00));
         m_glShaderWaterfall.initTexture(*m_waterfallBuffer);
         m_waterfallBufferPos = 0;
     }
 
     if(fftSizeChanged)
     {
         if(m_histogramBuffer != NULL) {
             delete m_histogramBuffer;
             m_histogramBuffer = NULL;
         }
         if(m_histogram != NULL) {
             delete[] m_histogram;
             m_histogram = NULL;
         }
 
         m_histogramBuffer = new QImage(m_fftSize, 100, QImage::Format_RGB32);
 
         m_histogramBuffer->fill(qRgb(0x00, 0x00, 0x00));
         m_glShaderHistogram.initTexture(*m_histogramBuffer, QOpenGLTexture::ClampToEdge);
 
         m_histogram = new quint8[100 * m_fftSize];
         memset(m_histogram, 0x00, 100 * m_fftSize);
 
         m_q3FFT.allocate(2*m_fftSize);
     }
 
     if(fftSizeChanged || windowSizeChanged)
     {
         m_waterfallTextureHeight = waterfallHeight;
         m_waterfallTexturePos = 0;
     }
 
     m_q3TickTime.allocate(4*m_timeScale.getTickList().count());
     m_q3TickFrequency.allocate(4*m_frequencyScale.getTickList().count());
     m_q3TickPower.allocate(4*m_powerScale.getTickList().count());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ channelMarkerChanged

void GLSpectrum::channelMarkerChanged ( )

privateslot

Definition at line 1842 of file glspectrum.cpp.

References m_changesPending.

Referenced by addChannelMarker(), mouseMoveEvent(), and mousePressEvent().

 {
     m_changesPending = true;
     update();
 }

Here is the caller graph for this function:

◆ channelMarkerDestroyed

void GLSpectrum::channelMarkerDestroyed ( QObject * object )

privateslot

Definition at line 1848 of file glspectrum.cpp.

References removeChannelMarker().

Referenced by addChannelMarker().

 {
     removeChannelMarker((ChannelMarker*)object);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cleanup

void GLSpectrum::cleanup ( )

privateslot

Definition at line 1874 of file glspectrum.cpp.

References GLShaderSimple::cleanup(), GLShaderTextured::cleanup(), m_glShaderFrequencyScale, m_glShaderHistogram, m_glShaderLeftScale, m_glShaderSimple, and m_glShaderWaterfall.

Referenced by initializeGL(), and ~GLSpectrum().

 {
     //makeCurrent();
     m_glShaderSimple.cleanup();
     m_glShaderFrequencyScale.cleanup();
     m_glShaderHistogram.cleanup();
     m_glShaderLeftScale.cleanup();
     m_glShaderWaterfall.cleanup();
     //doneCurrent();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearSpectrumHistogram()

void GLSpectrum::clearSpectrumHistogram ( )

Definition at line 535 of file glspectrum.cpp.

References m_fftSize, m_histogram, and m_mutex.

Referenced by GLSpectrumGUI::on_clearSpectrum_clicked().

 {
     if(!m_mutex.tryLock(2))
         return;
 
     memset(m_histogram, 0x00, 100 * m_fftSize);
 
     m_mutex.unlock();
     update();
 }

Here is the caller graph for this function:

◆ connectTimer()

void GLSpectrum::connectTimer ( const QTimer & timer )

Definition at line 1866 of file glspectrum.cpp.

References m_timer, and tick().

Referenced by DeviceUISet::DeviceUISet().

 {
     qDebug() << "GLSpectrum::connectTimer";
     disconnect(&m_timer, SIGNAL(timeout()), this, SLOT(tick()));
     connect(&timer, SIGNAL(timeout()), this, SLOT(tick()));
     m_timer.stop();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enterEvent()

void GLSpectrum::enterEvent ( QEvent * event )

private

Definition at line 1820 of file glspectrum.cpp.

References m_mouseInside.

 {
     m_mouseInside = true;
     update();
     QGLWidget::enterEvent(event);
 }

◆ getSampleRate()

qint32 GLSpectrum::getSampleRate ( ) const

inline

Definition at line 86 of file glspectrum.h.

Referenced by GLSpectrumGUI::setAveragingToolitp().

86 { return m_sampleRate; }

GLSpectrum::m_sampleRate

quint32 m_sampleRate

Definition: glspectrum.h:143

Here is the caller graph for this function:

◆ getWaterfallShare()

Real GLSpectrum::getWaterfallShare ( ) const

inline

Definition at line 95 of file glspectrum.h.

Referenced by GLSpectrumGUI::serialize().

95 { return m_waterfallShare; }

GLSpectrum::m_waterfallShare

Real m_waterfallShare

Definition: glspectrum.h:158

Here is the caller graph for this function:

◆ initializeGL()

void GLSpectrum::initializeGL ( )

private

Definition at line 496 of file glspectrum.cpp.

References cleanup(), GLShaderSimple::initializeGL(), GLShaderTextured::initializeGL(), m_glShaderFrequencyScale, m_glShaderHistogram, m_glShaderLeftScale, m_glShaderSimple, and m_glShaderWaterfall.

 {
     QOpenGLContext *glCurrentContext =  QOpenGLContext::currentContext();
 
     if (glCurrentContext) {
         if (QOpenGLContext::currentContext()->isValid()) {
             qDebug() << "GLSpectrum::initializeGL: context:"
                 << " major: " << (QOpenGLContext::currentContext()->format()).majorVersion()
                 << " minor: " << (QOpenGLContext::currentContext()->format()).minorVersion()
                 << " ES: " << (QOpenGLContext::currentContext()->isOpenGLES() ? "yes" : "no");
         }
         else {
             qDebug() << "GLSpectrum::initializeGL: current context is invalid";
         }
     } else {
         qCritical() << "GLSpectrum::initializeGL: no current context";
         return;
     }
 
     connect(glCurrentContext, &QOpenGLContext::aboutToBeDestroyed, this, &GLSpectrum::cleanup); // TODO: when migrating to QOpenGLWidget
 
     QOpenGLFunctions *glFunctions = QOpenGLContext::currentContext()->functions();
     glFunctions->initializeOpenGLFunctions();
 
     //glDisable(GL_DEPTH_TEST);
     m_glShaderSimple.initializeGL();
     m_glShaderLeftScale.initializeGL();
     m_glShaderFrequencyScale.initializeGL();
     m_glShaderWaterfall.initializeGL();
     m_glShaderHistogram.initializeGL();
 }

Here is the call graph for this function:

◆ leaveEvent()

void GLSpectrum::leaveEvent ( QEvent * event )

private

Definition at line 1827 of file glspectrum.cpp.

References m_mouseInside.

 {
     m_mouseInside = false;
     update();
     QGLWidget::enterEvent(event);
 }

◆ mouseMoveEvent()

void GLSpectrum::mouseMoveEvent ( QMouseEvent * event )

private

Definition at line 1617 of file glspectrum.cpp.

References channelMarkerChanged(), CSChannel, CSChannelMoving, CSNormal, CSSplitter, CSSplitterMoving, ScaleEngine::getValueFromPos(), i, m_centerFrequency, m_changesPending, m_channelMarkerStates, m_cursorChannel, m_cursorState, m_displayCurrent, m_displayHistogram, m_displayMaxHold, m_displaySourceOrSink, m_displayStreamIndex, m_displayWaterfall, m_frequencyScale, m_frequencyScaleRect, m_invertedWaterfall, m_leftMarginPixmap, and m_waterfallShare.

 {
     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)
     {
         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;
 
         update();
         return;
     }
     else if (m_cursorState == CSChannelMoving)
     {
         Real freq = m_frequencyScale.getValueFromPos(event->x() - m_leftMarginPixmap.width() - 1) - m_centerFrequency;
 
         if (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getMovable()
             && (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink)
             && (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getStreamIndex() == 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->getStreamIndex() != 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())
             {
                 m_channelMarkerStates[i]->m_channelMarker->setHighlightedByCursor(false);
                 channelMarkerChanged();
             }
         }
     }
 
     if(m_cursorState == CSChannel)
     {
         setCursor(Qt::ArrowCursor);
         m_cursorState = CSNormal;
 
         return;
     }
 }

Here is the call graph for this function:

◆ mousePressEvent()

void GLSpectrum::mousePressEvent ( QMouseEvent * event )

private

Definition at line 1720 of file glspectrum.cpp.

References channelMarkerChanged(), CSChannel, CSChannelMoving, CSNormal, CSSplitter, CSSplitterMoving, ScaleEngine::getValueFromPos(), m_centerFrequency, m_channelMarkerStates, m_cursorChannel, m_cursorState, m_displaySourceOrSink, m_displayStreamIndex, m_frequencyScale, and m_leftMarginPixmap.

 {
     if(event->button() != 1)
         return;
 
     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))
     {
         grabMouse();
         setCursor(Qt::SizeHorCursor);
         m_cursorState = CSChannelMoving;
         m_cursorChannel = 0;
         Real freq = m_frequencyScale.getValueFromPos(event->x() - m_leftMarginPixmap.width() - 1) - m_centerFrequency;
 
         if (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getMovable()
             && (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getSourceOrSinkStream() == m_displaySourceOrSink)
             && (m_channelMarkerStates[m_cursorChannel]->m_channelMarker->getStreamIndex() == m_displayStreamIndex))
         {
             m_channelMarkerStates[m_cursorChannel]->m_channelMarker->setCenterFrequencyByCursor(freq);
             channelMarkerChanged();
         }
 
         return;
     }
 }

Here is the call graph for this function:

◆ mouseReleaseEvent()

void GLSpectrum::mouseReleaseEvent ( QMouseEvent * event )

private

Definition at line 1757 of file glspectrum.cpp.

References CSChannel, CSChannelMoving, CSSplitter, CSSplitterMoving, and m_cursorState.

 {
     if(m_cursorState == CSSplitterMoving) {
         releaseMouse();
         m_cursorState = CSSplitter;
     } else if(m_cursorState == CSChannelMoving) {
         releaseMouse();
         m_cursorState = CSChannel;
     }
 }

◆ newSpectrum()

void GLSpectrum::newSpectrum	(	const std::vector< Real > &	spectrum,
		int	fftSize
	)

Definition at line 343 of file glspectrum.cpp.

References m_changesPending, m_displayChanged, m_fftSize, m_mutex, updateHistogram(), and updateWaterfall().

Referenced by SpectrumVis::feed().

 {
     QMutexLocker mutexLocker(&m_mutex);
 
     m_displayChanged = true;
 
     if(m_changesPending) {
         m_fftSize = fftSize;
         return;
     }
 
     if(fftSize != m_fftSize) {
         m_fftSize = fftSize;
         m_changesPending = true;
         return;
     }
 
     updateWaterfall(spectrum);
     updateHistogram(spectrum);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ paintGL()

void GLSpectrum::paintGL ( )

private

Definition at line 546 of file glspectrum.cpp.

References applyChanges(), GLShaderSimple::drawContour(), GLShaderSimple::drawPolyline(), GLShaderSimple::drawSegments(), GLShaderSimple::drawSurface(), GLShaderTextured::drawSurface(), ChannelMarker::dsb, ChannelMarker::getColor(), ChannelMarker::getHighlighted(), ChannelMarker::getSidebands(), ScaleEngine::getSize(), ChannelMarker::getSourceOrSinkStream(), ChannelMarker::getStreamIndex(), ScaleEngine::getTickList(), ChannelMarker::getVisible(), i, IncrementalArray< T >::m_array, m_changesPending, GLSpectrum::ChannelMarkerState::m_channelMarker, m_channelMarkerStates, m_currentSpectrum, m_displayCurrent, m_displayGrid, m_displayGridIntensity, m_displayHistogram, m_displayMaxHold, m_displaySourceOrSink, m_displayStreamIndex, m_displayTraceIntensity, m_displayWaterfall, m_fftSize, m_frequencyScale, m_glFrequencyScaleBoxMatrix, m_glHistogramBoxMatrix, m_glHistogramSpectrumMatrix, m_glLeftScaleBoxMatrix, GLSpectrum::ChannelMarkerState::m_glMatrixDsbFreqScale, GLSpectrum::ChannelMarkerState::m_glMatrixDsbHistogram, GLSpectrum::ChannelMarkerState::m_glMatrixDsbWaterfall, GLSpectrum::ChannelMarkerState::m_glMatrixFreqScale, GLSpectrum::ChannelMarkerState::m_glMatrixHistogram, GLSpectrum::ChannelMarkerState::m_glMatrixWaterfall, m_glShaderFrequencyScale, m_glShaderHistogram, m_glShaderLeftScale, m_glShaderSimple, m_glShaderWaterfall, m_glWaterfallBoxMatrix, m_histogram, m_histogramBuffer, m_histogramPalette, m_invertedWaterfall, m_maxHold, m_mouseInside, m_mutex, m_powerRange, m_powerScale, m_q3FFT, m_q3TickFrequency, m_q3TickPower, m_q3TickTime, m_referenceLevel, m_timeScale, m_waterfallBuffer, m_waterfallBufferPos, m_waterfallTextureHeight, m_waterfallTexturePos, ScaleEngine::Tick::major, ScaleEngine::Tick::pos, GLShaderTextured::subTexture(), ScaleEngine::Tick::textSize, and tick().

 {
     if(!m_mutex.tryLock(2))
         return;
 
     if(m_changesPending)
         applyChanges();
 
     if(m_fftSize <= 0) {
         m_mutex.unlock();
         return;
     }
 
     QOpenGLFunctions *glFunctions = QOpenGLContext::currentContext()->functions();
     glFunctions->glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     glFunctions->glClear(GL_COLOR_BUFFER_BIT);
 
     // paint waterfall
     if (m_displayWaterfall)
     {
         {
             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_fftSize, 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_fftSize, breakLine,  m_waterfallBuffer->scanLine(0));
                 m_glShaderWaterfall.subTexture(0, 0, m_fftSize, 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->getStreamIndex() == 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);
         }
     }
 
     // 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_fftSize; 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_fftSize, 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->getStreamIndex() == 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);
                     }
                 }
             }
         }
 
         // 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_glHistogramBoxMatrix, color, q3, 4);
         }
     }
 
     // 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->getStreamIndex() == 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 max hold lines on top of histogram
     if (m_displayMaxHold)
     {
         if (m_maxHold.size() < (uint) m_fftSize) {
             m_maxHold.resize(m_fftSize);
         }
 
         for (int i = 0; i < m_fftSize; 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;
         }
         {
             GLfloat *q3 = m_q3FFT.m_array;
 
             for (int i = 0; i < m_fftSize; i++)
             {
                 Real v = m_maxHold[i] - m_referenceLevel;
 
                 if (v >= 0) {
                     v = 0;
                 } else if (v < -m_powerRange) {
                     v = -m_powerRange;
                 }
 
                 q3[2*i] = (Real) i;
                 q3[2*i+1] = v;
             }
 
             QVector4D color(1.0f, 0.0f, 0.0f, (float) m_displayTraceIntensity / 100.0f);
             m_glShaderSimple.drawPolyline(m_glHistogramSpectrumMatrix, color, q3, m_fftSize);
         }
     }
 
     // paint current spectrum line on top of histogram
     if ((m_displayCurrent) && m_currentSpectrum)
     {
         {
             Real bottom = -m_powerRange;
             GLfloat *q3 = m_q3FFT.m_array;
 
             for(int i = 0; i < m_fftSize; i++)
             {
                 Real v = (*m_currentSpectrum)[i] - m_referenceLevel;
 
                 if(v > 0) {
                     v = 0;
                 } else if(v < bottom) {
                     v = bottom;
                 }
 
                 q3[2*i] = (Real) i;
                 q3[2*i+1] = v;
             }
 
             QVector4D color(1.0f, 1.0f, 0.25f, (float) m_displayTraceIntensity / 100.0f);
             m_glShaderSimple.drawPolyline(m_glHistogramSpectrumMatrix, color, q3, m_fftSize);
         }
     }
 
     // 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 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);
         }
     }
 
     m_mutex.unlock();
 }

Here is the call graph for this function:

◆ removeChannelMarker()

void GLSpectrum::removeChannelMarker ( ChannelMarker * channelMarker )

Definition at line 327 of file glspectrum.cpp.

References i, m_changesPending, m_channelMarkerStates, m_mutex, and stopDrag().

Referenced by channelMarkerDestroyed().

 {
     QMutexLocker mutexLocker(&m_mutex);
 
     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();
             update();
             return;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resizeGL()

void GLSpectrum::resizeGL	(	int	width,
		int	height
	)

private

Definition at line 528 of file glspectrum.cpp.

References m_changesPending.

 {
     QOpenGLFunctions *glFunctions = QOpenGLContext::currentContext()->functions();
     glFunctions->glViewport(0, 0, width, height);
     m_changesPending = true;
 }

◆ setCenterFrequency()

void GLSpectrum::setCenterFrequency ( qint64 frequency )

Definition at line 175 of file glspectrum.cpp.

References m_centerFrequency, and m_changesPending.

 {
     m_centerFrequency = frequency;
     m_changesPending = true;
     update();
 }

Here is the caller graph for this function:

◆ setDecay()

void GLSpectrum::setDecay ( int decay )

Definition at line 196 of file glspectrum.cpp.

References m_decay.

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_decay_valueChanged().

 {
     m_decay = decay < 0 ? 0 : decay > 20 ? 20 : decay;
 }

Here is the caller graph for this function:

◆ setDecayDivisor()

void GLSpectrum::setDecayDivisor ( int decayDivisor )

Definition at line 201 of file glspectrum.cpp.

References m_decayDivisor.

Referenced by GLSpectrumGUI::applySettings().

 {
     m_decayDivisor = decayDivisor < 1 ? 1 : decayDivisor > 20 ? 20 : decayDivisor;
 }

Here is the caller graph for this function:

◆ setDisplayCurrent()

void GLSpectrum::setDisplayCurrent ( bool display )

Definition at line 264 of file glspectrum.cpp.

References m_changesPending, m_displayCurrent, and stopDrag().

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_current_toggled().

 {
     m_displayCurrent = display;
     m_changesPending = true;
     stopDrag();
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDisplayedStream()

void GLSpectrum::setDisplayedStream	(	bool	sourceOrSink,
		int	streamIndex
	)

inline

Definition at line 99 of file glspectrum.h.

Referenced by TestMIGui::on_spectrumSource_currentIndexChanged(), and TestMIGui::on_streamIndex_currentIndexChanged().

     {
         m_displaySourceOrSink = sourceOrSink;
         m_displayStreamIndex = streamIndex;
     }

Here is the caller graph for this function:

◆ setDisplayGrid()

void GLSpectrum::setDisplayGrid ( bool display )

Definition at line 280 of file glspectrum.cpp.

References m_displayGrid.

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_grid_toggled().

 {
     m_displayGrid = display;
     update();
 }

Here is the caller graph for this function:

◆ setDisplayGridIntensity()

void GLSpectrum::setDisplayGridIntensity ( int intensity )

Definition at line 286 of file glspectrum.cpp.

References m_displayGridIntensity.

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_gridIntensity_valueChanged().

 {
     m_displayGridIntensity = intensity;
     if (m_displayGridIntensity > 100) {
         m_displayGridIntensity = 100;
     } else if (m_displayGridIntensity < 0) {
         m_displayGridIntensity = 0;
     }
     update();
 }

Here is the caller graph for this function:

◆ setDisplayHistogram()

void GLSpectrum::setDisplayHistogram ( bool display )

Definition at line 272 of file glspectrum.cpp.

References m_changesPending, m_displayHistogram, and stopDrag().

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_histogram_toggled().

 {
     m_displayHistogram = display;
     m_changesPending = true;
     stopDrag();
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDisplayMaxHold()

void GLSpectrum::setDisplayMaxHold ( bool display )

Definition at line 256 of file glspectrum.cpp.

References m_changesPending, m_displayMaxHold, and stopDrag().

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_maxHold_toggled().

 {
     m_displayMaxHold = display;
     m_changesPending = true;
     stopDrag();
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDisplayTraceIntensity()

void GLSpectrum::setDisplayTraceIntensity ( int intensity )

Definition at line 297 of file glspectrum.cpp.

References m_displayTraceIntensity.

Referenced by GLSpectrumGUI::on_traceIntensity_valueChanged().

 {
     m_displayTraceIntensity = intensity;
     if (m_displayTraceIntensity > 100) {
         m_displayTraceIntensity = 100;
     } else if (m_displayTraceIntensity < 0) {
         m_displayTraceIntensity = 0;
     }
     update();
 }

Here is the caller graph for this function:

◆ setDisplayWaterfall()

void GLSpectrum::setDisplayWaterfall ( bool display )

Definition at line 228 of file glspectrum.cpp.

References m_changesPending, m_displayWaterfall, and stopDrag().

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_waterfall_toggled().

 {
     m_displayWaterfall = display;
     m_changesPending = true;
     stopDrag();
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setHistoStroke()

void GLSpectrum::setHistoStroke ( int stroke )

Definition at line 206 of file glspectrum.cpp.

References m_histogramStroke.

Referenced by GLSpectrumGUI::applySettings().

 {
     m_histogramStroke = stroke < 1 ? 1 : stroke > 60 ? 60 : stroke;
 }

Here is the caller graph for this function:

◆ setInvertedWaterfall()

void GLSpectrum::setInvertedWaterfall ( bool inv )

Definition at line 248 of file glspectrum.cpp.

References m_changesPending, m_invertedWaterfall, and stopDrag().

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_invert_toggled().

 {
     m_invertedWaterfall = inv;
     m_changesPending = true;
     stopDrag();
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setLinear()

void GLSpectrum::setLinear ( bool linear )

Definition at line 308 of file glspectrum.cpp.

References m_changesPending, and m_linear.

Referenced by GLSpectrumGUI::applySettings(), and GLSpectrumGUI::on_linscale_toggled().

 {
     m_linear = linear;
     m_changesPending = true;
     update();
 }

Here is the caller graph for this function:

◆ setLsbDisplay()

void GLSpectrum::setLsbDisplay ( bool lsbDisplay )

Definition at line 242 of file glspectrum.cpp.

References m_lsbDisplay.

 {
     m_lsbDisplay = lsbDisplay;
     update();
 }

◆ setMessageQueueToGUI()

void GLSpectrum::setMessageQueueToGUI ( MessageQueue * messageQueue )

inline

Definition at line 90 of file glspectrum.h.

Referenced by GLSpectrumGUI::setBuddies().

90 { m_messageQueueToGUI = messageQueue; }

GLSpectrum::m_messageQueueToGUI

MessageQueue * m_messageQueueToGUI

Definition: glspectrum.h:205

Here is the caller graph for this function:

◆ setPowerRange()

void GLSpectrum::setPowerRange ( Real powerRange )

Definition at line 189 of file glspectrum.cpp.

References m_changesPending, and m_powerRange.

Referenced by GLSpectrumGUI::on_levelRange_currentIndexChanged(), GLSpectrumGUI::on_linscale_toggled(), and GLSpectrumGUI::on_refLevel_currentIndexChanged().

 {
     m_powerRange = powerRange;
     m_changesPending = true;
     update();
 }

Here is the caller graph for this function:

◆ setReferenceLevel()

void GLSpectrum::setReferenceLevel ( Real referenceLevel )

Definition at line 182 of file glspectrum.cpp.

References m_changesPending, and m_referenceLevel.

Referenced by GLSpectrumGUI::on_levelRange_currentIndexChanged(), GLSpectrumGUI::on_linscale_toggled(), and GLSpectrumGUI::on_refLevel_currentIndexChanged().

 {
     m_referenceLevel = referenceLevel;
     m_changesPending = true;
     update();
 }

Here is the caller graph for this function:

◆ setSampleRate()

void GLSpectrum::setSampleRate ( qint32 sampleRate )

Definition at line 211 of file glspectrum.cpp.

References m_changesPending, m_messageQueueToGUI, m_sampleRate, and MessageQueue::push().

 {
     m_sampleRate = sampleRate;
     if (m_messageQueueToGUI) {
         m_messageQueueToGUI->push(new MsgReportSampleRate(m_sampleRate));
     }
     m_changesPending = true;
     update();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSsbSpectrum()

void GLSpectrum::setSsbSpectrum ( bool ssbSpectrum )

Definition at line 236 of file glspectrum.cpp.

References m_ssbSpectrum.

 {
     m_ssbSpectrum = ssbSpectrum;
     update();
 }

◆ setTimingRate()

void GLSpectrum::setTimingRate ( qint32 timingRate )

Definition at line 221 of file glspectrum.cpp.

References m_changesPending, and m_timingRate.

Referenced by GLSpectrumGUI::on_averaging_currentIndexChanged(), and GLSpectrumGUI::on_averagingMode_currentIndexChanged().

 {
     m_timingRate = timingRate;
     m_changesPending = true;
     update();
 }

Here is the caller graph for this function:

◆ setWaterfallShare()

void GLSpectrum::setWaterfallShare ( Real waterfallShare )

Definition at line 1853 of file glspectrum.cpp.

References m_changesPending, and m_waterfallShare.

Referenced by GLSpectrumGUI::deserialize().

 {
     if (waterfallShare < 0.1f) {
         m_waterfallShare = 0.1f;
     }
     else if (waterfallShare > 0.8f) {
         m_waterfallShare = 0.8f;
     } else {
         m_waterfallShare = waterfallShare;
     }
     m_changesPending = true;
 }

Here is the caller graph for this function:

◆ stopDrag()

void GLSpectrum::stopDrag ( )

private

Definition at line 1021 of file glspectrum.cpp.

References CSChannelMoving, CSNormal, CSSplitterMoving, and m_cursorState.

Referenced by addChannelMarker(), removeChannelMarker(), setDisplayCurrent(), setDisplayHistogram(), setDisplayMaxHold(), setDisplayWaterfall(), and setInvertedWaterfall().

 {
     if(m_cursorState != CSNormal) {
         if((m_cursorState == CSSplitterMoving) || (m_cursorState == CSChannelMoving))
             releaseMouse();
         setCursor(Qt::ArrowCursor);
         m_cursorState = CSNormal;
     }
 }

Here is the caller graph for this function:

◆ tick

void GLSpectrum::tick ( )

privateslot

Definition at line 1834 of file glspectrum.cpp.

References m_displayChanged.

Referenced by applyChanges(), connectTimer(), and paintGL().

 {
     if(m_displayChanged) {
         m_displayChanged = false;
         update();
     }
 }

Here is the caller graph for this function:

◆ updateHistogram()

void GLSpectrum::updateHistogram ( const std::vector< Real > & spectrum )

private

Definition at line 383 of file glspectrum.cpp.

References i, m_currentSpectrum, m_decay, m_decayDivisor, m_decayDivisorCount, m_displayHistogram, m_displayMaxHold, m_fftSize, m_histogram, m_histogramStroke, m_powerRange, and m_referenceLevel.

Referenced by newSpectrum().

 {
     quint8* b = m_histogram;
     int fftMulSize = 100 * m_fftSize;
 
     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;
         }
     }
 
     m_currentSpectrum = &spectrum; // Store spectrum for current spectrum line display
 
 #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 < m_fftSize; i++)
     {
         int v = (int)((spectrum[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
 }

Here is the caller graph for this function:

◆ updateWaterfall()

void GLSpectrum::updateWaterfall ( const std::vector< Real > & spectrum )

private

Definition at line 364 of file glspectrum.cpp.

References i, m_fftSize, m_powerRange, m_referenceLevel, m_waterfallBuffer, m_waterfallBufferPos, and m_waterfallPalette.

Referenced by newSpectrum().

 {
     if(m_waterfallBufferPos < m_waterfallBuffer->height()) {
         quint32* pix = (quint32*)m_waterfallBuffer->scanLine(m_waterfallBufferPos);
 
         for(int i = 0; i < m_fftSize; i++) {
             int v = (int)((spectrum[i] - m_referenceLevel) * 2.4 * 100.0 / m_powerRange + 240.0);
             if(v > 239)
                 v = 239;
             else if(v < 0)
                 v = 0;
 
             *pix++ = m_waterfallPalette[(int)v];
         }
 
         m_waterfallBufferPos++;
     }
 }

Here is the caller graph for this function:

◆ wheelEvent()

void GLSpectrum::wheelEvent ( QWheelEvent * event )

private

Definition at line 1768 of file glspectrum.cpp.

References ScaleEngine::getPosFromValue(), ScaleEngine::getSize(), i, m_centerFrequency, m_channelMarkerStates, m_displaySourceOrSink, m_displayStreamIndex, m_frequencyScale, and m_leftMargin.

 {
     int mul;
 
     if (event->modifiers() & Qt::ShiftModifier) {
         mul = 100;
     } else if (event->modifiers() & Qt::ControlModifier) {
         mul = 10;
     } else {
         mul = 1;
     }
 
     for (int i = 0; i < m_channelMarkerStates.size(); ++i)
     {
         if ((m_channelMarkerStates[i]->m_channelMarker->getSourceOrSinkStream() != m_displaySourceOrSink)
             || (m_channelMarkerStates[i]->m_channelMarker->getStreamIndex() != m_displayStreamIndex))
         {
             continue;
         }
 
         if (m_channelMarkerStates[i]->m_rect.contains(event->pos()))
         {
             int freq = m_channelMarkerStates[i]->m_channelMarker->getCenterFrequency();
 
             if (event->delta() > 0) {
                 freq += 10 * mul;
             } else if (event->delta() < 0) {
                 freq -= 10 * mul;
             }
 
             // calculate scale relative cursor position for new frequency
             float x_pos = m_frequencyScale.getPosFromValue(m_centerFrequency + 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);
             }
         }
     }
 }

Here is the call graph for this function:

Member Data Documentation

◆ m_centerFrequency

qint64 GLSpectrum::m_centerFrequency

private

Definition at line 138 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), mousePressEvent(), setCenterFrequency(), and wheelEvent().

◆ m_changesPending

bool GLSpectrum::m_changesPending

private

◆ m_channelMarkerStates

QList<ChannelMarkerState*> GLSpectrum::m_channelMarkerStates

private

Definition at line 120 of file glspectrum.h.

Referenced by addChannelMarker(), applyChanges(), mouseMoveEvent(), mousePressEvent(), paintGL(), removeChannelMarker(), and wheelEvent().

◆ m_colorLoc

int GLSpectrum::m_colorLoc

private

Definition at line 199 of file glspectrum.h.

◆ m_currentSpectrum

const std::vector<Real>* GLSpectrum::m_currentSpectrum

private

Definition at line 155 of file glspectrum.h.

Referenced by paintGL(), and updateHistogram().

◆ m_cursorChannel

int GLSpectrum::m_cursorChannel

private

Definition at line 131 of file glspectrum.h.

Referenced by mouseMoveEvent(), and mousePressEvent().

◆ m_cursorState

CursorState GLSpectrum::m_cursorState

private

Definition at line 130 of file glspectrum.h.

Referenced by mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), and stopDrag().

◆ m_decay

int GLSpectrum::m_decay

private

Definition at line 142 of file glspectrum.h.

Referenced by setDecay(), and updateHistogram().

◆ m_decayDivisor

int GLSpectrum::m_decayDivisor

private

Definition at line 183 of file glspectrum.h.

Referenced by setDecayDivisor(), and updateHistogram().

◆ m_decayDivisorCount

int GLSpectrum::m_decayDivisorCount

private

Definition at line 184 of file glspectrum.h.

Referenced by updateHistogram().

◆ m_displayChanged

bool GLSpectrum::m_displayChanged

private

Definition at line 189 of file glspectrum.h.

Referenced by newSpectrum(), and tick().

◆ m_displayCurrent

bool GLSpectrum::m_displayCurrent

private

Definition at line 156 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), paintGL(), and setDisplayCurrent().

◆ m_displayGrid

bool GLSpectrum::m_displayGrid

private

Definition at line 148 of file glspectrum.h.

Referenced by paintGL(), and setDisplayGrid().

◆ m_displayGridIntensity

int GLSpectrum::m_displayGridIntensity

private

Definition at line 149 of file glspectrum.h.

Referenced by paintGL(), and setDisplayGridIntensity().

◆ m_displayHistogram

bool GLSpectrum::m_displayHistogram

private

Definition at line 188 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), paintGL(), setDisplayHistogram(), and updateHistogram().

◆ m_displayMaxHold

bool GLSpectrum::m_displayMaxHold

private

Definition at line 154 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), paintGL(), setDisplayMaxHold(), and updateHistogram().

◆ m_displaySourceOrSink

bool GLSpectrum::m_displaySourceOrSink

private

Definition at line 190 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), mousePressEvent(), paintGL(), and wheelEvent().

◆ m_displayStreamIndex

int GLSpectrum::m_displayStreamIndex

private

Definition at line 191 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), mousePressEvent(), paintGL(), and wheelEvent().

◆ m_displayTraceIntensity

int GLSpectrum::m_displayTraceIntensity

private

Definition at line 150 of file glspectrum.h.

Referenced by paintGL(), and setDisplayTraceIntensity().

◆ m_displayWaterfall

bool GLSpectrum::m_displayWaterfall

private

Definition at line 176 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), paintGL(), and setDisplayWaterfall().

◆ m_fftSize

int GLSpectrum::m_fftSize

private

Definition at line 146 of file glspectrum.h.

Referenced by applyChanges(), clearSpectrumHistogram(), newSpectrum(), paintGL(), updateHistogram(), and updateWaterfall().

◆ m_frequencyPixmap

QPixmap GLSpectrum::m_frequencyPixmap

private

Definition at line 162 of file glspectrum.h.

Referenced by applyChanges().

◆ m_frequencyScale

ScaleEngine GLSpectrum::m_frequencyScale

private

Definition at line 165 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), mousePressEvent(), paintGL(), and wheelEvent().

◆ m_frequencyScaleRect

QRect GLSpectrum::m_frequencyScaleRect

private

Definition at line 166 of file glspectrum.h.

Referenced by applyChanges(), and mouseMoveEvent().

◆ m_glFrequencyScaleBoxMatrix

QMatrix4x4 GLSpectrum::m_glFrequencyScaleBoxMatrix

private

Definition at line 167 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_glHistogramBoxMatrix

QMatrix4x4 GLSpectrum::m_glHistogramBoxMatrix

private

Definition at line 187 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_glHistogramSpectrumMatrix

QMatrix4x4 GLSpectrum::m_glHistogramSpectrumMatrix

private

Definition at line 186 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_glLeftScaleBoxMatrix

QMatrix4x4 GLSpectrum::m_glLeftScaleBoxMatrix

private

Definition at line 168 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_glShaderFrequencyScale

GLShaderTextured GLSpectrum::m_glShaderFrequencyScale

private

Definition at line 195 of file glspectrum.h.

Referenced by applyChanges(), cleanup(), initializeGL(), and paintGL().

◆ m_glShaderHistogram

GLShaderTextured GLSpectrum::m_glShaderHistogram

private

Definition at line 197 of file glspectrum.h.

Referenced by applyChanges(), cleanup(), initializeGL(), and paintGL().

◆ m_glShaderLeftScale

GLShaderTextured GLSpectrum::m_glShaderLeftScale

private

Definition at line 194 of file glspectrum.h.

Referenced by applyChanges(), cleanup(), initializeGL(), and paintGL().

◆ m_glShaderSimple

GLShaderSimple GLSpectrum::m_glShaderSimple

private

Definition at line 193 of file glspectrum.h.

Referenced by cleanup(), initializeGL(), and paintGL().

◆ m_glShaderWaterfall

GLShaderTextured GLSpectrum::m_glShaderWaterfall

private

Definition at line 196 of file glspectrum.h.

Referenced by applyChanges(), cleanup(), initializeGL(), and paintGL().

◆ m_glWaterfallBoxMatrix

QMatrix4x4 GLSpectrum::m_glWaterfallBoxMatrix

private

Definition at line 175 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_histogram

quint8* GLSpectrum::m_histogram

private

Spectrum phosphor matrix of FFT width and PSD height scaled to 100. values [0..239].

Definition at line 182 of file glspectrum.h.

Referenced by applyChanges(), clearSpectrumHistogram(), paintGL(), updateHistogram(), and ~GLSpectrum().

◆ m_histogramBuffer

QImage* GLSpectrum::m_histogramBuffer

private

Definition at line 181 of file glspectrum.h.

Referenced by applyChanges(), paintGL(), and ~GLSpectrum().

◆ m_histogramPalette

QRgb GLSpectrum::m_histogramPalette[240]

private

Definition at line 180 of file glspectrum.h.

Referenced by paintGL().

◆ m_histogramStroke

int GLSpectrum::m_histogramStroke

private

Definition at line 185 of file glspectrum.h.

Referenced by setHistoStroke(), and updateHistogram().

◆ m_invertedWaterfall

bool GLSpectrum::m_invertedWaterfall

private

Definition at line 151 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), paintGL(), and setInvertedWaterfall().

◆ m_leftMargin

int GLSpectrum::m_leftMargin

private

Definition at line 160 of file glspectrum.h.

Referenced by applyChanges(), and wheelEvent().

◆ m_leftMarginPixmap

QPixmap GLSpectrum::m_leftMarginPixmap

private

Definition at line 161 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), and mousePressEvent().

◆ m_linear

bool GLSpectrum::m_linear

private

Definition at line 141 of file glspectrum.h.

Referenced by applyChanges(), and setLinear().

◆ m_lsbDisplay

bool GLSpectrum::m_lsbDisplay

private

Definition at line 178 of file glspectrum.h.

Referenced by applyChanges(), and setLsbDisplay().

◆ m_matrixLoc

int GLSpectrum::m_matrixLoc

private

Definition at line 198 of file glspectrum.h.

◆ m_maxHold

std::vector<Real> GLSpectrum::m_maxHold

private

Definition at line 153 of file glspectrum.h.

Referenced by paintGL().

◆ m_messageQueueToGUI

MessageQueue* GLSpectrum::m_messageQueueToGUI

private

Definition at line 205 of file glspectrum.h.

Referenced by setSampleRate().

◆ m_mouseInside

bool GLSpectrum::m_mouseInside

private

Definition at line 135 of file glspectrum.h.

Referenced by enterEvent(), leaveEvent(), and paintGL().

◆ m_mutex

QMutex GLSpectrum::m_mutex

private

Definition at line 134 of file glspectrum.h.

Referenced by addChannelMarker(), clearSpectrumHistogram(), newSpectrum(), paintGL(), removeChannelMarker(), and ~GLSpectrum().

◆ m_powerRange

Real GLSpectrum::m_powerRange

private

Definition at line 140 of file glspectrum.h.

Referenced by applyChanges(), paintGL(), setPowerRange(), updateHistogram(), and updateWaterfall().

◆ m_powerScale

ScaleEngine GLSpectrum::m_powerScale

private

Definition at line 164 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_q3FFT

IncrementalArray<GLfloat> GLSpectrum::m_q3FFT

private

Definition at line 203 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_q3TickFrequency

IncrementalArray<GLfloat> GLSpectrum::m_q3TickFrequency

private

Definition at line 201 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_q3TickPower

IncrementalArray<GLfloat> GLSpectrum::m_q3TickPower

private

Definition at line 202 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_q3TickTime

IncrementalArray<GLfloat> GLSpectrum::m_q3TickTime

private

Definition at line 200 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_referenceLevel

Real GLSpectrum::m_referenceLevel

private

Definition at line 139 of file glspectrum.h.

Referenced by applyChanges(), paintGL(), setReferenceLevel(), updateHistogram(), and updateWaterfall().

◆ m_sampleRate

quint32 GLSpectrum::m_sampleRate

private

Definition at line 143 of file glspectrum.h.

Referenced by applyChanges(), and setSampleRate().

◆ m_ssbSpectrum

bool GLSpectrum::m_ssbSpectrum

private

Definition at line 177 of file glspectrum.h.

Referenced by applyChanges(), and setSsbSpectrum().

◆ m_timer

QTimer GLSpectrum::m_timer

private

Definition at line 133 of file glspectrum.h.

Referenced by connectTimer().

◆ m_timeScale

ScaleEngine GLSpectrum::m_timeScale

private

Definition at line 163 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_timingRate

quint32 GLSpectrum::m_timingRate

private

Definition at line 144 of file glspectrum.h.

Referenced by applyChanges(), and setTimingRate().

◆ m_waterfallBuffer

QImage* GLSpectrum::m_waterfallBuffer

private

Definition at line 171 of file glspectrum.h.

Referenced by applyChanges(), paintGL(), updateWaterfall(), and ~GLSpectrum().

◆ m_waterfallBufferHeight

const int GLSpectrum::m_waterfallBufferHeight = 256

staticprivate

Definition at line 207 of file glspectrum.h.

◆ m_waterfallBufferPos

int GLSpectrum::m_waterfallBufferPos

private

Definition at line 172 of file glspectrum.h.

Referenced by applyChanges(), paintGL(), and updateWaterfall().

◆ m_waterfallPalette

QRgb GLSpectrum::m_waterfallPalette[240]

private

Definition at line 170 of file glspectrum.h.

Referenced by updateWaterfall().

◆ m_waterfallShare

Real GLSpectrum::m_waterfallShare

private

Definition at line 158 of file glspectrum.h.

Referenced by applyChanges(), mouseMoveEvent(), and setWaterfallShare().

◆ m_waterfallTextureHeight

int GLSpectrum::m_waterfallTextureHeight

private

Definition at line 173 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

◆ m_waterfallTexturePos

int GLSpectrum::m_waterfallTexturePos

private

Definition at line 174 of file glspectrum.h.

Referenced by applyChanges(), and paintGL().

The documentation for this class was generated from the following files:

sdrgui/gui/glspectrum.h
sdrgui/gui/glspectrum.cpp

Classes

Public Member Functions

Private Types

Private Slots

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CursorState

Constructor & Destructor Documentation

◆ GLSpectrum()

◆ ~GLSpectrum()

Member Function Documentation

◆ addChannelMarker()

◆ applyChanges()

◆ channelMarkerChanged

◆ channelMarkerDestroyed

◆ cleanup

◆ clearSpectrumHistogram()

◆ connectTimer()

◆ enterEvent()

◆ getSampleRate()

◆ getWaterfallShare()

◆ initializeGL()

◆ leaveEvent()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ newSpectrum()

◆ paintGL()

◆ removeChannelMarker()

◆ resizeGL()

◆ setCenterFrequency()

◆ setDecay()

◆ setDecayDivisor()

◆ setDisplayCurrent()

◆ setDisplayedStream()

◆ setDisplayGrid()

◆ setDisplayGridIntensity()

◆ setDisplayHistogram()

◆ setDisplayMaxHold()

◆ setDisplayTraceIntensity()

◆ setDisplayWaterfall()

◆ setHistoStroke()

◆ setInvertedWaterfall()

◆ setLinear()

◆ setLsbDisplay()

◆ setMessageQueueToGUI()

◆ setPowerRange()

◆ setReferenceLevel()

◆ setSampleRate()

◆ setSsbSpectrum()

◆ setTimingRate()

◆ setWaterfallShare()

◆ stopDrag()

◆ tick

◆ updateHistogram()

◆ updateWaterfall()

◆ wheelEvent()

Member Data Documentation

◆ m_centerFrequency

◆ m_changesPending

◆ m_channelMarkerStates

◆ m_colorLoc

◆ m_currentSpectrum

◆ m_cursorChannel

◆ m_cursorState

◆ m_decay

◆ m_decayDivisor

◆ m_decayDivisorCount

◆ m_displayChanged

◆ m_displayCurrent

◆ m_displayGrid

◆ m_displayGridIntensity

◆ m_displayHistogram

◆ m_displayMaxHold

◆ m_displaySourceOrSink

◆ m_displayStreamIndex

◆ m_displayTraceIntensity