HG_REPOSITORIES/LPP/users/hugo/ColorMapChart Commit - r3:ab1c9ba54a31

improvements in execution time, colorbar ok, more work to do on axes,

winter -

r3:ab1c9ba54a31 default

parent child

Context file:

r3:ab1c9ba54a31

Collapse all files

examples/charts/colormap/main.cpp +5 -3

             /****************************************************************************
             **
             ** Copyright (C) 2016 The Qt Company Ltd.
             ** Contact: https://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module of the Qt Toolkit.
             **
             ** $QT_BEGIN_LICENSE:GPL$
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see https://www.qt.io/terms-conditions. For further
             ** information use the contact form at https://www.qt.io/contact-us.
             **
             ** GNU General Public License Usage
             ** Alternatively, this file may be used under the terms of the GNU
             ** General Public License version 3 or (at your option) any later version
             ** approved by the KDE Free Qt Foundation. The licenses are as published by
             ** the Free Software Foundation and appearing in the file LICENSE.GPL3
             ** included in the packaging of this file. Please review the following
             ** information to ensure the GNU General Public License requirements will
             ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
             **
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtWidgets/QApplication>
             #include <QtWidgets/QMainWindow>
             #include <QtCharts/QChartView>
             #include <QtCharts/QColorMapSeries>
             #include <QtCharts/colormapdatapart.h>
             QT_CHARTS_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QVector<double> *xSeries = new QVector<double>();
+                xSeries->reserve(1028);
                 for(int  i=0;i<1028;i++)
                 {
-                    xSeries->append(i*5.0);
+                    xSeries->append(i);
                 }
                 QVector<double> *ySeries = new QVector<double>();
+                ySeries->reserve(768);
                 for(int  i=0;i<768;i++)
                 {
-                    ySeries->append(i*10.0);
+                    ySeries->append(i);
                 }
                 QVector<double> *zSeries = new QVector<double>();
+                zSeries->reserve(1028*768);
                 for(int  i=0;i<1028*768;i++)
                 {
             //                if(i%2 != 1)
             //                    zSeries->append(0);
             //                else
             //                    zSeries->append(1);
                     zSeries->append(i);
                 }
                 ColorMapDataPart * data = new ColorMapDataPart(xSeries,ySeries,zSeries);
                 QColorMapSeries *series = new QColorMapSeries();
                 series->append(data);
                 QChart *chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple colormap example");
                 chart->createDefaultAxes();
                 chart->axisX()->setGridLineVisible(false);
                 chart->axisY()->setGridLineVisible(false);
                 QChartView *chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(100-77, 100-53);
                 window.show();
                 return a.exec();
             }

src/charts/axis/colorbaraxis/chartcolorbaraxisy.cpp +14 -10

             #include "chartcolorbaraxisy_p.h"
             #include <QtCharts/QAbstractAxis>
             #include <private/chartpresenter_p.h>
             //#include <QtCharts/QColorBarAxis>
             #include "colorbaraxis/qcolorbaraxis.h"
             #include <private/abstractchartlayout_p.h>
             #include <QtWidgets/QGraphicsLayout>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
-            ChartColorBarAxisY::ChartColorBarAxisY(QColorBarAxis *axis, QLinearGradient gradient, QGraphicsItem *item)
+            ChartColorBarAxisY::ChartColorBarAxisY(QColorBarAxis *axis, QPoint pos, qreal height, QLinearGradient gradient, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis),
-                  m_gradient(gradient)
+                  m_gradient(gradient),
+                  m_position(pos),
+                  m_height(height)
             {
                 QObject::connect(m_axis, SIGNAL(tickCountChanged(int)), this, SLOT(handleTickCountChanged(int)));
                 QObject::connect(m_axis, SIGNAL(minorTickCountChanged(int)),
                                  this, SLOT(handleMinorTickCountChanged(int)));
                 QObject::connect(m_axis, SIGNAL(labelFormatChanged(QString)), this, SLOT(handleLabelFormatChanged(QString)));
                 createColorBar();
             }
             ChartColorBarAxisY::~ChartColorBarAxisY()
             {
             }
             QVector<qreal> ChartColorBarAxisY::calculateLayout() const
             {
                 int tickCount = m_axis->tickCount();
                 Q_ASSERT(tickCount >= 2);
                 QVector<qreal> points;
                 points.resize(tickCount);
                 const QRectF &gridRect = gridGeometry();
                 const qreal deltaY = gridRect.height() / (qreal(tickCount) - 1.0);
                 for (int i = 0; i < tickCount; ++i)
                     points[i] = qreal(i) * -deltaY + gridRect.bottom();
                 return points;
             }
             void ChartColorBarAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 setLabels(createValueLabels(min(),max(),layout.size(),m_axis->labelFormat()));
                 VerticalAxis::updateGeometry();
             }
             void ChartColorBarAxisY::handleTickCountChanged(int tick)
             {
                 Q_UNUSED(tick);
                 QGraphicsLayoutItem::updateGeometry();
                 if (presenter()) presenter()->layout()->invalidate();
             }
             void ChartColorBarAxisY::handleMinorTickCountChanged(int tick)
             {
                 Q_UNUSED(tick);
                 QGraphicsLayoutItem::updateGeometry();
                 if (presenter())
                     presenter()->layout()->invalidate();
             }
             void ChartColorBarAxisY::handleLabelFormatChanged(const QString &format)
             {
                 Q_UNUSED(format);
                 QGraphicsLayoutItem::updateGeometry();
                 if(presenter()) presenter()->layout()->invalidate();
             }
             QSizeF ChartColorBarAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 QSizeF base = VerticalAxis::sizeHint(which, constraint);
                 QStringList ticksList = createValueLabels(min(),max(),m_axis->tickCount(),m_axis->labelFormat());
                 qreal width = 0;
                 // Height of vertical axis sizeHint indicates the maximum distance labels can extend past
                 // first and last ticks. Base height is irrelevant.
                 qreal height = 0;
                 switch (which)
                 {
                 case Qt::MinimumSize: {
                     QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                            QStringLiteral("..."),
                                                                            axis()->labelsAngle());
-                    width = boundingRect.width() + labelPadding() + base.width() + 1.0;
+                    width = boundingRect.width() + labelPadding() + base.width() + 61.0; //TODO : hint changed 1.0 to 61.0
                     height = boundingRect.height() / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 case Qt::PreferredSize: {
                     qreal labelWidth = 0.0;
                     qreal firstHeight = -1.0;
                     foreach (const QString& s, ticksList) {
                         QRectF rect = ChartPresenter::textBoundingRect(axis()->labelsFont(), s, axis()->labelsAngle());
                         labelWidth = qMax(rect.width(), labelWidth);
                         height = rect.height();
                         if (firstHeight < 0.0)
                             firstHeight = height;
                     }
-                    width = labelWidth + labelPadding() + base.width() + 2.0; //two pixels of tolerance
+                    width = labelWidth + labelPadding() + base.width() + 62.0; //two pixels of tolerance //TODO : hint changed 2.0 to 62.0
                     height = qMax(height, firstHeight) / 2.0;
                     sh = QSizeF(width, height);
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             void ChartColorBarAxisY::createColorBar()
             {
-                QGradientStops stops = m_gradient.stops();
+                //m_position.setX(80+m_position.x());// TODO : remove this when you know how to move labels
-                QLinearGradient gradient(0,0,1,250);
+                //gradient
+                QGradientStops stops = m_gradient.stops();
+                QLinearGradient gradient(0,0,1,m_height);
                 foreach(QGradientStop stop, stops)
                 {
                     gradient.setColorAt(1-stop.first,stop.second);
                 }
-                QPixmap image = QPixmap(50,250);
+                //colorbar
-                QPainter painter(&image);
+                QRectF rect(m_position.x(),m_position.y(),m_height/20,m_height);
-                QRectF rect(0,0,50,250);
-                painter.fillRect(rect,gradient);
                 QGraphicsRectItem *colorbar = new QGraphicsRectItem(rect, this);
+                colorbar->setZValue(ChartPresenter::AxisZValue);
+                colorbar->setBrush(gradient);
                 setGraphicsItem(colorbar);
             }
             #include "moc_chartcolorbaraxisy_p.cpp"
                 QT_CHARTS_END_NAMESPACE

src/charts/axis/colorbaraxis/chartcolorbaraxisy_p.h +3 -1

             #ifndef CHARTCOLORBARAXISY_H
             #define CHARTCOLORBARAXISY_H
             #include <private/verticalaxis_p.h>
             #include <QtGui>
             QT_CHARTS_BEGIN_NAMESPACE
             class QColorBarAxis;
             class ChartColorBarAxisY : public VerticalAxis
             {
                 Q_OBJECT
             public:
-                ChartColorBarAxisY(QColorBarAxis *axis, QLinearGradient gradient, QGraphicsItem *item = 0);
+                ChartColorBarAxisY(QColorBarAxis *axis, QPoint pos, qreal height, QLinearGradient gradient, QGraphicsItem *item = 0);
                 ~ChartColorBarAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
             private Q_SLOTS:
                 void handleTickCountChanged(int tick);
                 void handleMinorTickCountChanged(int tick);
                 void handleLabelFormatChanged(const QString &format);
                 void createColorBar();
             private:
                 QColorBarAxis *m_axis;
                 QLinearGradient m_gradient;
+                QPoint m_position;
+                qreal m_height;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // CHARTCOLORBARAXISY_H

src/charts/axis/colorbaraxis/qcolorbaraxis.cpp +13 -5

             //#include <QtCharts/QColorBarAxis> // TODO : fix this
             #include "colorbaraxis/qcolorbaraxis.h"
             //#include <private/qcolorbaraxis_p.h>
             #include "colorbaraxis/qcolorbaraxis_p.h"
             #include <private/abstractdomain_p.h>
             #include <private/chartdataset_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/charttheme_p.h>
             //#include <private/chartcolorbaraxisy_p.h>
             #include <chartcolorbaraxisy_p.h>
             #include <QtGui>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
-            QColorBarAxis::QColorBarAxis(QLinearGradient gradient, qreal min, qreal max,QObject *parent) :
+            QColorBarAxis::QColorBarAxis(QRectF plotArea, QLinearGradient gradient, qreal min, qreal max, QObject *parent) :
-                QAbstractAxis(*new QColorBarAxisPrivate(gradient, min, max, this), parent)
+                QAbstractAxis(*new QColorBarAxisPrivate(plotArea, gradient, min, max, this), parent)
             {
+            setGridLineVisible(false);
             }
             /*!
                 \internal
             */
             QColorBarAxis::QColorBarAxis(QColorBarAxisPrivate &d, QObject *parent)
                 : QAbstractAxis(d, parent)
             {
             }
             /*!
                 Destroys the object
             */
             QColorBarAxis::~QColorBarAxis()
             {
                 Q_D(QColorBarAxis);
                 if (d->m_chart)
                     d->m_chart->removeAxis(this);
             }
             void QColorBarAxis::setMin(qreal min)
             {
                 Q_D(QColorBarAxis);
                 setRange(min, qMax(d->m_max, min));
             }
             qreal QColorBarAxis::min() const
             {
                 Q_D(const QColorBarAxis);
                 return d->m_min;
             }
             void QColorBarAxis::setMax(qreal max)
             {
                 Q_D(QColorBarAxis);
                 setRange(qMin(d->m_min, max), max);
             }
             qreal QColorBarAxis::max() const
             {
                 Q_D(const QColorBarAxis);
                 return d->m_max;
             }
             void QColorBarAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QColorBarAxis);
                 d->setRange(min,max);
             }
             void QColorBarAxis::setTickCount(int count)
             {
                 Q_D(QColorBarAxis);
                 if (d->m_tickCount != count && count >= 2) {
                     d->m_tickCount = count;
                     emit tickCountChanged(count);
                 }
             }
             int QColorBarAxis::tickCount() const
             {
                 Q_D(const QColorBarAxis);
                 return d->m_tickCount;
             }
             void QColorBarAxis::setMinorTickCount(int count)
             {
                 Q_D(QColorBarAxis);
                 if (d->m_minorTickCount != count && count >= 0) {
                     d->m_minorTickCount = count;
                     emit minorTickCountChanged(count);
                 }
             }
             int QColorBarAxis::minorTickCount() const
             {
                 Q_D(const QColorBarAxis);
                 return d->m_minorTickCount;
             }
             void QColorBarAxis::setLabelFormat(const QString &format)
             {
                 Q_D(QColorBarAxis);
                 d->m_format = format;
                 emit labelFormatChanged(format);
             }
             QString QColorBarAxis::labelFormat() const
             {
                 Q_D(const QColorBarAxis);
                 return d->m_format;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QColorBarAxis::type() const
             {
                 return AxisTypeValue;
                 //TODO : AxisTypeColorBar
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QColorBarAxisPrivate::QColorBarAxisPrivate(QLinearGradient gradient, qreal min, qreal max, QColorBarAxis *q)
+            QColorBarAxisPrivate::QColorBarAxisPrivate(QRectF plotArea, QLinearGradient gradient, qreal min, qreal max, QColorBarAxis *q)
                 : QAbstractAxisPrivate(q),
+                  m_plotArea(plotArea),
                   m_min(min),
                   m_max(max),
                   m_tickCount(5),
                   m_minorTickCount(0),
                   m_format(QString::null),
                   //      m_applying(false)
                   m_gradient(gradient)
             {
             }
             QColorBarAxisPrivate::~QColorBarAxisPrivate()
             {
             }
             void QColorBarAxisPrivate::initializeGraphics(QGraphicsItem *parent)
             {
                 Q_Q(QColorBarAxis);
                 ChartAxisElement *axis(0);
                 setAlignment(Qt::AlignRight); //also set orientation (Vertical in this case)
-                axis = new ChartColorBarAxisY(q, m_gradient, parent);
+                //TODO : change this position
+                qreal x1;
+                qreal y1;
+                qreal x2;
+                qreal y2;
+                m_plotArea.getCoords(&x1,&y1,&x2,&y2);
+                QPoint pos(x2+5,y1);
+                axis = new ChartColorBarAxisY(q, pos, m_plotArea.height(),m_gradient, parent);
                 m_item.reset(axis);
                 QAbstractAxisPrivate::initializeGraphics(parent);
             }
             void QColorBarAxisPrivate::initializeDomain(AbstractDomain *domain)
             {
                 //domain is not supposed to have a rangeZ
                 //        if (orientation() == Qt::Vertical) {
                 //            if (!qFuzzyIsNull(m_max - m_min))
                 //                domain->setRangeY(m_min, m_max);
                 //            else
                 //                setRange(domain->minY(), domain->maxY());
                 //        }
             }
             void QColorBarAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QColorBarAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if (ok)
                     q->setMin(value);
             }
             void QColorBarAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QColorBarAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if (ok)
                     q->setMax(value);
             }
             void QColorBarAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QColorBarAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if (ok1 && ok2)
                     q->setRange(value1, value2);
             }
             void QColorBarAxisPrivate::setRange(qreal min,qreal max)
             {
                 Q_Q(QColorBarAxis);
                 bool changed = false;
                 if (min > max)
                     return;
                 bool changeMin = false;
                 if (m_min == 0 || min == 0)
                     changeMin = !qFuzzyCompare(1 + m_min, 1 + min);
                 else
                     changeMin = !qFuzzyCompare(m_min, min);
                 bool changeMax = false;
                 if (m_max == 0 || max == 0)
                     changeMax = !qFuzzyCompare(1 + m_max, 1 + max);
                 else
                     changeMax = !qFuzzyCompare(m_max, max);
                 if (changeMin) {
                     m_min = min;
                     changed = true;
                     emit q->minChanged(min);
                 }
                 if (changeMax) {
                     m_max = max;
                     changed = true;
                     emit q->maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(min,max);
                     emit q->rangeChanged(min, max);
                 }
             }
             #include "moc_qcolorbaraxis.cpp"
             #include "moc_qcolorbaraxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/colorbaraxis/qcolorbaraxis.h +1 -1

             #ifndef QCOLORBARAXIS_H
             #define QCOLORBARAXIS_H
             #include <QtCharts/QAbstractAxis>
             QT_CHARTS_BEGIN_NAMESPACE
             class QColorBarAxisPrivate;
             class QT_CHARTS_EXPORT QColorBarAxis : public QAbstractAxis
             {
                 Q_OBJECT
             public:
-                explicit QColorBarAxis(QLinearGradient gradient, qreal min, qreal max,QObject *parent = 0);
+                explicit QColorBarAxis(QRectF plotArea,QLinearGradient gradient, qreal min, qreal max,QObject *parent = 0);
                 ~QColorBarAxis();
             protected:
                 QColorBarAxis(QColorBarAxisPrivate &d, QObject *parent = 0);
             public:
                 AxisType type() const;
                 //range handling
                 void setMin(qreal min);
                 qreal min() const;
                 void setMax(qreal max);
                 qreal max() const;
                  void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTickCount(int count);
                 int tickCount() const;
                 void setMinorTickCount(int count);
                 int minorTickCount() const;
                 void setLabelFormat(const QString &format);
                 QString labelFormat() const;
             Q_SIGNALS:
                 void minChanged(qreal min);
                 void maxChanged(qreal max);
                 void rangeChanged(qreal min, qreal max);
                 void tickCountChanged(int tickCount);
                 void minorTickCountChanged(int tickCount);
                 void labelFormatChanged(const QString &format);
             private:
                 Q_DECLARE_PRIVATE(QColorBarAxis)
                 Q_DISABLE_COPY(QColorBarAxis)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCOLORBARAXIS_H

src/charts/axis/colorbaraxis/qcolorbaraxis_p.h +2 -1

             #ifndef QCOLORBARAXIS_P_H
             #define QCOLORBARAXIS_P_H
             //#include <QtCharts/QColorBarAxis> //TODO : fix this
             #include "colorbaraxis/qcolorbaraxis.h"
             #include <private/qabstractaxis_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             class QColorBarAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
-                QColorBarAxisPrivate(QLinearGradient gradient, qreal min, qreal max,QColorBarAxis *q);
+                QColorBarAxisPrivate(QRectF plotArea, QLinearGradient gradient, qreal min, qreal max,QColorBarAxis *q);
                 ~QColorBarAxisPrivate();
             public:
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeDomain(AbstractDomain *domain);
                 qreal min() { return m_min; }
                 qreal max() { return m_max; }
                 void setRange(qreal min,qreal max);
             protected:
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             private:
                 qreal m_min;
                 qreal m_max;
                 int m_tickCount;
                 int m_minorTickCount;
                 QString m_format;
                // bool m_applying;
                 QLinearGradient m_gradient;
+                QRectF m_plotArea;
                 Q_DECLARE_PUBLIC(QColorBarAxis)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCOLORBARAXIS_P_H

src/charts/colormapchart/colormapchart.cpp +32 -14

             #include <private/colormapchart_p.h>
             #include <QtCharts/QColorMapSeries>
             #include <private/qcolormapseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/chartdataset_p.h>
             #include <private/qabstractaxis_p.h>
             #include <QtGui/QPainter>
-            //#include <QtCharts/QColorBarAxis> TODO : fix this
-            #include "qcolorbaraxis.h"
             #include <QRgb>
             #define nbOfColors 65000
             QT_CHARTS_BEGIN_NAMESPACE
             ColorMapChart::ColorMapChart(QColorMapSeries *series, QGraphicsItem *item)
                 : ChartItem(series->d_func(), item),
                   m_series(series),
                   m_dirty(true),
                   m_gradientType(Rainbow),
                   m_colorbar(false)
             {
                 //    QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
                 //    QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 //    QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 //    QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 //    QObject::connect(series, SIGNAL(pointsRemoved(int, int)), this, SLOT(handlePointsRemoved(int, int)));
                 //    QObject::connect(this, SIGNAL(clicked(Point3D)), series, SIGNAL(clicked(Point3D)));
                 //    QObject::connect(this, SIGNAL(hovered(Point3D,bool)), series, SIGNAL(hovered(Point3D,bool)));
                 //    QObject::connect(this, SIGNAL(pressed(Point3D)), series, SIGNAL(pressed(Point3D)));
                 //    QObject::connect(this, SIGNAL(released(Point3D)), series, SIGNAL(released(Point3D)));
                 //    QObject::connect(this, SIGNAL(doubleClicked(Point3D)), series, SIGNAL(doubleClicked(Point3D)));
                 connect(this,SIGNAL(gradientTypeChanged()), this, SLOT(populateColorTable()));
                 m_colorTable = new QVector<QRgb>();
                 m_colorTable->reserve(nbOfColors);
                 populateColorTable();
             }
             void ColorMapChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             QRectF ColorMapChart::boundingRect() const
             {
                 return m_rect;
             }
             void ColorMapChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
+                m_series->setUseOpenGL();
+                painter->save();
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->setClipRect(clipRect);
                 QRectF plotAreaRect = m_series->chart()->plotArea();
                 QImage colorMapImage(plotAreaRect.width(),plotAreaRect.height(),QImage::Format_RGB32);
                 //http://doc.qt.io/qt-4.8/qimage.html#details :Warning: This will create a QImage with uninitialized data. Call fill() to fill the image with an appropriate pixel value before drawing onto it with QPainter.
                 colorMapImage.fill(QColor(Qt::white).rgb());
-                ColorMapDataPart * grid = m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),QColorMapSeries::LastPixel);
+                QElapsedTimer timer;
+                timer.start();
+                QVector<double> * grid = m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),QColorMapSeries::LastPixel);
+                int msec = timer.elapsed();
+                int msec2 = 0+msec;
                 double maxZ = m_series->maxZ();
                 double minZ = m_series->minZ();
                 double rangeZ = maxZ - minZ;
-                for(int i=0;i<colorMapImage.width();i++)
+                int imageWidth = colorMapImage.width();
+                int imageHeight = colorMapImage.height();
+                for(int i=0;i<imageWidth;i++)
                 {
-                    for(int j=0;j<colorMapImage.height();j++)
+                    for(int j=0;j<imageHeight;j++)
                     {
-                        double value = grid->dataSeries().at(i+j*(colorMapImage.width()));
+                        double value = grid->at(i+j*(imageWidth));
                         double pix=((value-minZ)/rangeZ);
                         int indexInColorTable = pix*(nbOfColors-1);
                         colorMapImage.setPixel(i,j,m_colorTable->at(indexInColorTable));
                     }
                 }
-                if(!m_colorbar)
+                addColorBar(plotAreaRect);
-                    addColorBar();
                 painter->drawImage(clipRect,colorMapImage);
-                update();
+                update();//Qt docs: Warning: If you call repaint() in a function which may itself be called from paintEvent(), you may get infinite recursion. The update() function never causes recursion
+                painter->restore();
             }
-            void ColorMapChart::addColorBar()
+            void ColorMapChart::addColorBar(QRectF plotAreaRect)
             {
                 double maxZ = m_series->maxZ();
                 double minZ = m_series->minZ();
-                QColorBarAxis *colorbar = new QColorBarAxis(createColorMapGradient(m_gradientType),minZ, maxZ,this);
-                m_series->chart()->addAxis(colorbar, Qt::AlignRight);
+                if(m_isColorBarDrawn)
-                m_colorbar = true;
+                    m_series->chart()->removeAxis(m_colorbar);
+                m_colorbar = new QColorBarAxis(plotAreaRect,createColorMapGradient(m_gradientType),minZ, maxZ,this);
+                m_series->chart()->addAxis(m_colorbar, Qt::AlignRight);
+                m_isColorBarDrawn = true;
             }
             /*!
                 Returns the predefined QLinearGradient corresponding to the \a gradientType passed as argument.
             */
             QLinearGradient ColorMapChart::createColorMapGradient(GradientType gradientType)
             {
                 QLinearGradient gradient(0,0,1,100);
                 switch(gradientType)
                 {
                 case Rainbow :
                     gradient.setColorAt(1.0,Qt::darkRed);
                     gradient.setColorAt(0.8,Qt::red);
                     gradient.setColorAt(0.6,Qt::yellow);
                     gradient.setColorAt(0.4,Qt::green);
                     gradient.setColorAt(0.2,Qt::cyan);
                     gradient.setColorAt(0.0,Qt::blue);
                     break;
                 case CyclingRainbow :
                     gradient.setColorAt(1.0,Qt::red);
                     gradient.setColorAt(0.8,Qt::yellow);
                     gradient.setColorAt(0.6,Qt::green);
                     gradient.setColorAt(0.4,Qt::cyan);
                     gradient.setColorAt(0.2,Qt::blue);
                     gradient.setColorAt(0.0,Qt::magenta);
                     break;
                 case BlackAndWhite :
                     gradient.setColorAt(1.0, Qt::black);
                     gradient.setColorAt(0.0, Qt::white);
                     break;
                 case ReverseBlackAndWhite :
                     gradient.setColorAt(1.0, Qt::white);
                     gradient.setColorAt(0.0, Qt::black);
                     break;
                 default:
                     break;
                 }
                 return gradient;
             }
             /*!
                 Changes the type of gradient used to paint the ColorMap.
             */
             void ColorMapChart::changeGradient(GradientType gradientType)
             {
                 if(m_gradientType == gradientType)
                     return;
                 else
                     m_gradientType = gradientType;
                 emit gradientTypeChanged();
             }
             /*!
                 Creates a color table corresponding to the  gradient type currently selected.
             */
             void ColorMapChart::populateColorTable()
             {
                 QLinearGradient gradient = createColorMapGradient(m_gradientType);
                 QGradientStops colorStops = gradient.stops();
                 for(int i=0;i<nbOfColors;i++)
                 {
                     double colorIndex = (double)i/nbOfColors;
                     for(int k =0;k<colorStops.size()-1;k++)
                     {
                         QGradientStop lowerBound = colorStops.at(k);
                         QGradientStop upperBound = colorStops.at(k+1);
                         if(colorIndex >= lowerBound.first && colorIndex < upperBound.first)
                         {
                             double ratio = (colorIndex-lowerBound.first)/(upperBound.first - lowerBound.first);
                             int red      = (int)((1-ratio)*lowerBound.second.red() + ratio*upperBound.second.red());
                             int green = (int)((1-ratio)*lowerBound.second.green() + ratio*upperBound.second.green());
                             int blue   = (int)((1-ratio)*lowerBound.second.blue() + ratio*upperBound.second.blue());
                             m_colorTable->append(qRgb(red, green, blue));
                             break;
                         }
                         else
                         {
                             if(k==colorStops.size()-2)
                             {
                                 m_colorTable->append(qRgb(colorStops.at(colorStops.size()-1).second.red(), colorStops.at(colorStops.size()-1).second.green(), colorStops.at(colorStops.size()-1).second.blue()));
                             }
                         }
                     }
                 }
             }
             //handlers
             void ColorMapChart::handlePointAdded(int index)
             {
             }
             void ColorMapChart::handlePointRemoved(int index)
             {
             }
             void ColorMapChart::handlePointsRemoved(int index, int count)
             {
             }
             void ColorMapChart::handlePointReplaced(int index)
             {
             }
             void ColorMapChart::handlePointsReplaced()
             {
             }
             void ColorMapChart::handleDomainUpdated()
             {
             }
             bool ColorMapChart::isEmpty()
             {
             }
             #include "moc_colormapchart_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/colormapchart/colormapchart_p.h +6 -2

             #ifndef COLORMAPCHART_H
             #define COLORMAPCHART_H
             #include "point3d.h"
             #include <QtCharts/QChartGlobal>
             #include <private/chartitem_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtGui/QPen>
+            //#include <QtCharts/QColorBarAxis> TODO : fix this
+            #include "qcolorbaraxis.h"
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class QColorMapSeries;
             class ColorMapChart :  public ChartItem
             {
                 Q_OBJECT
             public:
                 enum GradientType
                 {
                     Rainbow,
                     CyclingRainbow,
                     BlackAndWhite,
                     ReverseBlackAndWhite
                 };
                 explicit ColorMapChart(QColorMapSeries *series,QGraphicsItem *item = 0);
                 ~ColorMapChart() {}
                 bool isDirty() const { return m_dirty; }
                 void setDirty(bool dirty);
                 // from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointsRemoved(int index, int count);
                 void handlePointReplaced(int index);
                 void handlePointsReplaced();
                 void handleDomainUpdated();
             private slots :
                 void populateColorTable();
             Q_SIGNALS:
                 void clicked(const Point3D &point);
                 void hovered(const Point3D &point, bool state);
                 void pressed(const Point3D &point);
                 void released(const Point3D &point);
                 void doubleClicked(const Point3D &point);
                 void gradientTypeChanged();
             private:
                 inline bool isEmpty();
-                void addColorBar();
+                void addColorBar(QRectF plotAreaRect);
                 QLinearGradient createColorMapGradient(GradientType gradientType);
                 void changeGradient(GradientType gradientType);
             protected:
                 QColorMapSeries *m_series;
                 QVector<Point3D> m_points;
                 QRectF m_rect;
                 bool m_dirty;
                 QVector<QRgb> *m_colorTable;
                 GradientType m_gradientType;
-                bool m_colorbar;
+                bool m_isColorBarDrawn;
+                QColorBarAxis *m_colorbar;
             };
             //class PixmapMarker: public QGraphicsRectItem
             //{
             //public:
             //    PixmapMarker(qreal x, qreal y, qreal w, qreal h, ColorMapChart *parent)
             //        : QGraphicsRectItem(x, y, w, h, parent),
             //          m_parent(parent)
             //    {
             //        setAcceptHoverEvents(true);
             //        setFlag(QGraphicsItem::ItemIsSelectable);
             //    }
             //protected:
             //    void mousePressEvent(QGraphicsSceneMouseEvent *event)
             //    {
             //        QGraphicsRectItem::mousePressEvent(event);
             //        m_parent->markerPressed(this);
             //        m_parent->setMousePressed();
             //    }
             //    void hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             //    {
             //        QGraphicsRectItem::hoverEnterEvent(event);
             //        m_parent->markerHovered(this, true);
             //    }
             //    void hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             //    {
             //        QGraphicsRectItem::hoverLeaveEvent(event);
             //        m_parent->markerHovered(this, false);
             //    }
             //    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             //    {
             //        QGraphicsRectItem::mouseReleaseEvent(event);
             //        m_parent->markerReleased(this);
             //        if (m_parent->mousePressed())
             //            m_parent->markerSelected(this);
             //        m_parent->setMousePressed(false);
             //    }
             //    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
             //    {
             //        QGraphicsRectItem::mouseDoubleClickEvent(event);
             //        m_parent->markerDoubleClicked(this);
             //    }
             //private:
             //    ColorMapChart *m_parent;
             //};
             QT_CHARTS_END_NAMESPACE
             #endif // COLORMAPCHART_H

