|
|
#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(false)
|
|
|
{
|
|
|
// QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
|
|
|
// QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
|
|
|
// QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
|
|
|
// QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
|
|
|
// QObject::connect(series, SIGNAL(pointsRemoved(int, int)), this, SLOT(handlePointsRemoved(int, int)));
|
|
|
// QObject::connect(this, SIGNAL(clicked(Point3D)), series, SIGNAL(clicked(Point3D)));
|
|
|
// QObject::connect(this, SIGNAL(hovered(Point3D,bool)), series, SIGNAL(hovered(Point3D,bool)));
|
|
|
// QObject::connect(this, SIGNAL(pressed(Point3D)), series, SIGNAL(pressed(Point3D)));
|
|
|
// QObject::connect(this, SIGNAL(released(Point3D)), series, SIGNAL(released(Point3D)));
|
|
|
// QObject::connect(this, SIGNAL(doubleClicked(Point3D)), series, SIGNAL(doubleClicked(Point3D)));
|
|
|
|
|
|
connect(this,SIGNAL(gradientTypeChanged()), this, SLOT(populateColorTable()));
|
|
|
|
|
|
m_colorTable = new QVector<QRgb>();
|
|
|
m_colorTable->reserve(nbOfColors);
|
|
|
populateColorTable();
|
|
|
}
|
|
|
|
|
|
void ColorMapChart::setDirty(bool dirty)
|
|
|
{
|
|
|
m_dirty = dirty;
|
|
|
}
|
|
|
|
|
|
QRectF ColorMapChart::boundingRect() const
|
|
|
{
|
|
|
return m_rect;
|
|
|
}
|
|
|
|
|
|
void ColorMapChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
{
|
|
|
Q_UNUSED(widget)
|
|
|
Q_UNUSED(option)
|
|
|
|
|
|
m_series->setUseOpenGL();
|
|
|
|
|
|
painter->save();
|
|
|
|
|
|
QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
|
|
|
painter->setClipRect(clipRect);
|
|
|
|
|
|
QRectF plotAreaRect = m_series->chart()->plotArea();
|
|
|
QImage colorMapImage(plotAreaRect.width(),plotAreaRect.height(),QImage::Format_RGB32);
|
|
|
//http://doc.qt.io/qt-4.8/qimage.html#details :Warning: This will create a QImage with uninitialized data. Call fill() to fill the image with an appropriate pixel value before drawing onto it with QPainter.
|
|
|
colorMapImage.fill(QColor(Qt::white).rgb());
|
|
|
|
|
|
QElapsedTimer timer;
|
|
|
timer.start();
|
|
|
|
|
|
QVector<double> * grid = m_series->getUniformGrid(0,0,plotAreaRect.width(),plotAreaRect.height(),QColorMapSeries::LastPixel);
|
|
|
|
|
|
int msec = timer.elapsed();
|
|
|
int msec2 = 0+msec;
|
|
|
|
|
|
double maxZ = m_series->maxZ();
|
|
|
double minZ = m_series->minZ();
|
|
|
double rangeZ = maxZ - minZ;
|
|
|
|
|
|
int imageWidth = colorMapImage.width();
|
|
|
int imageHeight = colorMapImage.height();
|
|
|
|
|
|
for(int i=0;i<imageWidth;i++)
|
|
|
{
|
|
|
for(int j=0;j<imageHeight;j++)
|
|
|
{
|
|
|
double value = grid->at(i+j*(imageWidth));
|
|
|
double pix=((value-minZ)/rangeZ);
|
|
|
int indexInColorTable = pix*(nbOfColors-1);
|
|
|
colorMapImage.setPixel(i,j,m_colorTable->at(indexInColorTable));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
addColorBar(plotAreaRect);
|
|
|
|
|
|
|
|
|
painter->drawImage(clipRect,colorMapImage);
|
|
|
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
|
|
|
|
