QCPGraph Class Reference

A plottable representing a graph in a plot. More...

#include <qcustomplot.h>

Inherits QCPAbstractPlottable.

Public Types
enum	LineStyle {   LSNone, LSLine, LSStepLeft, LSStepRight,   LSStepCenter, LSImpulse }
enum	ScatterStyle {   SSNone, SSDot, SSCross, SSPlus,   SSCircle, SSDisc, SSSquare, SSStar,   SSTriangle, SSTriangleInverted, SSCrossSquare, SSPlusSquare,   SSCrossCircle, SSPlusCircle, SSPeace, SSPixmap }
enum	ErrorType { ETNone, ETKey, ETValue, ETBoth }

Public Slots
const QCPDataMap *	data () const
LineStyle	lineStyle () const
ScatterStyle	scatterStyle () const
double	scatterSize () const
const QPixmap	scatterPixmap () const
ErrorType	errorType () const
QPen	errorPen () const
double	errorBarSize () const
bool	errorBarSkipSymbol () const
QCPGraph *	channelFillGraph () const
void	setData (QCPDataMap *data, bool copy=false)
void	setData (const QVector< double > &key, const QVector< double > &value)
void	setDataKeyError (const QVector< double > &key, const QVector< double > &value, const QVector< double > &keyError)
void	setDataKeyError (const QVector< double > &key, const QVector< double > &value, const QVector< double > &keyErrorMinus, const QVector< double > &keyErrorPlus)
void	setDataValueError (const QVector< double > &key, const QVector< double > &value, const QVector< double > &valueError)
void	setDataValueError (const QVector< double > &key, const QVector< double > &value, const QVector< double > &valueErrorMinus, const QVector< double > &valueErrorPlus)
void	setDataBothError (const QVector< double > &key, const QVector< double > &value, const QVector< double > &keyError, const QVector< double > &valueError)
void	setDataBothError (const QVector< double > &key, const QVector< double > &value, const QVector< double > &keyErrorMinus, const QVector< double > &keyErrorPlus, const QVector< double > &valueErrorMinus, const QVector< double > &valueErrorPlus)
void	setLineStyle (int ls)
void	setScatterStyle (int ss)
void	setScatterSize (double size)
void	setScatterPixmap (const QPixmap &pixmap)
void	setErrorType (ErrorType errorType)
void	setErrorPen (const QPen &pen)
void	setErrorBarSize (double size)
void	setErrorBarSkipSymbol (bool enabled)
void	setChannelFillGraph (QCPGraph *targetGraph)
void	addData (const QCPDataMap &dataMap)
void	addData (const QCPData &data)
void	addData (double key, double value)
void	addData (const QVector< double > &keys, const QVector< double > &values)
void	removeDataBefore (double key)
void	removeDataAfter (double key)
void	removeData (double fromKey, double toKey)
void	removeData (double key)
virtual void	clearData ()
Public Slots inherited from QCPAbstractPlottable
QCustomPlot *	parentPlot () const
QString	name () const
bool	visible () const
QPen	pen () const
QBrush	brush () const
QCPAxis *	keyAxis () const
QCPAxis *	valueAxis () const
void	setName (const QString &name)
void	setVisible (bool visible)
void	setPen (const QPen &pen)
void	setBrush (const QBrush &brush)
void	setKeyAxis (QCPAxis *axis)
void	setValueAxis (QCPAxis *axis)
void	rescaleAxes (bool onlyEnlarge=false) const
void	rescaleKeyAxis (bool onlyEnlarge=false) const
void	rescaleValueAxis (bool onlyEnlarge=false) const
virtual void	clearData ()=0
virtual bool	addToLegend () const
virtual bool	removeFromLegend () const

Public Member Functions
	QCPGraph (QCPAxis *keyAxis, QCPAxis *valueAxis)
virtual	~QCPGraph ()
virtual void	rescaleAxes (bool onlyEnlarge, bool includeErrorBars) const
virtual void	rescaleKeyAxis (bool onlyEnlarge, bool includeErrorBars) const
virtual void	rescaleValueAxis (bool onlyEnlarge, bool includeErrorBars) const
Public Member Functions inherited from QCPAbstractPlottable
	QCPAbstractPlottable (QCPAxis *keyAxis, QCPAxis *valueAxis)
virtual	~QCPAbstractPlottable ()

Protected Member Functions
virtual void	draw (QPainter *painter) const
virtual void	drawLegendIcon (QPainter *painter, const QRect &rect) const
void	getPlotData (QVector< QPointF > *lineData, QVector< QCPData > *pointData) const
void	getScatterPlotData (QVector< QCPData > *pointData) const
void	getLinePlotData (QVector< QPointF > *lineData, QVector< QCPData > *pointData) const
void	getStepLeftPlotData (QVector< QPointF > *lineData, QVector< QCPData > *pointData) const
void	getStepRightPlotData (QVector< QPointF > *lineData, QVector< QCPData > *pointData) const
void	getStepCenterPlotData (QVector< QPointF > *lineData, QVector< QCPData > *pointData) const
void	getImpulsePlotData (QVector< QPointF > *lineData, QVector< QCPData > *pointData) const
void	drawFill (QPainter *painter, QVector< QPointF > *lineData) const
void	drawScatterPlot (QPainter *painter, QVector< QCPData > *pointData) const
void	drawLinePlot (QPainter *painter, QVector< QPointF > *lineData) const
void	drawImpulsePlot (QPainter *painter, QVector< QPointF > *lineData) const
void	drawScatter (QPainter *painter, double x, double y, ScatterStyle style) const
void	drawError (QPainter *painter, double x, double y, const QCPData &data) const
void	getVisibleDataBounds (QCPDataMap::const_iterator &lower, QCPDataMap::const_iterator &upper, int &count) const
void	addFillBasePoints (QVector< QPointF > *lineData) const
void	removeFillBasePoints (QVector< QPointF > *lineData) const
QPointF	lowerFillBasePoint (double lowerKey) const
QPointF	upperFillBasePoint (double upperKey) const
const QPolygonF	getChannelFillPolygon (const QVector< QPointF > *lineData) const
int	findIndexBelowX (const QVector< QPointF > *data, double x) const
int	findIndexAboveX (const QVector< QPointF > *data, double x) const
int	findIndexBelowY (const QVector< QPointF > *data, double y) const
int	findIndexAboveY (const QVector< QPointF > *data, double y) const
virtual QCPRange	getKeyRange (bool &validRange, SignDomain inSignDomain=SDBoth) const
virtual QCPRange	getValueRange (bool &validRange, SignDomain inSignDomain=SDBoth) const
virtual QCPRange	getKeyRange (bool &validRange, SignDomain inSignDomain, bool includeErrors) const
virtual QCPRange	getValueRange (bool &validRange, SignDomain inSignDomain, bool includeErrors) const
Protected Member Functions inherited from QCPAbstractPlottable
void	coordsToPixels (double key, double value, double &x, double &y) const
const QPointF	coordsToPixels (double key, double value) const

Protected Attributes
QCPDataMap *	mData
QPen	mErrorPen
LineStyle	mLineStyle
ScatterStyle	mScatterStyle
double	mScatterSize
QPixmap	mScatterPixmap
ErrorType	mErrorType
double	mErrorBarSize
bool	mErrorBarSkipSymbol
QCPGraph *	mChannelFillGraph
Protected Attributes inherited from QCPAbstractPlottable
QCustomPlot *	mParentPlot
QString	mName
bool	mVisible
QPen	mPen
QBrush	mBrush
QCPAxis *	mKeyAxis
QCPAxis *	mValueAxis

Friends
class	QCustomPlot
class	QCPLegend

Additional Inherited Members
Protected Types inherited from QCPAbstractPlottable
enum	SignDomain { SDNegative, SDBoth, SDPositive }

Detailed Description

A plottable representing a graph in a plot.

Usually QCustomPlot creates it internally via QCustomPlot::addGraph and the resulting instance is accessed via QCustomPlot::graph.

To plot data, assign it with the setData or addData functions.

Changing the appearance

The appearance of the graph is mainly determined by the line style, scatter style, brush and pen of the graph (setLineStyle, setScatterStyle, setBrush, setPen).

Filling under or between graphs

QCPGraph knows two types of fills: Normal graph fills towards the zero-value-line parallel to the key axis of the graph, and fills between two graphs, called channel fills. To enable a fill, just set a brush with setBrush which is neither Qt::NoBrush nor fully transparent.

By default, a normal fill towards the zero-value-line will be drawn. To set up a channel fill between this graph and another one, call setChannelFillGraph with the other graph as parameter.

See also

QCustomPlot::addGraph, QCustomPlot::graph, QCPLegend::addGraph

Definition at line 171 of file qcustomplot.h.

Member Enumeration Documentation

enum QCPGraph::ErrorType

Defines what kind of error bars are drawn for each data point

Enumerator
ETNone	No error bars are shown.
ETKey	Error bars for the key dimension of the data point are shown.
ETValue	Error bars for the value dimension of the data point are shown.
ETBoth	Error bars for both key and value dimensions of the data point are shown.

Definition at line 216 of file qcustomplot.h.

                 {ETNone,  
                  ETKey,   
                  ETValue, 
                  ETBoth   
                 };

enum QCPGraph::LineStyle

Defines how the graph's line is represented visually in the plot. The line is drawn with the current pen of the graph (setPen).

See also

setLineStyle

Enumerator
LSNone	data points are not connected with any lines (e.g. data only represented with symbols according to the scatter style, see setScatterStyle)
LSLine	data points are connected by a straight line
LSStepLeft	line is drawn as steps where the step height is the value of the left data point
LSStepRight	line is drawn as steps where the step height is the value of the right data point
LSStepCenter	line is drawn as steps where the step is in between two data points
LSImpulse	data points are represented by a straight line parallel to the value axis, which ranges down/up to the key axis