src/charts/colormapchart/qcolormapseries.cpp +11 -18

             #include "qcolormapseries.h"
             #include <private/qcolormapseries_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QValueAxis>
             #include <private/colormapchart_p.h>
             #include <QtCharts/QColorMapLegendMarker>
             #include <private/charthelpers_p.h>
             #include <private/qchart_p.h>
             #include <QtGui/QPainter>
             //#include <algorithm>
             #include <cmath>
             #include "qcolorbaraxis.h"
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QColorMapSeries::QColorMapSeries(QObject *parent)
                 : QAbstractSeries(*new QColorMapSeriesPrivate(this), parent)
             {
             }
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QColorMapSeries::QColorMapSeries(QColorMapSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QColorMapSeries::~QColorMapSeries()
             {
             }
             /*!
                 \fn virtual SeriesType QBoxPlotSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             QAbstractSeries::SeriesType QColorMapSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeColorMap;
             }
             /*!
                 Adds data part \a dataPart to the series.\n
                 If \a copy is true, adds a copy of the data part instead.
              */
             void QColorMapSeries::append(ColorMapDataPart* dataPart, bool copy)
             {
                 Q_D(QColorMapSeries);
                 if(copy)
                     d->m_dataParts << new ColorMapDataPart(dataPart);
                 else
                     d->m_dataParts  << dataPart;
                 d->recomputeDataRange();
                 emit dataPartAdded(d->m_dataParts.count() - 1);
             }
             /*!
                This is an overloaded function.\n
                Adds data parts \a dataParts to the series.\n
                 If \a copy is true, adds a copy of the data part instead.
              */
             void QColorMapSeries::append(const QList<ColorMapDataPart*> &dataParts, bool copy)
             {
                 foreach (ColorMapDataPart* dataPart , dataParts)
                     append(dataPart,copy);
             }
             /*!
                 Returns number of data parts within series.
             */
             int QColorMapSeries::count() const
             {
                 Q_D(const QColorMapSeries);
                 return d->m_dataParts.count();
             }
             /*!
                 Stream operator for adding a data part \a point to the series.
                 \sa append()
             */
             QColorMapSeries &QColorMapSeries::operator <<(const ColorMapDataPart &dataPart)
             {
                 append(new ColorMapDataPart(dataPart));
                 return *this;
             }
             /*!
                 Stream operator for adding a vector of data parts \a dataParts to the series.
                 \sa append()
             */
             QColorMapSeries &QColorMapSeries::operator <<(const QList<ColorMapDataPart*> &dataParts)
             {
                 append(dataParts);
                 return *this;
             }
             /*!
                 Returns a ColorMapData part containing a uniform grid of data points to be mapped in a ColorMapChart.\n
                 The rectangle of data returned is determined by \a width and \height,\n
                 from the position \a xpos , \a ypos (starting at the top left corner of the plot area).\n
                 When there are more points than pixels, \a strategy is applied to determine which to choose.
             */
-            ColorMapDataPart *QColorMapSeries::getUniformGrid(int xpos, int ypos,int width, int height, QColorMapSeries::Strategy strategy)
+            QVector<double> *QColorMapSeries::getUniformGrid(int xpos, int ypos,int width, int height, QColorMapSeries::Strategy strategy)
             {
                 Q_D(QColorMapSeries);
                 return d->getUniformGrid(xpos, ypos,width,height, strategy);
             }
             //void QColorMapSeries::attachAxis(QAbstractAxis *axis)
             //{
             //    axis = static_cast<QColorBarAxis*>();
             //    if(axis)
             //    {
             //    }
             //    else
             //    {
             //        QAbstractSeries::attachAxis(axis);
             //    }
             //}
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setTheme()
             */
             void QColorMapSeries::setPen(const QPen &pen)
             {
                 Q_D(QColorMapSeries);
                 if (d->m_pen != pen)
                 {
                     //bool emitColorChanged = d->m_pen.color() != pen.color();
                     d->m_pen = pen;
                     emit d->updated();
             //                if (emitColorChanged)
             //                    emit colorChanged(pen.color());
                     emit penChanged(pen);
                 }
             }
             QPen QColorMapSeries::pen() const
             {
                 Q_D(const QColorMapSeries);
                 if (d->m_pen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d->m_pen;
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setTheme()
             */
             void QColorMapSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QColorMapSeries);
                 if (d->m_brush != brush)
                 {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QColorMapSeries::brush() const
             {
                 Q_D(const QColorMapSeries);
                 if (d->m_brush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     return d->m_brush;
             }
             //void QColorMapSeries::setColor(const QColor &color)
             //{
             //    QPen p = pen();
             //    if (p.color() != color)
             //    {
             //        p.setColor(color);
             //        setPen(p);
             //    }
             //}
             //QColor QColorMapSeries::color() const
             //{
             //    return pen().color();
             //}
             //void QColorMapSeries::setPointsVisible(bool visible)
             //{
             //    Q_D(QColorMapSeries);
             //    if (d->m_pointsVisible != visible)
             //    {
             //        d->m_pointsVisible = visible;
             //        emit d->updated();
             //    }
             //}
             //bool QColorMapSeries::pointsVisible() const
             //{
             //    Q_D(const QColorMapSeries);
             //    return d->m_pointsVisible;
             //}
             //void QColorMapSeries::setPointLabelsFormat(const QString &format)
             //{
             //    Q_D(QColorMapSeries);
             //    if (d->m_pointLabelsFormat != format)
             //    {
             //        d->m_pointLabelsFormat = format;
             //        emit pointLabelsFormatChanged(format);
             //    }
             //}
             //QString QColorMapSeries::pointLabelsFormat() const
             //{
             //    Q_D(const QColorMapSeries);
             //    return d->m_pointLabelsFormat;
             //}
             //void QColorMapSeries::setPointLabelsVisible(bool visible)
             //{
             //    Q_D(QColorMapSeries);
             //    if (d->m_pointLabelsVisible != visible)
             //    {
             //        d->m_pointLabelsVisible = visible;
             //        emit pointLabelsVisibilityChanged(visible);
             //    }
             //}
             //bool QColorMapSeries::pointLabelsVisible() const
             //{
             //    Q_D(const QColorMapSeries);
             //    return d->m_pointLabelsVisible;
             //}
             //void QColorMapSeries::setPointLabelsFont(const QFont &font)
             //{
             //    Q_D(QColorMapSeries);
             //    if (d->m_pointLabelsFont != font) {
             //        d->m_pointLabelsFont = font;
             //        emit pointLabelsFontChanged(font);
             //    }
             //}
             //QFont QColorMapSeries::pointLabelsFont() const
             //{
             //    Q_D(const QColorMapSeries);
             //    return d->m_pointLabelsFont;
             //}
             //void QColorMapSeries::setPointLabelsColor(const QColor &color)
             //{
             //    Q_D(QColorMapSeries);
             //    if (d->m_pointLabelsColor != color) {
             //        d->m_pointLabelsColor = color;
             //        emit pointLabelsColorChanged(color);
             //    }
             //}
             //QColor QColorMapSeries::pointLabelsColor() const
             //{
             //    Q_D(const QColorMapSeries);
             //    if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color())
             //        return QPen().color();
             //    else
             //        return d->m_pointLabelsColor;
             //}
             //void QColorMapSeries::setPointLabelsClipping(bool enabled)
             //{
             //    Q_D(QColorMapSeries);
             //    if (d->m_pointLabelsClipping != enabled) {
             //        d->m_pointLabelsClipping = enabled;
             //        emit pointLabelsClippingChanged(enabled);
             //    }
             //}
             //bool QColorMapSeries::pointLabelsClipping() const
             //{
             //    Q_D(const QColorMapSeries);
             //    return d->m_pointLabelsClipping;
             //}
             /*!
                 Returns the minimum value of the series on the X axis.
             */
             double QColorMapSeries::minX()
             {
                 Q_D(QColorMapSeries);
                 return d->m_minX;
             }
             /*!
                 Returns the minimum value of the series on the Y axis.
             */
             double QColorMapSeries::minY()
             {
                 Q_D(QColorMapSeries);
                 return d->m_minY;
             }
             /*!
                 Returns the minimum value of the series on the Z axis.
             */
             double QColorMapSeries::minZ()
             {
                 Q_D(QColorMapSeries);
                 return d->m_minZ;
             }
             /*!
                 Returns the maximum value of the series on the X axis.
             */
             double QColorMapSeries::maxX()
             {
                 Q_D(QColorMapSeries);
                 return d->m_maxX;
             }
             /*!
                 Returns the maximum value of the series on the Y axis.
             */
             double QColorMapSeries::maxY()
             {
                 Q_D(QColorMapSeries);
                 return d->m_maxY;
             }
             /*!
                 Returns the maximum value of the series on the Z axis.
             */
             double QColorMapSeries::maxZ()
             {
                 Q_D(QColorMapSeries);
                 return d->m_maxZ;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QColorMapSeriesPrivate::QColorMapSeriesPrivate(QColorMapSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pen(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush()),
                   m_pointsVisible(false),
                   m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")), //TODO : change
                   m_pointLabelsVisible(false),
                   m_pointLabelsFont(QChartPrivate::defaultFont()),
                   m_pointLabelsColor(QChartPrivate::defaultPen().color()),
                   m_pointLabelsClipping(true)
             {
             }
             void QColorMapSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QColorMapSeries);
                 ColorMapChart *colormap = new ColorMapChart(q,parent);
                 m_item.reset(colormap);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
             }
             void QColorMapSeriesPrivate::initializeDomain()
             {
                 domain()->setRange(m_minX, m_maxX, m_minY, m_maxY);
             }
             void QColorMapSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 //    Q_Q(QColorMapSeries);
                 //    const QList<QGradient> gradients = theme->seriesGradients();
                 //    const QList<QColor> colors = theme->seriesColors();
                 //    if (forced || QChartPrivate::defaultPen() == m_pen) {
                 //        QPen pen;
                 //        pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0));
                 //        pen.setWidthF(2);
                 //        q->setPen(pen);
                 //    }
                 //    if (forced || QChartPrivate::defaultBrush() == m_brush) {
                 //        QBrush brush(colors.at(index % colors.size()));
                 //        q->setBrush(brush);
                 //    }
                 //    if (forced || QChartPrivate::defaultPen().color() == m_pointLabelsColor) {
                 //        QColor color = theme->labelBrush().color();
                 //        q->setPointLabelsColor(color);
                 //    }
             }
             QList<QLegendMarker*> QColorMapSeriesPrivate::createLegendMarkers(QLegend* legend)
             {
                 Q_Q(QColorMapSeries);
                 QList<QLegendMarker*> list;
                 return list << new QColorMapLegendMarker(q,legend);
             }
             void QColorMapSeriesPrivate::initializeAxes()
             {
             }
             QAbstractAxis::AxisType QColorMapSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QColorMapSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 return new QValueAxis;
             }
-            ColorMapDataPart *QColorMapSeriesPrivate::getUniformGrid(int xpos, int ypos,  int width, int height, QColorMapSeries::Strategy strategy)
+            QVector<double> *QColorMapSeriesPrivate::getUniformGrid(int xpos, int ypos,  int width, int height, QColorMapSeries::Strategy strategy)
             {
-                //    QVector<double> *timeSeries = new QVector<double>(width);
+                QVector<double> *grid = new QVector<double>(width*height);
-                //    QVector<double> *ySeries = new QVector<double>(height);
-                QVector<double> *dataSeries = new QVector<double>(width*height);
-                QVector<double> *timeSeries = new QVector<double>();
-                QVector<double> *ySeries = new QVector<double>();
-                ColorMapDataPart* grid = new ColorMapDataPart(timeSeries,ySeries,dataSeries);
                 double dx = (m_maxX - m_minX)/(double)width;
                 double dy = (m_maxY - m_minY)/(double)height;
                 int x=0;
                 int y=0;
-                for(int i=0;i<width;i++) //width-1?
+            QVector<Point3D> cluster;
+            cluster.reserve(height*width/1000);
-                    timeSeries->append((double)i);
+                for (auto cell= grid->begin();cell<grid->end();++cell)
-                for (auto cell= dataSeries->begin();cell<dataSeries->end();++cell)
                 {
-                    QVector<Point3D> cluster;
+                    cluster.resize(0);
                     this->buildCluster(x,y,dx,dy,cluster);
                     if(strategy == QColorMapSeries::LastPixel)
                         *cell=this->clusterStrategyLast(cluster);
                     else if(strategy == QColorMapSeries::MeanPixel)
                         *cell=this->clusterStrategyMean(cluster);
                     else if(strategy == QColorMapSeries::MedianPixel)
                         *cell=this->clusterStrategyMedian(cluster);
                     if(x<width-1)
                     {
                         x++;
                     }
                     else
                     {
                         x=0;
-                        ySeries->append((double)y);
                         y++;
                     }
                 }
                 return grid;
             }
             /*!
                 Recompute the data range on X, Y and Z axes each time a ColorMapDataPart is added to the series.\n
                 The minimum distance between 2 adjacent values on X and Y axis is added to the maximum on X and Y respectively\n
                 in order to take account of the width of the last element.
             */
             void QColorMapSeriesPrivate::recomputeDataRange()
             {
                 //TODO : if non empty
                 m_minX = m_dataParts.first()->timesSeries().first();
                 m_maxX = m_dataParts.last()->timesSeries().last();
                 m_minY = m_dataParts.last()->ySeries().last();
                 m_maxY = m_dataParts.last()->ySeries().first();
                 m_minZ = m_dataParts.first()->dataSeries().first();
                 m_maxZ = m_dataParts.last()->dataSeries().last();
                 double minDeltaX=m_maxX-m_minX;
                 double minDeltaY=m_minY-m_maxY;
                 foreach(ColorMapDataPart* datapart, m_dataParts)
                 {
                     m_minY = qMin(datapart->ySeries().first(),m_minY);
                     m_maxY = qMax(datapart->ySeries().last(),m_maxY);
                     for(int i=1;i<datapart->timesSeries().size();i++)
                     {
                         double newDeltaX=datapart->timesSeries()[i]-datapart->timesSeries()[i-1];
                         minDeltaX=qMin(minDeltaX,newDeltaX);
                     }
                     for(int i=1;i<datapart->ySeries().size();i++)
                     {
                         double newDeltaY=datapart->ySeries()[i]-datapart->ySeries()[i-1];
                         minDeltaY=qMin(minDeltaY,newDeltaY);
                     }
                     for (int i = 0; i < datapart->dataSeries().count(); i++)
                     {
                         double z = datapart->dataSeries().at(i);
                         m_minZ = qMin(m_minZ, z);
                         m_maxZ = qMax(m_maxZ, z);
                     }
                 }
                 m_maxX+=minDeltaX;
                 m_maxY+=minDeltaY;
             }
             /*!
                 Returns the last value (bottom right Z value) of a \a cluster of points passed as argument.
             */
             double QColorMapSeriesPrivate::clusterStrategyLast(QVector<Point3D>& cluster)
             {
                 if(!cluster.isEmpty())
                     return cluster.last().value();
                 return 0;
             }
             /*!
                 Returns the mean value (mean Z value) of a \a cluster of points passed as argument.
             */
             double QColorMapSeriesPrivate::clusterStrategyMean(QVector<Point3D>& cluster)
             {
                 if(!cluster.isEmpty())
                 {
                     double sum=0;
                     int count =0;
                     for(int i =0;i<cluster.size();i++)
                     {
                         if(!isnan(Point3D(cluster.at(i)).value()))
                         {
                             sum+= Point3D(cluster.at(i)).value();
                             count++;
                         }
                     }
                     return (sum/count);
                 }
                 return 0;
             }
             /*!
                 Returns the median value (median Z value) of a \a cluster of points passed as argument.
             */
             double QColorMapSeriesPrivate::clusterStrategyMedian(QVector<Point3D>& cluster)
             {
                 if(!cluster.isEmpty())
                 {
                     QVector<double> *copy = new QVector<double>();
                     for(int i =0;i<cluster.size();i++)
                     {
                         if(!isnan(Point3D(cluster.at(i)).value()))
                             copy->append(Point3D(cluster.at(i)).value());
                     }
                     if(!copy->isEmpty())
                     {
                         std::sort(copy->begin(), copy->end());
                         if(copy->count() & 1) // odd
                         {
                             int middle = (copy->count()+1)/2;
                             return copy->at(middle-1);
                         }
                         else //even
                         {
                             int middle = copy->count()/2;
                             return (copy->at(middle-1)+copy->at(middle))/2;
                         }
                     }
                 }
                 return 0;
             }
             /*!
                 Computes which data points correspond to the given position and returns the in a \a cluster.
             */
             void  QColorMapSeriesPrivate::buildCluster(int xpos, int  ypos, double dx, double dy, QVector<Point3D>& cluster)
             {
                 foreach(ColorMapDataPart *dataPart, m_dataParts)
                 {
                     QPair<int,int> xRange = dataPart->getRange(dataPart->timesSeries(),m_minX+xpos*dx,m_minX+(xpos+1)*dx);
                     QPair<int,int> yRange = dataPart->getRange(dataPart->ySeries(),m_maxY-(ypos+1)*dy,m_maxY-ypos*dy);
+                    int timeSeriesSize = dataPart->timesSeries().size();
                     if(xRange.first != xRange.second && yRange.first != yRange.second)
                     {
                         for(int i =xRange.first+1;i<xRange.second;i++)
                         {
                             qreal xval=dataPart->timesSeries()[i];
                             for(int j=yRange.first+1;j<yRange.second;j++)
                             {
                                 qreal yval=dataPart->ySeries()[j];
-                                qreal val=dataPart->dataSeries()[ i + (dataPart->timesSeries().size() * j)];
+                                qreal val=dataPart->dataSeries()[ i + (timeSeriesSize * j)];
                                 cluster.append(Point3D(xval,yval,val));
                             }
                         }
                     }
                 }
             }
             void QColorMapSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
                                                               int duration, QEasingCurve &curve)
             {
                 //    ColorMapChart *item = static_cast<ColorMapChart *>(m_item.data());
                 //    Q_ASSERT(item);
                 //    if (item->animation())
                 //        item->animation()->stopAndDestroyLater();
                 //    if (options.testFlag(QChart::SeriesAnimations))
                 //        item->setAnimation(new XYAnimation(item, duration, curve));
                 //    else
                 //        item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             #include "moc_qcolormapseries.cpp"
             #include "moc_qcolormapseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/colormapchart/qcolormapseries.h +2 -2

             #ifndef QCOLORMAPSERIES_H
             #define QCOLORMAPSERIES_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QAbstractSeries>
             #include <QtGui/QPen>
             #include <QtGui/QBrush>
             #include "colormapdatapart.h"
             QT_CHARTS_BEGIN_NAMESPACE
             class QColorMapSeriesPrivate;
             class QT_CHARTS_EXPORT QColorMapSeries : public QAbstractSeries
             {
                 Q_OBJECT
             //    Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
             //    Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
             //    Q_PROPERTY(QString pointLabelsFormat READ pointLabelsFormat WRITE setPointLabelsFormat NOTIFY pointLabelsFormatChanged)
             //    Q_PROPERTY(bool pointLabelsVisible READ pointLabelsVisible WRITE setPointLabelsVisible NOTIFY pointLabelsVisibilityChanged)
             //    Q_PROPERTY(QFont pointLabelsFont READ pointLabelsFont WRITE setPointLabelsFont NOTIFY pointLabelsFontChanged)
             //    Q_PROPERTY(QColor pointLabelsColor READ pointLabelsColor WRITE setPointLabelsColor NOTIFY pointLabelsColorChanged)
             //    Q_PROPERTY(bool pointLabelsClipping READ pointLabelsClipping WRITE setPointLabelsClipping NOTIFY pointLabelsClippingChanged)
             protected:
                 explicit QColorMapSeries(QColorMapSeriesPrivate &d, QObject *parent =0);
             public :
                 enum Strategy
                 {
                     LastPixel,
                     MeanPixel,
                     MedianPixel
                 };
                 explicit QColorMapSeries(QObject *parent =0);
                 ~QColorMapSeries();
                 QAbstractSeries::SeriesType type() const;
                 void append(ColorMapDataPart* dataPart, bool copy=true);
                 void append(const QList<ColorMapDataPart *> &dataParts, bool copy=true);
                 int count() const;
                 QVector<ColorMapDataPart*> dataParts() const;
                 QColorMapSeries &operator << (const ColorMapDataPart &dataPart);
                 QColorMapSeries &operator << (const QList<ColorMapDataPart *> &dataParts);
-                ColorMapDataPart* getUniformGrid(int xpos, int ypos,int width, int height, Strategy strategy);
+                QVector<double> *getUniformGrid(int xpos, int ypos,int width, int height, Strategy strategy);
-                //double getUniformGrid(int width, int height, Strategy lambda);
+                // QVector<double> *getUniformGrid(int width, int height, Strategy lambda);
                // virtual void attachAxis(QAbstractAxis *axis);
                 virtual void setPen(const QPen &pen);
                 QPen pen() const;
                 virtual void setBrush(const QBrush &brush);
                 QBrush brush() const;
             //    virtual void setColor(const QColor &color);
             //    QColor color() const;
             //    void setPointsVisible(bool visible = true);
             //    bool pointsVisible() const;
             //    void setPointLabelsFormat(const QString &format);
             //    QString pointLabelsFormat() const;
             //    void setPointLabelsVisible(bool visible = true);
             //    bool pointLabelsVisible() const;
             //    void setPointLabelsFont(const QFont &font);
             //    QFont pointLabelsFont() const;
             //    void setPointLabelsColor(const QColor &color);
             //    QColor pointLabelsColor() const;
             //    void setPointLabelsClipping(bool enabled = true);
             //    bool pointLabelsClipping() const;
                 double minX();
                 double minY();
                 double minZ();
                 double maxX();
                 double maxY();
                 double maxZ();
             Q_SIGNALS:
             //    void clicked(const Point3D &point);
             //    void hovered(const Point3D &point, bool state);
             //    void pressed(const Point3D &point);
             //    void released(const Point3D &point);
             //    void doubleClicked(const Point3D &point);
             //    void pointReplaced(int index);
             //    void pointRemoved(int index);
                 void dataPartAdded(int index);
             //    void colorChanged(QColor color);
             //    void pointsReplaced();
             //    void pointLabelsFormatChanged(const QString &format);
             //    void pointLabelsVisibilityChanged(bool visible);
             //    void pointLabelsFontChanged(const QFont &font);
             //    void pointLabelsColorChanged(const QColor &color);
             //    void pointLabelsClippingChanged(bool clipping);
             //    void pointsRemoved(int index, int count);
                 void penChanged(const QPen &pen);
             private:
                 Q_DECLARE_PRIVATE(QColorMapSeries)
                 Q_DISABLE_COPY(QColorMapSeries)
                 friend class ColorMapLegendMarker;
                 friend class ColorMapChart;
                 friend class QColorMapLegendMarkerPrivate;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCOLORMAPSERIES_H

src/charts/colormapchart/qcolormapseries_p.h +1 -3

             #ifndef QCOLORMAPSERIES_P_H
             #define QCOLORMAPSERIES_P_H
             #include <private/qabstractseries_p.h>
             #include "colormapdatapart.h"
             #include <point3d.h>
             QT_CHARTS_BEGIN_NAMESPACE
             #include "qcolormapseries.h"
             class QAbstractAxis;
             class QColorMapSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public :
                 QColorMapSeriesPrivate(QColorMapSeries *q);
                 void initializeDomain();
                 void initializeAxes();
                 void initializeGraphics(QGraphicsItem* parent);
                 void initializeTheme(int index, ChartTheme* theme, bool forced = false);
                 void initializeAnimations(QChart::AnimationOptions options, int duration,
                                           QEasingCurve &curve);
                 QList<QLegendMarker *> createLegendMarkers(QLegend *legend);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
                 QAbstractAxis* createDefaultAxis(Qt::Orientation) const;
-                ColorMapDataPart* getUniformGrid(int xpos, int ypos,int width, int height, QColorMapSeries::Strategy strategy);
+                QVector<double> *getUniformGrid(int xpos, int ypos,int width, int height, QColorMapSeries::Strategy strategy);
             Q_SIGNALS:
                 void updated();
             protected:
                 QList<ColorMapDataPart*> m_dataParts;
                 QPen m_pen;
                 QBrush m_brush;
                 bool m_pointsVisible;
                 QString m_pointLabelsFormat;
                 bool m_pointLabelsVisible;
                 QFont m_pointLabelsFont;
                 QColor m_pointLabelsColor;
                 bool m_pointLabelsClipping;
             private:
                 double m_minX;
                 double m_maxX;
                 double m_minY;
                 double m_maxY;
                 double m_minZ;
                 double m_maxZ;
                 void recomputeDataRange();
-                QPair<int,int> getLastX(double start, double end);
-                int getLastY(int x,double start, double end);
                 double clusterStrategyLast(QVector<Point3D>& cluster);
                 double clusterStrategyMean(QVector<Point3D> &cluster);
                 double clusterStrategyMedian(QVector<Point3D>& cluster);
                 void buildCluster(int xpos,int  ypos, double dx,double dy,QVector<Point3D>& cluster);
                 Q_DECLARE_PUBLIC(QColorMapSeries)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCOLORMAPSERIES_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