QWaterfallDisplay Class Reference

#include <qwaterfalldisplay.h>

Inherits QFrame.

Public Types
enum	Resizestyle {   Scale, ScaleAspect, ScaleEven, Cut,   CutMixed }

Public Slots
void	setColumns (int cols)
void	setRows (int rows)
void	setColumnsRows (int cols, int rows)
int	columns () const
int	rows () const
void	setResizestyle (Resizestyle resizestyle)
Resizestyle	resizestyle () const
void	setBackColor (QColor back)
QColor	backColor () const
void	setMaxValue (double max)
void	setMinValue (double min)
void	setMaxMinValue (double max, double min)
double	maxValue () const
double	minValue () const
void	pushData (const std::vector< float > &new_data)
void	pushDataFloat (const float *new_data, int elements)
void	pushDataQList (const QList< float > &new_data)
void	pushDataUint8 (const char *new_data, int length)
void	pushDataUint16 (const char *new_data, int length)
void	pushDataUint32 (const char *new_data, int length)
void	clearData ()
void	redrawData ()
void	pauseDrawing (bool onoff)

Signals
void	rowsChanged (uint)
void	columnsChanged (uint)
void	minChanged (double)
void	maxChanged (double)
void	drawingPaused ()
void	drawingStarted ()
void	drawing (bool)
void	paused (bool)

Public Member Functions
	QWaterfallDisplay (int rows=1, int columns=1, QWidget *parent=0)
	~QWaterfallDisplay ()
QSize	minimumSizeHint ()
QSize	sizeHint ()
bool	isPaused ()
bool	isDrawing ()

Protected Member Functions
void	paintEvent (QPaintEvent *event)
void	resizeEvent (QResizeEvent *event)

Properties
uint	rows
uint	columns
Resizestyle	resizestyle
QColor	backColor
double	maxValue
double	minValue

Detailed Description

Definition at line 27 of file qwaterfalldisplay.h.

Member Enumeration Documentation

Resizestyle

enum QWaterfallDisplay::Resizestyle

Enumerator
Scale
ScaleAspect
ScaleEven
Cut
CutMixed

Definition at line 40 of file qwaterfalldisplay.h.

                     {
            Scale,       // Just Scales (could be akward)
            ScaleAspect, // Scales, keeping the aspect ratio and centers
            ScaleEven,   // Scales only n times where widgetsize > n*rows and then centers for n<1 scales like ScaleAspect
            Cut,         // Just cuts if the widget is smaller and centers if bigger
            CutMixed     // Scales cols even and cuts rows
    };

Constructor & Destructor Documentation

QWaterfallDisplay()

QWaterfallDisplay::QWaterfallDisplay ( int  rows = 1, int  columns = 1, QWidget *  parent = 0  )

explicit

Definition at line 15 of file qwaterfalldisplay.cc.

                                                                           :
    QFrame(parent), m_cols(columns), m_rows(rows), m_resizes(ScaleAspect), back_color(QColor("black")),
    m_max(1.0), m_min(0.0),
    dirty_lines(0), widget_resized(true), redraw_all(true), is_drawing(true),
    m_size_hint(0,0), m_minimum_size(0,0),
    m_buffer(QSize(rows,columns),QImage::Format_RGB32), waterfall(QSize(rows,columns),QImage::Format_RGB32), data()
{

    // Init the buffer
    m_buffer.fill(0);

    // Init the watterwafll image
    waterfall.fill(0);

    // Init the data Array
    initData(m_cols, m_rows);

    // calculates the size hints
    calcSizeHint();
}

~QWaterfallDisplay()

QWaterfallDisplay::~QWaterfallDisplay

(

)

Definition at line 36 of file qwaterfalldisplay.cc.

{
}

Member Function Documentation

backColor

QColor QWaterfallDisplay::backColor ( ) const

slot

clearData

void QWaterfallDisplay::clearData ( )

slot

Definition at line 322 of file qwaterfalldisplay.cc.

{
    data.clear();  // I am not sure if this really deletes the content -> check (jca)

    // redraw!
    redrawData();
}

