A plottable representing a parametric curve in a plot. More...

#include <qcustomplot.h>

Public Member Functions
	QCPCurve (QCPAxis keyAxis, QCPAxis valueAxis)

virtual	~QCPCurve ()

const QCPCurveDataMap *	data () const

void	setData (QCPCurveDataMap *data, bool copy=false)

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

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

void	addData (const QCPCurveDataMap &dataMap)

void	addData (const QCPCurveData &data)

void	addData (double t, double key, double value)

void	addData (double key, double value)

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

void	removeDataBefore (double t)

void	removeDataAfter (double t)

void	removeData (double fromt, double tot)

void	removeData (double t)

virtual void	clearData ()

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	getCurveData (QVector< QPointF > *lineData) const

QPointF	outsideCoordsToPixels (double key, double value, int region) const

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

virtual QCPRange	getValueRange (bool &validRange, SignDomain inSignDomain=SDBoth) 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
QCPCurveDataMap *	mData

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
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 bool	addToLegend () const

virtual bool	removeFromLegend () const

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

Detailed Description

A plottable representing a parametric curve in a plot.

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

Changing the appearance

The appearance of the curve is determined by the pen and the brush (setPen, setBrush).

Usage

Like all data representing objects in QCustomPlot, the QCPCurve is a plottable (QCPAbstractPlottable). So the plottable-interface of QCustomPlot applies (QCustomPlot::plottable, QCustomPlot::addPlottable, QCustomPlot::removePlottable, etc.)

Usually, you first create an instance:

QCPCurve *newCurve = new QCPCurve(customPlot->xAxis, customPlot->yAxis);

add it to the customPlot with QCustomPlot::addPlottable:

customPlot->addPlottable(newCurve);

and then modify the properties of the newly created plottable, e.g.:

newCurve->setName("Fermat's Spiral");

newCurve->setData(tData, xData, yData);

Definition at line 330 of file qcustomplot.h.

Constructor & Destructor Documentation

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

explicit

Constructs a curve 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 QCPCurve can be added to the plot with QCustomPlot::addPlottable, QCustomPlot then takes ownership of the graph.

Definition at line 6560 of file qcustomplot.cc.

                                                        :
   QCPAbstractPlottable(keyAxis, valueAxis)
 {
   mData = new QCPCurveDataMap;
   mPen.setColor(Qt::blue);
   mPen.setStyle(Qt::SolidLine);
   mBrush.setColor(Qt::blue);
   mBrush.setStyle(Qt::NoBrush);
 }

QCPCurve::~QCPCurve ( )

virtual

Definition at line 6570 of file qcustomplot.cc.

 {
   delete mData;
 }

Member Function Documentation

void QCPCurve::addData ( const QCPCurveDataMap & dataMap )

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

See Also: removeData

Definition at line 6640 of file qcustomplot.cc.

 {
   mData->unite(dataMap);
 }

void QCPCurve::addData ( const QCPCurveData & data )

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 6649 of file qcustomplot.cc.

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

void QCPCurve::addData	(	double	t,
		double	key,
		double	value
	)

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 t, key and value tuple to the current data

See Also: removeData

Definition at line 6658 of file qcustomplot.cc.

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

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

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 The t parameter of the data point is set to the t of the last data point plus 1. If there is no last data point, t will be set to 0.

See Also: removeData

Definition at line 6675 of file qcustomplot.cc.

 {
   QCPCurveData newData;
   if (!mData->isEmpty())
     newData.t = (mData->constEnd()-1).key()+1;
   else
     newData.t = 0;
   newData.key = key;
   newData.value = value;
   mData->insertMulti(newData.t, newData);
 }

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

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 t, key and value tuples to the current data.

See Also: removeData

Definition at line 6691 of file qcustomplot.cc.

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

void QCPCurve::clearData ( )

virtual

Removes all data points.

See Also: removeData, removeDataAfter, removeDataBefore

Implements QCPAbstractPlottable.

Definition at line 6763 of file qcustomplot.cc.

 {
   mData->clear();
 }

const QCPCurveDataMap* QCPCurve::data ( ) const

inline

Definition at line 338 of file qcustomplot.h.

338 { return mData; }

QCPCurve::mData

QCPCurveDataMap * mData

Definition: qcustomplot.h:358

void QCPCurve::draw ( QPainter * painter ) const

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 6769 of file qcustomplot.cc.

 {
   if (!mVisible) return;
   if (mData->isEmpty()) return;
   painter->setClipRect(mKeyAxis->axisRect().united(mValueAxis->axisRect()));
   
   // allocate line vector:
   QVector<QPointF> *lineData = new QVector<QPointF>;
   // fill with curve data:
   getCurveData(lineData);
   // draw curve fill:
   if (mBrush.style() != Qt::NoBrush && mBrush.color().alpha() != 0)
   {
     painter->setRenderHint(QPainter::Antialiasing, mParentPlot->antialiasedElements().testFlag(QCustomPlot::AEFills));
     painter->setPen(Qt::NoPen);
     painter->setBrush(mBrush);
     painter->drawPolygon(QPolygonF(*lineData));
   }
   // draw curve line:
   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));
   }
   // free allocated line data:
   delete lineData;
 }

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

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 6800 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:
   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
 }

void QCPCurve::getCurveData ( QVector< QPointF > * lineData ) const

protected

