FlowField_sV* FlowSourceOpenCV_sV::buildFlow(uint leftFrame, uint rightFrame, FrameSize frameSize) throw(FlowBuildingError)
{
#if CV_MAJOR_VERSION == 2
#ifdef HAVE_OPENCV_OCL
if (ocl_device_index >= 0) {
setupOclDevice();
}
#endif
#endif
QString flowFileName(flowPath(leftFrame, rightFrame, frameSize));
/// \todo Check if size is equal
if (!QFile(flowFileName).exists()) {
QTime time;
time.start();
QString prevpath = project()->frameSource()->framePath(leftFrame, frameSize);
QString path = project()->frameSource()->framePath(rightFrame, frameSize);
qDebug() << "Building flow for left frame " << leftFrame << " to right frame " << rightFrame << "; Size: " << frameSize;
// check if file have been generated !
//TODO: maybe better error handling ?
if (!QFile(prevpath).exists())
throw FlowBuildingError(QString("Could not read image " + prevpath));
if (!QFile(path).exists())
throw FlowBuildingError(QString("Could not read image " + path));
cv::Mat prevgray, gray;
prevgray = cv::imread(prevpath.toStdString(), CV_LOAD_IMAGE_ANYDEPTH);
gray = cv::imread(path.toStdString(), CV_LOAD_IMAGE_ANYDEPTH);
#if CV_MAJOR_VERSION == 3
cv::UMat uprevgray, ugray;
prevgray.copyTo(uprevgray);
gray.copyTo(ugray);
#endif
{
if (!prevgray.empty()) {
#if CV_MAJOR_VERSION == 3
buildFlowOpenCV_3(uprevgray, ugray, flowFileName.toStdString());
#else
#ifdef HAVE_OPENCV_OCL
if (ocl_device_index >= 0) {
buildFlowOpenCV_OCL(prevgray, gray, flowFileName.toStdString());
} else {
buildFlowOpenCV_CPU(prevgray, gray, flowFileName.toStdString());
}
#else
buildFlowOpenCV_CPU(prevgray, gray, flowFileName.toStdString());
#endif
#endif
} else {
qDebug() << "imread: Could not read image " << prevpath;
throw FlowBuildingError(QString("imread: Could not read image " + prevpath));
}
}
qDebug() << "Optical flow built for " << flowFileName << " in " << time.elapsed() << " ms.";
} else {
qDebug().nospace() << "Re-using existing flow image for left frame " << leftFrame << " to right frame " << rightFrame << ": " << flowFileName;
}
try {
return FlowRW_sV::load(flowFileName.toStdString());
} catch (FlowRW_sV::FlowRWError &err) {
throw FlowBuildingError(err.message.c_str());
}
}
void XSPFParser::load() {
QTime timeElapsed;
timeElapsed.start();
_stop = false;
QList<MediaInfo> files;
qDebug() << __FUNCTION__ << "Playlist:" << _filename;
QFile file(_filename);
if (file.open(QIODevice::ReadOnly)) {
MediaInfo mediaInfo;
QXmlStreamReader xml(&file);
while (!xml.atEnd() && !_stop) {
xml.readNext();
switch (xml.tokenType()) {
case QXmlStreamReader::StartElement: {
QString element(xml.name().toString());
if (element == XSPF_TRACK) {
readTrack(xml, mediaInfo);
if (!mediaInfo.fileName().isEmpty()) {
//Add file to the list of files
files << mediaInfo;
//Clear the MediaInfo
mediaInfo.clear();
if (files.size() > FILES_FOUND_LIMIT) {
//Emits the signal every FILES_FOUND_LIMIT files found
emit filesFound(files);
files.clear();
}
}
}
//Otherwise won't read the track end element
break;
}
}
}
if (xml.hasError()) {
qCritical() << __FUNCTION__ << "Error:" << xml.errorString()
<< "line:" << xml.lineNumber()
<< "column:" << xml.columnNumber();
}
}
file.close();
if (!files.isEmpty()) {
//Emits the signal for the remaining files found (< FILES_FOUND_LIMIT)
emit filesFound(files);
}
//Emits the last signal
emit finished(timeElapsed.elapsed());
}
void QgsPalLabeling::drawLabeling( QgsRenderContext& context )
{
Q_ASSERT( mMapRenderer != NULL );
QPainter* painter = context.painter();
QgsRectangle extent = context.extent();
if ( mLabelSearchTree )
{
mLabelSearchTree->clear();
}
QTime t;
t.start();
// do the labeling itself
double scale = mMapRenderer->scale(); // scale denominator
QgsRectangle r = extent;
double bbox[] = { r.xMinimum(), r.yMinimum(), r.xMaximum(), r.yMaximum() };
std::list<LabelPosition*>* labels;
pal::Problem* problem;
try
{
problem = mPal->extractProblem( scale, bbox );
}
catch ( std::exception& e )
{
Q_UNUSED( e );
QgsDebugMsg( "PAL EXCEPTION :-( " + QString::fromLatin1( e.what() ) );
//mActiveLayers.clear(); // clean up
return;
}
const QgsMapToPixel* xform = mMapRenderer->coordinateTransform();
// draw rectangles with all candidates
// this is done before actual solution of the problem
// before number of candidates gets reduced
mCandidates.clear();
if ( mShowingCandidates && problem )
{
painter->setPen( QColor( 0, 0, 0, 64 ) );
painter->setBrush( Qt::NoBrush );
for ( int i = 0; i < problem->getNumFeatures(); i++ )
{
for ( int j = 0; j < problem->getFeatureCandidateCount( i ); j++ )
{
pal::LabelPosition* lp = problem->getFeatureCandidate( i, j );
drawLabelCandidateRect( lp, painter, xform );
}
}
}
// find the solution
labels = mPal->solveProblem( problem, mShowingAllLabels );
QgsDebugMsg( QString( "LABELING work: %1 ms ... labels# %2" ).arg( t.elapsed() ).arg( labels->size() ) );
t.restart();
painter->setRenderHint( QPainter::Antialiasing );
// draw the labels
std::list<LabelPosition*>::iterator it = labels->begin();
for ( ; it != labels->end(); ++it )
{
QgsPalGeometry* palGeometry = dynamic_cast< QgsPalGeometry* >(( *it )->getFeaturePart()->getUserGeometry() );
if ( !palGeometry )
{
continue;
}
//layer names
QString layerNameUtf8 = QString::fromUtf8(( *it )->getLayerName() );
if ( palGeometry->isDiagram() )
{
//render diagram
QHash<QgsVectorLayer*, QgsDiagramLayerSettings>::iterator dit = mActiveDiagramLayers.begin();
for ( dit = mActiveDiagramLayers.begin(); dit != mActiveDiagramLayers.end(); ++dit )
{
if ( dit.key() && dit.key()->id().append( "d" ) == layerNameUtf8 )
{
QgsPoint outPt = xform->transform(( *it )->getX(), ( *it )->getY() );
dit.value().renderer->renderDiagram( palGeometry->diagramAttributes(), context, QPointF( outPt.x(), outPt.y() ) );
}
}
//insert into label search tree to manipulate position interactively
if ( mLabelSearchTree )
{
//for diagrams, remove the additional 'd' at the end of the layer id
QString layerId = layerNameUtf8;
layerId.chop( 1 );
mLabelSearchTree->insertLabel( *it, QString( palGeometry->strId() ).toInt(), layerId, true );
}
continue;
}
const QgsPalLayerSettings& lyr = layer( layerNameUtf8 );
QFont fontForLabel = lyr.textFont;
QColor fontColor = lyr.textColor;
double bufferSize = lyr.bufferSize;
QColor bufferColor = lyr.bufferColor;
//apply data defined settings for the label
//font size
QVariant dataDefinedSize = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Size );
if ( dataDefinedSize.isValid() )
{
fontForLabel.setPixelSize( lyr.sizeToPixel( dataDefinedSize.toDouble(), context ) );
}
//font color
QVariant dataDefinedColor = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Color );
if ( dataDefinedColor.isValid() )
{
fontColor.setNamedColor( dataDefinedColor.toString() );
if ( !fontColor.isValid() )
{
fontColor = lyr.textColor;
}
}
//font bold
QVariant dataDefinedBold = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Bold );
if ( dataDefinedBold.isValid() )
{
fontForLabel.setBold(( bool )dataDefinedBold.toInt() );
}
//font italic
QVariant dataDefinedItalic = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Italic );
if ( dataDefinedItalic.isValid() )
{
fontForLabel.setItalic(( bool ) dataDefinedItalic.toInt() );
}
//font underline
QVariant dataDefinedUnderline = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Underline );
if ( dataDefinedUnderline.isValid() )
{
fontForLabel.setUnderline(( bool ) dataDefinedUnderline.toInt() );
}
//font strikeout
QVariant dataDefinedStrikeout = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Strikeout );
if ( dataDefinedStrikeout.isValid() )
{
fontForLabel.setStrikeOut(( bool ) dataDefinedStrikeout.toInt() );
}
//font family
QVariant dataDefinedFontFamily = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Family );
if ( dataDefinedFontFamily.isValid() )
{
fontForLabel.setFamily( dataDefinedFontFamily.toString() );
}
//buffer size
QVariant dataDefinedBufferSize = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::BufferSize );
if ( dataDefinedBufferSize.isValid() )
{
bufferSize = dataDefinedBufferSize.toDouble();
}
//buffer color
QVariant dataDefinedBufferColor = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::BufferColor );
if ( dataDefinedBufferColor.isValid() )
{
bufferColor.setNamedColor( dataDefinedBufferColor.toString() );
if ( !bufferColor.isValid() )
{
bufferColor = lyr.bufferColor;
}
}
if ( lyr.bufferSize != 0 )
drawLabel( *it, painter, fontForLabel, fontColor, xform, bufferSize, bufferColor, true );
drawLabel( *it, painter, fontForLabel, fontColor, xform );
if ( mLabelSearchTree )
{
mLabelSearchTree->insertLabel( *it, QString( palGeometry->strId() ).toInt(), ( *it )->getLayerName() );
}
}
QgsDebugMsg( QString( "LABELING draw: %1 ms" ).arg( t.elapsed() ) );
delete problem;
delete labels;
// delete all allocated geometries for features
QHash<QgsVectorLayer*, QgsPalLayerSettings>::iterator lit;
for ( lit = mActiveLayers.begin(); lit != mActiveLayers.end(); ++lit )
{
QgsPalLayerSettings& lyr = lit.value();
for ( QList<QgsPalGeometry*>::iterator git = lyr.geometries.begin(); git != lyr.geometries.end(); ++git )
delete *git;
lyr.geometries.clear();
}
//delete all allocated geometries for diagrams
QHash<QgsVectorLayer*, QgsDiagramLayerSettings>::iterator dIt = mActiveDiagramLayers.begin();
for ( ; dIt != mActiveDiagramLayers.end(); ++dIt )
{
QgsDiagramLayerSettings& dls = dIt.value();
for ( QList<QgsPalGeometry*>::iterator git = dls.geometries.begin(); git != dls.geometries.end(); ++git )
{
delete *git;
}
dls.geometries.clear();
}
}
QList<struct BansheeDbConnection::PlaylistEntry> BansheeDbConnection::getPlaylistEntries(int playlistId) {
QTime time;
time.start();
QList<struct BansheeDbConnection::PlaylistEntry> list;
struct BansheeDbConnection::PlaylistEntry entry;
QSqlQuery query(m_database);
query.setForwardOnly(true); // Saves about 50% time
QString queryString;
if (playlistId == 0) {
// Create Master Playlist
queryString = QString(
"SELECT "
"CoreTracks.TrackID, " // 0
"CoreTracks.TrackID, " // 1
"CoreTracks.Title, " // 2
"CoreTracks.Uri, " // 3
"CoreTracks.Duration, " // 4
"CoreTracks.ArtistID, " // 5
"CoreArtists.Name, " // 6
"CoreTracks.Year, " // 7
"CoreTracks.AlbumID, " // 8
"CoreAlbums.Title, " // 9
"CoreTracks.Rating, " // 10
"CoreTracks.Genre, " // 11
"CoreTracks.TrackNumber, " // 12
"CoreTracks.DateAddedStamp, " // 13
"CoreTracks.BPM, " // 14
"CoreTracks.BitRate, " // 15
"CoreTracks.Comment, " // 16
"CoreTracks.PlayCount, " // 17
"CoreTracks.Composer, " // 18
"CoreTracks.Grouping, " // 19
"CoreAlbums.ArtistID, " // 20
"AlbumArtists.Name " // 21
"FROM CoreTracks "
"INNER JOIN CoreArtists ON CoreArtists.ArtistID = CoreTracks.ArtistID "
"INNER JOIN CoreArtists AlbumArtists ON AlbumArtists.ArtistID = CoreAlbums.ArtistID "
"INNER JOIN CoreAlbums ON CoreAlbums.AlbumID = CoreTracks.AlbumID ");
} else {
// SELECT playlist from CorePlaylistEntries
queryString = QString(
"SELECT "
"CorePlaylistEntries.TrackID, " // 0
"CorePlaylistEntries.ViewOrder, " // 1
"CoreTracks.Title, " // 2
"CoreTracks.Uri, " // 3
"CoreTracks.Duration, " // 4
"CoreTracks.ArtistID, " // 5
"CoreArtists.Name, " // 6
"CoreTracks.Year, " // 7
"CoreTracks.AlbumID, " // 8
"CoreAlbums.Title, " // 9
"CoreTracks.Rating, " // 10
"CoreTracks.Genre, " // 11
"CoreTracks.TrackNumber, " // 12
"CoreTracks.DateAddedStamp, " // 13
"CoreTracks.BPM, " // 14
"CoreTracks.BitRate, " // 15
"CoreTracks.Comment, " // 16
"CoreTracks.PlayCount, " // 17
"CoreTracks.Composer, " // 18
"CoreTracks.Grouping, " // 19
"CoreAlbums.ArtistID, " // 20
"AlbumArtists.Name " // 21
"FROM CorePlaylistEntries "
"INNER JOIN CoreTracks ON CoreTracks.TrackID = CorePlaylistEntries.TrackID "
"INNER JOIN CoreArtists ON CoreArtists.ArtistID = CoreTracks.ArtistID "
"INNER JOIN CoreArtists AlbumArtists ON AlbumArtists.ArtistID = CoreAlbums.ArtistID "
"INNER JOIN CoreAlbums ON CoreAlbums.AlbumID = CoreTracks.AlbumID "
"WHERE CorePlaylistEntries.PlaylistID = %1")
.arg(playlistId);
}
query.prepare(queryString);
if (query.exec()) {
while (query.next()) {
entry.trackId = query.value(0).toInt();
entry.viewOrder = query.value(1).toInt();
m_trackMap[entry.trackId].title = query.value(2).toString();
m_trackMap[entry.trackId].uri = QUrl::fromEncoded(query.value(3).toByteArray(), QUrl::StrictMode);
m_trackMap[entry.trackId].duration = query.value(4).toInt();
int artistId = query.value(5).toInt();
m_artistMap[artistId].name = query.value(6).toString();
m_trackMap[entry.trackId].year = query.value(7).toInt();
int albumId = query.value(8).toInt();
m_albumMap[albumId].title = query.value(9).toString();
int albumArtistId = query.value(20).toInt();
m_artistMap[albumArtistId].name = query.value(21).toString();
m_trackMap[entry.trackId].rating = query.value(10).toInt();
m_trackMap[entry.trackId].genre = query.value(11).toString();
m_trackMap[entry.trackId].grouping = query.value(19).toString();
m_trackMap[entry.trackId].tracknumber = query.value(12).toInt();
m_trackMap[entry.trackId].dateadded = query.value(13).toInt();
m_trackMap[entry.trackId].bpm = query.value(14).toInt();
m_trackMap[entry.trackId].bitrate = query.value(15).toInt();
m_trackMap[entry.trackId].comment = query.value(16).toString();
m_trackMap[entry.trackId].playcount = query.value(17).toInt();
m_trackMap[entry.trackId].composer = query.value(18).toString();
entry.pTrack = &m_trackMap[entry.trackId];
entry.pArtist = &m_artistMap[artistId];
entry.pAlbum = &m_albumMap[albumId];
entry.pAlbumArtist = &m_artistMap[albumArtistId];
list.append(entry);
}
} else {
LOG_FAILED_QUERY(query);
}
qDebug() << "BansheeDbConnection::getPlaylistEntries(), took " << time.elapsed() << "ms";
return list;
}
void run()
{
testsTurn.release();
// TEST 1: thread can't acquire lock
threadsTurn.acquire();
QVERIFY(!normalMutex.tryLock());
testsTurn.release();
// TEST 2: thread can acquire lock
threadsTurn.acquire();
QVERIFY(normalMutex.tryLock());
QVERIFY(lockCount.testAndSetRelaxed(0, 1));
QVERIFY(!normalMutex.tryLock());
QVERIFY(lockCount.testAndSetRelaxed(1, 0));
normalMutex.unlock();
testsTurn.release();
// TEST 3: thread can't acquire lock, timeout = waitTime
threadsTurn.acquire();
QTime timer;
timer.start();
QVERIFY(!normalMutex.tryLock(waitTime));
QVERIFY(timer.elapsed() >= waitTime);
testsTurn.release();
// TEST 4: thread can acquire lock, timeout = waitTime
threadsTurn.acquire();
timer.start();
QVERIFY(normalMutex.tryLock(waitTime));
QVERIFY(timer.elapsed() <= waitTime);
QVERIFY(lockCount.testAndSetRelaxed(0, 1));
timer.start();
// it's non-recursive, so the following lock needs to fail
QVERIFY(!normalMutex.tryLock(waitTime));
QVERIFY(timer.elapsed() >= waitTime);
QVERIFY(lockCount.testAndSetRelaxed(1, 0));
normalMutex.unlock();
testsTurn.release();
// TEST 5: thread can't acquire lock, timeout = 0
threadsTurn.acquire();
QVERIFY(!normalMutex.tryLock(0));
testsTurn.release();
// TEST 6: thread can acquire lock, timeout = 0
threadsTurn.acquire();
timer.start();
QVERIFY(normalMutex.tryLock(0));
QVERIFY(timer.elapsed() < waitTime);
QVERIFY(lockCount.testAndSetRelaxed(0, 1));
QVERIFY(!normalMutex.tryLock(0));
QVERIFY(lockCount.testAndSetRelaxed(1, 0));
normalMutex.unlock();
testsTurn.release();
// TEST 7 overflow: thread can acquire lock, timeout = 3000 (QTBUG-24795)
threadsTurn.acquire();
timer.start();
QVERIFY(normalMutex.tryLock(3000));
QVERIFY(timer.elapsed() < 3000);
normalMutex.unlock();
testsTurn.release();
threadsTurn.acquire();
}
void
NodeMobilityMgr::populateNodePosTable(QString filter1,
QString filter2,
QString filter3,
QString filter4,
QTableWidget *tbl,
bool showTraj,
QProgressBar * progressBar)
{
QStringList headerList;
headerList << "Time"
<< "Node Id"
<< "X coord"
<< "Y coord";
tbl->clearContents();
tbl->setRowCount(0);
tbl->setColumnCount(headerList.count());
tbl->setHorizontalHeaderLabels(headerList);
int64_t filter1NodeId = -1;
int64_t filter2NodeId = -1;
int64_t filter3NodeId = -1;
int64_t filter4NodeId = -1;
if(filter1 != "All")
{
filter1NodeId = filter1.toUInt();
}
if(filter2 != "None")
{
filter2NodeId = filter2.toUInt();
}
if(filter3 != "None")
{
filter3NodeId = filter3.toUInt();
}
if(filter4 != "None")
{
filter4NodeId = filter4.toUInt();
}
QTime t;
t.start();
hideAllTrajectoryPaths();
uint32_t progressBarValue = 0;
for(NodeIdTimeLocationMap_t::const_iterator i = m_tsAnimNodes.begin();
i != m_tsAnimNodes.end();
++i)
{
uint32_t nodeId = i->first;
if(filter1 != "All")
{
if(filter1NodeId == nodeId)
goto resume;
if(filter2NodeId == nodeId)
goto resume;
if(filter3NodeId == nodeId)
goto resume;
if(filter4NodeId == nodeId)
goto resume;
continue;
}
resume:
TimeLocationVector_t tlv = i->second;
if(showTraj)
showTrajectory(nodeId, tlv);
for (TimeLocationVector_t::const_iterator j = tlv.begin();
j != tlv.end();
++j)
{
TimeLocation tl = *j;
if(!tbl)
{
return;
}
int row = tbl->rowCount();
tbl->insertRow(row);
QTableWidgetItem * wiTime = new QTableWidgetItem(QString::number(tl.timeStamp));
QTableWidgetItem * wiNodeId = new QTableWidgetItem(QString::number(nodeId));
QTableWidgetItem * wiXCoord = new QTableWidgetItem(QString::number(tl.location.x()));
QTableWidgetItem * wiYCoord = new QTableWidgetItem(QString::number(tl.location.y()));
tbl->setItem(row, 0, wiTime);
tbl->setItem(row, 1, wiNodeId);
tbl->setItem(row, 2, wiXCoord);
tbl->setItem(row, 3, wiYCoord);
}
progressBar->setValue(++progressBarValue);
if(t.elapsed() > 1000)
{
QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
t.restart();
}
}
tbl->setVisible(true);
}
void UARTWidget::run()
{
qDebug() << "[UARTWidget] Thread created.";
m_serialPort = new QSerialPort(m_serialInfo);
m_serialPort->setBaudRate(250000);
m_serialPort->setDataBits(QSerialPort::Data8);
m_serialPort->setStopBits(QSerialPort::TwoStop);
m_serialPort->setParity(QSerialPort::NoParity);
m_serialPort->setFlowControl(QSerialPort::NoFlowControl);
if (!m_serialPort->open(QIODevice::ReadWrite))
{
qWarning() << QString("[UARTWidget] Failed to open port %1, error: %2")
.arg(m_serialInfo.portName()).arg(m_serialPort->errorString());
return;
}
// If the "new" custom baud rate method is available, then use it to
// make sure the baud rate is properly set to 250Kbps
#if defined(TCGETS2)
int fd = m_serialPort->handle();
static const int rate = 250000;
struct termios2 tio; // linux-specific terminal stuff
if (ioctl(fd, TCGETS2, &tio) < 0)
{
qDebug() << "[UARTWidget] Error in getting termios2 data";
return;
}
tio.c_cflag &= ~CBAUD;
tio.c_cflag |= BOTHER;
tio.c_ispeed = rate;
tio.c_ospeed = rate; // set custom speed directly
if (ioctl(fd, TCSETS2, &tio) < 0)
{
qDebug() << "[UARTWidget] Error in setting termios2 data";
return;
}
#endif
m_serialPort->clear();
m_serialPort->setRequestToSend(false);
// One "official" DMX frame can take (1s/44Hz) = 23ms
int frameTime = (int) floor(((double)1000 / 30) + (double)0.5);
m_granularity = Bad;
QTime time;
time.start();
usleep(1000);
if (time.elapsed() <= 3)
m_granularity = Good;
m_running = true;
while (m_running == true)
{
time.restart();
if (m_mode & Output)
{
m_serialPort->setBreakEnabled(true);
if(m_granularity == Good)
usleep(DMX_BREAK);
m_serialPort->setBreakEnabled(false);
if(m_granularity == Good)
usleep(DMX_MAB);
if (m_serialPort->write(m_outputBuffer) == 0)
qDebug() << "[UARTWidget] Error in writing output buffer";
m_serialPort->waitForBytesWritten(10);
// Sleep for the rest of the DMX frame time
if (m_granularity == Good)
while (time.elapsed() < frameTime) { usleep(1000); }
else
while (time.elapsed() < frameTime) { /* Busy sleep */ }
}
}
}
// instance is created by Core::CorePlugin()
CoreImpl::CoreImpl(QObject *parent) :
ICore(parent),
m_MainWindow(0),
m_ActionManager(0),
m_ContextManager(0),
m_PadTools(0)
{
m_instance = this;
m_Settings = new SettingsPrivate(this);
m_Settings->setPath(ISettings::UpdateUrl, Utils::Constants::FREETOOLBOX_UPDATE_URL);
m_Theme = new ThemePrivate(this);
m_Theme->setThemeRootPath(m_Settings->path(ISettings::ThemeRootPath));
// m_CommandLine = new CommandLine();
// m_CommandLine->feedPatientDatas(m_Patient);
QTime chrono;
chrono.start();
bool logChrono = false; // m_CommandLine->value(CommandLine::CL_Chrono).toBool();
if (logChrono)
Utils::Log::logTimeElapsed(chrono, "Core", "command line parsing");
m_Theme->createSplashScreen(Constants::FREETOOLBOX_SPLASHSCREEN);
// add translators
m_Theme->messageSplashScreen(tkTr(Trans::Constants::INITIALIZING_TRANSLATIONS));
m_Translators = new Translators(this);
m_Translators->setPathToTranslations(m_Settings->path(ISettings::TranslationsPath));
// Qt
m_Translators->addNewTranslator("qt");
// Core Needed Libs
m_Translators->addNewTranslator(Trans::Constants::CONSTANTS_TRANSLATOR_NAME);
m_Translators->addNewTranslator("lib_utils");
m_Translators->addNewTranslator("plugin_ftbcore");
if (logChrono)
Utils::Log::logTimeElapsed(chrono, "Core", "translators");
m_Theme->messageSplashScreen(tkTr(Trans::Constants::STARTING_APPLICATION_AT_1).arg(QDateTime::currentDateTime().toString()));
m_FileManager = new FileManager(this);
m_UpdateChecker = new Utils::UpdateChecker(this);
LOG_FOR("Core", tkTr(Trans::Constants::STARTING_APPLICATION_AT_1).arg( QDateTime::currentDateTime().toString()));
// initialize the settings
m_Theme->messageSplashScreen(tkTr(Trans::Constants::LOADING_SETTINGS));
// WINE compatibility (only for testing under ubuntu when crosscompiling)
#ifdef Q_OS_WIN
// For WINE testings
// if (m_CommandLine->value(Core::CommandLine::CL_RunningUnderWine).toBool()) {
// LOG_FOR( "Core", "Running under Wine environnement." );
// QFont::insertSubstitution("MS Shell Dlg", "Tahoma" );
// QFont::insertSubstitution("MS Shell Dlg 2", "Tahoma" );
// }
#endif
foreach(const QString &l, QCoreApplication::libraryPaths()) {
LOG_FOR("Core" , tkTr(Trans::Constants::USING_LIBRARY_1).arg(l));
}
void Spider::start(){
XpathUtil *util = new XpathUtil(page);
int count = 0;
global::unVisitedUrl->pop();
global::unVisitedUrl->pop();
while (!global::unVisitedUrl->empty())
{
Node node = global::unVisitedUrl->top();
this->node = node;
//判断url是否本地采集过
if(global::bf->contains(node.url.toStdString())){
qDebug()<< node.url<<" already crawled before !";
global::unVisitedUrl->pop();
continue;
}
count++;
qDebug()<<count;
//判断数据采集节点是否服务器已经采集过
if(node.depth == global::maxDepth){
instance->flag = false;
instance->getService = true;
if(this->get(instance,node.url)){
qDebug()<<"elasticesearch indexed :" +node.url;
logInfo(QString::number(count)+" elasticesearch indexed :"+node.url);
global::bf->insert(node.url.toStdString());
global::unVisitedUrl->pop();
continue;
}
}
logInfo(QString::number(count)+" load url :"+node.url);
qDebug()<<"load url :"+node.url;
page->flag = true;
page->mainFrame()->load(QUrl(node.url));
QEventLoop eventLoop;
QObject::connect(page, SIGNAL(loadFinished(bool)), &eventLoop, SLOT(quit()));
QTimer timer;
timer.setSingleShot(true);
QObject::connect(&timer,SIGNAL(timeout()),&eventLoop,SLOT(quit()));
//5s
timer.start(5000);
eventLoop.exec(); //block until finish
if(timer.isActive()){
timer.stop();
}
//采集数据节点
int emptyCount = 0;
if(node.depth == global::maxDepth){
page->flag = true;
QMap<int,QStringList> result;
QMap<QString, QVariant> map;
emptyCount=0;
for(int j=0;j<node.collectData.size()-3;j++){
QStringList tmpResult;
QString nameFiled = node.collectData.at(j)["name"];
QString resultFiled = util->parserXpath(page,node.collectData.at(j)["xpath"],node.collectData.at(j)["type"].toInt());
//logInfo("[collect data ] nameFiled : "+nameFiled +" resultFiled :"+resultFiled);
//logInfo("debug : "+node.collectData.at(j)["xpath"]+ " debug :"+node.collectData.at(j)["type"]);
tmpResult.append(nameFiled);
tmpResult.append(resultFiled);
result.insert(j+1,tmpResult);
map.insert(nameFiled,resultFiled);
if(resultFiled.trimmed()==""){
emptyCount++;
}
}
QStringList tmpResult;
tmpResult.append("url");
tmpResult.append(node.url);
result.insert(node.collectData.size()-2,tmpResult);
map.insert("url",node.url);
QStringList tmpResult2;
tmpResult2.append("来源");
tmpResult2.append(global::taskID);
result.insert(node.collectData.size()-1,tmpResult2);
map.insert("来源",global::taskID);
QDateTime current_date_time = QDateTime::currentDateTime();
QString current_date = current_date_time.toString("yyyy-MM-dd hh:mm:ss");
QStringList tmpResult3;
tmpResult3.append("采集时间");
tmpResult3.append(current_date);
map.insert("采集时间",current_date);
result.insert(node.collectData.size(),tmpResult3);
if(emptyCount<7){
global::sqlite->insertXpathResult(global::taskID,result);
this->post(map,instance);
}
}else{
//非采集节点
page->flag = false;
//qDebug()<<page->mainFrame()->toHtml();
for(int j=0;j<node.regionXpath.size();j++){
qDebug()<<"region xpath";
this->node = (*(global::nodeMap))[node.depth];
this->isRegionNode = true;
this->currentSubNode = node.regionXpath.at(j);
qDebug()<<"--------------------------";
qDebug()<<"REGION :GET URL FROM XPATH";
//QStringList regionUrlResult = util->getUrlFromXpath(page,node.regionXpath.at(j).value);
QString html = util->parserXpath(page,node.regionXpath.at(j).value,2);
qDebug()<<"------------------html";
int time=1;
while(html==""){
QTime t;
t.start();
while(t.elapsed()<time*1000){
QCoreApplication::processEvents();
}
time++;
html = util->parserXpath(page,node.regionXpath.at(j).value,2);
if(time>=5){
break;
}
}
qDebug()<<"time***********";
qDebug()<<time;
QStringList regionUrlResult = util->getUrl(html);
// for(int i=0;i<regionUrlResult.length();i++){
// qDebug()<< "GET URL FROM XPATH";
// qDebug()<< regionUrlResult.at(i);
// addUrlToQueue(regionUrlResult.at(i));
// }
int count = util->getANodeNumFromXpath(page,node.regionXpath.at(j).value);
qDebug()<<"**********************";
qDebug()<<count;
qDebug()<<"**********************";
if(count==0){
count = util->getANodeNumFromXpath(page,node.regionXpath.at(j).value);
}
for(int m=0;m<count;m++){
util->clickNodeAtCount(page,node.regionXpath.at(j).value,m);
}
}
for(int j=0;j<node.loopXpath.size();j++){
qDebug()<<"loop xpath";
this->node = (*(global::nodeMap))[node.depth];
this->isRegionNode = false;
qDebug()<<"--------------------------";
qDebug()<<"LOOP :GET URL FROM XPATH";
QStringList loopUrlResult = util->getUrlFromXpath(page,node.loopXpath.at(j).value);
for(int i=0;i<loopUrlResult.length();i++){
qDebug()<< "GET URL FROM XPATH";
qDebug()<< loopUrlResult.at(i);
addUrlToQueue(loopUrlResult.at(i));
}
int count = util->getANodeNumFromXpath(page,node.loopXpath.at(j).value);
for(int m=0;m<count;m++){
util->clickNodeAtCount(page,node.loopXpath.at(j).value,m);
}
}
}
global::bf->insert(node.url.toStdString());
global::unVisitedUrl->pop();
}
logInfo("spider finished");
emit finish();
qDebug()<<"spider finished";
}
// This requires all the Grids be of the same size and all the orbitals to be
// of the same spin. Returns true only if something was calculated.
bool MolecularOrbitals::computeOrbitalGrids(Data::GridDataList& grids)
{
if (grids.isEmpty()) return false;;
// Check that the grids are all of the same size and Spin
Data::GridData* g0(grids[0]);
QList<int> orbitals;
Data::GridDataList::iterator iter;
for (iter = grids.begin(); iter != grids.end(); ++iter) {
qDebug() << "Computing grid" << (*iter)->surfaceType().toString() ;
(*iter)->size().dump();
if ( ((*iter)->size() != g0->size()) ) {
QLOG_ERROR() << "Different sized grids found in molecular orbitals calculator";
return false;
}
if ( ((*iter)->surfaceType().kind() != Data::SurfaceType::AlphaOrbital) &&
((*iter)->surfaceType().kind() != Data::SurfaceType::BetaOrbital) ) {
QLOG_ERROR() << "Incorrect grid type found in molecular orbitals calculator";
QLOG_ERROR() << (*iter)->surfaceType().toString();
return false;
}
orbitals.append((*iter)->surfaceType().index()-1);
}
QTime time;
time.start();
Matrix const* coefficients;
if (g0->surfaceType().kind() == Data::SurfaceType::AlphaOrbital) {
QLOG_TRACE() << "Setting MO coefficient data to Alpha";
coefficients = &(m_molecularOrbitals.alphaCoefficients());
}else {
QLOG_TRACE() << "Setting MO coefficient data to Beta";
coefficients = &(m_molecularOrbitals.betaCoefficients());
}
unsigned nOrb(orbitals.size());
unsigned nx, ny, nz;
g0->getNumberOfPoints(nx, ny, nz);
Vec delta(g0->delta());
Vec origin(g0->origin());
QProgressDialog progressDialog("Calculating orbital grid data", "Cancel", 0,
nx, QApplication::activeWindow());
int progress(0);
progressDialog.setValue(progress);
progressDialog.setWindowModality(Qt::WindowModal);
progressDialog.show();
double x, y, z;
double* values;
double* tmp = new double[nOrb];
unsigned i, j, k;
Data::ShellList const& shells(m_molecularOrbitals.shellList());
Data::ShellList::const_iterator shell;
for (i = 0, x = origin.x; i < nx; ++i, x += delta.x) {
for (j = 0, y = origin.y; j < ny; ++j, y += delta.y) {
for (k = 0, z = origin.z; k < nz; ++k, z += delta.z) {
Vec gridPoint(x,y,z);
for (unsigned orb = 0; orb < nOrb; ++orb) tmp[orb] = 0.0;
unsigned count(0);
//-----------------------------------------------------
for (shell = shells.begin(); shell != shells.end(); ++shell) {
if ( (values = (*shell)->evaluate(gridPoint)) ) {
for (unsigned s = 0; s < (*shell)->nBasis(); ++s) {
for (unsigned orb = 0; orb < nOrb; ++orb) {
tmp[orb] += (*coefficients)(orbitals[orb], count) * values[s];
}
++count;
}
}else {
count += (*shell)->nBasis();
}
}
for (unsigned orb = 0; orb < nOrb; ++orb) {
(*grids.at(orb))(i, j, k) = tmp[orb];
}
//-----------------------------------------------------
}
}
++progress;
progressDialog.setValue(progress);
if (progressDialog.wasCanceled()) return false;
}
delete [] tmp;
double t = time.elapsed() / 1000.0;
QLOG_INFO() << "Time to compute orbital grid data:" << t << "seconds";
return true;
}
bool MolecularOrbitals::computeDensityGrids(Data::GridData*& alpha, Data::GridData*& beta)
{
QTime time;
time.start();
unsigned nx, ny, nz;
alpha->getNumberOfPoints(nx, ny, nz);
Vec delta(alpha->delta());
Vec origin(alpha->origin());
// We take a two pass approach, the first computes data on a grid with half
// the number of points for each dimension (so a factor of 8 fewer points
// than the target grid). We then used these values in a subsequent pass to
// refine only those parts with significant density.
unsigned totalProgress(8*nx); // first and second passes
unsigned progress(0);
unsigned i, j, k;
double x, y, z;
QProgressDialog progressDialog("Calculating density grid data", "Cancel", 0,
totalProgress, QApplication::activeWindow());
progressDialog.setValue(progress);
progressDialog.setWindowModality(Qt::WindowModal);
progressDialog.show();
for (i = 0, x = origin.x; i < nx; i += 2, x += 2*delta.x) {
for (j = 0, y = origin.y; j < ny; j += 2, y += 2*delta.y) {
for (k = 0, z = origin.z; k < nz; k += 2, z += 2*delta.z) {
Vec gridPoint(x, y, z);
computeShellPairs(gridPoint);
(*alpha)(i, j, k) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i, j, k) = inner_prod(m_betaDensity, m_shellPairValues);
}
}
++progress;
progressDialog.setValue(progress);
if (progressDialog.wasCanceled()) return false;
}
double a000, a001, a010, a011, a100, a101, a110, a111, aTot;
double b000, b001, b010, b011, b100, b101, b110, b111, bTot;
double thresh(0.125*Data::Shell::thresh());
origin += delta;
for (i = 1, x = origin.x; i < nx-1; i += 2, x += 2*delta.x) {
for (j = 1, y = origin.y; j < ny-1; j += 2, y += 2*delta.y) {
for (k = 1, z = origin.z; k < nz-1; k += 2, z += 2*delta.z) {
a000 = (*alpha)(i-1, j-1, k-1);
a001 = (*alpha)(i-1, j-1, k+1);
a010 = (*alpha)(i-1, j+1, k-1);
a011 = (*alpha)(i-1, j+1, k+1);
a100 = (*alpha)(i+1, j-1, k-1);
a101 = (*alpha)(i+1, j-1, k+1);
a110 = (*alpha)(i+1, j+1, k-1);
a111 = (*alpha)(i+1, j+1, k+1);
aTot = a000+a001+a010+a011+a100+a101+a110+a111;
b000 = (*beta)(i-1, j-1, k-1);
b001 = (*beta)(i-1, j-1, k+1);
b010 = (*beta)(i-1, j+1, k-1);
b011 = (*beta)(i-1, j+1, k+1);
b100 = (*beta)(i+1, j-1, k-1);
b101 = (*beta)(i+1, j-1, k+1);
b110 = (*beta)(i+1, j+1, k-1);
b111 = (*beta)(i+1, j+1, k+1);
bTot = b000+b001+b010+b011+b100+b101+b110+b111;
if (std::abs(aTot) > thresh || std::abs(bTot) > thresh) {
computeShellPairs(Vec(x, y, z));
(*alpha)(i, j, k ) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i, j, k ) = inner_prod(m_betaDensity, m_shellPairValues);
computeShellPairs(Vec(x, y, z-delta.z));
(*alpha)(i, j, k-1) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i, j, k-1) = inner_prod(m_betaDensity, m_shellPairValues);
computeShellPairs(Vec(x, y-delta.y, z));
(*alpha)(i, j-1,k ) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i, j-1,k ) = inner_prod(m_betaDensity, m_shellPairValues);
computeShellPairs(Vec(x, y-delta.y, z-delta.z));
(*alpha)(i, j-1,k-1) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i, j-1,k-1) = inner_prod(m_betaDensity, m_shellPairValues);
computeShellPairs(Vec(x-delta.x, y, z));
(*alpha)(i-1,j, k ) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i-1,j, k ) = inner_prod(m_betaDensity, m_shellPairValues);
computeShellPairs(Vec(x-delta.x, y, z-delta.z));
(*alpha)(i-1,j, k-1) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i-1,j, k-1) = inner_prod(m_betaDensity, m_shellPairValues);
computeShellPairs(Vec(x-delta.x, y-delta.y, z));
(*alpha)(i-1,j-1,k ) = inner_prod(m_alphaDensity, m_shellPairValues);
(*beta )(i-1,j-1,k ) = inner_prod(m_betaDensity, m_shellPairValues);
}else {
(*alpha)(i, j, k ) = 0.125*aTot;
(*beta )(i, j, k ) = 0.125*bTot;
(*alpha)(i, j, k-1) = 0.25*(a000+a010+a100+a110);
(*beta )(i, j, k-1) = 0.25*(b000+b010+b100+b110);
(*alpha)(i, j-1,k ) = 0.25*(a000+a001+a100+a101);
(*beta )(i, j-1,k ) = 0.25*(b000+b001+b100+b101);
(*alpha)(i, j-1,k-1) = 0.50*(a000+a100);
(*beta )(i, j-1,k-1) = 0.50*(b000+b100);
(*alpha)(i-1,j, k ) = 0.25*(a000+a001+a010+a011);
(*beta )(i-1,j, k ) = 0.25*(b000+b001+b010+b011);
(*alpha)(i-1,j, k-1) = 0.50*(a000+a010);
(*beta )(i-1,j, k-1) = 0.50*(b000+b010);
(*alpha)(i-1,j-1,k ) = 0.50*(a000+a001);
(*beta )(i-1,j-1,k ) = 0.50*(b000+b001);
}
}
}
progress += 7;
progressDialog.setValue(progress);
if (progressDialog.wasCanceled()) return false;
}
// qDebug() << "End of calculation" << nPoints << count << progress;
double t = time.elapsed() / 1000.0;
QLOG_INFO() << "Time to compute density grid data:" << t << "seconds";
return true;
}
void Interpreter::run()
{
int res;
QTime time;
// init
try
{
ChirpProc versionProc;
uint16_t *version;
uint32_t verLen, responseInt;
if (m_link.open()<0)
throw std::runtime_error("Unable to open USB device.");
m_chirp = new ChirpMon(this, &m_link);
// get version and compare
versionProc = m_chirp->getProc("version");
if (versionProc<0)
throw std::runtime_error("Can't get firmware version.");
res = m_chirp->callSync(versionProc, END_OUT_ARGS, &responseInt, &verLen, &version, END_IN_ARGS);
if (res<0)
throw std::runtime_error("Can't get firmware version.");
memcpy(m_version, version, 3*sizeof(uint16_t));
if (m_version[0]!=VER_MAJOR || m_version[1]>VER_MINOR)
{
char buf[0x100];
sprintf(buf, "This Pixy's firmware version (%d.%d.%d) is not compatible with this PixyMon version (%d.%d.%d).",
m_version[0], m_version[1], m_version[2], VER_MAJOR, VER_MINOR, VER_BUILD);
throw std::runtime_error(buf);
}
m_exec_run = m_chirp->getProc("run");
m_exec_running = m_chirp->getProc("running");
m_exec_stop = m_chirp->getProc("stop");
m_exec_get_action = m_chirp->getProc("getAction");
m_get_param = m_chirp->getProc("prm_get");
m_getAll_param = m_chirp->getProc("prm_getAll");
m_set_param = m_chirp->getProc("prm_set");
if (m_exec_run<0 || m_exec_running<0 || m_exec_stop<0 || m_exec_get_action<0 ||
m_get_param<0 || m_getAll_param<0 || m_set_param<0)
throw std::runtime_error("Communication error with Pixy.");
}
catch (std::runtime_error &exception)
{
emit error(QString(exception.what()));
return;
}
qDebug() << "*** init done";
time.start();
getRunning();
handleLoadParams(); // load params upon initialization
while(m_run)
{
if (!m_programming &&
((m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_FAST) ||
(!m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_SLOW)))
{
getRunning();
time.start();
}
else
{
m_chirp->service(false);
msleep(1); // give config thread time to run
}
handlePendingCommand();
if (!m_running)
{
if (m_localProgramRunning)
execute();
else
{
Sleeper::msleep(10);
if (m_mutexProg.tryLock())
{
if (m_argv.size())
{
if (m_externalCommand!="") // print command to make things explicit and all pretty
emit textOut(PROMPT " " + m_externalCommand);
if (m_argv[0]=="help")
handleHelp();
else
{
res = call(m_argv, true);
if (res<0)
{
if (m_programming)
{
endLocalProgram();
clearLocalProgram();
}
m_commandList.clear(); // abort our little scriptlet
}
}
m_argv.clear();
if (m_externalCommand=="")
prompt(); // print prompt only if we expect an actual human to be typing into the command window
else
m_externalCommand = "";
// check quickly to see if we're running after this command
if (!m_programming)
getRunning();
// is there another command in our little scriptlet?
if (m_commandList.size())
{
execute(m_commandList[0]);
m_commandList.removeFirst();
}
}
m_mutexProg.unlock();
}
}
}
}
sendStop();
msleep(200); // let things settle a bit
qDebug("worker thead exiting");
}
// This is called from the AnalyserQueue thread
bool AnalyserQueue::doAnalysis(TrackPointer tio, SoundSourceProxy* pSoundSource) {
int totalSamples = pSoundSource->length();
//qDebug() << tio->getFilename() << " has " << totalSamples << " samples.";
int processedSamples = 0;
QTime progressUpdateInhibitTimer;
progressUpdateInhibitTimer.start(); // Inhibit Updates for 60 milliseconds
int read = 0;
bool dieflag = false;
bool cancelled = false;
int progress; // progress in 0 ... 100
do {
ScopedTimer t("AnalyserQueue::doAnalysis block");
read = pSoundSource->read(kAnalysisBlockSize, m_pSamplesPCM);
// To compare apples to apples, let's only look at blocks that are the
// full block size.
if (read != kAnalysisBlockSize) {
t.cancel();
}
// Safety net in case something later barfs on 0 sample input
if (read == 0) {
t.cancel();
break;
}
// If we get more samples than length, ask the analysers to process
// up to the number we promised, then stop reading - AD
if (read + processedSamples > totalSamples) {
qDebug() << "While processing track of length " << totalSamples << " actually got "
<< read + processedSamples << " samples, truncating analysis at expected length";
read = totalSamples - processedSamples;
dieflag = true;
}
// Normalize the samples from [SHRT_MIN, SHRT_MAX] to [-1.0, 1.0].
// TODO(rryan): Change the SoundSource API to do this for us.
for (int i = 0; i < read; ++i) {
m_pSamples[i] = static_cast<CSAMPLE>(m_pSamplesPCM[i]) / SHRT_MAX;
}
QListIterator<Analyser*> it(m_aq);
while (it.hasNext()) {
Analyser* an = it.next();
//qDebug() << typeid(*an).name() << ".process()";
an->process(m_pSamples, read);
//qDebug() << "Done " << typeid(*an).name() << ".process()";
}
// emit progress updates
// During the doAnalysis function it goes only to 100% - FINALIZE_PERCENT
// because the finalise functions will take also some time
processedSamples += read;
//fp div here prevents insane signed overflow
progress = (int)(((float)processedSamples)/totalSamples *
(1000 - FINALIZE_PERCENT));
if (m_progressInfo.track_progress != progress) {
if (progressUpdateInhibitTimer.elapsed() > 60) {
// Inhibit Updates for 60 milliseconds
emitUpdateProgress(tio, progress);
progressUpdateInhibitTimer.start();
}
}
// Since this is a background analysis queue, we should co-operatively
// yield every now and then to try and reduce CPU contention. The
// analyser queue is CPU intensive so we want to get out of the way of
// the audio callback thread.
//QThread::yieldCurrentThread();
//QThread::usleep(10);
//has something new entered the queue?
if (deref(m_aiCheckPriorities)) {
m_aiCheckPriorities = false;
if (isLoadedTrackWaiting(tio)) {
qDebug() << "Interrupting analysis to give preference to a loaded track.";
dieflag = true;
cancelled = true;
}
}
if (m_exit) {
dieflag = true;
cancelled = true;
}
// Ignore blocks in which we decided to bail for stats purposes.
if (dieflag || cancelled) {
t.cancel();
}
} while(read == kAnalysisBlockSize && !dieflag);
return !cancelled; //don't return !dieflag or we might reanalyze over and over
}
bool GribV2::loadFile(QString fileName) {
FILE * fptr=NULL;
int msg=0;
this->fileName=fileName;
QTime tLoad;
int m_sec_readCgrib=0;
int m_sec_ginfo=0;
int m_sec_g2_getfld=0;
int m_sec_grecConst=0;
int m_sec_endLoop=0;
qWarning() << "GV2 loading " << fileName;
g2int lskip=0,lgrib=0,iseek=0;
unsigned char *cgrib; // msg buffer
g2int ierr,listsec0[3],listsec1[13],numfields,numlocal;
std::string fname = qPrintable(fileName);
if(fileName == "") return false;
gribfield *gfld=NULL;
ok=false;
fptr=fopen(fname.c_str(),"rb");
if(!fptr) {
qWarning() << "Can't open Grib2 file (in loadFile): " << fileName;
return false;
}
fseek(fptr,0,SEEK_END);
fileSize=ftell(fptr);
rewind(fptr);
/* clean data structure + iso lines */
clean_all_vectors();
Util::cleanListPointers(listIsobars);
Util::cleanListPointers(listIsotherms0);
for(;;) {
msg++;
seekgb(fptr,iseek,32000,&lskip,&lgrib);
if (lgrib == 0) break; // end loop at EOF or problem
cgrib=(unsigned char *)malloc(lgrib);
fseek(fptr,lskip,SEEK_SET);
tLoad.start();
fread(cgrib,sizeof(unsigned char),lgrib,fptr);
m_sec_readCgrib+=tLoad.elapsed();
//qWarning() << "Size of cgrib: " << lgrib << ", skip=" << lskip;
//qWarning() << "Bytes read from file: " << bRead;
//qWarning() << "EOF=" << feof(fptr) << ", ferror=" << ferror(fptr);
//qWarning() << "File pos=" << ftell(fptr);
//qWarning() << "End of grib=" << cgrib[lgrib-4] << cgrib[lgrib-3] << cgrib[lgrib-2] << cgrib[lgrib-1];
iseek=lskip+lgrib;
tLoad.start();
ierr=g2_info(cgrib,listsec0,listsec1,&numfields,&numlocal);
m_sec_ginfo+=tLoad.elapsed();
if(ierr) {
qWarning() << "msg " << msg << ": g2_info error num=" << ierr;
fclose(fptr);
return false;
}
// accepting only GRIB2 with discipline=0 => Meteorological product (table 0.0)
if(listsec0[1]!=2 || (listsec0[0]!=0 && listsec0[0]!=10)) {
qWarning() << "msg " << msg << ": wrong version " << listsec0[1] << ", or discipline: " << listsec0[0];
continue;
}
if(listsec1[4]!=1) {
qWarning() << "msg " << msg << ": wrong reference time type: " << listsec1[4];
continue;
}
/* loop on th fields => 1 field = 1 GribRecord */
//qWarning() << "nb fields=" << numfields << ", nb locals=" << numlocal;
for(int i=0;i<numfields;++i) {
tLoad.start();
ierr=g2_getfld(cgrib,i+1,GRB2_UNPACK,GRB2_EXPAND,&gfld);
m_sec_g2_getfld+=tLoad.elapsed();
if(ierr) {
qWarning() << "msg=" << msg << "- field=" << i << ": g2_getfld error num=" << ierr;
continue;
}
tLoad.start();
GribV2Record * record = new GribV2Record(gfld,msg,i);
m_sec_grecConst+=tLoad.elapsed();
tLoad.start();
if(record && record->isOk() && record->isDataKnown())
addRecord(record);
else
if(record) delete record;
g2_free(gfld);
m_sec_endLoop+=tLoad.elapsed();
}
free(cgrib);
}
if(fptr) fclose(fptr);
qWarning() << "GRIBV2 load finished";
qWarning() << "NB key: " << mapGribRecords.size();
qWarning() << "List:";
std::map <long int, QMap<time_t,GribRecord *>* >::iterator it;
int i=0;
for(it=mapGribRecords.begin();it!=mapGribRecords.end();++it) {
qWarning() << "key " << i << ": key= " << it->first << ", nb elem" << it->second->size();
++i;
}
qWarning() << "Time stat:";
qWarning() << "\t read Cgrib: " << m_sec_readCgrib;
qWarning() << "\t call gInfo: " << m_sec_ginfo;
qWarning() << "\t call getFld: " << m_sec_g2_getfld;
qWarning() << "\t const GribRecordV2: " << m_sec_grecConst;
qWarning() << "\t End loop: " << m_sec_endLoop;
createDewPointData();
ok=true;
return true;
}
void ConversationModelPerfTest::getEvents()
{
QFETCH(int, messages);
QFETCH(int, contacts);
QFETCH(int, limit);
qRegisterMetaType<QModelIndex>("QModelIndex");
QDateTime startTime = QDateTime::currentDateTime();
addTestGroups( group1, group2 );
int commitBatchSize = 75;
#ifdef PERF_BATCH_SIZE
commitBatchSize = PERF_BATCH_SIZE;
#endif
EventModel addModel;
QDateTime when = QDateTime::currentDateTime();
QList<QString> remoteUids;
qDebug() << __FUNCTION__ << "- Creating" << contacts << "new contacts";
int ci = 0;
while(ci < contacts) {
ci++;
QString phoneNumber = QString().setNum(qrand() % 10000000);
remoteUids << phoneNumber;
addTestContact(QString("Test Contact %1").arg(ci), phoneNumber);
if(ci % commitBatchSize == 0 && ci < contacts) {
qDebug() << __FUNCTION__ << "- adding" << commitBatchSize
<< "contacts (" << ci << "/" << contacts << ")";
waitForIdle(5000);
}
}
qDebug() << __FUNCTION__ << "- adding rest of the contacts ("
<< ci << "/" << contacts << ")";
waitForIdle(5000);
QTest::qWait(TIMEOUT);
qDebug() << __FUNCTION__ << "- Creating" << messages << "new messages";
QList<Event> eventList;
int ei = 0;
while(ei < messages) {
ei++;
Event::EventDirection direction;
direction = qrand() % 2 > 0 ? Event::Inbound : Event::Outbound;
Event e;
e.setType(Event::SMSEvent);
e.setDirection(direction);
e.setGroupId(group1.id());
e.setStartTime(when.addSecs(ei));
e.setEndTime(when.addSecs(ei));
e.setLocalUid(ACCOUNT1);
e.setRemoteUid(remoteUids.at(0));
e.setFreeText(randomMessage(qrand() % 49 + 1)); // Max 50 words / message
e.setIsDraft(false);
e.setIsMissedCall(false);
eventList << e;
if(ei % commitBatchSize == 0 && ei != messages) {
qDebug() << __FUNCTION__ << "- adding" << commitBatchSize
<< "messages (" << ei << "/" << messages << ")";
QVERIFY(addModel.addEvents(eventList, false));
eventList.clear();
waitForIdle();
}
}
QVERIFY(addModel.addEvents(eventList, false));
qDebug() << __FUNCTION__ << "- adding rest of the messages ("
<< ei << "/" << messages << ")";
eventList.clear();
waitForIdle();
int iterations = 10;
int sum = 0;
QList<int> times;
#ifdef PERF_ITERATIONS
iterations = PERF_ITERATIONS;
#endif
char *iterVar = getenv("PERF_ITERATIONS");
if (iterVar) {
int iters = QString::fromAscii(iterVar).toInt();
if (iters > 0) {
iterations = iters;
}
}
QTest::qWait(TIMEOUT);
qDebug() << __FUNCTION__ << "- Fetching messages." << iterations << "iterations";
for(int i = 0; i < iterations; i++) {
ConversationModel fetchModel;
bool result = false;
QSignalSpy rowsInserted(&fetchModel, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
if (limit < 0) {
fetchModel.setQueryMode(EventModel::SyncQuery);
} else {
fetchModel.setQueryMode(EventModel::StreamedAsyncQuery);
fetchModel.setFirstChunkSize(limit);
fetchModel.setChunkSize(limit);
}
QTime time;
time.start();
result = fetchModel.getEvents(group1.id());
if(limit >= 0) {
while (time.elapsed() < 10000 && rowsInserted.isEmpty())
QCoreApplication::processEvents();
}
int elapsed = time.elapsed();
times << elapsed;
sum += elapsed;
qDebug("Time elapsed: %d ms", elapsed);
QVERIFY(result);
QVERIFY(fetchModel.rowCount() > 0);
// With 1000 messages deleting model right away results in segfault
waitForIdle();
}
if(logFile) {
QTextStream out(logFile);
out << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss") << ": "
<< metaObject()->className() << "::" << QTest::currentTestFunction() << "("
<< QTest::currentDataTag() << ", " << iterations << " iterations)"
<< "\n";
for (int i = 0; i < times.size(); i++) {
out << times.at(i) << " ";
}
out << "\n";
}
qSort(times);
float median = 0.0;
if(iterations % 2 > 0) {
median = times[(int)(iterations / 2)];
} else {
median = (times[iterations / 2] + times[iterations / 2 - 1]) / 2.0f;
}
float mean = sum / (float)iterations;
int testSecs = startTime.secsTo(QDateTime::currentDateTime());
qDebug("##### Mean: %.1f; Median: %.1f; Test time: %dsec", mean, median, testSecs);
if(logFile) {
QTextStream out(logFile);
out << "Median average: " << (int)median << " ms. Test time: ";
if (testSecs > 3600) { out << (testSecs / 3600) << "h "; }
if (testSecs > 60) { out << ((testSecs % 3600) / 60) << "m "; }
out << ((testSecs % 3600) % 60) << "s\n";
}
}
//............................................................................
bool QP::QS::onStartup(void const *) {
static uint8_t qsBuf[4*1024]; // 4K buffer for Quantum Spy
initBuf(qsBuf, sizeof(qsBuf));
QSPY_config(QP_VERSION, // version
QS_OBJ_PTR_SIZE, // objPtrSize
QS_FUN_PTR_SIZE, // funPtrSize
QS_TIME_SIZE, // tstampSize
Q_SIGNAL_SIZE, // sigSize,
QF_EVENT_SIZ_SIZE, // evtSize
QF_EQUEUE_CTR_SIZE, // queueCtrSize
QF_MPOOL_CTR_SIZE, // poolCtrSize
QF_MPOOL_SIZ_SIZE, // poolBlkSize
QF_TIMEEVT_CTR_SIZE,// tevtCtrSize
(void *)0, // matFile,
(void *)0,
&custParserFun); // customized parser function
l_time.start(); // start the time stamp
// set up the QS filters...
// QS_FILTER_ON(QS_QEP_STATE_ENTRY);
// QS_FILTER_ON(QS_QEP_STATE_EXIT);
// QS_FILTER_ON(QS_QEP_STATE_INIT);
// QS_FILTER_ON(QS_QEP_INIT_TRAN);
// QS_FILTER_ON(QS_QEP_INTERN_TRAN);
// QS_FILTER_ON(QS_QEP_TRAN);
// QS_FILTER_ON(QS_QEP_IGNORED);
// QS_FILTER_ON(QS_QEP_DISPATCH);
// QS_FILTER_ON(QS_QEP_UNHANDLED);
// QS_FILTER_ON(QS_QF_ACTIVE_ADD);
// QS_FILTER_ON(QS_QF_ACTIVE_REMOVE);
// QS_FILTER_ON(QS_QF_ACTIVE_SUBSCRIBE);
// QS_FILTER_ON(QS_QF_ACTIVE_UNSUBSCRIBE);
// QS_FILTER_ON(QS_QF_ACTIVE_POST_FIFO);
// QS_FILTER_ON(QS_QF_ACTIVE_POST_LIFO);
// QS_FILTER_ON(QS_QF_ACTIVE_GET);
// QS_FILTER_ON(QS_QF_ACTIVE_GET_LAST);
// QS_FILTER_ON(QS_QF_EQUEUE_INIT);
// QS_FILTER_ON(QS_QF_EQUEUE_POST_FIFO);
// QS_FILTER_ON(QS_QF_EQUEUE_POST_LIFO);
// QS_FILTER_ON(QS_QF_EQUEUE_GET);
// QS_FILTER_ON(QS_QF_EQUEUE_GET_LAST);
// QS_FILTER_ON(QS_QF_MPOOL_INIT);
QS_FILTER_ON(QS_QF_MPOOL_GET);
// QS_FILTER_ON(QS_QF_MPOOL_PUT);
// QS_FILTER_ON(QS_QF_PUBLISH);
// QS_FILTER_ON(QS_QF_RESERVED8);
// QS_FILTER_ON(QS_QF_NEW);
// QS_FILTER_ON(QS_QF_GC_ATTEMPT);
// QS_FILTER_ON(QS_QF_GC);
// QS_FILTER_ON(QS_QF_TICK);
// QS_FILTER_ON(QS_QF_TIMEEVT_ARM);
// QS_FILTER_ON(QS_QF_TIMEEVT_AUTO_DISARM);
// QS_FILTER_ON(QS_QF_TIMEEVT_DISARM_ATTEMPT);
// QS_FILTER_ON(QS_QF_TIMEEVT_DISARM);
// QS_FILTER_ON(QS_QF_TIMEEVT_REARM);
// QS_FILTER_ON(QS_QF_TIMEEVT_POST);
// QS_FILTER_ON(QS_QF_TIMEEVT_CTR);
// QS_FILTER_ON(QS_QF_CRIT_ENTRY);
// QS_FILTER_ON(QS_QF_CRIT_EXIT);
// QS_FILTER_ON(QS_QF_ISR_ENTRY);
// QS_FILTER_ON(QS_QF_ISR_EXIT);
// QS_FILTER_ON(QS_QF_INT_DISABLE);
// QS_FILTER_ON(QS_QF_INT_ENABLE);
// QS_FILTER_ON(QS_QF_ACTIVE_POST_ATTEMPT);
// QS_FILTER_ON(QS_QF_EQUEUE_POST_ATTEMPT);
// QS_FILTER_ON(QS_QF_MPOOL_GET_ATTEMPT);
// QS_FILTER_ON(QS_QF_RESERVED1);
// QS_FILTER_ON(QS_QF_RESERVED0);
// QS_FILTER_ON(QS_QK_MUTEX_LOCK);
// QS_FILTER_ON(QS_QK_MUTEX_UNLOCK);
// QS_FILTER_ON(QS_QK_SCHEDULE);
// QS_FILTER_ON(QS_QK_RESERVED1);
// QS_FILTER_ON(QS_QK_RESERVED0);
// QS_FILTER_ON(QS_QEP_TRAN_HIST);
// QS_FILTER_ON(QS_QEP_TRAN_EP);
// QS_FILTER_ON(QS_QEP_TRAN_XP);
// QS_FILTER_ON(QS_QEP_RESERVED1);
// QS_FILTER_ON(QS_QEP_RESERVED0);
QS_FILTER_ON(QS_SIG_DICT);
QS_FILTER_ON(QS_OBJ_DICT);
QS_FILTER_ON(QS_FUN_DICT);
QS_FILTER_ON(QS_USR_DICT);
QS_FILTER_ON(QS_EMPTY);
QS_FILTER_ON(QS_RESERVED3);
QS_FILTER_ON(QS_RESERVED2);
QS_FILTER_ON(QS_TEST_RUN);
QS_FILTER_ON(QS_TEST_FAIL);
QS_FILTER_ON(QS_ASSERT_FAIL);
return true; // success
}
void PerspetiveRectificationWithQt::startAllPictures()
{
std::string picturePath = "picture";
std::string pathEnd = ".jpg";
readApexs();
QTime time;
time.start();
for(int pictureCounter=0;pictureCounter<NUMBER_OF_PICTURES;pictureCounter++) {
ostringstream ss;
ss << pictureCounter;
std::string number = ss.str();
std::string fullPath = picturePath+number+pathEnd;
IplImage* image = cvLoadImage(fullPath.c_str());
if(image!=NULL) {
InputQuadrangle* quadrangle = new InputQuadrangle();
quadrangle->setFirstPointToRectification(apexsMatrix[pictureCounter*(POINTS*2)+0],apexsMatrix[pictureCounter*(POINTS*2)+1]);
quadrangle->setSecondPointToRectification(apexsMatrix[pictureCounter*(POINTS*2)+2],apexsMatrix[pictureCounter*(POINTS*2)+3]);
quadrangle->setThirdPointToRectification(apexsMatrix[pictureCounter*(POINTS*2)+4],apexsMatrix[pictureCounter*(POINTS*2)+5]);
quadrangle->setFourthPointToRectification(apexsMatrix[pictureCounter*(POINTS*2)+6],apexsMatrix[pictureCounter*(POINTS*2)+7]);
/*std::string fullPathSource = "origin"+number+".jpg";
cvLine(image,cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+0],apexsMatrix[pictureCounter*(POINTS*2)+1]),cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+2],apexsMatrix[pictureCounter*(POINTS*2)+3]),cvScalar(0, 255, 0, 0),2);
cvLine(image,cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+2],apexsMatrix[pictureCounter*(POINTS*2)+3]),cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+4],apexsMatrix[pictureCounter*(POINTS*2)+5]),cvScalar(0, 255, 0, 0),2);
cvLine(image,cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+4],apexsMatrix[pictureCounter*(POINTS*2)+5]),cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+6],apexsMatrix[pictureCounter*(POINTS*2)+7]),cvScalar(0, 255, 0, 0),2);
cvLine(image,cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+6],apexsMatrix[pictureCounter*(POINTS*2)+7]),cvPoint(apexsMatrix[pictureCounter*(POINTS*2)+0],apexsMatrix[pictureCounter*(POINTS*2)+1]),cvScalar(0, 255, 0, 0),2);
cvSaveImage(fullPathSource.c_str(),image);*/
QTime time1;
time1.start();
DimensionCalculationThread* dimThread = new DimensionCalculationThread();
dimThread->setAllData(image,quadrangle);
dimThread->start();
while(dimThread->isRunning()) {
}
int milis = time1.elapsed();
ui.label_7->setNum(milis);
IplImage* output = cvCreateImage(cvSize(dimThread->mWidth, dimThread->mHeight),IPL_DEPTH_8U,3);
QTime time2;
time2.start();
HomographyCalculationThread *thread = new HomographyCalculationThread();
thread->setAllData(image,output,dimThread->mWidth,dimThread->mHeight,dimThread->mOldFirstApexX,dimThread->mOldFirstApexY
,dimThread->newPictureXApex,dimThread->newPictureYApex,dimThread->mPictureApexXPosition,dimThread->mPictureApexYPosition);
thread->start();
while(thread->isRunning()) {
}
int milis2 = time2.elapsed();
ui.label_8->setNum(milis2);
QTime time3;
time3.start();
RectificationThread* rectificationThread = new RectificationThread();
rectificationThread->setAllData(image,output,dimThread->mOldFirstApexX,dimThread->mOldFirstApexY,dimThread->mWidth,dimThread->mHeight,thread->getHMatrix());
rectificationThread->start();
while(rectificationThread->isRunning()) {
}
int milis3 = time3.elapsed();
ui.label_9->setNum(milis3);
delete quadrangle;
delete thread;
delete dimThread;
}
}
int milis = time.elapsed();
ui.label_2->setNum(milis);
}
int main(int argc, char *argv[]){
QTime t;
t.start();
//START APP
QApplication app(argc,argv);
app.setWindowIcon(QIcon(":/data/img/11412394_407750046078820_6932822019341529347_n.jpg"));
QApplication::setApplicationName("Huffman");
QApplication::setApplicationVersion("ÚNICO");
QQmlApplicationEngine engine;
QQmlContext *interpreter = engine.rootContext();
Huffman huff;
DHuffman deHuff;
QCommandLineParser parser;
//Parser
parser.addHelpOption();
parser.addVersionOption();
parser.setApplicationDescription("Huffman Parsers");
parser.addPositionalArgument("in-file.x", QCoreApplication::translate("main", "File being compressed."));
parser.addPositionalArgument("out-name.huff", QCoreApplication::translate("main", "Name to save archive."));
//parser.addPositionalArgument("dir", QCoreApplication::translate("main", "Dir being compressed"));
parser.addPositionalArgument("local", QCoreApplication::translate("main", "Local to save archive."));
QCommandLineOption compress("c",QApplication::translate("main","Compress <in-file.x>."),
QApplication::translate("main","in-file.x"));
parser.addOption(compress);
QCommandLineOption outName("o",QApplication::translate("main","Save as <out-name.huff>."),
QApplication::translate("main","out-file.huff"));
parser.addOption(outName);
QCommandLineOption local("d",QApplication::translate("main","Decompress in <local>."),
QApplication::translate("main","local"));
parser.addOption(local);
QCommandLineOption startGui({"g", "gui"},QApplication::translate("main","Start gui."));
parser.addOption(startGui);
parser.process(app);
//ARGUMENTS
if(parser.isSet(startGui)){
interpreter->setContextProperty("_huff",&huff);
interpreter->setContextProperty("_dehuff",&deHuff);
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
}
else if(parser.isSet(compress) && parser.isSet(outName))
{
cout << "case 1" << endl;
huff.Huff(parser.value(compress),parser.value(outName));
}
else if(parser.isSet(compress))
{
cout << "case 2" << endl;
huff.Huff(parser.value(compress),parser.value(compress));
}
else{
if(app.arguments().size() == 1)
qDebug() << qPrintable(parser.helpText());
else if(parser.isSet(local))
deHuff.DHuff(app.arguments().at(1),parser.value(local));
else
deHuff.DHuff(app.arguments().at(1),app.arguments().at(1));
}
//END APP
qDebug("%s <> Tempo de execução: %d ms",Q_FUNC_INFO,t.elapsed());
return app.exec();
}
bool WinDebugInterface::runLoop()
{
m_waitHandles[TerminateEventHandle] = CreateEvent(NULL, FALSE, FALSE, NULL);
if (GetLastError() == ERROR_ALREADY_EXISTS)
return false;
m_waitHandles[DataReadyEventHandle] = CreateEvent(NULL, FALSE, FALSE, L"DBWIN_DATA_READY");
if (!m_waitHandles[TerminateEventHandle] || !m_waitHandles[DataReadyEventHandle]
|| GetLastError() == ERROR_ALREADY_EXISTS)
return false;
m_bufferReadyEvent = CreateEvent(NULL, FALSE, FALSE, L"DBWIN_BUFFER_READY");
if (!m_bufferReadyEvent
|| GetLastError() == ERROR_ALREADY_EXISTS)
return false;
m_sharedFile = CreateFileMapping((HANDLE)-1, NULL, PAGE_READWRITE, 0, 4096, L"DBWIN_BUFFER");
if (!m_sharedFile || GetLastError() == ERROR_ALREADY_EXISTS)
return false;
m_sharedMem = MapViewOfFile(m_sharedFile, FILE_MAP_READ, 0, 0, 512);
if (!m_sharedMem)
return false;
LPSTR message = reinterpret_cast<LPSTR>(m_sharedMem) + sizeof(DWORD);
LPDWORD processId = reinterpret_cast<LPDWORD>(m_sharedMem);
SetEvent(m_bufferReadyEvent);
QTime timer; // time since last signal sent
timer.start();
QMap<qint64, QString> delayedMessages;
auto flushMessages = [this, &delayedMessages, &timer](){
auto it = delayedMessages.constBegin();
auto end = delayedMessages.constEnd();
for (; it != end; ++it)
emit debugOutput(it.key(), it.value());
delayedMessages.clear();
timer.start();
};
while (true) {
DWORD timeout = INFINITE;
if (!delayedMessages.isEmpty()) // if we have delayed message, don't wait forever
timeout = qMax(60 - timer.elapsed(), 1);
const DWORD ret = WaitForMultipleObjects(HandleCount, m_waitHandles, FALSE, timeout);
if (ret == WAIT_FAILED || ret - WAIT_OBJECT_0 == TerminateEventHandle) {
flushMessages();
break;
}
if (ret == WAIT_TIMEOUT) {
flushMessages();
SetEvent(m_bufferReadyEvent);
} else if (ret - WAIT_OBJECT_0 == DataReadyEventHandle) {
if (*processId != m_creatorPid) {
if (timer.elapsed() < 60) {
delayedMessages[*processId].append(QString::fromLocal8Bit(message));
} else {
delayedMessages[*processId] += QString::fromLocal8Bit(message);
flushMessages();
}
}
SetEvent(m_bufferReadyEvent);
}
}
return true;
}
void QVX_Sim::SimLoop(QString* pSimMessage)
{
std::string tmp; //need to link this up to get info back...
if (!Import(NULL, NULL, &tmp)) return;
int Count = 0; //Possibly redundant with internal sim count.
int LastCount = 0;
bool IsStillDrawing;
Vec3D<> CurSelPos;
QString PosLabel;
bool InternalEnding = false;
QString Message, DispMessage;
std::string RetMsg;
QTime tLastPlot; //plot point add every...
QTime tLastStatus; //status text box updated...
// QTime tLastStatCalc; //simulation max/mins calculated every...
tLastPlot.start();
tLastStatus.start();
// tLastStatCalc.start();
emit ReqUiUpdate(); //for slider ranges that depend on dt or other sim params
emit StartExternalGLUpdate(DEFAULT_DISPLAY_UPDATE_MS);
StopSim = false;
Running = true;
Paused = false;
//initialize the COM at the start of the simulation
IniCM=GetCM();
Vec3D<> LastCM = IniCM;
int StatusNumber = 1, PlotPointNumber = 1;
double UpStatEv = 500; //Updates status pane every X ms
int UpPlotEv = 30; //updates plot every X ms when not plotting every point.
char PlotDataTypes;
bool PlotVis, StatusVis;
while (true){ //do this step...
if (StopConditionMet()){InternalEnding = true; StatToCalc=CALCSTAT_ALL; UpdateStats(); RetMsg+="Simulation stop condition reached.\n";break;}//if stop condition met...
//figure out what stats we need to calculate
StatToCalc=CALCSTAT_NONE;
emit IsPlotVisible(&PlotVis);
bool PlottingPoint = (LogEvery?true:tLastPlot.elapsed() > PlotPointNumber*UpPlotEv) && PlotVis;
if (PlottingPoint){ //ensure we calculate the info we want to plot
emit GetPlotRqdStats(&PlotDataTypes);
StatToCalc |= PlotDataTypes;
}
emit IsStatusTextVisible(&StatusVis);
bool UpdatingStatus = (tLastStatus.elapsed() > StatusNumber*UpStatEv) && StatusVis;
if (UpdatingStatus){StatToCalc |= CALCSTAT_COM;} //calc any data we need in the text status box
bool DrawingGLLocal = (GLUpdateEveryNFrame != -1 && Count%GLUpdateEveryNFrame==0);
if (DrawingGLLocal || NeedStatsUpdate){ //calc any data we need to draw the opengl view...
StatToCalc |= StatRqdToDraw();
NeedStatsUpdate = false;
if (LockCoMToCenter) StatToCalc |= CALCSTAT_COM;
}
// if (tLastStatCalc.elapsed() > StatCalcNumber*30){CalcStat=true; StatCalcNumber++; /*tLastStatCalc.restart();*/}
if (!TimeStep(&RetMsg)){InternalEnding = true; break;}//if something happened in this timestep
if (DrawingGLLocal){
IsStillDrawing = true;
ReqGLDrawingStatus(&IsStillDrawing);
while (IsStillDrawing){ //wait to finish drawing the previous timestep before continuing
LOCALSLEEP(1);
ReqGLDrawingStatus(&IsStillDrawing); //are
}
emit ReqGLUpdate();
}
if (StopSim) break;
while(Paused){
ActuallyPaused = true;
if (StopSim) break; //kick out of the loop if we've stopped...
LOCALSLEEP(100);
}
if(UpdatingStatus){
// emit IsStatusTextVisible...
if (CurXSel != -1){PosLabel = "Vox "+QString::number(XtoSIndexMap[CurXSel]) + "(sim)"; CurSelPos = VoxArray[XtoSIndexMap[CurXSel]].GetCurPos()*1000; }//position in mm
else {PosLabel = "CoM "; CurSelPos = SS.CurCM*1000;} //center of mass in mm if nothing else selected
Message = "Time " + QString::number(CurTime, 'g', 3) + " Sec" +
"\nStep Num " + QString::number(CurStepCount) +
"\nTime Step = " + QString::number(dt, 'g', 3)+ " Sec" +
"\nDisplay Rate = "+ QString::number((Count-LastCount)/(UpStatEv/1000.0), 'g', 3)+" Steps/sec" +
"\n" + PosLabel + " X:"+ QString::number(CurSelPos.x, 'g', 3)+" Y:"+ QString::number(CurSelPos.y, 'g', 3)+" Z:"+ QString::number(CurSelPos.z, 'g', 3)+ " mm" +
"\nCoM Displacement = "+ QString::number((SS.CurCM-IniCM).Length()*1000, 'g', 3)+" mm" +
"\nCoM Velocity = "+ QString::number((SS.CurCM-LastCM).Length()*1000/(dt*(Count-LastCount)), 'g', 3)+" mm/s\n";
if (pEnv->IsFloorEnabled()) Message += "Voxel touching ground: " + QString::number(GetNumTouchingFloor()) + "\n";
Message += "\n";
LastCM = SS.CurCM;
if (LogEvery) ApproxMSperLog = (double)tLastStatus.elapsed()/(Count-LastCount); //only update ms per step if its not fixed by the timer
LastCount = Count;
emit UpdateText(Message);
StatusNumber++;
}
if (PlottingPoint){
if (LogEvery) emit ReqAddPlotPoint(GetCurTime());
else {
ApproxMSperLog = UpPlotEv;
emit ReqAddPlotPoint(GetCurTime());
PlotPointNumber++;
}
}
// if (StatCalcNumber == INT_MAX){StatCalcNumber=1; tLastStatCalc.restart();} //avoid int rollover for our counters
if (StatusNumber == INT_MAX){StatusNumber=1; tLastStatus.restart();}
if (PlotPointNumber == INT_MAX){PlotPointNumber=1; tLastPlot.restart();}
Count++;
}
emit StopExternalGLUpdate();
// emit SetExternalGLUpdate(false);
Running = false;
Paused = false;
Message = "Time " + QString::number(CurTime, 'g', 3) + " Sec" +
"\nStep Num " + QString::number(CurStepCount) +
"\nTime Step = " + QString::number(dt, 'g', 3)+ " Sec" +
"\n" + PosLabel + " X:"+ QString::number(CurSelPos.x, 'g', 3)+" Y:"+ QString::number(CurSelPos.y, 'g', 3)+" Z:"+ QString::number(CurSelPos.z, 'g', 3)+ " mm" +
"\nCOM_Dist = "+ QString::number((SS.CurCM-IniCM).Length()*1000, 'g', 3)+" mm\n\n";
RetMsg += "Simulation stopped.\n";
Message += RetMsg.c_str();
DispMessage = Message + "\nFinal Conditions:\nStep = " + QString::number(CurStepCount) + "\nTime Step = " + QString::number(dt)+"\nKinetic Energy = " + QString::number(SS.TotalObjKineticE)+"\n" ;
emit UpdateText(DispMessage);
if (InternalEnding) emit SimEndedInternally(RetMsg.c_str());
// Running = false;
}
int main(int argc, char *argv[]) {
QSet<QString> valuedOptions, flagedOptions;
valuedOptions << "o" << "fps" << "dir" << "assets";
flagedOptions << "pot" << "M";
QHash<QString, QString> options;
QSet<QString> flags;
QString key;
QString inputPath;
bool isOption = false;
for(int i = 1; i < argc; i++) {
QString arg(argv[i]);
if(isOption) {
options[key] = arg;
isOption = false;
} else {
if(arg[0] == '-') {
key = arg.mid(1);
if(valuedOptions.contains(key)) {
isOption = true;
} else if(flagedOptions.contains(key)) {
flags << key;
} else {
qDebug() << "Warning: Ignored unrecognized flag or option " << arg;
}
} else {
if(inputPath.isEmpty())
inputPath = arg;
else {
qDebug() << "Warning: Only one input file is allowed, will ignore " << arg;
}
}
}
}
if(inputPath.isEmpty()) {
qDebug() << "Error: Must specify input tml file";
printHelp();
}
#define OPT(KEY, DEFAULT) (options.contains(#KEY) ? options[#KEY] : DEFAULT)
#define ABS_PATH(X) QDir().absoluteFilePath(X).toUtf8().data()
inputPath = ABS_PATH(inputPath);
CCPlus::setAssetsPath(ABS_PATH(OPT(assets, dirname(argv[0]) + "assets")));
CCPlus::RenderTarget t;
t.inputPath = inputPath.toUtf8().data();
t.outputPath = ABS_PATH(OPT(o, inputPath + ".mp4"));
t.footageDir = ABS_PATH(OPT(dir, dirname(inputPath)));
t.fps = OPT(fps, "18").toInt();
if(t.fps < 4)
t.fps = 4;
CCPlus::renderFlag = 0;
if(flags.contains("pot")) {
CCPlus::renderFlag |= CCPlus::FORCE_POT;
}
if(flags.contains("M")) {
CCPlus::collectorTimeInterval = 1;
CCPlus::collectorWindowSize = 10;
CCPlus::collectorThreadsNumber = 8;
CCPlus::renderFlag |= CCPlus::LARGE_MEM;
}
QApplication app(argc, argv);
QTime timer;
timer.start();
CCPlus::go(t);
t.waitFinish();
app.exit(0);
qDebug() << "Elapsed: " << timer.elapsed() * 0.001 << "s";
qDebug() << "END";
return 0;
}
bool ESerialPort::open(OpenMode mode)
{
if (!(mode & ReadWrite)) return false;
DWORD options = 0;
if (mode & ReadOnly) options |= GENERIC_READ;
if (mode & ReadWrite) options |= GENERIC_WRITE;
if (fd != ESP_INVALID_HANDLE) {
::CloseHandle(fd);
fd = ESP_INVALID_HANDLE;
QIODevice::close();
}
fd = CreateFileA(deviceName.toAscii().data(),
options,
0,
0,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
0);
if (fd == ESP_INVALID_HANDLE) {
return false;
}
FlushFileBuffers(fd);
PurgeComm(fd, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
DCB dcbSerialParams = {0};
dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
if (!GetCommState(fd, &dcbSerialParams)) {
::CloseHandle(fd);
fd = ESP_INVALID_HANDLE;
return false;
}
DWORD baud = (DWORD)nativeBaudRate(baudRate);
dcbSerialParams.BaudRate = baud;
dcbSerialParams.ByteSize=8;
dcbSerialParams.StopBits=ONESTOPBIT;
dcbSerialParams.Parity=NOPARITY;
if(!SetCommState(fd, &dcbSerialParams)){
::CloseHandle(fd);
fd = ESP_INVALID_HANDLE;
return false;
}
COMMTIMEOUTS timeouts={0};
timeouts.ReadIntervalTimeout=1;
timeouts.ReadTotalTimeoutConstant = 1;
timeouts.ReadTotalTimeoutMultiplier=1;
timeouts.WriteTotalTimeoutConstant=50;
timeouts.WriteTotalTimeoutMultiplier=10;
if(!SetCommTimeouts(fd, &timeouts)){
::CloseHandle(fd);
fd = ESP_INVALID_HANDLE;
return false;
}
if (!EscapeCommFunction(fd, CLRDTR)) {
::CloseHandle(fd);
fd = ESP_INVALID_HANDLE;
return false;
}
{
QTime t;
t.start();
while (t.elapsed() < 60) {};
}
QIODevice::open(mode);
setDtr(false);
return true;
}
void start()
{
t.start();
QThread::start();
}
void Lockin2::interpretInput()
{
QTime time;
time.start();
_timeValue += _outputPeriod;
// récupère les nouvelles valeurs
/*
* le nombre de nouvelle valeurs = outputPeriod * sampleRate / 1000
* outputPeriod (~0.1 s) étant beaucoup plus grand que la periode du chopper (~1/500 s)
* meme dans le cas d'un chopper lent et d'un temps de sortie rapide le nombre de periodes
* du chopper reste elevé. (~50)
* On peut donc garder uniquement les periodes entières
* On a donc une perte de présision de l'ordre de 2/50 = 4%
* Plus outputPeriod et grand et plus le chopper est rapide plus la perte diminue.
* 0.5s 500Hz -> 0.8%
* 1.0s 500Hz -> 0.4%
*/
QList<qreal> leftSignal;
QList<int> chopperSignal;
// les des données et les adapte
// left [-1;+1]
// right -1 ou +1
readSoudCard(leftSignal, chopperSignal);
if (leftSignal.size() == 0 || chopperSignal.size() == 0)
return;
QList<QPair<qreal, qreal> > chopperSinCos = parseChopperSignal(chopperSignal, _phase);
// multiplie le leftSignal ([-1;1]) par chopperSinCos ([-1;1])
for (int i = 0; i < leftSignal.size(); ++i) {
qreal x, y;
if (chopperSinCos[i].first != 3.0) { // 3.0 est la valeur qui indique ignoreValue dans parseChopperSignal(...)
x = chopperSinCos[i].first * leftSignal[i]; // sin
y = chopperSinCos[i].second * leftSignal[i]; // cos
} else {
x = y = 3.0; // ignore value
}
_dataXY << QPair<qreal, qreal>(x, y);
}
// renouvelle le view data (prend la fin des listes, qui correspond aux parties les plus récentes)
if (_vumeterMutex.tryLock()) {
_vumeterData.clear();
for (int i = leftSignal.size() - 1; i >= 0; --i) {
if (_vumeterData.size() >= _sampleVumeter)
break;
if (chopperSinCos[i].first != 3.0) {
_vumeterData.prepend(QPair<qreal, qreal>(leftSignal[i], chopperSinCos[i].first));
}
}
_vumeterMutex.unlock();
} else {
qDebug() << __FUNCTION__ << ": the view Mutex is locked";
}
// le nombre d'échantillons correslondant au temps d'integration
if (_dataXY.size() < _sampleIntegration) {
// pas encore assez d'elements pour faire la moyenne
emit info("wait more input data...");
return;
}
// supprime les valeurs en trop
while (_dataXY.size() > _sampleIntegration)
_dataXY.removeFirst();
qreal dataCount = 0.0;
qreal x = 0.0;
qreal y = 0.0;
for (int i = 0; i < _dataXY.size(); ++i) {
// deux fois 3.0 indique ignoreValue
if (_dataXY[i].first != 3.0) {
x += _dataXY[i].first;
y += _dataXY[i].second;
dataCount += 1.0;
}
}
if (dataCount == 0.0) {
qDebug() << __FUNCTION__ << ": no data usable";
emit info("signal too low");
return;
}
x /= dataCount;
y /= dataCount;
// _values << QPair<qreal, QPair<qreal, qreal> >(_timeValue, QPair<qreal, qreal>(x, y));
_xValue = x;
_yValue = y;
emit newValues(_timeValue, x, y);
qDebug() << __FUNCTION__ << ": execution time " << time.elapsed() << "ms";
}
void mathGraph::dijkstra()
{
QTime t;
t.start();
QVector<QVector<int> > sum;
sum.resize(matrixOfSize.size()-1);
for (int i = 0; i < sum.size(); ++i)
sum[i].resize(matrixOfSize.size()-1);
for (int i = 0; i < sum.size(); i++) {
for (int j = 0; j < sum.size(); j++) {
sum[i][j] = matrixOfSize[i][j];
}
}
// alg
QVector<bool> visited;
QVector<int> distance;
visited.resize(sum.size());
distance.resize(sum.size());
int index, u;
int max = 0;
for(int vert = 0; vert < sum.size(); vert++) { // vert - начальная точка
for (int i=0; i<sum.size(); i++)
{
distance[i]=INT_MAX;
visited[i]=false;
}
distance[vert]=0;
for (int count=0; count<sum.size()-1; count++)
{
int min=INT_MAX;
for (int i=0; i<sum.size(); i++)
if (!visited[i] && distance[i]<=min) {
min=distance[i];
index=i;
}
u=index;
visited[u]=true;
for (int i=0; i<sum.size(); i++)
if (!visited[i] && sum[u][i] && distance[u]!=INT_MAX && distance[u]+sum[u][i]<distance[i])
distance[i]=distance[u]+sum[u][i];
}
for(int i = 0; i < sum.size(); ++i) {
if (distance[i]!=INT_MAX)
if(max < distance[i]) {
max = distance[i];
}
}
}
qDebug() << "max dex" << max;
dijkstraResults << max;
dijkstraTime << t.elapsed();
//end alg
for (int i = 0; i < sum.size(); i++){
for (int j = 0; j < sum.size(); j++){
if (sum[i][j] == INT_MAX)
sum[i][j] = 0;
}
}
qDebug() << "dijk end";
}
int AirspaceHelper::loadAirspaces( QList<Airspace>& list )
{
// Set a global lock during execution to avoid calls in parallel.
QMutexLocker locker( &m_mutex );
QTime t; t.start();
uint loadCounter = 0; // number of successfully loaded files
m_airspaceDictionary.clear();
QString mapDir = MapContents::instance()->getMapRootDirectory() + "/airspaces";
QStringList preselect;
// Setup a filter for the desired file extensions.
QString filter = "*.txt *.TXT *.aip";
MapContents::addDir( preselect, mapDir, filter );
if( preselect.count() == 0 )
{
qWarning( "ASH: No Airspace files found in the map directory!" );
return loadCounter;
}
// Check, which files shall be loaded.
QStringList files = _settings.value( "/Airspace/FileList", QStringList(QString("All"))).toStringList();
if( files.isEmpty() )
{
// No files shall be loaded
qWarning() << "ASH: No Airspace files defined for loading!";
return loadCounter;
}
if( files.first() != "All" )
{
// Check for desired files to be loaded. All other items are removed from
// the files list.
for( int i = preselect.size() - 1; i >= 0; i-- )
{
QString file = QFileInfo(preselect.at(i)).fileName();
if( files.contains( file ) == false )
{
preselect.removeAt(i);
}
}
}
OpenAirParser oap;
OpenAip oaip;
QString errorInfo;
while( ! preselect.isEmpty() )
{
QString srcName;
if( preselect.first().endsWith(QString(".TXT")) ||
preselect.first().endsWith(QString(".txt")) )
{
srcName = preselect.first();
if( oap.parse(srcName, list) )
{
loadCounter++;
}
preselect.removeAt(0);
continue;
}
if( preselect.first().endsWith(QString(".aip")) )
{
// there can't be the same name aic after this aip
// parse found aip file
srcName = preselect.first();
if( oaip.readAirspaces(srcName, list, errorInfo ) )
{
loadCounter++;
}
preselect.removeAt(0);
continue;
}
} // End of While
qDebug("ASH: %d Airspace file(s) loaded in %dms", loadCounter, t.elapsed());
// for(int i=0; i < list.size(); i++ )
// {
// list.at(i)->debug();
// }
return loadCounter;
}
void M3UParser::load() {
QTime timeElapsed;
timeElapsed.start();
_stop = false;
QList<MediaInfo> files;
qDebug() << __FUNCTION__ << "Playlist:" << _filename;
//See http://regexlib.com/DisplayPatterns.aspx
//#EXTM3U
static QRegExp rx_extm3u("^#EXTM3U$|^#M3U$");
//#EXTINF:123,Sample title
static QRegExp rx_extinf("^#EXTINF:([-+]?\\d+),(.*)$");
//#EXTINF:Sample title
static QRegExp rx_extinf_title("^#EXTINF:(.*)$");
//#Just a comment
static QRegExp rx_comment("^#.*$");
QFile file(_filename);
if (file.open(QIODevice::ReadOnly)) {
QString path(QFileInfo(_filename).path());
QTextStream stream(&file);
if (isUtf8()) {
stream.setCodec("UTF-8");
} else {
stream.setCodec(QTextCodec::codecForLocale());
}
MediaInfo mediaInfo;
while (!stream.atEnd() && !_stop) {
//Line of text excluding '\n'
QString line(stream.readLine().trimmed());
if (line.isEmpty()) {
//Do nothing
}
else if (rx_extm3u.indexIn(line) != -1) {
//#EXTM3U line, ignored
}
else if (rx_extinf.indexIn(line) != -1) {
//#EXTINF line
QString length(rx_extinf.cap(1));
if (!length.isEmpty()) {
mediaInfo.setLength(length.toInt());
}
QString title(rx_extinf.cap(2));
if (!title.isEmpty()) {
mediaInfo.insertMetadata(MediaInfo::Title, title);
}
}
else if (rx_extinf_title.indexIn(line) != -1) {
QString title(rx_extinf_title.cap(1));
if (!title.isEmpty()) {
mediaInfo.insertMetadata(MediaInfo::Title, title);
}
}
else if (rx_comment.indexIn(line) != -1) {
//# line, comment, ignored
}
else {
bool isUrl = MediaInfo::isUrl(line);
mediaInfo.setUrl(isUrl);
if (isUrl) {
mediaInfo.setFileName(line);
} else {
mediaInfo.setFileName(Util::canonicalFilePath(path, line));
}
//Add file to the list of files
files << mediaInfo;
//Clear the MediaInfo for the next 2 lines from the m3u playlist
mediaInfo.clear();
if (files.size() > FILES_FOUND_LIMIT) {
//Emits the signal every FILES_FOUND_LIMIT files found
emit filesFound(files);
files.clear();
}
}
}
}
file.close();
if (!files.isEmpty()) {
//Emits the signal for the remaining files found (< FILES_FOUND_LIMIT)
emit filesFound(files);
}
//Emits the last signal
emit finished(timeElapsed.elapsed());
}
void AndroidRetracer::run()
{
m_androidUtils.reloadAdb();
QString errorStr;
bool setupRet;
QMetaObject::invokeMethod(this, "setup", Qt::BlockingQueuedConnection,
Q_RETURN_ARG(bool, setupRet),
Q_ARG(QString *, &errorStr));
if (!setupRet) {
emit finished(errorStr);
return;
}
if (!m_androidUtils.runAdb(QStringList() << _("shell") << _("am") << _("start") << _("-n") << packageName + activityName)) {
emit finished(tr("Can't start apitrace application"));
return;
}
QByteArray which;
if (!m_androidUtils.runAdb(QStringList() << _("shell") << _("readlink") << _("$(which ps)") , &which)) {
emit finished(tr("Can't start adb"));
return;
}
bool isBusyBox = which.startsWith("busybox");
QStringList psArgs;
psArgs << _("shell") << _("ps");
if (isBusyBox)
psArgs << _("-w");
qint64 processPID;
bool wasStarted = false;
QTime startTime;
startTime.start();
QTcpSocket stdoutSocket;
QTcpSocket stderrSocket;
ImageHash thumbnails;
QVariantMap parsedJson;
trace::Profile* profile = isProfiling() ? new trace::Profile() : NULL;
QList<ApiTraceError> errors;
QRegExp regexp("(^\\d+): +(\\b\\w+\\b): ([^\\r\\n]+)[\\r\\n]*$");
QString msg = QLatin1String("Replay finished!");
QByteArray ubjsonBuffer;
QByteArray outputBuffer;
bool keepGoing = true;
while(keepGoing) {
if (!wasStarted || startTime.elapsed() > 1000) {
QByteArray psOut;
m_androidUtils.runAdb(psArgs, &psOut);
processPID = extractPid(psOut);
if (wasStarted)
startTime.restart();
}
if (processPID == -1) {
if (wasStarted) {
break;
} else {
if (startTime.elapsed() > 3000) { // wait 3 seconds to start
emit finished(tr("Unable to start retrace on device."));
return;
}
}
msleep(100);
continue;
}
// we have a valid pid, it means the application started
if (!wasStarted) {
// connect the sockets
int tries = 0;
do {
stdoutSocket.connectToHost(QHostAddress::LocalHost, m_stdoutPort);
} while (!stdoutSocket.waitForConnected(100) && ++tries < 10);
if (stdoutSocket.state() != QAbstractSocket::ConnectedState) {
emit finished(tr("Can't connect to stdout socket."));
return;
}
// Android doesn't suport GPU and PPD profiling (at leats not on my devices)
//setProfiling(false, isProfilingCpu(), false);
QString args = (retraceArguments() << m_androdiFileName).join(" ") + _("\n");
stdoutSocket.write(args.toUtf8());
if (!stdoutSocket.waitForBytesWritten()) {
emit finished(tr("Can't send params."));
return;
}
stderrSocket.connectToHost(QHostAddress::LocalHost, m_stderrPort);
stderrSocket.waitForConnected(100);
if (stderrSocket.state() != QAbstractSocket::ConnectedState) {
emit finished(tr("Can't connect to stderr socket."));
return;
}
wasStarted = true;
}
// We are going to read both channels at the same time
// read stdout channel
if (stdoutSocket.waitForReadyRead(100)) {
if (captureState())
ubjsonBuffer.append(stdoutSocket.readAll());
else if (captureThumbnails()) {
// read one image
image::PNMInfo info;
QByteArray header;
int headerLines = 3; // assume no optional comment line
for (int headerLine = 0; headerLine < headerLines; ++headerLine) {
QByteArray line = readLine(stdoutSocket);
if (line.isEmpty()) {
keepGoing = false;
break;
}
header += line;
// if header actually contains optional comment line, ...
if (headerLine == 1 && line[0] == '#') {
++headerLines;
}
}
const char *headerEnd = image::readPNMHeader(header.constData(), header.size(), info);
// if invalid PNM header was encountered, ...
if (headerEnd == NULL ||
info.channelType != image::TYPE_UNORM8) {
qDebug() << "error: invalid snapshot stream encountered";
keepGoing = false;
break;
}
unsigned channels = info.channels;
unsigned width = info.width;
unsigned height = info.height;
// qDebug() << "channels: " << channels << ", width: " << width << ", height: " << height";
QImage snapshot = QImage(width, height, channels == 1 ? QImage::Format_Mono : QImage::Format_RGB888);
int rowBytes = channels * width;
for (int y = 0; y < height; ++y) {
unsigned char *scanLine = snapshot.scanLine(y);
if (!read(stdoutSocket, (char *) scanLine, rowBytes)) {
keepGoing = false;
break;
}
}
QImage thumb = thumbnail(snapshot);
thumbnails.insert(info.commentNumber, thumb);
} else if (isProfiling()) {
QByteArray line = readLine(stdoutSocket);
if (line.isEmpty()) {
keepGoing = false;
break;
}
line.append('\0');
trace::Profiler::parseLine(line.constData(), profile);
} else {
outputBuffer.append(stdoutSocket.readAll());
}
}
// read stderr channel
if (stderrSocket.waitForReadyRead(5) && stderrSocket.canReadLine()) {
QString line = stderrSocket.readLine();
if (regexp.indexIn(line) != -1) {
ApiTraceError error;
error.callIndex = regexp.cap(1).toInt();
error.type = regexp.cap(2);
error.message = regexp.cap(3);
errors.append(error);
} else if (!errors.isEmpty()) {
// Probably a multiligne message
ApiTraceError &previous = errors.last();
if (line.endsWith("\n")) {
line.chop(1);
}
previous.message.append('\n');
previous.message.append(line);
}
}
}
if (outputBuffer.size() < 80)
msg = outputBuffer;
if (captureState()) {
QBuffer io(&ubjsonBuffer);
io.open(QIODevice::ReadOnly);
parsedJson = decodeUBJSONObject(&io).toMap();
ApiTraceState *state = new ApiTraceState(parsedJson);
emit foundState(state);
}
if (captureThumbnails() && !thumbnails.isEmpty()) {
emit foundThumbnails(thumbnails);
}
if (isProfiling() && profile) {
emit foundProfile(profile);
}
if (!errors.isEmpty()) {
emit retraceErrors(errors);
}
emit finished(msg);
}
// Refresh not up to date metrics and metrics after date
void MetricAggregator::refreshMetrics(QDateTime forceAfterThisDate)
{
// only if we have established a connection to the database
if (dbaccess == NULL || main->isclean==true) return;
// first check db structure is still up to date
// this is because metadata.xml may add new fields
dbaccess->checkDBVersion();
// Get a list of the ride files
QRegExp rx = RideFileFactory::instance().rideFileRegExp();
QStringList filenames = RideFileFactory::instance().listRideFiles(home);
QStringListIterator i(filenames);
// get a Hash map of statistic records and timestamps
QSqlQuery query(dbaccess->connection());
QHash <QString, status> dbStatus;
bool rc = query.exec("SELECT filename, timestamp, fingerprint FROM metrics ORDER BY ride_date;");
while (rc && query.next()) {
status add;
QString filename = query.value(0).toString();
add.timestamp = query.value(1).toInt();
add.fingerprint = query.value(2).toInt();
dbStatus.insert(filename, add);
}
// begin LUW -- byproduct of turning off sync (nosync)
dbaccess->connection().transaction();
// Delete statistics for non-existant ride files
QHash<QString, status>::iterator d;
for (d = dbStatus.begin(); d != dbStatus.end(); ++d) {
if (QFile(home.absolutePath() + "/" + d.key()).exists() == false) {
dbaccess->deleteRide(d.key());
#ifdef GC_HAVE_LUCENE
main->lucene->deleteRide(d.key());
#endif
}
}
unsigned long zoneFingerPrint = static_cast<unsigned long>(zones->getFingerprint())
+ static_cast<unsigned long>(hrzones->getFingerprint()); // checksum of *all* zone data (HR and Power)
// update statistics for ride files which are out of date
// showing a progress bar as we go
QTime elapsed;
elapsed.start();
QString title = tr("Refreshing Ride Statistics...\nStarted");
QProgressDialog bar(title, tr("Abort"), 0, filenames.count(), main);
bar.setWindowModality(Qt::WindowModal);
bar.setMinimumDuration(0);
bar.show();
int processed=0;
QApplication::processEvents(); // get that dialog up!
// log of progress
QFile log(home.absolutePath() + "/" + "metric.log");
log.open(QIODevice::WriteOnly);
log.resize(0);
QTextStream out(&log);
out << "METRIC REFRESH STARTS: " << QDateTime::currentDateTime().toString() + "\r\n";
while (i.hasNext()) {
QString name = i.next();
QFile file(home.absolutePath() + "/" + name);
// if it s missing or out of date then update it!
status current = dbStatus.value(name);
unsigned long dbTimeStamp = current.timestamp;
unsigned long fingerprint = current.fingerprint;
RideFile *ride = NULL;
// update progress bar
long elapsedtime = elapsed.elapsed();
QString elapsedString = QString("%1:%2:%3").arg(elapsedtime/3600000,2)
.arg((elapsedtime%3600000)/60000,2,10,QLatin1Char('0'))
.arg((elapsedtime%60000)/1000,2,10,QLatin1Char('0'));
QString title = tr("Refreshing Ride Statistics...\nElapsed: %1\n%2").arg(elapsedString).arg(name);
bar.setLabelText(title);
bar.setValue(++processed);
QApplication::processEvents();
if (dbTimeStamp < QFileInfo(file).lastModified().toTime_t() ||
zoneFingerPrint != fingerprint ||
(!forceAfterThisDate.isNull() && name >= forceAfterThisDate.toString("yyyy_MM_dd_hh_mm_ss"))) {
QStringList errors;
// log
out << "Opening ride: " << name << "\r\n";
// read file and process it if we didn't already...
if (ride == NULL) ride = RideFileFactory::instance().openRideFile(main, file, errors);
out << "File open completed: " << name << "\r\n";
if (ride != NULL) {
out << "Getting weight: " << name << "\r\n";
ride->getWeight();
out << "Updating statistics: " << name << "\r\n";
importRide(home, ride, name, zoneFingerPrint, (dbTimeStamp > 0));
}
}
// update cache (will check timestamps itself)
// if ride wasn't opened it will do it itself
// we only want to check so passing check=true
// because we don't actually want the results now
RideFileCache updater(main, home.absolutePath() + "/" + name, ride, true);
// free memory - if needed
if (ride) delete ride;
if (bar.wasCanceled()) {
out << "METRIC REFRESH CANCELLED\r\n";
break;
}
}
// end LUW -- now syncs DB
out << "COMMIT: " << QDateTime::currentDateTime().toString() + "\r\n";
dbaccess->connection().commit();
#ifdef GC_HAVE_LUCENE
#ifndef WIN32 // windows crashes here....
out << "OPTIMISE: " << QDateTime::currentDateTime().toString() + "\r\n";
main->lucene->optimise();
#endif
#endif
main->isclean = true;
// stop logging
out << "SIGNAL DATA CHANGED: " << QDateTime::currentDateTime().toString() + "\r\n";
dataChanged(); // notify models/views
out << "METRIC REFRESH ENDS: " << QDateTime::currentDateTime().toString() + "\r\n";
log.close();
}
void Solution::run() {
// for ( count = 0; count < _myInstance->numPoints(); ++count ) {
// _pointsType[count] = CCP::Consumer;//Everyone is consumer at begin...
// }
// if (!_lock.tryLock()){
// return;
// }
// QProgressDialog dialog ("Progress of algorithm", "cancel", 0,100);
//
// dialog.setWindowModality(Qt::WindowModal);
if (_centers != 0){
delete [] _centers;
}
QTime count;
count.start();
switch (_type){
case Farthest: {
FarthestCluster far(_myInstance);
// connect (&far, SIGNAL(complete(int)), &dialog, SLOT(setValue(int)));
_centers = far.buildClusters();
_myAlgorithmName = "Farthest";
_myIterations = far.iterations();
_history = far.history();
}
break;
case Density: {
DensityCluster density(_myInstance);
// connect (&density, SIGNAL(complete(int)), &dialog, SLOT(setValue(int)));
_centers = density.buildClusters();
_myAlgorithmName = "Density";
_myIterations = density.iterations();
_history = density.history();
}
break;
case HMeans: {
HMeansCluster hmean(_myInstance);
// connect (&hmean, SIGNAL(complete(int)), &dialog, SLOT(setValue(int)));
_centers = hmean.buildClusters();
_myAlgorithmName = "HMeans";
_myIterations = hmean.iterations();
_history = hmean.history();
}break;
case JMeans: {
JMeansCluster jmean(_myInstance);
// connect (&jmean, SIGNAL(complete(int)), &dialog, SLOT(setValue(int)));
_centers = jmean.buildClusters();
_myAlgorithmName = "JMeans";
_myIterations = jmean.iterations();
_history = jmean.history();
}break;
case RandonDensity: {
RandomDensityCluster randomD(_myInstance);
_centers = randomD.buildClusters();
_myAlgorithmName = "Randon Density";
_history = randomD.history();
}break;
case DensityHMeans: {
HMeansWithDensity hd(_myInstance);
_centers = hd.buildClusters();
_myAlgorithmName = "HMeans With Density";
_history = hd.history();
}break;
case DensityJMeans: {
JMeansWithDensity jd(_myInstance);
_centers = jd.buildClusters();
_myAlgorithmName = "JMeans With Density";
_history = jd.history();
}break;
}
_myTime = count.elapsed()/1000.0;
// dialog.setValue(100);
// _lock.unlock();
// emit finished();
}
