HG_REPOSITORIES/LPP/users/hugo/ColorMapChart Commit - r7:a8e6b5a8e8d0

fix painting coordinates and added LGPL

winter -

r7:a8e6b5a8e8d0 tip default

parent child

Context file:

r7:a8e6b5a8e8d0

Collapse all files

examples/charts/colormap/colormap.pro +7 -1

@@ -1,6 +1,12
1	!include( ../examples.pri ) {	1	!include( ../examples.pri ) {
2	error( "Couldn't find the examples.pri file!" )	2	error( "Couldn't find the examples.pri file!" )
3	}	3	}
4		4
5	TARGET = colormap	5	TARGET = colormap
6	SOURCES += main.cpp	6	SOURCES += main.cpp \
		7	chart.cpp \
		8	chartview.cpp
		9
		10	HEADERS += \
		11	chart.h \
		12	chartview.h

examples/charts/colormap/main.cpp +42 -35

-            /****************************************************************************
+            /*------------------------------------------------------------------------------
-            **
+            --  This file is a part of the ColorMapChart API
-            ** Copyright (C) 2016 The Qt Company Ltd.
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
-            ** Contact: https://www.qt.io/licensing/
+            --
-            **
+            --  This program is free software; you can redistribute it and/or modify
-            ** This file is part of the Qt Charts module of the Qt Toolkit.
+            --  it under the terms of the GNU General Public License as published by
-            **
+            --  the Free Software Foundation; either version 2 of the License, or
-            ** $QT_BEGIN_LICENSE:GPL$
+            --  (at your option) any later version.
-            ** Commercial License Usage
+            --
-            ** Licensees holding valid commercial Qt licenses may use this file in
+            --  This program is distributed in the hope that it will be useful,
-            ** accordance with the commercial license agreement provided with the
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
-            ** Software or, alternatively, in accordance with the terms contained in
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-            ** a written agreement between you and The Qt Company. For licensing terms
+            --  GNU General Public License for more details.
-            ** and conditions see https://www.qt.io/terms-conditions. For further
+            --
-            ** information use the contact form at https://www.qt.io/contact-us.
+            --  You should have received a copy of the GNU General Public License
-            **
+            --  along with this program; if not, write to the Free Software
-            ** GNU General Public License Usage
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-            ** Alternatively, this file may be used under the terms of the GNU
+            -------------------------------------------------------------------------------*/
-            ** General Public License version 3 or (at your option) any later version
+            /*--                  Author : Hugo Winter
-            ** approved by the KDE Free Qt Foundation. The licenses are as published by
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
-            ** 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>
+            #include <QLineSeries>
+            #include "chart.h"
+            #include "chartview.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);
                 }
                 QVector<double> *ySeries = new QVector<double>();
                 ySeries->reserve(768);
                 for(int  i=0;i<768;i++)
                 {
                     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);
                 }
+                QLineSeries *series2 = new QLineSeries();
+                series2->append(-100, 300);
+                series2->append(100, 400);
+                series2->append(200, 50);
+                series2->append(300, 1000);
+                series2->append(400, 800);
+                *series2 << QPointF(500, 700) << QPointF(600, 600) << QPointF(700, 500) << QPointF(800, -100) << QPointF(1300, 50);
                 ColorMapDataPart * data = new ColorMapDataPart(xSeries,ySeries,zSeries);
                 QColorMapSeries *series = new QColorMapSeries();
                 series->append(data);
-                QChart *chart = new QChart();
+                Chart *chart = new Chart();
                 chart->addSeries(series);
-                chart->setTitle("Simple colormap example");
+                chart->addSeries(series2);
                 chart->createDefaultAxes();
+                chart->setTitle("Simple Colormap Example");
                 chart->axisX()->setGridLineVisible(false);
                 chart->axisY()->setGridLineVisible(false);
-                QChartView *chartView = new QChartView(chart);
+                ChartView *chartView = new ChartView(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 +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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, QPoint pos, qreal height, QLinearGradient gradient, QGraphicsItem *item)
                 : VerticalAxis(axis, item),
                   m_axis(axis),
                   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() + 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() + 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()
             {
                 m_axis->setLabelsColor(QColor(0,0,255,0)); //make automatic labels disappear without changing layout (as it would be the case with setlabelVisible(false))
                 //gradient
                 QGradientStops stops = m_gradient.stops();
                 QLinearGradient gradient(0,m_position.y(),1,m_height);
                 foreach(QGradientStop stop, stops)
                 {
                     gradient.setColorAt(1-stop.first,stop.second);
                 }
                 //colorbar
                 QRectF rect(m_position.x()+10,m_position.y(),m_height/20,m_height); //remove +10 if needed
                 QGraphicsRectItem *colorbar = new QGraphicsRectItem(rect, this);
                 colorbar->setZValue(ChartPresenter::AxisZValue);
                 colorbar->setBrush(gradient);
                 //colorbar labels
                 for(int i=0;i<m_axis->tickCount();i++)
                 {
                     qreal value = m_axis->max() - (i * (m_axis->max() - m_axis->min()) / (m_axis->tickCount() - 1));
                     QGraphicsTextItem *label = new QGraphicsTextItem(this);
                     label->setPlainText(QString::number(value));
                     label->setPos((m_position.x()+10+m_height/20+1),(m_position.y()*0.85+i*(m_height/(m_axis->tickCount()-1)))); //remove +10 if needed
                 }
             }
             #include "moc_chartcolorbaraxisy_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/colorbaraxis/chartcolorbaraxisy_p.h +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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, 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 +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             //#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(QRectF plotArea, QLinearGradient gradient, qreal min, qreal max, QObject *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(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)
                 //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 +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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(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 +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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(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 +79 -33

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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 <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(Q_NULLPTR),
                   m_isColorBarDrawn(false),
-                  m_currentplotArea(QRectF())
+                  m_currentClipRect(QRectF())
             {
                 //    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();
             }
             ColorMapChart::~ColorMapChart()
             {
                 delete m_colorTable;
                 delete m_colorbar;
             }
             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();
+                //m_series->setUseOpenGL();
-                QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
-                painter->setClipRect(clipRect);
                 QRectF plotAreaRect = m_series->chart()->plotArea();
-                if(m_currentplotArea !=plotAreaRect)
+                QRectF clipRect = mapColorMapToPlotArea();
+                painter->setClipRect(clipRect);
-                    m_currentplotArea = plotAreaRect;
-                    m_grid.reserve(plotAreaRect.width()*plotAreaRect.height());
+                if(m_currentClipRect !=clipRect)
-                    m_grid.resize(plotAreaRect.width()*plotAreaRect.height());
+                    m_currentClipRect = clipRect;
+                    m_grid.reserve(clipRect.width()*clipRect.height());
+                    m_grid.resize(clipRect.width()*clipRect.height());
-                    m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),m_grid, QColorMapSeries::LastPixel);
+                    m_series->getUniformGrid(qMax(m_series->minX(),domain()->minX()),qMin(m_series->maxX(),domain()->maxX()),qMax(m_series->minY(),domain()->minY()),qMin(m_series->maxY(),domain()->maxY()), clipRect.width(),clipRect.height(),m_grid, QColorMapSeries::LastPixel);
                     addColorBar(plotAreaRect);
                 }
-                QImage colorMapImage(plotAreaRect.width(),plotAreaRect.height(),QImage::Format_RGB32);
+                QImage colorMapImage(clipRect.width(),clipRect.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());
+                fillColorMapImage(colorMapImage);
+                painter->drawImage(clipRect,colorMapImage);
+                painter->restore();
+            }
+            void ColorMapChart::addColorBar(QRectF plotAreaRect)
+            {
+                double maxZ = m_series->maxZ();
+                double minZ = m_series->minZ();
+                if(m_isColorBarDrawn)
+                    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;
+            }
+            QRectF ColorMapChart::mapColorMapToPlotArea()
+            {
+                QRectF plotAreaRect = m_series->chart()->plotArea();
+                double seriesMinX = m_series->minX();
+                double seriesMaxX = m_series->maxX();
+                double seriesMinY = m_series->minY();
+                double seriesMaxY = m_series->maxY();
+                double domainMinX = domain()->minX();
+                double domainMaxX = domain()->maxX();
+                double domainMinY = domain()->minY();
+                double domainMaxY = domain()->maxY();
+                double widthToPaint = (qMin(seriesMaxX, domainMaxX)-qMax(seriesMinX, domainMinX))*plotAreaRect.width()/(domainMaxX-domainMinX);
+                double heightTopaint= (qMin(seriesMaxY, domainMaxY)-qMax(seriesMinY, domainMinY))*plotAreaRect.height()/(domainMaxY-domainMinY);
+                QSizeF size = QSize(widthToPaint,heightTopaint);
+                double pointX = (qMax(seriesMinX,domainMinX)-domainMinX)*plotAreaRect.width()/(domainMaxX-domainMinX);
+                double pointY = (domainMaxY-qMin(seriesMaxY,domainMaxY))*plotAreaRect.height()/(domainMaxY-domainMinY);
+                return QRectF(QPointF(pointX,pointY) ,size);
+            }
+            void ColorMapChart::fillColorMapImage(QImage &colorMapImage)
+            {
                 double maxZ = m_series->maxZ();
                 double minZ = m_series->minZ();
                 double rangeZ = maxZ - minZ;
                 int imageWidth = colorMapImage.width();
                 int imageHeight = colorMapImage.height();
                 for(int i=0;i<imageWidth;i++)
                 {
                     for(int j=0;j<imageHeight;j++)
                     {
                         double value = m_grid.at(i+j*(imageWidth));
                         double pix=((value-minZ)/rangeZ);
                         int indexInColorTable = pix*(nbOfColors-1);
                         colorMapImage.setPixel(i,j,m_colorTable->at(indexInColorTable));
                     }
                 }
-                painter->drawImage(clipRect,colorMapImage);
-                //This line was causing re-painting loop
-                //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(QRectF plotAreaRect)
-                double maxZ = m_series->maxZ();
-                double minZ = m_series->minZ();
-                if(m_isColorBarDrawn)
-                    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.pri +3 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
+            QT+=concurrent
-            QMAKE_CXXFLAGS+= -fopenmp
+            #QMAKE_CXXFLAGS+= -fopenmp
-            QMAKE_LFLAGS +=  -fopenmp
+            #QMAKE_LFLAGS +=  -fopenmp
             SOURCES += \
                 $$PWD/qcolormapseries.cpp \
                 $$PWD/colormapchart.cpp \
                 $$PWD/colormapdatapart.cpp \
                 $$PWD/point3d.cpp
             PRIVATE_HEADERS += \
                 $$PWD/qcolormapseries_p.h \
                 $$PWD/colormapchart_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qcolormapseries.h  \
                 $$PWD/point3d.h \
                 $$PWD/colormapdatapart.h

src/charts/colormapchart/colormapchart_p.h +26 -1

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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(QRectF plotAreaRect);
+                QRectF mapColorMapToPlotArea();
+                void fillColorMapImage(QImage &colorMapImage);
                 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_isColorBarDrawn;
                 QColorBarAxis *m_colorbar;
-                QRectF m_currentplotArea;
+                QRectF m_currentClipRect;
                 QVector<double> m_grid;
             };
             //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/colormapdatapart.cpp +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #include "colormapdatapart.h"
             QT_CHARTS_BEGIN_NAMESPACE
             ColorMapDataPart::ColorMapDataPart()
             {
             }
             ColorMapDataPart::ColorMapDataPart(ColorMapDataPart *dataPart)
             {/*
                 QVector<double> *m_timeSeries;
                 QVector<double> *m_ySeries;
                 QVector<double> *m_dataSeries;*/
                 this->m_dataSeries = new QVector<double>(dataPart->dataSeries());
                 this->m_ySeries = new QVector<double>(dataPart->ySeries());
                 this->m_timeSeries = new QVector<double>(dataPart->timesSeries());
             }
             ColorMapDataPart::ColorMapDataPart(QVector<double> *timeSeries, QVector<double> *ySeries, QVector<double> *dataSeries)
                 : m_timeSeries(timeSeries),m_ySeries(ySeries),m_dataSeries(dataSeries)
             {
             }
             ColorMapDataPart::~ColorMapDataPart()
             {
                 delete m_dataSeries;
                 delete m_ySeries;
                 delete m_timeSeries;
             }
             int ColorMapDataPart::find(double val, const QVector<double> &vect, bool more)
             {
                 if(val >=vect.last() && more)
                     return vect.count();
                 if(val <= vect.first() && !more)
                     return -1;
                 int guessedIndex = (val-vect.first())*vect.count()/(vect.last()-vect.first());
                 if(guessedIndex>(vect.count()-1))guessedIndex=vect.count()-1;
                 if(more)
                     while(vect[guessedIndex]<val){guessedIndex++;}
                 else
                     while(vect[guessedIndex--]>val){}
                 return guessedIndex;
             }
             QPair<int, int> ColorMapDataPart::getRange(const QVector<double> &vect, double start, double stop)
             {
                return QPair<int, int>(find(start,vect, false),find(stop,vect, true));
             }
             QT_CHARTS_END_NAMESPACE

src/charts/colormapchart/colormapdatapart.h +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #ifndef COLORMAPDATAPART_H
             #define COLORMAPDATAPART_H
             #include <QtCharts/QChartGlobal>
             #include <QtCore>
             QT_CHARTS_BEGIN_NAMESPACE
             class QT_CHARTS_EXPORT ColorMapDataPart
             {
             public:
                 explicit ColorMapDataPart();
                 ColorMapDataPart(ColorMapDataPart* dataPart);
                 explicit ColorMapDataPart(QVector<double> *timeSeries, QVector<double> *ySeries, QVector<double> *dataSeries);
                 ~ColorMapDataPart();
                 inline const QVector<double>& timesSeries(){return *this->m_timeSeries;}
                 inline const QVector<double>& ySeries(){return *this->m_ySeries;}
                 inline const QVector<double>& dataSeries(){return *this->m_dataSeries;}
                 inline void setTimeSeries(QVector<double> *timeSeries){this->m_timeSeries =timeSeries;}
                 inline void setYSeries(QVector<double> *ySeries){this->m_ySeries =ySeries;}
                 inline void setDataSeries(QVector<double> *dataSeries){this->m_dataSeries =dataSeries;}
                 QPair<int,int> getRange(const QVector<double> &vect, double start, double stop);
             protected:
                 QVector<double> *m_timeSeries;
                 QVector<double> *m_ySeries;
                 QVector<double> *m_dataSeries;
             private:
                 int find(double val, const QVector<double> &vect, bool more);
             };
             QT_CHARTS_END_NAMESPACE
             #endif // COLORMAPDATAPART_H

src/charts/colormapchart/point3d.cpp +22 0

@@ -1,13 +1,35
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the ColorMapChart API
		3	-- Copyright (C) 2016, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Hugo Winter
		20	-- Mail : hugo.winter@lpp.polytechnique.fr
		21	----------------------------------------------------------------------------*/
		22
1	#include "point3d.h"	23	#include "point3d.h"
2		24
3		25
4	Point3D::Point3D()	26	Point3D::Point3D()
5	: QPointF()	27	: QPointF()
6	{	28	{
7	}	29	}
8		30
9	Point3D::Point3D(qreal x, qreal y, qreal value)	31	Point3D::Point3D(qreal x, qreal y, qreal value)
10	: QPointF(x,y),	32	: QPointF(x,y),
11	m_value(value)	33	m_value(value)
12	{	34	{
13	}	35	}

src/charts/colormapchart/point3d.h +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #ifndef POINT3D_H
             #define POINT3D_H
             #include <QPointF>
             class Point3D : public QPointF
             {
             public:
                 Point3D();
                 Point3D(qreal x, qreal y, qreal value);
                 inline void setValue(qreal value){this->m_value = value;}
                 inline qreal value(){return this->m_value;}
             private:
                 qreal m_value;
             };
             #endif // POINT3D_H

src/charts/colormapchart/qcolormapseries.cpp +58 -46

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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 <cmath>
-            #include "omp.h"
+            #include <QtConcurrent>
             #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.
             */
