chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 02:30:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

ResMed loader multithreading work, Fixed autoscaling issue

Browse Source
This commit is contained in:
Mark Watkins 2014-05-20 21:51:47 +10:00
parent 27a7a78a53
commit c88f46a6fd
13 changed files with 569 additions and 625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
sleepyhead/Graphs/gGraph.cpp
View File

@ -516,15 +516,19 @@ void gGraph::roundY(EventDataType &miny, EventDataType &maxy)
int m, t;
bool ymin_good = false, ymax_good = false;
// rec_miny/maxy are the graph settings defined in preferences
if (rec_miny != rec_maxy) {
// Clip min
if (miny > rec_miny) {
miny = rec_miny;
}
// Clip max
if (maxy < rec_maxy) {
maxy = rec_maxy;
}
//
if (miny == rec_miny) {
ymin_good = true;
}
@ -534,6 +538,7 @@ void gGraph::roundY(EventDataType &miny, EventDataType &maxy)
}
}
// Have no minx/miny reference, have to create one
if (maxy == miny) {
m = ceil(maxy / 2.0);
t = m * 2;
@ -561,6 +566,13 @@ void gGraph::roundY(EventDataType &miny, EventDataType &maxy)
miny = t;
}
if (miny < 0) {
EventDataType tmp = qMax(qAbs(miny), qAbs(maxy));
maxy = tmp;
miny = -tmp;
}
return;
}
@ -609,6 +621,13 @@ void gGraph::roundY(EventDataType &miny, EventDataType &maxy)
}
}
if (miny < 0) {
EventDataType tmp = qMax(qAbs(miny), qAbs(maxy));
maxy = tmp;
miny = -tmp;
}
//if (m_enforceMinY) { miny=f_miny; }
//if (m_enforceMaxY) { maxy=f_maxy; }
}

10
sleepyhead/Graphs/gLineChart.cpp
View File

@ -194,9 +194,17 @@ void gLineChart::paint(QPainter &painter, gGraph &w, const QRegion &region)
} else {
miny = w.min_y, maxy = w.max_y;
}
w.roundY(miny, maxy);
#define DEBUG_AUTOSCALER
#ifdef DEBUG_AUTOSCALER
QString a = QString().sprintf("%.2f - %.2f",miny, maxy);
w.renderText(a,width/2,top-5);
#endif
// the middle of minx and maxy does not have to be the center...
double xx = maxx - minx;
double xmult = double(width) / xx;

17
sleepyhead/Graphs/gYAxis.cpp
View File

@ -69,12 +69,12 @@ void gXGrid::paint(QPainter &painter, gGraph &w, const QRegion &region)
double max_yticks = round(height / (y + 14.0)); // plus spacing between lines
//double yt=1/max_yticks;
double mxy = MAX(fabs(maxy), fabs(miny));
double mxy = maxy; //MAX(fabs(maxy), fabs(miny));
double mny = miny;
if (miny < 0) {
mny = -mxy;
}
// if (miny < 0) {
// mny = -mxy;
// }
double rxy = mxy - mny;
@ -304,13 +304,8 @@ void gYAxis::paint(QPainter &painter, gGraph &w, const QRegion &region)
miny = w.physMinY();
maxy = w.physMaxY();
} else {
miny = w.min_y;
maxy = w.max_y;
if (miny < 0) { // even it up if it's starts negative
miny = -MAX(fabs(miny), fabs(maxy));
}
}
w.roundY(miny, maxy);
@ -322,11 +317,11 @@ void gYAxis::paint(QPainter &painter, gGraph &w, const QRegion &region)
double max_yticks = round(height / (y + 14.0)); // plus spacing between lines
double mxy = MAX(fabs(maxy), fabs(miny));
double mxy = maxy; // MAX(fabs(maxy), fabs(miny));
double mny = miny;
if (miny < 0) {
mny = -mxy;
// mny = -mxy;
}
double rxy = mxy - mny;

32
sleepyhead/SleepLib/event.cpp
View File