columns

int QWaterfallDisplay::columns ( ) const

slot

columnsChanged

void QWaterfallDisplay::columnsChanged ( uint  )

signal

drawing

void QWaterfallDisplay::drawing ( bool  )

signal

drawingPaused

void QWaterfallDisplay::drawingPaused ( )

signal

drawingStarted

void QWaterfallDisplay::drawingStarted ( )

signal

isDrawing()

bool QWaterfallDisplay::isDrawing

(

)

Definition at line 54 of file qwaterfalldisplay.cc.

{
    return is_drawing;
}

isPaused()

bool QWaterfallDisplay::isPaused

(

)

Definition at line 59 of file qwaterfalldisplay.cc.

{
    return !is_drawing;
}

maxChanged

void QWaterfallDisplay::maxChanged ( double  )

signal

maxValue

double QWaterfallDisplay::maxValue ( ) const

slot

minChanged

void QWaterfallDisplay::minChanged ( double  )

signal

minimumSizeHint()

QSize QWaterfallDisplay::minimumSizeHint

(

)

Definition at line 44 of file qwaterfalldisplay.cc.

{
    return m_minimum_size;
}

minValue

double QWaterfallDisplay::minValue ( ) const

slot

paintEvent()

void QWaterfallDisplay::paintEvent ( QPaintEvent *  event )

protected

Definition at line 355 of file qwaterfalldisplay.cc.

