void MainWindow::updateData(QString data) { QTime t; t.start(); m_model.loadFromCSV( data ); qDebug("Time for loading data %s: %d ms", data.toLatin1().constData(), t.elapsed()); t.restart(); QSize size1 = QSize( 200, 200 ); QSize size2 = QSize( 800, 800 ); m_pix1 = drawIntoPixmap( size1, m_chart ); m_pix2 = drawIntoPixmap( size2, m_chart ); qDebug("Time for drawing pixmap %s: %d ms", data.toLatin1().constData(), t.elapsed()); t.restart(); m_lines->setModel( &m_model ); qDebug("Time for setting model %s: %d ms", data.toLatin1().constData(), t.elapsed()); t.restart(); m_smallChart1->setPixmap( m_pix1 ); m_smallChart2->setPixmap( m_pix2 ); m_smallChart1->show(); m_smallChart2->show(); qDebug("Time for setting pixmap %s: %d ms", data.toLatin1().constData(), t.elapsed()); t.restart(); }
void PlayerHandler::computeBaseState() { static QTime reloj=QTime::currentTime(); static float xant; static float yant; // float x = posIface->data->pose.pos.y*1000.; // float z = posIface->data->pose.pos.x*1000.; // client->Read(); float x = pos->GetYPos()*1000.; float z = pos->GetXPos()*1000.; float dl = float ( x - xant ); float dr = float ( z - yant ); xant = bState.x; yant = bState.z; float incA = sqrt(dl*dl+dr*dr); mutex->lock(); //Compute increments through robot kinematics client->Read(); bState.adv = incA; // bState.rotV = -posIface->data->velocity.yaw; bState.rotV = -pos->GetYawSpeed(); bState.advV = incA / (float) reloj.restart() * 1000; bState.rotV = -pos->GetYawSpeed() / (float) reloj.restart() * 1000; bState.isMoving = (bState.advV!=0 or bState.rotV!=0); //position // bState.alpha = posIface->data->pose.yaw - alfa; bState.alpha = pos->GetYaw(); bState.x = ( r00*x + r01*z ) - (r00*t0 + r01*t1); bState.z = ( r10*x + r11*z ) - (r10*t0 + r11*t1); // qDebug()<<bState.x<<bState.z<<rtod(bState.alpha); mutex->unlock(); }
QGraphicsScene * ClusteredArranger::arrange(SegmentList const & segments) const { QGraphicsScene * arrangement = new QGraphicsScene(); QTime time; time.start(); // determine background Segment * background = determineBackground(segments); SegmentList segmentsWOBack = removeBackground(segments, background); arrangement->setBackgroundBrush(QBrush(QColor(background->color().toQRgb()))); segmentsWOBack.calculateFeatureVariances(); // initialize layout //initializeLayout(segmentsWOBack, segmentsWOBack.featX(), segmentsWOBack.featY()); initializeLayout(segmentsWOBack, xAxisBox->currentIndex(), yAxisBox->currentIndex()); // find clusters time.restart(); QList<SegmentList> clusters = meanShift(segmentsWOBack); qDebug("Segments clustered in %f seconds", time.restart()/1000.0); qDebug(" %d clusters found", clusters.size()); // refine clusters //int counter = 0; foreach (SegmentList cluster, clusters) { if (clusterBox->currentIndex() == 0) { refineLayoutCircles(cluster); } else if (clusterBox->currentIndex() == 1) { refineLayoutPiles(cluster); } // debug output /*QGraphicsScene scene; scene.setBackgroundBrush(QBrush(QColor(255, 255, 255))); foreach(Segment * const segment, cluster) { scene.addItem(segment->toQGraphicsItem()); // without the following line QPainter tends to crash scene.width(); } ++counter; saveScene(&scene, QString("Test%1.png").arg(counter, 2));*/ } // refine layout if (clusterBox->currentIndex() == 0) { refineLayoutByPlace(clusters); } else if (clusterBox->currentIndex() == 1) { refineLayoutBySize(clusters); } // convert the segments to QGraphicsItems and add to QGraphicsScene foreach(Segment const * const segment, segmentsWOBack) { arrangement->addItem(segment->toQGraphicsItem()); // without the following line QPainter tends to crash arrangement->width(); }
void MainWindow::on_pushButton_9_clicked() { QStringList times; std::string testString="Test string é!"; std::string preparedString="sdflgsdfgpml$ùù"; { QTime time; time.restart(); quint64 index=0; while(index<6553500) { if(testString!=preparedString) {} if(testString==preparedString) {} index++; } times << QString("Condition with != and ==: %1ms").arg(time.elapsed()); } { QTime time; time.restart(); quint64 index=0; while(index<6553500) { testString+preparedString; index++; } times << QString("concat by +: %1ms").arg(time.elapsed()); } { QTime time; time.restart(); quint64 index=0; while(index<6553500) { stringreplaceAll(testString,preparedString,testString); index++; } times << QString("replace format to QString: %1ms").arg(time.elapsed()); } { QTime time; time.restart(); quint64 index=0; while(index<6553500) { stringreplaceAll(testString,preparedString,preparedString); index++; } times << QString("replace format to format: %1ms").arg(time.elapsed()); } qDebug() << QString("Prepared c++11: \n%1").arg(times.join("\n")); }
VoiceSignature::VoiceSignature(const Sound& sound) { static uint temp_wind=0, temp_fft=0, temp_moy=0; QTime t; t.start(); unsigned int start , stop; if(!window(sound,&start,&stop)) { kWarning() << "No voice found in the sound" ; return; } temp_wind+=t.restart(); uint length=stop-start; for(int wind=0; wind<WINDOW_NUMBER; wind++) { unsigned int w_start=MAX(start, start+ (int)((wind - WINDOW_SUPER)*length/WINDOW_NUMBER)); unsigned int w_stop =MIN(stop , start+ (int)((wind+1.0+WINDOW_SUPER)*length/WINDOW_NUMBER)); QVector<double> fourrier=fft(sound, w_start,w_stop); temp_fft+=t.restart(); //MEL conversion double mel_start=HZ_TO_MEL(FFT_RANGE_INF); uint mel_stop=HZ_TO_MEL(FFT_RANGE_SUP); for(int four=0; four<FOUR_NUMBER; four++) { unsigned int wf_start=mel_start + four*(mel_stop-mel_start)/FOUR_NUMBER; unsigned int wf_stop=mel_start + (four+1)*(mel_stop-mel_start)/FOUR_NUMBER; unsigned int f_start=MEL_TO_HZ( wf_start )*fourrier.size()/sound.fs(); unsigned int f_stop=MEL_TO_HZ( wf_stop )*fourrier.size()/sound.fs(); unsigned int f_size=f_stop-f_start; double nb=0; for(uint f=f_start; f<f_stop; f++) { int freq=f*fourrier.size()/sound.fs(); nb+=fourrier[f]*FFT_PONDERATION(freq); } nb/=(f_size); data[wind][four]=nb; } temp_moy+=t.restart(); } // kDebug() << "wind: "<< temp_wind << " - fft: " << temp_fft << " - moy: " << temp_moy; }
void App::applyEffect(QRectF rect, float zoom, float opacityA, float opacityB, float opacityC, float opacityD) { QTime t; t.start(); QRectF targetRect(0, 0, m_displayWidth, m_displayHeight); QRectF sourceRect(rect.x() / zoom, rect.y() / zoom, rect.width(), rect.height()); QImage resultImage(QSize(m_displayWidth, m_displayHeight), QImage::Format_ARGB32_Premultiplied); QImage baseImage = Helper::createImageFromTile(m_tile, m_displayWidth, m_displayHeight); baseImage.convertToFormat(QImage::Format_ARGB32_Premultiplied); QDir imageDir = QDir::current(); imageDir.cd("app/native/assets/images"); QImage overlay1(imageDir.absoluteFilePath("effect1.png")); overlay1.convertToFormat(QImage::Format_ARGB32_Premultiplied); QImage overlay2(imageDir.absoluteFilePath("effect2.png")); overlay2.convertToFormat(QImage::Format_ARGB32_Premultiplied); QImage overlay3(imageDir.absoluteFilePath("effect3.png")); overlay3.convertToFormat(QImage::Format_ARGB32_Premultiplied); QImage overlay4(imageDir.absoluteFilePath("effect4.png")); overlay4.convertToFormat(QImage::Format_ARGB32_Premultiplied); qDebug() << "TIME: loading images:" << t.elapsed(); t.restart(); QPainter p(&resultImage); p.drawImage(targetRect, baseImage, sourceRect); p.setCompositionMode(QPainter::CompositionMode_SourceOver); p.setOpacity(opacityA); p.drawImage(0,0, overlay1); p.setOpacity(opacityB); p.drawImage(0,0, overlay2); p.setOpacity(opacityC); p.drawImage(0,0, overlay3); p.setOpacity(opacityD); p.drawImage(0,0, overlay4); p.end(); qDebug() << "TIME drawing final image:" << t.elapsed(); t.restart(); m_bigImageCache = resultImage; bb::cascades::Image cimg = Helper::convertImage(resultImage); setBigImage(cimg); qDebug() << "TIME converting final image:" << t.elapsed(); t.restart(); }
void testOctree(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples) { std::cout << "==================================================="<< std::endl; std::cout << "Octree" << std::endl; QTime time; time.start(); // Construction of the uniform grid typedef vcg::Octree<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid; MeshGrid uniformGrid; uniformGrid.Set(mesh.vert.begin(), mesh.vert.end()); std::cout << "Build: " << time.elapsed() << " ms" << std::endl; // Test with the radius search std::cout << "Radius search (" << num_test << " tests)"<< std::endl; float avgTime = 0.0f; for (int ii = 0; ii < num_test; ii++) { time.restart(); std::vector<CMesh::VertexPointer> vertexPtr; std::vector<CMesh::VertexType::CoordType> points; std::vector<float> dists; vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points); avgTime += time.elapsed(); } std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; // Test with the k-nearest search std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; avgTime = 0.0f; for (int ii = 0; ii < num_test * 10; ii++) { time.restart(); std::vector<CMesh::VertexPointer> vertexPtr; std::vector<CMesh::VertexType::CoordType> points; std::vector<float> dists; vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points); avgTime += time.elapsed(); } std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; // Test with the Closest search std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; avgTime = 0.0f; for (int ii = 0; ii < num_test * 10; ii++) { time.restart(); float minDist; vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist); avgTime += time.elapsed(); } std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; }
static bool HasSomethingToPaste (kpMainWindow *mw) { #if DEBUG_KP_MAIN_WINDOW kdDebug () << "kpMainWindow(" << mw->name () << "):HasSomethingToPaste()" << endl; QTime timer; timer.start (); #else (void) mw; #endif bool hasSomething = false; QMimeSource *ms = QApplication::clipboard ()->data (QClipboard::Clipboard); if (ms) { // It's faster to test for QTextDrag::canDecode() first due to the // lazy evaluation of the '||' operator. hasSomething = (QTextDrag::canDecode (ms) || kpSelectionDrag::canDecode (ms)); #if DEBUG_KP_MAIN_WINDOW kdDebug () << "\t" << mw->name () << "***canDecode=" << timer.restart () << endl; for (int i = 0; ; i++) { const char *fmt = ms->format (i); if (!fmt) break; kdDebug () << "\t'" << fmt << "'" << endl; } #endif } return hasSomething; }
void SpecificWorker::compute() { static QTime reloj = QTime::currentTime(); static int fps=0; Mat frame, frameRGB; grabber.read(frame); cvtColor( frame, frameRGB, CV_BGR2RGB ); memcpy( &writeBuffer[0], frameRGB.data, frameRGB.size().area() * 3); // qDebug() << "Reading..."; // at" << grabber.get(CV_CAP_PROP_FPS) << "fps"; // imshow("img", frame); QMutexLocker ml(mutex); readBuffer.swap( writeBuffer); if( reloj.elapsed() > 1000) { qDebug() << "Grabbing at"<< fps << "FPS "; fps=0; reloj.restart(); } fps++; //if(waitKey(30) >= 0) exit(-1); }
static void artisticSleep(int sleepTime) { QTime time; time.restart(); while (time.elapsed() < sleepTime) QCoreApplication::processEvents(QEventLoop::AllEvents, 50); }
void testPerfectSpatialHashing(CMesh& mesh, std::vector<unsigned int>& test_indeces) { std::cout << "==================================================="<< std::endl; std::cout << "Perfect Spatial Hashing" << std::endl; QTime time; time.start(); // Construction of the uniform grid typedef vcg::SpatialHashTable<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid; MeshGrid uniformGrid; uniformGrid.Set(mesh.vert.begin(), mesh.vert.end()); std::cout << "Build: " << time.elapsed() << " ms" << std::endl; // Test with the radius search std::cout << "Radius search (" << num_test << " tests)"<< std::endl; float avgTime = 0.0f; for (int ii = 0; ii < num_test; ii++) { time.restart(); std::vector<CMesh::VertexPointer> vertexPtr; std::vector<CMesh::VertexType::CoordType> points; std::vector<float> dists; vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points); avgTime += time.elapsed(); } std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl << std::endl; }
void SpecificWorker::compute( ) { static QTime reloj = QTime::currentTime(); static bool first=true; if (first) { qLog::getInstance()->setProxy("both", logger_proxy); rDebug2(("navigationAgent started")); first = false; } if (worldModel->getIdentifierByType("robot") < 0) { try { RoboCompAGMWorldModel::World w = agmexecutive_proxy->getModel(); structuralChange(w); } catch(...) { printf("The executive is probably not running, waiting for first AGM model publication..."); } } actionExecution(); worker_params_mutex->lock(); //save framerate in params worker_params["frameRate"].value = std::to_string(reloj.restart()/1000.f); worker_params_mutex->unlock(); }
void MainWindow::downloadProgress(qint64 bytesReceived, qint64 bytesTotal) { if (lastReceivedBytes == 0) { ui->progressBar_FullScan->setMaximum(bytesTotal); } ui->progressBar_FullScan->setValue(bytesReceived); QTime nowTime; nowTime.restart(); int delta = lastReceivedBytesTime.msecsTo(nowTime); if (delta < 500 && bytesReceived < bytesTotal) return; QString downloadingFile = filesToDownload.at(nextFileToDownload); downloadingFile = downloadingFile.mid(downloadingFile.lastIndexOf("/") + 1); int speed = 0; if (delta != 0) speed = ((bytesReceived - lastReceivedBytes) / delta); QString label = "Downloading: " + downloadingFile + " " + QString::number(bytesReceived / 1000) + " kB / " + QString::number(bytesTotal / 1000) + " kB " + QString::number(speed) + " kB/s"; ui->label_current_work->setStyleSheet("color:black"); ui->label_current_work->setText(label); lastReceivedBytesTime.restart(); lastReceivedBytes = bytesReceived; }
bool QGalleryTrackerResultSet::waitForFinished(int msecs) { Q_D(QGalleryTrackerResultSet); QTime timer; timer.start(); do { if (d->flags & QGalleryTrackerResultSetPrivate::Active) { if (d->waitForSyncFinish(msecs)) { d->parserThread.wait(); d->_q_parseFinished(); if (!(d->flags & QGalleryTrackerResultSetPrivate::Active)) return true; } else { return false; } } else if (d->flags & (QGalleryTrackerResultSetPrivate::Refresh)) { d->update(); } else { return true; } } while ((msecs -= timer.restart()) > 0); return false; }
/** * Flushes the contents of the \a windowSurface into the screen area of \a widget. * \a tlwOffset is the position of the top level widget relative to the window surface. * \a region is the region to be updated in \a widget coordinates. */ static inline void qt_flush(QWidget *widget, const QRegion ®ion, QWindowSurface *windowSurface, QWidget *tlw, const QPoint &tlwOffset) { Q_ASSERT(widget); Q_ASSERT(!region.isEmpty()); Q_ASSERT(windowSurface); Q_ASSERT(tlw); #if !defined(QT_NO_PAINT_DEBUG) static int flushUpdate = qgetenv("QT_FLUSH_UPDATE").toInt(); if (flushUpdate > 0) QWidgetBackingStore::showYellowThing(widget, region, flushUpdate * 10, false); #endif //The performance hit by doing this should be negligible. However, be aware that //using this FPS when you have > 1 windowsurface can give you inaccurate FPS static bool fpsDebug = qgetenv("QT_DEBUG_FPS").toInt(); if (fpsDebug) { static QTime time = QTime::currentTime(); static int frames = 0; frames++; if(time.elapsed() > 5000) { double fps = double(frames * 1000) /time.restart(); fprintf(stderr,"FPS: %.1f\n",fps); frames = 0; } } if (widget != tlw) windowSurface->flush(widget, region, tlwOffset + widget->mapTo(tlw, QPoint())); else windowSurface->flush(widget, region, tlwOffset); }
bool MyProcess::runSync(SCRef rc, QByteArray* ro, QObject* rcv, SCRef buf) { async = false; runCmd = rc; runOutput = ro; receiver = rcv; if (runOutput) runOutput->clear(); setupSignals(); if (!launchMe(runCmd, buf)) return false; QTime t; t.start(); busy = true; // we have to wait here until we exit while (busy) { waitForFinished(20); // suspend 20ms to let OS reschedule if (t.elapsed() > 200) { EM_PROCESS_EVENTS; t.restart(); } } return !isErrorExit; }
void ExportThread::exportItems( const QString& name, ItemList& items, quint32& currentItem, QTime& time ) { if( !items.isEmpty() ) { QDir dir( m_directory ); if( dir.exists() ) { if( !dir.cd( name ) ) dir.mkdir( name ); dir.cd( name ); QTime rate; rate.start(); quint32 count = 0; foreach( TibiaItem* item, items ) { if( isCanceled() ) break; if( exportItem( dir, item ) ) { emit valueChanged( currentItem ); currentItem++; if( ( float )( rate.elapsed() / 1000 ) >= 1 ) { emit labelText( tr( "%1\n\nElapsed Time: %2\nTime left: %3" ).arg( m_labelText ).arg( QTime().addMSecs( time.elapsed() ).toString( "hh:mm:ss" ) ).arg( QTime().addMSecs( ( int )( ( ( float )( m_maximum - currentItem ) / count ) * ( float )1000 ) ).toString( "hh:mm:ss" ) ) ); //emit rateChanged( count, libraryFile->getCount() - i, time.elapsed() ); // Items/sec, Items remaining rate.restart(); count = 0; } count++; } } } }
void proc() { GrammarTree gt; QVector<double> p(9); p[0] = 5; p[1] = 0.5; p[2] = 1; p[3] = true; p[4] = 45; p[5] = 30; p[6] = 0.3; p[7] = 2; p[8] = true; QTime timer; timer.start(); for(int j = 0; j < 10; j ++) { QString d ("set arbre "+QString::number(j)+"/"); QDir di; di.mkdir(d); for(int i = 0; i < 10; i++) { timer.restart(); MeshBase::Mesh m = gt.generation(p); qDebug()<<"Génération de l'arbre "<<(j*10+i)<<"en"<<timer.elapsed()<<"ms"; m.writeObj(d+"treeTest" + QString::number(i) + ".obj"); } } }
void NelderMead::run() { NMWorker* worker = new NMWorker(liveCrystal); if (worker->valid()) { int loops = 0; int noImprovmentLoops=0; QTime rateLimiter; double bestEmitedScore=worker->bestScore(); rateLimiter.start(); forever { loops++; noImprovmentLoops++; threadLock.lockForRead(); bool _shouldStop = shouldStop; threadLock.unlock(); if (_shouldStop) { break; } double lastScore = worker->bestScore(); worker->doOneIteration(); if (worker->bestScore()<bestEmitedScore && rateLimiter.elapsed()>50) { bestEmitedScore = worker->bestScore(); emit bestSolutionScore(worker->bestScore()); emit bestSolution(worker->bestSolution(), worker->calcDeviation()); rateLimiter.restart(); } if (lastScore/worker->bestScore()>1.001) { noImprovmentLoops = 0; } double relativeScoreDifference = (worker->worstScore() - worker->bestScore())/worker->worstScore(); if ((noImprovmentLoops>75) || (relativeScoreDifference < 1e-4)) { break; } } }
bool QGalleryTrackerTypeResultSet::waitForFinished(int msecs) { Q_D(QGalleryTrackerTypeResultSet); QTime timer; timer.start(); do { if (QDBusPendingCallWatcher *watcher = d->queryWatcher) { d->queryWatcher = 0; watcher->waitForFinished(); d->queryFinished(*watcher); delete watcher; if (d->state != QGalleryAbstractRequest::Active) return true; } else { return true; } } while ((msecs -= timer.restart()) > 0); return false; }
void run(){ // we should be executed on the main queue MU_ASSERT_EQUAL_HEX(QDispatch::currentQueue().native(), dispatch_get_main_queue()); // assert that we can really get the timer MU_ASSERT_EQUAL_HEX(QDispatchTimer::current(), tested_timer); // test the timer interval (but only after the second run // as the first one will be started immediately if(counter > 0) { long diff = checked_time.elapsed(); MU_DESC_ASSERT_LESS_THAN_EQUAL("timer not too late", diff, 3*1000); MU_DESC_ASSERT_LESS_THAN_EQUAL("timer not too early", 1*1000, diff); } checked_time.restart(); // only pass when the timer fired at least 5 times MU_MESSAGE("\t%i", counter); if(counter < 5) counter++; else { MU_PASS(""); } }
void task_attributes::run_impl() { using namespace std; size_t counter(0); QTime time; time.start(); shared_ptr<rowset_model> mdl(new rowset_model(0)); auto rs(m_lr->attributes(get_frame())); mdl->m_columns = rs->columns(); vector<brig::variant> row; for (; rs->fetch(row) && counter < brig::PageSize; ++counter) { vector<string> strs; for (const auto& v: row) strs.push_back(brig::string_cast<char>(v)); mdl->m_rows.push_back(move(strs)); if (time.elapsed() < BatchInterval) continue; progress(QString("rows: %1").arg(counter + 1)); time.restart(); } if (counter >= brig::PageSize) progress(QString("in excess of %1 rows").arg(brig::PageSize)); else progress(QString("rows: %1").arg(counter)); emit signal_rowset(mdl); }
void SpecificWorker::compute() { static QTime reloj = QTime::currentTime(); static int fps=0; Mat frame, frameRGB; grabber.read(frame); cvtColor( frame, frameRGB, CV_BGR2RGB ); memcpy( &writeBuffer[0], frameRGB.data, frameRGB.size().area() * 3); //qDebug() << "Reading..."; // at" << grabber.get(CV_CAP_PROP_FPS) << "fps"; //imshow("img", frame); QMutexLocker ml(mutex); readBuffer.swap( writeBuffer); if( reloj.elapsed() > 1000) { qDebug() << "Grabbing at"<< fps << "FPS "; fps=0; reloj.restart(); } fps++; str->data = "If you are seeing this, it's mainly coz I'm awesome"; test_pub.publish(str); // ROS_INFO_STREAM("they see me rollin!"); ros::spinOnce(); //if(waitKey(30) >= 0) exit(-1); }
int work3() { int x = 0; QApplication a(x,0); //1396","uid":"359887 DanmuConnection dc; dc.debugFlag = true; dc.login("aabbeaabbe","aabbdaabbd", "359887","1396"); QTime t; t.start(); int count = 0; x = 1; while(true) { if (t.elapsed() >5000) { count+=123123; //a = dc.postDanmu(QString ::number(count)); // QJsonObject({"action":1,"cmdid":"blockuser","ip":"111.8.57.138","msg":"111","nam // e":"九千万亿电竞女神","type":1,"uid":100305463}) x = 1-x; t.restart(); } QCoreApplication::processEvents(); } return a.exec(); }
/// /// Set peak value (0.0 .. 1.0) /// void Fader::setPeak( float fPeak, float &targetPeak, float &persistentPeak, QTime &lastPeakTime ) { if( fPeak < m_fMinPeak ) { fPeak = m_fMinPeak; } else if( fPeak > m_fMaxPeak ) { fPeak = m_fMaxPeak; } if( targetPeak != fPeak) { targetPeak = fPeak; if( targetPeak >= persistentPeak ) { persistentPeak = targetPeak; lastPeakTime.restart(); } update(); } if( persistentPeak > 0 && lastPeakTime.elapsed() > 1500 ) { persistentPeak = qMax<float>( 0, persistentPeak-0.05 ); update(); } }
void Dialog::scanMaps(const QString &folderName) { CatchChallenger::DebugClass::redirection=true; QTime startTime; startTime.restart(); scanFolderMap(QDir(folderName)); scanFolderPosition(QDir(folderName)); qDebug() << startTime.elapsed(); QString html="<ul>"; QHash<QString,Map_full>::const_iterator i = other_map.constBegin(); while (i != other_map.constEnd()) { if(i.value().log.size()>0) { html+="<li>"+i.key(); html+="<ul><li>"+i.value().log.join("</li><li>")+"</li></ul>"; html+="</li>"; } ++i; } html+="</ul>"; ui->textEdit->setHtml(html); }
void process_gui_events_if_needed() { #ifdef QT_VERSION if (s_timer.elapsed()>500) { qApp->processEvents(); s_timer.restart(); } #endif }
inline void roiDetector::printFPS( ) { static int fps=0; static QTime ti; if ((++fps % 50) == 0) { qDebug() << " VisionComp Cam fps: " << (50000 / ti.restart())/params.numCams; } }
void BenchWidget::paintEvent(QPaintEvent *) { if (m_done) return; QPainter p(this); m_benchmark->begin(&p, 100); PaintingRectAdjuster adjuster; adjuster.setNewBenchmark(m_benchmark); adjuster.reset(rect()); for (int i = 0; i < 100; ++i) m_benchmark->draw(&p, adjuster.newPaintingRect(), i); m_benchmark->end(&p); ++m_iteration; uint currentElapsed = timer.isNull() ? 0 : timer.elapsed(); timer.restart(); m_total += currentElapsed; // warm up for at most 5 iterations or half a second if (m_iteration >= 5 || m_total >= 500) { iterationTimes << currentElapsed; if (iterationTimes.size() >= 5) { qreal mean = 0; qreal stddev = 0; uint min = INT_MAX; for (int i = 0; i < iterationTimes.size(); ++i) { mean += iterationTimes.at(i); min = qMin(min, iterationTimes.at(i)); } mean /= qreal(iterationTimes.size()); for (int i = 0; i < iterationTimes.size(); ++i) { qreal delta = iterationTimes.at(i) - mean; stddev += delta * delta; } stddev = qSqrt(stddev / iterationTimes.size()); stddev = 100 * stddev / mean; // do 50 iterations, break earlier if we spend more than 5 seconds or have a low std deviation after 2 seconds if (iterationTimes.size() >= 50 || m_total >= 5000 || (m_total >= 2000 && stddev < 4)) { m_result = min; m_done = true; return; } } } }
void MainWindow::on_pushButton_8_clicked() { QStringList times; std::string testString="Test string é!"; { QTime time; time.restart(); quint64 index=0; while(index<6553500) { if(testString!=std::string("test bis")) {} if(testString==std::string("test bis")) {} index++; } times << QString("Condition with != and ==: %1ms").arg(time.elapsed()); } { QTime time; time.restart(); quint64 index=0; while(index<6553500) { testString+std::string("test bis"); index++; } times << QString("concat by +: %1ms").arg(time.elapsed()); } { QTime time; time.restart(); quint64 index=0; while(index<6553500) { stringreplaceAll(testString,std::string("test bis"),testString); index++; } times << QString("replace format to QString: %1ms").arg(time.elapsed()); } { QTime time; time.restart(); quint64 index=0; while(index<6553500) { stringreplaceAll(testString,std::string("test bis"),std::string("test bis")); index++; } times << QString("replace format to format: %1ms").arg(time.elapsed()); } qDebug() << QString("dyna string c++11: \n%1").arg(times.join("\n")); }