Changeset - f7670384fcb0
Parent rev.
Child rev.
[Not reviewed]
value-tracker
0 14 0
Hasan Yavuz ÖZDERYA - 7 years ago 2018-12-12 15:05:26
hy@ozderya.net
added linear index buffer to support scaled x axis

this is also an important step towards "x data" support
14 files changed with 147 insertions and 75 deletions:
CMakeLists.txt
1
src/framebufferseries.cpp
29
40
src/framebufferseries.h
4
7
src/linindexbuffer.cpp
16
2
src/linindexbuffer.h
7
5
src/mainwindow.cpp
6
src/plotmanager.cpp
9
8
src/plotmanager.h
1
1
src/snapshot.h
3
1
src/snapshotmanager.cpp
2
src/stream.cpp
37
2
src/stream.h
12
3
tests/test.cpp
8
tests/test_stream.cpp
12
6
0 comments (0 inline, 0 general)
CMakeLists.txt
➞
Show inline comments
 
@@ -117,24 +117,25 @@ add_executable(${PROGRAM_NAME} WIN32
 
  src/dataformatpanel.cpp
 
  src/plotcontrolpanel.cpp
 
  src/recordpanel.cpp
 
  src/datarecorder.cpp
 
  src/tooltipfilter.cpp
 
  src/sneakylineedit.cpp
 
  src/stream.cpp
 
  src/streamchannel.cpp
 
  src/channelinfomodel.cpp
 
  src/ringbuffer.cpp
 
  src/ringbuffer.cpp
 
  src/indexbuffer.cpp
 
  src/linindexbuffer.cpp
 
  src/readonlybuffer.cpp
 
  src/framebufferseries.cpp
 
  src/numberformatbox.cpp
 
  src/endiannessbox.cpp
 
  src/abstractreader.cpp
 
  src/binarystreamreader.cpp
 
  src/binarystreamreadersettings.cpp
 
  src/asciireader.cpp
 
  src/asciireadersettings.cpp
 
  src/demoreader.cpp
 
  src/demoreadersettings.cpp
 
  src/framedreader.cpp
src/framebufferseries.cpp
➞
Show inline comments
 
@@ -11,84 +11,73 @@
 
  serialplot is distributed in the hope that it will be useful,
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
  GNU General Public License for more details.
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <math.h>

			




	
	
	
		
 
#include "framebufferseries.h"

			




	
	
	
		
 

			




	
	
	
		
 
FrameBufferSeries::FrameBufferSeries(const FrameBuffer* buffer)

			




	
	
	
		
 
FrameBufferSeries::FrameBufferSeries(const XFrameBuffer* x, const FrameBuffer* y)

			




	
	
	
		
 
{

			




	
	
	
		
 
    xAsIndex = true;

			




	
	
	
		
 
    _xmin = 0;

			




	
	
	
		
 
    _xmax = 1;

			




	
	
	
		
 
    _buffer = buffer;

			




	
	
	
		
 
    _x = x;

			




	
	
	
		
 
    _y = y;

			




	
	
	
		
 

			




	
	
	
		
 
    int_index_start = 0;

			




	
	
	
		
 
    int_index_end = _buffer->size();

			




	
	
	
		
 
    int_index_end = _y->size();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FrameBufferSeries::setXAxis(bool asIndex, double xmin, double xmax)

			




	
	
	
		
 
void FrameBufferSeries::setX(const XFrameBuffer* x)

			




	
	
	
		
 
{

			




	
	
	
		
 
    xAsIndex = asIndex;

			




	
	
	
		
 
    _xmin = xmin;

			




	
	
	
		
 
    _xmax = xmax;

			




	
	
	
		
 
    _x = x;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
size_t FrameBufferSeries::size() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return int_index_end - int_index_start;

			




	
	
	
		
 
    return int_index_end - int_index_start + 1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QPointF FrameBufferSeries::sample(size_t i) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    i += int_index_start;

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return QPointF(i, _buffer->sample(i));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return QPointF(i * (_xmax - _xmin) / _buffer->size() + _xmin, _buffer->sample(i));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return QPointF(_x->sample(i), _y->sample(i));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QRectF FrameBufferSeries::boundingRect() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    QRectF rect;

			




	
	
	
		
 
    auto yLim = _buffer->limits();

			




	
	
	
		
 
    auto yLim = _y->limits();

			




	
	
	
		
 
    auto xLim = _x->limits();

			




	
	
	
		
 
    rect.setBottom(yLim.start);

			




	
	
	
		
 
    rect.setTop(yLim.end);

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        rect.setLeft(0);

			




	
	
	
		
 
        rect.setRight(size());

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        rect.setLeft(_xmin);

			




	
	
	
		
 
        rect.setRight(_xmax);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    rect.setLeft(xLim.start);

			




	
	
	
		
 
    rect.setRight(xLim.end);

			




	
	
	
		
 

			




	
	
	
		
 
    return rect.normalized();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FrameBufferSeries::setRectOfInterest(const QRectF& rect)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    int_index_start = _x->findIndex(rect.left());

			




	
	
	
		
 
    int_index_end = _x->findIndex(rect.right());

			




	
	
	
		
 

			




	
	
	
		
 
    if (int_index_start == XFrameBuffer::OUT_OF_RANGE)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int_index_start = floor(rect.left())-1;

			




	
	
	
		
 
        int_index_end = ceil(rect.right())+1;

			




	
	
	
		
 
        int_index_start = 0;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    else if (int_index_start > 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        double xsize = _xmax - _xmin;

			




	
	
	
		
 
        size_t bsize = _buffer->size();

			




	
	
	
		
 
        int_index_start =  floor(bsize * (rect.left()-_xmin) / xsize)-1;

			




	
	
	
		
 
        int_index_end = ceil(bsize * (rect.right()-_xmin) / xsize)+1;

			




	
	
	
		
 
        int_index_start -= 1;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    int_index_start = std::max(int_index_start, 0);

			




	
	
	
		
 
    int_index_end = std::min((int) _buffer->size(), int_index_end);

			




	
	
	
		
 
    if (int_index_end == XFrameBuffer::OUT_OF_RANGE)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int_index_end = _x->size()-1;

			




	
	
	
		
 
}

			




	
	
	
		
 
    else if (int_index_end < (int)_x->size()-1)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int_index_end += 1;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/framebufferseries.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -26,34 +26,31 @@

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * This class provides an interface for actual FrameBuffer

			




	
	
	
		
 
 * object. That way we can keep our data structures relatively

			




	
	
	
		
 
 * isolated from Qwt. Otherwise QwtPlotCurve owns FrameBuffer

			




	
	
	
		
 
 * structures.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class FrameBufferSeries : public QwtSeriesData<QPointF>

			




	
	
	
		
 
{

			




	
	
	
		
 
public:

			




	
	
	
		
 
    FrameBufferSeries(const FrameBuffer* buffer);

			




	
	
	
		
 
    FrameBufferSeries(const XFrameBuffer* x, const FrameBuffer* y);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Behavior of X axis

			




	
	
	
		
 
    void setXAxis(bool asIndex, double xmin, double xmax);

			




	
	
	
		
 
    void setX(const XFrameBuffer* x);

			




	
	
	
		
 

			




	
	
	
		
 
    // QwtSeriesData implementations

			




	
	
	
		
 
    size_t size() const;

			




	
	
	
		
 
    QPointF sample(size_t i) const;

			




	
	
	
		
 
    QRectF boundingRect() const;

			




	
	
	
		
 
    void setRectOfInterest(const QRectF& rect);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    const FrameBuffer* _buffer;

			




	
	
	
		
 
    bool xAsIndex;

			




	
	
	
		
 
    double _xmin;

			




	
	
	
		
 
    double _xmax;

			




	
	
	
		
 
    const XFrameBuffer* _x;

			




	
	
	
		
 
    const FrameBuffer* _y;

			




	
	
	
		
 

			




	
	
	
		
 
    int int_index_start; ///< starting index of "rectangle of interest"

			




	
	
	
		
 
    int int_index_end;   ///< ending index of "rectangle of interest"

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // FRAMEBUFFERSERIES_H

			




        

    


    
    

    

        

                

                    src/linindexbuffer.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
 /*

			




	
	
	
		
 
  Copyright © 2017 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <QtGlobal>

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 

			




	
	
	
		
 
#include "linindexbuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
LinIndexBuffer::LinIndexBuffer(unsigned n, Range lim)

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(n > 0);

			




	
	
	
		
 
    // Note that calculation of _step would cause divide by 0

			




	
	
	
		
 
    Q_ASSERT(n > 1);

			




	
	
	
		
 

			




	
	
	
		
 
    _size = n;

			




	
	
	
		
 
    setLimits(lim);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned LinIndexBuffer::size() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _size;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
double LinIndexBuffer::sample(unsigned i) const

			




	
	
	
		
 
{

			




	
	
		
 
@@ -41,17 +43,29 @@ double LinIndexBuffer::sample(unsigned i

			




	
	
	
		
 

			




	
	
	
		
 
Range LinIndexBuffer::limits() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _limits;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void LinIndexBuffer::resize(unsigned n)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _size = n;

			




	
	
	
		
 
    setLimits(_limits);         // called to update `_step`

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int LinIndexBuffer::findIndex(double value) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (value < _limits.start || value > _limits.end)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return OUT_OF_RANGE;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    int r = (value - _limits.start) / _step;

			




	
	
	
		
 
    // Note: we are limiting return value because of floating point in-accuracies

			




	
	
	
		
 
    return std::min<int>(std::max<int>(r, 0), (_size-1));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void LinIndexBuffer::setLimits(Range lim)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _limits = lim;

			




	
	
	
		
 
    _step = (lim.end - lim.start) / (_size-1);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/linindexbuffer.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -17,33 +17,35 @@

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef LININDEXBUFFER_H

			




	
	
	
		
 
#define LININDEXBUFFER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
/// A dynamic frame buffer that start and end values can be set and

			




	
	
	
		
 
/// intermediate values are calculated linearly.

			




	
	
	
		
 
///

			




	
	
	
		
 
/// @note This buffer isn't for storing data.

			




	
	
	
		
 
class LinIndexBuffer : public ResizableBuffer

			




	
	
	
		
 
class LinIndexBuffer : public XFrameBuffer

			




	
	
	
		
 
{

			




	
	
	
		
 
public:

			




	
	
	
		
 
    LinIndexBuffer(unsigned n, Range lim);

			




	
	
	
		
 
    LinIndexBuffer(unsigned n, double min, double max) :

			




	
	
	
		
 
        LinIndexBuffer(n, {min, max}) {};

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned size() const;

			




	
	
	
		
 
    double sample(unsigned i) const;

			




	
	
	
		
 
    Range limits() const;

			




	
	
	
		
 
    void resize(unsigned n);

			




	
	
	
		
 
    unsigned size() const override;

			




	
	
	
		
 
    double sample(unsigned i) const override;

			




	
	
	
		
 
    Range limits() const override;

			




	
	
	
		
 
    void resize(unsigned n) override;

			




	
	
	
		
 
    int findIndex(double value) const override;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Sets minimum and maximum sample values of the buffer.

			




	
	
	
		
 
    void setLimits(Range lim);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    unsigned _size;

			




	
	
	
		
 
    Range _limits;

			




	
	
	
		
 
    double _step;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




        

    


    
    

    

        

                

                    src/mainwindow.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -160,24 +160,27 @@ MainWindow::MainWindow(QWidget *parent) 

			




	
	
	
		
 

			




	
	
	
		
 
    // plot control signals

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

			




	
	
	
		
 
            this, &MainWindow::onNumOfSamplesChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setNumOfSamples);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setYAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,

			




	
	
	
		
 
            &stream, &Stream::setXAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setXAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::plotWidthChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setPlotWidth);

			




	
	
	
		
 

			




	
	
	
		
 
    // plot toolbar signals

			




	
	
	
		
 
    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

			




	
	
	
		
 
                     this, SLOT(clearPlot()));

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

			




	
	
	
		
 
                     plotMan, &PlotManager::flashSnapshotOverlay);

			




	
	
	
		
 

			




	
	
		
 
@@ -206,24 +209,27 @@ MainWindow::MainWindow(QWidget *parent) 

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                     });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&serialPort, &QIODevice::aboutToClose,

			




	
	
	
		
 
            &recordPanel, &RecordPanel::onPortClose);

			




	
	
	
		
 

			




	
	
	
		
 
    // init plot

			




	
	
	
		
 
    numOfSamples = plotControlPanel.numOfSamples();

			




	
	
	
		
 
    stream.setNumSamples(numOfSamples);

			




	
	
	
		
 
    plotControlPanel.setChannelInfoModel(stream.infoModel());

			




	
	
	
		
 

			




	
	
	
		
 
    // init scales

			




	
	
	
		
 
    stream.setXAxis(plotControlPanel.xAxisAsIndex(),

			




	
	
	
		
 
                    plotControlPanel.xMin(), plotControlPanel.xMax());

			




	
	
	
		
 

			




	
	
	
		
 
    plotMan->setYAxis(plotControlPanel.autoScale(),

			




	
	
	
		
 
                      plotControlPanel.yMin(), plotControlPanel.yMax());

			




	
	
	
		
 
    plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),

			




	
	
	
		
 
                      plotControlPanel.xMin(), plotControlPanel.xMax());

			




	
	
	
		
 
    plotMan->setNumOfSamples(numOfSamples);

			




	
	
	
		
 
    plotMan->setPlotWidth(plotControlPanel.plotWidth());

			




	
	
	
		
 

			




	
	
	
		
 
    // Init sps (sample per second) counter

			




	
	
	
		
 
    spsLabel.setText("0sps");

			




	
	
	
		
 
    spsLabel.setToolTip("samples per second (per channel)");

			




	
	
	
		
 
    ui->statusBar->addPermanentWidget(&spsLabel);

			




	
	
	
		
 
    connect(&sampleCounter, &SampleCounter::spsChanged,

			




        

    


    
    

    

        

                

                    src/plotmanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -10,25 +10,24 @@

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#include <QMetaEnum>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 
#include "qwt_symbol.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "plot.h"

			




	
	
	
		
 
#include "plotmanager.h"

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
PlotManager::PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         const Stream* stream, QObject* parent) :

			




	
	
	
		
 
    QObject(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _stream = stream;

			




	
	
		
 
@@ -44,43 +43,43 @@ PlotManager::PlotManager(QWidget* plotAr

			




	
	
	
		
 
            {

			




	
	
	
		
 
                onChannelInfoChanged(infoModel->index(0, 0), // start

			




	
	
	
		
 
                                     infoModel->index(infoModel->rowCount()-1, 0), // end

			




	
	
	
		
 
                                     {}); // roles ignored

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(stream, &Stream::numChannelsChanged, this, &PlotManager::onNumChannelsChanged);

			




	
	
	
		
 
    connect(stream, &Stream::dataAdded, this, &PlotManager::replot);

			




	
	
	
		
 

			




	
	
	
		
 
    // add initial curves if any?

			




	
	
	
		
 
    for (unsigned int i = 0; i < stream->numChannels(); i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        addCurve(stream->channel(i)->name(), stream->channel(i)->yData());

			




	
	
	
		
 
        addCurve(stream->channel(i)->name(), stream->channel(i)->xData(), stream->channel(i)->yData());

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
PlotManager::PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         Snapshot* snapshot, QObject *parent) :

			




	
	
	
		
 
    QObject(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _stream = nullptr;

			




	
	
	
		
 
    construct(plotArea, menu);

			




	
	
	
		
 

			




	
	
	
		
 
    setNumOfSamples(snapshot->numSamples());

			




	
	
	
		
 
    setPlotWidth(snapshot->numSamples());

			




	
	
	
		
 
    infoModel = snapshot->infoModel();

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < snapshot->numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        addCurve(snapshot->channelName(ci), snapshot->yData[ci]);

			




	
	
	
		
 
        addCurve(snapshot->channelName(ci), snapshot->xData[ci], snapshot->yData[ci]);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    connect(infoModel, &QAbstractItemModel::dataChanged,

			




	
	
	
		
 
            this, &PlotManager::onChannelInfoChanged);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::construct(QWidget* plotArea, PlotMenu* menu)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _menu = menu;

			




	
	
	
		
 
    _plotArea = plotArea;

			




	
	
	
		
 
    _autoScaled = true;

			




	
	
	
		
 
    _yMin = 0;

			




	
	
		
 
@@ -140,25 +139,25 @@ PlotManager::~PlotManager()

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::onNumChannelsChanged(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    unsigned int oldNum = numOfCurves();

			




	
	
	
		
 
    unsigned numOfChannels = value;

			




	
	
	
		
 

			




	
	
	
		
 
    if (numOfChannels > oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // add new channels

			




	
	
	
		
 
        for (unsigned int i = oldNum; i < numOfChannels; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            addCurve(_stream->channel(i)->name(), _stream->channel(i)->yData());

			




	
	
	
		
 
            addCurve(_stream->channel(i)->name(), _stream->channel(i)->xData(), _stream->channel(i)->yData());

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if(numOfChannels < oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        removeCurves(oldNum - numOfChannels);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::onChannelInfoChanged(const QModelIndex &topLeft,

			




	
	
	
		
 
                                       const QModelIndex &bottomRight,

			




	
	
		
 
@@ -324,29 +323,28 @@ Plot* PlotManager::addPlotWidget()

			




	
	
	
		
 
    if (_xAxisAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setXAxis(0, _numOfSamples);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setXAxis(_xMin, _xMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return plot;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::addCurve(QString title, const FrameBuffer* buffer)

			




	
	
	
		
 
void PlotManager::addCurve(QString title, const XFrameBuffer* xBuf, const FrameBuffer* yBuf)

			




	
	
	
		
 
{

			




	
	
	
		
 
    auto curve = new QwtPlotCurve(title);

			




	
	
	
		
 
    auto series = new FrameBufferSeries(buffer);

			




	
	
	
		
 
    series->setXAxis(_xAxisAsIndex, _xMin, _xMax);

			




	
	
	
		
 
    auto series = new FrameBufferSeries(xBuf, yBuf);

			




	
	
	
		
 
    curve->setSamples(series);

			




	
	
	
		
 
    _addCurve(curve);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::_addCurve(QwtPlotCurve* curve)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // store and init the curve

			




	
	
	
		
 
    curves.append(curve);

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned index = curves.size()-1;

			




	
	
	
		
 
    auto color = infoModel->color(index);

			




	
	
	
		
 
    curve->setPen(color);

			




	
	
		
 
@@ -473,28 +471,31 @@ void PlotManager::setYAxis(bool autoScal

			




	
	
	
		
 
    _yMax = yAxisMax;

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setYAxis(autoScaled, yAxisMin, yAxisMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setXAxis(bool asIndex, double xMin, double xMax)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _xAxisAsIndex = asIndex;

			




	
	
	
		
 
    _xMin = xMin;

			




	
	
	
		
 
    _xMax = xMax;

			




	
	
	
		
 

			




	
	
	
		
 
    int ci = 0;

			




	
	
	
		
 
    for (auto curve : curves)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        FrameBufferSeries* series = static_cast<FrameBufferSeries*>(curve->data());

			




	
	
	
		
 
        series->setXAxis(asIndex, xMin, xMax);

			




	
	
	
		
 
        series->setX(_stream->channel(ci)->xData());

			




	
	
	
		
 
        ci++;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (asIndex)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            plot->setXAxis(0, _numOfSamples);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            plot->setXAxis(xMin, xMax);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




        

    


    
    

    

        

                

                    src/plotmanager.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -40,25 +40,25 @@ class PlotManager : public QObject

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         const Stream* stream = nullptr,

			




	
	
	
		
 
                         QObject *parent = 0);

			




	
	
	
		
 
    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         Snapshot* snapshot,

			




	
	
	
		
 
                         QObject *parent = 0);

			




	
	
	
		
 
    ~PlotManager();

			




	
	
	
		
 
    /// Add a new curve with title and buffer. A color is

			




	
	
	
		
 
    /// automatically chosen for curve.

			




	
	
	
		
 
    void addCurve(QString title, const FrameBuffer* buffer);

			




	
	
	
		
 
    void addCurve(QString title, const XFrameBuffer* xBuf, const FrameBuffer* yBuf);

			




	
	
	
		
 
    /// Removes curves from the end

			




	
	
	
		
 
    void removeCurves(unsigned number);

			




	
	
	
		
 
    /// Returns current number of curves known by plot manager

			




	
	
	
		
 
    unsigned numOfCurves();

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    /// Enable/Disable multiple plot display

			




	
	
	
		
 
    void setMulti(bool enabled);

			




	
	
	
		
 
    /// Update all plot widgets

			




	
	
	
		
 
    void replot();

			




	
	
	
		
 
    /// Enable display of a "DEMO" label on each plot

			




	
	
	
		
 
    void showDemoIndicator(bool show = true);

			




        

    


    
    

    

        

                

                    src/snapshot.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -19,37 +19,39 @@

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef SNAPSHOT_H

			




	
	
	
		
 
#define SNAPSHOT_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QAction>

			




	
	
	
		
 
#include <QVector>

			




	
	
	
		
 
#include <QString>

			




	
	
	
		
 
#include <QStringList>

			




	
	
	
		
 

			




	
	
	
		
 
#include "channelinfomodel.h"

			




	
	
	
		
 
#include "readonlybuffer.h"

			




	
	
	
		
 
#include "indexbuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
class SnapshotView;

			




	
	
	
		
 
class MainWindow;

			




	
	
	
		
 

			




	
	
	
		
 
class Snapshot : public QObject

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    Snapshot(MainWindow* parent, QString name, ChannelInfoModel infoModel, bool saved = false);

			




	
	
	
		
 
    ~Snapshot();

			




	
	
	
		
 

			




	
	
	
		
 
    // TODO: yData of snapshot shouldn't be public, preferable should be handled in constructor

			




	
	
	
		
 
    // TODO: yData and xData of snapshot shouldn't be public, preferable should be handled in constructor

			




	
	
	
		
 
    QVector<IndexBuffer*> xData;

			




	
	
	
		
 
    QVector<ReadOnlyBuffer*> yData;

			




	
	
	
		
 
    QAction* showAction();

			




	
	
	
		
 
    QAction* deleteAction();

			




	
	
	
		
 

			




	
	
	
		
 
    QString name();

			




	
	
	
		
 
    QString displayName(); ///< `name()` plus '*' if snapshot is not saved

			




	
	
	
		
 
    unsigned numChannels() const; ///< number of channels in this snapshot

			




	
	
	
		
 
    unsigned numSamples() const;  ///< number of samples in every channel

			




	
	
	
		
 
    const ChannelInfoModel* infoModel() const;

			




	
	
	
		
 
    ChannelInfoModel* infoModel();

			




	
	
	
		
 
    void setName(QString name);

			




	
	
	
		
 
    QString channelName(unsigned channel);

			




        

    


    
    

    

        

                

                    src/snapshotmanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -62,24 +62,25 @@ SnapshotManager::~SnapshotManager()

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete snapshot;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Snapshot* SnapshotManager::makeSnapshot() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString name = QTime::currentTime().toString("'Snapshot ['HH:mm:ss']'");

			




	
	
	
		
 
    auto snapshot = new Snapshot(_mainWindow, name, *(_stream->infoModel()));

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < _stream->numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        snapshot->xData.append(new IndexBuffer(_stream->numSamples()));

			




	
	
	
		
 
        snapshot->yData.append(new ReadOnlyBuffer(_stream->channel(ci)->yData()));

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return snapshot;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::takeSnapshot()

			




	
	
	
		
 
{

			




	
	
	
		
 
    addSnapshot(makeSnapshot());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::addSnapshot(Snapshot* snapshot, bool update_menu)

			




	
	
		
 
@@ -185,24 +186,25 @@ void SnapshotManager::loadSnapshotFromFi

			




	
	
	
		
 
            data[ci].append(y);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        lineNum++;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // create snapshot

			




	
	
	
		
 
    auto snapshot = new Snapshot(

			




	
	
	
		
 
        _mainWindow, QFileInfo(fileName).baseName(),

			




	
	
	
		
 
        ChannelInfoModel(channelNames), true);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < numOfChannels; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        snapshot->xData.append(new IndexBuffer(data[ci].size()));

			




	
	
	
		
 
        snapshot->yData.append(new ReadOnlyBuffer(data[ci].data(), data[ci].size()));

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    addSnapshot(snapshot, false);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QMenu* SnapshotManager::menu()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_menu;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QAction* SnapshotManager::takeSnapshotAction()

			




        

    


    
    

    

        

                

                    src/stream.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -11,41 +11,46 @@

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "stream.h"

			




	
	
	
		
 
#include "ringbuffer.h"

			




	
	
	
		
 
#include "indexbuffer.h"

			




	
	
	
		
 
#include "linindexbuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
Stream::Stream(unsigned nc, bool x, unsigned ns) :

			




	
	
	
		
 
    _infoModel(nc)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numSamples = ns;

			




	
	
	
		
 
    _paused = false;

			




	
	
	
		
 

			




	
	
	
		
 
    xAsIndex = true;

			




	
	
	
		
 
    xMin = 0;

			




	
	
	
		
 
    xMax = 1;

			




	
	
	
		
 

			




	
	
	
		
 
    // create xdata buffer

			




	
	
	
		
 
    _hasx = x;

			




	
	
	
		
 
    if (x)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // TODO: implement XRingBuffer (binary search)

			




	
	
	
		
 
        Q_ASSERT(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        xData = new IndexBuffer(ns);

			




	
	
	
		
 
        xData = makeXBuffer();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // create channels

			




	
	
	
		
 
    for (unsigned i = 0; i < nc; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        auto c = new StreamChannel(i, xData, new RingBuffer(ns), &_infoModel);

			




	
	
	
		
 
        channels.append(c);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Stream::~Stream()

			




	
	
	
		
 
{

			




	
	
		
 
@@ -115,44 +120,56 @@ void Stream::setNumChannels(unsigned nc,

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // change the xdata

			




	
	
	
		
 
    if (x != _hasx)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (x)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // TODO: implement XRingBuffer (binary search)

			




	
	
	
		
 
            Q_ASSERT(false);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            xData = new IndexBuffer(_numSamples);

			




	
	
	
		
 
            xData = makeXBuffer();

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        for (auto c : channels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            c->setX(xData);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        _hasx = x;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (nc != oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _infoModel.setNumOfChannels(nc);

			




	
	
	
		
 
        // TODO: how about X change?

			




	
	
	
		
 
        emit numChannelsChanged(nc);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    Sink::setNumChannels(nc, x);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
XFrameBuffer* Stream::makeXBuffer() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return new IndexBuffer(_numSamples);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return new LinIndexBuffer(_numSamples, xMin, xMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
const SamplePack* Stream::applyGainOffset(const SamplePack& pack) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(infoModel()->gainOrOffsetEn());

			




	
	
	
		
 

			




	
	
	
		
 
    SamplePack* mPack = new SamplePack(pack);

			




	
	
	
		
 
    unsigned ns = pack.numSamples();

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // TODO: we could use some kind of map (int32, int64 would suffice) to speed things up

			




	
	
	
		
 
        bool gainEn = infoModel()->gainEn(ci);

			




	
	
	
		
 
        bool offsetEn = infoModel()->offsetEn(ci);

			




	
	
		
 
@@ -232,21 +249,39 @@ void Stream::clear()

			




	
	
	
		
 
void Stream::setNumSamples(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (value == _numSamples) return;

			




	
	
	
		
 
    _numSamples = value;

			




	
	
	
		
 

			




	
	
	
		
 
    xData->resize(value);

			




	
	
	
		
 
    for (auto c : channels)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        static_cast<RingBuffer*>(c->yData())->resize(value);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::setXAxis(bool asIndex, double min, double max)

			




	
	
	
		
 
{

			




	
	
	
		
 
    xAsIndex = asIndex;

			




	
	
	
		
 
    xMin = min;

			




	
	
	
		
 
    xMax = max;

			




	
	
	
		
 

			




	
	
	
		
 
    // Note that x axis scaling is ignored when X is provided from source as data

			




	
	
	
		
 
    // TODO: assert (UI options for x axis should be disabled)

			




	
	
	
		
 
    if (!hasX())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        xData = makeXBuffer();

			




	
	
	
		
 
        for (auto c : channels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            c->setX(xData);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::saveSettings(QSettings* settings) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    _infoModel.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _infoModel.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/stream.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -39,25 +39,25 @@

			




	
	
	
		
 
 * connected to a `Device` source.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class Stream : public QObject, public Sink

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @param nc number of channels

			




	
	
	
		
 
     * @param x has X data input

			




	
	
	
		
 
     * @param ns number of samples

			




	
	
	
		
 
     */

			




	
	
	
		
 
    Stream(unsigned nc = 0, bool x = false, unsigned ns = 0);

			




	
	
	
		
 
    Stream(unsigned nc = 1, bool x = false, unsigned ns = 2);

			




	
	
	
		
 
    ~Stream();

			




	
	
	
		
 

			




	
	
	
		
 
    bool hasX() const;

			




	
	
	
		
 
    unsigned numChannels() const;

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned numSamples() const;

			




	
	
	
		
 
    const StreamChannel* channel(unsigned index) const;

			




	
	
	
		
 
    StreamChannel* channel(unsigned index);

			




	
	
	
		
 
    const ChannelInfoModel* infoModel() const;

			




	
	
	
		
 
    ChannelInfoModel* infoModel();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Saves channel information

			




	
	
		
 
@@ -69,48 +69,57 @@ protected:

			




	
	
	
		
 
    // implementations for `Sink`

			




	
	
	
		
 
    virtual void setNumChannels(unsigned nc, bool x);

			




	
	
	
		
 
    virtual void feedIn(const SamplePack& pack);

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void numChannelsChanged(unsigned value);

			




	
	
	
		
 
    void numSamplesChanged(unsigned value);

			




	
	
	
		
 
    void channelAdded(const StreamChannel* chan);

			




	
	
	
		
 
    void channelNameChanged(unsigned channel, QString name); // TODO: does it stay?

			




	
	
	
		
 
    void dataAdded(); ///< emitted when data added to channel man.

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    // TODO: these won't be public

			




	
	
	
		
 
    // void setNumChannels(unsigned number);

			




	
	
	
		
 
    /// Change number of samples (buffer size)

			




	
	
	
		
 
    void setNumSamples(unsigned value);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Change X axis style

			




	
	
	
		
 
    /// @note Ignored when X is provided by source (hasX == true)

			




	
	
	
		
 
    void setXAxis(bool asIndex, double min, double max);

			




	
	
	
		
 

			




	
	
	
		
 
    /// When paused data feed is ignored

			




	
	
	
		
 
    void pause(bool paused);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Clears buffer data (fills with 0)

			




	
	
	
		
 
    void clear();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    unsigned _numSamples;

			




	
	
	
		
 
    bool _paused;

			




	
	
	
		
 

			




	
	
	
		
 
    bool _hasx;

			




	
	
	
		
 
    XFrameBuffer* xData;

			




	
	
	
		
 
    QList<StreamChannel*> channels;

			




	
	
	
		
 

			




	
	
	
		
 
    ChannelInfoModel _infoModel;

			




	
	
	
		
 

			




	
	
	
		
 
    bool xAsIndex;

			




	
	
	
		
 
    double xMin, xMax;

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Applies gain and offset to given pack.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * Caller is responsible for deleting returned `SamplePack`.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @note Should be called only when gain or offset is enabled. Guard with

			




	
	
	
		
 
     * `ChannelInfoModel::gainOrOffsetEn()`.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @param pack input data

			




	
	
	
		
 
     * @return modified data

			




	
	
	
		
 
     */

			




	
	
	
		
 
    const SamplePack* applyGainOffset(const SamplePack& pack) const;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Returns a new virtual X buffer for settings

			




	
	
	
		
 
    XFrameBuffer* makeXBuffer() const;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#endif // STREAM_H

			




        

    


    
    

    

        

                

                    tests/test.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -212,24 +212,32 @@ TEST_CASE("LinIndexBuffer", "[memory, bu

			




	
	
	
		
 

			




	
	
	
		
 
    l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == 0.);

			




	
	
	
		
 
    REQUIRE(l.end == 3.0);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.setLimits({-5., 5.});

			




	
	
	
		
 
    l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == -5.0);

			




	
	
	
		
 
    REQUIRE(l.end == 5.0);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.sample(0) == -5.0);

			




	
	
	
		
 
    REQUIRE(buf.sample(19) == 5.0);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(10);

			




	
	
	
		
 
    buf.setLimits({0., 3.});

			




	
	
	
		
 
    REQUIRE(buf.findIndex(0.01) == 0);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(1.51) == 4);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(2.99) == 8);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(3.01) == XFrameBuffer::OUT_OF_RANGE);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(-0.01) == XFrameBuffer::OUT_OF_RANGE);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("RingBuffer sizing", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(5);

			




	
	
	
		
 
    REQUIRE(buf.size() == 5);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(15);

			




        

    


    
    

    

        

                

                    tests/test_stream.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -18,35 +18,35 @@

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "stream.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "catch.hpp"

			




	
	
	
		
 
#include "test_helpers.h"

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("construction of stream with default values", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    // default values are an empty stream with no channels

			




	
	
	
		
 
    Stream s;

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 0);

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 1);

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 
    REQUIRE(s.numSamples() == 0);

			




	
	
	
		
 
    REQUIRE(s.numSamples() == 2);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("construction of stream with parameters", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(4, true, 100);

			




	
	
	
		
 
    Stream s(4, false, 100);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 4);

			




	
	
	
		
 
    REQUIRE(s.hasX());

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 
    REQUIRE(s.numSamples() == 100);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 4; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("changing stream number of channels via sink", "[memory, stream, sink]")

			




	
	
	
		
 
{

			




	
	
		
 
@@ -55,36 +55,39 @@ TEST_CASE("changing stream number of cha

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 

			




	
	
	
		
 
    // nc=3, x= false

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 
    for (unsigned i = 0; i < 3; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: enable test when `Stream` supports X channel

			




	
	
	
		
 
#if 0

			




	
	
	
		
 
    // increase nc value, add X

			




	
	
	
		
 
    so._setNumChannels(5, true);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 5);

			




	
	
	
		
 
    REQUIRE(s.hasX());

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
    // reduce nc value, remove X

			




	
	
	
		
 
    so._setNumChannels(1, false);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 1);

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 1; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
		
 
@@ -118,45 +121,47 @@ TEST_CASE("adding data to a stream with 

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == 0);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == i-5);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: enable test when `Stream` supports X channel

			




	
	
	
		
 
#if 0

			




	
	
	
		
 
TEST_CASE("adding data to a stream with X", "[memory, stream, data, sink]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(3, true, 10);

			




	
	
	
		
 
    Stream s(3, false, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    // prepare data

			




	
	
	
		
 
    SamplePack pack(5, 3, true);

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            pack.data(ci)[i] = i;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    // x data

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        pack.xData()[i] = i+10;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    TestSource so(3, true);

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 
    REQUIRE_THROWS(so.connectSink(&s));

			




	
	
	
		
 

			




	
	
	
		
 
    // test

			




	
	
	
		
 
    so._feed(pack);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(ci);

			




	
	
	
		
 
        const FrameBuffer* y = c->yData();

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == 0);

			




	
	
		
 
@@ -169,24 +174,25 @@ TEST_CASE("adding data to a stream with 

			




	
	
	
		
 

			




	
	
	
		
 
    // check x

			




	
	
	
		
 
    const FrameBuffer* x = s.channel(0)->xData();

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(x->sample(i) == 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(x->sample(i) == (i-5)+10);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("paused stream shouldn't store data", "[memory, stream, pause]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(3, false, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    // prepare data

			




	
	
	
		
 
    SamplePack pack(5, 3, false);

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            pack.data(ci)[i] = i;

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-307515
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support