Definition at line 180 of file qcustomplot.h.

                 {LSNone,       
                  LSLine,       
                  LSStepLeft,   
                  LSStepRight,  
                  LSStepCenter, 
                  LSImpulse     
                 };

enum QCPGraph::ScatterStyle

This defines the visual appearance of the points, which are all drawn with the pen of the graph (setPen). The sizes of these visualizations (with exception of SSDot and SSPixmap) can be set with setScatterSize.

See also

setScatterStyle

Enumerator
SSNone	no scatter symbols are drawn (e.g. data only represented with lines, see setLineStyle)
SSDot	a single pixel, setScatterSize has no influence on its size.
SSCross	a cross (x)
SSPlus	a plus (+)
SSCircle	a circle which is not filled
SSDisc	a circle which is filled with the color of the graph's pen (not the brush!)
SSSquare	a square which is not filled
SSStar	a star with eight arms, i.e. a combination of cross and plus
SSTriangle	an equilateral triangle which is not filled, standing on baseline
SSTriangleInverted	an equilateral triangle which is not filled, standing on corner
SSCrossSquare	a square which is not filled, with a cross inside
SSPlusSquare	a square which is not filled, with a plus inside
SSCrossCircle	a circle which is not filled, with a cross inside
SSPlusCircle	a circle which is not filled, with a plus inside
SSPeace	a circle which is not filled, with one vertical and two downward diagonal lines
SSPixmap	a custom pixmap specified by setScatterPixmap, centered on the data point coordinates. setScatterSize has no influence on its size.

Definition at line 195 of file qcustomplot.h.

                    {SSNone,     
                     SSDot,      
                     SSCross,    
                     SSPlus,     
                     SSCircle,   
                     SSDisc,     
                     SSSquare,   
                     SSStar,     
                     SSTriangle, 
                     SSTriangleInverted, 
                     SSCrossSquare,      
                     SSPlusSquare,       
                     SSCrossCircle,      
                     SSPlusCircle,       
                     SSPeace,    
                     SSPixmap    
                    };

Constructor & Destructor Documentation

QCPGraph::QCPGraph ( QCPAxis *  keyAxis, QCPAxis *  valueAxis  )

explicit

Constructs a graph which uses keyAxis as its key axis ("x") and valueAxis as its value axis ("y"). keyAxis and valueAxis must both reside in the same QCustomPlot.

The constructed QCPGraph can be added to the plot with QCustomPlot::addPlottable, QCustomPlot then takes ownership of the graph.

To directly create a graph inside a plot, you can also use the simpler QCustomPlot::addGraph function.

Definition at line 256 of file qcustomplot.cc.

                                                       :
  QCPAbstractPlottable(keyAxis, valueAxis)
{
  mData = new QCPDataMap;
  mPen.setColor(Qt::blue);
  mPen.setStyle(Qt::SolidLine);
  mErrorPen.setColor(Qt::black);
  mBrush.setColor(Qt::blue);
  mBrush.setStyle(Qt::NoBrush);
  mLineStyle = LSLine;
  mScatterStyle = SSNone;
  mScatterSize = 6;
  mErrorType = ETNone;
  mErrorBarSize = 6;
  mErrorBarSkipSymbol = true;
  mChannelFillGraph = 0;
}

QCPGraph::~QCPGraph ( )

virtual

Definition at line 274 of file qcustomplot.cc.

{
  if (mParentPlot)
  {
    // if another graph has a channel fill towards this graph, set it to zero
    for (int i=0; i<mParentPlot->graphCount(); ++i)
    {
      if (mParentPlot->graph(i)->channelFillGraph() == this)
        mParentPlot->graph(i)->setChannelFillGraph(0);
    }
  }
  delete mData;
}

Member Function Documentation

void QCPGraph::addData ( const QCPDataMap &  dataMap )

slot

Adds the provided data points in dataMap to the current data.

See also

removeData

Definition at line 602 of file qcustomplot.cc.

{
  mData->unite(dataMap);
}

void QCPGraph::addData ( const QCPData &  data )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Adds the provided single data point in data to the current data.

See also

removeData

Definition at line 611 of file qcustomplot.cc.

{
  mData->insertMulti(data.key, data);
}

void QCPGraph::addData ( double  key, double  value  )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Adds the provided single data point as key and value pair to the current data.

See also

removeData

Definition at line 620 of file qcustomplot.cc.

{
  QCPData newData;
  newData.key = key;
  newData.value = value;
  mData->insertMulti(newData.key, newData);
}

void QCPGraph::addData ( const QVector< double > &  keys, const QVector< double > &  values  )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Adds the provided data points as key and value pairs to the current data.

See also

removeData

Definition at line 632 of file qcustomplot.cc.

{
  int n = qMin(keys.size(), values.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = keys[i];
    newData.value = values[i];
    mData->insertMulti(newData.key, newData);
  }
}

void QCPGraph::addFillBasePoints ( QVector< QPointF > *  lineData ) const

protected

Definition at line 1703 of file qcustomplot.cc.

{
  // append points that close the polygon fill at the key axis:
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    *lineData << upperFillBasePoint(lineData->last().y());
    *lineData << lowerFillBasePoint(lineData->first().y());
  } else
  {
    *lineData << upperFillBasePoint(lineData->last().x());
    *lineData << lowerFillBasePoint(lineData->first().x());
  }
}

QCPGraph* QCPGraph::channelFillGraph ( ) const

inlineslot

Definition at line 237 of file qcustomplot.h.

{ return mChannelFillGraph; }

void QCPGraph::clearData ( )

virtualslot

Removes all data points.

See also

removeData, removeDataAfter, removeDataBefore

Definition at line 700 of file qcustomplot.cc.

{
  mData->clear();
}

const QCPDataMap* QCPGraph::data ( ) const

inlineslot

Definition at line 228 of file qcustomplot.h.

{ return mData; }

void QCPGraph::draw ( QPainter *  painter ) const

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 779 of file qcustomplot.cc.

{
  if (!mVisible) return;
  if (mKeyAxis->range().size() <= 0) return;
  if (mData->isEmpty()) return;
  if (mLineStyle == LSNone && mScatterStyle == SSNone) return;
  painter->setClipRect(mKeyAxis->axisRect().united(mValueAxis->axisRect()));
  
  // allocate line and (if necessary) point vectors:
  QVector<QPointF> *lineData = new QVector<QPointF>;
  QVector<QCPData> *pointData = 0;
  if (mScatterStyle != SSNone)
    pointData = new QVector<QCPData>;
  
  // fill vectors with data appropriate to plot style:
  getPlotData(lineData, pointData);

  // draw fill of graph:
  drawFill(painter, lineData);
  
  // draw line:
  if (mLineStyle == LSImpulse)
    drawImpulsePlot(painter, lineData);
  else if (mLineStyle != LSNone)
    drawLinePlot(painter, lineData); // also step plots can be drawn as a line plot
  
  // draw scatters:
  if (pointData)
    drawScatterPlot(painter, pointData);
  
  // free allocated line and point vectors:
  delete lineData;
  if (pointData)
    delete pointData;
}

void QCPGraph::drawError ( QPainter *  painter, double  x, double  y, const QCPData &  data  ) const

protected

Definition at line 1559 of file qcustomplot.cc.

{
  double a, b; // positions of error bar bounds in pixels
  double barWidthHalf = mErrorBarSize*0.5;
  double skipSymbolMargin = mScatterSize*1.25; // pixels left blank per side, when mErrorBarSkipSymbol is true
  
  if (!mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEErrorBars))
  {
    x = x-0.9; // paint system correction, else, we don't get pixel exact matches (Qt problem)
    y = y-0.9; // paint system correction, else, we don't get pixel exact matches (Qt problem)
  }
  
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    // draw key error vertically and value error horizontally
    if (mErrorType == ETKey || mErrorType == ETBoth)
    {
      a = mKeyAxis->coordToPixel(data.key-data.keyErrorMinus);
      b = mKeyAxis->coordToPixel(data.key+data.keyErrorPlus);
      if (mKeyAxis->rangeReversed())
        qSwap(a,b);
      // draw spine:
      if (mErrorBarSkipSymbol)
      {
        if (a-y > skipSymbolMargin) // don't draw spine if error is so small it's within skipSymbolmargin
          painter->drawLine(QLineF(x, a, x, y+skipSymbolMargin));
        if (y-b > skipSymbolMargin) 
          painter->drawLine(QLineF(x, y-skipSymbolMargin, x, b));
      } else
        painter->drawLine(QLineF(x, a, x, b));
      // draw handles:
      painter->drawLine(QLineF(x-barWidthHalf, a, x+barWidthHalf, a));
      painter->drawLine(QLineF(x-barWidthHalf, b, x+barWidthHalf, b));
    }
    if (mErrorType == ETValue || mErrorType == ETBoth)
    {
      a = mValueAxis->coordToPixel(data.value-data.valueErrorMinus);
      b = mValueAxis->coordToPixel(data.value+data.valueErrorPlus);
      if (mValueAxis->rangeReversed())
        qSwap(a,b);
      // draw spine:
      if (mErrorBarSkipSymbol)
      {
        if (x-a > skipSymbolMargin) // don't draw spine if error is so small it's within skipSymbolmargin
          painter->drawLine(QLineF(a, y, x-skipSymbolMargin, y));
        if (b-x > skipSymbolMargin)
          painter->drawLine(QLineF(x+skipSymbolMargin, y, b, y));
      } else
        painter->drawLine(QLineF(a, y, b, y));
      // draw handles:
      painter->drawLine(QLineF(a, y-barWidthHalf, a, y+barWidthHalf));
      painter->drawLine(QLineF(b, y-barWidthHalf, b, y+barWidthHalf));
    }
  } else
  {
    // draw value error vertically and key error horizontally
    if (mErrorType == ETKey || mErrorType == ETBoth)
    {
      a = mKeyAxis->coordToPixel(data.key-data.keyErrorMinus);
      b = mKeyAxis->coordToPixel(data.key+data.keyErrorPlus);
      if (mKeyAxis->rangeReversed())
        qSwap(a,b);
      // draw spine:
      if (mErrorBarSkipSymbol)
      {
        if (x-a > skipSymbolMargin) // don't draw spine if error is so small it's within skipSymbolmargin
          painter->drawLine(QLineF(a, y, x-skipSymbolMargin, y));
        if (b-x > skipSymbolMargin)
          painter->drawLine(QLineF(x+skipSymbolMargin, y, b, y));
      } else
        painter->drawLine(QLineF(a, y, b, y));
      // draw handles:
      painter->drawLine(QLineF(a, y-barWidthHalf, a, y+barWidthHalf));
      painter->drawLine(QLineF(b, y-barWidthHalf, b, y+barWidthHalf));
    }
    if (mErrorType == ETValue || mErrorType == ETBoth)
    {
      a = mValueAxis->coordToPixel(data.value-data.valueErrorMinus);
      b = mValueAxis->coordToPixel(data.value+data.valueErrorPlus);
      if (mValueAxis->rangeReversed())
        qSwap(a,b);
      // draw spine:
      if (mErrorBarSkipSymbol)
      {
        if (a-y > skipSymbolMargin) // don't draw spine if error is so small it's within skipSymbolmargin
          painter->drawLine(QLineF(x, a, x, y+skipSymbolMargin));
        if (y-b > skipSymbolMargin)
          painter->drawLine(QLineF(x, y-skipSymbolMargin, x, b));
      } else
        painter->drawLine(QLineF(x, a, x, b));
      // draw handles:
      painter->drawLine(QLineF(x-barWidthHalf, a, x+barWidthHalf, a));
      painter->drawLine(QLineF(x-barWidthHalf, b, x+barWidthHalf, b));
    }
  }
}

void QCPGraph::drawFill ( QPainter *  painter, QVector< QPointF > *  lineData  ) const

protected

Definition at line 1322 of file qcustomplot.cc.

{
  if (mLineStyle == LSImpulse) return; // fill doesn't make sense for impulse plot
  if (mBrush.style() == Qt::NoBrush || mBrush.color().alpha() == 0) return;
  
  painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEFills));
  if (!mChannelFillGraph)
  {
    // draw base fill under graph, fill goes all the way to the zero-value-line:
    addFillBasePoints(lineData);
    painter->setPen(Qt::NoPen);
    painter->setBrush(mBrush);
    painter->drawPolygon(QPolygonF(*lineData));
    removeFillBasePoints(lineData);
  } else
  {
    // draw channel fill between this graph and mChannelFillGraph:
    painter->setPen(Qt::NoPen);
    painter->setBrush(mBrush);
    painter->drawPolygon(getChannelFillPolygon(lineData));
  }
}

void QCPGraph::drawImpulsePlot ( QPainter *  painter, QVector< QPointF > *  lineData  ) const

protected

Definition at line 1411 of file qcustomplot.cc.

{
  // draw impulses:
  if (mPen.style() != Qt::NoPen && mPen.color().alpha() != 0)
  {
    painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEGraphs));
    painter->setPen(mPen);
    painter->setBrush(Qt::NoBrush);
    painter->drawLines(*lineData);
  }
}

void QCPGraph::drawLegendIcon ( QPainter *  painter, const QRect &  rect  ) const

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 816 of file qcustomplot.cc.

{
  // draw fill:
  if (mBrush.style() != Qt::NoBrush)
  {
    painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEGraphs));
    painter->fillRect(rect.left(), rect.top()+rect.height()/2.0, rect.width(), rect.height()/3.0, mBrush);
  }
  // draw line vertically centered:
  if (mLineStyle != LSNone)
  {
    painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEGraphs));
    painter->setPen(mPen);
    painter->drawLine(rect.left(), rect.top()+rect.height()/2.0, rect.right()+5, rect.top()+rect.height()/2.0); // +5 on x2 else last segment is missing from dashed/dotted pens
  }
  // draw scatter symbol:
  if (mScatterStyle != SSNone)
  {
    if (mScatterStyle == SSPixmap && (mScatterPixmap.size().width() > rect.width() || mScatterPixmap.size().height() > rect.height()))
    {
      // handle pixmap scatters that are larger than legend icon rect separately.
      // We resize them and draw them manually, instead of calling drawScatter:
      QSize newSize = mScatterPixmap.size();
      newSize.scale(rect.size(), Qt::KeepAspectRatio);
      QRect targetRect;
      targetRect.setSize(newSize);
      targetRect.moveCenter(rect.center());
      bool smoothBackup = painter->testRenderHint(QPainter::SmoothPixmapTransform);
      painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
      painter->drawPixmap(targetRect, mScatterPixmap);
      painter->setRenderHint(QPainter::SmoothPixmapTransform, smoothBackup);
    } else // mScatterStyle != SSPixmap
    {
      painter->setPen(mPen);
      painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEScatters));
      drawScatter(painter, rect.center().x()+1, rect.center().y()+1, mScatterStyle);
    }
  }
}

void QCPGraph::drawLinePlot ( QPainter *  painter, QVector< QPointF > *  lineData  ) const

protected

Definition at line 1393 of file qcustomplot.cc.

{
  // draw line of graph:
  if (mPen.style() != Qt::NoPen && mPen.color().alpha() != 0)
  {
    painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEGraphs));
    painter->setPen(mPen);
    painter->setBrush(Qt::NoBrush);
    painter->drawPolyline(QPolygonF(*lineData));
  }
}

void QCPGraph::drawScatter ( QPainter *  painter, double  x, double  y, ScatterStyle  style  ) const

protected

Definition at line 1431 of file qcustomplot.cc.

{
  // If you change this correction, make sure pdf exported scatters are properly centered in error bars!
  // There seems to be some kind of discrepancy for different paint devices here.
  if (style == SSCross || style == SSPlus)
  {
    x = x-0.7; // paint system correction, else, we don't get pixel exact matches (Qt problem)
    y = y-0.4; // paint system correction, else, we don't get pixel exact matches (Qt problem)
  }
  
  double w = mScatterSize/2.0;
  switch (style)
  {
    case SSDot:
    {
      painter->drawPoint(QPointF(x, y));
      break;
    }
    case SSCross:
    {
      painter->drawLine(QLineF(x-w, y-w, x+w, y+w));
      painter->drawLine(QLineF(x-w, y+w, x+w, y-w));
      break;
    }
    case SSPlus:
    {
      painter->drawLine(QLineF(x-w, y, x+w, y));
      painter->drawLine(QLineF(x, y+w, x, y-w));
      break;
    }
    case SSCircle:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawEllipse(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSDisc:
    {
      painter->setBrush(QBrush(painter->pen().color()));
      painter->drawEllipse(QPointF(x,y), w, w);
      break;
    }
    case SSSquare:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawRect(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSStar:
    {
      painter->drawLine(QLineF(x-w, y, x+w, y));
      painter->drawLine(QLineF(x, y+w, x, y-w));
      painter->drawLine(QLineF(x-w*0.707, y-w*0.707, x+w*0.707, y+w*0.707));
      painter->drawLine(QLineF(x-w*0.707, y+w*0.707, x+w*0.707, y-w*0.707));
      break;
    }
    case SSTriangle:
    {
      painter->drawLine(QLineF(x-w, y+0.755*w, x+w, y+0.755*w));
      painter->drawLine(QLineF(x+w, y+0.755*w, x, y-0.977*w));
      painter->drawLine(QLineF(x, y-0.977*w, x-w, y+0.755*w));
      break;
    }
    case SSTriangleInverted:
    {
      painter->drawLine(QLineF(x-w, y-0.755*w, x+w, y-0.755*w));
      painter->drawLine(QLineF(x+w, y-0.755*w, x, y+0.977*w));
      painter->drawLine(QLineF(x, y+0.977*w, x-w, y-0.755*w));
      break;
    }
    case SSCrossSquare:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawLine(QLineF(x-w, y-w, x+w*0.95, y+w*0.95));
      painter->drawLine(QLineF(x-w, y+w*0.95, x+w*0.95, y-w));
      painter->drawRect(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSPlusSquare:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawLine(QLineF(x-w, y, x+w*0.95, y));
      painter->drawLine(QLineF(x, y+w, x, y-w));
      painter->drawRect(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSCrossCircle:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawLine(QLineF(x-w*0.707, y-w*0.707, x+w*0.67, y+w*0.67));
      painter->drawLine(QLineF(x-w*0.707, y+w*0.67, x+w*0.67, y-w*0.707));
      painter->drawEllipse(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSPlusCircle:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawLine(QLineF(x-w, y, x+w, y));
      painter->drawLine(QLineF(x, y+w, x, y-w));
      painter->drawEllipse(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSPeace:
    {
      painter->setBrush(Qt::NoBrush);
      painter->drawLine(QLineF(x, y-w, x, y+w));
      painter->drawLine(QLineF(x, y, x-w*0.707, y+w*0.707));
      painter->drawLine(QLineF(x, y, x+w*0.707, y+w*0.707));
      painter->drawEllipse(x-w,y-w,mScatterSize,mScatterSize);
      break;
    }
    case SSPixmap:
    {
      painter->drawPixmap(x-mScatterPixmap.width()*0.5, y-mScatterPixmap.height()*0.5, mScatterPixmap);
      // if something in here is changed, adapt SSPixmap scatter style case in drawLegendIcon(), too
      break;
    }
    default: break;
  }
}

void QCPGraph::drawScatterPlot ( QPainter *  painter, QVector< QCPData > *  pointData  ) const

protected

Definition at line 1352 of file qcustomplot.cc.

{
  // draw error bars:
  if (mErrorType != ETNone)
  {
    painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEErrorBars));
    painter->setPen(mErrorPen);
    if (mKeyAxis->orientation() == Qt::Vertical)
    {
      for (int i=0; i<pointData->size(); ++i)
        drawError(painter, mValueAxis->coordToPixel(pointData->at(i).value), mKeyAxis->coordToPixel(pointData->at(i).key), pointData->at(i));
    } else
    {
      for (int i=0; i<pointData->size(); ++i)
        drawError(painter, mKeyAxis->coordToPixel(pointData->at(i).key), mValueAxis->coordToPixel(pointData->at(i).value), pointData->at(i));
    }
  }
  
  // draw scatter point symbols:
  painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEScatters));
  painter->setPen(mPen);
  painter->setBrush(mBrush);
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    for (int i=0; i<pointData->size(); ++i)
      drawScatter(painter, mValueAxis->coordToPixel(pointData->at(i).value), mKeyAxis->coordToPixel(pointData->at(i).key), mScatterStyle);
  } else
  {
    for (int i=0; i<pointData->size(); ++i)
      drawScatter(painter, mKeyAxis->coordToPixel(pointData->at(i).key), mValueAxis->coordToPixel(pointData->at(i).value), mScatterStyle);
  }
}

double QCPGraph::errorBarSize ( ) const

inlineslot

Definition at line 235 of file qcustomplot.h.

{ return mErrorBarSize; }

bool QCPGraph::errorBarSkipSymbol ( ) const

inlineslot

Definition at line 236 of file qcustomplot.h.

{ return mErrorBarSkipSymbol; }

QPen QCPGraph::errorPen ( ) const

inlineslot

Definition at line 234 of file qcustomplot.h.

{ return mErrorPen; }

ErrorType QCPGraph::errorType ( ) const

inlineslot

Definition at line 233 of file qcustomplot.h.

{ return mErrorType; }

int QCPGraph::findIndexAboveX ( const QVector< QPointF > *  data, double  x  ) const

protected

Definition at line 1990 of file qcustomplot.cc.

{
  for (int i=data->size()-1; i>=0; --i)
  {
    if (data->at(i).x() < x)
    {
      if (i<data->size()-1)
        return i+1;
      else
        return data->size()-1;
    }
  }
  return -1;
}

int QCPGraph::findIndexAboveY ( const QVector< QPointF > *  data, double  y  ) const

protected

Definition at line 2034 of file qcustomplot.cc.

{
  for (int i=0; i<data->size(); ++i)
  {
    if (data->at(i).y() < y)
    {
      if (i>0)
        return i-1;
      else
        return 0;
    }
  }
  return -1;
}

int QCPGraph::findIndexBelowX ( const QVector< QPointF > *  data, double  x  ) const

protected

Definition at line 2012 of file qcustomplot.cc.

{
  for (int i=0; i<data->size(); ++i)
  {
    if (data->at(i).x() > x)
    {
      if (i>0)
        return i-1;
      else
        return 0;
    }
  }
  return -1;
}

int QCPGraph::findIndexBelowY ( const QVector< QPointF > *  data, double  y  ) const

protected

Definition at line 2056 of file qcustomplot.cc.

{
  for (int i=data->size()-1; i>=0; --i)
  {
    if (data->at(i).y() > y)
    {
      if (i<data->size()-1)
        return i+1;
      else
        return data->size()-1;
    }
  }
  return -1;
}

const QPolygonF QCPGraph::getChannelFillPolygon ( const QVector< QPointF > *  lineData ) const

protected

Definition at line 1856 of file qcustomplot.cc.

{
  if (mChannelFillGraph->mKeyAxis->orientation() != mKeyAxis->orientation())
    return QPolygonF(); // don't have same axis orientation, can't fill that (Note: if keyAxis fits, valueAxis will fit too, because it's always orthogonal to keyAxis)
  
  if (lineData->isEmpty()) return QPolygonF();
  QVector<QPointF> otherData;
  mChannelFillGraph->getPlotData(&otherData, 0);
  if (otherData.isEmpty()) return QPolygonF();
  QVector<QPointF> thisData;
  thisData.reserve(lineData->size()+otherData.size()); // because we will join both vectors at end of this function
  for (int i=0; i<lineData->size(); ++i) // don't use the vector<<(vector),  it squeezes internally, which ruins the performance tuning with reserve()
    thisData << lineData->at(i);
  
  // pointers to be able to swap them, depending which data range needs cropping:
  QVector<QPointF> *staticData = &thisData;
  QVector<QPointF> *croppedData = &otherData;
  
  // crop both vectors to ranges in which the keys overlap (which coord is key, depends on axisType):
  if (mKeyAxis->orientation() == Qt::Horizontal)
  {
    // x is key
    // if an axis range is reversed, the data point keys will be descending. Reverse them, since following algorithm assumes ascending keys:
    if (staticData->first().x() > staticData->last().x())
    {
      int size = staticData->size();
      for (int i=0; i<size/2; ++i)
        qSwap((*staticData)[i], (*staticData)[size-1-i]);
    }
    if (croppedData->first().x() > croppedData->last().x())
    {
      int size = croppedData->size();
      for (int i=0; i<size/2; ++i)
        qSwap((*croppedData)[i], (*croppedData)[size-1-i]);
    }
    // crop lower bound:
    if (staticData->first().x() < croppedData->first().x()) // other one must be cropped
      qSwap(staticData, croppedData);
    int lowBound = findIndexBelowX(croppedData, staticData->first().x());
    if (lowBound == -1) return QPolygonF(); // key ranges have no overlap
    croppedData->remove(0, lowBound);
    // set lowest point of cropped data to fit exactly key position of first static data
    // point via linear interpolation:
    if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
    double slope;
    if (croppedData->at(1).x()-croppedData->at(0).x() != 0)
      slope = (croppedData->at(1).y()-croppedData->at(0).y())/(croppedData->at(1).x()-croppedData->at(0).x());
    else
      slope = 0;
    (*croppedData)[0].setY(croppedData->at(0).y()+slope*(staticData->first().x()-croppedData->at(0).x()));
    (*croppedData)[0].setX(staticData->first().x());
    
    // crop upper bound:
    if (staticData->last().x() > croppedData->last().x()) // other one must be cropped
      qSwap(staticData, croppedData);
    int highBound = findIndexAboveX(croppedData, staticData->last().x());
    if (highBound == -1) return QPolygonF(); // key ranges have no overlap
    croppedData->remove(highBound+1, croppedData->size()-(highBound+1));
    // set highest point of cropped data to fit exactly key position of last static data
    // point via linear interpolation:
    if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
    int li = croppedData->size()-1; // last index
    if (croppedData->at(li).x()-croppedData->at(li-1).x() != 0)
      slope = (croppedData->at(li).y()-croppedData->at(li-1).y())/(croppedData->at(li).x()-croppedData->at(li-1).x());
    else
      slope = 0;
    (*croppedData)[li].setY(croppedData->at(li-1).y()+slope*(staticData->last().x()-croppedData->at(li-1).x()));
    (*croppedData)[li].setX(staticData->last().x());
  } else // mKeyAxis->orientation() == Qt::Vertical
  {
    // y is key
    // similar to "x is key" but switched x,y. Further, lower/upper meaning is inverted compared to x,
    // because in pixel coordinates, y increases from top to bottom, not bottom to top like data coordinate.
    // if an axis range is reversed, the data point keys will be descending. Reverse them, since following algorithm assumes ascending keys:
    if (staticData->first().y() < staticData->last().y())
    {
      int size = staticData->size();
      for (int i=0; i<size/2; ++i)
        qSwap((*staticData)[i], (*staticData)[size-1-i]);
    }
    if (croppedData->first().y() < croppedData->last().y())
    {
      int size = croppedData->size();
      for (int i=0; i<size/2; ++i)
        qSwap((*croppedData)[i], (*croppedData)[size-1-i]);
    }
    // crop lower bound:
    if (staticData->first().y() > croppedData->first().y()) // other one must be cropped
      qSwap(staticData, croppedData);
    int lowBound = findIndexAboveY(croppedData, staticData->first().y());
    if (lowBound == -1) return QPolygonF(); // key ranges have no overlap
    croppedData->remove(0, lowBound);
    // set lowest point of cropped data to fit exactly key position of first static data
    // point via linear interpolation:
    if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
    double slope;
    if (croppedData->at(1).y()-croppedData->at(0).y() != 0) // avoid division by zero in step plots
      slope = (croppedData->at(1).x()-croppedData->at(0).x())/(croppedData->at(1).y()-croppedData->at(0).y());
    else
      slope = 0;
    (*croppedData)[0].setX(croppedData->at(0).x()+slope*(staticData->first().y()-croppedData->at(0).y()));
    (*croppedData)[0].setY(staticData->first().y());
    
    // crop upper bound:
    if (staticData->last().y() < croppedData->last().y()) // other one must be cropped
      qSwap(staticData, croppedData);
    int highBound = findIndexBelowY(croppedData, staticData->last().y());
    if (highBound == -1) return QPolygonF(); // key ranges have no overlap
    croppedData->remove(highBound+1, croppedData->size()-(highBound+1));
    // set highest point of cropped data to fit exactly key position of last static data
    // point via linear interpolation:
    if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
    int li = croppedData->size()-1; // last index
    if (croppedData->at(li).y()-croppedData->at(li-1).y() != 0) // avoid division by zero in step plots
      slope = (croppedData->at(li).x()-croppedData->at(li-1).x())/(croppedData->at(li).y()-croppedData->at(li-1).y());
    else
      slope = 0;
    (*croppedData)[li].setX(croppedData->at(li-1).x()+slope*(staticData->last().y()-croppedData->at(li-1).y()));
    (*croppedData)[li].setY(staticData->last().y());
  }
  
  // return joined:
  for (int i=otherData.size()-1; i>=0; --i) // insert reversed, otherwise the polygon will be twisted
    thisData << otherData.at(i);
  return QPolygonF(thisData);
}

void QCPGraph::getImpulsePlotData ( QVector< QPointF > *  lineData, QVector< QCPData > *  pointData  ) const

protected

Definition at line 1248 of file qcustomplot.cc.

{
  // get visible data range:
  QCPDataMap::const_iterator lower, upper;
  int dataCount;
  getVisibleDataBounds(lower, upper, dataCount);
  // prepare vectors:
  if (lineData)
  {
    // no need to reserve 2 extra points, because there is no fill for impulse plot
    lineData->resize(dataCount*2);
  }
  if (pointData)
    pointData->resize(dataCount);
  
  // position data points:
  QCPDataMap::const_iterator it = lower;
  QCPDataMap::const_iterator upperEnd = upper+1;
  int i = 0;
  int ipoint = 0;
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    double zeroPointX = mValueAxis->coordToPixel(0);
    double key;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      key = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(zeroPointX);
      (*lineData)[i].setY(key);
      ++i;
      (*lineData)[i].setX(mValueAxis->coordToPixel(it.value().value));
      (*lineData)[i].setY(key);
      ++i;
      ++it;
    }
  } else // key axis is horizontal
  {
    double zeroPointY = mValueAxis->coordToPixel(0);
    double key;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      key = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(key);
      (*lineData)[i].setY(zeroPointY);
      ++i;
      (*lineData)[i].setX(key);
      (*lineData)[i].setY(mValueAxis->coordToPixel(it.value().value));
      ++i;
      ++it;
    }
  }
}

QCPRange QCPGraph::getKeyRange ( bool &  validRange, SignDomain  inSignDomain = SDBoth  ) const

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 2072 of file qcustomplot.cc.

{
  // just call the specialized version which takes an additional argument whether error bars
  // should also be taken into consideration for range calculation. We set this to true here.
  return getKeyRange(validRange, inSignDomain, true);
}

QCPRange QCPGraph::getKeyRange ( bool &  validRange, SignDomain  inSignDomain, bool  includeErrors  ) const

protectedvirtual

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Allows to specify whether the error bars should be included in the range calculation.

See also

getKeyRange(bool &validRange, SignDomain inSignDomain)

Definition at line 2092 of file qcustomplot.cc.

{
  QCPRange range;
  bool haveLower = false;
  bool haveUpper = false;
  
  double current, currentErrorMinus, currentErrorPlus;
  
  if (inSignDomain == SDBoth) // range may be anywhere
  {
    QCPDataMap::const_iterator it = mData->constBegin();
    while (it != mData->constEnd())
    {
      current = it.value().key;
      currentErrorMinus = (includeErrors ? it.value().keyErrorMinus : 0);
      currentErrorPlus = (includeErrors ? it.value().keyErrorPlus : 0);
      if (current-currentErrorMinus < range.lower || !haveLower)
      {
        range.lower = current-currentErrorMinus;
        haveLower = true;
      }
      if (current+currentErrorPlus > range.upper || !haveUpper)
      {
        range.upper = current+currentErrorPlus;
        haveUpper = true;
      }
      it++;
    }
  } else if (inSignDomain == SDNegative) // range may only be in the negative sign domain
  {
    QCPDataMap::const_iterator it = mData->constBegin();
    while (it != mData->constEnd())
    {
      current = it.value().key;
      currentErrorMinus = (includeErrors ? it.value().keyErrorMinus : 0);
      currentErrorPlus = (includeErrors ? it.value().keyErrorPlus : 0);
      if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus < 0)
      {
        range.lower = current-currentErrorMinus;
        haveLower = true;
      }
      if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus < 0)
      {
        range.upper = current+currentErrorPlus;
        haveUpper = true;
      }
      if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to geht that point.
      {
        if ((current < range.lower || !haveLower) && current < 0)
        {
          range.lower = current;
          haveLower = true;
        }
        if ((current > range.upper || !haveUpper) && current < 0)
        {
          range.upper = current;
          haveUpper = true;
        }
      }
      it++;
    }
  } else if (inSignDomain == SDPositive) // range may only be in the positive sign domain
  {
    QCPDataMap::const_iterator it = mData->constBegin();
    while (it != mData->constEnd())
    {
      current = it.value().key;
      currentErrorMinus = (includeErrors ? it.value().keyErrorMinus : 0);
      currentErrorPlus = (includeErrors ? it.value().keyErrorPlus : 0);
      if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus > 0)
      {
        range.lower = current-currentErrorMinus;
        haveLower = true;
      }
      if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus > 0)
      {
        range.upper = current+currentErrorPlus;
        haveUpper = true;
      }
      if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to get that point.
      {
        if ((current < range.lower || !haveLower) && current > 0)
        {
          range.lower = current;
          haveLower = true;
        }
        if ((current > range.upper || !haveUpper) && current > 0)
        {
          range.upper = current;
          haveUpper = true;
        }
      }
      it++;
    }
  }
  
  validRange = haveLower && haveUpper;
  return range;
}

void QCPGraph::getLinePlotData ( QVector< QPointF > *  lineData, QVector< QCPData > *  pointData  ) const

protected

Definition at line 936 of file qcustomplot.cc.

{
  // get visible data range:
  QCPDataMap::const_iterator lower, upper;
  int dataCount;
  getVisibleDataBounds(lower, upper, dataCount);
  // prepare vectors:
  if (lineData)
  { 
    // added 2 to reserve memory for lower/upper fill base points that might be needed for fill
    lineData->reserve(dataCount+2);
    lineData->resize(dataCount);
  }
  if (pointData)
    pointData->resize(dataCount);

  // position data points:
  QCPDataMap::const_iterator it = lower;
  QCPDataMap::const_iterator upperEnd = upper+1;
  int i = 0;
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    while (it != upperEnd)
    {
      if (pointData)
        (*pointData)[i] = it.value();
      (*lineData)[i].setX(mValueAxis->coordToPixel(it.value().value));
      (*lineData)[i].setY(mKeyAxis->coordToPixel(it.key()));
      ++i;
      ++it;
    }
  } else // key axis is horizontal
  {
    while (it != upperEnd)
    {
      if (pointData)
        (*pointData)[i] = it.value();
      (*lineData)[i].setX(mKeyAxis->coordToPixel(it.key()));
      (*lineData)[i].setY(mValueAxis->coordToPixel(it.value().value));
      ++i;
      ++it;
    }
  }
}

void QCPGraph::getPlotData ( QVector< QPointF > *  lineData, QVector< QCPData > *  pointData  ) const

protected

Definition at line 868 of file qcustomplot.cc.

{
  switch(mLineStyle)
  {
    case LSNone: getScatterPlotData(pointData); break;
    case LSLine: getLinePlotData(lineData, pointData); break;
    case LSStepLeft: getStepLeftPlotData(lineData, pointData); break;
    case LSStepRight: getStepRightPlotData(lineData, pointData); break;
    case LSStepCenter: getStepCenterPlotData(lineData, pointData); break;
    case LSImpulse: getImpulsePlotData(lineData, pointData); break;
  }
}

void QCPGraph::getScatterPlotData ( QVector< QCPData > *  pointData ) const

protected

Definition at line 891 of file qcustomplot.cc.

{
  if (!pointData) return;
  
  // get visible data range:
  QCPDataMap::const_iterator lower, upper;
  int dataCount;
  getVisibleDataBounds(lower, upper, dataCount);
  // prepare vectors:
  if (pointData)
    pointData->resize(dataCount);

  // position data points:
  QCPDataMap::const_iterator it = lower;
  QCPDataMap::const_iterator upperEnd = upper+1;
  int i = 0;
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    while (it != upperEnd)
    {
      (*pointData)[i] = it.value();
      ++i;
      ++it;
    }
  } else // key axis is horizontal
  {
    while (it != upperEnd)
    {
      (*pointData)[i] = it.value();
      ++i;
      ++it;
    }
  }
}

void QCPGraph::getStepCenterPlotData ( QVector< QPointF > *  lineData, QVector< QCPData > *  pointData  ) const

protected

Definition at line 1145 of file qcustomplot.cc.

{
  // get visible data range:
  QCPDataMap::const_iterator lower, upper;
  int dataCount;
  getVisibleDataBounds(lower, upper, dataCount);
  // prepare vectors:
  if (lineData)
  {
    // added 2 to reserve memory for lower/upper fill base points that might be needed for base fill
    // multiplied by 2 because step plot needs two polyline points per one actual data point
    lineData->reserve(dataCount*2+2);
    lineData->resize(dataCount*2);
  }
  if (pointData)
    pointData->resize(dataCount);
  
  // position points:
  QCPDataMap::const_iterator it = lower;
  QCPDataMap::const_iterator upperEnd = upper+1;
  int i = 0;
  int ipoint = 0;
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    double lastKey = mKeyAxis->coordToPixel(it.key());
    double lastValue = mValueAxis->coordToPixel(it.value().value);
    double key;
    if (pointData)
    {
      (*pointData)[ipoint] = it.value();
      ++ipoint;
    }
    (*lineData)[i].setX(lastValue);
    (*lineData)[i].setY(lastKey);
    ++it;
    ++i;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      key = (mKeyAxis->coordToPixel(it.key())-lastKey)*0.5 + lastKey;
      (*lineData)[i].setX(lastValue);
      (*lineData)[i].setY(key);
      ++i;
      lastValue = mValueAxis->coordToPixel(it.value().value);
      lastKey = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(lastValue);
      (*lineData)[i].setY(key);
      ++it;
      ++i;
    }
    (*lineData)[i].setX(lastValue);
    (*lineData)[i].setY(lastKey);
  } else // key axis is horizontal
  {
    double lastKey = mKeyAxis->coordToPixel(it.key());
    double lastValue = mValueAxis->coordToPixel(it.value().value);
    double key;
    if (pointData)
    {
      (*pointData)[ipoint] = it.value();
      ++ipoint;
    }
    (*lineData)[i].setX(lastKey);
    (*lineData)[i].setY(lastValue);
    ++it;
    ++i;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      key = (mKeyAxis->coordToPixel(it.key())-lastKey)*0.5 + lastKey;
      (*lineData)[i].setX(key);
      (*lineData)[i].setY(lastValue);
      ++i;
      lastValue = mValueAxis->coordToPixel(it.value().value);
      lastKey = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(key);
      (*lineData)[i].setY(lastValue);
      ++it;
      ++i;
    }
    (*lineData)[i].setX(lastKey);
    (*lineData)[i].setY(lastValue);
  }
}

void QCPGraph::getStepLeftPlotData ( QVector< QPointF > *  lineData, QVector< QCPData > *  pointData  ) const

protected

Definition at line 991 of file qcustomplot.cc.

{
  // get visible data range:
  QCPDataMap::const_iterator lower, upper;
  int dataCount;
  getVisibleDataBounds(lower, upper, dataCount);
  // prepare vectors:
  if (lineData)
  {
    // added 2 to reserve memory for lower/upper fill base points that might be needed for fill
    // multiplied by 2 because step plot needs two polyline points per one actual data point
    lineData->reserve(dataCount*2+2);
    lineData->resize(dataCount*2);
  }
  if (pointData)
    pointData->resize(dataCount);
  
  // position data points:
  QCPDataMap::const_iterator it = lower;
  QCPDataMap::const_iterator upperEnd = upper+1;
  int i = 0;
  int ipoint = 0;
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    double lastValue = mValueAxis->coordToPixel(it.value().value);
    double key;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      key = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(lastValue);
      (*lineData)[i].setY(key);
      ++i;
      lastValue = mValueAxis->coordToPixel(it.value().value);
      (*lineData)[i].setX(lastValue);
      (*lineData)[i].setY(key);
      ++i;
      ++it;
    }
  } else // key axis is horizontal
  {
    double lastValue = mValueAxis->coordToPixel(it.value().value);
    double key;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      key = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(key);
      (*lineData)[i].setY(lastValue);
      ++i;
      lastValue = mValueAxis->coordToPixel(it.value().value);
      (*lineData)[i].setX(key);
      (*lineData)[i].setY(lastValue);
      ++i;
      ++it;
    }
  }
}

void QCPGraph::getStepRightPlotData ( QVector< QPointF > *  lineData, QVector< QCPData > *  pointData  ) const

protected

Definition at line 1068 of file qcustomplot.cc.

{
  // get visible data range:
  QCPDataMap::const_iterator lower, upper;
  int dataCount;
  getVisibleDataBounds(lower, upper, dataCount);
  // prepare vectors:
  if (lineData)
  {
    // added 2 to reserve memory for lower/upper fill base points that might be needed for fill
    // multiplied by 2 because step plot needs two polyline points per one actual data point
    lineData->reserve(dataCount*2+2);
    lineData->resize(dataCount*2);
  }
  if (pointData)
    pointData->resize(dataCount);
  
  // position points:
  QCPDataMap::const_iterator it = lower;
  QCPDataMap::const_iterator upperEnd = upper+1;
  int i = 0;
  int ipoint = 0;
  if (mKeyAxis->orientation() == Qt::Vertical)
  {
    double lastKey = mKeyAxis->coordToPixel(it.key());
    double value;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      value = mValueAxis->coordToPixel(it.value().value);
      (*lineData)[i].setX(value);
      (*lineData)[i].setY(lastKey);
      ++i;
      lastKey = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(value);
      (*lineData)[i].setY(lastKey);
      ++i;
      ++it;
    }
  } else // key axis is horizontal
  {
    double lastKey = mKeyAxis->coordToPixel(it.key());
    double value;
    while (it != upperEnd)
    {
      if (pointData)
      {
        (*pointData)[ipoint] = it.value();
        ++ipoint;
      }
      value = mValueAxis->coordToPixel(it.value().value);
      (*lineData)[i].setX(lastKey);
      (*lineData)[i].setY(value);
      ++i;
      lastKey = mKeyAxis->coordToPixel(it.key());
      (*lineData)[i].setX(lastKey);
      (*lineData)[i].setY(value);
      ++i;
      ++it;
    }
  }
}

QCPRange QCPGraph::getValueRange ( bool &  validRange, SignDomain  inSignDomain = SDBoth  ) const

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 2080 of file qcustomplot.cc.

{
  // just call the specialized version which takes an additional argument whether error bars
  // should also be taken into consideration for range calculation. We set this to true here.
  return getValueRange(validRange, inSignDomain, true);
}

QCPRange QCPGraph::getValueRange ( bool &  validRange, SignDomain  inSignDomain, bool  includeErrors  ) const

protectedvirtual

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Allows to specify whether the error bars should be included in the range calculation.

See also

getValueRange(bool &validRange, SignDomain inSignDomain)

Definition at line 2197 of file qcustomplot.cc.

{
  QCPRange range;
  bool haveLower = false;
  bool haveUpper = false;
  
  double current, currentErrorMinus, currentErrorPlus;
  
  if (inSignDomain == SDBoth) // range may be anywhere
  {
    QCPDataMap::const_iterator it = mData->constBegin();
    while (it != mData->constEnd())
    {
      current = it.value().value;
      currentErrorMinus = (includeErrors ? it.value().valueErrorMinus : 0);
      currentErrorPlus = (includeErrors ? it.value().valueErrorPlus : 0);
      if (current-currentErrorMinus < range.lower || !haveLower)
      {
        range.lower = current-currentErrorMinus;
        haveLower = true;
      }
      if (current+currentErrorPlus > range.upper || !haveUpper)
      {
        range.upper = current+currentErrorPlus;
        haveUpper = true;
      }
      it++;
    }
  } else if (inSignDomain == SDNegative) // range may only be in the negative sign domain
  {
    QCPDataMap::const_iterator it = mData->constBegin();
    while (it != mData->constEnd())
    {
      current = it.value().value;
      currentErrorMinus = (includeErrors ? it.value().valueErrorMinus : 0);
      currentErrorPlus = (includeErrors ? it.value().valueErrorPlus : 0);
      if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus < 0)
      {
        range.lower = current-currentErrorMinus;
        haveLower = true;
      }
      if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus < 0)
      {
        range.upper = current+currentErrorPlus;
        haveUpper = true;
      }
      if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to get that point.
      {
        if ((current < range.lower || !haveLower) && current < 0)
        {
          range.lower = current;
          haveLower = true;
        }
        if ((current > range.upper || !haveUpper) && current < 0)
        {
          range.upper = current;
          haveUpper = true;
        }
      }
      it++;
    }
  } else if (inSignDomain == SDPositive) // range may only be in the positive sign domain
  {
    QCPDataMap::const_iterator it = mData->constBegin();
    while (it != mData->constEnd())
    {
      current = it.value().value;
      currentErrorMinus = (includeErrors ? it.value().valueErrorMinus : 0);
      currentErrorPlus = (includeErrors ? it.value().valueErrorPlus : 0);
      if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus > 0)
      {
        range.lower = current-currentErrorMinus;
        haveLower = true;
      }
      if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus > 0)
      {
        range.upper = current+currentErrorPlus;
        haveUpper = true;
      }
      if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to geht that point.
      {
        if ((current < range.lower || !haveLower) && current > 0)
        {
          range.lower = current;
          haveLower = true;
        }
        if ((current > range.upper || !haveUpper) && current > 0)
        {
          range.upper = current;
          haveUpper = true;
        }
      }
      it++;
    }
  }
  
  validRange = haveLower && haveUpper;
  return range;
}

void QCPGraph::getVisibleDataBounds ( QCPDataMap::const_iterator &  lower, QCPDataMap::const_iterator &  upper, int &  count  ) const

protected

Definition at line 1669 of file qcustomplot.cc.

{
  // get visible data range as QMap iterators
  QCPDataMap::const_iterator lbound = mData->lowerBound(mKeyAxis->range().lower);
  QCPDataMap::const_iterator ubound = mData->upperBound(mKeyAxis->range().upper)-1;
  bool lowoutlier = lbound != mData->constBegin(); // indicates whether there exist points below axis range
  bool highoutlier = ubound+1 != mData->constEnd(); // indicates whether there exist points above axis range
  lower = (lowoutlier ? lbound-1 : lbound); // data pointrange that will be actually drawn
  upper = (highoutlier ? ubound+1 : ubound); // data pointrange that will be actually drawn
  
  // count number of points in range lower to upper (including them), so we can allocate array for them in draw functions:
  QCPDataMap::const_iterator it = lower;
  count = 1;
  while (it != upper)
  {
    ++it;
    ++count;
  }
}

LineStyle QCPGraph::lineStyle ( ) const

inlineslot

Definition at line 229 of file qcustomplot.h.

{ return mLineStyle; }

QPointF QCPGraph::lowerFillBasePoint ( double  lowerKey ) const

protected

Definition at line 1740 of file qcustomplot.cc.

{
  QPointF point;
  if (mValueAxis->scaleType() == QCPAxis::STLinear)
  {
    if (mKeyAxis->axisType() == QCPAxis::ATLeft)
    {
      point.setX(mValueAxis->coordToPixel(0));
      point.setY(lowerKey);
    } else if (mKeyAxis->axisType() == QCPAxis::ATRight)
    {
      point.setX(mValueAxis->coordToPixel(0));
      point.setY(lowerKey);
    } else if (mKeyAxis->axisType() == QCPAxis::ATTop)
    {
      point.setX(lowerKey);
      point.setY(mValueAxis->coordToPixel(0));
    } else if (mKeyAxis->axisType() == QCPAxis::ATBottom)
    {
      point.setX(lowerKey);
      point.setY(mValueAxis->coordToPixel(0));
    }
  } else // mValueAxis->mScaleType == QCPAxis::STLogarithmic
  {
    // In logarithmic scaling we can't just draw to value zero so we just fill all the way
    // to the axis which is in the direction towards zero
    if (mKeyAxis->orientation() == Qt::Vertical)
    {
      if ((mValueAxis->range().upper < 0 && !mValueAxis->rangeReversed()) ||
          (mValueAxis->range().upper > 0 && mValueAxis->rangeReversed())) // if range is negative, zero is on opposite side of key axis
        point.setX(mKeyAxis->axisRect().right());
      else
        point.setX(mKeyAxis->axisRect().left());
      point.setY(lowerKey);
    } else if (mKeyAxis->axisType() == QCPAxis::ATTop || mKeyAxis->axisType() == QCPAxis::ATBottom)
    {
      point.setX(lowerKey);
      if ((mValueAxis->range().upper < 0 && !mValueAxis->rangeReversed()) ||
          (mValueAxis->range().upper > 0 && mValueAxis->rangeReversed())) // if range is negative, zero is on opposite side of key axis
        point.setY(mKeyAxis->axisRect().top());
      else
        point.setY(mKeyAxis->axisRect().bottom());
    }
  }
  return point;
}

void QCPGraph::removeData ( double  fromKey, double  toKey  )

slot

Removes all data points with keys between fromKey and toKey. if fromKey is greater or equal to toKey, the function does nothing. To remove a single data point with known key, use removeData(double key).

See also

addData, clearData

Definition at line 674 of file qcustomplot.cc.

{
  if (fromKey >= toKey || mData->isEmpty()) return;
  QCPDataMap::iterator it = mData->upperBound(fromKey);
  QCPDataMap::iterator itEnd = mData->upperBound(toKey);
  while (it != itEnd)
    it = mData->erase(it);
}

void QCPGraph::removeData ( double  key )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Removes a single data point at key. If the position is not known with absolute precision, consider using removeData(double fromKey, double toKey) with a small fuzziness interval around the suspected position, depeding on the precision with which the key is known.

See also

addData, clearData

Definition at line 691 of file qcustomplot.cc.

{
  mData->remove(key);
}

void QCPGraph::removeDataAfter ( double  key )

slot

Removes all data points with keys greater than key.

See also

addData, clearData

Definition at line 659 of file qcustomplot.cc.

{
  if (mData->isEmpty()) return;
  QCPDataMap::iterator it = mData->upperBound(key);
  while (it != mData->end())
    it = mData->erase(it);
}

void QCPGraph::removeDataBefore ( double  key )

slot

Removes all data points with keys smaller than key.

See also

addData, clearData

Definition at line 648 of file qcustomplot.cc.

{
  QCPDataMap::iterator it = mData->begin();
  while (it != mData->end() && it.key() < key)
    it = mData->erase(it);
}

void QCPGraph::removeFillBasePoints ( QVector< QPointF > *  lineData ) const

protected

Definition at line 1722 of file qcustomplot.cc.

{
  lineData->remove(lineData->size()-2, 2);
}

void QCPGraph::rescaleAxes ( bool  onlyEnlarge, bool  includeErrorBars  ) const

virtual

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Allows to define whether error bars are taken into consideration when determining the new axis range.

Definition at line 710 of file qcustomplot.cc.

{
  rescaleKeyAxis(onlyEnlarge, includeErrorBars);
  rescaleValueAxis(onlyEnlarge, includeErrorBars);
}

void QCPGraph::rescaleKeyAxis ( bool  onlyEnlarge, bool  includeErrorBars  ) const

virtual

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Allows to define whether error bars (of kind QCPGraph::etKey) are taken into consideration when determining the new axis range.

Definition at line 721 of file qcustomplot.cc.

{
  // this code is a copy of QCPAbstractPlottable::rescaleKeyAxis with the only change
  // is that getKeyRange is passed the includeErrorBars value.
  if (mData->isEmpty()) return;

  SignDomain signDomain = SDBoth;
  if (mKeyAxis->scaleType() == QCPAxis::STLogarithmic)
    signDomain = (mKeyAxis->range().upper < 0 ? SDNegative : SDPositive);
  
  bool validRange;
  QCPRange newRange = getKeyRange(validRange, signDomain, includeErrorBars);
  
  if (validRange)
  {
    if (onlyEnlarge)
    {
      if (mKeyAxis->range().lower < newRange.lower)
        newRange.lower = mKeyAxis->range().lower;
      if (mKeyAxis->range().upper > newRange.upper)
        newRange.upper = mKeyAxis->range().upper;
    }
    mKeyAxis->setRange(newRange);
  }
}

void QCPGraph::rescaleValueAxis ( bool  onlyEnlarge, bool  includeErrorBars  ) const

virtual

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Allows to define whether error bars (of kind QCPGraph::ETValue) are taken into consideration when determining the new axis range.

Definition at line 752 of file qcustomplot.cc.

{
  // this code is a copy of QCPAbstractPlottable::rescaleValueAxis with the only change
  // is that getValueRange is passed the includeErrorBars value.
  if (mData->isEmpty()) return;

  SignDomain signDomain = SDBoth;
  if (mValueAxis->scaleType() == QCPAxis::STLogarithmic)
    signDomain = (mValueAxis->range().upper < 0 ? SDNegative : SDPositive);
  
  bool validRange;
  QCPRange newRange = getValueRange(validRange, signDomain, includeErrorBars);
  
  if (validRange)
  {
    if (onlyEnlarge)
    {
      if (mValueAxis->range().lower < newRange.lower)
        newRange.lower = mValueAxis->range().lower;
      if (mValueAxis->range().upper > newRange.upper)
        newRange.upper = mValueAxis->range().upper;
    }
    mValueAxis->setRange(newRange);
  }
}

const QPixmap QCPGraph::scatterPixmap ( ) const

inlineslot

Definition at line 232 of file qcustomplot.h.

{ return mScatterPixmap; }

double QCPGraph::scatterSize ( ) const

inlineslot

Definition at line 231 of file qcustomplot.h.

{ return mScatterSize; }

ScatterStyle QCPGraph::scatterStyle ( ) const

inlineslot

Definition at line 230 of file qcustomplot.h.

{ return mScatterStyle; }

void QCPGraph::setChannelFillGraph ( QCPGraph *  targetGraph )

slot

Sets the target graph for filling the area between this graph and targetGraph with the current brush (setBrush).

When targetGraph is set to 0, a normal graph fill will be produced. This means, when the brush is not Qt::NoBrush or fully transparent, a fill all the way to the zero-value-line parallel to the key axis of this graph will be drawn. To disable any filling, set the brush to Qt::NoBrush.

See also

setBrush

Definition at line 578 of file qcustomplot.cc.

{
  // prevent setting channel target to this graph itself:
  if (targetGraph == this)
  {
    qDebug() << FUNCNAME << "targetGraph is self";
    mChannelFillGraph = 0;
    return;
  }
  // prevent setting channel target to a graph not in the plot:
  if (targetGraph && targetGraph->mParentPlot != mParentPlot)
  {
    qDebug() << FUNCNAME << "targetGraph not in same plot";
    mChannelFillGraph = 0;
    return;
  }
  
  mChannelFillGraph = targetGraph;
}

void QCPGraph::setData ( QCPDataMap *  data, bool  copy = false  )

slot

Replaces the current data with the provided data.

If copy is set to true, data points in data will only be copied. if false, the plottable takes ownership of the passed data and replaces the internal data pointer with it. This is significantly faster than copying for large datasets.

Definition at line 295 of file qcustomplot.cc.

{
  if (copy)
  {
    *mData = *data;
  } else
  {
    delete mData;
    mData = data;
  }
}

void QCPGraph::setData ( const QVector< double > &  key, const QVector< double > &  value  )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Replaces the current data with the provided points in key and value pairs. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 313 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    mData->insertMulti(newData.key, newData);
  }
}

void QCPGraph::setDataBothError ( const QVector< double > &  key, const QVector< double > &  value, const QVector< double > &  keyError, const QVector< double > &  valueError  )

slot

Replaces the current data with the provided points in key and value pairs. Additionally the symmetrical key and value errors of the data points are set to the values in keyError and valueError. For error bars to show appropriately, see setErrorType. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 436 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  n = qMin(n, valueError.size());
  n = qMin(n, keyError.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    newData.keyErrorMinus = keyError[i];
    newData.keyErrorPlus = keyError[i];
    newData.valueErrorMinus = valueError[i];
    newData.valueErrorPlus = valueError[i];
    mData->insertMulti(key[i], newData);
  }
}

void QCPGraph::setDataBothError ( const QVector< double > &  key, const QVector< double > &  value, const QVector< double > &  keyErrorMinus, const QVector< double > &  keyErrorPlus, const QVector< double > &  valueErrorMinus, const QVector< double > &  valueErrorPlus  )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Replaces the current data with the provided points in key and value pairs. Additionally the negative key and value errors of the data points are set to the values in keyErrorMinus and valueErrorMinus. The positive key and value errors are set to the values in keyErrorPlus valueErrorPlus. For error bars to show appropriately, see setErrorType. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 465 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  n = qMin(n, valueErrorMinus.size());
  n = qMin(n, valueErrorPlus.size());
  n = qMin(n, keyErrorMinus.size());
  n = qMin(n, keyErrorPlus.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    newData.keyErrorMinus = keyErrorMinus[i];
    newData.keyErrorPlus = keyErrorPlus[i];
    newData.valueErrorMinus = valueErrorMinus[i];
    newData.valueErrorPlus = valueErrorPlus[i];
    mData->insertMulti(key[i], newData);
  }
}

void QCPGraph::setDataKeyError ( const QVector< double > &  key, const QVector< double > &  value, const QVector< double > &  keyError  )

slot

Replaces the current data with the provided points in key and value pairs. Additionally the symmetrical key error of the data points are set to the values in keyError. For error bars to show appropriately, see setErrorType. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 385 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  n = qMin(n, keyError.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    newData.keyErrorMinus = keyError[i];
    newData.keyErrorPlus = keyError[i];
    mData->insertMulti(key[i], newData);
  }
}

void QCPGraph::setDataKeyError ( const QVector< double > &  key, const QVector< double > &  value, const QVector< double > &  keyErrorMinus, const QVector< double > &  keyErrorPlus  )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Replaces the current data with the provided points in key and value pairs. Additionally the negative key error of the data points are set to the values in keyErrorMinus, the positive key error to keyErrorPlus. For error bars to show appropriately, see setErrorType. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 411 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  n = qMin(n, keyErrorMinus.size());
  n = qMin(n, keyErrorPlus.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    newData.keyErrorMinus = keyErrorMinus[i];
    newData.keyErrorPlus = keyErrorPlus[i];
    mData->insertMulti(key[i], newData);
  }
}

void QCPGraph::setDataValueError ( const QVector< double > &  key, const QVector< double > &  value, const QVector< double > &  valueError  )

slot

Replaces the current data with the provided points in key and value pairs. Additionally the symmetrical value error of the data points are set to the values in valueError. For error bars to show appropriately, see setErrorType. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 334 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  n = qMin(n, valueError.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    newData.valueErrorMinus = valueError[i];
    newData.valueErrorPlus = valueError[i];
    mData->insertMulti(key[i], newData);
  }
}

void QCPGraph::setDataValueError ( const QVector< double > &  key, const QVector< double > &  value, const QVector< double > &  valueErrorMinus, const QVector< double > &  valueErrorPlus  )

slot

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Replaces the current data with the provided points in key and value pairs. Additionally the negative value error of the data points are set to the values in valueErrorMinus, the positive value error to valueErrorPlus. For error bars to show appropriately, see setErrorType. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 360 of file qcustomplot.cc.

{
  mData->clear();
  int n = key.size();
  n = qMin(n, value.size());
  n = qMin(n, valueErrorMinus.size());
  n = qMin(n, valueErrorPlus.size());
  QCPData newData;
  for (int i=0; i<n; ++i)
  {
    newData.key = key[i];
    newData.value = value[i];
    newData.valueErrorMinus = valueErrorMinus[i];
    newData.valueErrorPlus = valueErrorPlus[i];
    mData->insertMulti(key[i], newData);
  }
}

void QCPGraph::setErrorBarSize ( double  size )

slot

Sets the width of the handles at both ends of an error bar in pixels.

Definition at line 550 of file qcustomplot.cc.

{
  mErrorBarSize = size;
}

void QCPGraph::setErrorBarSkipSymbol ( bool  enabled )

slot

If enabled is set to true, the error bar will not be drawn as a solid line under the scatter symbol but leave some free space around the symbol.

This feature uses the current scatter size (setScatterSize) to determine the size of the area to leave blank. So when drawing Pixmaps as scatter points (SSPixmap), the scatter size must be set manually to a value corresponding to the size of the Pixmap, if the error bars should leave gaps to its boundaries.

Definition at line 564 of file qcustomplot.cc.

{
  mErrorBarSkipSymbol = enabled;
}

void QCPGraph::setErrorPen ( const QPen &  pen )

slot

Sets the pen with which the error bars will be drawn.

See also

setErrorBarSize, setErrorType

Definition at line 542 of file qcustomplot.cc.

{
  mErrorPen = pen;
}

void QCPGraph::setErrorType ( ErrorType  errorType )

slot

See also

ErrorType

Definition at line 533 of file qcustomplot.cc.

{
  mErrorType = errorType;
}

void QCPGraph::setLineStyle ( int  ls )

slot

Sets how the single data points are connected in the plot or how they are represented visually apart from the scatter symbol. For scatter-only plots, set ls to LSNone and setScatterStyle to the desired scatter style.

See also

setScatterStyle

Definition at line 494 of file qcustomplot.cc.

{
  mLineStyle = (LineStyle)ls;
}

void QCPGraph::setScatterPixmap ( const QPixmap &  pixmap )

slot

If the scatter style (setScatterStyle) is set to SSPixmap, this function defines the QPixmap that will be drawn centered on the data point coordinate.

See also

ScatterStyle

Definition at line 525 of file qcustomplot.cc.

{
  mScatterPixmap = pixmap;
}

void QCPGraph::setScatterSize ( double  size )

slot

This defines how big (in pixels) single scatters are drawn, if scatter style (setScatterStyle) isn't SSNone, SSDot or SSPixmap. Floating point values are allowed for fine grained control over optical appearance with antialiased painting.

See also

ScatterStyle

Definition at line 515 of file qcustomplot.cc.

{
  mScatterSize = size;
}

void QCPGraph::setScatterStyle ( int  ss )

slot

Sets the visual appearance of single data points in the plot. If set to SSNone, no scatter points are drawn (e.g. for line-only-plots with appropriate line style).

See also

ScatterStyle, setLineStyle

Definition at line 504 of file qcustomplot.cc.

{
  mScatterStyle = (ScatterStyle)ss;
}

QPointF QCPGraph::upperFillBasePoint ( double  upperKey ) const

protected

Definition at line 1800 of file qcustomplot.cc.

{
  QPointF point;
  if (mValueAxis->scaleType() == QCPAxis::STLinear)
  {
    if (mKeyAxis->axisType() == QCPAxis::ATLeft)
    {
      point.setX(mValueAxis->coordToPixel(0));
      point.setY(upperKey);
    } else if (mKeyAxis->axisType() == QCPAxis::ATRight)
    {
      point.setX(mValueAxis->coordToPixel(0));
      point.setY(upperKey);
    } else if (mKeyAxis->axisType() == QCPAxis::ATTop)
    {
      point.setX(upperKey);
      point.setY(mValueAxis->coordToPixel(0));
    } else if (mKeyAxis->axisType() == QCPAxis::ATBottom)
    {
      point.setX(upperKey);
      point.setY(mValueAxis->coordToPixel(0));
    }
  } else // mValueAxis->mScaleType == QCPAxis::STLogarithmic
  {
    // In logarithmic scaling we can't just draw to value 0 so we just fill all the way
    // to the axis which is in the direction towards 0
    if (mKeyAxis->orientation() == Qt::Vertical)
    {
      if ((mValueAxis->range().upper < 0 && !mValueAxis->rangeReversed()) ||
          (mValueAxis->range().upper > 0 && mValueAxis->rangeReversed())) // if range is negative, zero is on opposite side of key axis
        point.setX(mKeyAxis->axisRect().right());
      else
        point.setX(mKeyAxis->axisRect().left());
      point.setY(upperKey);
    } else if (mKeyAxis->axisType() == QCPAxis::ATTop || mKeyAxis->axisType() == QCPAxis::ATBottom)
    {
      point.setX(upperKey);
      if ((mValueAxis->range().upper < 0 && !mValueAxis->rangeReversed()) ||
          (mValueAxis->range().upper > 0 && mValueAxis->rangeReversed())) // if range is negative, zero is on opposite side of key axis
        point.setY(mKeyAxis->axisRect().top());
      else
        point.setY(mKeyAxis->axisRect().bottom());
    }
  }
  return point;
}

Friends And Related Function Documentation

friend class QCPLegend

friend

Definition at line 327 of file qcustomplot.h.

friend class QCustomPlot

friend

Definition at line 326 of file qcustomplot.h.

Member Data Documentation

QCPGraph* QCPGraph::mChannelFillGraph

protected

Definition at line 287 of file qcustomplot.h.

QCPDataMap* QCPGraph::mData

protected

Definition at line 278 of file qcustomplot.h.

double QCPGraph::mErrorBarSize

protected

Definition at line 285 of file qcustomplot.h.

bool QCPGraph::mErrorBarSkipSymbol

protected

Definition at line 286 of file qcustomplot.h.

QPen QCPGraph::mErrorPen

protected

Definition at line 279 of file qcustomplot.h.

ErrorType QCPGraph::mErrorType

protected

Definition at line 284 of file qcustomplot.h.

LineStyle QCPGraph::mLineStyle

protected

Definition at line 280 of file qcustomplot.h.

QPixmap QCPGraph::mScatterPixmap

protected

Definition at line 283 of file qcustomplot.h.

double QCPGraph::mScatterSize

protected

Definition at line 282 of file qcustomplot.h.

ScatterStyle QCPGraph::mScatterStyle

protected

Definition at line 281 of file qcustomplot.h.

---

The documentation for this class was generated from the following files:

• /build/rock-master-18.09-gui-rock-widget-collection-0.20180124/src/plot2d/qcustomplot.h
• /build/rock-master-18.09-gui-rock-widget-collection-0.20180124/src/plot2d/qcustomplot.cc