Qt design and performance issue - c++

Question

I am having some troubles while designing a C++ QT application. Among other things, the application displays the beams (or rays) of some lasers (each laser is composed by around 700 segments starting from the same position and spaced by a constant angle, and a small circle at the other end of the segment materializing the end point). Here is a drafting of one laser I found on the internet . Most of the time I have to display 12 lasers (so 12*700 segments), at 30 frames per second. My first implementation works, but it takes a huge amount of CPU (>12%) and the GUI lags a lot.
What I did for the implementation is quite simple: I have a LaserModel class, filled by a thread receiving TCP beacons; A MainWindow class with a QGraphicsScene* _scene; and a LaserView class, whose instances are added to the scene. A signal at 30fps triggers the passage of the datas from the model to the view using the setData() method.
I did a performance analysis and it seems that 80% of the work of the gui (There is way more than just displaying these lasers) is done by the drawLine(/*…*/) methods.
I am sure that there is a more elegant and efficient way to do that.
First the setData(/*…*/) method seems quite ugly to me. I know that I should probably emit a signal (like laserHasChanged(const LaserModel&)) from the model and catch it in the view (with a slot onNewData(const LaserModel&)) but for the performance point of view it seems worse (but it looks better for the coupling point of view, especially because in the future I will probably also display a property tree with the configuration of the lasers(so another view of the same model)).
More important I am not quite sure about what the drawLine(const QLine& line) does, but this part of the code should just “render” the line, not recreate it.
So the question is: how can I drastically improve the performances of the rendering? Especially the drawline part of the paint() method?
Here is the relevant code:
class LaserView : public QGraphicsItem {
/* c-tor, d-tor, members... */
std::vector<Beam> _beams;
QRectF _boundingRect;
void setData(const Sim::Pose& pose, const std::vector<Beam>& beams, const QRectF& boundingRect, const bool& showMaxRanges) {
/*...*/
_beams = beams;
_boundingRect = boundingRect;
}
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *) {
painter->setPen(_color);
// Display only the beams that are stopped by an obstacle
if (!_showMaxRanges) {
for (unsigned int i = 0 ; i < _beams.size() -1 ; i++) {
if (!_beams[i].endPointType == laserBeamEndPointType::MAX_RANGE) {
_beams[i]._line.setLine(_pose.x, _pose.y, _beams[i]._mapEndPose.x(), _beams[i]._mapEndPose.y());
painter->drawLine(_beams[i]._line);
}
}
}
// Display all beams
else {
for (unsigned int i = 0 ; i < _beams.size() -1 ; i++) {
_beams[i]._line.setLine(_pose.x, _pose.y, _beams[i]._mapEndPose.x(), _beams[i]._mapEndPose.y());
painter->drawLine(_beams[i]._line);
}
}
// Draw a small circle to visualize easily the end points of the beams when they stop against an obstacle
for (unsigned int i = 0; i < _beams.size() - 1 ; i++) {
// Draw the end point in blue if the obstacle is reflective
if (_beams[i].endPointType == laserBeamEndPointType::REFLECTIVE_OBJECT) {
painter->setBrush(REFLETIVE_END_POINT_COLOR);
painter->drawEllipse(_beams[i]._mapEndPose, END_POINT_SIZE, END_POINT_SIZE);
}
// Draw the end point in red if the obstacle is NOT reflective
else if (_beams[i].endPointType == laserBeamEndPointType::NOT_REFLECTIVE_OBJECT) {
painter->setBrush(NOT_REFLETIVE_END_POINT_COLOR);
painter->drawEllipse(_beams[i]._mapEndPose, END_POINT_SIZE, END_POINT_SIZE);
}
}
}
}

Answer 1

You are drawing one line at a time, one ellipse at a time, switching between brushes in the process. There is a significant overhead with these operations (at least with Qt4). You can do better by aggregating these calls to just 3 drawing calls.
you have
std::vector<QlineF> lines;
std::vector<QRectF> ellipse_refl_rects;
std::vector<QRectF> ellipse_non_refl_rects;
Rather than drawing a line add to lines collection. Same for ellipses.
Then at the end you have
if(!lines.isempty())
{
painter->drawLines(&lines[0], lines.size());
}
if(!ellipse_refl_rects.isempty())
{
painter->setBrush(REFLETIVE_END_POINT_COLOR);
painter->drawEllipses(&ellipse_refl_rects[0], ellipse_refl_rects.size());
}
if(!ellipse_non_refl_rects.isempty())
{
painter->setBrush(NOT_REFLETIVE_END_POINT_COLOR);
painter->drawEllipses(&ellipse_non_refl_rects[0], ellipse_non_refl_rects.size());
}