-            void QColorMapSeries::getUniformGrid(int xpos, int ypos,int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy)
+            void QColorMapSeries::getUniformGrid(double minX, double maxX, double minY, double maxY, int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy)
             {
                 Q_D(QColorMapSeries);
-                d->getUniformGrid(xpos, ypos,width,height, grid, strategy);
+                d->getUniformGrid(minX, maxX,minY,maxY,width,height, grid, 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;
             }
-            void QColorMapSeriesPrivate::getUniformGrid(int xpos, int ypos,  int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy)
+            void QColorMapSeriesPrivate::getUniformGrid(double minX, double maxX, double minY, double maxY, int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy)
             {
-                double dx = (m_maxX - m_minX)/(double)width;
+                m_imageHeight = height;
-                double dy = (m_maxY - m_minY)/(double)height;
+                m_imageWidth = width;
+                m_strategy = strategy;
+                m_requestedMinX = minX;
+                m_requestedMaxX = maxX;
+                m_requestedMinY = minY;
+                m_requestedMaxY = maxY;
                 int index=0;
+                std::generate(grid.begin(),grid.end(),[&index]{return index++;});
-                QVector<Point3D> cluster;
-                cluster.reserve(height*width/1000);
-                int x = 0;
-                int y = 0;
-                for (auto cell= grid.begin();cell<grid.end();++cell)
+                QFuture<void> futureWatcher = QtConcurrent::map(grid,[this] (double &index) { return computePixelValue(index); });
-                    x = index%width;
+                futureWatcher.waitForFinished();
-                    y = index/width;
-                    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);
-                    index++;
             }
-            //#pragma omp for
+            double QColorMapSeriesPrivate::computePixelValue(double &index)
-            //    for(int y = 0;y<height;y++)
-            //    {
+                QVector<Point3D> cluster;
-            //        for(int x =0;x<width;x++)
+                cluster.reserve(m_imageHeight*m_imageWidth/1000);
-            //        {
+                cluster.resize(0);
-            //                    cluster.resize(0);
-            //                    this->buildCluster(x,y,dx,dy,cluster);
+                double dx = (m_requestedMaxX - m_requestedMinX)/m_imageWidth;
-            //                    if(strategy == QColorMapSeries::LastPixel)
+                double dy = (m_requestedMaxY - m_requestedMinY)/m_imageHeight;
-            //                        grid[width*y+x] = this->clusterStrategyLast(cluster);
-            //                    else if(strategy == QColorMapSeries::MeanPixel)
-            //                        grid[width*y+x] = this->clusterStrategyMean(cluster);
-            //                    else if(strategy == QColorMapSeries::MedianPixel)
-            //                        grid[width*y+x] = this->clusterStrategyMedian(cluster);
-            //        }
-            //    }
-            double QColorMapSeriesPrivate::computeValuePixel()
+                int x = (int)index%m_imageWidth;
+                int y = (int)index/m_imageWidth;
+                this->buildCluster(x,y,dx,dy,cluster);
+                if(m_strategy == QColorMapSeries::LastPixel)
+                    index =  this->clusterStrategyLast(cluster);
+                else if(m_strategy == QColorMapSeries::MeanPixel)
+                    index =  this->clusterStrategyMean(cluster);
+                else if(m_strategy == QColorMapSeries::MedianPixel)
+                    index =   this->clusterStrategyMedian(cluster);
+                return index;//not used
             }
             /*!
                 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> xRange = dataPart->getRange(dataPart->timesSeries(),m_requestedMinX+xpos*dx,m_requestedMinX+(xpos+1)*dx);
-                    QPair<int,int> yRange = dataPart->getRange(dataPart->ySeries(),m_maxY-(ypos+1)*dy,m_maxY-ypos*dy);
+                    QPair<int,int> yRange = dataPart->getRange(dataPart->ySeries(),m_requestedMaxY-(ypos+1)*dy,m_requestedMaxY-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 + (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 +23 -1

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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);
-                void getUniformGrid(int xpos, int ypos,int width, int height, QVector<double> &grid, Strategy strategy);
+                void getUniformGrid(double minX, double maxX, double minY, double maxY, int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy);
                 // QVector<double> *getUniformGrid(int width, int height, QVector<double> &grid, 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 +33 -1

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #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;
-                void getUniformGrid(int xpos, int ypos,int width, int height,QVector<double> &grid, QColorMapSeries::Strategy strategy);
+                void getUniformGrid(double minX, double maxX, double minY, double maxY, int width, int height, QVector<double> &grid, 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;
+                int m_imageHeight;
+                int m_imageWidth;
+                QColorMapSeries::Strategy m_strategy;
+                double m_requestedMinX;
+                double m_requestedMaxX;
+                double m_requestedMinY;
+                double m_requestedMaxY;
                 void recomputeDataRange();
+                double computePixelValue(double &index);
                 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

src/charts/legend/qcolormaplegendmarker.cpp +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #include <QtCharts/QColorMapLegendMarker>
             #include <private/qcolormapseries_p.h>
             #include <private/qcolormaplegendmarker_p.h>
             #include <QtCharts/QColorMapSeries>
             QT_CHARTS_BEGIN_NAMESPACE
             QColorMapLegendMarker::QColorMapLegendMarker(QColorMapSeries *series, QLegend *legend, QObject *parent)
                 : QLegendMarker(*new QColorMapLegendMarkerPrivate(this,series,legend), parent)
             {
                 d_ptr->updated();
             }
             QColorMapLegendMarker::~QColorMapLegendMarker()
             {
             }
             QColorMapLegendMarker::QColorMapLegendMarker(QColorMapLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             QColorMapSeries* QColorMapLegendMarker::series()
             {
                 Q_D(QColorMapLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QColorMapLegendMarkerPrivate::QColorMapLegendMarkerPrivate(QColorMapLegendMarker *q, QColorMapSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series)
             {
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(updated()));
             }
             QColorMapLegendMarkerPrivate::~QColorMapLegendMarkerPrivate()
             {
             }
             QAbstractSeries* QColorMapLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QColorMapLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QColorMapLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 if (!m_customLabel && (m_item->label() != m_series->name())) {
                     m_item->setLabel(m_series->name());
                     labelChanged = true;
                 }
                 QBrush emptyBrush;
                 if (!m_customBrush
                         && (m_item->brush() == emptyBrush
                             || m_item->brush().color() != m_series->pen().color())) {
                     m_item->setBrush(QBrush(m_series->pen().color()));
                     brushChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
             }
             //#include "moc_qcolormaplegendmarker.cpp"
             //#include "moc_qcolormaplegendmarker_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/legend/qcolormaplegendmarker.h +21 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the ColorMapChart API
+            --  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Hugo Winter
+            --                     Mail : hugo.winter@lpp.polytechnique.fr
+            ----------------------------------------------------------------------------*/
             #ifndef QCOLORMAPLEGENDMARKER_H
             #define QCOLORMAPLEGENDMARKER_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QLegendMarker>
             #include <QtCharts/QColorMapSeries>
             QT_CHARTS_BEGIN_NAMESPACE
             class QColorMapLegendMarkerPrivate;
             class QColorMapLegendMarker : public QLegendMarker
             {
                     Q_OBJECT
             public:
                 explicit QColorMapLegendMarker(QColorMapSeries *series, QLegend *legend, QObject *parent = 0);
                 virtual ~QColorMapLegendMarker();
                 virtual LegendMarkerType type() { return LegendMarkerTypeColorMap; }
                 // Related series
                 virtual QColorMapSeries* series();
             protected:
                 QColorMapLegendMarker(QColorMapLegendMarkerPrivate &d, QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QColorMapLegendMarker)
                 Q_DISABLE_COPY(QColorMapLegendMarker)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCOLORMAPLEGENDMARKER_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