{
    //
    // This function is currently the ONE AND ONLY function for PAINTING!!!
    //

    // init the painter for the widget
    QPainter widget_painter(this);

    // this is needed for a lot of copying in the function
    QRect target;
    QRect source;

    // Do we have to redraw all or part of the widget due to changes in data or size
    if (redraw_all || widget_resized || (dirty_lines>0)) {


        // new content and we draw
        if (is_drawing && (redraw_all || (dirty_lines>0))) {
        //if ((redraw_all || (dirty_lines>0))) {
            QSize waterfall_size(m_cols,m_rows);
            QImage new_waterfall(waterfall_size,QImage::Format_RGB32);
            new_waterfall.fill(0);
            QPainter waterfall_painter(&new_waterfall);
            waterfall_painter.fillRect(new_waterfall.rect(),back_color);

            if (!(data.empty())) { // for safety reasons
                QRgb* t_line = NULL;
                list< vector<float> >::const_iterator it;

                // we have to redraw the widget
                if (redraw_all) {
                    int it_count = 0;
                    // draw the widget line-by-line
                    for(it = data.begin(); it != data.end(); it++) {
                        t_line = (QRgb*)(new_waterfall.scanLine(it_count));
                        drawLine(t_line, *it);
                        it_count++;
                    }

                    // there are no dirty lines anymore 8]
                    // neede to prevent a go in the next if, for the case of dirty_lines AND redraw_all
                    dirty_lines = 0;
                }
                else if (dirty_lines>0) {
                    // first copy the first height-dirty_lines from the old
                    // waterfall
                    target.setTopLeft(QPoint(0,dirty_lines));
                    target.setWidth(new_waterfall.width());
                    target.setHeight((new_waterfall.height())-dirty_lines);
                    source.setTopLeft(QPoint(0,0));
                    source.setWidth(waterfall.width());
                    source.setHeight((waterfall.height())-dirty_lines);

                    waterfall_painter.drawImage(target,waterfall,source);

                    int it_count = 0;
                    for(it = data.begin(); ((dirty_lines>0) && (it != data.end())); it++) {
                        t_line = (QRgb*)(new_waterfall.scanLine(it_count));
                        drawLine(t_line, *it);
                        it_count++;
                        dirty_lines--;
                    }
                }

            }

            // end painting
            waterfall_painter.end();


            // switch the waterfall
            waterfall = new_waterfall;

            // clear the flags
            redraw_all = false;
            dirty_lines = 0;

            // force a new paint via resize
            widget_resized = true;
        }


        // widget resized or new content (flag set to dirty above)
        if (widget_resized) {
            QImage new_buffer(size(),QImage::Format_RGB32);
            new_buffer.fill(0);

            QPainter buffer_painter(&new_buffer);
            buffer_painter.fillRect(new_buffer.rect(), back_color);

            QSize copy_size;
            float wf_aspect = 0;
            float bf_aspect = 0;
            int m_y = 0;
            int m_x = 0;
            int m_width = 0;
            int m_height = 0;


            // Here is the big switch for resizing and painting it into the new buffer
            switch(m_resizes) {
            case Scale:
                // this is akward, but easy to implement
                target = new_buffer.rect();
                source = waterfall.rect();
                buffer_painter.drawImage(target,waterfall,source);
                break;

            case ScaleAspect:
                // scales with respect to the aspect ratio of waterfall,
                // looks nicer than Scale but still...
                source = waterfall.rect();
                wf_aspect = (float)(waterfall.width())/(float)(waterfall.height());
                bf_aspect = (float)(new_buffer.width())/(float)(new_buffer.height());
                if (wf_aspect >= bf_aspect) {
                    // scale to width of new_buffer and center in height
                    m_width = new_buffer.width();
                    m_height = (int)((float)((new_buffer.width())*(waterfall.height()))/(float)(waterfall.width()));
                    m_y = ((new_buffer.height()) - m_height) / 2;
                }
                else {
                    // scale to height of new buffer and center in width
                    m_height = new_buffer.height();
                    m_width = wf_aspect * (float)(new_buffer.height());
                    m_x = ((new_buffer.width()) - m_width) / 2;
                }
                target.setTopLeft(QPoint(m_x,m_y));
                target.setHeight(m_height);
                target.setWidth(m_width);
                buffer_painter.drawImage(target,waterfall,source);
                break;

            case ScaleEven:
                // Scales only n times columns while keeping the aspect ratio and the centers:
                // widgetsize > n*cols -> centered
                // is a bit more true to the values painted
                source = waterfall.rect();
                qDebug()<<"QWaterfallDisplay: Resize Type:"<<m_resizes<<"not implemented ATM!";
                break;

            case Cut:
                // just put it into the window and cut of what can not be seen
                target.setTopLeft(QPoint(0,0));
                source.setTopLeft(QPoint(0,0));
                if (new_buffer.width() > waterfall.width())
                    copy_size.setWidth(waterfall.width());
                else
                    copy_size.setWidth(new_buffer.width());
                if (new_buffer.height() > waterfall.height())
                    copy_size.setHeight(waterfall.height());
                else
                    copy_size.setHeight(new_buffer.height());
                target.setSize(copy_size);
                source.setSize(copy_size);

                // draw it
                buffer_painter.drawImage(target,waterfall,source);
                break;

            case CutMixed:
                qDebug()<<"QWaterfallDisplay: Resize Type: "<<m_resizes<<" not implemented ATM!";
                break;

            default:
                qDebug()<<"QWaterfallDisplay: Unkown Resize Type: "<<m_resizes;
                break;
            }

            // end painting
            buffer_painter.end();

            // switch the buffer
            m_buffer = new_buffer;

            // clear the flags
            widget_resized = false;
        }


        // Copy the the buffer onto the widget
        widget_painter.drawImage(event->rect(),m_buffer,event->rect());
    }
    else {
        // we have to copy only the rect of the paint event
        // remember m_buffer is exactly the size of the widget!
        widget_painter.drawImage(event->rect(),m_buffer,event->rect());
    }

    // just to be safe
    widget_painter.end();
}

paused

void QWaterfallDisplay::paused ( bool  )

signal

pauseDrawing

void QWaterfallDisplay::pauseDrawing ( bool  onoff )

slot

Definition at line 339 of file qwaterfalldisplay.cc.

{
    is_drawing = onoff;

    emit drawing(is_drawing);
    emit paused(!is_drawing);

    if (is_drawing)
        emit drawingStarted();
    else
        emit drawingPaused();
}

pushData

void QWaterfallDisplay::pushData ( const std::vector< float > &  new_data )

slot

