void ProgressThread::run()
{
int timeElapsed, timeRemaining, percentageDone;
percentageDone = timeElapsed = timeRemaining = 0;
// main progress loop: update GUI, then sleep for a bit
while (true)
{
// get the current status
Status currentStatus = model->getStatus();
emit statusMessageUpdate(currentStatus.getMessage());
// see if there is a new image to be displayed
if (currentStatus.hasNewImage())
{
emit imageUpdate(model->getImage());
// TODO: if they are not looking at the most recent image,
// maybe don't update the current image...
}
// check if the model is still running
if (currentStatus.getState() == Status::RUNNING)
{
percentageDone = (int)(100*currentStatus.getProgress());
timeElapsed = currentStatus.getTimeElapsed();
timeRemaining = currentStatus.getTimeRemaining();
emitProgress(percentageDone, timeElapsed, timeRemaining);
}
// check if model is finished
else if (currentStatus.getState() == Status::COMPLETE)
{
break;
}
// sleep for now so it doesn't spend too much time in this thread
msleep(sleepTimeMilliseconds);
}
// fix the values for the progress
if (model->getStatus().getState() == Status::COMPLETE)
{
emitProgress(100, timeElapsed, 0);
emit imageUpdate(model->getImage());
}
// tell GUI that it is finished
emit finished();
}
void play() {
for (int i = 0, s = m_inputs[0].count() ; i < s ; ++i ) {
Photo& photo = m_inputs[0][i];
QDir targetDir(m_targetDirectory);
QString magick;
QString baseFilename = targetDir.filePath(photo.getTag(TAG_NAME));
QString ext;
switch (m_fileType) {
case OpSave::SaveFITS:
ext = ".fits"; magick = "FITS"; break;
case OpSave::SaveTIFF:
ext = ".tif"; magick = "TIFF"; break;
case OpSave::SaveJPEG:
ext = ".jpg"; magick = "JPG"; break;
}
QFileInfo finfo(baseFilename + ext);
if ( m_backup && finfo.exists() ) {
QDateTime lastModified = finfo.lastModified();
QString ts = lastModified.toString("yyyy'-'dd'-'MM'T'hh':'mm':'ss'.'zzz'Z'");
QFile orig(baseFilename + ext);
orig.rename(baseFilename + "-" + ts + ext);
}
QString filename = finfo.filePath();
photo.save(filename, magick);
emitProgress(i, s, 0, 1);
}
emitSuccess();
}
void
ImportPCD::compute()
{
if (_fileName.length () > 4)
{
std::string ext = _fileName.substr (_fileName.length () - 3, 3);
if (ext == "pcd")
{
emit emitProgress(0);
_cloud_intens = importPCD ();
emit emitProgress(100);
}
else if (ext == "asc"||ext == "txt")
{
emit emitProgress(0);
_cloud_intens = importASC ();
emit emitProgress(100);
}
}
emit emitCloud(_cloud_intens,true);
}
void QtlMovieCleanupSubtitles::timerEvent(QTimerEvent* event)
{
// This handler is invoked for all timer, make sure it is ours.
if (event == 0 || _timerId < 0 || event->timerId() != _timerId) {
// Not our poll timer, invoke superclass.
QtlMovieAction::timerEvent(event);
return;
}
// Read a chunk of the input file.
char buffer[QTL_FILE_CHUNK];
const qint64 inCount = _inputFile.read(buffer, sizeof(buffer));
if (inCount < 0) {
// File error.
emitCompleted(false, tr("Error reading %1").arg(_inputFile.fileName()));
}
else if (inCount == 0) {
// End of file.
emitCompleted(true);
}
else {
// Count total input bytes.
_readSize += inCount;
// Cleanup the buffer, remove nul bytes.
char* wr = buffer;
for (const char* rd = buffer; rd < buffer + inCount; ++rd) {
if (*rd != 0) {
*wr++ = *rd;
}
}
const qint64 outCount = wr - buffer;
// Write the clean buffer to output file.
if (_outputFile.write(buffer, outCount) < outCount) {
emitCompleted(false, tr("Error writing %1").arg(_outputFile.fileName()));
}
else if (_readSize >= _nextReport) {
// Report progress in the file.
emitProgress(int(_readSize), int(_totalSize));
_nextReport += _reportInterval;
}
}
}
void play() {
int n_outputs = outputsCount();
Q_ASSERT( n_outputs == m_ways );
int i = 0,
s = m_inputs[0].count();
foreach(Photo photo, m_inputs[0]) {
if (aborted())
continue;
outputPush(i%n_outputs, photo);
emitProgress(i, s, 0, 1);
++i;
}
if (aborted() )
emitFailure();
else
emitSuccess();
}
void timerEvent(QTimerEvent * ev) {
if (ev->timerId() == m_copy.timerId()) {
// Do the copy
qint64 read = m_fi.read(m_buf.data(), m_buf.size());
if (read == -1) {
error(m_fi);
return;
}
if (read == 0) return finished();
qint64 written = m_fo.write(m_buf.constData(), read);
if (written == -1) {
error(m_fo);
return;
}
Q_ASSERT(written == read);
m_done += read;
}
else if (ev->timerId() == m_progress.timerId())
emitProgress();
}
void finished() {
emitProgress();
emit finished(m_done == m_total, m_error);
close();
}
void play() {
int p = 0,
c = m_inputs[0].count();
foreach(Photo photo, m_inputs[0]) {
if (aborted())
continue;
Photo pRed(photo);
Photo pGreen(photo);
Photo pBlue(photo);
Photo pLuminance(photo);
Magick::Image& srcImage = photo.image();
Magick::Image& iRed = pRed.image();
Magick::Image& iGreen = pGreen.image();
Magick::Image& iBlue = pBlue.image();
Magick::Image& iLuminance = pLuminance.image();
try {
ResetImage(iRed);
ResetImage(iGreen);
ResetImage(iBlue);
ResetImage(iLuminance);
std::shared_ptr<Ordinary::Pixels> src_cache(new Ordinary::Pixels(srcImage));
std::shared_ptr<Ordinary::Pixels> iRed_cache(new Ordinary::Pixels(iRed));
std::shared_ptr<Ordinary::Pixels> iGreen_cache(new Ordinary::Pixels(iGreen));
std::shared_ptr<Ordinary::Pixels> iBlue_cache(new Ordinary::Pixels(iBlue));
std::shared_ptr<Ordinary::Pixels> iLuminance_cache(new Ordinary::Pixels(iLuminance));
int w = srcImage.columns();
int h = srcImage.rows();
dfl_block int line = 0;
dfl_parallel_for(y, 0, h, 4, (srcImage, iRed, iGreen, iBlue, iLuminance),{
const Magick::PixelPacket *src = src_cache->getConst(0, y, w, 1);
Magick::PixelPacket *pxl_Red = iRed_cache->get(0, y, w, 1);
Magick::PixelPacket *pxl_Green = iGreen_cache->get(0, y, w, 1);
Magick::PixelPacket *pxl_Blue = iBlue_cache->get(0, y, w, 1);
Magick::PixelPacket *pxl_Luminance = iLuminance_cache->get(0, y, w, 1);
if ( m_error || !src || !pxl_Red || !pxl_Green || !pxl_Blue || !pxl_Luminance ) {
if ( !m_error )
dflError(DF_NULL_PIXELS);
continue;
}
for ( int x = 0 ; x < w ; ++x ) {
pxl_Red[x].red = pxl_Red[x].green = pxl_Red[x].blue = src[x].red;
pxl_Green[x].red = pxl_Green[x].green = pxl_Green[x].blue = src[x].green;
pxl_Blue[x].red = pxl_Blue[x].green = pxl_Blue[x].blue = src[x].blue;
pxl_Luminance[x].red =
pxl_Luminance[x].green =
pxl_Luminance[x].blue = DF_ROUND(LUMINANCE_PIXEL(src[x]));
}
iRed_cache->sync();
iGreen_cache->sync();
iBlue_cache->sync();
iLuminance_cache->sync();
dfl_critical_section({
emitProgress(p, c, line++, h);
});
});
outputPush(0, pLuminance);
outputPush(1, pRed);
outputPush(2, pGreen);
outputPush(3, pBlue);
emitProgress(p, c, 1, 1);
++p;
}
catch(std::exception &e) {
void ProgressReporter::reportProgress(Progress& p)
{
m_current_progress = p;
emitProgress(p);
}
void
Quercus_folder::compute()
{
QString path;
QString file;
QStringList files;
QString error;
pcl::console::TicToc tt,tt2;
tt.tic ();
tt2.tic();
QDir dir = QFileDialog::getExistingDirectory(this, tr("Open Directory"),
"../data/",
QFileDialog::ShowDirsOnly
| QFileDialog::DontResolveSymlinks | QFileDialog::DontUseNativeDialog);
QFileInfo fi(dir, file);
QStringList filters;
filters << "*.pcd" ;
dir.setNameFilters ( filters );
dir.setFilter ( QDir::Files );
files = dir.entryList ();
qDebug() << files << "\n";
path = dir.absolutePath();
qDebug() << "The path to the file" << path << "\n";
for ( int i = 0; i < files.size (); i++ )
{
setStartCoefficient();
QString file_abs = path ;
file_abs = file_abs.append ( "/" ).append ( files.at ( i ) );
qDebug() << "The path to the file" << file_abs;
int index = file_abs.lastIndexOf ( "/" );
int size = file_abs.size ();
int position = size - index - 1;
file = file_abs.right ( position );
qDebug() << "The file" << file <<"\n";
emit emitTreeID(file);
emit emitQString(file, false, false);
std::string file_str = file_abs.toStdString ();
std::string abort;
if ( file_str != abort ) {
ImportPCD import ( file_abs);
import.compute();
_cloud_Ptr = import.getCloud();
emit emitCloud(_cloud_Ptr,true);
}
std::vector<float> e1;
std::vector<float> e2;
std::vector<float> e3;
std::vector<bool> isStem;
EigenValueEstimator es (_cloud_Ptr , e1, e2, e3, isStem, 0.035f );
StemPointDetection detect ( _cloud_Ptr, isStem );
isStem = detect.getStemPtsNew ();
emit emitE1(e1);
emit emitE2(e2);
emit emitE3(e3);
emit emitIsStem(isStem);
emit emitProgress(100);
QString str;
float f = tt.toc () / 1000;
str.append ( "Computed PCA analysis in " ).append ( QString::number ( f ) ).append ( " seconds.\n" );
emit emitQString(str,false,false);
boost::shared_ptr<Optimization> optimize (new Optimization(_method_coefficients.max_iterations, _method_coefficients.seeds_per_voxel, _method_coefficients.min_dist));
optimize->setCoefficients(_method_coefficients);
optimize->setCloudPtr(_cloud_Ptr);
optimize->setIsStem(isStem);
optimize->setTreeID(files.at(i).toStdString());
optimize->optimize();
_method_coefficients = optimize->getCoefficients();
emit emitQString(_method_coefficients.toQString());
{
if (_cloud_Ptr != 0 ) {
pcl::console::TicToc tt;
tt.tic ();
QString str = "\n";
emit emitProgress(0);
SphereFollowing sphereFollowing ( _cloud_Ptr, isStem, 1, _method_coefficients );
emit emitProgress(50);
boost::shared_ptr<simpleTree::Tree> tree = boost::make_shared<simpleTree::Tree> ( sphereFollowing.getCylinders (), _cloud_Ptr,
files.at(i).toStdString(), true );
if ( tree != 0 ) {
//emit emitTreeID(files.at(i).append("_imrpoved"));
QString ID =files.at(i);
ID = ID.append("_unimproved");
ExportPly tree_ply ( tree->getCylinders (), ID.toStdString(), "tree" );
WriteCSV write ( tree, ID.toStdString());
error.append(QString::number(1)).append(",").append(files.at(i)).append(",").append(QString::number(tree->getVolume())).append(",").append(QString::number(tree->getDBH())).append(",").append(QString::number(tree->getBaseDiameter())).append("\n");
}
simpleTree::Allometry allom;
allom.setTree(tree);
allom.setCoefficients(_method_coefficients.a,_method_coefficients.b);
allom.setFac(_method_coefficients.fact);
allom.setMinRad(_method_coefficients.minRad);
allom.improveTree();
float f = tt.toc () / 1000;
str.append ( "Done tree structure in " ).append ( QString::number ( f ) ).append ( " seconds.\n" );
emit emitQString(str,false,true);
emit emitProgress(100);
emit emitTree(tree);
if ( tree != 0 ) {
//emit emitTreeID(files.at(i).append("_imrpoved"));
QString ID =files.at(i);
ID = ID.append("_improved");
ExportPly tree_ply ( tree->getCylinders (), ID.toStdString(), "tree" );
WriteCSV write ( tree, ID.toStdString());
error.append(QString::number(1)).append(",").append(files.at(i)).append(",").append(QString::number(tree->getVolume())).append(",").append(QString::number(tree->getDBH())).append(",").append(QString::number(tree->getBaseDiameter())).append("\n");
}
}
}
}
QString timestr("running complete folder took ");
timestr.append(QString::number(tt2.toc()/1000)).append(QString(" seconds.\n"));
emit emitQString(timestr);
emit emitQString(error);
}
void FeatureController::generateFeatureGraphic(){
DatasetService dsHandler;
FeatureService dataGenerator;
FeatureGraphicsService plotter;
QStringList fileLists;
QString pathEntFiels;
if(_datasetTobeProcessed == NULL) return;
if (_datasetTobeProcessed->hasSample()){
pathEntFiels = _datasetTobeProcessed->pathSampledProteins();
}else{
pathEntFiels = _datasetTobeProcessed->pathProteins();
}
QList<SCOPEntry *> proteins;
if(_datasetTobeProcessed->hasSample()){
proteins = dsHandler.sampledProteins(*_datasetTobeProcessed);
} else {
proteins = dsHandler.proteins(*_datasetTobeProcessed);
}
Matrix <float> *data, *dataAux, *tmpMatrix;
tmpMatrix = NULL;
dataAux = NULL;
SCOPEntry *prot;
unsigned fileCounter;
fileCounter = 0;
QString dataTmpFile;
FeatureDefinition::GeneratorMethod method = _featureDefinition->method();
foreach (prot, proteins) {
// Checks if I'm generating a mixed matrix
switch (method) {
case FeatureDefinition::Angle:
case FeatureDefinition::Distance:
data = dataGenerator.rawMetricsMatrix(method,
prot,
_featureDefinition->treshold());
_svgFile = plotter.generateHeatmap(prot->sid(), data);
break;
case FeatureDefinition::Mixture:
data = dataGenerator.rawMetricsMatrix(FeatureDefinition::Distance,
prot,
_featureDefinition->treshold());
tmpMatrix = dataGenerator.scaleMatrixByNumber(data, _featureDefinition->treshold());
delete data;
data = tmpMatrix;
dataAux = dataGenerator.rawMetricsMatrix(FeatureDefinition::Angle,
prot);
tmpMatrix = dataGenerator.scaleMatrixByNumber(dataAux);
delete dataAux;
dataAux = tmpMatrix;
tmpMatrix = NULL;
_svgFile = plotter.generateMixedHeatmap(prot->sid(), data, dataAux);
break;
default:
qCritical() <<"This generation method is not supported by graphics";
return;
break;
}
delete data;
data = NULL;
if (dataAux != NULL) delete dataAux;
dataAux = NULL;
emitProgress(++fileCounter,proteins.size());
}
qDeleteAll(proteins);
// With sampling
//QStringList filesToProcess = dsHandler.scanFolderForEntFiles(pathEntFiels);
// QMap<QString, QString> filesToGraphic = dsHandler.getSampleFromFileList(filesToProcess, _graphicSampleSize);
// qDebug() << "Sample size for graphics: " << _graphicSampleSize;
// SCOPEntry * rawData;
// unsigned fileCounter;
// Matrix <float> *dataPreprocesed;
// fileCounter = 0;
// QString entryName;
// foreach (entryName, filesToGraphic.keys()) {
//// TODO: Uncomment this when iterating
// qDebug() << "Gonna Load the ent file for: " << entryName;
// rawData = dataLoader.loadEntFile (filesToGraphic.value (entryName));
//// rawData = dataLoader.loadEntFile (filesToGraphic.values().first());
// qDebug() << "Gonna generate the data for: " << entryName;
// dataPreprocesed = dataGenerator.rawMetricsMatrix(
// _featureDefinition, rawData);
// qDebug() << "Gonna write svg for: " << entryName;
// _svgFile = plotter.generateHeatmap(entryName, dataPreprocesed);
// qDebug() << "File located in: " << _svgFile;
// qDebug() << "Just deleted the file matrix";
// qDebug() << "Counter: " << fileCounter;
// fileCounter++;
// emitProgress(fileCounter, _graphicSampleSize);
// delete dataPreprocesed;
// delete rawData;
// }
emit featureGraphicsCompleted();
}
