PlotterWidget::PlotterWidget(QWidget *parent): QCustomPlot(parent), m_main_scale(0), m_plots_container(0)
{
//clear the layout
plotLayout()->clear(); //clear all
/// a main scale object at LEFT
m_main_scale = new MainScale(this);
plotLayout()->addElement(0,0,m_main_scale);
/// an area with plots at RIGHT
m_plots_container = new PlotsContainer();
plotLayout()->addElement(0,1, m_plots_container);
/// a group for aligning graphs
m_group = new QCPMarginGroup(this);
getMainAxisRect()->setMarginGroup(QCP::msTop|QCP::msBottom, m_group);
setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables | QCP::iSelectAxes );
// SinglePlot * sp = new SinglePlot(this);
// spc::ContinousValuesLog * log = new spc::ContinousValuesLog;
// log->resize(100);
// for(int i = 0 ; i < log->size(); ++i)
// log->setValue(i, i);
// sp->updateDataWith(log);
// addSinglePlot(sp);
replot();
}
DrawInteraction::DrawInteraction(QWidget *parent) :
QCustomPlot(parent)
{
resize(600,400);
statusBar = new QStatusBar(this);
srand(QDateTime::currentDateTime().toTime_t());
setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectAxes |
QCP::iSelectLegend | QCP::iSelectPlottables);
xAxis->setRange(-8, 8);
yAxis->setRange(-5, 5);
axisRect()->setupFullAxesBox();
plotLayout()->insertRow(0);
plotLayout()->addElement(0, 0, new QCPPlotTitle(this, "Interaction Example"));
xAxis->setLabel("x Axis");
yAxis->setLabel("y Axis");
legend->setVisible(true);
QFont legendFont = font();
legendFont.setPointSize(10);
legend->setFont(legendFont);
legend->setSelectedFont(legendFont);
legend->setSelectableParts(QCPLegend::spItems); // legend box shall not be selectable, only legend items
addRandomGraph();
addRandomGraph();
addRandomGraph();
addRandomGraph();
// connect slot that ties some axis selections together (especially opposite axes):
connect(this, SIGNAL(selectionChangedByUser()), this, SLOT(selectionChanged()));
// connect slots that takes care that when an axis is selected, only that direction can be dragged and zoomed:
connect(this, SIGNAL(mousePress(QMouseEvent*)), this, SLOT(mousePress()));
connect(this, SIGNAL(mouseWheel(QWheelEvent*)), this, SLOT(mouseWheel()));
// make bottom and left axes transfer their ranges to top and right axes:
connect(xAxis, SIGNAL(rangeChanged(QCPRange)), xAxis2, SLOT(setRange(QCPRange)));
connect(yAxis, SIGNAL(rangeChanged(QCPRange)), yAxis2, SLOT(setRange(QCPRange)));
// connect some interaction slots:
connect(this, SIGNAL(titleDoubleClick(QMouseEvent*,QCPPlotTitle*)), this, SLOT(titleDoubleClick(QMouseEvent*,QCPPlotTitle*)));
connect(this, SIGNAL(axisDoubleClick(QCPAxis*,QCPAxis::SelectablePart,QMouseEvent*)), this, SLOT(axisLabelDoubleClick(QCPAxis*,QCPAxis::SelectablePart)));
connect(this, SIGNAL(legendDoubleClick(QCPLegend*,QCPAbstractLegendItem*,QMouseEvent*)), this, SLOT(legendDoubleClick(QCPLegend*,QCPAbstractLegendItem*)));
// connect slot that shows a message in the status bar when a graph is clicked:
connect(this, SIGNAL(plottableClick(QCPAbstractPlottable*,QMouseEvent*)), this, SLOT(graphClicked(QCPAbstractPlottable*)));
// setup policy and connect slot for context menu popup:
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequest(QPoint)));
}
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();
}
/*!
\param axisId Axis
\return Map for the axis on the canvas. With this map pixel coordinates can
translated to plot coordinates and vice versa.
\sa QwtScaleMap, transform(), invTransform()
*/
QwtScaleMap QwtPlot::canvasMap( int axisId ) const
{
QwtScaleMap map;
if ( !d_data->canvas )
return map;
map.setTransformation( axisScaleEngine( axisId )->transformation() );
const QwtScaleDiv &sd = axisScaleDiv( axisId );
map.setScaleInterval( sd.lowerBound(), sd.upperBound() );
if ( axisEnabled( axisId ) )
{
const QwtScaleWidget *s = axisWidget( axisId );
if ( axisId == yLeft || axisId == yRight )
{
double y = s->y() + s->startBorderDist() - d_data->canvas->y();
double h = s->height() - s->startBorderDist() - s->endBorderDist();
map.setPaintInterval( y + h, y );
}
else
{
double x = s->x() + s->startBorderDist() - d_data->canvas->x();
double w = s->width() - s->startBorderDist() - s->endBorderDist();
map.setPaintInterval( x, x + w );
}
}
else
{
const QRect &canvasRect = d_data->canvas->contentsRect();
if ( axisId == yLeft || axisId == yRight )
{
int top = 0;
if ( !plotLayout()->alignCanvasToScale( xTop ) )
top = plotLayout()->canvasMargin( xTop );
int bottom = 0;
if ( !plotLayout()->alignCanvasToScale( xBottom ) )
bottom = plotLayout()->canvasMargin( xBottom );
map.setPaintInterval( canvasRect.bottom() - bottom,
canvasRect.top() + top );
}
else
{
int left = 0;
if ( !plotLayout()->alignCanvasToScale( yLeft ) )
left = plotLayout()->canvasMargin( yLeft );
int right = 0;
if ( !plotLayout()->alignCanvasToScale( yRight ) )
right = plotLayout()->canvasMargin( yRight );
map.setPaintInterval( canvasRect.left() + left,
canvasRect.right() - right );
}
}
return map;
}
HistPlot::HistPlot(QWidget *parent):
QwtPlot(parent)
{
setCanvasBackground(QColor(Qt::black));
plotLayout()->setAlignCanvasToScales(true);
//QwtLegend *legend = new QwtLegend;
//legend->setItemMode(QwtLegend::CheckableItem);
//insertLegend(legend, QwtPlot::RightLegend);
//populate();
//connect(this, SIGNAL(legendChecked(QwtPlotItem *, bool)),
// SLOT(showItem(QwtPlotItem *, bool)));
//replot(); // creating the legend items
QwtPlotItemList items = itemList(QwtPlotItem::Rtti_PlotHistogram);
for ( int i = 0; i < items.size(); i++ )
{
if ( i == 0 )
{
//QwtLegendItem *legendItem = (QwtLegendItem *)legend->find(items[i]);
//if ( legendItem )
// legendItem->setChecked(true);
items[i]->setVisible(true);
}
else
items[i]->setVisible(false);
}
setAutoReplot(true);
}
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 );
}
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();
}
Plot2D::Plot2D(QWidget *parent) : QCustomPlot(parent), canvasBrush_(Qt::white) {
setBackgroundColor(canvasBrush_);
setAutoAddPlottableToLegend(false);
setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectAxes |
QCP::iSelectLegend | QCP::iSelectPlottables);
plotLayout()->clear();
}
RandomPlot::RandomPlot(QWidget *parent):
IncrementalPlot(parent),
d_timer(0),
d_timerCount(0)
{
setFrameStyle(QFrame::NoFrame);
setLineWidth(0);
setCanvasLineWidth(2);
plotLayout()->setAlignCanvasToScales(true);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->setMajPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->attach(this);
setCanvasBackground(QColor(29, 100, 141)); // nice blue
setAxisScale(xBottom, 0, c_rangeMax);
setAxisScale(yLeft, 0, c_rangeMax);
replot();
// enable zooming
(void) new Zoomer(canvas());
}
Plot::Plot(QWidget *parent):
QwtPlot(parent),
d_mapItem(NULL),
d_mapRect(0.0, 0.0, 100.0, 100.0) // something
{
#if 1
/*
d_mapRect is only a reference for zooming, but
the ranges are nothing useful for the user. So we
hide the axes.
*/
plotLayout()->setCanvasMargin(0);
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
enableAxis(axis, false);
#else
QwtPlotGrid *grid = new QwtPlotGrid();
grid->attach(this);
#endif
/*
Navigation:
Left Mouse Button: Panning
Mouse Wheel: Zooming In/Out
Right Mouse Button: Reset to initial
*/
(void)new QwtPlotPanner(canvas());
(void)new QwtPlotMagnifier(canvas());
canvas()->setFocusPolicy(Qt::WheelFocus);
rescale();
}
void matrixofpixels::HistogramPlotProperty(double Xmin, double Xmax, double Ymax)
{
changeitems();
setAxisAutoScale(this->xTop);
setAxisAutoScale(this->xBottom);
//setAxisFont(QwtPlot::xBottom,QFont("Helvetica",15,1));
QwtText xlabel("Value");
QwtText ylabel("Events");
QColor col(Qt::red);
xlabel.setColor(col);
ylabel.setColor(col);
xlabel.setFont(QFont("Helvetica",15,1));
ylabel.setFont(QFont("Helvetica",15,1));
setAxisTitle(QwtPlot::xBottom,xlabel);
setAxisTitle(QwtPlot::yLeft,ylabel);
setCanvasBackground(QColor(Qt::white));
setAxisScale(QwtPlot::xBottom, Xmin, Xmax);
setAxisMaxMinor(QwtPlot::xBottom, 0);
setAxisScale(QwtPlot::yLeft, 0, Ymax);
setAxisMaxMinor(QwtPlot::yLeft, 0);
plotLayout()->setAlignCanvasToScales(true);
his->attach(this);
/*QwtPlotGrid **/grid = new QwtPlotGrid;
grid->setMajPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->attach(this);
replot();
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent)
{
setAutoReplot( false );
setTitle( "Animated Curves" );
// hide all axes
for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
enableAxis( axis, false );
plotLayout()->setCanvasMargin( 10 );
d_curves[0] = new Curve1();
d_curves[1] = new Curve2();
d_curves[2] = new Curve3();
d_curves[3] = new Curve4();
updateCurves();
for ( int i = 0; i < CurveCount; i++ )
d_curves[i]->attach( this );
d_time.start();
( void )startTimer( 40 );
}
/*!
\param axisId Axis
\return Map for the axis on the canvas. With this map pixel coordinates can
translated to plot coordinates and vice versa.
\sa QwtScaleMap, transform(), invTransform()
*/
QwtScaleMap QwtPlot::canvasMap( int axisId ) const
{
QwtScaleMap map;
if ( !d_data->canvas )
return map;
map.setTransformation( axisScaleEngine( axisId )->transformation() );
const QwtScaleDiv *sd = axisScaleDiv( axisId );
map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
if ( axisEnabled( axisId ) )
{
const QwtScaleWidget *s = axisWidget( axisId );
if ( axisId == yLeft || axisId == yRight )
{
double y = s->y() + s->startBorderDist() - d_data->canvas->y();
double h = s->height() - s->startBorderDist() - s->endBorderDist();
map.setPaintInterval( y + h, y );
}
else
{
double x = s->x() + s->startBorderDist() - d_data->canvas->x();
double w = s->width() - s->startBorderDist() - s->endBorderDist();
map.setPaintInterval( x, x + w );
}
}
else
{
int margin = 0;
if ( !plotLayout()->alignCanvasToScales() )
margin = plotLayout()->canvasMargin( axisId );
const QRect &canvasRect = d_data->canvas->contentsRect();
if ( axisId == yLeft || axisId == yRight )
{
map.setPaintInterval( canvasRect.bottom() - margin,
canvasRect.top() + margin );
}
else
{
map.setPaintInterval( canvasRect.left() + margin,
canvasRect.right() - margin );
}
}
return map;
}
void Spectrogramplot::setYAxisRange(double yMin, double yMax)
{
yMin_ = yMin;
yMax_ = yMax;
data_->setInterval( Qt::YAxis, QwtInterval( yMin_, yMax_ ) );
plotLayout()->setAlignCanvasToScales(true);
replot();
}
void Spectrogramplot::setXAxisRange(double xMin, double xMax)
{
xMin_ = xMin;
xMax_ = xMax;
data_->setInterval( Qt::XAxis, QwtInterval( xMin_, xMax_ ) );
plotLayout()->setAlignCanvasToScales(true);
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;
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent ),
d_formatType( 0 ),
d_alpha(255)
{
d_spectrogram = new QwtPlotSpectrogram();
d_spectrogram->setRenderThreadCount( 0 ); // use system specific thread count
d_spectrogram->setCachePolicy( QwtPlotRasterItem::PaintCache );
QList<double> contourLevels;
for ( double level = 0.5; level < 10.0; level += 1.0 )
contourLevels += level;
d_spectrogram->setContourLevels( contourLevels );
d_spectrogram->setData( new SpectrogramData() );
d_spectrogram->attach( this );
const QwtInterval zInterval = d_spectrogram->data()->interval( Qt::ZAxis );
// A color bar on the right axis
QwtScaleWidget *rightAxis = axisWidget( QwtPlot::yRight );
rightAxis->setTitle( "Intensity" );
rightAxis->setColorBarEnabled( true );
setAxisScale( QwtPlot::yRight, zInterval.minValue(), zInterval.maxValue() );
enableAxis( QwtPlot::yRight );
plotLayout()->setAlignCanvasToScales( true );
setColorMap( Plot::RGBMap );
// LeftButton for the zooming
// MidButton for the panning
// RightButton: zoom out by 1
// Ctrl+RighButton: zoom out to full size
QwtPlotZoomer* zoomer = new MyZoomer( canvas() );
zoomer->setMousePattern( QwtEventPattern::MouseSelect2,
Qt::RightButton, Qt::ControlModifier );
zoomer->setMousePattern( QwtEventPattern::MouseSelect3,
Qt::RightButton );
QwtPlotPanner *panner = new QwtPlotPanner( canvas() );
panner->setAxisEnabled( QwtPlot::yRight, false );
panner->setMouseButton( Qt::MidButton );
// Avoid jumping when labels with more/less digits
// appear/disappear when scrolling vertically
const QFontMetrics fm( axisWidget( QwtPlot::yLeft )->font() );
QwtScaleDraw *sd = axisScaleDraw( QwtPlot::yLeft );
sd->setMinimumExtent( fm.width( "100.00" ) );
const QColor c( Qt::darkBlue );
zoomer->setRubberBandPen( c );
zoomer->setTrackerPen( c );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuSummaryQwtPlot::setDefaults()
{
QPalette newPalette(palette());
newPalette.setColor(QPalette::Background, Qt::white);
setPalette(newPalette);
setAutoFillBackground(true);
setCanvasBackground(Qt::white);
QFrame* canvasFrame = dynamic_cast<QFrame*>(canvas());
if (canvasFrame)
{
canvasFrame->setFrameShape(QFrame::NoFrame);
}
canvas()->setMouseTracking(true);
canvas()->installEventFilter(this);
QPen gridPen(Qt::SolidLine);
gridPen.setColor(Qt::lightGray);
m_grid->setPen(gridPen);
enableAxis(QwtPlot::xBottom, true);
enableAxis(QwtPlot::yLeft, true);
enableAxis(QwtPlot::xTop, false);
enableAxis(QwtPlot::yRight, false);
plotLayout()->setAlignCanvasToScales(true);
useDateBasedTimeAxis();
QFont xAxisFont = axisFont(QwtPlot::xBottom);
xAxisFont.setPixelSize(11);
setAxisFont(QwtPlot::xBottom, xAxisFont);
setAxisMaxMinor(QwtPlot::xBottom, 2);
QFont yAxisFont = axisFont(QwtPlot::yLeft);
yAxisFont.setPixelSize(11);
setAxisFont(QwtPlot::yLeft, yAxisFont);
setAxisMaxMinor(QwtPlot::yLeft, 3);
QwtText axisTitleY = axisTitle(QwtPlot::yLeft);
QFont yAxisTitleFont = axisTitleY.font();
yAxisTitleFont.setPixelSize(11);
yAxisTitleFont.setBold(false);
axisTitleY.setFont(yAxisTitleFont);
axisTitleY.setRenderFlags(Qt::AlignRight);
setAxisTitle(QwtPlot::yLeft, axisTitleY);
QwtLegend* legend = new QwtLegend(this);
// The legend will be deleted in the destructor of the plot or when
// another legend is inserted.
this->insertLegend(legend, BottomLegend);
}
QPointF SingleCellViewGraphPanelPlotWidget::mousePositionWithinCanvas(const QPoint &pPoint) const
{
// Return the mouse position relative to our canvas, after making sure that
// its mapped values are within our local ranges
QPoint realPoint = pPoint-plotLayout()->canvasRect().toRect().topLeft();
return QPointF(qMin(localMaxX(), qMax(localMinX(), canvasMap(QwtPlot::xBottom).invTransform(realPoint.x()))),
qMin(localMaxY(), qMax(localMinY(), canvasMap(QwtPlot::yLeft).invTransform(realPoint.y()))));
}
/*!
\brief Render the plot to a given rectangle ( f.e on a QPrinter, QSvgRenderer )
\param painter Painter
\param plotRect Bounding rectangle for the plot
*/
void QwtPolarPlot::renderTo( QPainter *painter, const QRect &plotRect ) const
{
if ( painter == 0 || !painter->isActive() ||
!plotRect.isValid() || size().isNull() )
{
return;
}
// All paint operations need to be scaled according to
// the paint device metrics.
QwtPainter::setMetricsMap( this, painter->device() );
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
int layoutOptions = QwtPolarLayout::IgnoreScrollbars
| QwtPolarLayout::IgnoreFrames;
(( QwtPolarPlot * )this )->plotLayout()->activate( this,
QwtPainter::metricsMap().deviceToLayout( plotRect ),
layoutOptions );
painter->save();
renderTitle( painter, plotLayout()->titleRect() );
painter->restore();
painter->save();
renderLegend( painter, plotLayout()->legendRect() );
painter->restore();
QRect canvasRect = plotLayout()->canvasRect();
canvasRect = metricsMap.layoutToDevice( canvasRect );
QwtPainter::setMetricsMap( painter->device(), painter->device() );
painter->save();
painter->setClipRect( canvasRect );
drawCanvas( painter, canvasRect );
painter->restore();
QwtPainter::resetMetricsMap();
(( QwtPolarPlot * )this )->plotLayout()->invalidate();
}
LinesVisualisation::LinesVisualisation(QWidget *parent) :
AbstractVisualisation(parent)
{
plotLayout()->addElement(0, 0, new QCPPlotTitle(this, "Parallel coordinates"));
xAxis->setLabel("Dimension");
yAxis->setLabel("Position");
m_titlePlot = "parallelCoordinates";
}
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 matrixofpixels::PixPlotSpect(int TypeOfSpec,QwtMatrixRasterData *rasterpixdata)
{
changeitems();
MapPlot->setData(rasterpixdata);
MapPlot->setRenderThreadCount(0);
setAxisAutoScale(this->xTop);
setAxisAutoScale(this->xBottom);
switch (TypeOfSpec)
{
case 1:
MapPlot->setColorMap(new ColorMap(BLUERED));
break;
case 2:
MapPlot->setColorMap(new ColorMap(BLACKWHITE));
break;
default:
MapPlot->setColorMap(new ColorMap(BLUERED));
}
MapPlot->attach(/*MainPlot*/this);
const QwtInterval zInterval = MapPlot->data()->interval(Qt::ZAxis);
setAxisScale(QwtPlot::xBottom, 0, Npix);
setAxisMaxMinor(QwtPlot::xBottom, 0);
setAxisScale(QwtPlot::yLeft, 0, Npix);
setAxisMaxMinor(QwtPlot::yLeft, 0);
//rightAxis = new QwtScaleWidget();
QwtScaleWidget *rightAxis = axisWidget(QwtPlot::yRight);
//rightAxis = axisWidget(QwtPlot::yRight);
rightAxis->setColorBarEnabled(true);
rightAxis->setColorBarWidth(20);
rightAxis->setColorMap(zInterval, new ColorMap(TypeOfSpec) );
//ColorMap(TypeOfSpec);
plotLayout()->setAlignCanvasToScales(true);
setAxisScale(QwtPlot::yRight,zInterval.minValue(),zInterval.maxValue());
enableAxis(QwtPlot::yRight);
replot();
setAutoFillBackground(true);
/**
setAutoFillBackground(true); - autozapolnenie, ctobi isklyuchit'
nalozjeniya graphikov
*/
}
void BarChart::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 );
}
//设置坐标轴的min max和step
setAxisScale( axis1, 0, d_barChartItem->dataSize() - 1, 1.0 );
setAxisAutoScale( axis2 );
QwtScaleDraw *scaleDraw1 = axisScaleDraw( axis1 );
scaleDraw1->enableComponent( QwtScaleDraw::Backbone, false );
scaleDraw1->enableComponent( QwtScaleDraw::Ticks, false );
QwtScaleDraw *scaleDraw2 = axisScaleDraw( axis2 );
scaleDraw2->enableComponent( QwtScaleDraw::Backbone, true );
scaleDraw2->enableComponent( QwtScaleDraw::Ticks, true );
plotLayout()->setAlignCanvasToScale( axis1, true );
plotLayout()->setAlignCanvasToScale( axis2, false );
plotLayout()->setCanvasMargin( 0 );
updateCanvasMargins();
replot();
}
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()) );
}
QPointF SingleCellViewGraphPanelPlotWidget::canvasPoint(const QPoint &pPoint,
const bool pNeedOffset) const
{
// Return the mouse position using canvas coordinates, making sure that they
// are within our ranges
QPointF realPoint = pPoint;
if (pNeedOffset)
realPoint -= plotLayout()->canvasRect().topLeft();
return QPointF(qMin(maxX(), qMax(minX(), canvasMap(QwtPlot::xBottom).invTransform(realPoint.x()))),
qMin(maxY(), qMax(minY(), canvasMap(QwtPlot::yLeft).invTransform(realPoint.y()))));
}
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
}
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));
}
/**
\brief Adjust plot content to its current size.
Must be reimplemented because the base implementation adds a mask causing an ugly drawing artefact.
*/
void Plot::updateLayout()
{
plotLayout()->activate(this, contentsRect());
// resize and show the visible widgets
if (!titleLabel()->text().isEmpty()){
titleLabel()->setGeometry(plotLayout()->titleRect());
if (!titleLabel()->isVisible())
titleLabel()->show();
} else
titleLabel()->hide();
for (int axisId = 0; axisId < axisCnt; axisId++ ){
if (axisEnabled(axisId) ){
axisWidget(axisId)->setGeometry(plotLayout()->scaleRect(axisId));
if (!axisWidget(axisId)->isVisible())
axisWidget(axisId)->show();
} else
axisWidget(axisId)->hide();
}
canvas()->setGeometry(plotLayout()->canvasRect());
}
TVPlot::TVPlot( QWidget *parent ):
QwtPlot( parent )
{
setTitle( "Watching TV during a weekend" );
QwtPlotCanvas *canvas = new QwtPlotCanvas();
canvas->setPalette( Qt::gray );
canvas->setBorderRadius( 10 );
setCanvas( canvas );
plotLayout()->setAlignCanvasToScales( true );
setAxisTitle( QwtPlot::yLeft, "Number of People" );
setAxisTitle( QwtPlot::xBottom, "Number of Hours" );
QwtLegend *legend = new QwtLegend;
legend->setDefaultItemMode( QwtLegendData::Checkable );
insertLegend( legend, QwtPlot::RightLegend );
populate();
connect( legend, SIGNAL( checked( const QVariant &, bool, int ) ),
SLOT( showItem( const QVariant &, bool ) ) );
replot(); // creating the legend items
QwtPlotItemList items = itemList( QwtPlotItem::Rtti_PlotHistogram );
for ( int i = 0; i < items.size(); i++ )
{
if ( i == 0 )
{
const QVariant itemInfo = itemToInfo( items[i] );
QwtLegendLabel *legendLabel =
qobject_cast<QwtLegendLabel *>( legend->legendWidget( itemInfo ) );
if ( legendLabel )
legendLabel->setChecked( true );
items[i]->setVisible( true );
}
else
{
items[i]->setVisible( false );
}
}
setAutoReplot( true );
}