Definition at line 204 of file qwaterfalldisplay.cc.

{
    // push it to the std::list
    data.push_front(new_data);

    if (data.front().size() > m_cols) {
        // shorten the thing
        data.front().resize(m_cols);
    }


    // check wether we have grown too much
    while (data.size() > m_rows) {
        data.pop_back();
    }

    // increase the number of lines to be updated
    dirty_lines++;

    // redraw!
    update();
}

pushDataFloat

void QWaterfallDisplay::pushDataFloat ( const float *  new_data, int  elements  )

slot

Definition at line 247 of file qwaterfalldisplay.cc.

{
    vector<float> temp(new_data, new_data + length);
    if ((uint)(length)>m_cols)
        temp.resize(m_cols);

    // do the real push
    pushData(temp);
}

pushDataQList

void QWaterfallDisplay::pushDataQList ( const QList< float > &  new_data )

slot

Definition at line 227 of file qwaterfalldisplay.cc.

{
    uint i=0;
    vector<float> temp(new_data.size());

    if ((uint)(new_data.size()) > m_cols) {
        temp.resize(m_cols);
        for(i=0;i<m_cols;i++)
            temp[i] = new_data[i];
    }
    else {
        //temp.resize(new_data.size());
        for(i=0;i<temp.size();i++)
            temp[i] = new_data[i];
    }

    // do the real push
    pushData(temp);
}

pushDataUint16

void QWaterfallDisplay::pushDataUint16 ( const char *  new_data, int  length  )

slot

Definition at line 278 of file qwaterfalldisplay.cc.

{
    uint i=0;
    uint16_t* new_data = (uint16_t*)new_data_in;
    uint length = length_in/2;
    vector<float> temp(length);

    if (length > m_cols) {
        temp.resize(m_cols);
        for(i=0;i<m_cols;i++)
            temp[i] = (float)(new_data[i]);
    }
    else {
        //temp.resize(length);
        for(i=0;i<length;i++)
            temp[i] = (float)(new_data[i]);
    }

    // do the real push
    pushData(temp);
}

pushDataUint32

void QWaterfallDisplay::pushDataUint32 ( const char *  new_data, int  length  )

slot

Definition at line 300 of file qwaterfalldisplay.cc.

{
    uint i=0;
    uint32_t* new_data = (uint32_t*)new_data_in;
    uint length = length_in/4;
    vector<float> temp(length);

    if (length > m_cols) {
        temp.resize(m_cols);
        for(i=0;i<m_cols;i++)
            temp[i] = (float)(new_data[i]);
    }
    else {
        //temp.resize(length);
        for(i=0;i<length;i++)
            temp[i] = (float)(new_data[i]);
    }

    // do the real push
    pushData(temp);
}

pushDataUint8

void QWaterfallDisplay::pushDataUint8 ( const char *  new_data, int  length  )

slot

Definition at line 258 of file qwaterfalldisplay.cc.

{
    uint i=0;
    vector<float> temp(length);

    if (length > m_cols) {
        temp.resize(m_cols);
        for(i=0;i<m_cols;i++)
            temp[i] = (float)(new_data[i]);
    }
    else {
        //temp.resize(length);
        for(i=0;i<length;i++)
            temp[i] = (float)(new_data[i]);
    }

    // do the real push
    pushData(temp);
}

redrawData

void QWaterfallDisplay::redrawData ( )

slot

Definition at line 332 of file qwaterfalldisplay.cc.

{
    redraw_all = true; // signals paintEvent to do a complete overhaul
    //if(!(data.isEmpty()))
        update();          // envoces a repaint
}

resizeEvent()

void QWaterfallDisplay::resizeEvent ( QResizeEvent *  event )

protected

Definition at line 548 of file qwaterfalldisplay.cc.

{
    widget_resized = true; // signals the paintEvent, that a resize has occured
}

resizestyle

Resizestyle QWaterfallDisplay::resizestyle ( ) const

slot

rows

int QWaterfallDisplay::rows ( ) const

slot

rowsChanged

void QWaterfallDisplay::rowsChanged ( uint  )