Definition at line 6819 of file qcustomplot.cc.

 {
   /* Edges of axis rect R divide outside space into 9 regions:
      1__|_4_|__7  
      2__|_R_|__8
      3  | 6 |  9 
      General idea: If the two points of a line segment are in the same region (that is not R), the line segment is omitted.
      The region inside R has index 5.
   */
   lineData->reserve(mData->size());
   QCPCurveDataMap::const_iterator it;
   int lastRegion = 5;
   int currentRegion = 5;
   double RLeft = mKeyAxis->range().lower;
   double RRight = mKeyAxis->range().upper;
   double RBottom = mValueAxis->range().lower;
   double RTop = mValueAxis->range().upper;
   double x, y; // current key/value
   bool addedLastAlready = true;
   bool firstPoint = true; // first point must always be drawn, to make sure fill works correctly
   for (it = mData->constBegin(); it != mData->constEnd(); ++it)
   {
     x = it.value().key;
     y = it.value().value;
     // determine current region:
     if (x < RLeft) // region 123
     {
       if (y > RTop)
         currentRegion = 1;
       else if (y < RBottom)
         currentRegion = 3;
       else
         currentRegion = 2;
     } else if (x > RRight) // region 789
     {
       if (y > RTop)
         currentRegion = 7;
       else if (y < RBottom)
         currentRegion = 9;
       else
         currentRegion = 8;
     } else // region 456
     {
       if (y > RTop)
         currentRegion = 4;
       else if (y < RBottom)
         currentRegion = 6;
       else
         currentRegion = 5;
     }
     
     /*
       Watch out, the next part is very tricky, since it modifies the curve such that it seems like
       the whole thing is still drawn, but actually the points outside the axisRect are simplified
       ("optimized") greatly. There are some subtle special cases when line segments are large and
       thereby each subsequent point may be in a different region or even skip some.
     */
     // determine whether to keep current point:
     if (currentRegion == 5 || (firstPoint && mBrush.style() != Qt::NoBrush)) // current is in R, add current and last if it wasn't added already
     {
       if (!addedLastAlready) // in case curve just entered R, make sure the last point outside R is also drawn correctly
         lineData->append(coordsToPixels((it-1).value().key, (it-1).value().value)); // add last point to vector
       else if (lastRegion != 5) // added last already. If that's the case, we probably added it at optimized position. So go back and make sure it's at original position
       {
         if (!firstPoint) // because on firstPoint, currentRegion is 5 and addedLastAlready is true, although there is no last point
           lineData->replace(lineData->size()-1, coordsToPixels((it-1).value().key, (it-1).value().value));
       }
       lineData->append(coordsToPixels(it.value().key, it.value().value)); // add current point to vector
       addedLastAlready = true; // so in next iteration, we don't add this point twice
     } else if (currentRegion != lastRegion) // changed region, add current and last if not added already
     {
       // using outsideCoordsToPixels instead of coorsToPixels for optimized point placement (places points just outside axisRect instead of potentially far away)
       
       // if we're coming from R or we skip diagonally over the edge regions (so line might still be visible in R), we can't place points optimized
       if (lastRegion == 5 || // coming from R
           ((lastRegion==2 && currentRegion==4) || (lastRegion==4 && currentRegion==2)) || // skip top left diagonal
           ((lastRegion==4 && currentRegion==8) || (lastRegion==8 && currentRegion==4)) || // skip top right diagonal
           ((lastRegion==8 && currentRegion==6) || (lastRegion==6 && currentRegion==8)) || // skip bottom right diagonal
           ((lastRegion==6 && currentRegion==2) || (lastRegion==2 && currentRegion==6))    // skip bottom left diagonal
           )
       {
         // always add last point if not added already, original:
         if (!addedLastAlready)
           lineData->append(coordsToPixels((it-1).value().key, (it-1).value().value));
         // add current point, original:
         lineData->append(coordsToPixels(it.value().key, it.value().value));
       } else // no special case that forbids optimized point placement, so do it:
       {
         // always add last point if not added already, optimized:
         if (!addedLastAlready)
           lineData->append(outsideCoordsToPixels((it-1).value().key, (it-1).value().value, currentRegion));
         // add current point, optimized:
         lineData->append(outsideCoordsToPixels(it.value().key, it.value().value, currentRegion));
       }
       addedLastAlready = true; // so that if next point enters 5, or crosses another region boundary, we don't add this point twice
     } else // neither in R, nor crossed a region boundary, skip current point
     {
       addedLastAlready = false;
     }
     lastRegion = currentRegion;
     firstPoint = false;
   }
   // If curve ends outside R, we want to add very last point so the fill looks like it should when the curve started inside R:
   if (lastRegion != 5 && mBrush.style() != Qt::NoBrush && !mData->isEmpty())
     lineData->append(coordsToPixels((mData->constEnd()-1).value().key, (mData->constEnd()-1).value().value));
 }

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

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 6960 of file qcustomplot.cc.

 {
   QCPRange range;
   bool haveLower = false;
   bool haveUpper = false;
   
   double current;
   
   QCPCurveDataMap::const_iterator it = mData->constBegin();
   while (it != mData->constEnd())
   {
     current = it.value().key;
     if (inSignDomain == SDBoth || (inSignDomain == SDNegative && current < 0) || (inSignDomain == SDPositive && current > 0))
     {
       if (current < range.lower || !haveLower)
       {
         range.lower = current;
         haveLower = true;
       }
       if (current > range.upper || !haveUpper)
       {
         range.upper = current;
         haveUpper = true;
       }
     }
     ++it;
   }
   
   validRange = haveLower && haveUpper;
   return range;
 }

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

protectedvirtual

Implements QCPAbstractPlottable.

Definition at line 6993 of file qcustomplot.cc.

 {
   QCPRange range;
   bool haveLower = false;
   bool haveUpper = false;
   
   double current;
   
   QCPCurveDataMap::const_iterator it = mData->constBegin();
   while (it != mData->constEnd())
   {
     current = it.value().value;
     if (inSignDomain == SDBoth || (inSignDomain == SDNegative && current < 0) || (inSignDomain == SDPositive && current > 0))
     {
       if (current < range.lower || !haveLower)
       {
         range.lower = current;
         haveLower = true;
       }
       if (current > range.upper || !haveUpper)
       {
         range.upper = current;
         haveUpper = true;
       }
     }
     ++it;
   }
   
   validRange = haveLower && haveUpper;
   return range;
 }

QPointF QCPCurve::outsideCoordsToPixels	(	double	key,
		double	value,
		int	region
	)		const

protected

Definition at line 6936 of file qcustomplot.cc.

 {
   int margin = 10;
   QRect axisRect = mKeyAxis->axisRect().united(mValueAxis->axisRect());
   QPointF result = coordsToPixels(key, value);
   switch (region)
   {
     case 2: result.setX(axisRect.left()-margin); break; // left
     case 8: result.setX(axisRect.right()+margin); break; // right
     case 4: result.setY(axisRect.top()-margin); break; // top
     case 6: result.setY(axisRect.bottom()+margin); break; // bottom
     case 1: result.setX(axisRect.left()-margin);
             result.setY(axisRect.top()-margin); break; // top left
     case 7: result.setX(axisRect.right()+margin);
             result.setY(axisRect.top()-margin); break; // top right
     case 9: result.setX(axisRect.right()+margin);
             result.setY(axisRect.bottom()+margin); break; // bottom right
     case 3: result.setX(axisRect.left()-margin);
             result.setY(axisRect.bottom()+margin); break; // bottom left
   }
   return result;
 }

void QCPCurve::removeData	(	double	fromt,
		double	tot
	)

Removes all data points with curve parameter t between fromt and tot. if fromt is greater or equal to tot, the function does nothing. To remove a single data point with known t, use removeData(double t).

See Also: addData, clearData

Definition at line 6736 of file qcustomplot.cc.

 {
   if (fromt >= tot || mData->isEmpty()) return;
   QCPCurveDataMap::iterator it = mData->upperBound(fromt);
   QCPCurveDataMap::iterator itEnd = mData->upperBound(tot);
   while (it != itEnd)
     it = mData->erase(it);
 }

void QCPCurve::removeData ( double t )

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 curve parameter t. If the position is not known with absolute precision, consider using removeData(double fromt, double tot) with a small fuzziness interval around the suspected position, depeding on the precision with which the curve parameter is known.

See Also: addData, clearData

Definition at line 6754 of file qcustomplot.cc.

 {
   mData->remove(t);
 }

void QCPCurve::removeDataAfter ( double t )

Removes all data points with curve parameter t greater than t.

See Also: addData, clearData

Definition at line 6721 of file qcustomplot.cc.

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

void QCPCurve::removeDataBefore ( double t )

Removes all data points with curve parameter t smaller than t.

See Also: addData, clearData

Definition at line 6710 of file qcustomplot.cc.

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

void QCPCurve::setData	(	QCPCurveDataMap *	data,
		bool	copy = `false`
	)

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 6582 of file qcustomplot.cc.

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

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

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 t, key and value tuples. The provided vectors should have equal length. Else, the number of added points will be the size of the smallest vector.

Definition at line 6600 of file qcustomplot.cc.

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

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

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 key and value pairs. The t parameter of each data point will be set to the integer index of the respective key/value pair.

Definition at line 6621 of file qcustomplot.cc.

 {
   mData->clear();
   int n = key.size();
   n = qMin(n, value.size());
   QCPCurveData newData;
   for (int i=0; i<n; ++i)
   {
     newData.t = i; // no t vector given, so we assign t the index of the key/value pair
     newData.key = key[i];
     newData.value = value[i];
     mData->insertMulti(newData.t, newData);
   }
 }

Friends And Related Function Documentation

friend class QCPLegend

friend

Definition at line 369 of file qcustomplot.h.

friend class QCustomPlot

friend

Definition at line 368 of file qcustomplot.h.

Member Data Documentation

QCPCurveDataMap* QCPCurve::mData

protected

Definition at line 358 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

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Changing the appearance

Usage

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation