HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2902:1f7564788f9d

Some perfs improvments....

jeandet -

r2902:1f7564788f9d 5.7

parent child

Context file:

r2902:1f7564788f9d

src/charts/colormapchart/colormapchart.cpp +15 -4

             /*------------------------------------------------------------------------------
             --  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 <QColorBarAxis>
             #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_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)
                 painter->save();
-                //m_series->setUseOpenGL();
+                m_series->setUseOpenGL();
                 QRectF plotAreaRect = m_series->chart()->plotArea();
                 QRectF clipRect = mapColorMapToPlotArea();
                 painter->setClipRect(clipRect);
                 if(m_currentClipRect !=clipRect)
                 {
                     m_currentClipRect = clipRect;
-                    m_grid.reserve(clipRect.width()*clipRect.height());
+                    m_grid.resize(clipRect.width()*clipRect.height()); //faster than reserve
-                    m_grid.resize(clipRect.width()*clipRect.height());
                     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(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);
+                if(Q_UNLIKELY(widthToPaint < 0))
+                    widthToPaint = 0;
+                if(Q_UNLIKELY(heightTopaint < 0))
+                        heightTopaint = 0;
+                 QSizeF size = QSize(widthToPaint,heightTopaint);
+                if(Q_UNLIKELY(pointX < 0))
+                    pointX = 0;
+                if(Q_UNLIKELY(pointY < 0))
+                    pointY = 0;
                 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));
                     }
                 }
             }
             /*!
                 Returns the predefined QLinearGradient corresponding to the \a gradientType passed as argument.
             */
             QLinearGradient ColorMapChart::createColorMapGradient(GradientType gradientType)
             {
                 QLinearGradient gradient(0,0,1,100);
                 switch(gradientType)
                 {
                 case Rainbow :
                     gradient.setColorAt(1.0,Qt::darkRed);
                     gradient.setColorAt(0.8,Qt::red);
                     gradient.setColorAt(0.6,Qt::yellow);
                     gradient.setColorAt(0.4,Qt::green);
                     gradient.setColorAt(0.2,Qt::cyan);
                     gradient.setColorAt(0.0,Qt::blue);
                     break;
                 case CyclingRainbow :
                     gradient.setColorAt(1.0,Qt::red);
                     gradient.setColorAt(0.8,Qt::yellow);
                     gradient.setColorAt(0.6,Qt::green);
                     gradient.setColorAt(0.4,Qt::cyan);
                     gradient.setColorAt(0.2,Qt::blue);
                     gradient.setColorAt(0.0,Qt::magenta);
                     break;
                 case BlackAndWhite :
                     gradient.setColorAt(1.0, Qt::black);
                     gradient.setColorAt(0.0, Qt::white);
                     break;
                 case ReverseBlackAndWhite :
                     gradient.setColorAt(1.0, Qt::white);
                     gradient.setColorAt(0.0, Qt::black);
                     break;
                 default:
                     break;
                 }
                 return gradient;
             }
             /*!
                 Changes the type of gradient used to paint the ColorMap.
             */
             void ColorMapChart::changeGradient(GradientType gradientType)
             {
                 if(m_gradientType == gradientType)
                     return;
                 else
                     m_gradientType = gradientType;
                 emit gradientTypeChanged();
             }
             /*!
                 Creates a color table corresponding to the  gradient type currently selected.
             */
             void ColorMapChart::populateColorTable()
             {
                 QLinearGradient gradient = createColorMapGradient(m_gradientType);
                 QGradientStops colorStops = gradient.stops();
                 for(int i=0;i<nbOfColors;i++)
                 {
                     double colorIndex = (double)i/nbOfColors;
                     for(int k =0;k<colorStops.size()-1;k++)
                     {
                         QGradientStop lowerBound = colorStops.at(k);
                         QGradientStop upperBound = colorStops.at(k+1);
                         if(colorIndex >= lowerBound.first && colorIndex < upperBound.first)
                         {
                             double ratio = (colorIndex-lowerBound.first)/(upperBound.first - lowerBound.first);
                             int red      = (int)((1-ratio)*lowerBound.second.red() + ratio*upperBound.second.red());
                             int green = (int)((1-ratio)*lowerBound.second.green() + ratio*upperBound.second.green());
                             int blue   = (int)((1-ratio)*lowerBound.second.blue() + ratio*upperBound.second.blue());
                             m_colorTable->append(qRgb(red, green, blue));
                             break;
                         }
                         else
                         {
                             if(k==colorStops.size()-2)
                             {
                                 m_colorTable->append(qRgb(colorStops.at(colorStops.size()-1).second.red(), colorStops.at(colorStops.size()-1).second.green(), colorStops.at(colorStops.size()-1).second.blue()));
                             }
                         }
                     }
                 }
             }
             //handlers
             void ColorMapChart::handlePointAdded(int index)
             {
             }
             void ColorMapChart::handlePointRemoved(int index)
             {
             }
             void ColorMapChart::handlePointsRemoved(int index, int count)
             {
             }
             void ColorMapChart::handlePointReplaced(int index)
             {
             }
             void ColorMapChart::handlePointsReplaced()
             {
             }
             void ColorMapChart::handleDomainUpdated()
             {
             }
             bool ColorMapChart::isEmpty()
             {
             }
             #include "moc_colormapchart_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/colormapchart/colormapchart_p.h +8 -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();
+            protected:
+            //    void updateGeometry();
+            //    void mousePressEvent(QGraphicsSceneMouseEvent *event);
+            //    void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
+            //    void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
+            //    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+            //    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
             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_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

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