HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2372:d6a999e30ac3

QSplineSeries calculateControlPoints moved to splinechartitem. This way we don't need to deal with controlPoints on logaritmic scale

Marek Rosa -

r2372:d6a999e30ac3

parent child

Context file:

r2372:d6a999e30ac3

Collapse all files

src/axis/logvalueaxis/chartlogvalueaxisx.cpp +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlogvalueaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "chartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartLogValueAxisX::ChartLogValueAxisX(QLogValueAxis *axis, QGraphicsItem* item)
                 : HorizontalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis,SIGNAL(baseChanged(qreal)),this, SLOT(handleBaseChanged(qreal)));
                 QObject::connect(m_axis,SIGNAL(labelFormatChanged(QString)),this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartLogValueAxisX::~ChartLogValueAxisX()
             {
             }
             QVector<qreal> ChartLogValueAxisX::calculateLayout() const
             {
                 QVector<qreal> points;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 qreal leftEdge = logMin < logMax ? logMin : logMax;
                 qreal ceilEdge = ceil(leftEdge);
-                int tickCount = qAbs(qRound(logMax - logMin));
+                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
-                tickCount++;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaX = gridRect.width() / qAbs(logMax - logMin);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = (ceilEdge + i) * deltaX - leftEdge * deltaX + gridRect.left();
                 return points;
             }
             void ChartLogValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
                 HorizontalAxis::updateGeometry();
             }
             void ChartLogValueAxisX::handleBaseChanged(qreal base)
             {
                 Q_UNUSED(base);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartLogValueAxisX::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartLogValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = HorizontalAxis::sizeHint(which, constraint);
                 QStringList ticksList;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 int tickCount = qAbs(ceil(logMax) - ceil(logMin));
                 if (m_axis->max() > m_axis->min() && tickCount > 1)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else
                     ticksList.append(QString(" "));
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize:{
                     int count = qMax(ticksList.last().count(),ticksList.first().count());
                     width = fn.averageCharWidth() * count;
                     height = fn.height() + labelPadding();
                     width = qMax(width,base.width());
                     height += base.height();
                     sh = QSizeF(width,height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     int count = qMax(ticksList.last().count(),ticksList.first().count());
                     width=fn.averageCharWidth() * count;
                     height=fn.height()+labelPadding();
                     width=qMax(width,base.width());
                     height+=base.height();
                     sh = QSizeF(width,height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisx_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisy.cpp +1 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartlogvalueaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qlogvalueaxis.h"
             #include "chartlayout_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartLogValueAxisY::ChartLogValueAxisY(QLogValueAxis *axis, QGraphicsItem* item)
                 : VerticalAxis(axis, item),
                   m_axis(axis)
             {
                 QObject::connect(m_axis, SIGNAL(baseChanged(qreal)),this, SLOT(handleBaseChanged(qreal)));
                 QObject::connect(m_axis,SIGNAL(labelFormatChanged(QString)),this, SLOT(handleLabelFormatChanged(QString)));
             }
             ChartLogValueAxisY::~ChartLogValueAxisY()
             {
             }
             QVector<qreal> ChartLogValueAxisY::calculateLayout() const
             {
                 QVector<qreal> points;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 qreal leftEdge = logMin < logMax ? logMin : logMax;
                 qreal ceilEdge = ceil(leftEdge);
-                int tickCount = qAbs(qRound(logMax - logMin));
+                int tickCount = qAbs(ceil(logMax) - ceil(logMin));
-                tickCount++;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / qAbs(logMax - logMin);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = (ceilEdge + i) * -deltaY - leftEdge * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartLogValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
                 VerticalAxis::updateGeometry();
             }
             void ChartLogValueAxisY::handleBaseChanged(qreal base)
             {
                 Q_UNUSED(base);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartLogValueAxisY::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartLogValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(font());
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList;
                 qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
                 qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
                 int tickCount = qAbs(ceil(logMax) - ceil(logMin));
                 if (m_axis->max() > m_axis->min() && tickCount > 1)
                     ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
                 else
                     ticksList.append(QString(" "));
-                qDebug() << ticksList;
-                qDebug() << tickCount;
                 qreal width = 0;
                 qreal height = 0;
                 switch (which) {
                 case Qt::MinimumSize: {
                     width = fn.boundingRect("...").width() + labelPadding();
                     width += base.width();
                     height = fn.height();
                     height = qMax(height,base.height());
                     sh = QSizeF(width,height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     int count = qMax(ticksList.first().count(), ticksList.last().count());
                     width = count*fn.averageCharWidth() + labelPadding() + 2; //two pixels of tolerance
                     width += base.width();
                     height = fn.height() * ticksList.count();
                     height = qMax(height,base.height());
                     sh = QSizeF(width,height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             #include "moc_chartlogvalueaxisy_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp 0 -120

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qsplineseries.h"
             #include "qsplineseries_p.h"
             #include "splinechartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "splineanimation_p.h"
             /*!
                 \class QSplineSeries
                 \brief Series type used to store data needed to draw a spline.
                 QSplineSeries stores the data points along with the segment control points needed by QPainterPath to draw spline
                 Control points are automatically calculated when data changes. The algorithm computes the points so that the normal spline can be drawn.
                 \image examples_splinechart.png
                 Creating basic spline chart is simple:
                 \code
                 QSplineSeries* series = new QSplineSeries();
                 series->append(0, 6);
                 series->append(2, 4);
                 ...
                 chart->addSeries(series);
                 \endcode
             */
             /*!
                 \qmlclass SplineSeries QSplineSeries
                 \inherits XYSeries
                 The following QML shows how to create a simple spline chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View3.qml 1
                 \beginfloatleft
                 \image demos_qmlchart3.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \fn QSeriesType QSplineSeries::type() const
                 Returns the type of the series
             */
             /*!
                 \qmlproperty real SplineSeries::width
                 The width of the line. By default the width is 2.0.
             */
             /*!
                 \qmlproperty Qt::PenStyle SplineSeries::style
                 Controls the style of the line. Set to one of Qt.NoPen, Qt.SolidLine, Qt.DashLine, Qt.DotLine,
                 Qt.DashDotLine or Qt.DashDotDotLine. Using Qt.CustomDashLine is not supported in the QML API.
                 By default the style is Qt.SolidLine.
             */
             /*!
                 \qmlproperty Qt::PenCapStyle SplineSeries::capStyle
                 Controls the cap style of the line. Set to one of Qt.FlatCap, Qt.SquareCap or Qt.RoundCap. By
                 default the cap style is Qt.SquareCap.
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance then the ownerships is transferred.
               */
             QSplineSeries::QSplineSeries(QObject *parent)
                 : QLineSeries(*new QSplineSeriesPrivate(this), parent)
             {
-                Q_D(QSplineSeries);
-                QObject::connect(this, SIGNAL(pointAdded(int)), d, SLOT(updateControlPoints()));
-                QObject::connect(this, SIGNAL(pointRemoved(int)), d, SLOT(updateControlPoints()));
-                QObject::connect(this, SIGNAL(pointReplaced(int)), d, SLOT(updateControlPoints()));
-                QObject::connect(this, SIGNAL(pointsReplaced()), d, SLOT(updateControlPoints()));
             }
             /*!
               Destroys the object.
             */
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeSpline;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries *q)
                 : QLineSeriesPrivate(q)
             {
             }
-            /*!
-              Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
-              */
-            void QSplineSeriesPrivate::calculateControlPoints()
-                Q_Q(QSplineSeries);
-                const QList<QPointF>& points = q->points();
-                int n = points.count() - 1;
-                if (n == 1) {
-                    //for n==1
-                    m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
-                    m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
-                    m_controlPoints[1].setX(2 * m_controlPoints[0].x() - points[0].x());
-                    m_controlPoints[1].setY(2 * m_controlPoints[0].y() - points[0].y());
-                    return;
-                // Calculate first Bezier control points
-                // Set of equations for P0 to Pn points.
-                //
-                //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
-                //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
-                //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
-                //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
-                //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
-                //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
-                //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
-                //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
-                //
-                QVector<qreal> vector;
-                vector.resize(n);
-                vector[0] = points[0].x() + 2 * points[1].x();
-                for (int i = 1; i < n - 1; ++i)
-                    vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
-                vector[n - 1] = (8 * points[n - 1].x() + points[n].x()) / 2.0;
-                QVector<qreal> xControl = firstControlPoints(vector);
-                vector[0] = points[0].y() + 2 * points[1].y();
-                for (int i = 1; i < n - 1; ++i)
-                    vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
-                vector[n - 1] = (8 * points[n - 1].y() + points[n].y()) / 2.0;
-                QVector<qreal> yControl = firstControlPoints(vector);
-                for (int i = 0, j = 0; i < n; ++i, ++j) {
-                    m_controlPoints[j].setX(xControl[i]);
-                    m_controlPoints[j].setY(yControl[i]);
-                    j++;
-                    if (i < n - 1) {
-                        m_controlPoints[j].setX(2 * points[i + 1].x() - xControl[i + 1]);
-                        m_controlPoints[j].setY(2 * points[i + 1].y() - yControl[i + 1]);
-                    } else {
-                        m_controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
-                        m_controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
-            QVector<qreal> QSplineSeriesPrivate::firstControlPoints(const QVector<qreal>& vector)
-                QVector<qreal> result;
-                int count = vector.count();
-                result.resize(count);
-                result[0] = vector[0] / 2.0;
-                QVector<qreal> temp;
-                temp.resize(count);
-                temp[0] = 0;
-                qreal b = 2.0;
-                for (int i = 1; i < count; i++) {
-                    temp[i] = 1 / b;
-                    b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
-                    result[i] = (vector[i] - result[i - 1]) / b;
-                for (int i = 1; i < count; i++)
-                    result[count - i - 1] -= temp[count - i] * result[count - i];
-                return result;
-            QPointF QSplineSeriesPrivate::controlPoint(int index) const
-                return m_controlPoints[index];
-            /*!
-              Updates the control points, besed on currently avaiable knots.
-              */
-            void QSplineSeriesPrivate::updateControlPoints()
-                Q_Q(QSplineSeries);
-                if (q->count() > 1) {
-                    m_controlPoints.resize(2 * q->count() - 2);
-                    calculateControlPoints();
             void QSplineSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem *spline = new SplineChartItem(q,parent);
                 m_item.reset(spline);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QSplineSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QSplineSeries);
                 const QList<QColor> colors = theme->seriesColors();
                 QPen pen;
                 if (forced || pen == m_pen) {
                     pen.setColor(colors.at(index % colors.size()));
                     pen.setWidthF(2);
                     q->setPen(pen);
                 }
             }
             void QSplineSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 SplineChartItem *item = static_cast<SplineChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new SplineAnimation(item));
                 }else{
                     item->setAnimation(0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             #include "moc_qsplineseries.cpp"
             #include "moc_qsplineseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries_p.h 0 -11

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QSPLINESERIES_P_H
             #define QSPLINESERIES_P_H
             #include "qlineseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QSplineSeriesPrivate: public QLineSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QSplineSeriesPrivate(QSplineSeries *q);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeAnimations(QtCommercialChart::QChart::AnimationOptions options);
-                QPointF controlPoint(int index) const;
-            public Q_SLOTS:
-                void updateControlPoints();
-            private:
-                void calculateControlPoints();
-                QVector<qreal> firstControlPoints(const QVector<qreal>& vector);
-            public:
-                QVector<QPointF> m_controlPoints;
             private:
                 Q_DECLARE_PUBLIC(QSplineSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/splinechart/splinechartitem.cpp +98 -13

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "splineanimation_p.h"
             #include "abstractdomain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, QGraphicsItem* item)
                 : XYChart(series,item),
                   m_series(series),
                   m_pointsVisible(false),
                   m_animation(0)
             {
                 setAcceptHoverEvents(true);
                 setZValue(ChartPresenter::SplineChartZValue);
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 QPainterPathStroker stroker;
                 return stroker.createStroke(m_path);
             }
             void SplineChartItem::setAnimation(SplineAnimation *animation)
             {
                 m_animation = animation;
                 XYChart::setAnimation(animation);
             }
             ChartAnimation *SplineChartItem::animation() const
             {
                 return m_animation;
             }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints = points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 QVector<QPointF> controlPoints;
                 if (newPoints.count() >= 2)
-                    controlPoints.resize(newPoints.count() * 2 - 2);
+                    controlPoints = calculateControlPoints(newPoints);
-                for (int i = 0; i < newPoints.size() - 1; i++) {
-                    controlPoints[2 * i] = calculateGeometryControlPoint(2 * i);
-                    controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 if (m_animation)
                     m_animation->setup(oldPoints, newPoints, m_controlPoints, controlPoints, index);
                 m_points = newPoints;
                 m_controlPoints = controlPoints;
                 setDirty(false);
                 if (m_animation)
                     presenter()->startAnimation(m_animation);
                 else
                     updateGeometry();
             }
-            QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
-                bool ok;
-                return domain()->calculateGeometryPoint(m_series->d_func()->controlPoint(index), ok);
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = m_points;
                 const QVector<QPointF> &controlPoints = m_controlPoints;
                 if ((points.size() < 2) || (controlPoints.size() < 2)) {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 Q_ASSERT(points.count() * 2 - 2 == controlPoints.count());
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF &point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point);
                 }
                 prepareGeometryChange();
                 //    QPainterPathStroker stroker;
                 //    stroker.setWidth(m_linePen.width() / 2.0);
                 //    m_path = stroker.createStroke(splinePath);
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
             }
+            /*!
+              Calculates control points which are needed by QPainterPath.cubicTo function to draw the cubic Bezier cureve between two points.
+              */
+            QVector<QPointF> SplineChartItem::calculateControlPoints(const QVector<QPointF> &points)
+            {
+                QVector<QPointF> controlPoints;
+                controlPoints.resize(points.count() * 2 - 2);
+                int n = points.count() - 1;
+                if (n == 1) {
+                    //for n==1
+                    controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
+                    controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
+                    controlPoints[1].setX(2 * controlPoints[0].x() - points[0].x());
+                    controlPoints[1].setY(2 * controlPoints[0].y() - points[0].y());
+                    return controlPoints;
+                }
+                // Calculate first Bezier control points
+                // Set of equations for P0 to Pn points.
+                //
+                //  |   2   1   0   0   ... 0   0   0   ... 0   0   0   |   |   P1_1    |   |   P0 + 2 * P1             |
+                //  |   1   4   1   0   ... 0   0   0   ... 0   0   0   |   |   P1_2    |   |   4 * P1 + 2 * P2         |
+                //  |   0   1   4   1   ... 0   0   0   ... 0   0   0   |   |   P1_3    |   |   4 * P2 + 2 * P3         |
+                //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
+                //  |   0   0   0   0   ... 1   4   1   ... 0   0   0   | * |   P1_i    | = |   4 * P(i-1) + 2 * Pi     |
+                //  |   .   .   .   .   .   .   .   .   .   .   .   .   |   |   ...     |   |   ...                     |
+                //  |   0   0   0   0   0   0   0   0   ... 1   4   1   |   |   P1_(n-1)|   |   4 * P(n-2) + 2 * P(n-1) |
+                //  |   0   0   0   0   0   0   0   0   ... 0   2   7   |   |   P1_n    |   |   8 * P(n-1) + Pn         |
+                //
+                QVector<qreal> vector;
+                vector.resize(n);
+                vector[0] = points[0].x() + 2 * points[1].x();
+                for (int i = 1; i < n - 1; ++i)
+                    vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
+                vector[n - 1] = (8 * points[n - 1].x() + points[n].x()) / 2.0;
+                QVector<qreal> xControl = firstControlPoints(vector);
+                vector[0] = points[0].y() + 2 * points[1].y();
+                for (int i = 1; i < n - 1; ++i)
+                    vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
+                vector[n - 1] = (8 * points[n - 1].y() + points[n].y()) / 2.0;
+                QVector<qreal> yControl = firstControlPoints(vector);
+                for (int i = 0, j = 0; i < n; ++i, ++j) {
+                    controlPoints[j].setX(xControl[i]);
+                    controlPoints[j].setY(yControl[i]);
+                    j++;
+                    if (i < n - 1) {
+                        controlPoints[j].setX(2 * points[i + 1].x() - xControl[i + 1]);
+                        controlPoints[j].setY(2 * points[i + 1].y() - yControl[i + 1]);
+                    } else {
+                        controlPoints[j].setX((points[n].x() + xControl[n - 1]) / 2);
+                        controlPoints[j].setY((points[n].y() + yControl[n - 1]) / 2);
+                    }
+                }
+                return controlPoints;
+            }
+            QVector<qreal> SplineChartItem::firstControlPoints(const QVector<qreal>& vector)
+            {
+                QVector<qreal> result;
+                int count = vector.count();
+                result.resize(count);
+                result[0] = vector[0] / 2.0;
+                QVector<qreal> temp;
+                temp.resize(count);
+                temp[0] = 0;
+                qreal b = 2.0;
+                for (int i = 1; i < count; i++) {
+                    temp[i] = 1 / b;
+                    b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
+                    result[i] = (vector[i] - result[i - 1]) / b;
+                }
+                for (int i = 1; i < count; i++)
+                    result[count - i - 1] -= temp[count - i] * result[count - i];
+                return result;
+            }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
                 painter->setPen(m_linePen);
                 //    painter->setBrush(m_linePen.color());
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(domain()->calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
             void SplineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), true);
                 QGraphicsItem::hoverEnterEvent(event);
             }
             void SplineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit XYChart::hovered(domain()->calculateDomainPoint(event->pos()), false);
                 QGraphicsItem::hoverLeaveEvent(event);
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h +2 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "qsplineseries.h"
             #include "xychart_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class SplineAnimation;
             class SplineChartItem : public XYChart
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
                 SplineChartItem(QSplineSeries *series, QGraphicsItem* item = 0);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 void setControlGeometryPoints(QVector<QPointF>& points);
                 QVector<QPointF> controlGeometryPoints() const;
                 void setAnimation(SplineAnimation *animation);
                 ChartAnimation *animation() const;
             public Q_SLOTS:
                 void handleUpdated();
             protected:
                 void updateGeometry();
+                QVector<QPointF> calculateControlPoints(const QVector<QPointF> &points);
+                QVector<qreal> firstControlPoints(const QVector<qreal>& vector);
                 void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             private:
-                QPointF calculateGeometryControlPoint(int index) const;
-            private:
                 QSplineSeries *m_series;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
                 QVector<QPointF> m_controlPoints;
                 SplineAnimation *m_animation;
                 friend class SplineAnimation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages