HG_REPOSITORIES/LPP/users/hugo/ColorMapChart Commit - r1:35d010b06810

work on color bar axis

winter -

r1:35d010b06810 default

parent child

Context file:

r1:35d010b06810

Collapse all files

src/charts/axis/colorbaraxis/qcolorbaraxis.cpp created 644 +173 0

@@ -0,0 +1,173
	1	//#include <QtCharts/QColorBarAxis> // TODO : fix this
	2	#include "colorbaraxis/qcolorbaraxis.h"
	3	//#include <private/qcolorbaraxis_p.h>
	4	#include "colorbaraxis/qcolorbaraxis_p.h"
	5	#include <private/abstractdomain_p.h>
	6	#include <private/chartdataset_p.h>
	7	#include <private/chartpresenter_p.h>
	8	#include <private/charttheme_p.h>
	9
	10	#include <QtGui>
	11
	12	QT_CHARTS_BEGIN_NAMESPACE
	13
	14
	15	/*!
	16	Constructs an axis object which is a child of \a parent.
	17	*/
	18	QColorBarAxis::QColorBarAxis(QLinearGradient gradient, qreal min, qreal max,QObject *parent) :
	19	QAbstractAxis(*new QColorBarAxisPrivate(gradient, min, max, this), parent)
	20	{
	21
	22	}
	23
	24	/*!
	25	\internal
	26	*/
	27	QColorBarAxis::QColorBarAxis(QColorBarAxisPrivate &d, QObject *parent)
	28	: QAbstractAxis(d, parent)
	29	{
	30
	31	}
	32
	33	/*!
	34	Destroys the object
	35	*/
	36	QColorBarAxis::~QColorBarAxis()
	37	{
	38	Q_D(QColorBarAxis);
	39	if (d->m_chart)
	40	d->m_chart->removeAxis(this);
	41	}
	42
	43	qreal QColorBarAxis::min() const
	44	{
	45	Q_D(const QColorBarAxis);
	46	return d->m_min;
	47	}
	48
	49	qreal QColorBarAxis::max() const
	50	{
	51	Q_D(const QColorBarAxis);
	52	return d->m_max;
	53	}
	54
	55
	56	//void QColorBarAxis::setTickCount(int count)
	57	//{
	58	// Q_D(QColorBarAxis);
	59	// if (d->m_tickCount != count && count >= 2) {
	60	// d->m_tickCount = count;
	61	// emit tickCountChanged(count);
	62	// }
	63	//}
	64
	65	//int QColorBarAxis::tickCount() const
	66	//{
	67	// Q_D(const QColorBarAxis);
	68	// return d->m_tickCount;
	69	//}
	70
	71	//void QColorBarAxis::setMinorTickCount(int count)
	72	//{
	73	// Q_D(QColorBarAxis);
	74	// if (d->m_minorTickCount != count && count >= 0) {
	75	// d->m_minorTickCount = count;
	76	// emit minorTickCountChanged(count);
	77	// }
	78	//}
	79
	80	//int QColorBarAxis::minorTickCount() const
	81	//{
	82	// Q_D(const QColorBarAxis);
	83	// return d->m_minorTickCount;
	84	//}
	85
	86	void QColorBarAxis::setLabelFormat(const QString &format)
	87	{
	88	Q_D(QColorBarAxis);
	89	d->m_format = format;
	90	emit labelFormatChanged(format);
	91	}
	92
	93	QString QColorBarAxis::labelFormat() const
	94	{
	95	Q_D(const QColorBarAxis);
	96	return d->m_format;
	97	}
	98
	99	/*!
	100	Returns the type of the axis
	101	*/
	102	QAbstractAxis::AxisType QColorBarAxis::type() const
	103	{
	104	return AxisTypeValue;
	105	//TODO : AxisTypeColorBar
	106	}
	107
	108	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	109
	110	QColorBarAxisPrivate::QColorBarAxisPrivate(QLinearGradient gradient, qreal min, qreal max, QColorBarAxis *q)
	111	: QAbstractAxisPrivate(q),
	112	m_min(min),
	113	m_max(max),
	114	// m_tickCount(5),
	115	// m_minorTickCount(0),
	116	m_format(QString::null),
	117	// m_applying(false)
	118	m_gradient(gradient)
	119	{
	120
	121	}
	122
	123	QColorBarAxisPrivate::~QColorBarAxisPrivate()
	124	{
	125
	126	}
	127
	128	void QColorBarAxisPrivate::initializeGraphics(QGraphicsItem *parent)
	129	{
	130	Q_Q(QColorBarAxis);
	131	ChartAxisElement *axis(0);
	132
	133	setAlignment(Qt::AlignRight); //also set orientation (Vertical in this case)
	134
	135	QGradientStops stops = m_gradient.stops();
	136
	137	QLinearGradient gradient(0,0,1,250);
	138	foreach(QGradientStop stop, stops)
	139	{
	140	gradient.setColorAt(1-stop.first,stop.second);
	141	}
	142
	143	QPixmap image = QPixmap(50,250);
	144	QPainter painter(&image);
	145	painter.fillRect(0,0,50,250,gradient);
	146
	147	//m_item.reset(axis);
	148	QAbstractAxisPrivate::initializeGraphics(parent);
	149	}
	150
	151	void QColorBarAxisPrivate::initializeDomain(AbstractDomain *domain)
	152	{
	153	//domain is not supposed to have a rangeZ
	154
	155	// if (orientation() == Qt::Vertical) {
	156	// if (!qFuzzyIsNull(m_max - m_min))
	157	// domain->setRangeY(m_min, m_max);
	158	// else
	159	// setRange(domain->minY(), domain->maxY());
	160	// }
	161	// if (orientation() == Qt::Horizontal) {
	162	// if (!qFuzzyIsNull(m_max - m_min))
	163	// domain->setRangeX(m_min, m_max);
	164	// else
	165	// setRange(domain->minX(), domain->maxX());
	166	// }
	167	}
	168
	169
	170	#include "moc_qcolorbaraxis.cpp"
	171	#include "moc_qcolorbaraxis_p.cpp"
	172
	173	QT_CHARTS_END_NAMESPACE

src/charts/axis/colorbaraxis/qcolorbaraxis.h created 644 +51 0

@@ -0,0 +1,51
	1	#ifndef QCOLORBARAXIS_H
	2	#define QCOLORBARAXIS_H
	3
	4	#include <QtCharts/QAbstractAxis>
	5
	6	QT_CHARTS_BEGIN_NAMESPACE
	7
	8	class QColorBarAxisPrivate;
	9
	10	class QT_CHARTS_EXPORT QColorBarAxis : public QAbstractAxis
	11	{
	12	Q_OBJECT
	13	public:
	14	explicit QColorBarAxis(QLinearGradient gradient, qreal min, qreal max,QObject *parent = 0);
	15	~QColorBarAxis();
	16
	17	protected:
	18	QColorBarAxis(QColorBarAxisPrivate &d, QObject *parent = 0);
	19
	20	public:
	21	AxisType type() const;
	22
	23	//range handling
	24	qreal min() const;
	25	qreal max() const;
	26
	27	//ticks handling
	28	// void setTickCount(int count);
	29	// int tickCount() const;
	30	// void setMinorTickCount(int count);
	31	// int minorTickCount() const;
	32
	33	void setLabelFormat(const QString &format);
	34	QString labelFormat() const;
	35
	36	Q_SIGNALS:
	37	void minChanged(qreal min);
	38	void maxChanged(qreal max);
	39	void rangeChanged(qreal min, qreal max);
	40	// void tickCountChanged(int tickCount);
	41	// void minorTickCountChanged(int tickCount);
	42	void labelFormatChanged(const QString &format);
	43
	44	private:
	45	Q_DECLARE_PRIVATE(QColorBarAxis)
	46	Q_DISABLE_COPY(QColorBarAxis)
	47	};
	48
	49	QT_CHARTS_END_NAMESPACE
	50
	51	#endif // QCOLORBARAXIS_H

src/charts/axis/colorbaraxis/qcolorbaraxis_p.h created 644 +41 0

@@ -0,0 +1,41
	1	#ifndef QCOLORBARAXIS_P_H
	2	#define QCOLORBARAXIS_P_H
	3
	4	//#include <QtCharts/QColorBarAxis> //TODO : fix this
	5	#include "colorbaraxis/qcolorbaraxis.h"
	6	#include <private/qabstractaxis_p.h>
	7
	8	QT_CHARTS_BEGIN_NAMESPACE
	9
	10	class QColorBarAxisPrivate : public QAbstractAxisPrivate
	11	{
	12	Q_OBJECT
	13	public:
	14	QColorBarAxisPrivate(QLinearGradient gradient, qreal min, qreal max,QColorBarAxis *q);
	15	~QColorBarAxisPrivate();
	16
	17	public:
	18	void initializeGraphics(QGraphicsItem* parent);
	19	void initializeDomain(AbstractDomain *domain);
	20
	21	qreal min() { return m_min; }
	22	qreal max() { return m_max; }
	23	void setRange(qreal min,qreal max);
	24
	25	protected:
	26	void setMin(const QVariant &min);
	27	void setMax(const QVariant &max);
	28	void setRange(const QVariant &min, const QVariant &max);
	29
	30	private:
	31	qreal m_min;
	32	qreal m_max;
	33	// int m_tickCount;
	34	// int m_minorTickCount;
	35	QString m_format;
	36	// bool m_applying;
	37	QLinearGradient m_gradient;
	38	Q_DECLARE_PUBLIC(QColorBarAxis)
	39	};
	40
	41	#endif // QCOLORBARAXIS_P_H

src/charts/axis/axis.pri +11 -4

             #Subdirectiores are defined here, because qt creator doesn't handle nested include(foo.pri) chains very well.
             INCLUDEPATH += $$PWD \
                 $$PWD/valueaxis \
                 $$PWD/barcategoryaxis \
                 $$PWD/categoryaxis \
-                $$PWD/logvalueaxis
+                $$PWD/logvalueaxis \
+                $$PWD/colorbaraxis
             DEPENDPATH += $$PWD \
                 $$PWD/valueaxis \
                 $$PWD/barcategoryaxis \
                 $$PWD/categoryaxis \
-                $$PWD/logvalueaxis
+                $$PWD/logvalueaxis \
+                $$PWD/colorbaraxis
             SOURCES += \
                 $$PWD/chartaxiselement.cpp \
                 $$PWD/cartesianchartaxis.cpp \
                 $$PWD/qabstractaxis.cpp \
                 $$PWD/verticalaxis.cpp \
                 $$PWD/horizontalaxis.cpp \
                 $$PWD/valueaxis/chartvalueaxisx.cpp \
                 $$PWD/valueaxis/chartvalueaxisy.cpp \
                 $$PWD/valueaxis/qvalueaxis.cpp \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisx.cpp \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisy.cpp \
                 $$PWD/barcategoryaxis/qbarcategoryaxis.cpp \
                 $$PWD/categoryaxis/chartcategoryaxisx.cpp \
                 $$PWD/categoryaxis/chartcategoryaxisy.cpp \
                 $$PWD/categoryaxis/qcategoryaxis.cpp \
                 $$PWD/logvalueaxis/chartlogvalueaxisx.cpp \
                 $$PWD/logvalueaxis/chartlogvalueaxisy.cpp \
-                $$PWD/logvalueaxis/qlogvalueaxis.cpp
+                $$PWD/logvalueaxis/qlogvalueaxis.cpp \
+                $$PWD/colorbaraxis/qcolorbaraxis.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxiselement_p.h \
                 $$PWD/cartesianchartaxis_p.h \
                 $$PWD/qabstractaxis_p.h \
                 $$PWD/verticalaxis_p.h \
                 $$PWD/horizontalaxis_p.h \
                 $$PWD/linearrowitem_p.h \
                 $$PWD/valueaxis/chartvalueaxisx_p.h \
                 $$PWD/valueaxis/chartvalueaxisy_p.h \
                 $$PWD/valueaxis/qvalueaxis_p.h \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisx_p.h \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisy_p.h \
                 $$PWD/barcategoryaxis/qbarcategoryaxis_p.h \
                 $$PWD/categoryaxis/chartcategoryaxisx_p.h \
                 $$PWD/categoryaxis/chartcategoryaxisy_p.h \
                 $$PWD/categoryaxis/qcategoryaxis_p.h \
                 $$PWD/logvalueaxis/chartlogvalueaxisx_p.h \
                 $$PWD/logvalueaxis/chartlogvalueaxisy_p.h \
-                $$PWD/logvalueaxis/qlogvalueaxis_p.h
+                $$PWD/logvalueaxis/qlogvalueaxis_p.h \
+                $$PWD/colorbaraxis/qcolorbaraxis_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qabstractaxis.h \
                 $$PWD/valueaxis/qvalueaxis.h \
                 $$PWD/barcategoryaxis/qbarcategoryaxis.h \
                 $$PWD/categoryaxis/qcategoryaxis.h \
                 $$PWD/logvalueaxis/qlogvalueaxis.h \
+                $$PWD/colorbaraxis/qcolorbaraxis.h
             # polar
             SOURCES += \
                 $$PWD/polarchartaxis.cpp \
                 $$PWD/polarchartaxisangular.cpp \
                 $$PWD/polarchartaxisradial.cpp \
                 $$PWD/valueaxis/polarchartvalueaxisangular.cpp \
                 $$PWD/valueaxis/polarchartvalueaxisradial.cpp \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisangular.cpp \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisradial.cpp \
                 $$PWD/categoryaxis/polarchartcategoryaxisangular.cpp \
                 $$PWD/categoryaxis/polarchartcategoryaxisradial.cpp
             PRIVATE_HEADERS += \
                 $$PWD/polarchartaxis_p.h \
                 $$PWD/polarchartaxisangular_p.h \
                 $$PWD/polarchartaxisradial_p.h \
                 $$PWD/valueaxis/polarchartvalueaxisangular_p.h \
                 $$PWD/valueaxis/polarchartvalueaxisradial_p.h \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisangular_p.h \
                 $$PWD/logvalueaxis/polarchartlogvalueaxisradial_p.h \
                 $$PWD/categoryaxis/polarchartcategoryaxisangular_p.h \
                 $$PWD/categoryaxis/polarchartcategoryaxisradial_p.h
             !linux-arm*: {
             INCLUDEPATH += \
                 $$PWD/datetimeaxis
             DEPENDPATH += \
                 $$PWD/datetimeaxis
             SOURCES += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx.cpp \
                 $$PWD/datetimeaxis/chartdatetimeaxisy.cpp \
                 $$PWD/datetimeaxis/qdatetimeaxis.cpp \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisangular.cpp \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisradial.cpp
             PRIVATE_HEADERS += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx_p.h \
                 $$PWD/datetimeaxis/chartdatetimeaxisy_p.h \
                 $$PWD/datetimeaxis/qdatetimeaxis_p.h \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisangular_p.h \
                 $$PWD/datetimeaxis/polarchartdatetimeaxisradial_p.h
             PUBLIC_HEADERS += \
                 $$PWD/datetimeaxis/qdatetimeaxis.h
             }

src/charts/colormapchart/colormapchart.cpp +71 -41

             #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_dirty(true),
+                  m_gradientType(Rainbow)
             {
                 //    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)));
-                m_abscissTable = new QMap<int, int>() ;
+                connect(this,SIGNAL(gradientTypeChanged()), this, SLOT(populateColorTable()));
-                m_ordinateTable = new QMap<int, int>() ;
-                m_coordinateToColorTable = new QMap<QPair<int, int>,uint>();
+                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)
-                static double debug=0.0;
-                m_coordinateToColorTable->clear();
-                m_abscissTable->clear();
-                m_ordinateTable->clear();
                 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::MeanPixel);
+                ColorMapDataPart * grid = m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),QColorMapSeries::LastPixel);
                 double maxZ = m_series->maxZ();
                 double minZ = m_series->minZ();
                 double rangeZ = maxZ - minZ;
-                QLinearGradient gradient = createColorMapGradient(Rainbow);
-                QGradientStops colorStops = gradient.stops();
-            QVector<QRgb> *values = new QVector<QRgb>();
                 for(int i=0;i<colorMapImage.width();i++)
                 {
                     for(int j=0;j<colorMapImage.height();j++)
                     {
-                        double value = grid->dataSeries().at(i+j*colorMapImage.width());
+                        double value = grid->dataSeries().at(i+j*(colorMapImage.width()));
                         double pix=((value-minZ)/rangeZ);
-                        for(int k =0;k<colorStops.size()-1;k++)
+                        int indexInColorTable = pix*(nbOfColors-1);
+                        colorMapImage.setPixel(i,j,m_colorTable->at(indexInColorTable));
-                            QGradientStop lowerBound = colorStops.at(k);
-                            QGradientStop upperBound = colorStops.at(k+1);
-                            if(pix >= lowerBound.first && pix < upperBound.first)
-                                double ratio = (pix-lowerBound.first)/(upperBound.first - lowerBound.first);
-                                int red      = (int)(ratio*lowerBound.second.red() + (1-ratio)*upperBound.second.red());
-                                int green = (int)(ratio*lowerBound.second.green() + (1-ratio)*upperBound.second.green());
-                                int blue   = (int)(ratio*lowerBound.second.blue() + (1-ratio)*upperBound.second.blue());
-                                colorMapImage.setPixel(i,j,qRgb(red, green, blue));
-                                values->append(qRgb(red, green, blue));
-                                break;
-                            else
-                                if(k==colorStops.size()-2)
-                                    colorMapImage.setPixel(i,j,qRgb(colorStops.at(colorStops.size()-1).second.red(), colorStops.at(colorStops.size()-1).second.green(), colorStops.at(colorStops.size()-1).second.blue()));
-                                     values->append(qRgb(colorStops.at(colorStops.size()-1).second.red(), colorStops.at(colorStops.size()-1).second.green(), colorStops.at(colorStops.size()-1).second.blue()));
                     }
                 }
                 painter->drawImage(clipRect,colorMapImage);
                 update();
+            QColorBarAxis *colorbar = new QColorBarAxis(createColorMapGradient(m_gradientType),minZ, maxZ,this);
+                m_series->chart()->addAxis(colorbar, Qt::AlignRight);
             }
             /*!
                 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 Grey :
+                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;
+                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 +9 -5

             #ifndef COLORMAPCHART_H
             #define COLORMAPCHART_H
             #include "point3d.h"
             #include <QtCharts/QChartGlobal>
             #include <private/chartitem_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtGui/QPen>
             QT_CHARTS_BEGIN_NAMESPACE
             class ChartPresenter;
             class QColorMapSeries;
             class ColorMapChart :  public ChartItem
             {
                 Q_OBJECT
             public:
                 enum GradientType
                 {
                     Rainbow,
                     CyclingRainbow,
-                    Grey
+                    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();
                 QLinearGradient createColorMapGradient(GradientType gradientType);
+                void changeGradient(GradientType gradientType);
             protected:
                 QColorMapSeries *m_series;
                 QVector<Point3D> m_points;
                 QRectF m_rect;
                 bool m_dirty;
-                QMap<int, int> *m_abscissTable;
+                QVector<QRgb> *m_colorTable;
-                QMap<int, int> *m_ordinateTable;
+                GradientType m_gradientType;
-                QMap<QPair<int, int>,uint> *m_coordinateToColorTable;
             };
             //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 +29 -28

             #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>
             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)
             {
                 Q_D(QColorMapSeries);
                 return d->getUniformGrid(xpos, ypos,width,height, strategy);
             }
             /*!
                 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> *timeSeries = new QVector<double>(width);
                 //    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?
                 {
                     timeSeries->append((double)i);
                 }
                 for (auto cell= dataSeries->begin();cell<dataSeries->end();++cell)
                 {
                     QVector<Point3D> cluster;
                     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)
+            void  QColorMapSeriesPrivate::buildCluster(int xpos, int  ypos, double dx, double dy, QVector<Point3D>& cluster)
+            {
+                foreach(ColorMapDataPart *dataPart, m_dataParts)
                 {
-                    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);
+                    if(xRange.first != xRange.second && yRange.first != yRange.second)
                     {
-                        QPair<int,int> xRange = dataPart->getRange(dataPart->timesSeries(),m_minX+xpos*dx,m_minX+(double)(xpos+1)*dx);
+                        for(int i =xRange.first+1;i<xRange.second;i++)
-                        QPair<int,int> yRange = dataPart->getRange(dataPart->ySeries(),m_minY+ypos*dy,m_minY+(double)(ypos+1)*dy);
-                        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 xval=dataPart->timesSeries()[i];
+                                qreal yval=dataPart->ySeries()[j];
-                                for(int j=yRange.first+1;j<yRange.second;j++)
+                                qreal val=dataPart->dataSeries()[ i + (dataPart->timesSeries().size() * j)];
+                                cluster.append(Point3D(xval,yval,val));
-                                    qreal yval=dataPart->ySeries()[j];
-                                    qreal val=dataPart->dataSeries()[ i + (dataPart->timesSeries().size() * j)];
-                                    cluster.append(Point3D(xval,yval,val));
                             }
                         }
                     }
                 }
+            }
-                void QColorMapSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
+            void QColorMapSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
-                                                                  int duration, QEasingCurve &curve)
+                                                              int duration, QEasingCurve &curve)
+            {
-                    //    ColorMapChart *item = static_cast<ColorMapChart *>(m_item.data());
+                //    ColorMapChart *item = static_cast<ColorMapChart *>(m_item.data());
-                    //    Q_ASSERT(item);
+                //    Q_ASSERT(item);
-                    //    if (item->animation())
+                //    if (item->animation())
-                    //        item->animation()->stopAndDestroyLater();
+                //        item->animation()->stopAndDestroyLater();
-                    //    if (options.testFlag(QChart::SeriesAnimations))
+                //    if (options.testFlag(QChart::SeriesAnimations))
-                    //        item->setAnimation(new XYAnimation(item, duration, curve));
+                //        item->setAnimation(new XYAnimation(item, duration, curve));
-                    //    else
+                //    else
-                    //        item->setAnimation(0);
+                //        item->setAnimation(0);
-                    QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
+                QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
+            }
             #include "moc_qcolormapseries.cpp"
             #include "moc_qcolormapseries_p.cpp"
-                QT_CHARTS_END_NAMESPACE
+            QT_CHARTS_END_NAMESPACE

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