signal

setBackColor

void QWaterfallDisplay::setBackColor ( QColor  back )

slot

Definition at line 138 of file qwaterfalldisplay.cc.

{
    back_color = back;
    redrawData();
}

setColumns

void QWaterfallDisplay::setColumns ( int  cols )

slot

Definition at line 70 of file qwaterfalldisplay.cc.

{
    initData(cols,m_rows); // resize the data storage
    m_cols = cols;
    emit columnsChanged(cols);

    // recalc size hints
    calcSizeHint();

    // redraw!
    redrawData();
}

setColumnsRows

void QWaterfallDisplay::setColumnsRows ( int  cols, int  rows  )

slot

Definition at line 106 of file qwaterfalldisplay.cc.

{
    initData(cols,rows); // resize the data storage
    m_cols = cols;
    m_rows = rows;
    emit columnsChanged(cols);
    emit rowsChanged(rows);

    // recalc size hints
    calcSizeHint();

    // redraw!
    redrawData();
}

setMaxMinValue

void QWaterfallDisplay::setMaxMinValue ( double  max, double  min  )

slot

Definition at line 189 of file qwaterfalldisplay.cc.

{
    m_max = max;
    m_min = min;
    // sanity check
    if (m_min >= m_max)
        m_min = m_max-1.0;
    emit maxChanged(m_max);
    emit minChanged(m_min);

    // redraw!
    redrawData();
}

setMaxValue

void QWaterfallDisplay::setMaxValue ( double  max )

slot

Definition at line 151 of file qwaterfalldisplay.cc.

{
    m_max = max;
    // sanity check
    if (m_min >= m_max) {
        m_min = m_max-1.0;
        emit minChanged(m_min);
    }
    emit maxChanged(m_max);

    // redraw!
    redrawData();
}

setMinValue

void QWaterfallDisplay::setMinValue ( double  min )

slot

Definition at line 170 of file qwaterfalldisplay.cc.

{
    m_min = min;
    // sanity check
    if (m_min >= m_max) {
        m_max = m_min+1.0;
        emit maxChanged(m_max);
    }
    emit minChanged(m_min);

    // redraw!
    redrawData();
}

setResizestyle

void QWaterfallDisplay::setResizestyle ( Resizestyle  resizestyle )

slot

Definition at line 123 of file qwaterfalldisplay.cc.

{
    m_resizes = resizestyle;
    // same as geometry change
    widget_resized = true;
    update();
}

setRows

void QWaterfallDisplay::setRows ( int  rows )

slot

Definition at line 88 of file qwaterfalldisplay.cc.

{
    initData(m_cols,rows); // resize the data storage
    m_rows = rows;
    emit rowsChanged(rows);

    // recalc size hints
    calcSizeHint();

    // redraw!
    redrawData();
}

sizeHint()

QSize QWaterfallDisplay::sizeHint

(

)

Definition at line 49 of file qwaterfalldisplay.cc.

{
    return m_size_hint;
}

Property Documentation

backColor

QColor QWaterfallDisplay::backColor

readwrite

Definition at line 34 of file qwaterfalldisplay.h.

columns

int QWaterfallDisplay::columns

readwrite

Definition at line 32 of file qwaterfalldisplay.h.

maxValue

double QWaterfallDisplay::maxValue

readwrite

Definition at line 35 of file qwaterfalldisplay.h.

minValue

double QWaterfallDisplay::minValue

readwrite

Definition at line 36 of file qwaterfalldisplay.h.

resizestyle

QWaterfallDisplay::Resizestyle QWaterfallDisplay::resizestyle

readwrite

Definition at line 33 of file qwaterfalldisplay.h.

rows

int QWaterfallDisplay::rows

readwrite

Definition at line 31 of file qwaterfalldisplay.h.

---

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

• /build/rock-master-18.09-gui-rock-widget-collection-0.20180124/src/2dvis/qwaterfalldisplay.h
• /build/rock-master-18.09-gui-rock-widget-collection-0.20180124/src/2dvis/qwaterfalldisplay.cc