void caStripPlot::setAxis(double interval, double period)
{
// set axis and in case of a time scale define the time axis
if(thisXaxisType == TimeScale) {
QTime timeNow= QTime::currentTime();
timeNow = timeNow.addSecs((int) -interval);
setAxisScale(QwtPlot::xBottom, 0, interval);
setAxisScaleDraw ( QwtPlot::xBottom, new TimeScaleDraw (timeNow) );
} else {
setAxisScale(QwtPlot::xBottom, -period, 0);
setAxisScaleDraw(QwtPlot::xBottom, new QwtScaleDraw());
}
}
void
HrPwPlot::configChanged(qint32)
{
// setColors bg
setCanvasBackground(GColor(CPLOTBACKGROUND));
QPalette palette;
palette.setBrush(QPalette::Window, QBrush(GColor(CPLOTBACKGROUND)));
palette.setBrush(QPalette::Background, QBrush(GColor(CPLOTBACKGROUND)));
palette.setColor(QPalette::WindowText, GColor(CPLOTMARKER));
palette.setColor(QPalette::Text, GColor(CPLOTMARKER));
setPalette(palette);
// tick draw
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->setTickLength(QwtScaleDiv::MinorTick, 0);
setAxisScaleDraw(QwtPlot::xBottom, sd);
axisWidget(QwtPlot::xBottom)->setPalette(palette);
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(QwtPlot::yLeft, sd);
axisWidget(QwtPlot::yLeft)->setPalette(palette);
QPen gridPen;
gridPen.setColor(GColor(CPLOTGRID));
grid->setPen(gridPen);
}
ScatterPlot::ScatterPlot(Context *context) : context(context)
{
setAutoDelete(false); // no don't delete on detach !
curve = NULL;
curve2 = NULL;
hover = NULL;
hover2 = NULL;
grid = NULL;
ride = NULL;
static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame);
setAxisMaxMinor(xBottom, 0);
setAxisMaxMinor(yLeft, 0);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::xBottom, sd);
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(QwtPlot::yLeft, sd);
connect(context, SIGNAL(configChanged(qint32)), this, SLOT(configChanged(qint32)));
connect(context, SIGNAL(intervalHover(IntervalItem*)), this, SLOT(intervalHover(IntervalItem*)));
// lets watch the mouse move...
new mouseTracker(this);
configChanged(CONFIG_APPEARANCE | CONFIG_GENERAL); // use latest wheelsize/cranklength and colors
}
PerfPlot::PerfPlot() : STScurve(NULL), LTScurve(NULL), SBcurve(NULL), DAYcurve(NULL)
{
xsd = new PPTimeScaleDraw(QDateTime());
xsd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::xBottom, xsd);
insertLegend(new QwtLegend(), QwtPlot::BottomLegend);
setAxisTitle(yLeft, tr("Exponentially Weighted Average Stress"));
setAxisTitle(xBottom, tr("Time (days)"));
setAxisTitle(yRight, tr("Daily Stress"));
enableAxis(yRight, true);
static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame);
setAxisMaxMinor(xBottom, 0);
setAxisMaxMinor(yLeft, 0);
setAxisMaxMinor(yRight, 0);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::yLeft, sd);
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::yRight, sd);
grid = new QwtPlotGrid();
grid->attach(this);
configUpdate();
}
void BarChart::setOrientation( int o )
{
const Qt::Orientation orientation =
( o == 0 ) ? Qt::Vertical : Qt::Horizontal;
int axis1 = QwtPlot::xBottom;
int axis2 = QwtPlot::yLeft;
if ( orientation == Qt::Horizontal )
qSwap( axis1, axis2 );
d_barChartItem->setOrientation( orientation );
setAxisTitle( axis1, "Distros" );
setAxisMaxMinor( axis1, 3 );
setAxisScaleDraw( axis1, new DistroScaleDraw( orientation, d_distros ) );
setAxisTitle( axis2, "Hits per day ( HPD )" );
setAxisMaxMinor( axis2, 3 );
QwtScaleDraw *scaleDraw = new QwtScaleDraw();
scaleDraw->setTickLength( QwtScaleDiv::MediumTick, 4 );
setAxisScaleDraw( axis2, scaleDraw );
plotLayout()->setCanvasMargin( 0 );
replot();
}
CpintPlot::CpintPlot(Context *context, QString p, const Zones *zones, bool rangemode) :
path(p),
thisCurve(NULL),
CPCurve(NULL),
allCurve(NULL),
zones(zones),
series(RideFile::watts),
context(context),
current(NULL),
bests(NULL),
isFiltered(false),
shadeMode(2),
rangemode(rangemode)
{
setAutoFillBackground(true);
setAxisTitle(xBottom, tr("Interval Length"));
LogTimeScaleDraw *ld = new LogTimeScaleDraw;
ld->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(xBottom, ld);
setAxisScaleEngine(xBottom, new QwtLogScaleEngine);
QwtScaleDiv div( (double)0.017, (double)60 );
div.setTicks(QwtScaleDiv::MajorTick, LogTimeScaleDraw::ticks);
setAxisScaleDiv(QwtPlot::xBottom, div);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(yLeft, sd);
setAxisTitle(yLeft, tr("Average Power (watts)"));
setAxisMaxMinor(yLeft, 0);
plotLayout()->setAlignCanvasToScales(true);
//grid = new QwtPlotGrid();
//grid->enableX(true);
//grid->attach(this);
curveTitle.attach(this);
curveTitle.setXValue(5);
curveTitle.setYValue(60);
curveTitle.setLabel(QwtText("", QwtText::PlainText)); // default to no title
zoomer = new penTooltip(static_cast<QwtPlotCanvas*>(this->canvas()));
zoomer->setMousePattern(QwtEventPattern::MouseSelect1,
Qt::LeftButton, Qt::ShiftModifier);
canvasPicker = new LTMCanvasPicker(this);
static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame);
connect(canvasPicker, SIGNAL(pointHover(QwtPlotCurve*, int)), this, SLOT(pointHover(QwtPlotCurve*, int)));
configChanged(); // apply colors
ecp = new ExtendedCriticalPower(context);
extendedCPCurve4 = NULL;
extendedCurveTitle2 = NULL;
}
void ICResultChart::setOrientation(int orientation)
{
QwtPlot::Axis axis1, axis2;
if (orientation == 0) {
axis1 = QwtPlot::xBottom;
axis2 = QwtPlot::yLeft;
d_barChartItem->setOrientation(Qt::Vertical);
} else {
axis1 = QwtPlot::yLeft;
axis2 = QwtPlot::xBottom;
d_barChartItem->setOrientation(Qt::Horizontal);
}
setAxisTitle(axis2, tr("Number"));
setAxisTitle(axis1, tr("Answers"));
setAxisScaleDraw(axis1, new ChoicesScaleDraw(result.keys()));
setAxisScaleDraw(axis2, new QwtScaleDraw);
int size = result.size()-1 <= 0 ? 0: result.size()-1;
if (size == 0) {
setAxisAutoScale(axis1);
}
else {
setAxisScale(axis1, 0, size, 1.0);
}
int maxsize = 0;
foreach (int size, result.values()) {
if (maxsize < size) maxsize = size;
}
setAxisScale(axis2, 0, maxsize * 1.3);
QwtScaleDraw *scaleDraw1 = axisScaleDraw(axis1);
scaleDraw1->enableComponent(QwtScaleDraw::Backbone, false);
scaleDraw1->enableComponent(QwtScaleDraw::Ticks, false);
QwtScaleDraw *scaleDraw2 = axisScaleDraw(axis2);
scaleDraw2->enableComponent(QwtScaleDraw::Backbone, false);
scaleDraw2->enableComponent(QwtScaleDraw::Ticks, true);
//plotLayout()->setAlignCanvasToScales( true );
plotLayout()->setAlignCanvasToScale(axis1, true);
plotLayout()->setAlignCanvasToScale(axis2, false);
plotLayout()->setCanvasMargin(0);
updateCanvasMargins();
replot();
}
void EcgCh::setSignal(ECGSignalChannel signal, ECGChannelInfo info)
{
gsl_vector *v = signal->signal;
QVector<QPointF> samples;
for (long int i = 0; i < v->size; i++) {
samples.push_back(QPointF(float(i), float(v->data[i*v->stride])));
}
signalCurve->setSamples(samples);
setAxisScaleDraw(QwtPlot::xBottom, new TimeScaleDraw(info.frequecy));
setAxisScaleDraw(QwtPlot::yLeft, new GainScaleDraw(info.gain));
replot();
}
CpintPlot::CpintPlot(Context *context, QString p, const Zones *zones) :
path(p),
thisCurve(NULL),
CPCurve(NULL),
allCurve(NULL),
zones(zones),
series(RideFile::watts),
context(context),
current(NULL),
bests(NULL),
isFiltered(false),
shadeMode(2)
{
setInstanceName("CP Plot");
assert(!USE_T0_IN_CP_MODEL); // doesn't work with energyMode=true
setAxisTitle(xBottom, tr("Interval Length"));
LogTimeScaleDraw *ld = new LogTimeScaleDraw;
ld->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(xBottom, ld);
setAxisScaleEngine(xBottom, new LogTimeScaleEngine);
setAxisScale(xBottom, (double)0.017, (double)60);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(yLeft, sd);
setAxisTitle(yLeft, tr("Average Power (watts)"));
setAxisMaxMinor(yLeft, 0);
plotLayout()->setAlignCanvasToScales(true);
grid = new QwtPlotGrid();
grid->enableX(true);
grid->attach(this);
curveTitle.attach(this);
curveTitle.setXValue(5);
curveTitle.setYValue(20);
curveTitle.setLabel(QwtText("", QwtText::PlainText)); // default to no title
zoomer = new penTooltip(this->canvas());
zoomer->setMousePattern(QwtEventPattern::MouseSelect1,
Qt::LeftButton, Qt::ShiftModifier);
canvasPicker = new LTMCanvasPicker(this);
canvas()->setFrameStyle(QFrame::NoFrame);
connect(canvasPicker, SIGNAL(pointHover(QwtPlotCurve*, int)), this, SLOT(pointHover(QwtPlotCurve*, int)));
configChanged(); // apply colors
}
/**
* Tworzy wykres spektrogramu.
*
* Przygotowuje mapowanie kolorów, skale osi we właściwych jednostkach itp.
*
* @param parent obiekt rodzica
*/
SpectrogramPlot::SpectrogramPlot(QWidget* parent):
QwtPlot(tr("Wave file not loaded"), parent)
{
spectrogram = new QwtPlotSpectrogram();
QwtLinearColorMap colorMap(Qt::black, Qt::red);
colorMap.addColorStop(0.3, Qt::darkBlue);
colorMap.addColorStop(0.4, Qt::blue);
colorMap.addColorStop(0.65, Qt::green);
colorMap.addColorStop(0.85, Qt::yellow);
spectrogram->setColorMap(colorMap);
// kolorowa prawa oś
QwtScaleWidget *rightAxis = axisWidget(yRight);
rightAxis->setTitle(tr("Intensity [dB]"));
rightAxis->setColorBarEnabled(true);
enableAxis(yRight);
spectrogram->attach(this);
const QFontMetrics fmRight(rightAxis->font());
int intensityWidth = rightAxis->colorBarWidth() + fmRight.width("888 888");
axisScaleDraw(yRight)->setMinimumExtent(intensityWidth);
QwtPlotPanner *panner = new QwtPlotPanner(canvas());
panner->setAxisEnabled(QwtPlot::yRight, false);
panner->setMouseButton(Qt::MidButton);
// dolna oś
setAxisScaleDraw(xBottom, new DurationScaleDraw());
}
HistoricPlot::HistoricPlot(QWidget *parent)
:QwtPlot(parent)
{
//Fondo del canvas negro
canvas()->setPalette(Qt::black);
//Auto repintar las curvas
setAutoReplot(true);
setTitle("Historian Variable Plot");
// Grid
m_grid = new QwtPlotGrid;
m_grid->enableXMin( true );
m_grid->setMajorPen( Qt::gray, 0, Qt::DotLine );
m_grid->setMinorPen( Qt::darkGray, 0, Qt::DotLine );
m_grid->attach( this );
//Scale
m_scaleDraw = new QwtDateScaleDraw( Qt::UTC );
m_scaleDraw->setDateFormat( QwtDate::Millisecond, "hh:mm:ss:zzz\nddd dd MMM yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Second, "hh:mm:ss\nddd dd MMM yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Minute, "hh:mm\nddd dd MMM yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Hour, "hh:mm\nddd dd MMM yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Day, "ddd dd MMM yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Week, "Www yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Month, "MMM yyyy" );
m_scaleDraw->setDateFormat( QwtDate::Year, "yyyy");
m_scaleEngine = new QwtDateScaleEngine( Qt::UTC );
//Axis
setAxisTitle( QwtPlot::xBottom, QString( "Time" ) );
setAxisScaleDraw( QwtPlot::xBottom, m_scaleDraw );
setAxisScaleEngine( QwtPlot::xBottom, m_scaleEngine );
setAxisLabelRotation( QwtPlot::xBottom, -50.0 );
setAxisLabelAlignment( QwtPlot::xBottom, Qt::AlignLeft | Qt::AlignBottom );
setAxisTitle( QwtPlot::yLeft, QString( "Value" ) );
//Legend
m_legend = new QwtLegend;
insertLegend(m_legend);
//Zoomer
m_zoomer = new Zoomer( canvas() );
m_zoomer->setMousePattern( QwtEventPattern::MouseSelect2,
Qt::RightButton, Qt::ControlModifier );
m_zoomer->setMousePattern( QwtEventPattern::MouseSelect3,
Qt::RightButton );
//Panner
m_panner = new QwtPlotPanner( canvas() );
m_panner->setMouseButton( Qt::MidButton );
resize(800,600);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuSummaryQwtPlot::useDateBasedTimeAxis()
{
QwtDateScaleDraw* scaleDraw = new QwtDateScaleDraw(Qt::UTC);
scaleDraw->setDateFormat(QwtDate::Year, QString("dd-MM-yyyy"));
QwtDateScaleEngine* scaleEngine = new QwtDateScaleEngine(Qt::UTC);
setAxisScaleEngine(QwtPlot::xBottom, scaleEngine);
setAxisScaleDraw(QwtPlot::xBottom, scaleDraw);
}
void EcgCh::setSignal(ECGSignalChannel signal, ECGChannelInfo info)
{
gsl_vector *v = signal->signal;
int size = int(v->size);
samples->clear();
for (int i = 0; i < size; i++)
{
if ((float)(v->data[i*v->stride]) != 0.0)
samples->push_back(QPointF(float(i), float(v->data[i*v->stride])));
}
data->setSamples(*samples);
curve->setData(data);
setAxisScaleDraw(QwtPlot::xBottom, new TimeScaleDraw(info.frequecy));
setAxisScaleDraw(QwtPlot::yLeft, new GainScaleDraw(info.gain));
replot();
}
PlotWidget::PlotWidget(QWidget *parent) :
QwtPlot(parent),
ui(new Ui::PlotWidget)
{
ui->setupUi(this);
// Setup plot stuff
setAutoReplot(false);
canvas()->setBorderRadius( 10 );
plotLayout()->setAlignCanvasToScales(true);
QwtLegend *legend = new QwtLegend;
legend->setItemMode(QwtLegend::CheckableItem);
insertLegend(legend, QwtPlot::RightLegend);
setAxisTitle(QwtPlot::xBottom, " Time [s]");
setAxisScaleDraw(QwtPlot::xBottom,
new QwtScaleDraw());
setAxisAutoScale(QwtPlot::xBottom, false);
setAxisScale(QwtPlot::xBottom, 0, Market::EXPERIMENT_RUNNING_TIME);
setAxisLabelRotation(QwtPlot::xBottom, -50.0);
setAxisLabelAlignment(QwtPlot::xBottom, Qt::AlignLeft | Qt::AlignBottom);
setAxisTitle(QwtPlot::yLeft, " Price [$]");
setAxisScaleDraw(QwtPlot::yLeft,
new QwtScaleDraw());
setAxisScale(QwtPlot::yLeft, 0, MAX_PRICE_PLOT);
setAxisLabelRotation(QwtPlot::yLeft, -50.0);
setAxisLabelAlignment(QwtPlot::yLeft, Qt::AlignLeft | Qt::AlignBottom);
// Setup the data
asset1Data = new CircularBuffer((Market::EXPERIMENT_RUNNING_TIME)/2 + 4); // Running time, /2 for data every 2 seconds, + a safety buffer
asset2Data = new CircularBuffer((Market::EXPERIMENT_RUNNING_TIME)/2 + 4);
timeData = new CircularBuffer((Market::EXPERIMENT_RUNNING_TIME)/2 + 4);
asset1Curve = new QwtPlotCurve("Asset 1");
asset1Curve->setPen(QPen(Qt::red));
asset1Curve->attach(this);
asset2Curve = new QwtPlotCurve("Asset 2");
asset2Curve->setPen(QPen(Qt::blue));
asset2Curve->attach(this);
}
SweepInspector::SweepInspector(QWidget *parent) : QwtPlot(parent), data(NULL), d_curve(NULL), picker(NULL) {
setObjectName( "SweepData" );
setTitle( "RF Sweep" );
setAxisTitle( QwtPlot::xBottom, "Frequency");
setAxisTitle( QwtPlot::yLeft, QString( "Power Level (dBm)"));
setAutoReplot(true);
enableAxis(QwtPlot::xBottom, true);
enableAxis(QwtPlot::yLeft, true);
enableAxis(QwtPlot::xTop, false);
enableAxis(QwtPlot::yRight, false);
canvas = new QwtPlotCanvas();
canvas->setPalette( Qt::black );
canvas->setBorderRadius(0);
setCanvas(canvas);
//Allow zooming / panning
zoomer = new QwtPlotZoomer( canvas );
zoomer->setRubberBandPen( QColor( Qt::white ) );
zoomer->setTrackerPen( QColor( Qt::white ) );
connect(zoomer, SIGNAL(zoomed(const QRectF &)), this, SLOT(zoomed(const QRectF &)));
panner = new QwtPlotPanner( canvas );
panner->setMouseButton( Qt::MidButton );
//Show the X/Y markers that follow the mouse
picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft, QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn, canvas);
picker->setStateMachine( new QwtPickerTrackerMachine() );
picker->setRubberBandPen( QColor( Qt::cyan ) );
picker->setTrackerPen( QColor( Qt::cyan ) );
//FreqdBmPicker *er = new FreqdBmPicker(QwtPlot::xBottom, QwtPlot::yLeft, QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn, canvas);
//Setup grid
grid = new QwtPlotGrid();
grid->enableXMin( true );
grid->enableYMin( true );
QColor color(Qt::gray); color.setAlpha(128);
grid->setMajorPen( color, 1, Qt::DotLine );
grid->setMinorPen( color, 1, Qt::DotLine );
grid->attach( this );
//format in kHz, MHz, GHz, not raw values
setAxisScaleDraw(QwtPlot::xBottom, new FreqScaleDraw);
setAxisAutoScale(QwtPlot::xBottom, true);
//setAxisScale(QwtPlot::xBottom, 1, 4.4e9, 4.4e9 / 5.0);
//setAxisScale(QwtPlot::yLeft, -135, 20, 20.0);
setAxisScale(QwtPlot::yRight, 0, 10, 1);
setAxisScale(QwtPlot::xTop, 0, 10, 1);
repaint();
replot();
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent )
{
setObjectName( "FriedbergPlot" );
setTitle( "Temperature of Friedberg/Germany" );
setAxisTitle( QwtPlot::xBottom, "2007" );
setAxisScaleDiv( QwtPlot::xBottom, yearScaleDiv() );
setAxisScaleDraw( QwtPlot::xBottom, new YearScaleDraw() );
setAxisTitle( QwtPlot::yLeft,
QString( "Temperature [%1C]" ).arg( QChar( 0x00B0 ) ) );
// grid
QwtPlotGrid *grid = new Grid;
grid->attach( this );
insertLegend( new QwtLegend(), QwtPlot::RightLegend );
const int numDays = 365;
QVector<QPointF> averageData( numDays );
QVector<QwtIntervalSample> rangeData( numDays );
for ( int i = 0; i < numDays; i++ )
{
const Temperature &t = friedberg2007[i];
averageData[i] = QPointF( double( i ), t.averageValue );
rangeData[i] = QwtIntervalSample( double( i ),
QwtInterval( t.minValue, t.maxValue ) );
}
insertCurve( "Average", averageData, Qt::black );
insertErrorBars( "Range", rangeData, Qt::blue );
// LeftButton for the zooming
// MidButton for the panning
// RightButton: zoom out by 1
// Ctrl+RighButton: zoom out to full size
QwtPlotZoomer* zoomer = new QwtPlotZoomer( canvas() );
zoomer->setRubberBandPen( QColor( Qt::black ) );
zoomer->setTrackerPen( QColor( Qt::black ) );
zoomer->setMousePattern( QwtEventPattern::MouseSelect2,
Qt::RightButton, Qt::ControlModifier );
zoomer->setMousePattern( QwtEventPattern::MouseSelect3,
Qt::RightButton );
QwtPlotPanner *panner = new QwtPlotPanner( canvas() );
panner->setMouseButton( Qt::MidButton );
canvas()->setPalette( Qt::darkGray );
canvas()->setBorderRadius( 10 );
}
void PlotHRT::setData(ECGHRT &data)
{
offset = data.offset;
setAxisScaleDraw(QwtPlot::xBottom, new LabeledScaleDraw(offset));
rr->setSamples(data.rr);
QVector<QPointF> data_ts;
data_ts.push_back(data.ts.p1());
data_ts.push_back(data.ts.p2());
ts->setSamples(data_ts);
replot();
}
void
PowerHist::setYMax()
{
double MaxY = curve->maxYValue();
if (MaxY < curveSelected->maxYValue()) MaxY = curveSelected->maxYValue();
static const double tmin = 1.0/60;
setAxisScale(yLeft, (lny ? tmin : 0.0), MaxY * 1.1);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::yLeft, sd);
}
ScatterPlot::ScatterPlot(Context *context) : context(context)
{
setInstanceName("2D Plot");
all = NULL;
grid = NULL;
canvas()->setFrameStyle(QFrame::NoFrame);
setAxisMaxMinor(xBottom, 0);
setAxisMaxMinor(yLeft, 0);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::xBottom, sd);
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::yLeft, sd);
connect(context, SIGNAL(configChanged()), this, SLOT(configChanged()));
configChanged(); // use latest colors etc
}
ScatterPlot::ScatterPlot(Context *context) : context(context)
{
all = NULL;
grid = NULL;
static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame);
setAxisMaxMinor(xBottom, 0);
setAxisMaxMinor(yLeft, 0);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(QwtPlot::xBottom, sd);
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(QwtPlot::yLeft, sd);
connect(context, SIGNAL(configChanged()), this, SLOT(configChanged()));
configChanged(); // use latest colors etc
}
// Init X axis.
void DataPlot::initAxisX()
{
//QwtText xTitle("System Uptime [h:m:s]");
//xTitle.setFont(QFont("Ubuntu", 10));
//setAxisTitle(QwtPlot::xBottom, xTitle);
setAxisScaleDraw(QwtPlot::xBottom,new TimeScaleDraw(upTime()));
setAxisScale(QwtPlot::xBottom, 0, PLOT_SIZE );
setAxisLabelRotation(QwtPlot::xBottom, -50.0);
setAxisLabelAlignment(QwtPlot::xBottom, Qt::AlignLeft | Qt::AlignBottom);
QwtScaleWidget *scaleWidget = axisWidget(QwtPlot::xBottom);
const int fmh = QFontMetrics(scaleWidget->font()).height();
scaleWidget->setMinBorderDist(0, fmh / 2);
}
Plot::Plot(QWidget *parent, const char *name)
: QwtPlot(parent,name)
{
movedGraph=FALSE;
graphToResize=FALSE;
ShiftButton=FALSE;
d_lineWidth = 1;
minTickLength = 5;
majTickLength = 9;
setGeometry(QRect(0,0,500,400));
setAutoLegend(FALSE); // We don't want a Qwt legend
setAxisTitle(0, tr("Y Axis Title"));
setAxisTitle(2, tr("X Axis Title"));
//custom scale
for (int i= 0; i<QwtPlot::axisCnt; i++)
{
ticksType<<Out;
QwtScale *scale = (QwtScale *) axis(i);
if (scale)
scale->setBaselineDist(0);
ScaleDraw *sd= new ScaleDraw(1);
setAxisScaleDraw (i, sd);
}
QwtPlotLayout *pLayout=plotLayout();
pLayout->setCanvasMargin(0);
QwtPlotCanvas* plCanvas=canvas();
plCanvas->setFocusPolicy(QWidget::StrongFocus);
plCanvas->setFocusIndicator(QwtPlotCanvas::ItemFocusIndicator);
plCanvas->setFocus();
plCanvas->setFrameShadow( QwtPlot::Plain);
plCanvas->setCursor(Qt::arrowCursor);
plCanvas->setLineWidth(0);
setFocusPolicy(QWidget::StrongFocus);
setFocusProxy(plCanvas);
setFrameShape (QFrame::Box);
setFrameShadow(QFrame::Plain);
setLineWidth(0);
//setCanvasBackground (QColor(gray));
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent )
{
setTitle( "Trading Chart" );
QwtDateScaleDraw *scaleDraw = new DateScaleDraw( Qt::UTC );
QwtDateScaleEngine *scaleEngine = new QwtDateScaleEngine( Qt::UTC );
setAxisTitle( QwtPlot::xBottom, QString( "2010" ) );
setAxisScaleDraw( QwtPlot::xBottom, scaleDraw );
setAxisScaleEngine( QwtPlot::xBottom, scaleEngine );
setAxisLabelRotation( QwtPlot::xBottom, -50.0 );
setAxisLabelAlignment( QwtPlot::xBottom, Qt::AlignLeft | Qt::AlignBottom );
setAxisTitle( QwtPlot::yLeft, QString( "Price [EUR]" ) );
#if 0
QwtLegend *legend = new QwtLegend;
legend->setDefaultItemMode( QwtLegendData::Checkable );
insertLegend( legend, QwtPlot::RightLegend );
#else
Legend *legend = new Legend;
insertLegend( legend, QwtPlot::RightLegend );
#endif
populate();
// LeftButton for the zooming
// MidButton for the panning
// RightButton: zoom out by 1
// Ctrl+RighButton: zoom out to full size
Zoomer* zoomer = new Zoomer( canvas() );
zoomer->setMousePattern( QwtEventPattern::MouseSelect2,
Qt::RightButton, Qt::ControlModifier );
zoomer->setMousePattern( QwtEventPattern::MouseSelect3,
Qt::RightButton );
QwtPlotPanner *panner = new QwtPlotPanner( canvas() );
panner->setMouseButton( Qt::MidButton );
connect( legend, SIGNAL( checked( QwtPlotItem *, bool, int ) ),
SLOT( showItem( QwtPlotItem *, bool ) ) );
}
EEGPlot::EEGPlot(int channelId, QWidget *parent, const QObject* sender,
const char* dataSignal, unsigned int numChannels)
: QwtPlot(parent)
, m_channelId(channelId)
, m_firstPacket(true)
, m_numChannels(numChannels)
{
setAutoReplot(false);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
CENT::connect(sender, dataSignal, this, SLOT(dataReceived(CentData::AnalogData)));
m_curve = new QwtPlotCurve("signal channel");
m_curve->setStyle(QwtPlotCurve::Lines);
m_curve->setPen(QPen(Qt::darkBlue));
m_curve->setRenderHint(QwtPlotItem::RenderAntialiased, false);
m_curve->setPaintAttribute(QwtPlotCurve::ClipPolygons, true);
m_arraySeriesData = new ArraySeriesData();
m_curve->setData(m_arraySeriesData);
m_curve->attach(this);
// Canvas
setCanvasBackground(QBrush(Qt::white));
// Axes
enableAxis(QwtPlot::yLeft, true);
setAxisTitle(QwtPlot::yLeft, Y_AXIS_TEXT);
setAxisAutoScale(QwtPlot::yLeft, true);
setAxisScaleDraw(QwtPlot::yLeft, new IntegerScaleDraw);
setAxisAutoScale(QwtPlot::xBottom, false);
QwtText xText(tr(X_AXIS_TEXT_LOC));
setAxisTitle(QwtPlot::xBottom, xText);
CENT::connect(&m_redrawTimer, SIGNAL(timeout()), this, SLOT(replotManual()));
m_redrawTimer.setInterval(200);
m_redrawTimer.start();
}
void Plot::initAxis( int axis,
const QString& title, Qt::TimeSpec timeSpec )
{
setAxisTitle( axis, title );
QwtDateScaleDraw *scaleDraw = new QwtDateScaleDraw( timeSpec );
QwtDateScaleEngine *scaleEngine = new QwtDateScaleEngine( timeSpec );
#if 0
if ( timeSpec == Qt::LocalTime )
{
scaleDraw->setTimeSpec( Qt::OffsetFromUTC );
scaleDraw->setUtcOffset( 10 );
scaleEngine->setTimeSpec( Qt::OffsetFromUTC );
scaleEngine->setUtcOffset( 10 );
}
#endif
setAxisScaleDraw( axis, scaleDraw );
setAxisScaleEngine( axis, scaleEngine );
}
PfPvPlot::PfPvPlot(Context *context)
: rideItem (NULL), context(context), hover(NULL), cp_ (0), cad_ (85), cl_ (0.175), shade_zones(true)
{
static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame);
setAutoFillBackground(true);
setAxisTitle(yLeft, tr("Average Effective Pedal Force (N)"));
setAxisScale(yLeft, 0, 600);
setAxisTitle(xBottom, tr("Circumferential Pedal Velocity (m/s)"));
setAxisScale(xBottom, 0, 3);
setAxisMaxMinor(yLeft, 0);
setAxisMaxMinor(xBottom, 0);
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
setAxisScaleDraw(xBottom, sd);
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(yLeft, sd);
mX = new QwtPlotMarker();
mX->setLineStyle(QwtPlotMarker::VLine);
mX->attach(this);
mY = new QwtPlotMarker();
mY->setLineStyle(QwtPlotMarker::HLine);
mY->attach(this);
cpCurve = new QwtPlotCurve();
cpCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
cpCurve->attach(this);
curve = new QwtPlotCurve();
curve->attach(this);
cl_ = appsettings->value(this, GC_CRANKLENGTH).toDouble() / 1000.0;
// markup timeInQuadrant
tiqMarker[0] = new QwtPlotMarker(); tiqMarker[0]->attach(this);
tiqMarker[0]->setXValue(2.9);
tiqMarker[0]->setYValue(580);
tiqMarker[1] = new QwtPlotMarker(); tiqMarker[1]->attach(this);
tiqMarker[1]->setXValue(0.1);
tiqMarker[1]->setYValue(580);
tiqMarker[2] = new QwtPlotMarker(); tiqMarker[2]->attach(this);
tiqMarker[2]->setXValue(0.1);
tiqMarker[2]->setYValue(10);
tiqMarker[3] = new QwtPlotMarker(); tiqMarker[3]->attach(this);
tiqMarker[3]->setXValue(2.9);
tiqMarker[3]->setYValue(10);
merge_intervals = false;
frame_intervals = true;
// only default on first time through, after this the user may have adjusted
if (appsettings->value(this, GC_SHADEZONES, true).toBool()==false) shade_zones = false;
else shade_zones = true;
configChanged();
recalc();
}
CpuPlot::CpuPlot( QWidget *parent ):
QwtPlot( parent ),
dataCount( 0 ) {
setAutoReplot( false );
QwtPlotCanvas *canvas = new QwtPlotCanvas();
canvas->setBorderRadius( 10 );
setCanvas( canvas );
plotLayout()->setAlignCanvasToScales( true );
QwtLegend *legend = new QwtLegend;
legend->setDefaultItemMode( QwtLegendData::Checkable );
insertLegend( legend, QwtPlot::RightLegend );
setAxisTitle( QwtPlot::xBottom, "System Uptime [h:m:s]" );
setAxisScaleDraw( QwtPlot::xBottom,
new TimeScaleDraw( cpuStat.upTime() ) );
setAxisScale( QwtPlot::xBottom, 0, HISTORY );
//setAxisLabelRotation( QwtPlot::xBottom, -50.0 );
setAxisLabelRotation( QwtPlot::xBottom, 0.0 );
setAxisLabelAlignment( QwtPlot::xBottom, Qt::AlignLeft | Qt::AlignBottom );
/*
In situations, when there is a label at the most right position of the
scale, additional space is needed to display the overlapping part
of the label would be taken by reducing the width of scale and canvas.
To avoid this "jumping canvas" effect, we add a permanent margin.
We don't need to do the same for the left border, because there
is enough space for the overlapping label below the left scale.
*/
QwtScaleWidget *scaleWidget = axisWidget( QwtPlot::xBottom );
const int fmh = QFontMetrics( scaleWidget->font() ).height();
scaleWidget->setMinBorderDist( 0, fmh / 2 );
setAxisTitle( QwtPlot::yLeft, "Cpu Usage [%]" );
setAxisScale( QwtPlot::yLeft, 0, 100 );
//attach方法将元素关联到qwtplot空间上
Background *bg = new Background();
bg->attach( this );
CpuPieMarker *pie = new CpuPieMarker();
pie->attach( this );
CpuCurve *curve;
curve = new CpuCurve( "System" );
curve->setColor( Qt::red );
curve->attach( this );
data[System].curve = curve;
curve = new CpuCurve( "User" );
curve->setColor( Qt::blue );
curve->setZ( curve->z() - 1 );
curve->attach( this );
data[User].curve = curve;
curve = new CpuCurve( "Total" );
curve->setColor( Qt::black );
curve->setZ( curve->z() - 2 );
curve->attach( this );
data[Total].curve = curve;
curve = new CpuCurve( "Idle" );
curve->setColor( Qt::darkCyan );
curve->setZ( curve->z() - 3 );
curve->attach( this );
data[Idle].curve = curve;
showCurve( data[System].curve, true );
showCurve( data[User].curve, true );
showCurve( data[Total].curve, false );
showCurve( data[Idle].curve, false );
for ( int i = 0; i < HISTORY; i++ )
timeData[HISTORY - 1 - i] = i;
( void )startTimer( 1000 ); // 1 second
connect( legend, SIGNAL( checked( const QVariant &, bool, int ) ),
SLOT( legendChecked( const QVariant &, bool ) ) );
}
Plot::Plot(QWidget *parent, const char *name)
: QwtPlot(parent)
{
marker_key = 0;
curve_key = 0;
minTickLength = 5;
majTickLength = 9;
movedGraph=FALSE;
graphToResize=FALSE;
ShiftButton=FALSE;
setGeometry(QRect(0,0,500,400));
setAxisTitle(QwtPlot::yLeft, tr("Y Axis Title"));
setAxisTitle(QwtPlot::xBottom, tr("X Axis Title"));
// grid
d_grid = new Grid;
d_grid->enableX(false);
d_grid->enableY(false);
d_grid->setMajPen(QPen(Qt::blue, 0, Qt::SolidLine));
d_grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
d_grid->attach(this);
//custom scale
for (int i= 0; i<QwtPlot::axisCnt; i++)
{
QwtScaleWidget *scale = (QwtScaleWidget *) axisWidget(i);
if (scale)
{
scale->setMargin(0);
//the axis title color must be initialized
QwtText title = scale->title();
title.setColor(Qt::black);
scale->setTitle(title);
ScaleDraw *sd = new ScaleDraw();
sd->setTickLength (QwtScaleDiv::MinorTick, minTickLength);
sd->setTickLength (QwtScaleDiv::MediumTick, minTickLength);
sd->setTickLength (QwtScaleDiv::MajorTick, majTickLength);
setAxisScaleDraw (i, sd);
}
}
QwtPlotLayout *pLayout=plotLayout();
pLayout->setCanvasMargin(0);
QwtPlotCanvas* plCanvas = canvas();
plCanvas->setFocusPolicy(QWidget::StrongFocus);
plCanvas->setFocusIndicator(QwtPlotCanvas::ItemFocusIndicator);
plCanvas->setFocus();
plCanvas->setFrameShadow(QwtPlot::Plain);
plCanvas->setCursor(Qt::arrowCursor);
plCanvas->setLineWidth(0);
setFocusPolicy(QWidget::StrongFocus);
setFocusProxy(plCanvas);
setFrameShape (QFrame::Box);
setLineWidth(0);
}
MUPlot::MUPlot(MUWidget *muw, CriticalPowerWindow *parent, Context *context)
: QwtPlot(parent), QwtSyntheticPointData(MUN),
context(context), muw(muw), parent(parent), modelCurve(NULL), slowCurve(NULL), fastCurve(NULL), mmpCurve(NULL)
{
// initalise all the model stufff
// probably abstract this out later
muSet = NULL;
slowHandle = NULL;
slowLine = NULL;
slowDrag = false;
fastHandle = NULL;
fastLine = NULL;
fastDrag = false;
setAutoDelete(false);
setAutoFillBackground(true);
static_cast<QwtPlotCanvas*>(canvas())->setFrameStyle(QFrame::NoFrame);
// left yAxis scale prettify
QwtScaleDraw *sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(yLeft, sd);
setAxisTitle(yLeft, tr("w(x)"));
setAxisMaxMinor(yLeft, 0);
plotLayout()->setAlignCanvasToScales(true);
// 0.5 increments on bottom axis
QwtValueList ytick[QwtScaleDiv::NTickTypes];
for (double i=0.0f; i<=10.0f; i+= 1.0)
ytick[QwtScaleDiv::MajorTick]<<i;
setAxisScaleDiv(yLeft,QwtScaleDiv(0.0f,10.0f,ytick));
// bottom xAxis scale prettify
sd = new QwtScaleDraw;
sd->setTickLength(QwtScaleDiv::MajorTick, 3);
sd->enableComponent(QwtScaleDraw::Ticks, false);
sd->enableComponent(QwtScaleDraw::Backbone, false);
setAxisScaleDraw(xBottom, sd);
setAxisTitle(xBottom, tr("Motor Unit, x"));
setAxisMaxMinor(xBottom, 0);
// 0.2 increments on bottom axis
QwtValueList xtick[QwtScaleDiv::NTickTypes];
for (double i=0.0f; i<=1.0f; i+= 0.2)
xtick[QwtScaleDiv::MajorTick]<<i;
setAxisScaleDiv(xBottom,QwtScaleDiv(0.0f,1.0f,xtick));
// now color everything we created
configChanged(CONFIG_APPEARANCE);
// set to a 2 Normal Model
setModel(2);
// set mouse tracker
parent->setMouseTracking(true);
installEventFilter(parent);
new muMouseTracker(this);
}
Plot::Plot (QString name, QWidget *p) : QwtPlot (p)
{
//TODO
high = 0;
low = 0;
destroying = false;
//PlotSettings
_plotSettings.name = name;
_plotSettings.spacing = 4;
_plotSettings.high = 0;
_plotSettings.low = 0;
_plotSettings.startPos = -1;
_plotSettings.endPos = -1;
_plotSettings.selected = 0;
_plotSettings.antiAlias = TRUE;
_plotSettings.barLength = BarLength::_DAILY;
_plotSettings.status = PlotStatus::_NONE;
_plotSettings.info = TRUE;
mpage = 360; //default
setMinimumHeight(20);
setCanvasBackground(QColor(Qt::black));
setMargin(0);
enableAxis(QwtPlot::yRight, TRUE);
enableAxis(QwtPlot::yLeft, FALSE);
// add custom date scale drawing class to plot
_dateScaleDraw = new PlotDateScaleDraw;
setAxisScaleDraw(QwtPlot::xBottom, _dateScaleDraw);
// add custom date scale drawing class to plot
_plotScaleDraw = new PlotScaleDraw;
setAxisScaleDraw(QwtPlot::yRight, _plotScaleDraw);
_grid = new QwtPlotGrid;
// _grid->enableXMin(FALSE);
_grid->enableX(FALSE);
_grid->enableYMin(FALSE);
_grid->setMajPen(QPen(Qt::gray, 0, Qt::DotLine));
_grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
_grid->setYAxis(QwtPlot::yRight);
_grid->attach(this);
// try to set the scale width to a sane size to keep plots aligned
QwtScaleWidget *sw = axisWidget(QwtPlot::yRight);
sw->scaleDraw()->setMinimumExtent(60);
// setup the mouse events handler
_picker = new PlotPicker(this);
connect(_picker, SIGNAL(signalMouseMove(QPoint)), this, SLOT(mouseMove(QPoint)));
connect(_picker, SIGNAL(signalMouseClick(int, QPoint)), this, SLOT(mouseClick(int, QPoint)));
connect(_picker, SIGNAL(signalMouseDoubleClick(int, QPoint)), this, SLOT(mouseDoubleClick(int, QPoint)));
// connect(_picker, SIGNAL(signalMouseRelease(int, QPoint)), this, SLOT(mouseRelease(int, QPoint)));
// setup the context menu
createMenu();
// grabGesture(Qt::TapAndHoldGesture);
// grabGesture(Qt::SwipeGesture);
_plotInfo = new PlotInfo;
_plotInfo->attach(this);
}