HG_REPOSITORIES/LPP/users/hugo/ColorMapChart Commit - r5:d44370b2cb06

memory leak fixed

winter -

r5:d44370b2cb06 default

parent child

Context file:

r5:d44370b2cb06

Collapse all files

src/charts/axis/colorbaraxis/chartcolorbaraxisy.cpp +3 -2

             #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
+                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
+                    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/colormapchart/colormapchart.cpp +6 -4

             #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_currentplotArea(QRectF())
-                  m_grid(Q_NULLPTR)
             {
                 //    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();
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->setClipRect(clipRect);
                 QRectF plotAreaRect = m_series->chart()->plotArea();
                 if(m_currentplotArea !=plotAreaRect)
                 {
                     m_currentplotArea = plotAreaRect;
-                    m_grid = m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),QColorMapSeries::LastPixel);
+                    m_grid.reserve(plotAreaRect.width()*plotAreaRect.height());
+                    m_grid.resize(plotAreaRect.width()*plotAreaRect.height());
+                    m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),m_grid, QColorMapSeries::LastPixel);
                     addColorBar(plotAreaRect);
                 }
                 QImage colorMapImage(plotAreaRect.width(),plotAreaRect.height(),QImage::Format_RGB32);
                 //http://doc.qt.io/qt-4.8/qimage.html#details :Warning: This will create a QImage with uninitialized data. Call fill() to fill the image with an appropriate pixel value before drawing onto it with QPainter.
                 colorMapImage.fill(QColor(Qt::white).rgb());
                 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 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_p.h +1 -1

             #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);
                 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;
-                QVector<double> * m_grid;
+                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/qcolormapseries.cpp +4 -8

             #include "qcolormapseries.h"
             #include <private/qcolormapseries_p.h>
             #include <private/abstractdomain_p.h>
             #include <QtCharts/QValueAxis>
             #include <private/colormapchart_p.h>
             #include <QtCharts/QColorMapLegendMarker>
             #include <private/charthelpers_p.h>
             #include <private/qchart_p.h>
             #include <QtGui/QPainter>
             //#include <algorithm>
             #include <cmath>
             #include "qcolorbaraxis.h"
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QColorMapSeries::QColorMapSeries(QObject *parent)
                 : QAbstractSeries(*new QColorMapSeriesPrivate(this), parent)
             {
             }
             /*!
                 \internal
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChart instance ownerships is transferred.
             */
             QColorMapSeries::QColorMapSeries(QColorMapSeriesPrivate &d, QObject *parent)
                 : QAbstractSeries(d, parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChart instances are owned by those,
                 and are destroyed when QChart instances are destroyed.
             */
             QColorMapSeries::~QColorMapSeries()
             {
             }
             /*!
                 \fn virtual SeriesType QBoxPlotSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             QAbstractSeries::SeriesType QColorMapSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeColorMap;
             }
             /*!
                 Adds data part \a dataPart to the series.\n
                 If \a copy is true, adds a copy of the data part instead.
              */
             void QColorMapSeries::append(ColorMapDataPart* dataPart, bool copy)
             {
                 Q_D(QColorMapSeries);
                 if(copy)
                     d->m_dataParts << new ColorMapDataPart(dataPart);
                 else
                     d->m_dataParts  << dataPart;
                 d->recomputeDataRange();
                 emit dataPartAdded(d->m_dataParts.count() - 1);
             }
             /*!
                This is an overloaded function.\n
                Adds data parts \a dataParts to the series.\n
                 If \a copy is true, adds a copy of the data part instead.
              */
             void QColorMapSeries::append(const QList<ColorMapDataPart*> &dataParts, bool copy)
             {
                 foreach (ColorMapDataPart* dataPart , dataParts)
                     append(dataPart,copy);
             }
             /*!
                 Returns number of data parts within series.
             */
             int QColorMapSeries::count() const
             {
                 Q_D(const QColorMapSeries);
                 return d->m_dataParts.count();
             }
             /*!
                 Stream operator for adding a data part \a point to the series.
                 \sa append()
             */
             QColorMapSeries &QColorMapSeries::operator <<(const ColorMapDataPart &dataPart)
             {
                 append(new ColorMapDataPart(dataPart));
                 return *this;
             }
             /*!
                 Stream operator for adding a vector of data parts \a dataParts to the series.
                 \sa append()
             */
             QColorMapSeries &QColorMapSeries::operator <<(const QList<ColorMapDataPart*> &dataParts)
             {
                 append(dataParts);
                 return *this;
             }
             /*!
                 Returns a ColorMapData part containing a uniform grid of data points to be mapped in a ColorMapChart.\n
                 The rectangle of data returned is determined by \a width and \height,\n
                 from the position \a xpos , \a ypos (starting at the top left corner of the plot area).\n
                 When there are more points than pixels, \a strategy is applied to determine which to choose.
             */
-            QVector<double> *QColorMapSeries::getUniformGrid(int xpos, int ypos,int width, int height, QColorMapSeries::Strategy strategy)
+            void QColorMapSeries::getUniformGrid(int xpos, int ypos,int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy)
             {
                 Q_D(QColorMapSeries);
-                return d->getUniformGrid(xpos, ypos,width,height, strategy);
+                d->getUniformGrid(xpos, ypos,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;
             }
-            QVector<double> *QColorMapSeriesPrivate::getUniformGrid(int xpos, int ypos,  int width, int height, QColorMapSeries::Strategy strategy)
+            void QColorMapSeriesPrivate::getUniformGrid(int xpos, int ypos,  int width, int height, QVector<double> &grid, QColorMapSeries::Strategy strategy)
             {
-                QVector<double> *grid = new QVector<double>(width*height);
                 double dx = (m_maxX - m_minX)/(double)width;
                 double dy = (m_maxY - m_minY)/(double)height;
                 int x=0;
                 int y=0;
             QVector<Point3D> cluster;
             cluster.reserve(height*width/1000);
-                for (auto cell= grid->begin();cell<grid->end();++cell)
+                for (auto cell= grid.begin();cell<grid.end();++cell)
                 {
                     cluster.resize(0);
                     this->buildCluster(x,y,dx,dy,cluster);
                     if(strategy == QColorMapSeries::LastPixel)
                         *cell=this->clusterStrategyLast(cluster);
                     else if(strategy == QColorMapSeries::MeanPixel)
                         *cell=this->clusterStrategyMean(cluster);
                     else if(strategy == QColorMapSeries::MedianPixel)
                         *cell=this->clusterStrategyMedian(cluster);
                     if(x<width-1)
                     {
                         x++;
                     }
                     else
                     {
                         x=0;
                         y++;
                     }
                 }
-                return grid;
             }
             /*!
                 Recompute the data range on X, Y and Z axes each time a ColorMapDataPart is added to the series.\n
                 The minimum distance between 2 adjacent values on X and Y axis is added to the maximum on X and Y respectively\n
                 in order to take account of the width of the last element.
             */
             void QColorMapSeriesPrivate::recomputeDataRange()
             {
                 //TODO : if non empty
                 m_minX = m_dataParts.first()->timesSeries().first();
                 m_maxX = m_dataParts.last()->timesSeries().last();
                 m_minY = m_dataParts.last()->ySeries().last();
                 m_maxY = m_dataParts.last()->ySeries().first();
                 m_minZ = m_dataParts.first()->dataSeries().first();
                 m_maxZ = m_dataParts.last()->dataSeries().last();
                 double minDeltaX=m_maxX-m_minX;
                 double minDeltaY=m_minY-m_maxY;
                 foreach(ColorMapDataPart* datapart, m_dataParts)
                 {
                     m_minY = qMin(datapart->ySeries().first(),m_minY);
                     m_maxY = qMax(datapart->ySeries().last(),m_maxY);
                     for(int i=1;i<datapart->timesSeries().size();i++)
                     {
                         double newDeltaX=datapart->timesSeries()[i]-datapart->timesSeries()[i-1];
                         minDeltaX=qMin(minDeltaX,newDeltaX);
                     }
                     for(int i=1;i<datapart->ySeries().size();i++)
                     {
                         double newDeltaY=datapart->ySeries()[i]-datapart->ySeries()[i-1];
                         minDeltaY=qMin(minDeltaY,newDeltaY);
                     }
                     for (int i = 0; i < datapart->dataSeries().count(); i++)
                     {
                         double z = datapart->dataSeries().at(i);
                         m_minZ = qMin(m_minZ, z);
                         m_maxZ = qMax(m_maxZ, z);
                     }
                 }
                 m_maxX+=minDeltaX;
                 m_maxY+=minDeltaY;
             }
             /*!
                 Returns the last value (bottom right Z value) of a \a cluster of points passed as argument.
             */
             double QColorMapSeriesPrivate::clusterStrategyLast(QVector<Point3D>& cluster)
             {
                 if(!cluster.isEmpty())
                     return cluster.last().value();
                 return 0;
             }
             /*!
                 Returns the mean value (mean Z value) of a \a cluster of points passed as argument.
             */
             double QColorMapSeriesPrivate::clusterStrategyMean(QVector<Point3D>& cluster)
             {
                 if(!cluster.isEmpty())
                 {
                     double sum=0;
                     int count =0;
                     for(int i =0;i<cluster.size();i++)
                     {
                         if(!isnan(Point3D(cluster.at(i)).value()))
                         {
                             sum+= Point3D(cluster.at(i)).value();
                             count++;
                         }
                     }
                     return (sum/count);
                 }
                 return 0;
             }
             /*!
                 Returns the median value (median Z value) of a \a cluster of points passed as argument.
             */
             double QColorMapSeriesPrivate::clusterStrategyMedian(QVector<Point3D>& cluster)
             {
                 if(!cluster.isEmpty())
                 {
                     QVector<double> *copy = new QVector<double>();
                     for(int i =0;i<cluster.size();i++)
                     {
                         if(!isnan(Point3D(cluster.at(i)).value()))
                             copy->append(Point3D(cluster.at(i)).value());
                     }
                     if(!copy->isEmpty())
                     {
                         std::sort(copy->begin(), copy->end());
                         if(copy->count() & 1) // odd
                         {
                             int middle = (copy->count()+1)/2;
                             return copy->at(middle-1);
                         }
                         else //even
                         {
                             int middle = copy->count()/2;
                             return (copy->at(middle-1)+copy->at(middle))/2;
                         }
                     }
                 }
                 return 0;
             }
             /*!
                 Computes which data points correspond to the given position and returns the in a \a cluster.
             */
             void  QColorMapSeriesPrivate::buildCluster(int xpos, int  ypos, double dx, double dy, QVector<Point3D>& cluster)
             {
                 foreach(ColorMapDataPart *dataPart, m_dataParts)
                 {
                     QPair<int,int> xRange = dataPart->getRange(dataPart->timesSeries(),m_minX+xpos*dx,m_minX+(xpos+1)*dx);
                     QPair<int,int> yRange = dataPart->getRange(dataPart->ySeries(),m_maxY-(ypos+1)*dy,m_maxY-ypos*dy);
                     int timeSeriesSize = dataPart->timesSeries().size();
                     if(xRange.first != xRange.second && yRange.first != yRange.second)
                     {
                         for(int i =xRange.first+1;i<xRange.second;i++)
                         {
                             qreal xval=dataPart->timesSeries()[i];
                             for(int j=yRange.first+1;j<yRange.second;j++)
                             {
                                 qreal yval=dataPart->ySeries()[j];
                                 qreal val=dataPart->dataSeries()[ i + (timeSeriesSize * j)];
                                 cluster.append(Point3D(xval,yval,val));
                             }
                         }
                     }
                 }
             }
             void QColorMapSeriesPrivate::initializeAnimations(QtCharts::QChart::AnimationOptions options,
                                                               int duration, QEasingCurve &curve)
             {
                 //    ColorMapChart *item = static_cast<ColorMapChart *>(m_item.data());
                 //    Q_ASSERT(item);
                 //    if (item->animation())
                 //        item->animation()->stopAndDestroyLater();
                 //    if (options.testFlag(QChart::SeriesAnimations))
                 //        item->setAnimation(new XYAnimation(item, duration, curve));
                 //    else
                 //        item->setAnimation(0);
                 QAbstractSeriesPrivate::initializeAnimations(options, duration, curve);
             }
             #include "moc_qcolormapseries.cpp"
             #include "moc_qcolormapseries_p.cpp"
             QT_CHARTS_END_NAMESPACE

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

             #ifndef QCOLORMAPSERIES_H
             #define QCOLORMAPSERIES_H
             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QAbstractSeries>
             #include <QtGui/QPen>
             #include <QtGui/QBrush>
             #include "colormapdatapart.h"
             QT_CHARTS_BEGIN_NAMESPACE
             class QColorMapSeriesPrivate;
             class QT_CHARTS_EXPORT QColorMapSeries : public QAbstractSeries
             {
                 Q_OBJECT
             //    Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
             //    Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
             //    Q_PROPERTY(QString pointLabelsFormat READ pointLabelsFormat WRITE setPointLabelsFormat NOTIFY pointLabelsFormatChanged)
             //    Q_PROPERTY(bool pointLabelsVisible READ pointLabelsVisible WRITE setPointLabelsVisible NOTIFY pointLabelsVisibilityChanged)
             //    Q_PROPERTY(QFont pointLabelsFont READ pointLabelsFont WRITE setPointLabelsFont NOTIFY pointLabelsFontChanged)
             //    Q_PROPERTY(QColor pointLabelsColor READ pointLabelsColor WRITE setPointLabelsColor NOTIFY pointLabelsColorChanged)
             //    Q_PROPERTY(bool pointLabelsClipping READ pointLabelsClipping WRITE setPointLabelsClipping NOTIFY pointLabelsClippingChanged)
             protected:
                 explicit QColorMapSeries(QColorMapSeriesPrivate &d, QObject *parent =0);
             public :
                 enum Strategy
                 {
                     LastPixel,
                     MeanPixel,
                     MedianPixel
                 };
                 explicit QColorMapSeries(QObject *parent =0);
                 ~QColorMapSeries();
                 QAbstractSeries::SeriesType type() const;
                 void append(ColorMapDataPart* dataPart, bool copy=true);
                 void append(const QList<ColorMapDataPart *> &dataParts, bool copy=true);
                 int count() const;
                 QVector<ColorMapDataPart*> dataParts() const;
                 QColorMapSeries &operator << (const ColorMapDataPart &dataPart);
                 QColorMapSeries &operator << (const QList<ColorMapDataPart *> &dataParts);
-                QVector<double> *getUniformGrid(int xpos, int ypos,int width, int height, Strategy strategy);
+                void getUniformGrid(int xpos, int ypos,int width, int height, QVector<double> &grid, Strategy strategy);
-                // QVector<double> *getUniformGrid(int width, int height, Strategy lambda);
+                // 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 +1 -1

             #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;
-                QVector<double> *getUniformGrid(int xpos, int ypos,int width, int height, QColorMapSeries::Strategy strategy);
+                void getUniformGrid(int xpos, int ypos,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;
                 void recomputeDataRange();
                 double clusterStrategyLast(QVector<Point3D>& cluster);
                 double clusterStrategyMean(QVector<Point3D> &cluster);
                 double clusterStrategyMedian(QVector<Point3D>& cluster);
                 void buildCluster(int xpos,int  ypos, double dx,double dy,QVector<Point3D>& cluster);
                 Q_DECLARE_PUBLIC(QColorMapSeries)
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QCOLORMAPSERIES_P_H

General Comments 0

Write
Preview

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

No TODOs yet

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

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