/*!
Receive newConnection() signals from the tcp server, when a client
connects. Respond by accepting, creating a socket, and piping the
traffic to and from a micro_httpd instance.
*/
void InetdAdaptor::newConnection()
{
HttpWorker *worker = new HttpWorker();
mShowingProgressLock.lock();
if ( mShowingProgress == 0 )
{
// only show progress for one tcp request, if another comes in at
// the same time, don't bother showing progress for that
mShowingProgress = worker;
mShowingProgressLock.unlock();
emit adaptorMessage( tr( "Receiving http request" ));
emit progressValue( 10 );
}
else
{
mShowingProgressLock.unlock();
}
worker->socket = mTcpServer->nextPendingConnection();
Q_ASSERT( worker->socket != NULL );
connect( worker->socket, SIGNAL(disconnected()),
this, SLOT(disconnected()));
connect( worker->socket, SIGNAL(readyRead()),
this, SLOT(socketReadyRead()));
if ( worker == mShowingProgress )
emit progressValue( 20 );
mWorkersLock.lock();
mWorkers.append( worker );
mWorkersLock.unlock();
}
void dataconfigs::loadLevelBGO()
{
unsigned int i;
obj_bgo sbgo;
unsigned long bgo_total=0;
QString bgo_ini = config_dir + "lvl_bgo.ini";
if(!QFile::exists(bgo_ini))
{
addError(QString("ERROR LOADING lvl_bgo.ini: file does not exist"), PGE_LogLevel::Critical);
return;
}
QSettings bgoset(bgo_ini, QSettings::IniFormat);
bgoset.setIniCodec("UTF-8");
main_bgo.clear(); //Clear old
// index_bgo.clear();
bgoset.beginGroup("background-main");
bgo_total = bgoset.value("total", "0").toInt();
total_data +=bgo_total;
bgoset.endGroup();
emit progressPartNumber(1);
emit progressMax(bgo_total);
emit progressValue(0);
emit progressTitle(QObject::tr("Loading BGOs..."));
ConfStatus::total_bgo = bgo_total;
main_bgo.allocateSlots(bgo_total);
if(ConfStatus::total_bgo==0)
{
addError(QString("ERROR LOADING lvl_bgo.ini: number of items not define, or empty config"), PGE_LogLevel::Critical);
return;
}
for(i=1; i<=bgo_total; i++)
{
emit progressValue(i);
if( loadLevelBGO(sbgo, QString("background-"+QString::number(i)), 0, "", &bgoset) )
{
sbgo.id = i;
main_bgo.storeElement(i, sbgo);
}
if( bgoset.status() != QSettings::NoError )
{
addError(QString("ERROR LOADING lvl_bgo.ini N:%1 (bgo-%2)").arg(bgoset.status()).arg(i), PGE_LogLevel::Critical);
}
}
if((unsigned int)main_bgo.stored()<bgo_total)
{
addError(QString("Not all BGOs loaded! Total: %1, Loaded: %2").arg(bgo_total).arg(main_bgo.stored()));
}
}
void dataconfigs::loadRotationTable()
{
size_t i = 0;
obj_rotation_table rTable;
QString rtables_ini = config_dir + "rotation_table.ini";
if(!QFile::exists(rtables_ini))
{
addError(QString("Rotation tables wasn't load: rotation_table.ini does not exist"), PGE_LogLevel::Warning);
return;
}
IniProcessing rtable_set(rtables_ini);
main_rotation_table.clear();
std::vector<std::string> groups = rtable_set.childGroups();
if(groups.size()==0)
{
addError(QString("ERROR LOADING of rotation_table.ini: number of items not define, or empty config"), PGE_LogLevel::Warning);
return;
}
emit progressPartNumber(12);
emit progressMax(static_cast<int>(groups.size()));
emit progressValue(0);
emit progressTitle(QObject::tr("Loading rotation rules table..."));
for(i = 0; i < groups.size(); i++)
{
emit progressValue(static_cast<int>(i));
if(groups[i]=="main")
continue;
rtable_set.beginGroup( groups[i] );
{
rTable.type = Items::getItemType(rtable_set.value("type", "-1").toQString());
rTable.id = rtable_set.value("id", "0").toInt();
rTable.rotate_left = rtable_set.value("rotate-left", "0").toInt();
rTable.rotate_right = rtable_set.value("rotate-right", "0").toInt();
rTable.flip_h = rtable_set.value("flip-h", "0").toInt();
rTable.flip_v = rtable_set.value("flip-v", "0").toInt();
}
rtable_set.endGroup();
if(rTable.type<0) continue;
main_rotation_table.push_back(rTable);
if(rtable_set.lastError() != IniProcessing::ERR_OK)
{
addError(QString("ERROR LOADING lvl_bgo.ini N:%1 (bgo-%2)").arg(rtable_set.lastError()).arg(i), PGE_LogLevel::Critical);
}
}
}
void PackageScanner::scannerDone()
{
emit progressValue( DEFAULT_PROGRESS_MAX );
emit progressMessage( tr( "Found %1 packages" ).arg( mPackageList.count() ));
emit updated();
delete mScanner;
mScanner = 0;
reset();
}
/*!
Receive disconnected() signals from sockets, and respond by cleaning up
the corresponding worker.
*/
void InetdAdaptor::disconnected()
{
QTcpSocket *sock = 0;
QProcess *proc = 0;
sock = qobject_cast<QTcpSocket*>( sender() );
proc = qobject_cast<QProcess*>( sender() );
Q_ASSERT( sock != 0 || proc != 0 );
HttpWorker *disconnectedWorker = 0;
foreach ( HttpWorker *worker, mWorkers )
if ( worker->socket == sock || worker->httpd == proc )
disconnectedWorker = worker;
if ( disconnectedWorker == 0 )
{
qWarning( "Worker quit, but matching socket/process not found. Leak?" );
return;
}
if ( disconnectedWorker == mShowingProgress )
emit progressValue( 80 );
if ( disconnectedWorker->socket )
{
disconnectedWorker->socket->disconnect( mTcpServer );
disconnectedWorker->socket->disconnect( this );
delete disconnectedWorker->socket;
disconnectedWorker->socket = 0;
}
if ( disconnectedWorker->httpd )
{
disconnectedWorker->httpd->disconnect( this );
if ( disconnectedWorker->httpd->state() != QProcess::NotRunning )
{
disconnectedWorker->httpd->terminate();
if ( !disconnectedWorker->httpd->waitForFinished( 100 ))
disconnectedWorker->httpd->kill();
}
delete disconnectedWorker->httpd;
}
mWorkers.removeAll( disconnectedWorker );
delete disconnectedWorker;
if ( disconnectedWorker == mShowingProgress )
{
emit progressValue( 100 );
mShowingProgress = 0;
}
}
/*!
Receive a signal from a httpd process that output is ready for reading
and respond by writing all the output into the appropriate socket.
*/
void InetdAdaptor::httpdReadyRead()
{
QProcess *proc = 0;
HttpWorker *workerReady = 0;
proc = qobject_cast<QProcess*>( sender() );
Q_ASSERT( proc != 0 );
foreach ( HttpWorker *worker, mWorkers )
if ( worker->httpd == proc )
workerReady = worker;
Q_ASSERT( workerReady != 0 );
if ( workerReady == mShowingProgress )
emit progressValue( 40 );
workerReady->socket->write( workerReady->httpd->readAllStandardOutput() );
if ( workerReady == mShowingProgress )
{
emit progressValue( 60 );
emit adaptorMessage( tr( "Processing http request" ));
}
}
void PackageScanner::refresh()
{
emit progressMessage( tr( "Scanning for packages..." ));
emit progressValue( 0 );
mScanner = new ScannerThread( this );
connect( mScanner, SIGNAL(finished()),
this, SLOT(scannerDone()) );
connect( mScanner, SIGNAL(terminated()),
this, SLOT(scannerDone()) );
mScanner->start();
}
/*!
Receive a signal from a socket that output is ready for reading
and respond by writing all the output into the appropriate httpd process.
*/
void InetdAdaptor::socketReadyRead()
{
QTcpSocket *sock = 0;
HttpWorker *workerReady = 0;
sock = qobject_cast<QTcpSocket*>( sender() );
Q_ASSERT( sock != 0 );
foreach ( HttpWorker *worker, mWorkers )
if ( worker->socket == sock )
workerReady = worker;
Q_ASSERT( workerReady != 0 );
runMicroHttpd( workerReady );
workerReady->httpd->write( workerReady->socket->readAll() );
if ( workerReady == mShowingProgress )
emit progressValue( 30 );
}
void PatientManager::readDatabase()
{
QList<Patient> patients = DatabaseAccess().db()->findPatients();
emit progressStarted(patients.size());
QHash<int, int> oldIds = d->patientIdHash;
QList<Patient::Ptr> newPatientList;
foreach (Patient data, patients)
{
int index = d->patientIdHash.value(data.id, -1);
oldIds.remove(data.id);
if (index == -1)
{
Patient::Ptr p = createPatient(data);
loadData(p);
emit patientAdded(d->patients.size()-1, p);
}
else
{
loadData(d->patients[index]);
}
emit progressValue(d->patients.size());
}
int Downloader::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< int*>(_v) = progressTotal(); break;
case 1: *reinterpret_cast< int*>(_v) = progressValue(); break;
case 2: *reinterpret_cast< QString*>(_v) = progressMessage(); break;
}
_id -= 3;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 3;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 3;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 3;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void dataconfigs::loadLevelBackgrounds()
{
unsigned int i;
obj_BG sbg;
unsigned long bg_total=0;
bool useDirectory=false;
QString bg_ini = getFullIniPath("lvl_bkgrd.ini");
if( bg_ini.isEmpty() )
return;
QString nestDir = "";
QSettings setup(bg_ini, QSettings::IniFormat);
setup.setIniCodec("UTF-8");
main_bg.clear(); //Clear old
if(!openSection(&setup, "background2-main")) return;
bg_total = setup.value("total", 0).toUInt();
total_data += bg_total;
nestDir = setup.value("config-dir", "").toString();
if(!nestDir.isEmpty())
{
nestDir = config_dir + nestDir;
useDirectory = true;
}
closeSection(&setup);
emit progressPartNumber(0);
emit progressMax(int(bg_total));
emit progressValue(0);
emit progressTitle(QObject::tr("Loading Backgrounds..."));
ConfStatus::total_bg = long(bg_total);
main_bg.allocateSlots(int(bg_total));
if(ConfStatus::total_bg==0)
{
addError(QString("ERROR LOADING lvl_bkgrd.ini: number of items not define, or empty config"), PGE_LogLevel::Critical);
return;
}
for(i=1; i<=bg_total; i++)
{
emit progressValue(int(i));
bool valid = false;
if(useDirectory)
{
valid = loadLevelBackground(sbg, "background2", nullptr, QString("%1/background2-%2.ini").arg(nestDir).arg(i));
}
else
{
valid = loadLevelBackground(sbg, QString("background2-%1").arg(i), 0, "", &setup);
}
sbg.id = i;
main_bg.storeElement(int(i), sbg, valid);
if( setup.status() != QSettings::NoError )
{
addError(QString("ERROR LOADING lvl_bgrnd.ini N:%1 (background2-%2)").arg(setup.status()).arg(i), PGE_LogLevel::Critical);
}
}
}
void dataconfigs::loadWorldScene()
{
unsigned int i;
obj_w_scenery sScene;
unsigned long scenery_total=0;
QString scene_ini = config_dir + "wld_scenery.ini";
if(!QFile::exists(scene_ini))
{
addError(QString("ERROR LOADING wld_scenery.ini: file does not exist"), QtCriticalMsg);
return;
}
QSettings sceneset(scene_ini, QSettings::IniFormat);
sceneset.setIniCodec("UTF-8");
main_wscene.clear(); //Clear old
index_wscene.clear();
sceneset.beginGroup("scenery-main");
scenery_total = sceneset.value("total", "0").toInt();
total_data +=scenery_total;
sceneset.endGroup();
emit progressMax(scenery_total);
emit progressTitle(QApplication::tr("Loading Sceneries..."));
ConfStatus::total_wscene= scenery_total;
//creation of empty indexes of arrayElements
wSceneIndexes sceneIndex;
for(i=0;i<=scenery_total; i++)
{
sceneIndex.i=i;
sceneIndex.type=0;
sceneIndex.ai=0;
index_wscene.push_back(sceneIndex);
}
if(ConfStatus::total_wscene==0)
{
addError(QString("ERROR LOADING wld_scenery.ini: number of items not define, or empty config"), QtCriticalMsg);
return;
}
for(i=1; i<=scenery_total; i++)
{
emit progressValue(i);
QString errStr;
sceneset.beginGroup( QString("scenery-"+QString::number(i)) );
sScene.group = sceneset.value("group", "_NoGroup").toString();
sScene.category = sceneset.value("category", "_Other").toString();
sScene.image_n = sceneset.value("image", "").toString();
/***************Load image*******************/
GraphicsHelps::loadMaskedImage(scenePath,
sScene.image_n, sScene.mask_n,
sScene.image, sScene.mask,
errStr);
if(!errStr.isEmpty())
{
addError(QString("SCENE-%1 %2").arg(i).arg(errStr));
goto skipScene;
}
/***************Load image*end***************/
sScene.grid = sceneset.value("grid", qRound(qreal(default_grid)/2)).toInt();
sScene.animated = (sceneset.value("animated", "0").toString()=="1");
sScene.frames = sceneset.value("frames", "1").toInt();
sScene.framespeed = sceneset.value("frame-speed", "175").toInt();
sScene.frame_h = (sScene.animated?
qRound(qreal(sScene.image.height())/
sScene.frames)
: sScene.image.height());
sScene.display_frame = sceneset.value("display-frame", "0").toInt();
sScene.id = i;
main_wscene.push_back(sScene);
/************Add to Index***************/
if(i <= (unsigned int)index_wscene.size())
{
index_wscene[i].i = i-1;
}
/************Add to Index***************/
skipScene:
sceneset.endGroup();
if( sceneset.status() != QSettings::NoError )
{
addError(QString("ERROR LOADING wld_scenery.ini N:%1 (scene-%2)").arg(sceneset.status()).arg(i), QtCriticalMsg);
}
}
if((unsigned int)main_wscene.size()<scenery_total)
{
addError(QString("Not all Sceneries loaded! Total: %1, Loaded: %2").arg(scenery_total).arg(main_wscene.size()));
}
}
void dataconfigs::loadTilesets()
{
main_tilesets.clear();
main_tilesets_grp.clear();
QString tileset_dir = config_dir + "tilesets/";
QString tileset_grp_dir = config_dir + "group_tilesets/";
QStringList filters;
if(QDir(tileset_dir).exists())
{
emit progressPartNumber(10);
emit progressMax(100);
emit progressValue(0);
emit progressTitle(QObject::tr("Loading Tilesets..."));
filters.clear();
filters << "*.tileset.ini";
QDir tilesetDir(tileset_dir);
tilesetDir.setSorting(QDir::Name);
tilesetDir.setNameFilters(filters);
QStringList files = tilesetDir.entryList(filters);
emit progressMax(files.size());
for(int i=0;i<files.size(); i++)
{
emit progressValue(i);
SimpleTileset xxx;
if(tileset::OpenSimpleTileset(tileset_dir + files[i], xxx))
{
main_tilesets.push_back(xxx);
}
}
}
if(QDir(tileset_grp_dir).exists())
{
emit progressPartNumber(11);
emit progressMax(100);
emit progressValue(0);
emit progressTitle(QObject::tr("Loading Tileset groups..."));
filters.clear();
filters << "*.tsgrp.ini";
QDir tilesetDir(tileset_grp_dir);
tilesetDir.setSorting(QDir::Name);
tilesetDir.setNameFilters(filters);
QStringList files = tilesetDir.entryList(filters);
emit progressMax(files.size());
for(int i=0;i<files.size(); i++)
{
emit progressValue(i);
SimpleTilesetGroup xxx;
if(TilesetGroupEditor::OpenSimpleTilesetGroup(tileset_grp_dir + files[i], xxx))
{
main_tilesets_grp.push_back(xxx);
}
}
}
}
void dataconfigs::loadLevelBlocks()
{
unsigned int i;
obj_block sblock;
unsigned long block_total=0;
QString block_ini = config_dir + "lvl_blocks.ini";
if(!QFile::exists(block_ini))
{
addError(QString("ERROR LOADING lvl_blocks.ini: file does not exist"), QtCriticalMsg);
return;
}
QSettings blockset(block_ini, QSettings::IniFormat);
blockset.setIniCodec("UTF-8");
main_block.clear(); //Clear old
index_blocks.clear();
blockset.beginGroup("blocks-main");
block_total = blockset.value("total", "0").toInt();
total_data +=block_total;
blockset.endGroup();
emit progressMax(block_total);
emit progressTitle(QApplication::tr("Loading Blocks..."));
ConfStatus::total_blocks = block_total;
//creation of empty indexes of arrayElements
blocksIndexes blockIndex;
for(i=0;i<=block_total; i++)
{
blockIndex.i=i;
blockIndex.type=0;
index_blocks.push_back(blockIndex);
}
if(ConfStatus::total_blocks==0)
{
addError(QString("ERROR LOADING lvl_blocks.ini: number of items not define, or empty config"), QtCriticalMsg);
return;
}
for(i=1; i<=block_total; i++)
{
emit progressValue(i);
QString errStr;
blockset.beginGroup( QString("block-%1").arg(i) );
sblock.name = blockset.value("name", QString("block %1").arg(i) ).toString();
if(sblock.name=="")
{
addError(QString("BLOCK-%1 Item name isn't defined").arg(i));
goto skipBLOCK;
}
sblock.group = blockset.value("group", "_NoGroup").toString();
sblock.category = blockset.value("category", "_Other").toString();
sblock.grid = blockset.value("grid", default_grid).toInt();
sblock.image_n = blockset.value("image", "").toString();
/***************Load image*******************/
GraphicsHelps::loadMaskedImage(blockPath,
sblock.image_n, sblock.mask_n,
sblock.image, sblock.mask,
errStr);
if(!errStr.isEmpty())
{
addError(QString("BLOCK-%1 %2").arg(i).arg(errStr));
goto skipBLOCK;
}
/***************Load image*end***************/
sblock.sizable = blockset.value("sizable", "0").toBool();
sblock.danger = blockset.value("danger", "0").toInt();
sblock.collision = blockset.value("collision", "1").toInt();
sblock.slopeslide = blockset.value("slope-slide", "0").toBool();
sblock.phys_shape = blockset.value("fixture-type", "0").toInt();// Leaved for compatibility
sblock.phys_shape = blockset.value("shape-type", sblock.phys_shape).toInt();//new value-name
sblock.lava = blockset.value("lava", "0").toBool();
sblock.destroyable = blockset.value("destroyable", "0").toBool();
sblock.destroyable_by_bomb = blockset.value("destroyable-by-bomb", "0").toBool();
sblock.destroyable_by_fireball= blockset.value("destroyable-by-fireball", "0").toBool();
Temp01 = blockset.value("spawn-on-destroy", "0").toString();
if(Temp01!="0")
{
tmp = Temp01.split("-", QString::SkipEmptyParts);
if(tmp.size()==2)
{
if(tmp[0]=="npc")
sblock.spawn_obj = 1;
else
if(tmp[0]=="block")
sblock.spawn_obj = 2;
else
if(tmp[0]=="bgo")
sblock.spawn_obj = 3;
// 1 - NPC, 2 - block, 3 - BGO
sblock.spawn_obj_id = tmp[1].toInt();
}
else // if syntax error in config
{
sblock.spawn = false;
sblock.spawn_obj = 0;
sblock.spawn_obj_id = 0;
}
}
else
{
sblock.spawn = false;
sblock.spawn_obj = 0;
sblock.spawn_obj_id = 0;
}
sblock.effect= blockset.value("destroy-effect", "1").toInt();
sblock.bounce = blockset.value("bounce", "0").toBool();
sblock.hitable = blockset.value("hitable", "0").toBool();
sblock.transfororm_on_hit_into= blockset.value("transform-onhit-into", "2").toInt();
sblock.algorithm = blockset.value("algorithm", "2").toInt();
sblock.view = (int)(blockset.value("view", "background").toString()=="foreground");
sblock.animated = blockset.value("animated", "0").toBool();
sblock.animation_rev = blockset.value("animation-reverse", "0").toBool(); //Reverse animation
sblock.animation_bid = blockset.value("animation-bidirectional", "0").toBool(); //Bidirectional animation
sblock.frames = blockset.value("frames", "1").toInt();
sblock.framespeed = blockset.value("framespeed", "125").toInt();
sblock.frame_h = (sblock.animated?
qRound(
qreal(sblock.image.height())
/sblock.frames)
: sblock.image.height());
sblock.display_frame = blockset.value("display-frame", "0").toInt();
long iTmp;
iTmp = blockset.value("default-invisible", "-1").toInt();
sblock.default_invisible = (iTmp>=0);
sblock.default_invisible_value = (iTmp>=0)?(bool)iTmp:false;
iTmp = blockset.value("default-slippery", "-1").toInt();
sblock.default_slippery = (iTmp>=0);
sblock.default_slippery_value = (iTmp>=0)?(bool)iTmp:false;
iTmp = blockset.value("default-npc-content", "-1").toInt();
sblock.default_content = (iTmp>=0);
sblock.default_content_value = (iTmp>=0) ? (iTmp<1000? iTmp*-1 : iTmp-1000) : 0;
sblock.id = i;
main_block.push_back(sblock);
/************Add to Index***************/
if(i < (unsigned int)index_blocks.size())
index_blocks[i].i = i-1;
/************Add to Index***************/
skipBLOCK:
blockset.endGroup();
if( blockset.status()!=QSettings::NoError)
{
addError(QString("ERROR LOADING lvl_blocks.ini N:%1 (block-%2)").arg(blockset.status()).arg(i), QtCriticalMsg);
break;
}
}
if((unsigned int)main_block.size()<block_total)
{
addError(QString("Not all blocks loaded! Total: %1, Loaded: %2)").arg(block_total).arg(main_block.size()), QtWarningMsg);
}
}
void dataconfigs::loadWorldLevels()
{
unsigned int i;
obj_w_level slevel;
unsigned long levels_total=0;
QString level_ini = config_dir + "wld_levels.ini";
if(!QFile::exists(level_ini))
{
addError(QString("ERROR LOADING wld_levels.ini: file does not exist"), QtCriticalMsg);
return;
}
QSettings levelset(level_ini, QSettings::IniFormat);
levelset.setIniCodec("UTF-8");
main_wlevels.clear(); //Clear old
index_wlvl.clear();
levelset.beginGroup("levels-main");
levels_total = levelset.value("total", "0").toInt();
marker_wlvl.path = levelset.value("path", "0").toInt();
marker_wlvl.bigpath = levelset.value("bigpath", "0").toInt();
total_data +=levels_total;
levelset.endGroup();
emit progressMax(levels_total);
emit progressTitle(QApplication::tr("Loading Level images..."));
ConfStatus::total_wlvl = levels_total;
//creation of empty indexes of arrayElements
wLevelIndexes levelIndex;
for(i=0;i<=levels_total; i++)
{
levelIndex.i=i;
levelIndex.type=0;
levelIndex.ai=0;
index_wlvl.push_back(levelIndex);
}
if(ConfStatus::total_wlvl==0)
{
addError(QString("ERROR LOADING wld_levels.ini: number of items not define, or empty config"), QtCriticalMsg);
return;
}
for(i=0; i<=levels_total; i++)
{
emit progressValue(i);
QString errStr;
levelset.beginGroup( QString("level-"+QString::number(i)) );
slevel.group = levelset.value("group", "_NoGroup").toString();
slevel.category = levelset.value("category", "_Other").toString();
slevel.image_n = levelset.value("image", "").toString();
/***************Load image*******************/
GraphicsHelps::loadMaskedImage(wlvlPath,
slevel.image_n, slevel.mask_n,
slevel.image, slevel.mask,
errStr);
if(!errStr.isEmpty())
{
addError(QString("LEVEL-%1 %2").arg(i).arg(errStr));
goto skipLevel;
}
/***************Load image*end***************/
slevel.grid = levelset.value("grid", default_grid).toInt();
slevel.animated = (levelset.value("animated", "0").toString()=="1");
slevel.frames = levelset.value("frames", "1").toInt();
slevel.framespeed = levelset.value("frame-speed", "175").toInt();
slevel.frame_h = (slevel.animated?
qRound(qreal(slevel.image.height())/
slevel.frames)
: slevel.image.height());
slevel.display_frame = levelset.value("display-frame", "0").toInt();
slevel.id = i;
main_wlevels.push_back(slevel);
/************Add to Index***************/
if(i <= (unsigned int)index_wlvl.size())
{
index_wlvl[i].i = i;
}
/************Add to Index***************/
skipLevel:
levelset.endGroup();
if( levelset.status() != QSettings::NoError )
{
addError(QString("ERROR LOADING wld_levels.ini N:%1 (level-%2)").arg(levelset.status()).arg(i), QtCriticalMsg);
}
}
if((unsigned int)main_wlevels.size()<levels_total)
{
addError(QString("Not all Level images loaded! Total: %1, Loaded: %2").arg(levels_total).arg(main_wlevels.size()));
}
}
void dataconfigs::loadLevelBGO()
{
unsigned long i;
obj_bgo sbgo;
unsigned long bgo_total = 0;
bool useDirectory = false;
QString bgo_ini = getFullIniPath("lvl_bgo.ini");
if(bgo_ini.isEmpty())
return;
IniProcessing setup(bgo_ini);
folderLvlBgo.items.clear();
main_bgo.clear(); //Clear old
if(!openSection(&setup, "background-main"))
return;
{
setup.read("total", bgo_total, 0);
setup.read("grid", defaultGrid.bgo, defaultGrid.bgo);
total_data += bgo_total;
setup.read("config-dir", folderLvlBgo.items, "");
setup.read("extra-settings", folderLvlBgo.extraSettings, folderLvlBgo.items);
if(!folderLvlBgo.items.isEmpty())
{
folderLvlBgo.items = config_dir + folderLvlBgo.items;
useDirectory = true;
}
}
closeSection(&setup);
emit progressPartNumber(1);
emit progressMax(static_cast<int>(bgo_total));
emit progressValue(0);
emit progressTitle(QObject::tr("Loading BGOs..."));
ConfStatus::total_bgo = static_cast<long>(bgo_total);
main_bgo.allocateSlots(static_cast<int>(bgo_total));
if(ConfStatus::total_bgo == 0)
{
addError(QString("ERROR LOADING lvl_bgo.ini: number of items not define, or empty config"), PGE_LogLevel::Critical);
return;
}
for(i = 1; i <= bgo_total; i++)
{
emit progressValue(static_cast<int>(i));
bool valid = false;
if(useDirectory)
valid = loadLevelBGO(sbgo, "background", nullptr, QString("%1/background-%2.ini").arg(folderLvlBgo.items).arg(i));
else
valid = loadLevelBGO(sbgo, QString("background-%1").arg(i), 0, "", &setup);
/***************Load image*******************/
if(valid)
{
QString errStr;
GraphicsHelps::loadMaskedImage(folderLvlBgo.graphics,
sbgo.setup.image_n, sbgo.setup.mask_n,
sbgo.image,
errStr);
if(!errStr.isEmpty())
{
valid = false;
addError(QString("BGO-%1 %2").arg(i).arg(errStr));
}
}
/***************Load image*end***************/
sbgo.setup.id = i;
main_bgo.storeElement(static_cast<int>(i), sbgo, valid);
if(setup.lastError() != IniProcessing::ERR_OK)
addError(QString("ERROR LOADING lvl_bgo.ini N:%1 (bgo-%2)").arg(setup.lastError()).arg(i), PGE_LogLevel::Critical);
}
if(static_cast<unsigned long>(main_bgo.stored()) < bgo_total)
addError(QString("Not all BGOs loaded! Total: %1, Loaded: %2").arg(bgo_total).arg(main_bgo.stored()));
}
void QgsGeometryChecker::emitProgressValue()
{
emit progressValue( mProgressCounter );
}
void HttpFetcher::run()
{
QString fetchFile;
// if no file set, assume fetching package list
fetchFile = file.isEmpty() ? AbstractPackageController::PACKAGE_SUMMARY_FILE : file;
if(url.path().endsWith("/"))
url.setPath(url.path() + fetchFile);
else
url.setPath(url.path() + "/" + fetchFile);
if ( http == 0 ) http = new QHttp();
connect( this, SIGNAL(httpAbort()),
http, SLOT(abort()) );
QString query;
HttpFileReceiver *hr;
Md5File *md5File = 0;
QDir packagePathDir( Qtopia::packagePath() );
if ( file.isEmpty() ) // getting package list
{
if ( packageData == 0 ) packageData = new QBuffer();
hr = new HttpInfoReceiver;
connect( packageData, SIGNAL(bytesWritten(qint64)),
hr, SLOT(packageDataWritten(qint64)));
}
else // getting a file
{
md5File = new Md5File( InstallControl::downloadedPkgPath() );
if ( md5File->exists() )
md5File->remove();
packageData = md5File;
hr = new HttpFileReceiver;
hr->fileSize = fileSize;
}
hr->fetcher = this;
connect( http, SIGNAL(responseHeaderReceived(QHttpResponseHeader)),
hr, SLOT(readResponseHeader(QHttpResponseHeader)));
connect( http, SIGNAL(dataReadProgress(int,int)),
hr, SLOT(updateDataReadProgress(int,int)));
connect( http, SIGNAL(requestFinished(int,bool)),
hr, SLOT(httpRequestFinished(int,bool)));
http->setHost( url.host() , url.port(80));
packageData->open( QIODevice::WriteOnly );
httpGetId = http->get( url.path() + query, packageData );
// show some progress now that we've set everything up
curProgValue = initProgress;
emit progressValue( initProgress );
// run threads event loop
exec();
packageData->close();
if( md5File )
md5Sum = md5File->md5Sum();
delete packageData;
packageData = 0;
delete http;
http = 0;
delete hr;
}
void dataconfigs::loadLevelBGO()
{
unsigned long i;
obj_bgo sbgo;
unsigned long bgo_total=0;
bool useDirectory=false;
QString bgo_ini = getFullIniPath("lvl_bgo.ini");
if(bgo_ini.isEmpty())
return;
QString nestDir = "";
QSettings setup(bgo_ini, QSettings::IniFormat);
setup.setIniCodec("UTF-8");
main_bgo.clear(); //Clear old
if(!openSection( &setup, "background-main")) return;
bgo_total = setup.value("total", 0).toUInt();
defaultGrid.bgo = setup.value("grid", defaultGrid.bgo).toUInt();
total_data +=bgo_total;
nestDir = setup.value("config-dir", "").toString();
if(!nestDir.isEmpty())
{
nestDir = config_dir + nestDir;
useDirectory = true;
}
closeSection(&setup);
emit progressPartNumber(1);
emit progressMax(static_cast<int>(bgo_total));
emit progressValue(0);
emit progressTitle(QObject::tr("Loading BGOs..."));
ConfStatus::total_bgo = static_cast<long>(bgo_total);
main_bgo.allocateSlots(static_cast<int>(bgo_total));
if(ConfStatus::total_bgo==0)
{
addError(QString("ERROR LOADING lvl_bgo.ini: number of items not define, or empty config"), PGE_LogLevel::Critical);
return;
}
for(i=1; i<=bgo_total; i++)
{
emit progressValue(static_cast<int>(i));
bool valid=false;
if(useDirectory)
{
valid = loadLevelBGO(sbgo, "background", nullptr, QString("%1/background-%2.ini").arg(nestDir).arg(i));
}
else
{
valid = loadLevelBGO(sbgo, QString("background-%1").arg(i), 0, "", &setup);
}
/***************Load image*******************/
if(valid)
{
QString errStr;
GraphicsHelps::loadMaskedImage(bgoPath,
sbgo.setup.image_n, sbgo.setup.mask_n,
sbgo.image,
errStr);
if(!errStr.isEmpty())
{
valid=false;
addError(QString("BGO-%1 %2").arg(i).arg(errStr));
}
}
/***************Load image*end***************/
sbgo.setup.id = i;
main_bgo.storeElement(static_cast<int>(i), sbgo, valid);
if( setup.status() != QSettings::NoError )
{
addError(QString("ERROR LOADING lvl_bgo.ini N:%1 (bgo-%2)").arg(setup.status()).arg(i), PGE_LogLevel::Critical);
}
}
if(static_cast<unsigned long>(main_bgo.stored()) < bgo_total)
{
addError(QString("Not all BGOs loaded! Total: %1, Loaded: %2").arg(bgo_total).arg(main_bgo.stored()));
}
}
cv::Mat DarkPixelFilter2Plugin::filter(const cv::Mat &data) const
{
cv::Mat out;
if (data.channels() > 1)
{
// create gray image
std::vector<cv::Mat> iChannels(data.channels());
cv::split(data, &iChannels[0]);
double a = 1.0/iChannels.size();
iChannels[0].convertTo(out, CV_32F, a);
for (int i=1; i<iChannels.size();i++)
{
out += a*iChannels[i];
}
}
else
{
if (data.depth() == CV_32F)
{
data.copyTo(out);
}
else
{
data.convertTo(out, CV_32F);
}
}
// -) Compute mask from specified value:
cv::Mat datamask;
if (_maskByValue > -12345)
{
datamask = out != _maskByValue;
}
// -) Image -> 1/Image
cv::divide(1.0,out,out,CV_32F);
if (_verbose) { verboseDisplayImage("Image -> 1/Image", out); }
emit progressValue(15);
// -) Gaussian blur
cv::GaussianBlur(out, out, cv::Size(_gbWinSize, _gbWinSize), _gbWinSize/1.5);
if (_verbose) { verboseDisplayImage("Gaussian blur", out); }
// -) Resize image
int initW=out.cols, initH=out.rows;
double rf = _resizeFactor;
int newW = initW*rf;
int newH = initH*rf;
if (newW < 256 || newH < 256)
{
rf = qMax(256.0 / initW, 256.0 / initH);
SD_TRACE1("New resize factor : %1", rf);
}
cv::resize(out, out, cv::Size(0, 0), rf, rf, cv::INTER_NEAREST);
if (!datamask.empty())
{
cv::resize(datamask, datamask, cv::Size(0, 0), rf, rf, cv::INTER_NEAREST);
}
emit progressValue(25);
// -) Convert to 8U
{
double minVal, maxVal;
cv::minMaxLoc(out, &minVal, &maxVal, 0, 0,datamask);
cv::Scalar mean, std;
cv::meanStdDev(out, mean, std, datamask);
double nmin = mean.val[0] - 3.0*std.val[0];
minVal = (nmin < minVal) ? minVal : nmin;
double nmax = mean.val[0] + 3.0*std.val[0];
maxVal = (nmax > maxVal) ? maxVal : nmax;
cv::Mat out8U;
out.convertTo(out8U, CV_8U, 255.0/(maxVal-minVal), -255.0*minVal/(maxVal-minVal));
out = out8U;
emit progressValue(30);
}
// -) Median blur
cv::medianBlur(out, out, 3);
// -) Only bright objects
{
cv::Scalar mean = cv::mean(out, datamask);
cv::threshold(out, out, mean[0], 255, cv::THRESH_TOZERO);
cv::Mat mask, m = out == 0;
m.convertTo(mask, out.type(), mean[0]/255.0);
out = out + mask;
}
if (_verbose) { verboseDisplayImage("Only bright objects", out); }
// -) Adaptive thresholding
// Y = (Ymax - Ymin) * (X - Xmin)/(Xmax - Xmin) + Ymin
// Y = (Ymin - Ymax) * (X - Xmin)/(Xmax - Xmin) + Ymax
// transform sensivity [0.0 -> 1.0] into coeff [1.0 -> 0.3]
double v = 1.0 - (0.7)*_sensivity;
cv::Scalar mean = cv::mean(out, datamask);
double c = -v*mean[0];
cv::adaptiveThreshold(out, out, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, _atWinSize, c);
if (_verbose) { verboseDisplayImage("Adaptive thresholding", out); }
emit progressValue(40);
// -) Morpho close
out = blurThreshClose(out, 3, 100, _mcWinSize, 2);
if (_verbose) { verboseDisplayImage("Blur + Theshold + Morpho", out); }
emit progressValue(50);
// -) Resize to initial
cv::resize(out, out, cv::Size(initW, initH), 0, 0, cv::INTER_LINEAR);
emit progressValue(60);
// -) Make contours smoother
{
int s = 7;
cv::blur(out, out, cv::Size(s, s));
cv::Mat k1 = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(s, s));
cv::morphologyEx(out, out, cv::MORPH_ERODE, k1);
}
// -) Find contours
std::vector<std::vector<cv::Point> > contours;
cv::findContours(out, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
cv::Mat res(out.size(), CV_32F);
res.setTo(_noDataValue);
emit progressValue(80);
if (contours.size() > 0)
{
double minArea = _minSize*_minSize;
for (int i=0;i<contours.size();i++)
{
std::vector<cv::Point> contour = contours[i];
// remove line and points
if (contour.size() < 3)
continue;
double s = cv::contourArea(contour);
if (s > minArea)
{
cv::drawContours(res, contours, i, cv::Scalar::all(1.0), CV_FILLED);
}
}
out = res;
}
else
{
_errorMessage = tr("No dark pixel zones found of size larger than %1").arg(_minSize);
return cv::Mat();
}
return out;
}