@ -162,33 +162,43 @@ void EventList::AddWaveform(qint64 start, qint16 *data, int recs, qint64 duratio
m_count += recs;
m_data.resize(m_count);
EventStoreType *edata = m_data.data();
// EventStoreType *edata = m_data.data();
EventStoreType raw;
qint16 *ep = data + recs;
qint16 *sp;
EventStoreType *dp = &edata[r];
// qint16 *ep = data + recs;
qint16 *sp = data;
// EventStoreType *dp = &edata[r];
if (m_update_minmax) {
EventDataType min = m_min, max = m_max, val, gain = m_gain;
for (sp = data; sp < ep; ++sp) {
*dp++ = raw = *sp;
for (int i=0; i < recs; ++i ) {
m_data[i] = raw = *sp;
val = EventDataType(raw) * gain + m_offset;
if (min > val) { min = val; }
if (max < val) { max = val; }
sp++;
}
// for (sp = data; sp < ep; ++sp) {
// *dp++ = raw = *sp;
// val = EventDataType(raw) * gain + m_offset;
// if (min > val) { min = val; }
// if (max < val) { max = val; }
// }
m_min = min;
m_max = max;
} else {
//register EventDataType val,gain=m_gain;
for (sp = data; sp < ep; ++sp) {
*dp++ = *sp;
//val=EventDataType(raw)*gain;
for (int i=0; i < recs; ++i) {
m_data[i] = *sp++;
}
// for (sp = data; sp < ep; ++sp) {
// *dp++ = *sp;
// //val=EventDataType(raw)*gain;
// }
}
}

291
sleepyhead/SleepLib/loader_plugins/cms50_loader.cpp
View File

@ -42,6 +42,13 @@ CMS50Loader::CMS50Loader()
CMS50Loader::~CMS50Loader()
{
}
bool CMS50Loader::Detect(const QString &path)
{
Q_UNUSED(path);
return false;
}
int CMS50Loader::Open(QString &path, Profile *profile)
{
// CMS50 folder structure detection stuff here.
@ -66,293 +73,12 @@ int CMS50Loader::Open(QString &path, Profile *profile)
&& dir.exists("Data")) {
// SPO2Review/etc software
return OpenCMS50(tmp, profile);
// return OpenCMS50(tmp, profile);
}
return 0;
}
int CMS50Loader::OpenCMS50(QString &path, Profile *profile)
{
QString filename, pathname;
QList<QString> files;
QDir dir(path);
if (!dir.exists()) {
return 0;
}
if (qprogress) { qprogress->setValue(0); }
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Name);
QFileInfoList flist = dir.entryInfoList();
QString fn;
for (int i = 0; i < flist.size(); i++) {
QFileInfo fi = flist.at(i);
fn = fi.fileName().toLower();
if (fn.endsWith(".spor") || fn.endsWith(".spo2")) {
files.push_back(fi.canonicalFilePath());
}
//if (loader_progress) loader_progress->Pulse();
}
int size = files.size();
if (size == 0) { return 0; }
Machine *mach = CreateMachine(profile);
int cnt = 0;
for (QList<QString>::iterator n = files.begin(); n != files.end(); n++, ++cnt) {
if (qprogress) { qprogress->setValue((float(cnt) / float(size) * 50.0)); }
QApplication::processEvents();
OpenSPORFile((*n), mach, profile);
}
mach->Save();
if (qprogress) { qprogress->setValue(100); }
return 1;
}
bool CMS50Loader::OpenSPORFile(QString path, Machine *mach, Profile *profile)
{
if (!mach || !profile) {
return false;
}
QFile f(path);
unsigned char tmp[256];
qint16 data_starts;
qint16 some_code;
qint16 some_more_code;
int seconds = 0, num_records;
int br;
if (!f.open(QIODevice::ReadOnly)) {
return false;
}
// Find everything after the last _
QString str = path.section("/", -1);
str = str.section("_", -1);
str = str.section(".", 0, 0);
QDateTime dt;
if (str.length() == 14) {
dt = QDateTime::fromString(str, "yyyyMMddHHmmss");
} else if (str.length() == 12) {
dt = QDateTime::fromString(str, "yyyyMMddHHmm");
} else {
qDebug() << "CMS50::Spo[r2] Dodgy date field";
return false;
}
if (!dt.isValid()) {
return false;
}
SessionID sessid = dt.toTime_t(); // Import date becomes session id
if (mach->SessionExists(sessid)) {
return false; // Already imported
}
br = f.read((char *)tmp, 2);
if (br != 2) { return false; }
data_starts = tmp[0] | (tmp[1] << 8);
br = f.read((char *)tmp, 2);
if (br != 2) { return false; }
some_code = tmp[0] | (tmp[1] << 8); // 512 or 256 observed
Q_UNUSED(some_code);
br = f.read((char *)tmp, 2);
if (br != 2) { return false; }
seconds = tmp[0] | (tmp[1] << 8);
if (!seconds) {
num_records = (f.size() - data_starts);
seconds = num_records / 2;
} else {
num_records = seconds << 1;
}
if (seconds < 60) {
// Don't bother importing short sessions
return false;
}
br = f.read((char *)tmp, 2);
if (br != 2) { return false; }
some_more_code = tmp[0] | (tmp[1] << 8); // == 0
Q_UNUSED(some_more_code);
br = f.read((char *)tmp, 34); // Read widechar date record
if (br != 34) { return false; }
for (int i = 0; i < 17; i++) { // Convert to 8bit
tmp[i] = tmp[i << 1];
}
tmp[17] = 0;
QString datestr = (char *)tmp;
QDateTime date;
qint64 starttime;
if (datestr.isEmpty()) { // Has Internal date record, so use it
date = QDateTime::fromString(datestr, "MM/dd/yy HH:mm:ss");
QDate d2 = date.date();
if (d2.year() < 2000) { // Nice to see CMS50 is Y2K friendly..
d2.setDate(d2.year() + 100, d2.month(), d2.day());
date.setDate(d2);
}
if (!date.isValid()) {
qDebug() << "Invalid date time retreieved in CMS50::OpenSPO[R2]File";
return false;
}
starttime = qint64(date.toTime_t()) * 1000L;
} else if (dt.isValid()) { // Else take the filenames date
date = dt;
starttime = qint64(dt.toTime_t()) * 1000L;
} else { // Has nothing, so add it up to current time
qDebug() << "CMS50: Couldn't get any start date indication";
date = QDateTime::currentDateTime();
date = date.addSecs(-seconds);
starttime = qint64(date.toTime_t()) * 1000L;
}
f.seek(data_starts);
buffer = new char [num_records];
br = f.read(buffer, num_records);
if (br != num_records) {
qDebug() << "Short .spo[R2] File: " << path;
delete [] buffer;
return false;
}
//QDateTime last_pulse_time=date;
//QDateTime last_spo2_time=date;
EventDataType last_pulse = buffer[0];
EventDataType last_spo2 = buffer[1];
EventDataType cp = 0, cs = 0;
Session *sess = new Session(mach, sessid);
sess->updateFirst(starttime);
EventList *oxip = sess->AddEventList(OXI_Pulse, EVL_Event);
EventList *oxis = sess->AddEventList(OXI_SPO2, EVL_Event);
oxip->AddEvent(starttime, last_pulse);
oxis->AddEvent(starttime, last_spo2);
EventDataType PMin = 0, PMax = 0, SMin = 0, SMax = 0, PAvg = 0, SAvg = 0;
int PCnt = 0, SCnt = 0;
qint64 tt = starttime;
//fixme: Need two lasttime values here..
qint64 lasttime = starttime;
bool first_p = true, first_s = true;
for (int i = 2; i < num_records; i += 2) {
cp = buffer[i];
cs = buffer[i + 1];
if (last_pulse != cp) {
oxip->AddEvent(tt, cp);
if (tt > lasttime) { lasttime = tt; }
if (cp > 0) {
if (first_p) {
PMin = cp;
first_p = false;
} else {
if (PMin > cp) { PMin = cp; }
}
PAvg += cp;
PCnt++;
}
}
if (last_spo2 != cs) {
oxis->AddEvent(tt, cs);
if (tt > lasttime) { lasttime = tt; }
if (cs > 0) {
if (first_s) {
SMin = cs;
first_s = false;
} else {
if (SMin > cs) { SMin = cs; }
}
SAvg += cs;
SCnt++;
}
}
last_pulse = cp;
last_spo2 = cs;
if (PMax < cp) { PMax = cp; }
if (SMax < cs) { SMax = cs; }
tt += 1000; // An educated guess of 1 second. Verified by gcz@cpaptalk
}
if (cp) { oxip->AddEvent(tt, cp); }
if (cs) { oxis->AddEvent(tt, cs); }
sess->updateLast(tt);
EventDataType pa = 0, sa = 0;
if (PCnt > 0) { pa = PAvg / double(PCnt); }
if (SCnt > 0) { sa = SAvg / double(SCnt); }
sess->setMin(OXI_Pulse, PMin);
sess->setMax(OXI_Pulse, PMax);
sess->setAvg(OXI_Pulse, pa);
sess->setMin(OXI_SPO2, SMin);
sess->setMax(OXI_SPO2, SMax);
sess->setAvg(OXI_SPO2, sa);
mach->AddSession(sess, profile);
sess->SetChanged(true);
delete [] buffer;
return true;
}
Machine *CMS50Loader::CreateMachine(Profile *profile)
{
if (!profile) {
@ -396,7 +122,6 @@ void CMS50Loader::Register()
qDebug() << "Registering CMS50Loader";
RegisterLoader(new CMS50Loader());
//InitModelMap();
cms50_initialized = true;
}

6
sleepyhead/SleepLib/loader_plugins/cms50_loader.h
View File

@ -29,9 +29,9 @@ class CMS50Loader : public MachineLoader
CMS50Loader();
virtual ~CMS50Loader();
virtual bool Detect(const QString &path) { Q_UNUSED(path); return false; } // bypass autoscanner
virtual bool Detect(const QString &path);
virtual int Open(QString &path, Profile *profile);
static void Register();
virtual int Version() { return cms50_data_version; }
@ -42,7 +42,7 @@ class CMS50Loader : public MachineLoader
protected:
int OpenCMS50(QString &path, Profile *profile);
bool OpenSPORFile(QString path, Machine *machine, Profile *profile);
// bool OpenSPORFile(QString path, Machine *machine, Profile *profile);
private:
char *buffer;

433
sleepyhead/SleepLib/loader_plugins/resmed_loader.cpp
View File

@ -190,9 +190,13 @@ void ResmedLoader::ParseSTR(Machine *mach, QStringList strfiles)
continue;
}
bool skip = false;
QMap<quint32, STRRecord>::iterator sid = strsess.find(ontime);
// Record already exists?
if (sid != strsess.end()) {
skip=true;
// then skip
laston = ontime;
continue;
}
// For every mask on, there will be a session within 1 minute either way
@ -204,17 +208,23 @@ void ResmedLoader::ParseSTR(Machine *mach, QStringList strfiles)
R.maskoff = offtime;
}
if (sig = str.lookupLabel("Mask Dur")) {
if ((sig = str.lookupLabel("Mask Dur"))) {
R.maskdur = EventDataType(sig->data[rec]) * sig->gain + sig->offset;
}
if (sig == str.lookupLabel("Leak Med")) {
R.leakmed = EventDataType(sig->data[rec]) * sig->gain + sig->offset;
if ((sig = str.lookupLabel("Leak Med"))) {
float gain = sig->gain * 60.0;
R.leakgain = gain;
R.leakmed = EventDataType(sig->data[rec]) * gain + sig->offset;
}
if (sig == str.lookupLabel("Leak Max")) {
R.leakmax = EventDataType(sig->data[rec]) * sig->gain + sig->offset;
if ((sig = str.lookupLabel("Leak Max"))) {
float gain = sig->gain * 60.0;
R.leakgain = gain;
R.leakmax = EventDataType(sig->data[rec]) * gain + sig->offset;
}
if (sig == str.lookupLabel("Leak 95")) {
R.leak95 = EventDataType(sig->data[rec]) * sig->gain + sig->offset;
if ((sig = str.lookupLabel("Leak 95"))) {
float gain = sig->gain * 60.0;
R.leakgain = gain;
R.leak95 = EventDataType(sig->data[rec]) * gain + sig->offset;
}
@ -293,14 +303,12 @@ void ResmedLoader::ParseSTR(Machine *mach, QStringList strfiles)
}
laston = ontime;
if (skip) continue;
QDateTime dontime = QDateTime::fromTime_t(ontime);
date = dontime.date();
R.date = date;
strsess[ontime] = R;
strdate[date].push_back(&strsess[ontime]);
strdate[date].push_back(&strsess.insert(ontime, R).value());
QDateTime dofftime = QDateTime::fromTime_t(offtime);
qDebug() << "Mask on" << dontime << "Mask off" << dofftime;
@ -563,25 +571,131 @@ badfile:
return false;
}
struct EDFGroup {
EDFGroup() { }
EDFGroup(QString brp, QString eve, QString pld, QString sad) {
BRP = brp;
EVE = eve;
PLD = pld;
SAD = sad;
void ResmedImport::run()
{
Session * sess = mach->SessionExists(sessionid);
if (sess) {
if (sess->setting(CPAP_SummaryOnly).toBool()) {
// Reuse this session
sess->wipeSummary();
} else {
// Already imported
return;
}
} else {
// Could be importing from an older backup.. if so, destroy the summary only records
quint32 key = int(sessionid / 60) * 60;
sess = mach->SessionExists(key);
if (sess) {
if (sess->setting(CPAP_SummaryOnly).toBool()) {
sess->Destroy();
delete sess;
}
}
// Create the session
sess = new Session(mach, sessionid);
}
EDFGroup(const EDFGroup & copy) {
BRP = copy.BRP;
EVE = copy.EVE;
PLD = copy.PLD;
SAD = copy.SAD;
if (!group.EVE.isEmpty()) {
loader->LoadEVE(sess, group.EVE);
}
QString BRP;
QString EVE;
QString PLD;
QString SAD;
};
if (!group.BRP.isEmpty()) {
loader->LoadBRP(sess, group.BRP);
}
if (!group.PLD.isEmpty()) {
loader->LoadPLD(sess, group.PLD);
}
if (!group.SAD.isEmpty()) {
loader->LoadSAD(sess, group.SAD);
}
if (!sess->first()) {
delete sess;
return;
}
sess->settings[CPAP_SummaryOnly] = false;
sess->SetChanged(true);
/////////////////////////////////////////////////////////////////////////////////
// Process STR.edf now all valid Session data is imported
/////////////////////////////////////////////////////////////////////////////////
quint32 key = quint32(sessionid / 60) * 60; // round to 1 minute
QMap<quint32, STRRecord>::iterator strsess_end = loader->strsess.end();
QMap<quint32, STRRecord>::iterator it = loader->strsess.find(key);
if (it == strsess_end) {
// ResMed merges mask on/off groups that are less than a minute apart
// this means have to jump back to the last session closest.
it = loader->strsess.lowerBound(key);
if (it != loader->strsess.begin()) it--;
}
if (it != strsess_end) {
STRRecord & R = it.value();
// calculate the time between session record and mask-on record.
int gap = sessionid - R.maskon;
if (gap > 3600*6) {
QDateTime dt = QDateTime::fromTime_t(sessionid);
QDateTime rt = QDateTime::fromTime_t(R.maskon);
qDebug() << "Warning: Closest matching STR record for" << dt << (sess->length() / 1000L) << "is" << rt << "by" << gap << "seconds";
}
// Claim this session
R.sessionid = sessionid;
// Save maskon time in session setting so we can use it later to avoid doubleups.
sess->settings[RMS9_MaskOnTime] = R.maskon;
// Grab all the system settings
if (R.set_pressure >= 0) sess->settings[RMS9_SetPressure] = R.set_pressure;
if (R.min_pressure >= 0) sess->settings[CPAP_PressureMin] = R.min_pressure;
if (R.max_pressure >= 0) sess->settings[CPAP_PressureMax] = R.max_pressure;
if (R.ps >= 0) sess->settings[CPAP_PS] = R.ps;
if (R.min_ps >= 0) sess->settings[CPAP_PSMin] = R.min_ps;
if (R.max_ps >= 0) sess->settings[CPAP_PSMax] = R.max_ps;
if (R.epap >= 0) sess->settings[CPAP_EPAP] = R.epap;
if (R.max_epap >= 0) sess->settings[CPAP_EPAPHi] = R.max_epap;
if (R.min_epap >= 0) sess->settings[CPAP_EPAPLo] = R.min_epap;
if (R.ipap >= 0) sess->settings[CPAP_IPAP] = R.ipap;
if (R.max_ipap >= 0) sess->settings[CPAP_IPAPHi] = R.max_ipap;
if (R.min_ipap >= 0) sess->settings[CPAP_IPAPLo] = R.min_ipap;
if (R.mode >= 0) sess->settings[CPAP_Mode] = R.mode;
if (R.epr >= 0) sess->settings[RMS9_EPR] = R.epr;
if (R.epr_set >= 0) sess->settings[RMS9_EPRSet] = R.epr_set;
// Ignore all the rest of the sumary data, because there is enough available to calculate it with higher accuracy.
if (sess->length() > 0) {
if (!mach->AddSession(sess, p_profile)) {
delete sess;
return;
}
} else {
delete sess;
return;
}
}
// Update indexes, process waveform and perform flagging
sess->UpdateSummaries();
// Save is not threadsafe
loader->saveMutex.lock();
sess->Store(p_profile->Get(mach->properties[STR_PROP_Path]));
loader->saveMutex.unlock();
// Free the memory used by this session
sess->TrashEvents();
}
ResmedLoader::ResmedLoader()
{
@ -635,6 +749,8 @@ Machine *ResmedLoader::CreateMachine(QString serial, Profile *profile)
return m;
}
long event_cnt = 0;
const QString RMS9_STR_datalog = "DATALOG";
@ -788,19 +904,21 @@ int ResmedLoader::Open(QString &path, Profile *profile)
dir.setFilter(QDir::Files | QDir::Hidden | QDir::Readable);
QFileInfoList flist = dir.entryInfoList();
for (int i = 0; i < flist.size(); i++) {
{
int size = flist.size();
for (int i = 0; i < size; i++) {
QFileInfo fi = flist.at(i);
filename = fi.fileName();
if (filename.startsWith("STR", Qt::CaseInsensitive)) {
strfiles.push_back(fi.filePath());
}
}
}
strsess.clear();
ParseSTR(m, strfiles);
EDFParser stredf(strpath);
if (!stredf.Parse()) {
qDebug() << "Faulty file" << RMS9_STR_strfile;
return 0;
@ -1043,7 +1161,7 @@ int ResmedLoader::Open(QString &path, Profile *profile)
if (qprogress) {
if ((i % 5) == 0) {
qprogress->setValue((float(i + 1) / float(size) * 10.0));
qprogress->setValue((float(i + 1) / float(size) * 100.0));
QApplication::processEvents();
}
}
@ -1051,15 +1169,10 @@ int ResmedLoader::Open(QString &path, Profile *profile)
}
QString fn;
Session *sess;
int cnt = 0;
size = filegroups.size();
QHash<SessionID, int> sessday;
EDFSignal *sig;
backup_path += RMS9_STR_datalog + "/";
// Have to sacrifice these features to get access to summary data.
@ -1067,152 +1180,14 @@ int ResmedLoader::Open(QString &path, Profile *profile)
p_profile->session->setDaySplitTime(QTime(12,0,0));
p_profile->session->setIgnoreShortSessions(false);
QList<STRRecord *> trashstr; // list of strsess records to destroy afterwards
/////////////////////////////////////////////////////////////////////////////
// Scan through new file list and import sessions
/////////////////////////////////////////////////////////////////////////////
m_totaltasks = filegroups.size();
for (fgit = filegroups.begin(); fgit != filegroups.end(); ++fgit) {
sessionid = fgit.key();
sess = m->SessionExists(sessionid);
if (sess) {
if (sess->setting(CPAP_SummaryOnly).toBool()) {
// Reuse this session
sess->wipeSummary();
} else {
continue;
}
} else {
// Could be importing from an older backup.. if so, destroy the summary only records
quint32 key = int(sessionid / 60) * 60;
sess = m->SessionExists(key);
if (sess) {
if (sess->setting(CPAP_SummaryOnly).toBool()) {
sess->Destroy();
delete sess;
}
}
// Create the session
sess = new Session(m, sessionid);
}
if (!fgit.value().EVE.isEmpty()) {
EDFParser edf(fgit.value().EVE);
if (edf.Parse()) LoadEVE(sess,edf);
}
if (!fgit.value().BRP.isEmpty()) {
EDFParser edf(fgit.value().BRP);
if (edf.Parse()) LoadBRP(sess,edf);
}
if (!fgit.value().PLD.isEmpty()) {
EDFParser edf(fgit.value().PLD);
if (edf.Parse()) LoadPLD(sess,edf);
}
if (!fgit.value().SAD.isEmpty()) {
EDFParser edf(fgit.value().SAD);
if (edf.Parse()) LoadSAD(sess,edf);
}
if ((++cnt % 10) == 0) {
// TODO: Change me to emit once MachineLoader is QObjectified...
if (qprogress) { qprogress->setValue(10.0 + (float(cnt) / float(size) * 90.0)); }
QApplication::processEvents();
}
int mode = 0;
EventDataType prset = 0, prmode = 0;
qint64 dif;
int dn;
if (!sess) { continue; }
if (!sess->first()) {
delete sess;
continue;
}
sess->settings[CPAP_SummaryOnly] = false;
sess->SetChanged(true);
/////////////////////////////////////////////////////////////////////////////////
// Process STR.edf now all valid Session data is imported
/////////////////////////////////////////////////////////////////////////////////
QMap<quint32, STRRecord>::iterator strsess_end = strsess.end();
quint32 key = int(sessionid / 60) * 60; // round to 1 minute
QMap<quint32, STRRecord>::iterator it = strsess.find(key);
if (it == strsess_end) {
// ResMed merges mask on/off groups that are less than a minute apart
// this means have to jump back to the last session closest.
QMap<quint32, STRRecord>::iterator sit;
int min = 86400;
// Look for the closest matching str record that starts before sessionid.
for (sit = strsess.begin(); sit != strsess_end; ++sit) {
STRRecord & R = *sit;
if (R.maskon > sessionid)
break;
int t = sessionid - R.maskon;
if (qAbs(t) < min) {
it = sit;
min = t;
}
}
}
if (it != strsess_end) {
// This is the right session ID
STRRecord & R = it.value();
QDateTime dt = QDateTime::fromTime_t(sessionid);
QDateTime rt = QDateTime::fromTime_t(R.maskon);
qDebug() << "Closest matching STR record for" << dt << (sess->length() / 1000L) << "is" << rt;
// Claim this session
R.sessionid = sessionid;
// Save maskon time in session setting so we can use it later to avoid doubleups.
sess->settings[RMS9_MaskOnTime]=R.maskon;
// Grab all the system settings
if (R.set_pressure >= 0) sess->settings[RMS9_SetPressure] = R.set_pressure;
if (R.min_pressure >= 0) sess->settings[CPAP_PressureMin] = R.min_pressure;
if (R.max_pressure >= 0) sess->settings[CPAP_PressureMax] = R.max_pressure;
if (R.ps >= 0) sess->settings[CPAP_PS] = R.ps;
if (R.min_ps >= 0) sess->settings[CPAP_PSMin] = R.min_ps;
if (R.max_ps >= 0) sess->settings[CPAP_PSMax] = R.max_ps;
if (R.epap >= 0) sess->settings[CPAP_EPAP] = R.epap;
if (R.max_epap >= 0) sess->settings[CPAP_EPAPHi] = R.max_epap;
if (R.min_epap >= 0) sess->settings[CPAP_EPAPLo] = R.min_epap;
if (R.ipap >= 0) sess->settings[CPAP_IPAP] = R.ipap;
if (R.max_ipap >= 0) sess->settings[CPAP_IPAPHi] = R.max_ipap;
if (R.min_ipap >= 0) sess->settings[CPAP_IPAPLo] = R.min_ipap;
if (R.mode >= 0) sess->settings[CPAP_Mode] = R.mode;
if (R.epr >= 0) sess->settings[RMS9_EPR] = R.epr;
if (R.epr_set >= 0) sess->settings[RMS9_EPRSet] = R.epr_set;
// Ignore all the rest of the sumary data, because there is enough available to calculate it with higher accuracy.
if (sess->length() > 0) {
if (m->AddSession(sess, profile).isNull()) {
continue;
}
} else {
// Hmm.. this means a ton of these could slow down import.
// I could instead set these to disabled by default, or implement a dodgy session marker
delete sess;
}
}
queTask(new ResmedImport(this, fgit.key(), fgit.value(), m));
}
runTasks();
// Now look for any new summary data that can be extracted from STR.edf records
QMap<quint32, STRRecord>::iterator it;
@ -1223,16 +1198,11 @@ int ResmedLoader::Open(QString &path, Profile *profile)
size = m->sessionlist.size();
cnt=0;
// Scan through all sessions, and remove any strsess records that have a matching session already
for (sessit = m->sessionlist.begin(); sessit != sessend; ++sessit) {
sess = *sessit;
quint32 key = sess->settings[RMS9_MaskOnTime].toUInt();
if ((++cnt % 10) == 0) {
// TODO: Change me to emit once MachineLoader is QObjectified...
if (qprogress) { qprogress->setValue(10.0 + (float(cnt) / float(size) * 90.0)); }
QApplication::processEvents();
}
QMap<quint32, STRRecord>::iterator e = strsess.find(key);
if (e != end) {
@ -1245,23 +1215,38 @@ int ResmedLoader::Open(QString &path, Profile *profile)
cnt=0;
quint32 ignoreolder = PROFILE.session->ignoreOlderSessionsDate().toTime_t();
// strsess end can change above.
end = strsess.end();
m->lockSaveMutex();
m->setTotalTasks(m->totalTasks() + size);
m->unlockSaveMutex();
m->StartSaveThreads();
// Look for the nearest matching str record
for (it = strsess.begin(); it != end; ++it) {
STRRecord &R = *it;
STRRecord & R = it.value();
if (R.maskon < ignoreolder) continue;
if (R.maskon < ignoreolder) {
m->skipSaveTask();
continue;
}
//Q_ASSERT(R.sessionid == 0);
if (R.sessionid > 0) continue;
if ((++cnt % 10) == 0) {
// TODO: Change me to emit once MachineLoader is QObjectified...
if (qprogress) { qprogress->setValue(10.0 + (float(cnt) / float(size) * 90.0)); }
QApplication::processEvents();
if (R.sessionid > 0) {
m->skipSaveTask();
continue;
}
// if ((++cnt % 5) == 0) {
// // TODO: Change me to emit once MachineLoader is QObjectified...
// if (qprogress) { qprogress->setValue(10.0 + (float(cnt) / float(size) * 90.0)); }
// QApplication::processEvents();
// }
sess = new Session(m, R.maskon);
sess->really_set_first(qint64(R.maskon) * 1000L);
@ -1291,6 +1276,12 @@ int ResmedLoader::Open(QString &path, Profile *profile)
if (R.epr_set >= 0) sess->settings[RMS9_EPRSet] = R.epr_set;
if (R.leakmax >= 0) sess->setMax(CPAP_Leak, R.leakmax);
if (R.leakmax >= 0) sess->setMin(CPAP_Leak, 0);
if ((R.leakmed >= 0) && (R.leak95 >= 0) && (R.leakmax >= 0)) {
sess->m_timesummary[CPAP_Leak][short(R.leakmax / R.leakgain)]=1;
sess->m_timesummary[CPAP_Leak][short(R.leak95 / R.leakgain)]=9;
sess->m_timesummary[CPAP_Leak][short(R.leakmed / R.leakgain)]=65;
sess->m_timesummary[CPAP_Leak][0]=25;
}
// Find the matching date group for this record
@ -1299,12 +1290,10 @@ int ResmedLoader::Open(QString &path, Profile *profile)
// should not be possible, but my brain hurts...
Q_ASSERT(dtit != strdate.end());
if (dtit != strdate.end()) {
QList<STRRecord *> & dayrecs = dtit.value();
int entries = dayrecs.count();
bool hasdatasess=false;
EventDataType ai=0, hi=0, uai=0, time=0, totaltime=0;
EventDataType time=0, totaltime=0;
for (int c=0; c < dayrecs.size(); ++c) {
STRRecord *r = dayrecs[c];
@ -1339,11 +1328,6 @@ int ResmedLoader::Open(QString &path, Profile *profile)
sess->setCount(CPAP_ClearAirway, r->cai / ratio);
sess->setCph(CPAP_ClearAirway, (r->ai / ratio) / (time / 3600.0));
}
if ((r->leakmed >= 0) && (r->leak95 >= 0) && (r->leakmax >= 0)) {
sess->m_valuesummary[CPAP_Leak][(short)r->leakmax]=100;
sess->m_valuesummary[CPAP_Leak][(short)r->leak95]=90;
sess->m_valuesummary[CPAP_Leak][(short)r->leakmed]=50;
}
}
@ -1353,7 +1337,9 @@ int ResmedLoader::Open(QString &path, Profile *profile)
m->AddSession(sess, profile);
m->queSaveList(sess);
}
m->FinishSaveThreads();
#ifdef DEBUG_EFFICIENCY
{
@ -1379,12 +1365,15 @@ int ResmedLoader::Open(QString &path, Profile *profile)
}
#endif
if (m) {
m->Save();
}
if (qprogress) { qprogress->setValue(100); }
sessfiles.clear();
strsess.clear();
strdate.clear();
channel_efficiency.clear();
channel_time.clear();
qDebug() << "Total Events " << event_cnt;
return 1;
}
@ -1463,10 +1452,14 @@ QString ResmedLoader::backup(QString fullname, QString backup_path, bool compres
}
bool ResmedLoader::LoadEVE(Session *sess, EDFParser &edf)
bool ResmedLoader::LoadEVE(Session *sess, const QString & path)
{
EDFParser edf(path);
if (!edf.Parse())
return false;
QString t;
long recs;
double duration;
char *data;
@ -1604,8 +1597,13 @@ bool ResmedLoader::LoadEVE(Session *sess, EDFParser &edf)
return true;
}
bool ResmedLoader::LoadBRP(Session *sess, EDFParser &edf)
bool ResmedLoader::LoadBRP(Session *sess, const QString & path)
{
EDFParser edf(path);
if (!edf.Parse())
return false;
sess->updateFirst(edf.startdate);
qint64 duration = edf.GetNumDataRecords() * edf.GetDuration();
@ -1799,8 +1797,12 @@ void ResmedLoader::ToTimeDelta(Session *sess, EDFParser &edf, EDFSignal &es, Cha
}
// Load SAD Oximetry Signals
bool ResmedLoader::LoadSAD(Session *sess, EDFParser &edf)
bool ResmedLoader::LoadSAD(Session *sess, const QString & path)
{
EDFParser edf(path);
if (!edf.Parse())
return false;
sess->updateFirst(edf.startdate);
qint64 duration = edf.GetNumDataRecords() * edf.GetDuration();
sess->updateLast(edf.startdate + duration);
@ -1819,21 +1821,21 @@ bool ResmedLoader::LoadSAD(Session *sess, EDFParser &edf)
break;
}
}
if (!hasdata) continue;
if (!hasdata) {
continue;
}
if (matchSignal(OXI_Pulse, es.label)) {
code = OXI_Pulse;
ToTimeDelta(sess, edf, es, code, recs, duration);
sess->setPhysMax(code, 180);
sess->setPhysMin(code, 18);
} else if (matchSignal(OXI_SPO2, es.label)) {
code = OXI_SPO2;
es.physical_minimum = 60;
ToTimeDelta(sess, edf, es, code, recs, duration);
sess->setPhysMax(code, 100);
sess->setPhysMin(code, 60);
} else {
qDebug() << "Unobserved ResMed SAD Signal " << es.label;
}
@ -1843,8 +1845,12 @@ bool ResmedLoader::LoadSAD(Session *sess, EDFParser &edf)
}
bool ResmedLoader::LoadPLD(Session *sess, EDFParser &edf)
bool ResmedLoader::LoadPLD(Session *sess, const QString & path)
{
EDFParser edf(path);
if (!edf.Parse())
return false;
// Is it save to assume the order does not change here?
enum PLDType { MaskPres = 0, TherapyPres, ExpPress, Leak, RR, Vt, Mv, SnoreIndex, FFLIndex, U1, U2 };
@ -1967,6 +1973,7 @@ bool ResmedLoader::LoadPLD(Session *sess, EDFParser &edf)
sess->setPhysMax(code, es.physical_maximum);
a->setDimension(es.physical_dimension);
}
}
return true;

58
sleepyhead/SleepLib/loader_plugins/resmed_loader.h
View File

@ -134,6 +134,8 @@ struct STRRecord
leakmed = -1;
leak95 = -1;
leakmax = -1;
leakgain = 0;
date=QDate();
}
STRRecord(const STRRecord & copy) {
@ -166,6 +168,7 @@ struct STRRecord
leakmed = copy.leakmed;
leak95 = copy.leak95;
leakmax = copy.leakmax;
leakgain = copy.leakgain;
}
quint32 maskon;
quint32 maskoff;
@ -195,9 +198,11 @@ struct STRRecord
EventDataType leakmed;
EventDataType leak95;
EventDataType leakmax;
EventDataType leakgain;
QDate date;
};
/*! \class EDFParser
\author Mark Watkins <jedimark64_at_users.sourceforge.net>
\brief Parse an EDF+ data file into a list of EDFSignal's
@ -270,11 +275,49 @@ class EDFParser
QString reserved44;
};
class ResmedLoader;
struct EDFGroup {
EDFGroup() { }
EDFGroup(QString brp, QString eve, QString pld, QString sad) {
BRP = brp;
EVE = eve;
PLD = pld;
SAD = sad;
}
EDFGroup(const EDFGroup & copy) {
BRP = copy.BRP;
EVE = copy.EVE;
PLD = copy.PLD;
SAD = copy.SAD;
}
QString BRP;
QString EVE;
QString PLD;
QString SAD;
};
class ResmedImport:public ImportTask
{
public:
ResmedImport(ResmedLoader * l, SessionID s, EDFGroup g, Machine * m): loader(l), sessionid(s), group(g), mach(m) {}
virtual ~ResmedImport() {}
virtual void run();
protected:
ResmedLoader * loader;
SessionID sessionid;
EDFGroup group;
Machine * mach;
};
/*! \class ResmedLoader
\brief Importer for ResMed S9 Data
*/
class ResmedLoader : public MachineLoader
{
friend class ResmedImport;
public:
ResmedLoader();
virtual ~ResmedLoader();
@ -300,24 +343,25 @@ class ResmedLoader : public MachineLoader
//! \brief Register the ResmedLoader with the list of other machine loaders
static void Register();
protected:
QHash<QString, Machine *> ResmedList;
//! \brief Parse the EVE Event annotation data, and save to Session * sess
//! This contains all Hypopnea, Obstructive Apnea, Central and Apnea codes
bool LoadEVE(Session *sess, EDFParser &edf);
bool LoadEVE(Session *sess, const QString & path);
//! \brief Parse the BRP High Resolution data, and save to Session * sess
//! This contains Flow Rate, Mask Pressure, and Resp. Event data
bool LoadBRP(Session *sess, EDFParser &edf);
bool LoadBRP(Session *sess, const QString & path);
//! \brief Parse the SAD Pulse oximetry attachment data, and save to Session * sess
//! This contains Pulse Rate and SpO2 Oxygen saturation data
bool LoadSAD(Session *sess, EDFParser &edf);
bool LoadSAD(Session *sess, const QString & path);
//! \brief Parse the PRD low resolution data, and save to Session * sess
//! This contains the Pressure, Leak, Respiratory Rate, Minute Ventilation, Tidal Volume, etc..
bool LoadPLD(Session *sess, EDFParser &edf);
bool LoadPLD(Session *sess, const QString & path);
protected:
QHash<QString, Machine *> ResmedList;
void ParseSTR(Machine *mach, QStringList strfiles);
@ -328,6 +372,8 @@ class ResmedLoader : public MachineLoader
QMap<quint32, STRRecord> strsess;
QMap<QDate, QList<STRRecord *> > strdate;
QMutex saveMutex;
#ifdef DEBUG_EFFICIENCY
QHash<ChannelID, qint64> channel_efficiency;
QHash<ChannelID, qint64> channel_time;

185
sleepyhead/SleepLib/machine.cpp
View File

@ -97,24 +97,16 @@ QDate Machine::pickDate(qint64 first)
return date;
}
QDate Machine::AddSession(Session *s, Profile *p)
bool Machine::AddSession(Session *s, Profile *p)
{
if (!s) {
qWarning() << "Empty Session in Machine::AddSession()";
return QDate();
}
if (!p) {
qWarning() << "Empty Profile in Machine::AddSession()";
return QDate();
}
Q_ASSERT(s != nullptr);
Q_ASSERT(p != nullptr);
if (profile->session->ignoreOlderSessions()) {
qint64 ignorebefore = profile->session->ignoreOlderSessionsDate().toMSecsSinceEpoch();
if (s->last() < ignorebefore) {
skipped_sessions++;
delete s;
return QDate();
return false;
}
}
@ -122,7 +114,6 @@ QDate Machine::AddSession(Session *s, Profile *p)
highest_sessionid = s->session();
}
QTime split_time = PROFILE.session->daySplitTime();
int combine_sessions = PROFILE.session->combineCloseSessions();
int ignore_sessions = PROFILE.session->ignoreShortSessions();
@ -175,7 +166,7 @@ QDate Machine::AddSession(Session *s, Profile *p)
if (session_length < ignore_sessions) {
// keep the session to save importing it again, but don't add it to the day record this time
return QDate();
return true;
}
if (!firstsession) {
@ -220,7 +211,7 @@ QDate Machine::AddSession(Session *s, Profile *p)
day.erase(nextday);
}
return date;
return true;
}
// This functions purpose is murder and mayhem... It deletes all of a machines data.
@ -381,13 +372,127 @@ bool Machine::SaveSession(Session *sess)
return true;
}
void Machine::queSaveList(Session * sess)
{
if (!m_save_threads_running) {
// Threads aren't being used.. so run the actual immediately...
int i = (float(m_donetasks) / float(m_totaltasks) * 100.0);
qprogress->setValue(i);
QApplication::processEvents();
sess->UpdateSummaries();
sess->Store(profile->Get(properties[STR_PROP_Path]));
if (!PROFILE.session->cacheSessions()) {
sess->TrashEvents();
}
} else {
savelistMutex.lock();
m_savelist.append(sess);
savelistMutex.unlock();
}
}
Session *Machine::popSaveList()
{
Session *sess = nullptr;
savelistMutex.lock();
if (!m_savelist.isEmpty()) {
sess = m_savelist.at(0);
m_savelist.pop_front();
m_donetasks++;
}
savelistMutex.unlock();
return sess;
}
// Call any time queing starts
void Machine::StartSaveThreads()
{
m_savelist.clear();
QString path = profile->Get(properties[STR_PROP_Path]);
int threads = QThread::idealThreadCount();
savelistSem = new QSemaphore(threads);
savelistSem->acquire(threads);
m_save_threads_running = true;
m_donetasks=0;
m_totaltasks=0;
for (int i = 0; i < threads; i++) {
thread.push_back(new SaveThread(this, path));
QObject::connect(thread[i], SIGNAL(UpdateProgress(int)), qprogress, SLOT(setValue(int)));
thread[i]->start();
}
}
// Call when all queing is completed
void Machine::FinishSaveThreads()
{
if (!m_save_threads_running)
return;
m_save_threads_running = false;
// Wait for all tasks to finish
while (!savelistSem->tryAcquire(thread.size(), 250)) {
if (qprogress) {
QApplication::processEvents();
}
}
for (int i = 0; i < thread.size(); ++i) {
while (thread[i]->isRunning()) {
SaveThread::msleep(250);
QApplication::processEvents();
}
QObject::disconnect(thread[i], SIGNAL(UpdateProgress(int)), qprogress, SLOT(setValue(int)));
delete thread[i];
}
delete savelistSem;
}
void SaveThread::run()
{
bool running = true;
while (running) {
Session *sess = machine->popSaveList();
if (sess) {
if (machine->m_donetasks % 10 == 0) {
int i = (float(machine->m_donetasks) / float(machine->m_totaltasks) * 100.0);
emit UpdateProgress(i);
}
sess->UpdateSummaries();
sess->Store(path);
sess->TrashEvents();
} else {
if (!machine->m_save_threads_running) {
break; // done
} else {
yieldCurrentThread(); // go do something else for a while
}
}
}
machine->savelistSem->release(1);
}
bool Machine::Save()
{
//int size;
int cnt = 0;
QString path = profile->Get(
properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
QString path = profile->Get(properties[STR_PROP_Path]);
QDir dir(path);
if (!dir.exists()) {
@ -408,7 +513,6 @@ bool Machine::Save()
savelistCnt = 0;
savelistSize = m_savelist.size();
bool cachesessions = PROFILE.session->cacheSessions();
if (!PROFILE.session->multithreading()) {
for (int i = 0; i < savelistSize; i++) {
@ -422,10 +526,7 @@ bool Machine::Save()
Session *s = m_savelist.at(i);
s->UpdateSummaries();
s->Store(path);
if (!cachesessions) {
s->TrashEvents();
}
s->TrashEvents();
savelistCnt++;
@ -465,46 +566,6 @@ bool Machine::Save()
return true;
}
/*SaveThread::SaveThread(Machine *m,QString p)
{
machine=m;
path=p;
} */
void SaveThread::run()
{
bool cachesessions = PROFILE.session->cacheSessions();
while (Session *sess = machine->popSaveList()) {
int i = (float(machine->savelistCnt) / float(machine->savelistSize) * 100.0);
emit UpdateProgress(i);
sess->UpdateSummaries();
sess->Store(path);
if (!cachesessions) {
sess->TrashEvents();
}
}
machine->savelistSem->release(1);
}
Session *Machine::popSaveList()
{
Session *sess = nullptr;
savelistMutex.lock();
if (m_savelist.size() > 0) {
sess = m_savelist.at(0);
m_savelist.pop_front();
savelistCnt++;
}
savelistMutex.unlock();
return sess;
}
//////////////////////////////////////////////////////////////////////////////////////////
// CPAP implmementation
//////////////////////////////////////////////////////////////////////////////////////////

26
sleepyhead/SleepLib/machine.h
View File

@ -66,6 +66,8 @@ class SaveThread: public QThread
*/
class Machine
{
friend class SaveThread;
public:
/*! \fn Machine(Profile *p,MachineID id=0);
\brief Constructs a Machine object in Profile p, and with MachineID id
@ -99,7 +101,7 @@ class Machine
Session *SessionExists(SessionID session);
//! \brief Adds the session to this machine object, and the Master Profile list. (used during load)
QDate AddSession(Session *s, Profile *p);
bool AddSession(Session *s, Profile *p);
//! \brief Find the date this session belongs in, according to profile settings
QDate pickDate(qint64 start);
@ -132,20 +134,39 @@ class Machine
//! \brief Returns the date of the most recent loaded Session
const QDate &LastDay() { return lastday; }
//! \brief Add a new task to the multithreaded save code
void queSaveList(Session * sess);
//! \brief Grab the next task in the multithreaded save code
Session *popSaveList();
//! \brief Start the save threads which handle indexing, file storage and waveform processing
void StartSaveThreads();
//! \brief Finish the save threads and safely close them
void FinishSaveThreads();
//! \brief The list of sessions that need saving (for multithreaded save code)
QList<Session *> m_savelist;
QVector<SaveThread *>thread;
volatile int savelistCnt;
int savelistSize;
QMutex savelistMutex;
QSemaphore *savelistSem;
void lockSaveMutex() { savelistMutex.lock(); }
void unlockSaveMutex() { savelistMutex.unlock(); }
void skipSaveTask() { lockSaveMutex(); m_donetasks++; unlockSaveMutex(); }
void clearSkipped() { skipped_sessions = 0; }
int skippedSessions() { return skipped_sessions; }
inline int totalTasks() { return m_totaltasks; }
inline void setTotalTasks(int value) { m_totaltasks = value; }
inline int doneTasks() { return m_donetasks; }
protected:
QDate firstday, lastday;
SessionID highest_sessionid;
@ -156,8 +177,11 @@ class Machine
Profile *profile;
bool changed;
bool firstsession;
int m_totaltasks;
int m_donetasks;
int skipped_sessions;
volatile bool m_save_threads_running;
};

45
sleepyhead/SleepLib/machine_loader.cpp
View File

@ -9,17 +9,32 @@
* License. See the file COPYING in the main directory of the Linux
* distribution for more details. */
#include <QProgressBar>
#include <QApplication>
#include <QFile>
#include <QDir>
#include <QThreadPool>
extern QProgressBar *qprogress;
#include "machine_loader.h"
// This crap moves to Profile
QList<MachineLoader *> m_loaders;
QList<MachineLoader *> GetLoaders()
QList<MachineLoader *> GetLoaders(MachineType mt)
{
return m_loaders;
QList<MachineLoader *> list;
for (int i=0; i < m_loaders.size(); ++i) {
if (mt == MT_UNKNOWN) {
list.push_back(m_loaders.at(i));
} else {
if (m_loaders.at(i)->type() == mt) {
list.push_back(m_loaders.at(i));
}
}
}
return list;
}
void RegisterLoader(MachineLoader *loader)
@ -35,7 +50,7 @@ void DestroyLoaders()
m_loaders.clear();
}
MachineLoader::MachineLoader()
MachineLoader::MachineLoader() :QObject(nullptr)
{
}
@ -46,7 +61,7 @@ MachineLoader::~MachineLoader()
}
}
bool MachineLoader::compressFile(QString inpath, QString outpath)
bool compressFile(QString inpath, QString outpath)
{
if (outpath.isEmpty()) {
outpath = inpath + ".gz";
@ -92,6 +107,28 @@ bool MachineLoader::compressFile(QString inpath, QString outpath)
return true;
}
void MachineLoader::queTask(ImportTask * task)
{
m_tasklist.push_back(task);
}
void MachineLoader::runTasks()
{
QThreadPool * threadpool = QThreadPool::globalInstance();
m_totaltasks=m_tasklist.size();
m_currenttask=0;
while (!m_tasklist.isEmpty()) {
if (threadpool->tryStart(m_tasklist.at(0))) {
m_tasklist.pop_front();
float f = float(m_currenttask) / float(m_totaltasks) * 100.0;
qprogress->setValue(f);
m_currenttask++;
}
QApplication::processEvents();
}
QThreadPool::globalInstance()->waitForDone(-1);
}
/*const QString machine_profile_name="MachineList.xml";
void MachineLoader::LoadMachineList()

63
sleepyhead/SleepLib/machine_loader.h
View File

@ -11,23 +11,38 @@
#ifndef MACHINE_LOADER_H
#define MACHINE_LOADER_H
#include <QMutex>
#include <QRunnable>
#include "profiles.h"
#include "machine.h"
#include "zlib.h"
class MachineLoader;
class ImportTask:public QRunnable
{
public:
explicit ImportTask() {}
virtual ~ImportTask() {}
virtual void run() {}
};
/*! \class MachineLoader
\brief Base class to derive a new Machine importer from
*/
class MachineLoader
class MachineLoader: public QObject
{
Q_OBJECT
friend class ImportThread;
public:
MachineLoader();
virtual ~MachineLoader();
//virtual Machine * CreateMachine() {};
//! \brief Detect if the given path contains a valid folder structure
virtual bool Detect(const QString & path) = 0;
@ -39,41 +54,33 @@ class MachineLoader
//! \brief Override to returns the class name of this MachineLoader
virtual const QString &ClassName() = 0;
inline MachineType type() { return m_type; }
bool compressFile(QString inpath, QString outpath = "");
/*
MachineLoader(Profile *profile,QString & classname);
virtual void LoadMachineList();
virtual void SaveMachineList();
virtual bool LoadSummaries();
virtual bool LoadEvents();
virtual bool LoadWaveforms();
virtual bool Scan(QString &)=0; // Scans for new content
virtual bool LoadAll();
virtual bool SaveAll();
virtual bool LoadSummary(Machine * m, QString & filename);
virtual bool LoadEvent(Machine * m, QString & filename);
virtual bool LoadWaveform(Machine * m, QString & filename);
virtual bool SaveSummary(Machine * m, QString & filename);
virtual bool SaveEvent(Machine * m, QString & filename);
virtual bool SaveWaveform(Machine * m, QString & filename);*/
void queTask(ImportTask * task);
//! \brief Process Task list using all available threads.
void runTasks();
protected:
//! \brief Contains a list of Machine records known by this loader
QList<Machine *> m_machlist;
QString m_class;
MachineType m_type;
QString m_class;
Profile *m_profile;
int m_currenttask;
int m_totaltasks;
private:
QList<ImportTask *> m_tasklist;
};
// Put in machine loader class as static??
void RegisterLoader(MachineLoader *loader);
void DestroyLoaders();
QList<MachineLoader *> GetLoaders();
bool compressFile(QString inpath, QString outpath = "");
QList<MachineLoader *> GetLoaders(MachineType mt = MT_UNKNOWN);
#endif //MACHINE_LOADER_H

9
sleepyhead/SleepLib/session.cpp
View File

@ -69,12 +69,18 @@ void Session::TrashEvents()
for (i = eventlist.begin(); i != i_end; ++i) {
j_end=i.value().end();
for (j = i.value().begin(); j != j_end; ++j) {
delete *j;
EventList * ev = *j;
ev->clear();
ev->m_data.squeeze();
ev->m_data2.squeeze();
ev->m_time.squeeze();
delete ev;
}
}
s_events_loaded = false;
eventlist.clear();
eventlist.squeeze();
}
//const int max_pack_size=128;
@ -150,7 +156,6 @@ bool Session::Store(QString path)
s_changed = false;
s_events_loaded = true;
//TrashEvents();
//} else {
// qDebug() << "Session::Store() No event data saved" << s_session;
//}