QTabWidget* ResultsPage::createDataTabWidget()
{
QTabWidget *tabWidget = new QTabWidget;
// Plot
m_plot = new QwtPlot(tabWidget);
m_plot->setCanvasBackground(Qt::white);
m_plot->setContextMenuPolicy(Qt::CustomContextMenu);
m_plot->setAutoReplot(false);
connect(m_plot, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(showPlotContextMenu(QPoint)));
// Picker to allow for selection of the closest curve and displays curve
// coordinates with a cross rubber band.
QwtPlotPicker *picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,
QwtPicker::CrossRubberBand, QwtPicker::ActiveOnly,
m_plot->canvas());
picker->setStateMachine(new QwtPickerDragPointMachine());
connect(picker, SIGNAL(appended(QPoint)), this, SLOT(pointSelected(QPoint)));
// Legend
QwtLegend* legend = new QwtLegend;
legend->setFrameStyle(QFrame::Box | QFrame::Sunken);
m_plot->insertLegend(legend, QwtPlot::BottomLegend);
#if QWT_VERSION >= 0x060100
connect(m_plot,
SIGNAL(legendDataChanged(QVariant,QList<QwtLegendData>)),
legend,
SLOT(updateLegend(QVariant,QList<QwtLegendData>)));
#endif
// Add the generic curves to the legend
QList<QPair<QString, Qt::GlobalColor> > pairs;
pairs << qMakePair(tr("Unselected Realization"), Qt::darkGray)
<< qMakePair(tr("Selected and Enabled Realization"), Qt::darkGreen)
<< qMakePair(tr("Selected and Disabled Realization"), Qt::darkRed);
QPair<QString, Qt::GlobalColor> pair;
foreach (pair, pairs) {
QwtPlotCurve *curve = new QwtPlotCurve(pair.first);
curve->setLegendIconSize(QSize(32, 8));
curve->setPen(QPen(QBrush(pair.second), 2));
curve->setLegendAttribute(QwtPlotCurve::LegendShowLine);
#if QWT_VERSION < 0x060100
curve->updateLegend(legend);
#else
m_plot->updateLegend(curve);
#endif
}
OdomPlot::OdomPlot(QWidget *parent)
: DataPlot(parent) {
for (int i = 0; i < PLOT_SIZE; ++i){
motionData[i] = 0.0; visionData[i] = 0.0; combinedData[i] = 0.0;
}
for (int i = 0; i < PLOT_SIZE-1; ++i){
motionDiff[i] = 0.0; visionDiff[i] = 0.0; combinedDiff[i] = 0.0;
}
setTitle("Odometry turn");
QwtPlotCurve *fcurve = new QwtPlotCurve("Vision");
fcurve->attach(this);
fcurve->setRawData(t, visionDiff, PLOT_SIZE-1);
fcurve->setPen(QPen(Qt::red));
QwtPlotCurve *rcurve = new QwtPlotCurve("Motion");
rcurve->attach(this);
rcurve->setRawData(t, motionDiff, PLOT_SIZE-1);
rcurve->setPen(QPen(Qt::blue));
QwtPlotCurve *vcurve = new QwtPlotCurve("Combined");
vcurve->attach(this);
vcurve->setRawData(t, combinedDiff, PLOT_SIZE-1);
vcurve->setPen(QPen(Qt::green));
setAxisScale(QwtPlot::xBottom, 0, PLOT_SIZE - 2);
setAxisScale(QwtPlot::yLeft, -10, 10);
}
CoronalZMPPlot::CoronalZMPPlot(QWidget *parent)
: DataPlot(parent) {
for (int i = 0; i < PLOT_SIZE; ++i) {
data_l[i] = 0.0;
data_r[i] = 0.0;
data_t[i] = 0.0;
}
setTitle("Coronal Plane");
QwtPlotCurve *curveL = new QwtPlotCurve("Left");
curveL->attach(this);
curveL->setRawData(t, data_l, PLOT_SIZE);
curveL->setPen(QPen(Qt::red));
QwtPlotCurve *curveR = new QwtPlotCurve("Right");
curveR->attach(this);
curveR->setRawData(t, data_r, PLOT_SIZE);
curveR->setPen(QPen(Qt::blue));
QwtPlotCurve *curveT = new QwtPlotCurve("Total");
curveT->attach(this);
curveT->setRawData(t, data_t, PLOT_SIZE);
setAxisScale(QwtPlot::xBottom, 0, PLOT_SIZE - 1);
setAxisScale(QwtPlot::yLeft, -100, 100);
}
//changing to angle x comparison plot
FsrPlot::FsrPlot(QWidget *parent)
: DataPlot(parent) {
for (int i = 0; i < PLOT_SIZE; ++i)
data_r2[i] = data_l[i] = data_r[i] = data_t[i] = 0.0;
setTitle("angleX");
QwtPlotCurve *curveL = new QwtPlotCurve("filtered angleX");
curveL->attach(this);
curveL->setRawData(t, data_l, PLOT_SIZE);
curveL->setPen(QPen(Qt::red));
QwtPlotCurve *curveR = new QwtPlotCurve("raw angleX");
curveR->attach(this);
curveR->setRawData(t, data_r, PLOT_SIZE);
curveR->setPen(QPen(Qt::blue));
// QwtPlotCurve *curveR2 = new QwtPlotCurve("Right2");
// curveR2->attach(this);
// curveR2->setRawData(t, data_r2, PLOT_SIZE);
// curveR2->setPen(QPen(Qt::black));
// QwtPlotCurve *curveT = new QwtPlotCurve("Total");
// curveT->attach(this);
// curveT->setRawData(t, data_t, PLOT_SIZE);
setAxisScale(QwtPlot::xBottom, 0, PLOT_SIZE - 1);
setAxisScale(QwtPlot::yLeft, -12, 12);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGenPlotWidget::updatePlotCurves()
{
// qDebug() << "StatsGenPlotWidget::updatePlotCurves" << "\n";
//Loop over each entry in the table
QwtPlotCurve* curve = NULL;
// Delete all the plots
qint32 nRows = m_PlotCurves.count();
for (qint32 r = nRows - 1; r >= 0; --r)
{
curve = m_PlotCurves[r];
curve->detach();
m_PlotCurves.remove(r);
delete curve;
}
nRows = m_TableModel->rowCount();
float xMax = 0.0;
float yMax = 0.0;
for (qint32 r = 0; r < nRows; ++r)
{
if (r == m_PlotCurves.size())
{
curve = new QwtPlotCurve("");
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
QColor c = QColor(m_TableModel->getColor(r));
c.setAlpha(UIA::Alpha);
curve->setPen(QPen(c));
curve->attach(m_PlotView);
m_PlotCurves.append(curve);
}
else
{
curve = m_PlotCurves[r];
QColor c = QColor(m_TableModel->getColor(r));
c.setAlpha(UIA::Alpha);
curve->setPen(QPen(c));
}
switch(m_DistributionType)
{
case DREAM3D::DistributionType::Beta:
createBetaCurve(r, xMax, yMax);
break;
case DREAM3D::DistributionType::LogNormal:
createLogNormalCurve(r, xMax, yMax);
break;
case DREAM3D::DistributionType::Power:
createPowerCurve(r, xMax, yMax);
break;
default:
break;
}
}
m_PlotView->replot();
}
Plot::Plot()
{
setTitle("A Simple QwtPlot Demonstration");
insertLegend(new QwtLegend(), QwtPlot::RightLegend);
// Set axis titles
setAxisTitle(xBottom, "x -->");
setAxisTitle(yLeft, "y -->");
// Insert new curves
QwtPlotCurve *cSin = new QwtPlotCurve("y = sin(x)");
#if QT_VERSION >= 0x040000
cSin->setRenderHint(QwtPlotItem::RenderAntialiased);
#endif
cSin->setPen(QPen(Qt::red));
cSin->attach(this);
QwtPlotCurve *cCos = new QwtPlotCurve("y = cos(x)");
#if QT_VERSION >= 0x040000
cCos->setRenderHint(QwtPlotItem::RenderAntialiased);
#endif
cCos->setPen(QPen(Qt::blue));
cCos->attach(this);
// Create sin and cos data
const int nPoints = 100;
cSin->setData(SimpleData(::sin, nPoints));
cCos->setData(SimpleData(::cos, nPoints));
// Insert markers
// ...a horizontal line at y = 0...
QwtPlotMarker *mY = new QwtPlotMarker();
mY->setLabel(QString::fromLatin1("y = 0"));
mY->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
mY->setLineStyle(QwtPlotMarker::HLine);
mY->setYValue(0.0);
mY->attach(this);
// ...a vertical line at x = 2 * pi
QwtPlotMarker *mX = new QwtPlotMarker();
mX->setLabel(QString::fromLatin1("x = 2 pi"));
mX->setLabelAlignment(Qt::AlignLeft | Qt::AlignBottom);
mX->setLabelOrientation(Qt::Vertical);
mX->setLineStyle(QwtPlotMarker::VLine);
mX->setLinePen(QPen(Qt::black, 0, Qt::DashDotLine));
mX->setXValue(2.0 * M_PI);
mX->attach(this);
}
void PlotWidget::AddPlotData(QString title, float* plotData, int size, bool showMarkers)
{
if(_curves.contains(title))
return;
QwtPointSeriesData *points = CreatePointSeriesFromArray(plotData, size);
QwtPlotCurve *curve = new QwtPlotCurve(title);
curve->setData(points);
//Устанавливается цвет
curve->setPen(QColor(255,0,0), 2.0);
if(size < 1000)
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
//Marker
if(_showMarkers || showMarkers)
{
/*QwtSymbol *symbol1 = new QwtSymbol();
symbol1->setStyle(QwtSymbol::Ellipse);
symbol1->setPen(QColor(Qt::black));
symbol1->setSize(4);*/
curve->setSymbol(GetDefaultMarker());
}
//Кривая добавляется на график
curve->attach(_plot);
//Добавляется в список кривых
_curves.insert(title, curve);
//Область рисования перерисовывается, если включен автоматический режим
CheckNReplot();
}
void Plot::insertCurve(Qt::Orientation o,
const QColor &c, double base)
{
QwtPlotCurve *curve = new QwtPlotCurve();
curve->setPen(c);
curve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,
Qt::gray, c, QSize(8, 8)));
double x[10];
double y[sizeof(x) / sizeof(x[0])];
for ( uint i = 0; i < sizeof(x) / sizeof(x[0]); i++ )
{
double v = 5.0 + i * 10.0;
if ( o == Qt::Horizontal )
{
x[i] = v;
y[i] = base;
}
else
{
x[i] = base;
y[i] = v;
}
}
curve->setSamples(x, y, sizeof(x) / sizeof(x[0]));
curve->attach(this);
}
QwtPlotCurve * PlotViewWidget::addCurveData(WaveformData *curveData, bool secondary, QColor col)
{
maWaveformData << curveData;
QwtPlotCurve *waveCurve = new QwtPlotCurve("dummy");
waveCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
waveCurve->setPen(QPen(col));
waveCurve->setSamples( curveData );
maCurves << waveCurve;
waveCurve->attach(this);
if( !mSecondaryAxis || maCurves.length() == 0 ) // no secondary axis or just one plot
{
replot();
setAxisScaleDiv(QwtPlot::yRight, axisScaleDiv(QwtPlot::yLeft));
replot();
}
else
{
if(secondary)
{
setAxisAutoScale(QwtPlot::yRight);
waveCurve->setYAxis(QwtPlot::yRight);
}
else
{
waveCurve->setYAxis(QwtPlot::yLeft);
}
}
repaint();
return waveCurve;
}
//---------------------------------------------------------------------------
void JrkPlotDialog::createCurve(QString title, QColor cl, bool on, double scale)
{
QwtPlotCurve *curve;
QPen pen;
curve = new QwtPlotCurve(title);
pen.setColor(cl);
pen.setWidth(2);
curve->setPen(pen);
curve->setPaintAttribute(QwtPlotCurve::ClipPolygons, true);
curve->setRenderHint( QwtPlotCurve::RenderAntialiased, true);
#if 0
QwtSplineCurveFitter* curveFitter = new QwtSplineCurveFitter();
curveFitter->setSplineSize(500);
curve->setCurveFitter(curveFitter);
#endif
curve->attach(ui->jrkPlot);
showCurve(curve, on);
jrkdata.push_back(new JrkPlotData(curve, scale, samples()));
// qDebug("Scale: %f", scale);
}
void Plot::add() {
Q_ASSERT(plotWidget && x && y && x->size()==y->size());
setIntervals();
for (int i = 0; i < intervals.size(); ++i) {
QwtPlotCurve *curve = new QwtPlotCurve(yLegend);
curve->setItemAttribute(QwtPlotItem::Legend, showLegend && i==0);
plotWidget->addCurve(curve);
if (type == Trace::Symbols) {
curve->setStyle(QwtPlotCurve::NoCurve);
}
if (type == Trace::Symbols || type == Trace::Both) {
Q_ASSERT(symbol);
curve->setSymbol(symbol);
}
if (type == Trace::Line || type == Trace::Both) {
curve->setPen(pen);
}
Interval iv = intervals[i];
int numPoints = iv.second - iv.first + 1;
if (numPoints <=0 )
Q_ASSERT(numPoints > 0);
curve->setSamples(x->data() + iv.first, y->data() + iv.first, numPoints);
}
}
void HistoricPlot::addCurve(quint32 idVariable, std::vector<VariablePoint> data)
{
m_zoomer->setZoomBase(true);
QwtPlotCurve *c = new QwtPlotCurve(QString("id : %1").arg(idVariable));
c->setPen( QColor(qrand() % 255,qrand() % 255,qrand() % 255), 2 ),
c->setRenderHint( QwtPlotItem::RenderAntialiased, true );
QwtSymbol *symbol = new QwtSymbol( QwtSymbol::Ellipse, QBrush( Qt::yellow ), QPen( Qt::red, 2 ), QSize( 5, 5 ) );
c->setSymbol( symbol );
QVector<VariablePoint> d2 = QVector<VariablePoint>::fromStdVector(data);
QVector<QPointF> cleanData;
for (int i = 0; i < data.size(); ++i) {
VariablePoint vp = d2.at(i);
qDebug() << QString("ID: %1, VALUE: %2").arg(vp.idVariable()).arg(vp.value().toDouble());
if (vp.value().type() == QVariant::Double)
cleanData.append(QPointF(QwtDate::toDouble(QDateTime::fromMSecsSinceEpoch(vp.timeStamp())),
vp.value().toDouble()));
else
cleanData.append(QPointF(QwtDate::toDouble(QDateTime::fromMSecsSinceEpoch(vp.timeStamp())),
(double)vp.value().toLongLong()));
}
c->setSamples(cleanData);
c->attach(this);
}
void CDataPlot::rebuild(void)
{
for(int ci = 0; ci < m_portalCurveMap.count(); ++ci)
{
if(m_portalCurveMap.values().at(ci))
{
m_portalCurveMap.values().at(ci)->detach();
delete m_portalCurveMap.values().at(ci);
}
}
m_portalCurveMap.clear();
if(m_algTreeModel)
{
QList<CPortal*> portals = m_algTreeModel->checkedPortalList();
foreach(CPortal *portal, portals)
{
if(!portal) continue;
QwtPlotCurve *curve = new QwtPlotCurve(portal->caption());
curve->setData(new CCurveData(portal));
curve->setPen(portal->dataColor(), 3);
curve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
curve->attach(this);
m_portalCurveMap[portal] = curve;
}
}
refresh();
}
void CentralWidget::initTmpPlotAndGL()
{
QwtPlot *plot = new QwtPlot(this);
plot->setTitle( "Plot Demo" );
plot->setCanvasBackground( Qt::white );
plot->setAxisScale( QwtPlot::yLeft, 0.0, 10.0 );
QwtPlotGrid *grid = new QwtPlotGrid();
grid->attach( plot );
QwtPlotCurve *curve = new QwtPlotCurve();
curve->setTitle( "Some Points" );
curve->setPen( Qt::blue, 4 ),
curve->setRenderHint( QwtPlotItem::RenderAntialiased, true );
QPolygonF points;
points << QPointF( 0.0, 4.4 ) << QPointF( 1.0, 3.0 )
<< QPointF( 2.0, 4.5 ) << QPointF( 3.0, 6.8 )
<< QPointF( 4.0, 7.9 ) << QPointF( 5.0, 7.1 );
curve->setSamples( points );
curve->attach( plot );
this->addTab(plot, tr("Tmp Plot"));
MyGLWidget *widget = new MyGLWidget(this);
this->addTab(widget, tr("Tmp OpenGL"));
}
void Plot::populate()
{
QwtPlotGrid *grid = new QwtPlotGrid();
grid->setMinorPen( Qt::black, 0, Qt::DashLine );
grid->enableXMin( true );
grid->attach( this );
QwtPlotCurve *curve = new QwtPlotCurve();
curve->setTitle("Some Points");
curve->setPen( Qt::blue, 4 ),
curve->setRenderHint( QwtPlotItem::RenderAntialiased, true );
QwtSymbol *symbol = new QwtSymbol( QwtSymbol::Ellipse,
QBrush( Qt::yellow ), QPen( Qt::red, 2 ), QSize( 8, 8 ) );
curve->setSymbol( symbol );
QPolygonF points;
points << QPointF( 10.0, 4.4 )
<< QPointF( 100.0, 3.0 ) << QPointF( 200.0, 4.5 )
<< QPointF( 300.0, 6.8 ) << QPointF( 400.0, 7.9 )
<< QPointF( 500.0, 7.1 ) << QPointF( 600.0, 7.9 )
<< QPointF( 700.0, 7.1 ) << QPointF( 800.0, 5.4 )
<< QPointF( 900.0, 2.8 ) << QPointF( 1000.0, 3.6 );
curve->setSamples( points );
curve->attach( this );
}
void Plot::drawPoints(){
QwtPlotCurve *curvePoints;
curvePoints = new QwtPlotCurve();
curvePoints->setPen(Qt::green);
curvePoints->setSamples(pointsArr);
curvePoints->attach(this);
this->replot();
}
QwtPlotCurve* Curves::createCurve(int i) const
{
QwtPlotCurve* curve = new QwtPlotCurve(file->header(i));
curve->setRenderHint(QwtPlotCurve::RenderAntialiased);
curve->setPen(QPen(QColor(rand() % 255, rand() % 255, rand() % 255), 2));
curve->setPaintAttribute(QwtPlotCurve::ClipPolygons);
return curve;
}
int main(int argc, char *argv[])
{
/*const int L = 10;
fftw_complex *in;
fftw_complex *out;
gsl_sf_bessel_k0_scaled(0.684684);
fftw_plan p;
in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*L);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*L);
p = fftw_plan_dft_1d(L, in, out,FFTW_FORWARD,FFTW_MEASURE);
fftw_execute(p);
fftw_destroy_plan(p);
fftw_free(in);
fftw_free(out);
QApplication a(argc, argv);
Ekg w;
w.show();
qDebug() << "sdfsdfsd";
std::cout << "ALKO PROJEKT CPP CHLOSTA!";
return a.exec();*/
QApplication a( argc, argv );
QwtPlot plot;
plot.setTitle( "Plot Demo" );
plot.setCanvasBackground( Qt::white );
plot.setAxisScale( QwtPlot::yLeft, 0.0, 10.0 );
plot.insertLegend( new QwtLegend() );
QwtPlotGrid *grid = new QwtPlotGrid();
grid->attach( &plot );
QwtPlotCurve *curve = new QwtPlotCurve();
curve->setTitle( "Some Points" );
curve->setPen( Qt::blue, 4 ),
curve->setRenderHint( QwtPlotItem::RenderAntialiased, true );
QwtSymbol *symbol = new QwtSymbol( QwtSymbol::Ellipse,
QBrush( Qt::yellow ), QPen( Qt::red, 2 ), QSize( 8, 8 ) );
curve->setSymbol( symbol );
QPolygonF points;
points << QPointF( 0.0, 4.4 ) << QPointF( 1.0, 3.0 )
<< QPointF( 2.0, 4.5 ) << QPointF( 3.0, 6.8 )
<< QPointF( 4.0, 7.9 ) << QPointF( 5.0, 7.1 );
curve->setSamples( points );
curve->attach( &plot );
plot.resize( 600, 400 );
plot.show();
return a.exec();
}
void Plot::drawLine(QColor color){
QwtPlotCurve *curvePoints;
curvePoints = new QwtPlotCurve();
curvePoints->setPen(color);
curvePoints->setSamples(pointsArr);
curvePoints->attach(this);
this->replot();
pointsArr.clear();
}
void PlotPropertiesGUI::selectedLine(int value)
{
QwtPlotCurve *plotCurve = internalCurves.value(currentCurve)->plotCurve;
// Changes only the curve style
QPen pen = plotCurve->pen();
pen.setStyle((Qt::PenStyle) value);
plotCurve->setPen(pen);
plotter->replot();
}
void PlotPropertiesGUI::curveWidthValue(int value)
{
QwtPlotCurve *plotCurve = internalCurves.value(currentCurve)->plotCurve;
// Changes only the curve width
QPen pen = plotCurve->pen();
pen.setWidth(value);
plotCurve->setPen(pen);
plotter->replot();
}
void Plot::setSignalColor(SignalData* signalData, QColor color)
{
if (!signalData)
{
return;
}
QwtPlotCurve* curve = mSignals.value(signalData);
assert(curve);
curve->setPen(QPen(color));
}
//using it for gyrY
CurrentPlot::CurrentPlot(QWidget *parent)
: DataPlot(parent) {
for (int i = 0; i < PLOT_SIZE; ++i) {
data[i] = 0.0; data2[i] = 0.0;
}
setTitle("gyroY");
QwtPlotCurve *fcurve = new QwtPlotCurve("filtered gyroY");
fcurve->attach(this);
fcurve->setRawData(t, data, PLOT_SIZE);
fcurve->setPen(QPen(Qt::red));
QwtPlotCurve *rcurve = new QwtPlotCurve("raw gyroY");
rcurve->attach(this);
rcurve->setRawData(t, data2, PLOT_SIZE);
rcurve->setPen(QPen(Qt::blue));
setAxisScale(QwtPlot::xBottom, 0, PLOT_SIZE - 1);
setAxisScale(QwtPlot::yLeft, -70, 70);
}
void RTVTPlotWindow::addCurveWithDataFromChannel(QVector<qreal> frequency, QVector<qreal> amplitude, unsigned int channel)
{
QwtPlotCurve *curve = new QwtPlotCurve(QString("Channel " + QString::number(channel)));
curve->setPen(selectPen());
curve->setSamples(frequency, amplitude);
curve->setAxes(QwtPlot::xBottom, QwtPlot::yLeft);
curves << curve;
channelStringList << curve->title().text();
channelListStringModel->setStringList(channelStringList);
}
WorkoutPlot()
{
workoutCurve = new QwtPlotCurve();
setTitle("Workout Chart");
QPen pen = QPen(Qt::blue,1.0);
workoutCurve->setPen(pen);
QColor brush_color = QColor(124, 91, 31);
brush_color.setAlpha(64);
workoutCurve->setBrush(brush_color);
workoutCurve->attach(this);
}
void MainWindow::sampleFormatChanged()
{
for (int i = 0; i < curves.size(); i++) {
curves[i].curve->detach();
delete curves[i].curve;
curves[i].data->clear();
delete curves[i].data;
}
curves.clear();
timeAxis.clear();
QList<sampleValue> sampleList = kwp.getSample();
int numSamples = settingsDialog->rate * settingsDialog->historySecs + 1;
timeAxis.clear();
for (int i = 0; i < numSamples; i++) {
timeAxis.prepend(-i / static_cast<double>(settingsDialog->rate));
}
int numColors = sizeof(colorList) / sizeof(QString);
for (int i = 0; i < sampleList.length(); i++) {
QwtPlotCurve* curve = new QwtPlotCurve;
QVector<double>* data = new QVector<double>();
data->reserve(numSamples+1);
data->fill(0, numSamples);
QColor curveColor;
curveColor.setNamedColor(colorList[i % numColors]);
int blockNum = sampleList.at(i).refs.at(0).blockNum;
int pos = sampleList.at(i).refs.at(0).pos;
blockLabels_t label = kwp.getBlockLabel(blockNum);
QString desc = label.desc[pos] + " " + label.subDesc[pos];
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
curve->setPen(curveColor);
curve->setTitle(desc);
curve->setRawSamples(timeAxis.constData(), data->constData(), numSamples);
curve->attach(ui->plot);
// set legend checked
QwtLegendItem *legendItem = qobject_cast<QwtLegendItem*>(ui->plot->legend()->find(curve));
if (legendItem) {
legendItem->setChecked(true);
}
curveAndData tmp;
tmp.curve = curve;
tmp.data = data;
curves.append(tmp);
}
}
void Plot::populate()
{
// Insert new curves
QwtPlotCurve *cSin = new QwtPlotCurve("y = sin(x)");
cSin->setRenderHint(QwtPlotItem::RenderAntialiased);
cSin->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
cSin->setPen(QPen(Qt::red));
cSin->attach(this);
QwtPlotCurve *cCos = new QwtPlotCurve("y = cos(x)");
cCos->setRenderHint(QwtPlotItem::RenderAntialiased);
cCos->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
cCos->setPen(QPen(Qt::blue));
cCos->attach(this);
// Create sin and cos data
cSin->setData(new FunctionData(::sin));
cCos->setData(new FunctionData(::cos));
// Insert markers
// ...a horizontal line at y = 0...
QwtPlotMarker *mY = new QwtPlotMarker();
mY->setLabel(QString::fromLatin1("y = 0"));
mY->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
mY->setLineStyle(QwtPlotMarker::HLine);
mY->setYValue(0.0);
mY->attach(this);
// ...a vertical line at x = 2 * pi
QwtPlotMarker *mX = new QwtPlotMarker();
mX->setLabel(QString::fromLatin1("x = 2 pi"));
mX->setLabelAlignment(Qt::AlignLeft | Qt::AlignBottom);
mX->setLabelOrientation(Qt::Vertical);
mX->setLineStyle(QwtPlotMarker::VLine);
mX->setLinePen(QPen(Qt::black, 0, Qt::DashDotLine));
mX->setXValue(2.0 * M_PI);
mX->attach(this);
}
void Plot::initCurves()
{
QwtPointSeriesData* data = new QwtPointSeriesData();
m_manager.GetPointSeriesData(data, ResourceManager::MF_0);
QwtPlotCurve* curve = new QwtPlotCurve(tr("measured data"));
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
curve->setLegendAttribute(QwtPlotCurve::LegendNoAttribute);
curve->setPen(QPen(Qt::red));
curve->attach(this);
curve->setData(data);
}
void VectorPlot::addLinePlot(const VectorQwtAdapter &adapter) {
setupPlot(adapter.boundingRect());
QwtPlotCurve *curve = new QwtPlotCurve();
QwtSymbol sym;
sym.setStyle(QwtSymbol::Cross);
sym.setPen(QColor(Qt::black));
sym.setSize(2);
curve->setSymbol(sym);
curve->setPen(QColor(Qt::darkGreen));
curve->setData(adapter);
curve->attach(plot);
}
void IncrementalPlot::startNewCurve()
{
if (!curves.empty())
curCurveOffset += curves.back()->dataSize();
QwtPlotCurve *newCurve = new QwtPlotCurve("Line");
newCurve->setStyle(QwtPlotCurve::Lines);
newCurve->setPaintAttribute(QwtPlotCurve::PaintFiltered);
newCurve->setPen(QColor(Qt::white));
const QColor &c = Qt::white;
newCurve->setSymbol(QwtSymbol(QwtSymbol::NoSymbol, QBrush(c), QPen(c), QSize(6, 6)));
curves.push_back(newCurve);
newCurve->attach(this);
}
