void HistPlot::populate()
{
setTitle("Watching TV during a weekend");
setAxisTitle(QwtPlot::yLeft, "Number of People");
setAxisTitle(QwtPlot::xBottom, "Number of Hours");
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX(false);
grid->enableY(true);
grid->enableXMin(false);
grid->enableYMin(false);
grid->setMajPen(QPen(Qt::black, 0, Qt::SolidLine));
grid->attach(this);
const double juneValues[] = { 7, 19, 24, 32, 10, 5, 3 };
const double novemberValues[] = { 4, 15, 22, 34, 13, 8, 4 };
Histogram *histogramJune = new Histogram("Summer", Qt::red);
histogramJune->setValues(
sizeof(juneValues) / sizeof(double), juneValues);
histogramJune->attach(this);
Histogram *histogramNovember = new Histogram("Winter", Qt::blue);
histogramNovember->setValues(
sizeof(novemberValues) / sizeof(double), novemberValues);
histogramNovember->attach(this);
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent )
{
setAutoFillBackground( true );
setPalette( Qt::darkGray );
setCanvasBackground( Qt::white );
plotLayout()->setAlignCanvasToScales( true );
initAxis( QwtAxis::yLeft, "Local Time", Qt::LocalTime );
initAxis( QwtAxis::yRight,
"Coordinated Universal Time ( UTC )", Qt::UTC );
QwtPlotPanner *panner = new QwtPlotPanner( canvas() );
QwtPlotMagnifier *magnifier = new QwtPlotMagnifier( canvas() );
for ( int axis = 0; axis < QwtAxis::PosCount; axis++ )
{
const bool on = QwtAxis::isYAxis( axis );
setAxisVisible( axis, on );
panner->setAxisEnabled( axis, on );
magnifier->setAxisEnabled( axis, on );
}
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setMajorPen( Qt::black, 0, Qt::SolidLine );
grid->setMinorPen( Qt::gray, 0 , Qt::SolidLine );
grid->enableX( false );
grid->enableXMin( false );
grid->enableY( true );
grid->enableYMin( true );
grid->attach( this );
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent ),
d_curve( NULL )
{
/*canvas()->setStyleSheet(
"border: 2px solid Black;"
"border-radius: 15px;"
"background-color: qlineargradient( x1: 0, y1: 0, x2: 0, y2: 1,"
"stop: 0 LemonChiffon, stop: 1 PaleGoldenrod );"
);*/
//QwtPlotCanvas *newcanvas=new QwtPlotCanvas();
//newcanvas->setPalette(Qt::white);
//newcanvas->setBorderRadius(10);
//setCanvas( newcanvas );
//plotLayout()->setAlignCanvasToScales( true );
setAxisTitle( QwtPlot::yLeft, "ylabel" );
setAxisTitle( QwtPlot::xBottom, "xlabel" );
//setAxisScale(QwtPlot::yLeft,0.0,25.0);
//setAxisScale(QwtPlot::xBottom,0.0,25.0);
//canvas()->resize(800, 600);
//plotLayout(AlignScales);
// attach curve
d_curve = new QwtPlotCurve( "Scattered Points" );
d_curve->setPen( QColor( "Black" ) );
// d_curve->setCurveAttribute(fitten);
// when using QwtPlotCurve::ImageBuffer simple dots can be
// rendered in parallel on multicore systems.
d_curve->setRenderThreadCount( 0 ); // 0: use QThread::idealThreadCount()
//d_curve->setCurveAttribute(QwtPlotCurve::Fitted, true);
d_curve->attach( this );
QwtSymbol * symbol2 = new QwtSymbol( QwtSymbol::XCross, QBrush(Qt::white), QPen(Qt::red, 1), QSize(6,6));
//QwtSymbol::Style style = Cross;
setSymbol( symbol2 );
//setSymbol(NULL);
// panning with the left mouse button
(void )new QwtPlotPanner( canvas() );
// zoom in/out with the wheel
QwtPlotMagnifier *magnifier = new QwtPlotMagnifier( canvas() );
magnifier->setMouseButton( Qt::NoButton );
// distanve measurement with the right mouse button
DistancePicker *picker = new DistancePicker( canvas() );
picker->setMousePattern( QwtPlotPicker::MouseSelect1, Qt::RightButton );
picker->setRubberBandPen( QPen( Qt::blue ) );
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX( true );//设置网格线
grid->enableY( true );
grid->setMajorPen( Qt::black, 0, Qt::DotLine );
grid->attach( this );
//QSize sizeH = sizeHint();
}
Plot::Plot(QWidget *parent):
QwtPlot(parent),
d_paintedPoints(0),
d_interval(0.0, 10.0),
d_timerId(-1)
{
d_directPainter = new QwtPlotDirectPainter();
setAutoReplot(false);
// We don't need the cache here
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
//canvas()->setPaintAttribute(QwtPlotCanvas::PaintPacked, false);
#if defined(Q_WS_X11)
// Even if not recommended by TrollTech, Qt::WA_PaintOutsidePaintEvent
// works on X11. This has a nice effect on the performance.
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
canvas()->setAttribute(Qt::WA_PaintOnScreen, true);
#endif
plotLayout()->setAlignCanvasToScales(true);
setAxisTitle(QwtPlot::xBottom, "Time [s]");
setAxisScale(QwtPlot::xBottom, d_interval.minValue(), d_interval.maxValue());
setAxisScale(QwtPlot::yLeft, -200.0, 200.0);
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen(QPen(Qt::gray, 0.0, Qt::DotLine));
grid->enableX(true);
grid->enableXMin(true);
grid->enableY(true);
grid->enableYMin(false);
grid->attach(this);
d_origin = new QwtPlotMarker();
d_origin->setLineStyle(QwtPlotMarker::Cross);
d_origin->setValue(d_interval.minValue() + d_interval.width() / 2.0, 0.0);
d_origin->setLinePen(QPen(Qt::gray, 0.0, Qt::DashLine));
d_origin->attach(this);
d_curve = new QwtPlotCurve();
d_curve->setStyle(QwtPlotCurve::Lines);
d_curve->setPen(QPen(Qt::green));
#if 1
d_curve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
#endif
#if 1
d_curve->setPaintAttribute(QwtPlotCurve::ClipPolygons, false);
#endif
d_curve->setData(new CurveData());
d_curve->attach(this);
}
void GenericHistogramView::populate()
{
QwtPlotGrid* grid = new QwtPlotGrid();
grid->enableX(false);
grid->enableY(true);
grid->enableXMin(false);
grid->enableYMin(false);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->attach(_qwtPlot);
for(unsigned int i = 0; i < _image->getNbChannels(); ++i)
{
imagein::Array<unsigned int>* histogram;
if(_projection)
histogram = new imagein::ProjectionHistogram(*_image, _value, _horizontal, *_rectangle, i);
else
histogram = new imagein::Histogram(*_image, i, *_rectangle);
int values[histogram->getWidth()];
for(unsigned int j = 0; j < histogram->getWidth(); ++j)
values[j] = (*histogram)[j];
GraphicalHistogram* graphicalHisto;
switch(i)
{
case 0:
if(_image->getNbChannels() == 1 || _image->getNbChannels() == 2)
graphicalHisto = new GraphicalHistogram("Black", Qt::black);
else
graphicalHisto = new GraphicalHistogram("Red", Qt::red);
break;
case 1:
if(_image->getNbChannels() == 1 || _image->getNbChannels() == 2)
graphicalHisto = new GraphicalHistogram("Alpha", Qt::white);
else
graphicalHisto = new GraphicalHistogram("Green", Qt::green);
break;
case 2:
graphicalHisto = new GraphicalHistogram("Blue", Qt::blue);
break;
case 3:
graphicalHisto = new GraphicalHistogram("Alpha", Qt::black);
break;
default:
graphicalHisto = new GraphicalHistogram("Default", Qt::black);
}
graphicalHisto->setValues(sizeof(values) / sizeof(int), values);
if(_horizontal)
graphicalHisto->setOrientation(Qt::Horizontal);
graphicalHisto->attach(_qwtPlot);
_graphicalHistos.push_back(graphicalHisto);
}
}
void AnalogGraph::populate()
{
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX(false);
grid->enableY(false);
grid->enableXMin(false);
grid->enableYMin(false);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->attach(this);
analogHistogram_ = new Histogram("", QColor(80, 180, 220, 150));
//analogHistogram_->setValues(analogChannels_);
analogHistogram_->attach(this);
}
void panelControlMotor::chartSetting()
{
QwtPlotGrid *grid = new QwtPlotGrid();
ui->chartTemp->setAutoReplot(true);
grid->setMinorPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->setMajorPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->enableX(true);
grid->enableY(true);
grid->attach(ui->chartTemp);
temperature = new QwtPlotCurve();
temperature->setTitle("temperature");
temperature->setPen(Qt::black, 2, Qt::SolidLine);
temperature->setRenderHint(QwtPlotItem::RenderAntialiased, true);
temperature->attach(ui->chartTemp);
}
void ICResultChart::populate()
{
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX( false );
grid->enableY( true );
grid->enableXMin( false );
grid->enableYMin( false );
grid->setMajorPen( Qt::black, 0, Qt::DotLine );
grid->attach( this );
QColor color = Qt::blue;
color.setAlpha(180);
QwtColumnSymbol *symbol = new QwtColumnSymbol(QwtColumnSymbol::Box);
symbol->setLineWidth(2);
symbol->setFrameStyle(QwtColumnSymbol::Raised);
symbol->setPalette(QPalette(color));
d_barChartItem->setSymbol(symbol);
QVector<double> samples;
QMap<QString, int>::const_iterator i = result.constBegin();
while (i != result.constEnd()) {
samples.append(i.value());
++i;
}
d_barChartItem->setSamples(samples);
double k = (0.0 + SPACING_RATIO) / MARGIN_RATIO;
double m = (0.0 + WINDOW_WIDTH - BAR_WIDTH) / (2 + k * (result.size() - 1));
int margin = static_cast<int>(m);
int spacing = static_cast<int>(m * k);
if (spacing < MIN_SPACING) spacing = MIN_SPACING;
if (margin < MIN_MARGIN) margin = MIN_MARGIN;
d_barChartItem->setSpacing(spacing);
d_barChartItem->setMargin(100);
//d_barChartItem->setLayoutPolicy(QwtPlotAbstractBarChart::FixedSampleSize);
//d_barChartItem->setLayoutHint(BAR_WIDTH);
}
void HistPlot::setValueHist(const vector<double>& histogram, int origin)
{
setTitle("Histogram");
setAxisTitle(QwtPlot::yLeft, "Count");
setAxisTitle(QwtPlot::xBottom, "Value");
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX(false);
grid->enableY(true);
grid->enableXMin(false);
grid->enableYMin(false);
grid->setMajPen(QPen(Qt::darkGreen, 0, Qt::SolidLine));
grid->attach(this);
Histogram *histogramJune = new Histogram("Summer", Qt::red);
histogramJune->setValues(
histogram.size(), &histogram[0], origin);
histogramJune->attach(this);
}
Spectrograph::Spectrograph(QWidget *parent):
QwtPlot(parent)
{
//real-time plotting
d_directPainter = new QwtPlotDirectPainter();
setAutoReplot( false );
//all plot widgets will be displayed on the canvas
setCanvas( new QwtPlotCanvas() );
plotLayout()->setAlignCanvasToScales( true );
//set plot title and range
setAxisTitle( QwtPlot::xBottom, "Frequency (MHz)" );
setAxisTitle( QwtPlot::yLeft, "Amplitude (dB)" );
setAxisScale( QwtPlot::xBottom, 0, RESULT_LENGTH );
setAxisScale( QwtPlot::yLeft, -90, -10);
//black background
setCanvasBackground(QColor(0,0,0));
//add grid
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen( Qt::white, 0.0, Qt::DotLine );
grid->enableX( true );
grid->enableXMin( true );
grid->enableY( true );
grid->enableYMin( false );
grid->attach( this );//attach grid to plot
//add curve
d_curve = new QwtPlotCurve();
d_curve->setStyle( QwtPlotCurve::Lines );
d_curve->setPen(Qt::yellow);
d_curve->setPaintAttribute( QwtPlotCurve::ClipPolygons, false );
d_curve->attach( this );//attach curve to plot
for(int i=0; i<RESULT_LENGTH; ++i) {
d_x[i] = i;
}
}
OscilloscopePlot::OscilloscopePlot( QWidget *parent ):
QwtPlot( parent ),
d_paintedPoints( 0 ),
d_interval( 0.0, 10.0 ),
d_timerId( -1 )
{
d_directPainter = new QwtPlotDirectPainter();
setAutoReplot( false );
setCanvas( new Canvas() );
plotLayout()->setAlignCanvasToScales( true );
setAxisTitle( QwtPlot::xBottom, "Time [s]" );
setAxisScale( QwtPlot::xBottom, d_interval.minValue(), d_interval.maxValue() );
setAxisScale( QwtPlot::yLeft, -200.0, 200.0 );
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen( Qt::gray, 0.0, Qt::DotLine );
grid->enableX( true );
grid->enableXMin( true );
grid->enableY( true );
grid->enableYMin( false );
grid->attach( this );
d_origin = new QwtPlotMarker();
d_origin->setLineStyle( QwtPlotMarker::Cross );
d_origin->setValue( d_interval.minValue() + d_interval.width() / 2.0, 0.0 );
d_origin->setLinePen( Qt::gray, 0.0, Qt::DashLine );
d_origin->attach( this );
d_curve = new QwtPlotCurve();
d_curve->setStyle( QwtPlotCurve::Lines );
d_curve->setPen( canvas()->palette().color( QPalette::WindowText ) );
d_curve->setRenderHint( QwtPlotItem::RenderAntialiased, true );
d_curve->setPaintAttribute( QwtPlotCurve::ClipPolygons, false );
d_curve->setData( new CurveData() );
d_curve->attach( this );
}
Osc::Osc( QWidget * parent )
: QwtPlot( parent )
{
COscScaler * scaler = new COscScaler( this );
scaler->setWheelZoomX( true );
scaler->setWheelZoomY( true );
scaler->setEqualScales( false );
scaler->setSaveScales( false );
QwtPlotGrid * g = new QwtPlotGrid();
g->enableXMin( true );
g->enableYMin( true );
g->setPen( QPen( Qt::gray, 0.0, Qt::DotLine ) );
g->attach( this );
g = new QwtPlotGrid();
g->enableX( true );
g->enableY( true );
g->setPen( QPen( Qt::gray, 0.0, Qt::SolidLine ) );
g->attach( this );
canvas()->setBorderRadius( 10 );
plotLayout()->setAlignCanvasToScales( true );
// Nice background coloration.
QPalette pal = canvas()->palette();
QLinearGradient gr( 0.0, 0.0, 1.0, 1.0 );
gr.setCoordinateMode( QGradient::StretchToDeviceMode );
gr.setColorAt( 0.0, QColor( 200, 200, 230 ) );
gr.setColorAt( 1.0, QColor( 230, 230, 250 ) );
pal.setBrush( QPalette::Window, QBrush( gr ) );
canvas()->setPalette( pal );
canvas()->setBorderRadius( 10 );
plotLayout()->setAlignCanvasToScales( true );
m_timer = new QTimer( this );
connect( m_timer, SIGNAL(timeout()), this, SIGNAL(timeout()) );
}
void Histograma::populate(QImage *img)
{
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX(false);
grid->enableY(true);
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajorPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinorPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->attach(this);
int cinza, mQtd = 0;
int x, y;
// Quantidade de pontos de 0 a 255
const int pts = 256;
QVector<float> valores(pts);
// inicializa os valores com 0
for (int i = 0; i < pts; i++)
valores[i] = 0.0;
for (x = 0; x < img->width(); x++) {
for (y = 0; y < img->height(); y++) {
cinza = qGray(img->pixel(QPoint(x,y)));
valores[cinza]++;
if (valores[cinza] > mQtd)
mQtd = valores[cinza];
}
}
Histogram *hist = new Histogram("", Qt::black);
hist->setValues(pts, &valores);
hist->attach(this);
this->replot();
}
void TVPlot::populate()
{
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX( false );
grid->enableY( true );
grid->enableXMin( false );
grid->enableYMin( false );
grid->setMajorPen( Qt::black, 0, Qt::DotLine );
grid->attach( this );
const double juneValues[] = { 7, 19, 24, 32, 10, 5, 3 };
const double novemberValues[] = { 4, 15, 22, 34, 13, 8, 4 };
Histogram *histogramJune = new Histogram( "Summer", Qt::red );
histogramJune->setValues(
sizeof( juneValues ) / sizeof( double ), juneValues );
histogramJune->attach( this );
Histogram *histogramNovember = new Histogram( "Winter", Qt::blue );
histogramNovember->setValues(
sizeof( novemberValues ) / sizeof( double ), novemberValues );
histogramNovember->attach( this );
}
COscMain::COscMain()
: QMainWindow()
{
m_dev = new CUsbIo();
m_running = false;
ui.setupUi( this );
connect( ui.actionQuit, SIGNAL(triggered()), this, SLOT(close()) );
connect( ui.actionRun, SIGNAL(triggered()), this, SLOT(start()) );
connect( ui.actionConnect, SIGNAL(triggered()), this, SLOT(open()) );
COscScaler * scaler = new COscScaler( ui.plot );
scaler->setWheelZoomX( true );
scaler->setWheelZoomY( true );
scaler->setEqualScales( false );
scaler->setSaveScales( false );
QwtPlotGrid * g = new QwtPlotGrid();
g->enableXMin( true );
g->enableYMin( true );
g->setPen( QPen( Qt::gray, 0.0, Qt::DotLine ) );
g->attach( ui.plot );
g = new QwtPlotGrid();
g->enableX( true );
g->enableY( true );
g->setPen( QPen( Qt::gray, 0.0, Qt::SolidLine ) );
g->attach( ui.plot );
connect( this, SIGNAL(sigReplot()), this, SLOT(replot()), Qt::QueuedConnection );
ui.plot->canvas()->setBorderRadius( 10 );
ui.plot->plotLayout()->setAlignCanvasToScales( true );
// Nice background coloration.
QPalette pal = ui.plot->canvas()->palette();
QLinearGradient gr( 0.0, 0.0, 1.0, 1.0 );
gr.setCoordinateMode( QGradient::StretchToDeviceMode );
gr.setColorAt( 0.0, QColor( 200, 200, 230 ) );
gr.setColorAt( 1.0, QColor( 230, 230, 250 ) );
pal.setBrush( QPalette::Window, QBrush( gr ) );
ui.plot->canvas()->setPalette( pal );
m_ptsPerSecond = new QSpinBox();
m_ptsPerSecond->setRange( 1, 128 );
m_ptsPerSecond->setPrefix( tr( "Pts/sec" ) );
m_ptsPerSecond->setValue( 50 );
connect( m_ptsPerSecond, SIGNAL(editingFinished()), this, SLOT(settingsChanged()) );
m_seconds = new QSpinBox();
m_seconds->setRange( 1, 600 );
m_seconds->setPrefix( tr( "Seconds" ) );
m_seconds->setValue( 3 );
connect( m_seconds, SIGNAL(editingFinished()), this, SLOT(settingsChanged()) );
m_curvesCnt = new QSpinBox();
m_curvesCnt->setRange( 1, 10 );
m_curvesCnt->setValue( 3 );
m_curvesCnt->setPrefix( tr( "Curves" ) );
connect( m_curvesCnt, SIGNAL(editingFinished()), this, SLOT(curvesCntChanged()) );
ui.sb->addWidget( m_ptsPerSecond );
ui.sb->addWidget( m_seconds );
ui.sb->addWidget( m_curvesCnt );
ui.sb->adjustSize();
open();
curvesCntChanged();
settingsChanged();
/*if ( m_dev->isOpen() )
{
m_dev->setTimer( 12000, CUsbIo::T1024 );
m_dev->setTimer( 6000, CUsbIo::T1024 );
m_dev->setTimer( 255, CUsbIo::T1024 );
}*/
}
Plot::Plot(QWidget *parent):
QwtPlot(parent),
d_paintedPoints0(0),
d_paintedPoints1(0),
d_interval(0.0, 25.0),
d_timerId(-1)
{
d_directPainter0 = new QwtPlotDirectPainter();
setAutoReplot(false);
canvas()->setPaintAttribute(QwtPlotCanvas::BackingStore, false);
#if defined(Q_WS_X11)
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
if ( canvas()->testPaintAttribute( QwtPlotCanvas::BackingStore ) )
{
canvas()->setAttribute(Qt::WA_PaintOnScreen, true);
canvas()->setAttribute(Qt::WA_NoSystemBackground, true);
}
#endif
initGradient();
plotLayout()->setAlignCanvasToScales(true);
setAxisTitle(QwtPlot::xBottom, "Time [s]");
setAxisScale(QwtPlot::xBottom, d_interval.minValue(), d_interval.maxValue());
setAxisScale(QwtPlot::yLeft, 0, 10.0);
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen(QPen(Qt::green, 0.0, Qt::DotLine));
grid->enableX(true);
grid->enableXMin(true);
grid->enableY(true);
grid->enableYMin(false);
grid->attach(this);
d_origin = new QwtPlotMarker();
d_origin->setLineStyle(QwtPlotMarker::Cross);
d_origin->setValue(d_interval.minValue() + d_interval.width() / 2.0, 0.0);
d_origin->setLinePen(QPen(Qt::red, 0.0, Qt::DashLine));
d_origin->attach(this);
d_curve0 = new QwtPlotCurve();
d_curve0->setStyle(QwtPlotCurve::Lines);
d_curve0->setPen(QPen(Qt::green,3));
#if 1
d_curve0->setRenderHint(QwtPlotItem::RenderAntialiased, true);
#endif
#if 1
d_curve0->setPaintAttribute(QwtPlotCurve::ClipPolygons, false);
#endif
d_curve0->setData(new CurveData());
d_curve0->attach(this);
d_curve1 = new QwtPlotCurve();
d_curve1->setStyle(QwtPlotCurve::Lines);
d_curve1->setPen(QPen(Qt::red,3));
#if 1
d_curve1->setRenderHint(QwtPlotItem::RenderAntialiased, true);
#endif
#if 1
d_curve1->setPaintAttribute(QwtPlotCurve::ClipPolygons, false);
#endif
d_curve1->setData(new CurveData());
d_curve1->attach(this);
}
MainWindow::MainWindow(QWidget *parent): QMainWindow(parent)
{
// create menu bar and actions
createActions();
createMenus();
// initialize FFTW
m_main_signal = new DataFft();
m_qpoint_magnitude.resize(m_main_signal->get_fft_size());
setCentralWidget(new QWidget(this));
QVBoxLayout *layout = new QVBoxLayout;
layout->setSpacing(5);
layout->setMargin(15);
//------------qwt plot start---------------------
QString label;
label.sprintf( "FFT plot" );
QwtText text(label);
m_main_plot = new QwtPlot(text, parent);
m_main_plot->setCanvasBackground(QColor( Qt::darkBlue ));
m_main_plot->setAxisScale( QwtPlot::xBottom, 0, m_main_signal->get_fft_size() / 2 );
m_main_plot->setAxisTitle( QwtPlot::xBottom, "FFT points [-]" );
m_main_plot->setAxisScale( QwtPlot::yLeft, -250, 2 );
m_main_plot->setAxisTitle( QwtPlot::yLeft, "Sine magnitude [dB]" );
m_main_plot->enableAxis(QwtPlot::yRight,true);
m_main_plot->setAxisScale( QwtPlot::yRight, -250, 2 );
m_main_plot->enableAxis(QwtPlot::xTop,true);
m_main_plot->setAxisScale( QwtPlot::xTop, 0, m_main_signal->get_fft_size() / 2 );
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen( QPen( Qt::green, 0.0, Qt::DotLine ) );
grid->enableX( true );
grid->enableXMin( true );
grid->enableY( true );
grid->enableYMin( false );
grid->attach( m_main_plot );
m_slider_freq = new Slider(this, 2, sineStartValue);
m_main_plot->setCanvasBackground( QColor( Qt::white ) );
m_slider_scroll = new Slider(this, 2, 2500);
// add curve
m_main_curve = new QwtPlotCurve("Main curve");
// connect or copy the data to the curves
int iter = 0;
for(auto it = m_qpoint_magnitude.begin(); it != m_qpoint_magnitude.end(); it++ , iter++)
{
*it = QPointF(iter,iter); // initialize 'x' axis
}
layout->addWidget(m_slider_freq);
layout->addWidget(m_slider_scroll);
layout->addWidget(m_main_plot);
centralWidget()->setLayout(layout);
m_main_curve->setSamples(m_qpoint_magnitude);
m_main_curve->setPen(QPen(Qt::green));
m_main_curve->attach(m_main_plot);
// finally, refresh the plot
m_main_plot->replot();
}
void CurveWidget::initialize(bool zoom)
{
setContentsMargins(2, 2, 2, 2);
setMinimumHeight(338);
int _width = QApplication::desktop()->availableGeometry().width();
switch (_width) {
case 1280: q_width = 493; break;
case 1366: q_width = 532; break;
default: q_width = 493; break;
}
setFixedWidth(q_width);
plotLayout()->setAlignCanvasToScales( true);
setAutoReplot();
//setAxisAutoScale(QwtPlot::yLeft, false);
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen(QColor(80, 80, 80, 100), 0.5, Qt::SolidLine);
grid->enableX(true);
grid->enableY(true);
grid->attach(this);
q_origin = new QwtPlotMarker();
q_origin->setLineStyle( QwtPlotMarker::Cross);
q_origin->setLinePen(QColor(100, 100, 100, 100), 1.0, Qt::DashLine );
q_origin->attach(this);
setAxisScaleDraw(QwtPlot::xBottom, new TimeScaleDraw());
TimePlotPicker* picker = new TimePlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,
QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn, canvas());
picker->setStateMachine(new QwtPickerDragPointMachine());
picker->setRubberBandPen(QColor(100, 100, 100, 200));
picker->setTrackerPen(QColor(128, 128, 200, 200));
// zoomer
if (zoom) {
q_zoomer = new Zoomer(QwtPlot::xBottom, QwtPlot::yLeft, canvas());
q_zoomer->setRubberBand(QwtPicker::RectRubberBand);
q_zoomer->setRubberBandPen(QColor(Qt::green));
q_zoomer->setTrackerMode(QwtPicker::ActiveOnly);
q_zoomer->setTrackerPen(QColor(Qt::white));
}
// scale
//setAxisScale( QwtPlot::xBottom, 0, 200 );
//setAxisScale( QwtPlot::yLeft, 400, 800 );
//! curve
//srand(QDateTime::currentDateTime().fromMSecsSinceEpoch());
//
QVector<QPointF> samples(0);
addCurve("Curve 1", QPen(QColor("#0c78a6"), 1), samples);
addCurve("Curve 2", QPen(QColor("#5fd43b"), 1), samples);
// Legend
QwtPlotLegendItem* legendItem = new JLegendItem;
legendItem->setMaxColumns(q_curves.count());
legendItem->attach(this);
}
Plot::Plot(QWidget *parent):
QwtPlot(parent),
d_paintedPoints(0),
d_interval(0.0, 10.0),
d_timerId(-1)
{
d_directPainter = new QwtPlotDirectPainter();
setAutoReplot(false);
// The backing store is important, when working with widget
// overlays ( f.e rubberbands for zooming ).
// Here we don't have them and the internal
// backing store of QWidget is good enough.
canvas()->setPaintAttribute(QwtPlotCanvas::BackingStore, false);
#if defined(Q_WS_X11)
// Even if not recommended by TrollTech, Qt::WA_PaintOutsidePaintEvent
// works on X11. This has a nice effect on the performance.
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
// Disabling the backing store of Qt improves the performance
// for the direct painter even more, but the canvas becomes
// a native window of the window system, receiving paint events
// for resize and expose operations. Those might be expensive
// when there are many points and the backing store of
// the canvas is disabled. So in this application
// we better don't both backing stores.
if ( canvas()->testPaintAttribute( QwtPlotCanvas::BackingStore ) )
{
canvas()->setAttribute(Qt::WA_PaintOnScreen, true);
canvas()->setAttribute(Qt::WA_NoSystemBackground, true);
}
#endif
initGradient();
plotLayout()->setAlignCanvasToScales(true);
setAxisTitle(QwtPlot::xBottom, "Time [s]");
setAxisScale(QwtPlot::xBottom, d_interval.minValue(), d_interval.maxValue());
setAxisScale(QwtPlot::yLeft, -200.0, 200.0);
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen(QPen(Qt::gray, 0.0, Qt::DotLine));
grid->enableX(true);
grid->enableXMin(true);
grid->enableY(true);
grid->enableYMin(false);
grid->attach(this);
d_origin = new QwtPlotMarker();
d_origin->setLineStyle(QwtPlotMarker::Cross);
d_origin->setValue(d_interval.minValue() + d_interval.width() / 2.0, 0.0);
d_origin->setLinePen(QPen(Qt::gray, 0.0, Qt::DashLine));
d_origin->attach(this);
d_curve = new QwtPlotCurve();
d_curve->setStyle(QwtPlotCurve::Lines);
d_curve->setPen(QPen(Qt::green));
#if 1
d_curve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
#endif
#if 1
d_curve->setPaintAttribute(QwtPlotCurve::ClipPolygons, false);
#endif
d_curve->setData(new CurveData());
d_curve->attach(this);
}
ChartView::ChartView( QWidget * parent ) : QwtPlot( parent )
{
// void setupPalette()
{
QPalette pal = palette();
QLinearGradient gradient;
gradient.setCoordinateMode( QGradient::StretchToDeviceMode );
// gradient.setColorAt( 0.0, QColor( 0xcf, 0xcf, 0xc4 ) ); // pastel gray
// gradient.setColorAt( 1.0, QColor( 0xae, 0xc6, 0xcf ) ); // pastel blue
gradient.setColorAt( 0.0, QColor( 0xc1, 0xff, 0xc1 ) ); // darkseagreen
gradient.setColorAt( 1.0, QColor( 0xb4, 0xee, 0xb4 ) ); // darkseagreen 2
pal.setBrush( QPalette::Window, QBrush( gradient ) );
// QPalette::WindowText is used for the curve color
// pal.setColor( QPalette::WindowText, Qt::green );
setPalette( pal );
}
this->enableAxis( QwtPlot::yLeft, true );
this->enableAxis( QwtPlot::xBottom, true );
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setPen( Qt::gray, 0.0, Qt::DotLine );
grid->enableX( true );
grid->enableXMin( true );
grid->enableY( true );
grid->enableYMin( false );
grid->attach( this );
this->axisScaleEngine( QwtPlot::yLeft )->setAttribute( QwtScaleEngine::Floating, true );
this->axisScaleEngine( QwtPlot::xBottom )->setAttribute( QwtScaleEngine::Floating, true );
auto zoomer = new adplot::Zoomer( QwtPlot::xBottom, QwtPlot::yLeft, this->canvas() );
// Shift+LeftButton: zoom out to full size
// Double click: zoom out by 1
zoomer->setMousePattern( QwtEventPattern::MouseSelect2, Qt::LeftButton, Qt::ShiftModifier );
const QColor c( Qt::darkBlue );
zoomer->setRubberBandPen( c );
zoomer->setTrackerPen( c );
zoomer->autoYScaleHock( [&]( QRectF& rc ){ yScaleHock( rc ); } );
zoomer->autoYScale( true );
if ( auto panner = new QwtPlotPanner( canvas() ) ) {
panner->setAxisEnabled( QwtPlot::yRight, false );
panner->setMouseButton( Qt::MidButton );
}
if ( auto picker = new QwtPlotPicker( canvas() ) ) {
picker->setMousePattern( QwtEventPattern::MouseSelect1, Qt::RightButton );
picker->setStateMachine( new QwtPickerDragRectMachine() );
picker->setRubberBand( QwtPicker::RectRubberBand );
picker->setRubberBandPen( QColor(Qt::red) );
picker->setTrackerPen( QColor( Qt::blue ) );
connect( picker, static_cast< void(QwtPlotPicker::*)(const QRectF&) >(&QwtPlotPicker::selected), this, &ChartView::selected );
picker->setEnabled( true );
}
}