IDEApplication::IDEApplication(int& argc, char **argv) : QApplication(argc, argv), mSettings(NULL) { setOrganizationName(PROJECT_ORGANIZATION); setApplicationName(PROJECT_NAME); setApplicationVersion(PROJECT_VERSION); setWindowIcon(QIcon(":/images/arduide.png")); // translation support initializeTranslator(); // fix the data path mDataPath = QDir(DATA_PATH).absolutePath(); registerMetaTypes(); // initialize Grantlee initializeTemplates(); // start the GUI initializeGui(); // check the settings are correct, or start the wizard initializeSettings(); // further gui initialization mMainWindow->initialize(); // initialize the plugins initializePlugins(); }
void ScriptEngine::init() { if (_isInitialized) { return; // only initialize once } _isInitialized = true; auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>(); entityScriptingInterface->init(); // register various meta-types registerMetaTypes(this); registerMIDIMetaTypes(this); registerEventTypes(this); registerMenuItemProperties(this); registerAnimationTypes(this); registerAvatarTypes(this); registerAudioMetaTypes(this); if (_controllerScriptingInterface) { _controllerScriptingInterface->registerControllerTypes(this); } qScriptRegisterMetaType(this, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly); qScriptRegisterMetaType(this, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue); qScriptRegisterMetaType(this, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue); qScriptRegisterSequenceMetaType<QVector<QUuid>>(this); qScriptRegisterSequenceMetaType<QVector<EntityItemID>>(this); qScriptRegisterSequenceMetaType<QVector<glm::vec2> >(this); qScriptRegisterSequenceMetaType<QVector<glm::quat> >(this); qScriptRegisterSequenceMetaType<QVector<QString> >(this); QScriptValue xmlHttpRequestConstructorValue = newFunction(XMLHttpRequestClass::constructor); globalObject().setProperty("XMLHttpRequest", xmlHttpRequestConstructorValue); QScriptValue printConstructorValue = newFunction(debugPrint); globalObject().setProperty("print", printConstructorValue); QScriptValue audioEffectOptionsConstructorValue = newFunction(AudioEffectOptions::constructor); globalObject().setProperty("AudioEffectOptions", audioEffectOptionsConstructorValue); qScriptRegisterMetaType(this, injectorToScriptValue, injectorFromScriptValue); qScriptRegisterMetaType(this, inputControllerToScriptValue, inputControllerFromScriptValue); qScriptRegisterMetaType(this, avatarDataToScriptValue, avatarDataFromScriptValue); qScriptRegisterMetaType(this, animationDetailsToScriptValue, animationDetailsFromScriptValue); registerGlobalObject("Script", this); registerGlobalObject("Audio", &AudioScriptingInterface::getInstance()); registerGlobalObject("Controller", _controllerScriptingInterface); registerGlobalObject("Entities", entityScriptingInterface.data()); registerGlobalObject("Quat", &_quatLibrary); registerGlobalObject("Vec3", &_vec3Library); registerGlobalObject("Uuid", &_uuidLibrary); registerGlobalObject("AnimationCache", DependencyManager::get<AnimationCache>().data()); // constants globalObject().setProperty("TREE_SCALE", newVariant(QVariant(TREE_SCALE))); }
MixxxApplication::MixxxApplication(int& argc, char** argv) : QApplication(argc, argv), m_fakeMouseSourcePointId(0), m_fakeMouseWidget(NULL), m_activeTouchButton(Qt::NoButton), m_pTouchShift(NULL) { registerMetaTypes(); }
void Processor::start(ui::MainWindow * const mainWindow) { registerMetaTypes(); m_thread = createThread(mainWindow); QObject::connect(m_thread, &ProcessorThread::phaseChanged, mainWindow, &ui::MainWindow::setPhase); QObject::connect(m_thread, &ProcessorThread::inputCountChanged, mainWindow, &ui::MainWindow::setInputCount); QObject::connect(m_thread, &ProcessorThread::hashingProgressChanged, mainWindow, &ui::MainWindow::setHashingProgress); QObject::connect(m_thread, &ProcessorThread::comparisonProgressChanged, mainWindow, &ui::MainWindow::setComparisonProgress); m_thread->start(); }
int main(int argc, char **argv) { registerMetaTypes(); App app(argc, argv); MainWindow mainWindow; mainWindow.show(); app.exec(); mxexit(0); }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { this->setWindowState(this->windowState() ^ Qt::WindowFullScreen); this->setWindowIcon(QPixmap(":/Resources/icon.png")); widgetsList.push_back(new LoadingWidget(this)); widgetsList.push_back(new SettingsWidget(this)); widgetsList.push_back(new HomeWidget(this)); widgetsList.push_back(new GalleryWidget(this)); //widgetsList.push_back(new VideoplayerWidget(this)); widgetsList.push_back(new DesktopWidget(this)); initializeCursors(); registerMetaTypes(); startSensorThread(); }
namespace Gaussian1dFitService { // register metatypes with QT so that we can pass Results and InputParameters via signals/slots static bool registerMetaTypes() { std::cerr << "Registering metatype\n"; std::cerr << "Gaussian1dFitService::Results = " << qRegisterMetaType < Gaussian1dFitService::ResultsG1dFit > ( "ResultsG1dFit" ) << "\n"; std::cerr << "Gaussian1dFitService::InputParameters = " << qRegisterMetaType < Gaussian1dFitService::InputParametersG1dFit > ( "InputParametersG1dFit" ) << "\n"; return true; } static bool initOnce_ = registerMetaTypes(); // private exception class class Interrupt { }; ResultsG1dFit::ResultsG1dFit() { // std::cerr << "Results constructor from thread " << QThread::currentThread () << "\n"; status_ = Error; diffSq = 0 / 0.0; rms = 0 / 0.0; } /* Results::Results(const Results & r) { std::cerr << "Results copy-constructor " << r.testImage.width () << "x" << r.testImage.height () << " from thread " << QThread::currentThread () << "\n"; testImage = r.testImage; } */ Manager::Manager( QObject * parent ) : QObject( parent ), worker_( interruptRequested_ ) { // initialize internal fields interruptRequested_ = false; hasPendingInput_ = false; workerBusy_ = false; // connect worker and manager connect( & worker_, SIGNAL( progress( ResultsG1dFit ) ), this, SLOT( onProgress( ResultsG1dFit ) ) ); connect( & worker_, SIGNAL( done( ResultsG1dFit ) ), this, SLOT( onDone( ResultsG1dFit ) ) ); connect( & worker_, SIGNAL( error( QString ) ), this, SLOT( onError( QString ) ) ); connect( & worker_, SIGNAL( interrupt() ), this, SLOT( onInterrupt() ) ); connect( this, SIGNAL( privateGo( InputParametersG1dFit ) ), & worker_, SLOT( onGoFromService( InputParametersG1dFit ) ) ); // move the worker to a separate thread worker_.moveToThread( & workerThread_ ); workerThread_.start(); } void Manager::request( InputParametersG1dFit input ) { // std::cerr << "Manager::request " << input.toString() << "\n"; // if worker is running, ask for interrupt if ( workerBusy_ ) { interruptRequested_ = true; } pendingInput_ = input; hasPendingInput_ = true; schedulePending(); } // if there is a pending request, and worker is not busy, ask worker // to process the pending request // otherwise do nothing void Manager::schedulePending() { if ( ! hasPendingInput_ ) { return; } if ( workerBusy_ ) { return; } hasPendingInput_ = false; interruptRequested_ = false; workerBusy_ = true; // tell worker to start working on the request emit privateGo( pendingInput_ ); } Worker::Worker( bool & interruptFlagRef ) : interruptFlag_( interruptFlagRef ) { } Worker::~Worker() { } // throws an exception if the interrupt flag is set void Worker::checkForInterrupts() { if ( interruptFlag_ == true ) { throw Interrupt(); } } void Worker::onGoFromService( InputParametersG1dFit input ) { try { doWork( input ); } catch ( Interrupt & ) { // std::cerr << "*** Worker interrupted ***\n"; emit interrupt(); } catch ( std::runtime_error & e ) { qDebug() << "Worker runtime-exception: " << e.what(); emit error( QString( "runtime-exception: %1" ).arg( e.what() ) ); } catch ( std::exception & e ) { qDebug() << "Worker std-exception: " << e.what(); emit error( QString( "std-exception: %1" ).arg( e.what() ) ); } catch ( std::string & s ) { qDebug() << "Worker exception: " << s.c_str(); emit error( QString( "exception: %1" ).arg( s.c_str() ) ); } catch ( QString & s ) { qDebug() << "Worker exception: " << s; emit error( QString( "exception: %1" ).arg( s ) ); } catch ( char * s ) { qDebug() << "Worker exception: " << s; emit error( QString( "exception: %1" ).arg( s ) ); } catch ( ... ) { qDebug() << "Worker uncaught exception..."; emit error( "Uncaught exception" ); } qDebug() << "Exiting onGoFromService"; } // Worker::onGoFromService void Worker::doWork( InputParametersG1dFit input ) { // prepare results (partial) ResultsG1dFit res; res.input = input; res.status_ = ResultsG1dFit::Partial; res.params.resize( res.input.nGaussians * 3 + res.input.poly, 0.0 ); // handle null input (early exit) if ( input.isNull || input.nGaussians + input.poly <= 0 ) { res.status_ = ResultsG1dFit::Complete; res.diffSq = - 1; emit done( res ); return; } // should we do all fitters? // heuristic fitter only if initial guess not present bool doHeuristic = ( int ( input.initGuess.size() ) != input.nGaussians * 3 + input.poly ); // threshold accepting only if // - multiple gaussians // - or 1 gaussian and at least 1 polynomial term // - it is enabled by the user // bool doLBTA = input.nGaussians > 1 || ( input.nGaussians == 1 && input.poly > 0 ); if ( ! input.randomHeuristicsEnabled ) { doLBTA = false; } // levenberg/marquardt if there is at least 1 gaussian bool doLM = input.nGaussians > 0; // doLBTA = false; // doLM = false; // initialize timer for reporting progress QTime progressTimer; progressTimer.restart(); bool firstProgressNeeded = true; int iteration = 0; // set up the data source for the various gaussian fitters Optimization::Gaussian1DFitting::FitterInput dataInterface( input.data ); dataInterface.x1 = input.left; dataInterface.x2 = input.right; dataInterface.nGaussians = input.nGaussians; dataInterface.nPolyTerms = input.poly; dataInterface.precomputeRangeMinMax(); dataInterface.ranges.resize( dataInterface.numParams() ); double range12 = dataInterface.rangeMax - dataInterface.rangeMin; for ( int i = 0 ; i < dataInterface.nGaussians ; i++ ) { // center dataInterface.ranges[i * 3 + 0].set( input.left, input.right ); // amplitude dataInterface.ranges[i * 3 + 1].set( dataInterface.rangeMin - 0.1 * range12, dataInterface.rangeMax + 0.1 * range12 ); qDebug() << "Data range:" << dataInterface.rangeMin << dataInterface.rangeMax; // dataInterface.ranges[i*3+1].set( -10, 10); // variance controlling term dataInterface.ranges[i * 3 + 2].set( - 1.0 / ( 2 * 0.25 ), - 1.0 / ( 2 * ( dataInterface.x2 - dataInterface.x1 ) * ( dataInterface.x2 - dataInterface.x1 ) ) ); } // ---------------------------------------------------------------------- // run the heuristic fitter // ---------------------------------------------------------------------- if ( doHeuristic ) { Optimization::Gaussian1DFitting::HeuristicFitter hFitter( dataInterface ); // start fitting iteration = 0; while ( true ) { iteration++; checkForInterrupts(); bool fitDone = hFitter.iterate(); // report progress: // - after 100ms if it's the first time // - after that every 1000ms bool reportProgress = progressTimer.elapsed() > 1000 || ( progressTimer.elapsed() > 100 && firstProgressNeeded ); bool copyResults = fitDone || reportProgress; if ( copyResults ) { res.params = hFitter.getResults(); res.diffSq = dataInterface.calculateDiffSq( res.params ); res.rms = sqrt( res.diffSq / dataInterface.data.size() ); if ( int ( res.params.size() ) != input.nGaussians * 3 + input.poly ) { throw std::runtime_error( "Gaussian1dFitService::Worker - mismatch in result size" ); } } if ( reportProgress ) { firstProgressNeeded = false; progressTimer.restart(); res.status_ = res.Partial; res.info = QString( "Heuristics #%1" ).arg( iteration ); checkForInterrupts(); emit progress( res ); } if ( fitDone ) { break; } } qDebug() << "Heuristic fitter produced diffSq = " << res.diffSq; } else { // if caller provided initial guess, use that instead res.params = input.initGuess; res.diffSq = dataInterface.calculateDiffSq( res.params ); res.rms = sqrt( res.diffSq / dataInterface.data.size() ); res.status_ = res.Partial; res.info = QString( "Initial guess" ); qDebug() << "Initial guess has diffSq = " << res.diffSq; } // ---------------------------------------------------------------------- // setup the LBTA fitter // ---------------------------------------------------------------------- if ( doLBTA ) { Optimization::Gaussian1DFitting::LBTAFitter taFitter( dataInterface ); taFitter.setInitialParams( res.params ); // start fitting iteration = 0; while ( true ) { iteration++; checkForInterrupts(); // dbg(1) << "Calling taFitter.iterate()\n"; bool taDone = taFitter.iterate(); // report progress: // - after 100ms if it's the first time // - after that every 1000ms bool reportProgress = progressTimer.elapsed() > 1000 || ( progressTimer.elapsed() > 100 && firstProgressNeeded ); bool copyResults = taDone || reportProgress; if ( copyResults ) { res.params = taFitter.getResults(); res.diffSq = dataInterface.calculateDiffSq( res.params ); res.rms = sqrt( res.diffSq / dataInterface.data.size() ); if ( int ( res.params.size() ) != input.nGaussians * 3 + input.poly ) { throw std::runtime_error( "Gaussian1dFitService::Worker - mismatch in result size" ); } } if ( reportProgress ) { firstProgressNeeded = false; progressTimer.restart(); res.status_ = res.Partial; res.info = QString( "TA #%1" ).arg( iteration ); checkForInterrupts(); emit progress( res ); } if ( taDone ) { break; } } qDebug() << "LBTA fitter produced diffSq = " << res.diffSq; } if ( doLM ) { // ---------------------------------------------------------------------- // setup up the lev-mar fitter // ---------------------------------------------------------------------- Optimization::Gaussian1DFitting::LMFitter lmfitter( dataInterface ); lmfitter.setInitialParams( res.params ); // start fitting iteration = 0; while ( true ) { iteration++; checkForInterrupts(); bool lmDone = lmfitter.iterate(); // report progress: // - after 100ms if it's the first time // - after that every 1000ms bool reportProgress = progressTimer.elapsed() > 1000 || ( progressTimer.elapsed() > 100 && firstProgressNeeded ); bool copyResults = lmDone || reportProgress; if ( copyResults ) { res.params = lmfitter.getResults(); res.diffSq = dataInterface.calculateDiffSq( res.params ); // TODO: fix up RMS to account for NANs res.rms = sqrt( res.diffSq / dataInterface.data.size() ); if ( int ( res.params.size() ) != input.nGaussians * 3 + input.poly ) { throw std::runtime_error( "Gaussian1dFitService::Worker - mismatch in result size" ); } } if ( reportProgress ) { firstProgressNeeded = false; progressTimer.restart(); res.status_ = res.Partial; res.info = QString( "LevMar #%1" ).arg( iteration ); checkForInterrupts(); emit progress( res ); } if ( lmDone ) { break; } } qDebug() << "LevMar iteration = " << iteration; qDebug() << "LevMar fitter produced diffSq = " << res.diffSq; // { // QString s; // QTextStream out(&s); // for( size_t i = 0 ; i < res.params.size() ; i ++ ) { // if( i > 10) { out << "..."; break; } // out << res.params[i] << " "; // } // out << "\n"; // dbg(1) << " params: " << s; // } } res.status_ = res.Complete; res.info = "All done."; checkForInterrupts(); emit done( res ); } // Worker::doWork void Manager::onProgress( ResultsG1dFit r ) { // std::cerr << "Manager::onProgress: " << r.toString() << "\n"; emit progress( r ); emit results( r ); } void Manager::onDone( ResultsG1dFit r ) { // std::cerr << "Manager::onDone: " << r.toString() << "\n"; emit done( r ); emit results( r ); workerBusy_ = false; schedulePending(); } void Manager::onError( QString s ) { // std::cerr << "Manager::onError: " << s << "\n"; emit error( s ); workerBusy_ = false; schedulePending(); } void Manager::onInterrupt() { // std::cerr << "Manager::onInterrupt\n"; workerBusy_ = false; schedulePending(); } //double Worker::getData( int x) //{ // if( x < 0 || x >= int(data.size()) ) { // LTHROW( QString("Gaussian1dFitService::Worker::getData() out of bounds x = %1").arg(x)); // qDebug() << "Gaussian1dFitService::Worker::getData() out of bounds x = " << x << "\n"; // return 0; // } // return data[x]; //} }; // namespace Gaussian1dFitService
ProxyBase::ProxyBase(QObject *parent) : QObject(parent) { registerMetaTypes(); }
void ScriptEngine::init() { if (_isInitialized) { return; // only initialize once } _isInitialized = true; _voxelsScriptingInterface.init(); _particlesScriptingInterface.init(); // register various meta-types registerMetaTypes(&_engine); registerVoxelMetaTypes(&_engine); registerEventTypes(&_engine); registerMenuItemProperties(&_engine); registerAnimationTypes(&_engine); registerAvatarTypes(&_engine); qScriptRegisterMetaType(&_engine, ParticlePropertiesToScriptValue, ParticlePropertiesFromScriptValue); qScriptRegisterMetaType(&_engine, ParticleIDtoScriptValue, ParticleIDfromScriptValue); qScriptRegisterSequenceMetaType<QVector<ParticleID> >(&_engine); qScriptRegisterMetaType(&_engine, ModelItemPropertiesToScriptValue, ModelItemPropertiesFromScriptValue); qScriptRegisterMetaType(&_engine, ModelItemIDtoScriptValue, ModelItemIDfromScriptValue); qScriptRegisterMetaType(&_engine, RayToModelIntersectionResultToScriptValue, RayToModelIntersectionResultFromScriptValue); qScriptRegisterSequenceMetaType<QVector<ModelItemID> >(&_engine); qScriptRegisterSequenceMetaType<QVector<glm::vec2> >(&_engine); qScriptRegisterSequenceMetaType<QVector<glm::quat> >(&_engine); qScriptRegisterSequenceMetaType<QVector<QString> >(&_engine); QScriptValue xmlHttpRequestConstructorValue = _engine.newFunction(XMLHttpRequestClass::constructor); _engine.globalObject().setProperty("XMLHttpRequest", xmlHttpRequestConstructorValue); QScriptValue printConstructorValue = _engine.newFunction(debugPrint); _engine.globalObject().setProperty("print", printConstructorValue); QScriptValue soundConstructorValue = _engine.newFunction(soundConstructor); QScriptValue soundMetaObject = _engine.newQMetaObject(&Sound::staticMetaObject, soundConstructorValue); _engine.globalObject().setProperty("Sound", soundMetaObject); QScriptValue injectionOptionValue = _engine.scriptValueFromQMetaObject<AudioInjectorOptions>(); _engine.globalObject().setProperty("AudioInjectionOptions", injectionOptionValue); QScriptValue localVoxelsValue = _engine.scriptValueFromQMetaObject<LocalVoxels>(); _engine.globalObject().setProperty("LocalVoxels", localVoxelsValue); qScriptRegisterMetaType(&_engine, injectorToScriptValue, injectorFromScriptValue); registerGlobalObject("Script", this); registerGlobalObject("Audio", &_audioScriptingInterface); registerGlobalObject("Controller", _controllerScriptingInterface); registerGlobalObject("Models", &_modelsScriptingInterface); registerGlobalObject("Particles", &_particlesScriptingInterface); registerGlobalObject("Quat", &_quatLibrary); registerGlobalObject("Vec3", &_vec3Library); registerGlobalObject("Uuid", &_uuidLibrary); registerGlobalObject("AnimationCache", &_animationCache); registerGlobalObject("Voxels", &_voxelsScriptingInterface); // constants QScriptValue globalObject = _engine.globalObject(); globalObject.setProperty("TREE_SCALE", _engine.newVariant(QVariant(TREE_SCALE))); globalObject.setProperty("COLLISION_GROUP_ENVIRONMENT", _engine.newVariant(QVariant(COLLISION_GROUP_ENVIRONMENT))); globalObject.setProperty("COLLISION_GROUP_AVATARS", _engine.newVariant(QVariant(COLLISION_GROUP_AVATARS))); globalObject.setProperty("COLLISION_GROUP_VOXELS", _engine.newVariant(QVariant(COLLISION_GROUP_VOXELS))); globalObject.setProperty("COLLISION_GROUP_PARTICLES", _engine.newVariant(QVariant(COLLISION_GROUP_PARTICLES))); globalObject.setProperty("AVATAR_MOTION_OBEY_LOCAL_GRAVITY", _engine.newVariant(QVariant(AVATAR_MOTION_OBEY_LOCAL_GRAVITY))); globalObject.setProperty("AVATAR_MOTION_OBEY_ENVIRONMENTAL_GRAVITY", _engine.newVariant(QVariant(AVATAR_MOTION_OBEY_ENVIRONMENTAL_GRAVITY))); // let the VoxelPacketSender know how frequently we plan to call it _voxelsScriptingInterface.getVoxelPacketSender()->setProcessCallIntervalHint(SCRIPT_DATA_CALLBACK_USECS); _particlesScriptingInterface.getParticlePacketSender()->setProcessCallIntervalHint(SCRIPT_DATA_CALLBACK_USECS); }
bool Quassel::init() { if(_initialized) return true; // allow multiple invocations because of MonolithicApplication if (_handleCrashes) { // we have crashhandler for win32 and unix (based on execinfo). #if defined(Q_OS_WIN32) || defined(HAVE_EXECINFO) # ifndef Q_OS_WIN32 // we only handle crashes ourselves if coredumps are disabled struct rlimit *limit = (rlimit *) malloc(sizeof(struct rlimit)); int rc = getrlimit(RLIMIT_CORE, limit); if(rc == -1 || !((long)limit->rlim_cur > 0 || limit->rlim_cur == RLIM_INFINITY)) { # endif /* Q_OS_WIN32 */ signal(SIGABRT, handleSignal); signal(SIGSEGV, handleSignal); # ifndef Q_OS_WIN32 signal(SIGBUS, handleSignal); } free(limit); # endif /* Q_OS_WIN32 */ #endif /* Q_OS_WIN32 || HAVE_EXECINFO */ } _initialized = true; qsrand(QTime(0,0,0).secsTo(QTime::currentTime())); registerMetaTypes(); Network::setDefaultCodecForServer("ISO-8859-1"); Network::setDefaultCodecForEncoding("UTF-8"); Network::setDefaultCodecForDecoding("ISO-8859-15"); if(isOptionSet("help")) { cliParser()->usage(); return false; } if(isOptionSet("version")) { std::cout << qPrintable("Quassel IRC: " + Quassel::buildInfo().plainVersionString) << std::endl; return false; } DEBUG = isOptionSet("debug"); // set up logging if(Quassel::runMode() != Quassel::ClientOnly) { if(isOptionSet("loglevel")) { QString level = optionValue("loglevel"); if(level == "Debug") _logLevel = DebugLevel; else if(level == "Info") _logLevel = InfoLevel; else if(level == "Warning") _logLevel= WarningLevel; else if(level == "Error") _logLevel = ErrorLevel; } QString logfilename = optionValue("logfile"); if(!logfilename.isEmpty()) { _logFile = new QFile(logfilename); if(!_logFile->open(QIODevice::Append | QIODevice::Text)) { qWarning() << "Could not open log file" << logfilename << ":" << _logFile->errorString(); _logFile->deleteLater(); _logFile = 0; } } #ifdef HAVE_SYSLOG _logToSyslog = isOptionSet("syslog"); #endif } return true; }
/*! Constructs a new abstract file task object with \a item. */ AbstractFileTask::AbstractFileTask(const FileTaskItem &item) { registerMetaTypes(); setTaskItem(item); }
#include "../../general/hlogger_p.h" #include "../../utils/hsysutils_p.h" #include <QtCore/QUrl> #include <QtCore/QString> #include <QtCore/QMetaType> static bool registerMetaTypes() { qRegisterMetaType<Herqq::Upnp::HUdn>("Herqq::Upnp::HUdn"); return true; } static bool test = registerMetaTypes(); namespace Herqq { namespace Upnp { /******************************************************************************* * ControlPointHttpServer ******************************************************************************/ ControlPointHttpServer::ControlPointHttpServer(HControlPointPrivate* owner) : HHttpServer(owner->m_loggingIdentifier, owner), m_owner(owner) { Q_ASSERT(m_owner);
namespace RegionStatsService { // register metatypes with QT so that we can pass Results and InputParameters via signals/slots static bool registerMetaTypes() { std::cerr << "Registering metatype\n"; std::cerr << " RegionStatsService::Results = " << qRegisterMetaType<RegionStatsService::ResultsRS>("ResultsRS") << "\n"; std::cerr << " RegionStatsService::InputParameters = " << qRegisterMetaType<RegionStatsService::InputParametersRS>("InputParametersRS") << "\n"; return true; } static bool initOnce_ = registerMetaTypes (); // private exception class //class Interrupt : public std::runtime_error //{ //public: // Interrupt() : std::runtime_error("worker-interrupt") {} //}; // private exception class class Interrupt { }; ResultsRS::ResultsRS() { status_ = Error; width = height = totalPixels = nanPixels = 0; min = max = average = sum = rms = bkgLevel = sumMinusBkg = maxMinusBkg = 0.0; maxPos = QPoint( -1, -1); depth = 0; currentFrame = 0; nFramesComputed = 0; beamArea = std::numeric_limits<double>::quiet_NaN(); totalFluxDensity = std::numeric_limits<double>::quiet_NaN(); aboveBackground = std::numeric_limits<double>::quiet_NaN(); } /* Results::Results(const Results & r) { std::cerr << "Results copy-constructor " << r.testImage.width () << "x" << r.testImage.height () << " from thread " << QThread::currentThread () << "\n"; testImage = r.testImage; } */ Manager::Manager(QObject *parent) : QObject(parent), worker_(interruptRequested_) { // initialize internal fields interruptRequested_ = false; hasPendingInput_ = false; workerBusy_ = false; // connect worker and manager connect ( & worker_, SIGNAL( progress(ResultsRS)), this, SLOT(onProgress(ResultsRS))); connect ( & worker_, SIGNAL( done(ResultsRS)), this, SLOT(onDone(ResultsRS))); connect ( & worker_, SIGNAL( error(QString)), this, SLOT(onError(QString))); connect ( & worker_, SIGNAL( interrupt()), this, SLOT(onInterrupt())); connect ( this, SIGNAL(privateGo(InputParametersRS)), & worker_, SLOT(onGoFromService(InputParametersRS))); // move the worker to a separate thread worker_.moveToThread( & workerThread_); workerThread_.start (); } void Manager::request (InputParametersRS input) { dbg(1) << "Manager::request " << input.toString() << "\n"; // if worker is running, ask for interrupt if( workerBusy_) { interruptRequested_ = true; } pendingInput_ = input; hasPendingInput_ = true; schedulePending (); } // if there is a pending request, and worker is not busy, ask worker // to process the pending request, otherwise do nothing void Manager::schedulePending () { if( ! hasPendingInput_) return; if( workerBusy_) return; hasPendingInput_ = false; interruptRequested_ = false; workerBusy_ = true; // tell worker to start working on the request emit privateGo ( pendingInput_); } void Manager::go () { } Worker::Worker( bool & interruptFlagRef) : interruptFlag_( interruptFlagRef) , m_parser( 0) { // fitsParser_ = 0; // currentFitsLocation_ = ""; } // throws an exception if the interrupt flag is set void Worker::throwIfInterrupt () { if( interruptFlag_ == true) throw Interrupt(); } void Worker::onGoFromService (InputParametersRS input) { try { doWork( input); } catch ( Interrupt & ) { // std::cerr << "*** Worker interrupted ***\n"; dbg(1) << "RS interrupted\n"; emit interrupt (); } catch ( std::runtime_error & e) { std::cerr << "Worker runtime-exception: " << e.what() << "\n"; emit error( QString("runtime-exception: %1").arg(e.what())); } catch ( std::exception & e) { std::cerr << "Worker std-exception: " << e.what() << "\n"; emit error( QString("std-exception: %1").arg(e.what())); } catch ( std::string & s) { std::cerr << "Worker exception: " << s << "\n"; emit error( QString("exception: %1").arg(s.c_str())); } catch ( QString & s) { std::cerr << "Worker exception: " << s << "\n"; emit error( QString("exception: %1").arg(s)); } catch ( char * s) { std::cerr << "Worker exception: " << s << "\n"; emit error( QString("exception: %1").arg(s)); } catch (...) { std::cerr << "Worker uncaught exception...\n"; dbg(1) << "Worker uncaught exception\n"; emit error ( "Uncaught exception"); // throw; } } void Worker::doWorkOld (InputParametersRS input) { ResultsRS r; // for null input emit null output if( input.isNull) { r.status_ = ResultsRS::NullInput; emit done(r); return; } // initialize the parser if it's not already initialized if( ! m_parser) m_parser = new FitsParser(); // if the parser is working on a different filename, reopen it if( currentFitsLocation_.uniqueId () != input.fitsLocation.uniqueId ()) { bool res = m_parser->loadFile ( input.fitsLocation); if( ! res) throw std::runtime_error("Could not open file"); else currentFitsLocation_ = input.fitsLocation; } // get a reference to the fits header const FitsParser::HeaderInfo & hdr = m_parser->getHeaderInfo (); // check for more input errors now that we have fits header input.left = clamp( input.left, 0, hdr.naxis1-1); input.right = clamp( input.right, 0, hdr.naxis1-1); input.top = clamp( input.top, 0, hdr.naxis2-1); input.bottom = clamp( input.bottom, 0, hdr.naxis2-1); if( input.left > input.right) std::swap( input.left, input.right); if( input.top > input.bottom) std::swap( input.top, input.bottom); // prepare results (partial) r.input = input; // save reference to (fixed) input r.width = r.input.right - r.input.left + 1; r.height = r.input.bottom - r.input.top + 1; r.totalPixels = r.width * r.height; r.status_ = ResultsRS::Partial; r.depth = hdr.totalFrames; r.currentFrame = r.input.currentFrame; throwIfInterrupt(); // emit progress (r); int frame = r.input.currentFrame; // get the frame results for the current frame r.frames.resize( hdr.totalFrames); r.frames[ frame] = computeFrame( input, frame); ResultsRS::FrameRes & cfr = r.frames[ frame]; // cfr = computeForFrame( input, frame); // copy out the relevant bits r.nanPixels = cfr.nanPixels; r.min = cfr.min; r.max = cfr.max; r.average = cfr.average; r.sum = cfr.sum; r.rms = cfr.rms; r.bkgLevel = cfr.bkgLevel; r.sumMinusBkg = cfr.sumMinusBkg; r.maxMinusBkg = cfr.maxMinusBkg; r.maxPos = cfr.maxPos; emit progress( r); // initialize timer for reporting progress QTime progressTimer; progressTimer.restart (); // now extract all the other frames for( int i = 0 ; i < hdr.totalFrames ; i ++ ) { throwIfInterrupt(); if( i == frame) continue; // skip the current frame, we already did that one // compute the frame r.frames[i] = computeFrame( input, i); r.nFramesComputed = i + 1; // report progress every second or so, but not for the last frame... if( progressTimer.elapsed () > 1000 && i+1 < hdr.totalFrames) { progressTimer.restart (); throwIfInterrupt (); emit progress( r); } } // we are done r.status_ = ResultsRS::Complete; r.nFramesComputed = r.depth; throwIfInterrupt (); emit done (r); } void Worker::doWork (InputParametersRS input) { // if the last input is different from this input only in the frame number, // then we can re-use some of the results from previous invocation bool cacheValid = false; if( m_lastInput.fitsLocation.uniqueId() == input.fitsLocation.uniqueId() && ! m_lastInput.isNull && m_lastInput.bottom == input.bottom && m_lastInput.top == input.top && m_lastInput.left == input.left && m_lastInput.right == input.right) { cacheValid = true; } else { cacheValid = false; m_currRes = ResultsRS(); m_currRes.nFramesComputed = 0; } m_lastInput = input; // for null input emit null output if( input.isNull) { m_currRes.status_ = ResultsRS::NullInput; emit done(m_currRes); return; } // initialize the parser if it's not already initialized if( ! m_parser) m_parser = new FitsParser(); // if the parser is working on a different filename, reopen it if( currentFitsLocation_.uniqueId () != input.fitsLocation.uniqueId ()) { bool res = m_parser->loadFile ( input.fitsLocation); if( ! res) throw std::runtime_error("Could not open file"); else currentFitsLocation_ = input.fitsLocation; } // get a reference to the fits header const FitsParser::HeaderInfo & hdr = m_parser->getHeaderInfo (); // check for more input errors now that we have fits header input.left = clamp( input.left, 0, hdr.naxis1-1); input.right = clamp( input.right, 0, hdr.naxis1-1); input.top = clamp( input.top, 0, hdr.naxis2-1); input.bottom = clamp( input.bottom, 0, hdr.naxis2-1); if( input.left > input.right) std::swap( input.left, input.right); if( input.top > input.bottom) std::swap( input.top, input.bottom); // prepare results (partial) m_currRes.input = input; // save reference to (fixed) input m_currRes.width = m_currRes.input.right - m_currRes.input.left + 1; m_currRes.height = m_currRes.input.bottom - m_currRes.input.top + 1; m_currRes.totalPixels = m_currRes.width * m_currRes.height; m_currRes.depth = hdr.totalFrames; m_currRes.currentFrame = m_currRes.input.currentFrame; throwIfInterrupt(); int frame = m_currRes.input.currentFrame; // get the frame results for the current frame, unless we can retrieve this already // from the last time m_currRes.frames.resize( hdr.totalFrames); if( cacheValid && frame < m_currRes.nFramesComputed) { } else { m_currRes.frames[ frame] = computeFrame( input, frame); } ResultsRS::FrameRes & cfr = m_currRes.frames[ frame]; // copy out the relevant bits m_currRes.nanPixels = cfr.nanPixels; m_currRes.min = cfr.min; m_currRes.max = cfr.max; m_currRes.average = cfr.average; m_currRes.sum = cfr.sum; m_currRes.rms = cfr.rms; m_currRes.bkgLevel = cfr.bkgLevel; m_currRes.sumMinusBkg = cfr.sumMinusBkg; m_currRes.maxMinusBkg = cfr.maxMinusBkg; m_currRes.maxPos = cfr.maxPos; { // total flux double bmin = 0.0, bmaj = 0.0; bool ok = true; if( ok) bmin = hdr.bmin.toDouble( & ok); if( ok) bmaj = hdr.bmaj.toDouble( & ok); if( ok) { m_currRes.beamArea = bmin * bmaj * 1.13309003545679845240692073642916670254 / (hdr.cdelt1 * hdr.cdelt2); m_currRes.beamArea = fabs( m_currRes.beamArea); m_currRes.totalFluxDensity = m_currRes.sum / m_currRes.beamArea; m_currRes.aboveBackground = m_currRes.sumMinusBkg / m_currRes.beamArea; } else { m_currRes.totalFluxDensity = std::numeric_limits<double>::quiet_NaN(); m_currRes.aboveBackground = std::numeric_limits<double>::quiet_NaN(); m_currRes.beamArea = std::numeric_limits<double>::quiet_NaN(); } } // if the results are already complete, we are done if( m_currRes.nFramesComputed == hdr.totalFrames) { m_currRes.status_ = ResultsRS::Complete; emit done (m_currRes); return; } // otherwise we'll have to compute the remaining frames, but in any case, // report a partial result right now with the current frame m_currRes.status_ = ResultsRS::Partial; emit progress( m_currRes); // initialize timer for reporting progress QTime progressTimer; progressTimer.restart (); // now extract all the other frames int startFrame = m_currRes.nFramesComputed; for( int i = startFrame ; i < hdr.totalFrames ; i ++ ) { throwIfInterrupt(); if( i == frame) continue; // skip the current frame, we already did that one // compute the frame m_currRes.frames[i] = computeFrame( input, i); m_currRes.nFramesComputed = i + 1; // report progress every second or so, but not for the last frame... if( progressTimer.elapsed () > 1000 && i+1 < hdr.totalFrames) { progressTimer.restart (); throwIfInterrupt (); emit progress( m_currRes); } } // we are done m_currRes.status_ = ResultsRS::Complete; m_currRes.nFramesComputed = m_currRes.depth; throwIfInterrupt (); emit done (m_currRes); } ResultsRS::FrameRes Worker::computeFrame(InputParametersRS input, int frame) { ResultsRS::FrameRes r; // prepare results (partial) r.width = input.right - input.left + 1; r.height = input.bottom - input.top + 1; r.totalPixels = r.width * r.height; // get the four corner average double cornerSum = 0.0; int cornerCount = 0; { double val = m_parser-> src( input.left, input.top, frame); if( ! isnan(val)) { cornerCount ++; cornerSum += val; } }{ double val = m_parser-> src( input.left, input.bottom, frame); if( ! isnan(val)) { cornerCount ++; cornerSum += val; } }{ double val = m_parser-> src( input.right, input.top, frame); if( ! isnan(val)) { cornerCount ++; cornerSum += val; } }{ double val = m_parser-> src( input.right, input.bottom, frame); if( ! isnan(val)) { cornerCount ++; cornerSum += val; } } if( cornerCount > 0) { r.bkgLevel = cornerSum / cornerCount; } else { r.bkgLevel = std::numeric_limits<double>::quiet_NaN(); } // const char * ptr = 0; double val; r.min = r.max = std::numeric_limits<double>::quiet_NaN(); r.nanPixels = 0; r.sum = 0; for( int y = input.top ; y <= input.bottom ; y ++ ) { throwIfInterrupt(); for( int x = input.left ; x <= input.right ; x ++ ) { // ptr = m_parser-> srcRaw ( x, y, frame); // val = m_parser-> raw2double( ptr); val = m_parser-> src( x, y, frame); if( std::isnan(val)) { r.nanPixels ++; } else { r.sum += val; if( isnan(r.min) || val < r.min) r.min = val; if( isnan(r.max) || val > r.max) { r.max = val; r.maxPos = QPoint( x, y); } } } } r.average = r.sum / (r.totalPixels - r.nanPixels); r.sumMinusBkg = r.sum - r.bkgLevel * (r.totalPixels - r.nanPixels); r.maxMinusBkg = r.max - r.bkgLevel; double sumSq = 0; for( int y = input.top ; y <= input.bottom ; y ++ ) { throwIfInterrupt(); for( int x = input.left ; x <= input.right ; x ++ ) { // ptr = m_parser-> srcRaw ( x, y, frame); // val = m_parser-> raw2double( ptr); val = m_parser-> src( x, y, frame); if( ! std::isnan(val)) { sumSq += (val - r.average) * (val - r.average); } } } r.rms = sqrt( sumSq / (r.totalPixels - r.nanPixels - 1)); return r; } void Manager::onProgress (ResultsRS r) { // std::cerr << "Manager::onProgress: " << r.toString() << "\n"; emit progress (r); } void Manager::onDone (ResultsRS r) { // std::cerr << "Manager::onDone: " << r.toString() << "\n"; emit done (r); workerBusy_ = false; schedulePending (); } void Manager::onError (QString s) { // std::cerr << "Manager::onError: " << s << "\n"; emit error (s); workerBusy_ = false; schedulePending (); } void Manager::onInterrupt () { // std::cerr << "Manager::onInterrupt\n"; workerBusy_ = false; schedulePending (); } }; // namespace PSRVC
/*! Constructs a new abstract file task object with \a source and \a target. */ AbstractFileTask::AbstractFileTask(const QString &source, const QString &target) { registerMetaTypes(); setTaskItem(FileTaskItem(source, target)); }
* * You should have received a copy of the GNU General Public License * along with Herqq UPnP Av. If not, see <http://www.gnu.org/licenses/>. */ #include "hrating.h" #include <QtCore/QMetaType> static bool registerMetaTypes() { qRegisterMetaType<Herqq::Upnp::Av::HRating>("Herqq::Upnp::Av::HRating"); return true; } static bool regMetaT = registerMetaTypes(); namespace Herqq { namespace Upnp { namespace Av { namespace { HRating::MpaaValues convertMpaa(const QString& arg) { HRating::MpaaValues retVal = HRating::MPAA_Undefined;
int main(int argc, char* argv[]) { namespace DU = util::directory; BibleTimeApp app(argc, argv); //for QApplication app.setApplicationName("bibletime"); app.setApplicationVersion(BT_VERSION); showDebugMessages = QCoreApplication::arguments().contains("--debug"); #ifdef Q_WS_WIN // Use the default Qt message handler if --debug is not specified // This works with Visual Studio debugger Output Window if (showDebugMessages) qInstallMsgHandler( myMessageOutput ); #else qInstallMsgHandler( myMessageOutput ); #endif #ifdef BT_ENABLE_TESTING if (QString(argv[1]) == QString("--run-tests")) { BibleTimeTest testClass; return QTest::qExec(&testClass); } #endif /** \todo Reimplement "--ignore-session" and "--open-default-bible <key>" command line argument handling. */ #ifdef Q_WS_WIN // On Windows, add a path for Qt plugins to be loaded from app.addLibraryPath(app.applicationDirPath() + "/plugins"); // Must set HOME var on Windows QString homeDir(getenv("APPDATA")); _putenv_s("HOME", qPrintable(homeDir)); #endif registerMetaTypes(); if (!DU::initDirectoryCache()) { qFatal("Error initializing directory cache!"); return EXIT_FAILURE; } #ifdef Q_WS_WIN // change directory to the Sword or .sword directory in the $HOME dir so that // the sword.conf is found. It points to the sword/locales.d directory QString homeSwordDir = util::directory::getUserHomeDir().absolutePath(); QDir dir; dir.setCurrent(homeSwordDir); #endif // This is needed for languagemgr language names to work, they use \uxxxx escape sequences in string literals QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8")); //first install QT's own translations QTranslator qtTranslator; qtTranslator.load("qt_" + QLocale::system().name()); app.installTranslator(&qtTranslator); //then our own QTranslator BibleTimeTranslator; BibleTimeTranslator.load( QString("bibletime_ui_").append(QLocale::system().name()), DU::getLocaleDir().canonicalPath()); app.installTranslator(&BibleTimeTranslator); app.setProperty("--debug", QVariant(showDebugMessages)); //Migrate configuration data, if neccessary util::migration::checkMigration(); // setSignalHandler(signalHandler); BibleTime *mainWindow = new BibleTime(); mainWindow->setAttribute(Qt::WA_DeleteOnClose); // a new BibleTime version was installed (maybe a completely new installation) if (CBTConfig::get(CBTConfig::bibletimeVersion) != BT_VERSION) { CBTConfig::set(CBTConfig::bibletimeVersion, BT_VERSION); mainWindow->saveConfigSettings(); } // restore the workspace and process command line options //app.setMainWidget(bibletime_ptr); //no longer used in qt4 (QApplication) mainWindow->show(); mainWindow->processCommandline(); //must be done after the bibletime window is visible #ifndef NO_DBUS new BibleTimeDBusAdaptor(mainWindow); // connect to D-Bus and register as an object: QDBusConnection::sessionBus().registerService("info.bibletime.BibleTime"); QDBusConnection::sessionBus().registerObject("/BibleTime", mainWindow); #endif int r = app.exec(); CLOSE_DEBUG_STREAM; return r; }
/*! Constructs an empty abstract file task object. */ AbstractFileTask::AbstractFileTask() { registerMetaTypes(); }