Здравствуйте,
разработка идёт в версии Qt 5.6.2 + mingw-w64, ОС Windows 10 64-bit.
Вывод данных выполняется с помощью QGraphicsView, QGraphicsScene и QOpenGLWidget.
Запускается процедура отображения данных нажатием кнопки "Multiple files" и управление
передаётся в рабочую нить. В нити формируется QImage из которого получается QPixmap и выводится на экран в цикле.
Если k<2 (место _1_), то на глаз ещё можно наблюдать за тем, как отрисовывается картинка т.е. QPixmap . Если k<100, то
возникает ощущение, что картинка отрисовывается не полностью, а при k<500 всё наглядит как будто одна картинка
не отрисовалась полностью и начинает отрисовываться следующая.
Возникает вопрос, как узнать, что QPixmap отрисовался полностью и чтобы картинки отрисовывались одна после другой?

void MainWindow::displayPixmap(const QPixmap &pixmap_data)
{
    QString str;
    counter++;
    if(counter==1)
        (0);
    else {
        pScene->removeItem(graphicspixmapItem);
        delete graphicspixmapItem;
    }
    graphicspixmapItem=pScene->addPixmap(pixmap_data);
    return;
}

void MainWindow::startWorkInAThread()
{
   /* WorkerThread * */workerThread = new WorkerThread;
    connect(workerThread, &WorkerThread::resultReady,this, &MainWindow::appendtoLogListBox);
    connect(workerThread, &WorkerThread::sendData, this, &MainWindow::displayPixmap);
    connect(workerThread,SIGNAL(finished()), workerThread,SLOT(deleteLater()) );
    workerThread->initInnerObjects();
    workerThread->start();
    return;
}

void MainWindow::initializeGL()
{
    QGraphicsView* pView =ui->graphicsView;


    QRect viewRect = pView->rect();
    QRectF viewRectF(viewRect);

    pScene = new QGraphicsScene(viewRectF,this);

    pView->setScene(pScene);

    pOpenGLWidget = new QOpenGLWidget( this );
    QSurfaceFormat format_srf;
    format_srf.setDepthBufferSize(32);
    format_srf.setStencilBufferSize(16);
    format_srf.setVersion(3,2);
    format_srf.setProfile( QSurfaceFormat::CoreProfile );

    pOpenGLWidget->setFormat(format_srf);

    pView->setViewport(pOpenGLWidget);
    return;
}

class WorkerThread : public QThread
{
    Q_OBJECT
public:
    QMutex mutex;
    QWaitCondition wtc_worker2;
    void initInnerObjects()
    {
        wait_cnd=false;
        lock_cnd=false;
        fileSize=0;
    }
    void run() Q_DECL_OVERRIDE {
        QString result;
        forever {
            mutex.lock();
            qDebug() << "--- Worker: run() func, after lock call";
            wait_cnd=wtc_worker2.wait(&mutex,/*5000*/one_and_a_half_hour_wait);
            if(false==wait_cnd)
            {
                mutex.unlock();
                continue;
            }
            else if(true==wait_cnd)
            {
//                prepare_data();
                prepare_generate_data();
                result=QString(tr("--- wait_cnd is true"));
                do_send_result(result);
            }
            qDebug() << "--- wait_cnd is " << wait_cnd;
            qDebug() << "--- Worker: run() func, after wait call";
            mutex.unlock();
        }
    }
private:
    void prepare_generate_data()
    {
        QString str;
       // str.append(" --- slot button6Clicked() ");
       // appendtoLogListBox(str);
        QString filePath;
        QFile file;
        QDataStream dstrm;
        int data_quant=0;
        std::vector<unsigned short> buffer_vect;
        QSize rct_size(320,256);

        QPixmap myPixmap;

        QImage loc_img(rct_size,QImage::Format_RGB32 /*QImage::Format_RGBX8888*/);

        QRgb *line;

        pixmap_vect.clear();

        QBuffer hr;

        unsigned long/* long */ start_time=GetTickCount();
        for(int k=0;k<2;k++) // (_1_)
        for(int i=0;i<256;i++)
        {
            for(int y=0;y<loc_img.height();y++)
            {
               // QRgb *line=reinterpret_cast<QRgb*>(loc_img.scanLine(y));
                line=static_cast<QRgb *>(static_cast<void *>(loc_img.scanLine(y)));
                for(int x=0;x<loc_img.width();x++)
                {
                    if(x<256-i)
                        line[x]=qRgb(x,x,x);
                    else
                        line[x]=qRgb(0x80,0x80,0x80);
                }
            }
            pixmap_copy=QPixmap::fromImage( loc_img);
            if(b_counter==false)
            {
                b_counter=true;
            }
            else
            {
               // (_2_)
               // ::Sleep(1);
            }
            emit sendData(pixmap_copy);
        }

        unsigned long/* long */ end_time=GetTickCount();
        unsigned long/* long */ loc_delta=end_time-start_time;
         str=QString(tr("  --- loc_delta = %1")).arg(loc_delta);
         do_send_result(str);
        loc_list.clear();
        return;
    }
public /*slots*/:
    void launch_threadfunc()
    {
        wtc_worker2.wakeOne();
    }
signals:
    void resultReady(const QString &s);
    void sendData(const QPixmap &pixmap);
public slots:
    void do_send_result(const QString &info_msg)
    {
        emit resultReady(info_msg);
    }
...
};