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

Some profiling & optimisations. Implemented Session Events Compression, Backup edf File compression for ResMed, preference changed around a bit, and new options for the compression and backup stuff. And more efficient Weighted Percentile calculations

Browse Source
This commit is contained in:
Mark Watkins 2012-01-05 14:37:22 +10:00
parent 88fbc9d746
commit 3e7684efac
27 changed files with 1457 additions and 1010 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Graphs/gSummaryChart.cpp
View File

@ -427,6 +427,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
if (!m_hours.contains(zd)) if (!m_hours.contains(zd))
goto jumpnext; goto jumpnext;
//continue; //continue;
hours=m_hours[zd]; hours=m_hours[zd];
int x1=px; int x1=px;
@ -473,12 +474,13 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
outlines->add(x1,py,x2,py,x2,py,x2,py-h); outlines->add(x1,py,x2,py,x2,py,x2,py-h);
} // if (bar } // if (bar
//py-=h; //py-=h;
totalvalues[0]+=tmp; totalvalues[0]+=hours*tmp;
} }
totalcounts[0]++; totalcounts[0]+=hours;
totalvalues[1]+=j; totalvalues[1]+=j;
totalcounts[1]++; totalcounts[1]++;
total_val+=hours; total_val+=hours;
total_hours+=hours;
total_days++; total_days++;
} else { } else {
if (!d.value().contains(0)) goto jumpnext; if (!d.value().contains(0)) goto jumpnext;

1
SleepLib/calcs.cpp
View File

@ -409,7 +409,6 @@ int calcAHIGraph(Session *session)
const qint64 window_size=3600000L; const qint64 window_size=3600000L;
const qint64 window_step=30000; // 30 second windows const qint64 window_step=30000; // 30 second windows
if (session->machine()->GetType()!=MT_CPAP) return 0; if (session->machine()->GetType()!=MT_CPAP) return 0;
if (session->eventlist.contains(CPAP_AHI)) return 0; // abort if already there if (session->eventlist.contains(CPAP_AHI)) return 0; // abort if already there

5
SleepLib/common.cpp
View File

@ -36,3 +36,8 @@ QString weightString(float kg, UnitSystem us)
} }
return("Bad UnitSystem"); return("Bad UnitSystem");
} }
bool operator <(const ValueCount & a, const ValueCount & b)
{
return a.value < b.value;
}

19
SleepLib/common.h
View File

@ -6,11 +6,29 @@
enum UnitSystem { US_Undefined, US_Metric, US_Archiac }; enum UnitSystem { US_Undefined, US_Metric, US_Archiac };
typedef float EventDataType;
struct ValueCount {
ValueCount() { value=0; count=0; p=0; }
ValueCount(const ValueCount & copy) {
value=copy.value;
count=copy.count;
p=copy.p;
}
EventDataType value;
int count;
double p;
};
// Primarily sort by value
bool operator <(const ValueCount & a, const ValueCount & b);
const float ounce_convert=28.3495231; // grams const float ounce_convert=28.3495231; // grams
const float pound_convert=ounce_convert*16; const float pound_convert=ounce_convert*16;
QString weightString(float kg, UnitSystem us=US_Undefined); QString weightString(float kg, UnitSystem us=US_Undefined);
const QString STR_UNIT_CM=QObject::tr("cm"); const QString STR_UNIT_CM=QObject::tr("cm");
const QString STR_UNIT_INCH=QObject::tr("\""); const QString STR_UNIT_INCH=QObject::tr("\"");
const QString STR_UNIT_FOOT=QObject::tr("ft"); const QString STR_UNIT_FOOT=QObject::tr("ft");
@ -40,6 +58,7 @@ const QString STR_PROP_SubModel="SubModel";
const QString STR_PROP_Serial="Serial"; const QString STR_PROP_Serial="Serial";
const QString STR_PROP_DataVersion="DataVersion"; const QString STR_PROP_DataVersion="DataVersion";
const QString STR_PROP_Path="Path"; const QString STR_PROP_Path="Path";
const QString STR_PROP_BackupPath="BackupPath";
const QString STR_PROP_LastImported="LastImported"; const QString STR_PROP_LastImported="LastImported";
const QString STR_MACH_ResMed="ResMed"; const QString STR_MACH_ResMed="ResMed";

119
SleepLib/day.cpp
View File

@ -6,6 +6,7 @@
#include "day.h" #include "day.h"
#include "profiles.h" #include "profiles.h"
#include <cmath>
#include <algorithm> #include <algorithm>
Day::Day(Machine *m) Day::Day(Machine *m)
@ -149,60 +150,110 @@ EventDataType Day::settings_wavg(ChannelID code)
} }
EventDataType Day::percentile(ChannelID code,EventDataType percentile) EventDataType Day::percentile(ChannelID code,EventDataType percentile)
{ {
// Cache this calculation // QHash<ChannelID, QHash<EventDataType, EventDataType> >::iterator pi;
//if (percentile>=1) return 0; // probably better to crash and burn. // pi=perc_cache.find(code);
// if (pi!=perc_cache.end()) {
// QHash<EventDataType, EventDataType> & hsh=pi.value();
// QHash<EventDataType, EventDataType>::iterator hi=hsh.find(
// if (hi!=pi.value().end()) {
// return hi.value();
// }
// }
// Cache this calculation?
QVector<Session *>::iterator s; QVector<Session *>::iterator s;
// Don't assume sessions are in order. QMap<EventDataType, int> wmap;
QVector<EventDataType> ar;
int SN=0;
// First Calculate count of all events
for (s=sessions.begin();s!=sessions.end();s++) { for (s=sessions.begin();s!=sessions.end();s++) {
if (!(*s)->enabled()) continue; if (!(*s)->enabled()) continue;
Session & sess=*(*s); Session & sess=*(*s);
QHash<ChannelID,QHash<EventStoreType, EventStoreType> > ::iterator ei=sess.m_valuesummary.find(code); QHash<ChannelID,QHash<EventStoreType, EventStoreType> > ::iterator ei=sess.m_valuesummary.find(code);
if (ei==sess.m_valuesummary.end()) continue; if (ei==sess.m_valuesummary.end()) continue;
EventDataType gain=sess.m_gain[code]; EventDataType gain=sess.m_gain[code];
EventDataType weight,value;
for (QHash<EventStoreType, EventStoreType>::iterator i=ei.value().begin();i!=ei.value().end();i++) { for (QHash<EventStoreType, EventStoreType>::iterator i=ei.value().begin();i!=ei.value().end();i++) {
for (int j=0;j<i.value();j++) { weight=i.value();
ar.push_back(float(i.key())*gain); value=EventDataType(i.key())*gain;
SN+=weight;
if (wmap.contains(value)) {
wmap[value]+=weight;
} else {
wmap[value]=weight;
} }
} }
} }
int size=ar.size();
if (!size)
return 0;
size--;
QVector<EventDataType>::iterator first=ar.begin(); QVector<ValueCount> valcnt;
QVector<EventDataType>::iterator last=ar.end();
QVector<EventDataType>::iterator middle = first + int((last-first) * percentile);
std::nth_element(first,middle,last);
EventDataType val=*middle;
// qSort(ar); // Build sorted list of value/counts
// int p=EventDataType(size)*percentile; for (QMap<EventDataType, int>::iterator n=wmap.begin();n!=wmap.end();n++) {
// float p2=EventDataType(size)*percentile; ValueCount vc;
// float diff=p2-p; vc.value=n.key();
// EventDataType val=ar[p]; vc.count=n.value();
// if (diff>0) { vc.p=0;
// int s=p+1; valcnt.push_back(vc);
// if (s>size-1) s=size-1; }
// EventDataType v2=ar[s]; // sort by weight, then value
// EventDataType v3=v2-val; qSort(valcnt);
// if (v3>0) {
// val+=v3*diff; //double SN=100.0/double(N); // 100% / overall sum
// } double p=100.0*percentile;
double nth=double(SN)*percentile; // index of the position in the unweighted set would be
double nthi=floor(nth);
int sum1=0,sum2=0;
int w1,w2=0;
EventDataType v1,v2;
int N=valcnt.size();
int k=0;
for (k=0;k < N;k++) {
v1=valcnt[k].value;
w1=valcnt[k].count;
sum1+=w1;
if (sum1 > nthi) {
return v1;
}
if (sum1 == nthi){
break; // boundary condition
}
}
if (k>=N)
return v1;
v2=valcnt[k+1].value;
w2=valcnt[k+1].count;
sum2=sum1+w2;
// value lies between v1 and v2
double px=100.0/double(SN); // Percentile represented by one full value
// calculate percentile ranks
double p1=px * (double(sum1)-(double(w1)/2.0));
double p2=px * (double(sum2)-(double(w2)/2.0));
// calculate linear interpolation
double v=v1 + ((p-p1)/(p2-p1)) * (v2-v1);
return v;
// p1.....p.............p2
// 37 55 70
// }
return val;
} }
EventDataType Day::p90(ChannelID code) EventDataType Day::p90(ChannelID code)

1
SleepLib/day.h
View File

@ -155,6 +155,7 @@ public:
protected: protected:
//! \brief A Vector containing all sessions for this day //! \brief A Vector containing all sessions for this day
QVector<Session *> sessions; QVector<Session *> sessions;
QHash<ChannelID, QHash<EventDataType, EventDataType> > perc_cache;
qint64 d_first,d_last; qint64 d_first,d_last;
private: private:
bool d_firstsession; bool d_firstsession;

78
SleepLib/event.cpp
View File

@ -22,6 +22,8 @@ EventList::EventList(EventListType et,EventDataType gain, EventDataType offset,
m_update_minmax=false; m_update_minmax=false;
} }
m_data.reserve(2048);
// Reserve a few to increase performace?? // Reserve a few to increase performace??
} }
EventList::~EventList() EventList::~EventList()
@ -112,17 +114,33 @@ void EventList::AddWaveform(qint64 start, qint16 * data, int recs, qint64 durati
//double rate=duration/recs; //double rate=duration/recs;
//realloc buffers. //realloc buffers.
int r=m_count;
m_count+=recs; m_count+=recs;
m_data.reserve(m_count); m_data.resize(m_count);
EventStoreType *edata=m_data.data();
EventStoreType raw;
EventDataType val; EventDataType val;
for (int i=0;i<recs;i++) { qint16 * sp=data;
val=EventDataType(data[i])*m_gain+m_offset; EventStoreType * dp=&edata[r];
if (m_update_minmax) { if (m_update_minmax) {
for (int i=0;i<recs;i++) {
raw=*sp++;
val=EventDataType(raw)*m_gain+m_offset;
if (m_min>val) m_min=val; if (m_min>val) m_min=val;
if (m_max<val) m_max=val; if (m_max<val) m_max=val;
*dp=raw;
dp++;
}
} else {
for (int i=0;i<recs;i++) {
raw=*(sp++);
val=EventDataType(raw)*m_gain+m_offset;
*dp=raw;
dp++;
} }
m_data.push_back(data[i]);
} }
} }
@ -155,17 +173,33 @@ void EventList::AddWaveform(qint64 start, unsigned char * data, int recs, qint64
// TODO: Check waveform chunk really is contiguos // TODO: Check waveform chunk really is contiguos
//realloc buffers. //realloc buffers.
int r=m_count;
m_count+=recs; m_count+=recs;
m_data.reserve(m_count); m_data.resize(m_count);
EventStoreType *edata=m_data.data();
EventStoreType raw;
EventDataType val; EventDataType val;
for (int i=0;i<recs;i++) {
val=EventDataType(data[i])*m_gain+m_offset; unsigned char * sp=data;
EventStoreType * dp=&edata[r];
if (m_update_minmax) { if (m_update_minmax) {
for (int i=0;i<recs;i++) {
raw=*sp++;
val=EventDataType(val)*m_gain+m_offset;
if (m_min>val) m_min=val; if (m_min>val) m_min=val;
if (m_max<val) m_max=val; if (m_max<val) m_max=val;
*dp=raw;
dp++;
}
} else {
for (int i=0;i<recs;i++) {
raw=*sp++;
val=EventDataType(val)*m_gain+m_offset;
*dp=raw;
dp++;
} }
m_data.push_back(data[i]);
} }
} }
@ -199,17 +233,33 @@ void EventList::AddWaveform(qint64 start, char * data, int recs, qint64 duration
// TODO: Check waveform chunk really is contiguos // TODO: Check waveform chunk really is contiguos
//realloc buffers. //realloc buffers.
m_count+=recs;
m_data.reserve(m_count);
int r=m_count;
m_count+=recs;
m_data.resize(m_count);
EventStoreType *edata=m_data.data();
EventStoreType raw;
EventDataType val; EventDataType val;
for (int i=0;i<recs;i++) {
val=EventDataType(data[i])*m_gain+m_offset; char * sp=data;
EventStoreType * dp=&edata[r];
if (m_update_minmax) { if (m_update_minmax) {
for (int i=0;i<recs;i++) {
raw=*sp++;
val=EventDataType(val)*m_gain+m_offset;
if (m_min>val) m_min=val; if (m_min>val) m_min=val;
if (m_max<val) m_max=val; if (m_max<val) m_max=val;
*dp=raw;
dp++;
}
} else {
for (int i=0;i<recs;i++) {
raw=*sp++;
val=EventDataType(val)*m_gain+m_offset;
*dp=raw;
dp++;
} }
m_data.push_back(data[i]);
} }
} }

8
SleepLib/event.h
View File

@ -138,6 +138,14 @@ public:
//! \brief Returns the time storage vector (only used in EVL_Event types) //! \brief Returns the time storage vector (only used in EVL_Event types)
QVector<quint32> & getTime() { return m_time; } QVector<quint32> & getTime() { return m_time; }
// Don't mess with these without considering the consequences
void rawDataResize(quint32 i) { m_data.resize(i); m_count=i; }
void rawData2Resize(quint32 i) { m_data2.resize(i); m_count=i; }
void rawTimeResize(quint32 i) { m_time.resize(i); m_count=i; }
EventStoreType * rawData() { return m_data.data(); }
EventStoreType * rawData2() { return m_data2.data(); }
quint32 * rawTime() { return m_time.data(); }
protected: protected:
//! \brief The time storage vector, in 32bits delta format, added as offsets to m_first //! \brief The time storage vector, in 32bits delta format, added as offsets to m_first

8
SleepLib/loader_plugins/cms50_loader.cpp
View File

@ -324,11 +324,11 @@ Machine *CMS50Loader::CreateMachine(Profile *profile)
m->SetClass(cms50_class_name); m->SetClass(cms50_class_name);
m->properties[STR_PROP_Brand]="Contec"; m->properties[STR_PROP_Brand]="Contec";
m->properties[STR_PROP_Model]="CMS50X"; m->properties[STR_PROP_Model]="CMS50X";
QString a; m->properties[STR_PROP_DataVersion]=QString::number(cms50_data_version);
a.sprintf("%i",cms50_data_version);
m->properties[STR_PROP_DataVersion]=a;
profile->AddMachine(m); profile->AddMachine(m);
m->properties[STR_PROP_Path]="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/"; QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/";
m->properties[STR_PROP_Path]=path;
return m; return m;
} }

6
SleepLib/loader_plugins/intellipap_loader.cpp
View File

@ -399,7 +399,11 @@ Machine *IntellipapLoader::CreateMachine(QString serial,Profile *profile)
profile->AddMachine(m); profile->AddMachine(m);
m->properties[STR_PROP_Serial]=serial; m->properties[STR_PROP_Serial]=serial;
m->properties[STR_PROP_Path]="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/"; m->properties[STR_PROP_DataVersion]=QString::number(intellipap_data_version);
QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
m->properties[STR_PROP_Path]=path;
m->properties[STR_PROP_BackupPath]=path+"Backup/";
return m; return m;
} }

8
SleepLib/loader_plugins/prs1_loader.cpp
View File

@ -152,7 +152,11 @@ Machine *PRS1Loader::CreateMachine(QString serial,Profile *profile)
profile->AddMachine(m); profile->AddMachine(m);
m->properties[STR_PROP_Serial]=serial; m->properties[STR_PROP_Serial]=serial;
m->properties[STR_PROP_Path]="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";; m->properties[STR_PROP_DataVersion]=QString::number(prs1_data_version);
QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
m->properties[STR_PROP_Path]=path;
m->properties[STR_PROP_BackupPath]=path+"Backup/";
return m; return m;
} }
@ -419,7 +423,7 @@ int PRS1Loader::OpenMachine(Machine *m,QString path,Profile *profile)
} }
m->properties[STR_PROP_DataVersion]=QString().sprintf("%i",prs1_data_version); m->properties[STR_PROP_DataVersion]=QString::number(prs1_data_version);
m->properties[STR_PROP_LastImported]=QDateTime::currentDateTime().toString(Qt::ISODate); m->properties[STR_PROP_LastImported]=QDateTime::currentDateTime().toString(Qt::ISODate);
m->Save(); // Save any new sessions to disk in our format m->Save(); // Save any new sessions to disk in our format
if (qprogress) qprogress->setValue(100); if (qprogress) qprogress->setValue(100);

220
SleepLib/loader_plugins/resmed_loader.cpp
View File

@ -198,21 +198,45 @@ bool EDFParser::Parse()
} }
bool EDFParser::Open(QString name) bool EDFParser::Open(QString name)
{ {
//Urk.. This needs fixing for VC++, as it doesn't have packed attribute type..
if (name.endsWith(".gz")) {
filename=name.mid(0,-3);
QFile fi(name);
fi.open(QFile::ReadOnly);
fi.seek(fi.size()-4);
unsigned char ch[4];
fi.read((char *)ch,4);
filesize=ch[0] | (ch [1] << 8) | (ch[2] << 16) | (ch[3] << 24);
datasize=filesize-EDFHeaderSize;
if (datasize<0) return false;
qDebug() << "Size of" << name << "uncompressed=" << filesize;
gzFile f=gzopen(name.toAscii(),"rb");
if (!f) {
qDebug() << "EDFParser::Open() Couldn't open file" << name;
return false;
}
gzread(f,(char *)&header,EDFHeaderSize);
buffer=new char [datasize];
gzbuffer(f,65536*2);
gzread(f,buffer,datasize);
gzclose(f);
} else {
QFile f(name); QFile f(name);
if (!f.open(QIODevice::ReadOnly)) return false; if (!f.open(QIODevice::ReadOnly))
if (!f.isReadable()) return false; return false;
filename=name; filename=name;
filesize=f.size(); filesize=f.size();
datasize=filesize-EDFHeaderSize; datasize=filesize-EDFHeaderSize;
if (datasize<0) return false; if (datasize<0) return false;
//Urk.. This needs fixing for VC++, as it doesn't have packed attribute type..
f.read((char *)&header,EDFHeaderSize); f.read((char *)&header,EDFHeaderSize);
//qDebug() << "Opening " << name; //qDebug() << "Opening " << name;
buffer=new char [datasize]; buffer=new char [datasize];
f.read(buffer,datasize); f.read(buffer,datasize);
f.close(); f.close();
}
pos=0; pos=0;
return true; return true;
} }
@ -248,10 +272,11 @@ Machine *ResmedLoader::CreateMachine(QString serial,Profile *profile)
m->properties[STR_PROP_Serial]=serial; m->properties[STR_PROP_Serial]=serial;
m->properties[STR_PROP_Brand]=STR_MACH_ResMed; m->properties[STR_PROP_Brand]=STR_MACH_ResMed;
QString a; m->properties[STR_PROP_DataVersion]=QString::number(resmed_data_version);
a.sprintf("%i",resmed_data_version);
m->properties[STR_PROP_DataVersion]=a; QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
m->properties[STR_PROP_Path]="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/"; m->properties[STR_PROP_Path]=path;
m->properties[STR_PROP_BackupPath]=path+"Backup/";
return m; return m;
@ -268,6 +293,7 @@ int ResmedLoader::Open(QString & path,Profile *profile)
const QString ext_TGT="tgt"; const QString ext_TGT="tgt";
const QString ext_CRC="crc"; const QString ext_CRC="crc";
const QString ext_EDF="edf"; const QString ext_EDF="edf";
const QString ext_gz=".gz";
QString serial; // Serial number QString serial; // Serial number
QString key,value; QString key,value;
@ -330,16 +356,31 @@ int ResmedLoader::Open(QString & path,Profile *profile)
// Early check for STR.edf file, so we can early exit before creating faulty machine record. // Early check for STR.edf file, so we can early exit before creating faulty machine record.
QString strpath=path+strfile+ext_EDF; // STR.edf file QString strpath=path+strfile+ext_EDF; // STR.edf file
f.setFileName(strpath); f.setFileName(strpath);
if (!f.exists()) { // No STR.edf.. Do we have a STR.edf.gz?
strpath+=ext_gz;
f.setFileName(strpath);
if (!f.exists()) { if (!f.exists()) {
qDebug() << "Missing STR.edf file"; qDebug() << "Missing STR.edf file";
return 0; return 0;
} }
}
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Create machine object (unless it's already registered) // Create machine object (unless it's already registered)
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
Machine *m=CreateMachine(serial,profile); Machine *m=CreateMachine(serial,profile);
bool create_backups=PROFILE.session->backupCardData();
bool compress_backups=PROFILE.session->compressBackupData();
QString backup_path=PROFILE.Get(m->properties[STR_PROP_BackupPath]);
if (backup_path.isEmpty())
backup_path=PROFILE.Get(m->properties[STR_PROP_Path])+"Backup/";
if (path==backup_path) {
create_backups=false;
}
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Parse the idmap into machine objects properties, (overwriting any old values) // Parse the idmap into machine objects properties, (overwriting any old values)
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
@ -369,10 +410,12 @@ int ResmedLoader::Open(QString & path,Profile *profile)
// Creating early as we need the object // Creating early as we need the object
QDir dir(newpath); QDir dir(newpath);
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Create the backup folder for storing a copy of everything in.. // Create the backup folder for storing a copy of everything in..
// (Unless we are importing from this backup folder)
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
QString backup_path=PROFILE.Get(m->properties[STR_PROP_Path])+"Backup/"; if (create_backups) {
if (!dir.exists(backup_path)) { if (!dir.exists(backup_path)) {
if (!dir.mkpath(backup_path+datalog)) { if (!dir.mkpath(backup_path+datalog)) {
qDebug() << "Could not create S9 backup directory :-/"; qDebug() << "Could not create S9 backup directory :-/";
@ -383,9 +426,19 @@ int ResmedLoader::Open(QString & path,Profile *profile)
QFile::copy(path+idfile+ext_TGT,backup_path+idfile+ext_TGT); QFile::copy(path+idfile+ext_TGT,backup_path+idfile+ext_TGT);
QFile::copy(path+idfile+ext_CRC,backup_path+idfile+ext_CRC); QFile::copy(path+idfile+ext_CRC,backup_path+idfile+ext_CRC);
// Copy STR files to backup folder
//copy STR files to backup folder
if (strpath.endsWith(ext_gz)) // Already compressed.
QFile::copy(strpath,backup_path+strfile+ext_EDF+ext_gz);
else { // Compress STR file to backup folder
compress_backups ?
compressFile(strpath,backup_path+strfile+ext_EDF)
:
QFile::copy(strpath,backup_path+strfile+ext_EDF); QFile::copy(strpath,backup_path+strfile+ext_EDF);
QFile::copy(path+strfile+ext_CRC,backup_path+strfile+ext_CRC); }
QFile::copy(path+"STR.crc",backup_path+"STR.crc");
}
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Process the actual STR.edf data // Process the actual STR.edf data
@ -475,14 +528,14 @@ int ResmedLoader::Open(QString & path,Profile *profile)
dir.setSorting(QDir::Name); dir.setSorting(QDir::Name);
QFileInfoList flist=dir.entryInfoList(); QFileInfoList flist=dir.entryInfoList();
QString ext,rest,datestr;//,s,codestr; QString datestr;
SessionID sessionid; SessionID sessionid;
QDateTime date; QDateTime date;
int size=flist.size(); int size=flist.size();
sessfiles.clear(); sessfiles.clear();
// For each file in filelist... // For each file in flist...
for (int i=0;i<size;i++) { for (int i=0;i<size;i++) {
QFileInfo fi=flist.at(i); QFileInfo fi=flist.at(i);
filename=fi.fileName(); filename=fi.fileName();
@ -491,24 +544,28 @@ int ResmedLoader::Open(QString & path,Profile *profile)
if (!fi.isReadable()) if (!fi.isReadable())
continue; continue;
// Check the file extnsion // Accept only .edf and .edf.gz files
ext=filename.section(".",1).toLower(); if (!((filename.right(4).toLower() == "."+ext_EDF)
if (ext!=ext_EDF) continue; || (filename.right(7).toLower() == "."+ext_EDF+ext_gz)))
continue;
// Split the filename into components // Extract the session date out of the filename
rest=filename.section(".",0,0);
datestr=filename.section("_",0,1); datestr=filename.section("_",0,1);
// Take the filename's date, and convert it to epoch to form the sessionID. // Take the filename's date, and
date=QDateTime::fromString(datestr,"yyyyMMdd_HHmmss"); date=QDateTime::fromString(datestr,"yyyyMMdd_HHmmss");
if (!date.isValid())
continue; // Skip file if dates invalid
// Skip file if dates invalid, the filename is clearly wrong..
if (!date.isValid())
continue;
// convert this date to UNIX epoch to form the sessionID
sessionid=date.toTime_t(); sessionid=date.toTime_t();
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
// Resmed bugs up on the session filenames.. 1 or 2 seconds either way // Resmed bugs up on the session filenames.. 1 or 2 seconds either way
// Moral of the story, when writing firmware and saving in batches, use the same datetimes. // Moral of the story, when writing firmware and saving in batches, use the same datetimes,
// and provide firmware updates for free to your customers.
//////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////
if (sessfiles.find(sessionid)==sessfiles.end()) { if (sessfiles.find(sessionid)==sessfiles.end()) {
if (sessfiles.find(sessionid+2)!=sessfiles.end()) sessionid+=2; if (sessfiles.find(sessionid+2)!=sessfiles.end()) sessionid+=2;
@ -517,8 +574,8 @@ int ResmedLoader::Open(QString & path,Profile *profile)
else if (sessfiles.find(sessionid-2)!=sessfiles.end()) sessionid-=2; else if (sessfiles.find(sessionid-2)!=sessfiles.end()) sessionid-=2;
} }
// Push current filename to sanitized by-session list // Push current filename to ordered-by-sessionid list
sessfiles[sessionid].push_back(rest); sessfiles[sessionid].push_back(filename);
// Update the progress bar // Update the progress bar
if (qprogress) qprogress->setValue((float(i+1)/float(size)*10.0)); if (qprogress) qprogress->setValue((float(i+1)/float(size)*10.0));
@ -536,6 +593,7 @@ int ResmedLoader::Open(QString & path,Profile *profile)
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Scan over file list and knock out of dayused list // Scan over file list and knock out of dayused list
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
int dn;
for (QMap<SessionID,QVector<QString> >::iterator si=sessfiles.begin();si!=sessfiles.end();si++) { for (QMap<SessionID,QVector<QString> >::iterator si=sessfiles.begin();si!=sessfiles.end();si++) {
sessionid=si.key(); sessionid=si.key();
@ -544,17 +602,18 @@ int ResmedLoader::Open(QString & path,Profile *profile)
if (edn<0) edn=0; if (edn<0) edn=0;
// Find real day number from str.edf mask on/off data. // Find real day number from str.edf mask on/off data.
int dn=-1; dn=-1;
for (int j=edn;j<strfirst.size();j++){ for (int j=edn;j<strfirst.size();j++){
time_t st=strfirst.at(j); st=strfirst.at(j);
time_t et=strlast.at(j);
if (sessionid>=st) { if (sessionid>=st) {
et=strlast.at(j);
if (sessionid<(et+300)) { if (sessionid<(et+300)) {
dn=j; dn=j;
break; break;
} }
} }
} }
// If found, mark day off so STR.edf summary data isn't used instead of the real thing.
if (dn>=0) { if (dn>=0) {
dayused[dn]=0; dayused[dn]=0;
} }
@ -565,16 +624,21 @@ int ResmedLoader::Open(QString & path,Profile *profile)
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// For all days not in session lists, (to get at days without data records) // For all days not in session lists, (to get at days without data records)
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
for (int dn=0;dn<days;dn++) { for (dn=0;dn<days;dn++) {
if (!dayused[dn]) continue; // Skip days with loadable data. // Skip days with loadable data.
if (!dayused[dn])
continue;
if (!daystarttimes.contains(dn)) continue; if (!daystarttimes.contains(dn))
int j; continue;
int scnt=daystarttimes[dn].size();
sess=NULL; sess=NULL;
// For each mask on/off segment.
for (j=0;j<scnt;j++) { int scnt=daystarttimes[dn].size(); // count of sessions for this day
// Create a new session for each mask on/off segment in a day
// But only populate the last one with summary data.
for (int j=0;j<scnt;j++) {
st=daystarttimes[dn].at(j); st=daystarttimes[dn].at(j);
// Skip if session already exists // Skip if session already exists
@ -583,13 +647,12 @@ int ResmedLoader::Open(QString & path,Profile *profile)
et=dayendtimes[dn].at(j); et=dayendtimes[dn].at(j);
// Create session // Create the session
sess=new Session(m,st); sess=new Session(m,st);
sess->really_set_first(qint64(st)*1000L); sess->really_set_first(qint64(st)*1000L);
sess->really_set_last(qint64(et)*1000L); sess->really_set_last(qint64(et)*1000L);
sess->SetChanged(true); sess->SetChanged(true);
m->AddSession(sess,profile); m->AddSession(sess,profile);
} }
// Add the actual data to the last session // Add the actual data to the last session
EventDataType tmp,dur; EventDataType tmp,dur;
@ -693,12 +756,14 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->settings[CPAP_PressureMax]=pressure; sess->settings[CPAP_PressureMax]=pressure;
//sess->setMax(CPAP_Pressure,pressure); //sess->setMax(CPAP_Pressure,pressure);
} }
} }
} }
EventDataType valmed=0,valmax=0,val95=0; EventDataType valmed=0,valmax=0,val95=0;
/////////////////////////////////////////////////////////////////////
// Leak Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Leak Med"))) { if ((sig=stredf.lookupName("Leak Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_Leak]=sig->gain*60.0; sess->m_gain[CPAP_Leak]=sig->gain*60.0;
@ -714,6 +779,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->m_valuesummary[CPAP_Leak][valmax]=4; sess->m_valuesummary[CPAP_Leak][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Minute Ventilation Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Min Vent Med"))) { if ((sig=stredf.lookupName("Min Vent Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_MinuteVent]=sig->gain; sess->m_gain[CPAP_MinuteVent]=sig->gain;
@ -728,6 +796,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->setMax(CPAP_MinuteVent,valmax*sig->gain); sess->setMax(CPAP_MinuteVent,valmax*sig->gain);
sess->m_valuesummary[CPAP_MinuteVent][valmax]=4; sess->m_valuesummary[CPAP_MinuteVent][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Respiratory Rate Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("RR Med"))) { if ((sig=stredf.lookupName("RR Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_RespRate]=sig->gain; sess->m_gain[CPAP_RespRate]=sig->gain;
@ -743,6 +814,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->m_valuesummary[CPAP_RespRate][valmax]=4; sess->m_valuesummary[CPAP_RespRate][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Tidal Volume Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Tid Vol Med"))) { if ((sig=stredf.lookupName("Tid Vol Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_TidalVolume]=sig->gain*1000.0; sess->m_gain[CPAP_TidalVolume]=sig->gain*1000.0;
@ -758,6 +832,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->m_valuesummary[CPAP_TidalVolume][valmax]=4; sess->m_valuesummary[CPAP_TidalVolume][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Target Minute Ventilation Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Targ Vent Med"))) { if ((sig=stredf.lookupName("Targ Vent Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_TgMV]=sig->gain; sess->m_gain[CPAP_TgMV]=sig->gain;
@ -774,6 +851,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
} }
/////////////////////////////////////////////////////////////////////
// I:E Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("I:E Med"))) { if ((sig=stredf.lookupName("I:E Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_IE]=sig->gain; sess->m_gain[CPAP_IE]=sig->gain;
@ -789,6 +869,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->m_valuesummary[CPAP_IE][valmax]=4; sess->m_valuesummary[CPAP_IE][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Mask Pressure Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Mask Pres Med"))) { if ((sig=stredf.lookupName("Mask Pres Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_Pressure]=sig->gain; sess->m_gain[CPAP_Pressure]=sig->gain;
@ -804,6 +887,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->m_valuesummary[CPAP_Pressure][valmax]=4; sess->m_valuesummary[CPAP_Pressure][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Inspiratory Pressure (IPAP) Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Insp Pres Med"))) { if ((sig=stredf.lookupName("Insp Pres Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_IPAP]=sig->gain; sess->m_gain[CPAP_IPAP]=sig->gain;
@ -818,6 +904,9 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->setMax(CPAP_IPAP,valmax*sig->gain); sess->setMax(CPAP_IPAP,valmax*sig->gain);
sess->m_valuesummary[CPAP_IPAP][valmax]=4; sess->m_valuesummary[CPAP_IPAP][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Expiratory Pressure (EPAP) Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Exp Pres Med"))) { if ((sig=stredf.lookupName("Exp Pres Med"))) {
valmed=sig->data[dn]; valmed=sig->data[dn];
sess->m_gain[CPAP_EPAP]=sig->gain; sess->m_gain[CPAP_EPAP]=sig->gain;
@ -833,33 +922,39 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sess->m_valuesummary[CPAP_EPAP][valmax]=4; sess->m_valuesummary[CPAP_EPAP][valmax]=4;
} }
/////////////////////////////////////////////////////////////////////
// Duration and Event Indices
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Mask Dur"))) { if ((sig=stredf.lookupName("Mask Dur"))) {
dur=sig->data[dn]*sig->gain; dur=sig->data[dn]*sig->gain;
dur/=60.0f; // convert to hours.
} }
if ((sig=stredf.lookupName("OAI"))) { if ((sig=stredf.lookupName("OAI"))) { // Obstructive Apnea Index
tmp=sig->data[dn]*sig->gain; tmp=sig->data[dn]*sig->gain;
sess->setCph(CPAP_Obstructive,tmp); sess->setCph(CPAP_Obstructive,tmp);
sess->setCount(CPAP_Obstructive,tmp*(dur/60.0)); sess->setCount(CPAP_Obstructive,tmp*dur); // Converting from indice to counts..
} }
if ((sig=stredf.lookupName("HI"))) { if ((sig=stredf.lookupName("HI"))) { // Hypopnea Index
tmp=sig->data[dn]*sig->gain; tmp=sig->data[dn]*sig->gain;
sess->setCph(CPAP_Hypopnea,tmp); sess->setCph(CPAP_Hypopnea,tmp);
sess->setCount(CPAP_Hypopnea,tmp*(dur/60.0)); sess->setCount(CPAP_Hypopnea,tmp*dur);
} }
if ((sig=stredf.lookupName("UAI"))) { if ((sig=stredf.lookupName("UAI"))) { // Unspecified Apnea Index
tmp=sig->data[dn]*sig->gain; tmp=sig->data[dn]*sig->gain;
sess->setCph(CPAP_Apnea,tmp); sess->setCph(CPAP_Apnea,tmp);
sess->setCount(CPAP_Apnea,tmp*(dur/60.0)); sess->setCount(CPAP_Apnea,tmp*dur);
} }
if ((sig=stredf.lookupName("CAI"))) { if ((sig=stredf.lookupName("CAI"))) { // "Central" Apnea Index
tmp=sig->data[dn]*sig->gain; tmp=sig->data[dn]*sig->gain;
sess->setCph(CPAP_ClearAirway,tmp); sess->setCph(CPAP_ClearAirway,tmp);
sess->setCount(CPAP_ClearAirway,tmp*(dur/60.0)); sess->setCount(CPAP_ClearAirway,tmp*dur);
} }
} }
} }
bool gz;
backup_path+=datalog+"/";
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Scan through new file list and import sessions // Scan through new file list and import sessions
@ -873,18 +968,31 @@ int ResmedLoader::Open(QString & path,Profile *profile)
// Create the session // Create the session
sess=new Session(m,sessionid); sess=new Session(m,sessionid);
QString filename,fullpath,backupfile,backfile, crcfile;
// Process EDF File List // Process EDF File List
for (int i=0;i<si.value().size();++i) { for (int i=0;i<si.value().size();++i) {
QString filename=si.value()[i]+"."; filename=si.value()[i];
QString fullpath=newpath+filename; gz=(filename.right(3).toLower()==ext_gz);
fullpath=newpath+filename;
// Copy the EDF file to the backup folder // Copy the EDF file to the backup folder
QString backup_file=backup_path+datalog+"/"+filename; if (create_backups) {
QFile().copy(fullpath+ext_EDF, backup_file+ext_EDF); backupfile=backup_path+filename;
QFile().copy(fullpath+ext_CRC, backup_file+ext_CRC); if (!gz) {
compress_backups ?
compressFile(fullpath, backupfile)
:
QFile::copy(fullpath, backupfile);
} else // already compressed, just copy it.
QFile::copy(fullpath, backupfile);
backfile=filename.replace(".edf",".crc",Qt::CaseInsensitive);
backupfile=backup_path+backfile;
crcfile=newpath+backfile;
QFile::copy(crcfile, backupfile);
}
fullpath+=ext_EDF;
EDFParser edf(fullpath); EDFParser edf(fullpath);
// Parse the actual file // Parse the actual file
@ -896,12 +1004,12 @@ int ResmedLoader::Open(QString & path,Profile *profile)
qDebug() << "edf Serial number doesn't match Identification.tgt"; qDebug() << "edf Serial number doesn't match Identification.tgt";
} }
fn=fullpath.section("_",-1).toLower(); fn=filename.section("_",-1).section(".",0,0).toLower();
if (fn=="eve.edf") LoadEVE(sess,edf); if (fn=="eve") LoadEVE(sess,edf);
else if (fn=="pld.edf") LoadPLD(sess,edf); else if (fn=="pld") LoadPLD(sess,edf);
else if (fn=="brp.edf") LoadBRP(sess,edf); else if (fn=="brp") LoadBRP(sess,edf);
else if (fn=="sad.edf") LoadSAD(sess,edf); else if (fn=="sad") LoadSAD(sess,edf);
} }
if (qprogress) qprogress->setValue(10.0+(float(++cnt)/float(size)*90.0)); if (qprogress) qprogress->setValue(10.0+(float(++cnt)/float(size)*90.0));
QApplication::processEvents(); QApplication::processEvents();

1
SleepLib/machine_common.h
View File

@ -28,6 +28,7 @@ class BoundsError {};
class OldDBVersion {}; class OldDBVersion {};
const quint32 magic=0xC73216AB; // Magic number for Sleepyhead Data Files.. Don't touch! const quint32 magic=0xC73216AB; // Magic number for Sleepyhead Data Files.. Don't touch!
const quint32 compmagic=0xC73216AC; // Magic number for Compressed Sleepyhead Data Files.. Don't touch!
//const int max_number_event_fields=10; //const int max_number_event_fields=10;
// This should probably move somewhere else // This should probably move somewhere else

39
SleepLib/machine_loader.cpp
View File

@ -44,6 +44,45 @@ MachineLoader::~MachineLoader()
delete *m; delete *m;
} }
} }
bool MachineLoader::compressFile(QString inpath, QString outpath)
{
if (outpath.isEmpty())
outpath=inpath+".gz";
else if (!outpath.endsWith(".gz")) {
outpath+=".gz";
}
QFile f(inpath);
if (!f.exists(inpath)) {
qDebug() << "compressFile()" << inpath << "does not exist";
return false;
}
qint64 size=f.size();
if (!f.open(QFile::ReadOnly)) {
qDebug() << "compressFile() Couldn't open" << inpath;
return false;
}
char * buf=new char [size];
if (!f.read(buf,size)) {
delete buf;
qDebug() << "compressFile() Couldn't read all of" << inpath;
return false;
}
f.close();
gzFile gz=gzopen(outpath.toAscii(),"wb");
gzbuffer(gz,65536*2);
if (!gz) {
qDebug() << "compressFile() Couldn't open" << outpath <<"for writing";
delete buf;
return false;
}
gzwrite(gz,buf,size);
gzclose(gz);
delete buf;
return true;
}
/*const QString machine_profile_name="MachineList.xml"; /*const QString machine_profile_name="MachineList.xml";
void MachineLoader::LoadMachineList() void MachineLoader::LoadMachineList()

3
SleepLib/machine_loader.h
View File

@ -11,6 +11,7 @@ License: GPL
#define MACHINE_LOADER_H #define MACHINE_LOADER_H
#include "profiles.h" #include "profiles.h"
#include "machine.h" #include "machine.h"
#include "zlib.h"
/*! \class MachineLoader /*! \class MachineLoader
\brief Base class to derive a new Machine importer from \brief Base class to derive a new Machine importer from
@ -33,6 +34,8 @@ public:
//! \brief Override to returns the class name of this MachineLoader //! \brief Override to returns the class name of this MachineLoader
virtual const QString & ClassName()=0; virtual const QString & ClassName()=0;
bool compressFile(QString inpath, QString outpath="");
/* /*
MachineLoader(Profile *profile,QString & classname); MachineLoader(Profile *profile,QString & classname);

277
SleepLib/profiles.cpp
View File

@ -13,6 +13,7 @@ License: GPL
#include <QMessageBox> #include <QMessageBox>
#include <QDebug> #include <QDebug>
#include <algorithm> #include <algorithm>
#include <cmath>
#include "preferences.h" #include "preferences.h"
#include "profiles.h" #include "profiles.h"
@ -27,6 +28,8 @@ Preferences *p_pref;
Preferences *p_layout; Preferences *p_layout;
Profile * p_profile; Profile * p_profile;
Profile::Profile() Profile::Profile()
:Preferences(),is_first_day(true) :Preferences(),is_first_day(true)
{ {
@ -428,7 +431,7 @@ Profile *Create(QString name)
prof->user->setUserName(name); prof->user->setUserName(name);
//prof->Set("Realname",realname); //prof->Set("Realname",realname);
//if (!password.isEmpty()) prof.user->setPassword(password); //if (!password.isEmpty()) prof.user->setPassword(password);
prof->Set(STR_GEN_DataFolder,QString("{home}/Profiles/{")+QString(UI_STR_UserName)+QString("}")); prof->Set(STR_GEN_DataFolder,QString("{home}/Profiles/{")+QString(STR_UI_UserName)+QString("}"));
Machine *m=new Machine(prof,0); Machine *m=new Machine(prof,0);
m->SetClass("Journal"); m->SetClass("Journal");
@ -504,80 +507,6 @@ void Scan()
} // namespace Profiles } // namespace Profiles
// DoctorInfo Strings
const char * DI_STR_Name="DoctorName";
const char * DI_STR_Phone="DoctorPhone";
const char * DI_STR_Email="DoctorEmail";
const char * DI_STR_Practice="DoctorPractice";
const char * DI_STR_Address="DoctorAddress";
const char * DI_STR_PatientID="DoctorPatientID";
// UserInfo Strings
const char * UI_STR_DOB="DOB";
const char * UI_STR_FirstName="FirstName";
const char * UI_STR_LastName="LastName";
const char * UI_STR_UserName="UserName";
const char * UI_STR_Password="Password";
const char * UI_STR_Address="Address";
const char * UI_STR_Phone="Phone";
const char * UI_STR_EmailAddress="EmailAddress";
const char * UI_STR_Country="Country";
const char * UI_STR_Height="Height";
const char * UI_STR_Gender="Gender";
const char * UI_STR_TimeZone="TimeZone";
const char * UI_STR_Language="Language";
const char * UI_STR_DST="DST";
// OxiSettings Strings
const char * OS_STR_EnableOximetry="EnableOximetry";
const char * OS_STR_SyncOximetry="SyncOximetry";
const char * OS_STR_OximeterType="OximeterType";
const char * OS_STR_OxiDiscardThreshold="OxiDiscardThreshold";
const char * OS_STR_SPO2DropDuration="SPO2DropDuration";
const char * OS_STR_SPO2DropPercentage="SPO2DropPercentage";
const char * OS_STR_PulseChangeDuration="PulseChangeDuration";
const char * OS_STR_PulseChangeBPM="PulseChangeBPM";
// CPAPSettings Strings
const char * CS_STR_ComplianceHours="ComplianceHours";
const char * CS_STR_ShowCompliance="ShowCompliance";
const char * CS_STR_ShowLeaksMode="ShowLeaksMode";
const char * CS_STR_MaskStartDate="MaskStartDate";
const char * CS_STR_MaskDescription="MaskDescription";
const char * CS_STR_MaskType="MaskType";
const char * CS_STR_PrescribedMode="CPAPPrescribedMode";
const char * CS_STR_PrescribedMinPressure="CPAPPrescribedMinPressure";
const char * CS_STR_PrescribedMaxPressure="CPAPPrescribedMaxPressure";
const char * CS_STR_UntreatedAHI="UntreatedAHI";
const char * CS_STR_Notes="CPAPNotes";
const char * CS_STR_DateDiagnosed="DateDiagnosed";
// ImportSettings Strings
const char * IS_STR_DaySplitTime="DaySplitTime";
const char * IS_STR_CacheSessions="MemoryHog";
const char * IS_STR_CombineCloseSessions="CombineCloserSessions";
const char * IS_STR_IgnoreShorterSessions="IgnoreShorterSessions";
const char * IS_STR_Multithreading="EnableMultithreading";
const char * IS_STR_TrashDayCache="TrashDayCache";
const char * IS_STR_ShowSerialNumbers="ShowSerialNumbers";
// AppearanceSettings Strings
const char * AS_STR_GraphHeight="GraphHeight";
const char * AS_STR_AntiAliasing="UseAntiAliasing";
const char * AS_STR_GraphSnapshots="EnableGraphSnapshots";
const char * AS_STR_Animations="AnimationsAndTransitions";
const char * AS_STR_SquareWave="SquareWavePlots";
const char * AS_STR_OverlayType="OverlayType";
// UserSettings Strings
const char * US_STR_UnitSystem="UnitSystem";
const char * US_STR_EventWindowSize="EventWindowSize";
const char * US_STR_SkipEmptyDays="SkipEmptyDays";
const char * US_STR_RebuildCache="RebuildCache";
const char * US_STR_ShowDebug="ShowDebug";
const char * US_STR_LinkGroups="LinkGroups";
const char * US_STR_CalculateRDI="CalculateRDI";
int Profile::countDays(MachineType mt, QDate start, QDate end) int Profile::countDays(MachineType mt, QDate start, QDate end)
{ {
if (!start.isValid()) if (!start.isValid())
@ -778,17 +707,14 @@ EventDataType Profile::calcPercentile(ChannelID code, EventDataType percent, Mac
QDate date=start; QDate date=start;
// This is one messy function.. It requires all data to be loaded.. :( QMap<EventDataType, int> wmap;
QHash<EventStoreType,EventStoreType> summary;
QHash<EventStoreType,EventStoreType>::iterator sumi;
QVector<EventDataType> array;
QHash<ChannelID,QHash<EventStoreType, EventStoreType> >::iterator vsi; QHash<ChannelID,QHash<EventStoreType, EventStoreType> >::iterator vsi;
EventDataType val,gain; EventDataType val,gain;
bool setgain=false; bool setgain=false;
EventDataType weight,value;
//double val=0,tmp,hours=0; int SN=0;
do { do {
Day * day=GetGoodDay(date,mt); Day * day=GetGoodDay(date,mt);
if (day) { if (day) {
@ -800,81 +726,86 @@ EventDataType Profile::calcPercentile(ChannelID code, EventDataType percent, Mac
Session *sess=*s; Session *sess=*s;
gain=sess->m_gain[code]; gain=sess->m_gain[code];
if (!gain) gain=1; if (!gain) gain=1;
setgain=true;
vsi=sess->m_valuesummary.find(code); vsi=sess->m_valuesummary.find(code);
if (vsi==sess->m_valuesummary.end()) continue; if (vsi==sess->m_valuesummary.end()) continue;
QHash<EventStoreType, EventStoreType> & vsum=vsi.value(); QHash<EventStoreType, EventStoreType> & vsum=vsi.value();
for (QHash<EventStoreType, EventStoreType>::iterator k=vsum.begin();k!=vsum.end();k++) { for (QHash<EventStoreType, EventStoreType>::iterator k=vsum.begin();k!=vsum.end();k++) {
for (int z=0;z<k.value();z++) { weight=k.value();
val=k.key(); value=EventDataType(k.key())*gain;
val*=gain;
array.push_back(val); SN+=weight;
if (wmap.contains(value)) {
wmap[value]+=weight;
} else {
wmap[value]=weight;
} }
/*sumi=summary.find(k.key());
if (sumi==summary.end()) summary[k.key()]=k.value();
else {
sumi.value()+=k.value();
}*/
} }
/*QHash<ChannelID,QVector<EventList *> >::iterator el=(*s)->eventlist.find(code);
if (el==(*s)->eventlist.end()) continue;
for (int j=0;j<el.value().size();j++) {
EventList & e=*el.value()[j];
for (unsigned k=0;k<e.count();k++) {
array.push_back(e.data(k));
}
}*/
} }
} }
} }
date=date.addDays(1); date=date.addDays(1);
} while (date<=end); } while (date<=end);
// for (QHash<EventStoreType, EventStoreType>::iterator k=summary.begin();k!=summary.end();k++) { QVector<ValueCount> valcnt;
// for (int i=0;i<k.value();i++) {
// array.push_back(k.key());
// }
// }
/*if (array.size()==0) return 0; // Build sorted list of value/counts
qSort(array); for (QMap<EventDataType, int>::iterator n=wmap.begin();n!=wmap.end();n++) {
ValueCount vc;
vc.value=n.key();
vc.count=n.value();
vc.p=0;
valcnt.push_back(vc);
}
// sort by weight, then value
qSort(valcnt);
//double SN=100.0/double(N); // 100% / overall sum
double p=100.0*percent;
int idx=array.size()*percent; double nth=double(SN)*percent; // index of the position in the unweighted set would be
if (idx>array.size()-1) idx=array.size()-1; double nthi=floor(nth);
return array[idx]; */
QVector<EventDataType>::iterator first=array.begin(); int sum1=0,sum2=0;
QVector<EventDataType>::iterator last=array.end(); int w1,w2=0;
QVector<EventDataType>::iterator middle = first + int((last-first) * percent); EventDataType v1,v2;
std::nth_element(first,middle,last);
val=*middle;
return val; int N=valcnt.size();
// int size=array.size(); int k=0;
// if (!size)
// return 0;
// size--;
// qSort(array);
// int p=EventDataType(size)*percent;
// float p2=EventDataType(size)*percent;
// float diff=p2-p;
// val=array[p];
// if (diff>0) {
// int s=p+1;
// if (s>size-1) s=size-1;
// EventDataType v2=array[s];
// EventDataType v3=v2-val;
// if (v3>0) {
// val+=v3*diff;
// }
// } for (k=0;k < N;k++) {
v1=valcnt[k].value;
w1=valcnt[k].count;
sum1+=w1;
// return val; if (sum1 > nthi) {
return v1;
}
if (sum1 == nthi){
break; // boundary condition
}
}
if (k>=N)
return v1;
v2=valcnt[k+1].value;
w2=valcnt[k+1].count;
sum2=sum1+w2;
// value lies between v1 and v2
double px=100.0/double(SN); // Percentile represented by one full value
// calculate percentile ranks
double p1=px * (double(sum1)-(double(w1)/2.0));
double p2=px * (double(sum2)-(double(w2)/2.0));
// calculate linear interpolation
double v=v1 + ((p-p1)/(p2-p1)) * (v2-v1);
// p1.....p.............p2
// 37 55 70
return v;
} }
QDate Profile::FirstDay(MachineType mt) QDate Profile::FirstDay(MachineType mt)
@ -929,3 +860,81 @@ QDate Profile::LastGoodDay(MachineType mt)
} while (d>=f); } while (d>=f);
return f; //m_first; return f; //m_first;
} }
// DoctorInfo Strings
const char * STR_DI_Name="DoctorName";
const char * STR_DI_Phone="DoctorPhone";
const char * STR_DI_Email="DoctorEmail";
const char * STR_DI_Practice="DoctorPractice";
const char * STR_DI_Address="DoctorAddress";
const char * STR_DI_PatientID="DoctorPatientID";
// UserInfo Strings
const char * STR_UI_DOB="DOB";
const char * STR_UI_FirstName="FirstName";
const char * STR_UI_LastName="LastName";
const char * STR_UI_UserName="UserName";
const char * STR_UI_Password="Password";
const char * STR_UI_Address="Address";
const char * STR_UI_Phone="Phone";
const char * STR_UI_EmailAddress="EmailAddress";
const char * STR_UI_Country="Country";
const char * STR_UI_Height="Height";
const char * STR_UI_Gender="Gender";
const char * STR_UI_TimeZone="TimeZone";
const char * STR_UI_Language="Language";
const char * STR_UI_DST="DST";
// OxiSettings Strings
const char * STR_OS_EnableOximetry="EnableOximetry";
const char * STR_OS_SyncOximetry="SyncOximetry";
const char * STR_OS_OximeterType="OximeterType";
const char * STR_OS_OxiDiscardThreshold="OxiDiscardThreshold";
const char * STR_OS_SPO2DropDuration="SPO2DropDuration";
const char * STR_OS_SPO2DropPercentage="SPO2DropPercentage";
const char * STR_OS_PulseChangeDuration="PulseChangeDuration";
const char * STR_OS_PulseChangeBPM="PulseChangeBPM";
// CPAPSettings Strings
const char * STR_CS_ComplianceHours="ComplianceHours";
const char * STR_CS_ShowCompliance="ShowCompliance";
const char * STR_CS_ShowLeaksMode="ShowLeaksMode";
const char * STR_CS_MaskStartDate="MaskStartDate";
const char * STR_CS_MaskDescription="MaskDescription";
const char * STR_CS_MaskType="MaskType";
const char * STR_CS_PrescribedMode="CPAPPrescribedMode";
const char * STR_CS_PrescribedMinPressure="CPAPPrescribedMinPressure";
const char * STR_CS_PrescribedMaxPressure="CPAPPrescribedMaxPressure";
const char * STR_CS_UntreatedAHI="UntreatedAHI";
const char * STR_CS_Notes="CPAPNotes";
const char * STR_CS_DateDiagnosed="DateDiagnosed";
// ImportSettings Strings
const char * STR_IS_DaySplitTime="DaySplitTime";
const char * STR_IS_CacheSessions="MemoryHog";
const char * STR_IS_CombineCloseSessions="CombineCloserSessions";
const char * STR_IS_IgnoreShorterSessions="IgnoreShorterSessions";
const char * STR_IS_Multithreading="EnableMultithreading";
const char * STR_IS_BackupCardData="BackupCardData";
const char * STR_IS_CompressBackupData="CompressBackupData";
const char * STR_IS_CompressSessionData="CompressSessionData";
// AppearanceSettings Strings
const char * STR_AS_GraphHeight="GraphHeight";
const char * STR_AS_AntiAliasing="UseAntiAliasing";
const char * STR_AS_GraphSnapshots="EnableGraphSnapshots";
const char * STR_AS_Animations="AnimationsAndTransitions";
const char * STR_AS_SquareWave="SquareWavePlots";
const char * STR_AS_OverlayType="OverlayType";
// UserSettings Strings
const char * STR_US_UnitSystem="UnitSystem";
const char * STR_US_EventWindowSize="EventWindowSize";
const char * STR_US_SkipEmptyDays="SkipEmptyDays";
const char * STR_US_RebuildCache="RebuildCache";
const char * STR_US_ShowDebug="ShowDebug";
const char * STR_US_LinkGroups="LinkGroups";
const char * STR_US_CalculateRDI="CalculateRDI";
const char * STR_US_ShowSerialNumbers="ShowSerialNumbers";

492
SleepLib/profiles.h
View File

@ -151,59 +151,59 @@ extern Profile * p_profile;
#define LAYOUT (*p_layout) #define LAYOUT (*p_layout)
#define PROFILE (*p_profile) #define PROFILE (*p_profile)
extern const char * DI_STR_Name; extern const char * STR_DI_Name;
extern const char * DI_STR_Phone; extern const char * STR_DI_Phone;
extern const char * DI_STR_Email; extern const char * STR_DI_Email;
extern const char * DI_STR_Practice; extern const char * STR_DI_Practice;
extern const char * DI_STR_Address; extern const char * STR_DI_Address;
extern const char * DI_STR_PatientID; extern const char * STR_DI_PatientID;
class DoctorInfo class DoctorInfo
{ {
public: public:
DoctorInfo(Profile *p) : m_profile(p) DoctorInfo(Profile *p) : m_profile(p)
{ {
if (!m_profile->contains(DI_STR_Name)) (*m_profile)[DI_STR_Name]=QString(); if (!m_profile->contains(STR_DI_Name)) (*m_profile)[STR_DI_Name]=QString();
if (!m_profile->contains(DI_STR_Phone)) (*m_profile)[DI_STR_Phone]=QString(); if (!m_profile->contains(STR_DI_Phone)) (*m_profile)[STR_DI_Phone]=QString();
if (!m_profile->contains(DI_STR_Email)) (*m_profile)[DI_STR_Email]=QString(); if (!m_profile->contains(STR_DI_Email)) (*m_profile)[STR_DI_Email]=QString();
if (!m_profile->contains(DI_STR_Practice)) (*m_profile)[DI_STR_Practice]=QString(); if (!m_profile->contains(STR_DI_Practice)) (*m_profile)[STR_DI_Practice]=QString();
if (!m_profile->contains(DI_STR_Address)) (*m_profile)[DI_STR_Address]=QString(); if (!m_profile->contains(STR_DI_Address)) (*m_profile)[STR_DI_Address]=QString();
if (!m_profile->contains(DI_STR_PatientID)) (*m_profile)[DI_STR_PatientID]=QString(); if (!m_profile->contains(STR_DI_PatientID)) (*m_profile)[STR_DI_PatientID]=QString();
} }
~DoctorInfo() {} ~DoctorInfo() {}
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
const QString name() { return (*m_profile)[DI_STR_Name].toString(); } const QString name() { return (*m_profile)[STR_DI_Name].toString(); }
const QString phone() { return (*m_profile)[DI_STR_Phone].toString(); } const QString phone() { return (*m_profile)[STR_DI_Phone].toString(); }
const QString email() { return (*m_profile)[DI_STR_Email].toString(); } const QString email() { return (*m_profile)[STR_DI_Email].toString(); }
const QString practiceName() { return (*m_profile)[DI_STR_Practice].toString(); } const QString practiceName() { return (*m_profile)[STR_DI_Practice].toString(); }
const QString address() { return (*m_profile)[DI_STR_Address].toString(); } const QString address() { return (*m_profile)[STR_DI_Address].toString(); }
const QString patientID() { return (*m_profile)[DI_STR_PatientID].toString(); } const QString patientID() { return (*m_profile)[STR_DI_PatientID].toString(); }
void setName(QString name) { (*m_profile)[DI_STR_Name]=name; } void setName(QString name) { (*m_profile)[STR_DI_Name]=name; }
void setPhone(QString phone) { (*m_profile)[DI_STR_Phone]=phone; } void setPhone(QString phone) { (*m_profile)[STR_DI_Phone]=phone; }
void setEmail(QString phone) { (*m_profile)[DI_STR_Email]=phone; } void setEmail(QString phone) { (*m_profile)[STR_DI_Email]=phone; }
void setPracticeName(QString practice) { (*m_profile)[DI_STR_Practice]=practice; } void setPracticeName(QString practice) { (*m_profile)[STR_DI_Practice]=practice; }
void setAddress(QString address) { (*m_profile)[DI_STR_Address]=address; } void setAddress(QString address) { (*m_profile)[STR_DI_Address]=address; }
void setPatientID(QString pid) { (*m_profile)[DI_STR_PatientID]=pid; } void setPatientID(QString pid) { (*m_profile)[STR_DI_PatientID]=pid; }
Profile *m_profile; Profile *m_profile;
}; };
extern const char * UI_STR_DOB; extern const char * STR_UI_DOB;
extern const char * UI_STR_FirstName; extern const char * STR_UI_FirstName;
extern const char * UI_STR_LastName; extern const char * STR_UI_LastName;
extern const char * UI_STR_UserName; extern const char * STR_UI_UserName;
extern const char * UI_STR_Password; extern const char * STR_UI_Password;
extern const char * UI_STR_Address; extern const char * STR_UI_Address;
extern const char * UI_STR_Phone; extern const char * STR_UI_Phone;
extern const char * UI_STR_EmailAddress; extern const char * STR_UI_EmailAddress;
extern const char * UI_STR_Country; extern const char * STR_UI_Country;
extern const char * UI_STR_Height; extern const char * STR_UI_Height;
extern const char * UI_STR_Gender; extern const char * STR_UI_Gender;
extern const char * UI_STR_TimeZone; extern const char * STR_UI_TimeZone;
extern const char * UI_STR_Language; extern const char * STR_UI_Language;
extern const char * UI_STR_DST; extern const char * STR_UI_DST;
/*! \class UserInfo /*! \class UserInfo
\brief Profile Options relating to the User Information \brief Profile Options relating to the User Information
@ -214,78 +214,78 @@ public:
//! \brief Create UserInfo object given Profile *p, and initialize the defaults //! \brief Create UserInfo object given Profile *p, and initialize the defaults
UserInfo(Profile *p) : m_profile(p) UserInfo(Profile *p) : m_profile(p)
{ {
if (!m_profile->contains(UI_STR_DOB)) (*m_profile)[UI_STR_DOB]=QDate(1970,1,1); if (!m_profile->contains(STR_UI_DOB)) (*m_profile)[STR_UI_DOB]=QDate(1970,1,1);
if (!m_profile->contains(UI_STR_FirstName)) (*m_profile)[UI_STR_FirstName]=QString(); if (!m_profile->contains(STR_UI_FirstName)) (*m_profile)[STR_UI_FirstName]=QString();
if (!m_profile->contains(UI_STR_LastName)) (*m_profile)[UI_STR_LastName]=QString(); if (!m_profile->contains(STR_UI_LastName)) (*m_profile)[STR_UI_LastName]=QString();
if (!m_profile->contains(UI_STR_UserName)) (*m_profile)[UI_STR_UserName]=QString(); if (!m_profile->contains(STR_UI_UserName)) (*m_profile)[STR_UI_UserName]=QString();
if (!m_profile->contains(UI_STR_Password)) (*m_profile)[UI_STR_Password]=QString(); if (!m_profile->contains(STR_UI_Password)) (*m_profile)[STR_UI_Password]=QString();
if (!m_profile->contains(UI_STR_Address)) (*m_profile)[UI_STR_Address]=QString(); if (!m_profile->contains(STR_UI_Address)) (*m_profile)[STR_UI_Address]=QString();
if (!m_profile->contains(UI_STR_Phone)) (*m_profile)[UI_STR_Phone]=QString(); if (!m_profile->contains(STR_UI_Phone)) (*m_profile)[STR_UI_Phone]=QString();
if (!m_profile->contains(UI_STR_EmailAddress)) (*m_profile)[UI_STR_EmailAddress]=QString(); if (!m_profile->contains(STR_UI_EmailAddress)) (*m_profile)[STR_UI_EmailAddress]=QString();
if (!m_profile->contains(UI_STR_Country)) (*m_profile)[UI_STR_Country]=QString(); if (!m_profile->contains(STR_UI_Country)) (*m_profile)[STR_UI_Country]=QString();
if (!m_profile->contains(UI_STR_Height)) (*m_profile)[UI_STR_Height]=0.0; if (!m_profile->contains(STR_UI_Height)) (*m_profile)[STR_UI_Height]=0.0;
if (!m_profile->contains(UI_STR_Gender)) (*m_profile)[UI_STR_Gender]=(int)GenderNotSpecified; if (!m_profile->contains(STR_UI_Gender)) (*m_profile)[STR_UI_Gender]=(int)GenderNotSpecified;
if (!m_profile->contains(UI_STR_TimeZone)) (*m_profile)[UI_STR_TimeZone]=QString(); if (!m_profile->contains(STR_UI_TimeZone)) (*m_profile)[STR_UI_TimeZone]=QString();
if (!m_profile->contains(UI_STR_Language)) (*m_profile)[UI_STR_Language]="English"; if (!m_profile->contains(STR_UI_Language)) (*m_profile)[STR_UI_Language]="English";
if (!m_profile->contains(UI_STR_DST)) (*m_profile)[UI_STR_DST]=false; if (!m_profile->contains(STR_UI_DST)) (*m_profile)[STR_UI_DST]=false;
} }
~UserInfo() {} ~UserInfo() {}
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
QDate DOB() { return (*m_profile)[UI_STR_DOB].toDate(); } QDate DOB() { return (*m_profile)[STR_UI_DOB].toDate(); }
const QString firstName() { return (*m_profile)[UI_STR_FirstName].toString(); } const QString firstName() { return (*m_profile)[STR_UI_FirstName].toString(); }
const QString lastName() { return (*m_profile)[UI_STR_LastName].toString(); } const QString lastName() { return (*m_profile)[STR_UI_LastName].toString(); }
const QString userName() { return (*m_profile)[UI_STR_UserName].toString(); } const QString userName() { return (*m_profile)[STR_UI_UserName].toString(); }
const QString address() { return (*m_profile)[UI_STR_Address].toString(); } const QString address() { return (*m_profile)[STR_UI_Address].toString(); }
const QString phone() { return (*m_profile)[UI_STR_Phone].toString(); } const QString phone() { return (*m_profile)[STR_UI_Phone].toString(); }
const QString email() { return (*m_profile)[UI_STR_EmailAddress].toString(); } const QString email() { return (*m_profile)[STR_UI_EmailAddress].toString(); }
double height() { return (*m_profile)[UI_STR_Height].toDouble(); } double height() { return (*m_profile)[STR_UI_Height].toDouble(); }
const QString country() { return (*m_profile)[UI_STR_Country].toString(); } const QString country() { return (*m_profile)[STR_UI_Country].toString(); }
Gender gender() { return (Gender)(*m_profile)[UI_STR_Gender].toInt(); } Gender gender() { return (Gender)(*m_profile)[STR_UI_Gender].toInt(); }
const QString timeZone() { return (*m_profile)[UI_STR_TimeZone].toString(); } const QString timeZone() { return (*m_profile)[STR_UI_TimeZone].toString(); }
const QString language() { return (*m_profile)[UI_STR_Language].toString(); } const QString language() { return (*m_profile)[STR_UI_Language].toString(); }
bool daylightSaving() { return (*m_profile)[UI_STR_DST].toBool(); } bool daylightSaving() { return (*m_profile)[STR_UI_DST].toBool(); }
void setDOB(QDate date) { (*m_profile)[UI_STR_DOB]=date; } void setDOB(QDate date) { (*m_profile)[STR_UI_DOB]=date; }
void setFirstName(QString name) { (*m_profile)[UI_STR_FirstName]=name; } void setFirstName(QString name) { (*m_profile)[STR_UI_FirstName]=name; }
void setLastName(QString name) { (*m_profile)[UI_STR_LastName]=name; } void setLastName(QString name) { (*m_profile)[STR_UI_LastName]=name; }
void setUserName(QString username) { (*m_profile)[UI_STR_UserName]=username; } void setUserName(QString username) { (*m_profile)[STR_UI_UserName]=username; }
void setAddress(QString address) { (*m_profile)[UI_STR_Address]=address; } void setAddress(QString address) { (*m_profile)[STR_UI_Address]=address; }
void setPhone(QString phone) { (*m_profile)[UI_STR_Phone]=phone; } void setPhone(QString phone) { (*m_profile)[STR_UI_Phone]=phone; }
void setEmail(QString email) { (*m_profile)[UI_STR_EmailAddress]=email; } void setEmail(QString email) { (*m_profile)[STR_UI_EmailAddress]=email; }
void setHeight(double height) { (*m_profile)[UI_STR_Height]=height; } void setHeight(double height) { (*m_profile)[STR_UI_Height]=height; }
void setCountry(QString country) { (*m_profile)[UI_STR_Country]=country; } void setCountry(QString country) { (*m_profile)[STR_UI_Country]=country; }
void setGender(Gender g) { (*m_profile)[UI_STR_Gender]=(int)g; } void setGender(Gender g) { (*m_profile)[STR_UI_Gender]=(int)g; }
void setTimeZone(QString tz) { (*m_profile)[UI_STR_TimeZone]=tz; } void setTimeZone(QString tz) { (*m_profile)[STR_UI_TimeZone]=tz; }
void setLanguage(QString language) { (*m_profile)[UI_STR_Language]=language; } void setLanguage(QString language) { (*m_profile)[STR_UI_Language]=language; }
void setDaylightSaving(bool ds) { (*m_profile)[UI_STR_DST]=ds; } void setDaylightSaving(bool ds) { (*m_profile)[STR_UI_DST]=ds; }
bool hasPassword() { bool hasPassword() {
return !((*m_profile)[UI_STR_Password].toString().isEmpty()); return !((*m_profile)[STR_UI_Password].toString().isEmpty());
} }
bool checkPassword(QString password) { bool checkPassword(QString password) {
QByteArray ba=password.toUtf8(); QByteArray ba=password.toUtf8();
return ((*m_profile)[UI_STR_Password].toString()==QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex())); return ((*m_profile)[STR_UI_Password].toString()==QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex()));
} }
void setPassword(QString password) { void setPassword(QString password) {
QByteArray ba=password.toUtf8(); QByteArray ba=password.toUtf8();
// Hash me. // Hash me.
(*m_profile)[UI_STR_Password]=QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex()); (*m_profile)[STR_UI_Password]=QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex());
} }
Profile *m_profile; Profile *m_profile;
}; };
extern const char * OS_STR_EnableOximetry; extern const char * STR_OS_EnableOximetry;
extern const char * OS_STR_SyncOximetry; extern const char * STR_OS_SyncOximetry;
extern const char * OS_STR_OximeterType; extern const char * STR_OS_OximeterType;
extern const char * OS_STR_OxiDiscardThreshold; extern const char * STR_OS_OxiDiscardThreshold;
extern const char * OS_STR_SPO2DropDuration; extern const char * STR_OS_SPO2DropDuration;
extern const char * OS_STR_SPO2DropPercentage; extern const char * STR_OS_SPO2DropPercentage;
extern const char * OS_STR_PulseChangeDuration; extern const char * STR_OS_PulseChangeDuration;
extern const char * OS_STR_PulseChangeBPM; extern const char * STR_OS_PulseChangeBPM;
/*! \class OxiSettings /*! \class OxiSettings
\brief Profile Options relating to the Oximetry settings \brief Profile Options relating to the Oximetry settings
@ -296,52 +296,52 @@ public:
//! \brief Create OxiSettings object given Profile *p, and initialize the defaults //! \brief Create OxiSettings object given Profile *p, and initialize the defaults
OxiSettings(Profile *p) :m_profile(p) OxiSettings(Profile *p) :m_profile(p)
{ {
if (!m_profile->contains(OS_STR_EnableOximetry)) (*m_profile)[OS_STR_EnableOximetry]=false; if (!m_profile->contains(STR_OS_EnableOximetry)) (*m_profile)[STR_OS_EnableOximetry]=false;
if (!m_profile->contains(OS_STR_SyncOximetry)) (*m_profile)[OS_STR_SyncOximetry]=true; if (!m_profile->contains(STR_OS_SyncOximetry)) (*m_profile)[STR_OS_SyncOximetry]=true;
if (!m_profile->contains(OS_STR_OximeterType)) (*m_profile)[OS_STR_OximeterType]="CMS50"; if (!m_profile->contains(STR_OS_OximeterType)) (*m_profile)[STR_OS_OximeterType]="CMS50";
if (!m_profile->contains(OS_STR_OxiDiscardThreshold)) (*m_profile)[OS_STR_OxiDiscardThreshold]=0.0; if (!m_profile->contains(STR_OS_OxiDiscardThreshold)) (*m_profile)[STR_OS_OxiDiscardThreshold]=0.0;
if (!m_profile->contains(OS_STR_SPO2DropDuration)) (*m_profile)[OS_STR_SPO2DropDuration]=8.0; if (!m_profile->contains(STR_OS_SPO2DropDuration)) (*m_profile)[STR_OS_SPO2DropDuration]=8.0;
if (!m_profile->contains(OS_STR_SPO2DropPercentage)) (*m_profile)[OS_STR_SPO2DropPercentage]=3.0; if (!m_profile->contains(STR_OS_SPO2DropPercentage)) (*m_profile)[STR_OS_SPO2DropPercentage]=3.0;
if (!m_profile->contains(OS_STR_PulseChangeDuration)) (*m_profile)[OS_STR_PulseChangeDuration]=8.0; if (!m_profile->contains(STR_OS_PulseChangeDuration)) (*m_profile)[STR_OS_PulseChangeDuration]=8.0;
if (!m_profile->contains(OS_STR_PulseChangeBPM)) (*m_profile)[OS_STR_PulseChangeBPM]=5.0; if (!m_profile->contains(STR_OS_PulseChangeBPM)) (*m_profile)[STR_OS_PulseChangeBPM]=5.0;
} }
~OxiSettings() {} ~OxiSettings() {}
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
bool oximetryEnabled() { return (*m_profile)[OS_STR_EnableOximetry].toBool(); } bool oximetryEnabled() { return (*m_profile)[STR_OS_EnableOximetry].toBool(); }
bool syncOximetry() { return (*m_profile)[OS_STR_SyncOximetry].toBool(); } bool syncOximetry() { return (*m_profile)[STR_OS_SyncOximetry].toBool(); }
QString oximeterType() { return (*m_profile)[OS_STR_OximeterType].toString(); } QString oximeterType() { return (*m_profile)[STR_OS_OximeterType].toString(); }
double oxiDiscardThreshold() { return (*m_profile)[OS_STR_OxiDiscardThreshold].toDouble(); } double oxiDiscardThreshold() { return (*m_profile)[STR_OS_OxiDiscardThreshold].toDouble(); }
double spO2DropDuration() { return (*m_profile)[OS_STR_SPO2DropDuration].toDouble(); } double spO2DropDuration() { return (*m_profile)[STR_OS_SPO2DropDuration].toDouble(); }
double spO2DropPercentage() { return (*m_profile)[OS_STR_SPO2DropPercentage].toDouble(); } double spO2DropPercentage() { return (*m_profile)[STR_OS_SPO2DropPercentage].toDouble(); }
double pulseChangeDuration() { return (*m_profile)[OS_STR_PulseChangeDuration].toDouble(); } double pulseChangeDuration() { return (*m_profile)[STR_OS_PulseChangeDuration].toDouble(); }
double pulseChangeBPM() { return (*m_profile)[OS_STR_PulseChangeBPM].toDouble(); } double pulseChangeBPM() { return (*m_profile)[STR_OS_PulseChangeBPM].toDouble(); }
void setOximetryEnabled(bool enabled) { (*m_profile)[OS_STR_EnableOximetry]=enabled; } void setOximetryEnabled(bool enabled) { (*m_profile)[STR_OS_EnableOximetry]=enabled; }
void setSyncOximetry(bool synced) { (*m_profile)[OS_STR_SyncOximetry]=synced; } void setSyncOximetry(bool synced) { (*m_profile)[STR_OS_SyncOximetry]=synced; }
void setOximeterType(QString oxitype) { (*m_profile)[OS_STR_OximeterType]=oxitype; } void setOximeterType(QString oxitype) { (*m_profile)[STR_OS_OximeterType]=oxitype; }
void setOxiDiscardThreshold(double thresh) { (*m_profile)[OS_STR_OxiDiscardThreshold]=thresh; } void setOxiDiscardThreshold(double thresh) { (*m_profile)[STR_OS_OxiDiscardThreshold]=thresh; }
void setSpO2DropDuration(double duration) { (*m_profile)[OS_STR_SPO2DropDuration]=duration; } void setSpO2DropDuration(double duration) { (*m_profile)[STR_OS_SPO2DropDuration]=duration; }
void setSpO2DropPercentage(double percentage) { (*m_profile)[OS_STR_SPO2DropPercentage]=percentage; } void setSpO2DropPercentage(double percentage) { (*m_profile)[STR_OS_SPO2DropPercentage]=percentage; }
void setPulseChangeDuration(double duration) { (*m_profile)[OS_STR_PulseChangeDuration]=duration; } void setPulseChangeDuration(double duration) { (*m_profile)[STR_OS_PulseChangeDuration]=duration; }
void setPulseChangeBPM(double bpm) { (*m_profile)[OS_STR_PulseChangeBPM]=bpm; } void setPulseChangeBPM(double bpm) { (*m_profile)[STR_OS_PulseChangeBPM]=bpm; }
Profile *m_profile; Profile *m_profile;
}; };
extern const char * CS_STR_ComplianceHours; extern const char * STR_CS_ComplianceHours;
extern const char * CS_STR_ShowCompliance; extern const char * STR_CS_ShowCompliance;
extern const char * CS_STR_ShowLeaksMode; extern const char * STR_CS_ShowLeaksMode;
extern const char * CS_STR_MaskStartDate; extern const char * STR_CS_MaskStartDate;
extern const char * CS_STR_MaskDescription; extern const char * STR_CS_MaskDescription;
extern const char * CS_STR_MaskType; extern const char * STR_CS_MaskType;
extern const char * CS_STR_PrescribedMode; extern const char * STR_CS_PrescribedMode;
extern const char * CS_STR_PrescribedMinPressure; extern const char * STR_CS_PrescribedMinPressure;
extern const char * CS_STR_PrescribedMaxPressure; extern const char * STR_CS_PrescribedMaxPressure;
extern const char * CS_STR_UntreatedAHI; extern const char * STR_CS_UntreatedAHI;
extern const char * CS_STR_Notes; extern const char * STR_CS_Notes;
extern const char * CS_STR_DateDiagnosed; extern const char * STR_CS_DateDiagnosed;
/*! \class CPAPSettings /*! \class CPAPSettings
\brief Profile Options relating to the CPAP settings \brief Profile Options relating to the CPAP settings
@ -352,19 +352,19 @@ public:
//! \brief Create CPAPSettings object given Profile *p, and initialize the defaults //! \brief Create CPAPSettings object given Profile *p, and initialize the defaults
CPAPSettings(Profile *p) :m_profile(p) CPAPSettings(Profile *p) :m_profile(p)
{ {
if (!m_profile->contains(CS_STR_ComplianceHours)) (*m_profile)[CS_STR_ComplianceHours]=4; if (!m_profile->contains(STR_CS_ComplianceHours)) (*m_profile)[STR_CS_ComplianceHours]=4;
if (!m_profile->contains(CS_STR_ShowCompliance)) (*m_profile)[CS_STR_ShowCompliance]=true; if (!m_profile->contains(STR_CS_ShowCompliance)) (*m_profile)[STR_CS_ShowCompliance]=true;
if (!m_profile->contains(CS_STR_ShowLeaksMode)) (*m_profile)[CS_STR_ShowLeaksMode]=0; if (!m_profile->contains(STR_CS_ShowLeaksMode)) (*m_profile)[STR_CS_ShowLeaksMode]=0;
// TODO: Check if this date is initiliazed yet // TODO: Check if this date is initiliazed yet
if (!m_profile->contains(CS_STR_MaskStartDate)) (*m_profile)[CS_STR_MaskStartDate]=QDate(); if (!m_profile->contains(STR_CS_MaskStartDate)) (*m_profile)[STR_CS_MaskStartDate]=QDate();
if (!m_profile->contains(CS_STR_MaskDescription)) (*m_profile)[CS_STR_MaskDescription]=QString(); if (!m_profile->contains(STR_CS_MaskDescription)) (*m_profile)[STR_CS_MaskDescription]=QString();
if (!m_profile->contains(CS_STR_MaskType)) (*m_profile)[CS_STR_MaskType]=Mask_Unknown; if (!m_profile->contains(STR_CS_MaskType)) (*m_profile)[STR_CS_MaskType]=Mask_Unknown;
if (!m_profile->contains(CS_STR_PrescribedMode)) (*m_profile)[CS_STR_PrescribedMode]=MODE_UNKNOWN; if (!m_profile->contains(STR_CS_PrescribedMode)) (*m_profile)[STR_CS_PrescribedMode]=MODE_UNKNOWN;
if (!m_profile->contains(CS_STR_PrescribedMinPressure)) (*m_profile)[CS_STR_PrescribedMinPressure]=0.0; if (!m_profile->contains(STR_CS_PrescribedMinPressure)) (*m_profile)[STR_CS_PrescribedMinPressure]=0.0;
if (!m_profile->contains(CS_STR_PrescribedMaxPressure)) (*m_profile)[CS_STR_PrescribedMaxPressure]=0.0; if (!m_profile->contains(STR_CS_PrescribedMaxPressure)) (*m_profile)[STR_CS_PrescribedMaxPressure]=0.0;
if (!m_profile->contains(CS_STR_UntreatedAHI)) (*m_profile)[CS_STR_UntreatedAHI]=0.0; if (!m_profile->contains(STR_CS_UntreatedAHI)) (*m_profile)[STR_CS_UntreatedAHI]=0.0;
if (!m_profile->contains(CS_STR_Notes)) (*m_profile)[CS_STR_Notes]=QString(); if (!m_profile->contains(STR_CS_Notes)) (*m_profile)[STR_CS_Notes]=QString();
if (!m_profile->contains(CS_STR_DateDiagnosed)) (*m_profile)[CS_STR_DateDiagnosed]=QDate(); if (!m_profile->contains(STR_CS_DateDiagnosed)) (*m_profile)[STR_CS_DateDiagnosed]=QDate();
} }
~CPAPSettings() {} ~CPAPSettings() {}
@ -372,43 +372,44 @@ public:
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
//Getters //Getters
double complianceHours() { return (*m_profile)[CS_STR_ComplianceHours].toDouble(); } double complianceHours() { return (*m_profile)[STR_CS_ComplianceHours].toDouble(); }
bool showComplianceInfo() { return (*m_profile)[CS_STR_ShowCompliance].toBool(); } bool showComplianceInfo() { return (*m_profile)[STR_CS_ShowCompliance].toBool(); }
int leakMode() { return (*m_profile)[CS_STR_ShowLeaksMode].toInt(); } int leakMode() { return (*m_profile)[STR_CS_ShowLeaksMode].toInt(); }
QDate maskStartDate() { return (*m_profile)[CS_STR_MaskStartDate].toDate(); } QDate maskStartDate() { return (*m_profile)[STR_CS_MaskStartDate].toDate(); }
QString maskDescription() { return (*m_profile)[CS_STR_MaskDescription].toString(); } QString maskDescription() { return (*m_profile)[STR_CS_MaskDescription].toString(); }
MaskType maskType() { return (MaskType)(*m_profile)[CS_STR_MaskType].toInt(); } MaskType maskType() { return (MaskType)(*m_profile)[STR_CS_MaskType].toInt(); }
CPAPMode mode() { return CPAPMode((*m_profile)[CS_STR_PrescribedMode].toInt()); } CPAPMode mode() { return CPAPMode((*m_profile)[STR_CS_PrescribedMode].toInt()); }
double minPressure() { return (*m_profile)[CS_STR_PrescribedMinPressure].toDouble(); } double minPressure() { return (*m_profile)[STR_CS_PrescribedMinPressure].toDouble(); }
double maxPressure() { return (*m_profile)[CS_STR_PrescribedMaxPressure].toDouble(); } double maxPressure() { return (*m_profile)[STR_CS_PrescribedMaxPressure].toDouble(); }
double untreatedAHI() { return (*m_profile)[CS_STR_UntreatedAHI].toDouble(); } double untreatedAHI() { return (*m_profile)[STR_CS_UntreatedAHI].toDouble(); }
const QString notes() { return (*m_profile)[CS_STR_Notes].toString(); } const QString notes() { return (*m_profile)[STR_CS_Notes].toString(); }
QDate dateDiagnosed() { return (*m_profile)[CS_STR_DateDiagnosed].toDate(); } QDate dateDiagnosed() { return (*m_profile)[STR_CS_DateDiagnosed].toDate(); }
//Setters //Setters
void setMode(CPAPMode mode) { (*m_profile)[CS_STR_PrescribedMode]=(int)mode; } void setMode(CPAPMode mode) { (*m_profile)[STR_CS_PrescribedMode]=(int)mode; }
void setMinPressure(double pressure) { (*m_profile)[CS_STR_PrescribedMinPressure]=pressure; } void setMinPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMinPressure]=pressure; }
void setMaxPressure(double pressure) { (*m_profile)[CS_STR_PrescribedMaxPressure]=pressure; } void setMaxPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMaxPressure]=pressure; }
void setUntreatedAHI(double ahi) { (*m_profile)[CS_STR_UntreatedAHI]=ahi; } void setUntreatedAHI(double ahi) { (*m_profile)[STR_CS_UntreatedAHI]=ahi; }
void setNotes(QString notes) { (*m_profile)[CS_STR_Notes]=notes; } void setNotes(QString notes) { (*m_profile)[STR_CS_Notes]=notes; }
void setDateDiagnosed(QDate date) { (*m_profile)[CS_STR_DateDiagnosed]=date; } void setDateDiagnosed(QDate date) { (*m_profile)[STR_CS_DateDiagnosed]=date; }
void setComplianceHours(double hours) { (*m_profile)[CS_STR_ComplianceHours]=hours; } void setComplianceHours(double hours) { (*m_profile)[STR_CS_ComplianceHours]=hours; }
void setShowComplianceInfo(bool b) { (*m_profile)[CS_STR_ShowCompliance]=b; } void setShowComplianceInfo(bool b) { (*m_profile)[STR_CS_ShowCompliance]=b; }
void setLeakMode(int leakmode) { (*m_profile)[CS_STR_ShowLeaksMode]=(int)leakmode; } void setLeakMode(int leakmode) { (*m_profile)[STR_CS_ShowLeaksMode]=(int)leakmode; }
void setMaskStartDate(QDate date) { (*m_profile)[CS_STR_MaskStartDate]=date; } void setMaskStartDate(QDate date) { (*m_profile)[STR_CS_MaskStartDate]=date; }
void setMaskDescription(QString description) { (*m_profile)[CS_STR_MaskDescription]=description; } void setMaskDescription(QString description) { (*m_profile)[STR_CS_MaskDescription]=description; }
void setMaskType(MaskType masktype) { (*m_profile)[CS_STR_MaskType]=(int)masktype; } void setMaskType(MaskType masktype) { (*m_profile)[STR_CS_MaskType]=(int)masktype; }
Profile *m_profile; Profile *m_profile;
}; };
extern const char * IS_STR_DaySplitTime; extern const char * STR_IS_DaySplitTime;
extern const char * IS_STR_CacheSessions; extern const char * STR_IS_CacheSessions;
extern const char * IS_STR_CombineCloseSessions; extern const char * STR_IS_CombineCloseSessions;
extern const char * IS_STR_IgnoreShorterSessions; extern const char * STR_IS_IgnoreShorterSessions;
extern const char * IS_STR_Multithreading; extern const char * STR_IS_Multithreading;
extern const char * IS_STR_TrashDayCache; extern const char * STR_IS_BackupCardData;
extern const char * IS_STR_ShowSerialNumbers; extern const char * STR_IS_CompressBackupData;
extern const char * STR_IS_CompressSessionData;
/*! \class ImportSettings /*! \class ImportSettings
\brief Profile Options relating to the Import process \brief Profile Options relating to the Import process
@ -419,43 +420,46 @@ public:
//! \brief Create ImportSettings object given Profile *p, and initialize the defaults //! \brief Create ImportSettings object given Profile *p, and initialize the defaults
SessionSettings(Profile *p) :m_profile(p) SessionSettings(Profile *p) :m_profile(p)
{ {
if (!m_profile->contains(IS_STR_DaySplitTime)) (*m_profile)[IS_STR_DaySplitTime]=QTime(12,0,0); if (!m_profile->contains(STR_IS_DaySplitTime)) (*m_profile)[STR_IS_DaySplitTime]=QTime(12,0,0);
if (!m_profile->contains(IS_STR_CacheSessions)) (*m_profile)[IS_STR_CacheSessions]=false; if (!m_profile->contains(STR_IS_CacheSessions)) (*m_profile)[STR_IS_CacheSessions]=false;
if (!m_profile->contains(IS_STR_CombineCloseSessions)) (*m_profile)[IS_STR_CombineCloseSessions]=240; if (!m_profile->contains(STR_IS_CombineCloseSessions)) (*m_profile)[STR_IS_CombineCloseSessions]=240;
if (!m_profile->contains(IS_STR_IgnoreShorterSessions)) (*m_profile)[IS_STR_IgnoreShorterSessions]=5; if (!m_profile->contains(STR_IS_IgnoreShorterSessions)) (*m_profile)[STR_IS_IgnoreShorterSessions]=5;
if (!m_profile->contains(IS_STR_Multithreading)) (*m_profile)[IS_STR_Multithreading]=QThread::idealThreadCount() > 1; if (!m_profile->contains(STR_IS_Multithreading)) (*m_profile)[STR_IS_Multithreading]=QThread::idealThreadCount() > 1;
if (!m_profile->contains(IS_STR_TrashDayCache)) (*m_profile)[IS_STR_TrashDayCache]=false; // can't remember.. if (!m_profile->contains(STR_IS_BackupCardData)) (*m_profile)[STR_IS_BackupCardData]=true;
if (!m_profile->contains(IS_STR_ShowSerialNumbers)) (*m_profile)[IS_STR_ShowSerialNumbers]=false; if (!m_profile->contains(STR_IS_CompressBackupData)) (*m_profile)[STR_IS_CompressBackupData]=false;
if (!m_profile->contains(STR_IS_CompressSessionData)) (*m_profile)[STR_IS_CompressSessionData]=false;
} }
~SessionSettings() {} ~SessionSettings() {}
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
QTime daySplitTime() { return (*m_profile)[IS_STR_DaySplitTime].toTime(); } QTime daySplitTime() { return (*m_profile)[STR_IS_DaySplitTime].toTime(); }
bool cacheSessions() { return (*m_profile)[IS_STR_CacheSessions].toBool(); } bool cacheSessions() { return (*m_profile)[STR_IS_CacheSessions].toBool(); }
double combineCloseSessions() { return (*m_profile)[IS_STR_CombineCloseSessions].toDouble(); } double combineCloseSessions() { return (*m_profile)[STR_IS_CombineCloseSessions].toDouble(); }
double ignoreShortSessions() { return (*m_profile)[IS_STR_IgnoreShorterSessions].toDouble(); } double ignoreShortSessions() { return (*m_profile)[STR_IS_IgnoreShorterSessions].toDouble(); }
bool multithreading() { return (*m_profile)[IS_STR_Multithreading].toBool(); } bool multithreading() { return (*m_profile)[STR_IS_Multithreading].toBool(); }
bool trashDayCache() { return (*m_profile)[IS_STR_TrashDayCache].toBool(); } bool compressSessionData() { return (*m_profile)[STR_IS_CompressSessionData].toBool(); }
bool showSerialNumbers() { return (*m_profile)[IS_STR_ShowSerialNumbers].toBool(); } bool compressBackupData() { return (*m_profile)[STR_IS_CompressBackupData].toBool(); }
bool backupCardData() { return (*m_profile)[STR_IS_BackupCardData].toBool(); }
void setDaySplitTime(QTime time) { (*m_profile)[IS_STR_DaySplitTime]=time; } void setDaySplitTime(QTime time) { (*m_profile)[STR_IS_DaySplitTime]=time; }
void setCacheSessions(bool c) { (*m_profile)[IS_STR_CacheSessions]=c; } void setCacheSessions(bool c) { (*m_profile)[STR_IS_CacheSessions]=c; }
void setCombineCloseSessions(double val) { (*m_profile)[IS_STR_CombineCloseSessions]=val; } void setCombineCloseSessions(double val) { (*m_profile)[STR_IS_CombineCloseSessions]=val; }
void setIgnoreShortSessions(double val) { (*m_profile)[IS_STR_IgnoreShorterSessions]=val; } void setIgnoreShortSessions(double val) { (*m_profile)[STR_IS_IgnoreShorterSessions]=val; }
void setMultithreading(bool enabled) { (*m_profile)[IS_STR_Multithreading]=enabled; } void setMultithreading(bool enabled) { (*m_profile)[STR_IS_Multithreading]=enabled; }
void setTrashDayCache(bool trash) { (*m_profile)[IS_STR_TrashDayCache]=trash; } void setBackupCardData(bool enabled) { (*m_profile)[STR_IS_BackupCardData]=enabled; }
void setShowSerialNumbers(bool trash) { (*m_profile)[IS_STR_ShowSerialNumbers]=trash; } void setCompressBackupData(bool enabled) { (*m_profile)[STR_IS_CompressBackupData]=enabled; }
void setCompressSessionData(bool enabled) { (*m_profile)[STR_IS_CompressSessionData]=enabled; }
Profile *m_profile; Profile *m_profile;
}; };
extern const char * AS_STR_GraphHeight; extern const char * STR_AS_GraphHeight;
extern const char * AS_STR_AntiAliasing; extern const char * STR_AS_AntiAliasing;
extern const char * AS_STR_GraphSnapshots; extern const char * STR_AS_GraphSnapshots;
extern const char * AS_STR_Animations; extern const char * STR_AS_Animations;
extern const char * AS_STR_SquareWave; extern const char * STR_AS_SquareWave;
extern const char * AS_STR_OverlayType; extern const char * STR_AS_OverlayType;
/*! \class AppearanceSettings /*! \class AppearanceSettings
\brief Profile Options relating to Visual Appearance \brief Profile Options relating to Visual Appearance
@ -466,54 +470,54 @@ public:
//! \brief Create AppearanceSettings object given Profile *p, and initialize the defaults //! \brief Create AppearanceSettings object given Profile *p, and initialize the defaults
AppearanceSettings(Profile *p) :m_profile(p) AppearanceSettings(Profile *p) :m_profile(p)
{ {
if (!m_profile->contains(AS_STR_GraphHeight)) (*m_profile)[AS_STR_GraphHeight]=180.0; if (!m_profile->contains(STR_AS_GraphHeight)) (*m_profile)[STR_AS_GraphHeight]=180.0;
if (!m_profile->contains(AS_STR_AntiAliasing)) (*m_profile)[AS_STR_AntiAliasing]=false; // i think it's ugly if (!m_profile->contains(STR_AS_AntiAliasing)) (*m_profile)[STR_AS_AntiAliasing]=false; // i think it's ugly
if (!m_profile->contains(AS_STR_GraphSnapshots)) (*m_profile)[AS_STR_GraphSnapshots]=true; if (!m_profile->contains(STR_AS_GraphSnapshots)) (*m_profile)[STR_AS_GraphSnapshots]=true;
if (!m_profile->contains(AS_STR_Animations)) (*m_profile)[AS_STR_Animations]=true; if (!m_profile->contains(STR_AS_Animations)) (*m_profile)[STR_AS_Animations]=true;
if (!m_profile->contains(AS_STR_SquareWave)) (*m_profile)[AS_STR_SquareWave]=false; if (!m_profile->contains(STR_AS_SquareWave)) (*m_profile)[STR_AS_SquareWave]=false;
if (!m_profile->contains(AS_STR_OverlayType)) (*m_profile)[AS_STR_OverlayType]=ODT_Bars; if (!m_profile->contains(STR_AS_OverlayType)) (*m_profile)[STR_AS_OverlayType]=ODT_Bars;
} }
~AppearanceSettings() {} ~AppearanceSettings() {}
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
//! \brief Returns the normal (unscaled) height of a graph //! \brief Returns the normal (unscaled) height of a graph
int graphHeight() { return (*m_profile)[AS_STR_GraphHeight].toInt(); } int graphHeight() { return (*m_profile)[STR_AS_GraphHeight].toInt(); }
//! \brief Returns true if AntiAliasing (the graphical smoothing method) is enabled //! \brief Returns true if AntiAliasing (the graphical smoothing method) is enabled
bool antiAliasing() { return (*m_profile)[AS_STR_AntiAliasing].toBool(); } bool antiAliasing() { return (*m_profile)[STR_AS_AntiAliasing].toBool(); }
//! \brief Returns true if renderPixmap function is in use, which takes snapshots of graphs //! \brief Returns true if renderPixmap function is in use, which takes snapshots of graphs
bool graphSnapshots() { return (*m_profile)[AS_STR_GraphSnapshots].toBool(); } bool graphSnapshots() { return (*m_profile)[STR_AS_GraphSnapshots].toBool(); }
//! \brief Returns true if Graphical animations & Transitions will be drawn //! \brief Returns true if Graphical animations & Transitions will be drawn
bool animations() { return (*m_profile)[AS_STR_Animations].toBool(); } bool animations() { return (*m_profile)[STR_AS_Animations].toBool(); }
//! \brief Returns true if Square Wave plots are preferred (where possible) //! \brief Returns true if Square Wave plots are preferred (where possible)
bool squareWavePlots() { return (*m_profile)[AS_STR_SquareWave].toBool(); } bool squareWavePlots() { return (*m_profile)[STR_AS_SquareWave].toBool(); }
//! \brief Returns the type of overlay flags (which are displayed over the Flow Waveform) //! \brief Returns the type of overlay flags (which are displayed over the Flow Waveform)
OverlayDisplayType overlayType() { return (OverlayDisplayType )(*m_profile)[AS_STR_OverlayType].toInt(); } OverlayDisplayType overlayType() { return (OverlayDisplayType )(*m_profile)[STR_AS_OverlayType].toInt(); }
//! \brief Set the normal (unscaled) height of a graph. //! \brief Set the normal (unscaled) height of a graph.
void setGraphHeight(int height) { (*m_profile)[AS_STR_GraphHeight]=height; } void setGraphHeight(int height) { (*m_profile)[STR_AS_GraphHeight]=height; }
//! \brief Set to true to turn on AntiAliasing (the graphical smoothing method) //! \brief Set to true to turn on AntiAliasing (the graphical smoothing method)
void setAntiAliasing(bool aa) { (*m_profile)[AS_STR_AntiAliasing]=aa; } void setAntiAliasing(bool aa) { (*m_profile)[STR_AS_AntiAliasing]=aa; }
//! \brief Set to true if renderPixmap functions are in use, which takes snapshots of graphs. //! \brief Set to true if renderPixmap functions are in use, which takes snapshots of graphs.
void setGraphSnapshots(bool gs) { (*m_profile)[AS_STR_GraphSnapshots]=gs; } void setGraphSnapshots(bool gs) { (*m_profile)[STR_AS_GraphSnapshots]=gs; }
//! \brief Set to true if Graphical animations & Transitions will be drawn //! \brief Set to true if Graphical animations & Transitions will be drawn
void setAnimations(bool anim) { (*m_profile)[AS_STR_Animations]=anim; } void setAnimations(bool anim) { (*m_profile)[STR_AS_Animations]=anim; }
//! \brief Set whether or not to useSquare Wave plots (where possible) //! \brief Set whether or not to useSquare Wave plots (where possible)
void setSquareWavePlots(bool sw) { (*m_profile)[AS_STR_SquareWave]=sw; } void setSquareWavePlots(bool sw) { (*m_profile)[STR_AS_SquareWave]=sw; }
//! \brief Sets the type of overlay flags (which are displayed over the Flow Waveform) //! \brief Sets the type of overlay flags (which are displayed over the Flow Waveform)
void setOverlayType(OverlayDisplayType od) { (*m_profile)[AS_STR_OverlayType]=(int)od; } void setOverlayType(OverlayDisplayType od) { (*m_profile)[STR_AS_OverlayType]=(int)od; }
Profile *m_profile; Profile *m_profile;
}; };
extern const char * STR_US_UnitSystem;
extern const char * US_STR_UnitSystem; extern const char * STR_US_EventWindowSize;
extern const char * US_STR_EventWindowSize; extern const char * STR_US_SkipEmptyDays;
extern const char * US_STR_SkipEmptyDays; extern const char * STR_US_RebuildCache;
extern const char * US_STR_RebuildCache; extern const char * STR_US_ShowDebug;
extern const char * US_STR_ShowDebug; extern const char * STR_US_LinkGroups;
extern const char * US_STR_LinkGroups; extern const char * STR_US_CalculateRDI;
extern const char * US_STR_CalculateRDI; extern const char * STR_US_ShowSerialNumbers;
/*! \class UserSettings /*! \class UserSettings
\brief Profile Options relating to General User Settings \brief Profile Options relating to General User Settings
@ -524,34 +528,36 @@ public:
//! \brief Create UserSettings object given Profile *p, and initialize the defaults //! \brief Create UserSettings object given Profile *p, and initialize the defaults
UserSettings(Profile *p) :m_profile(p) UserSettings(Profile *p) :m_profile(p)
{ {
if (!m_profile->contains(US_STR_UnitSystem)) (*m_profile)[US_STR_UnitSystem]=US_Metric; if (!m_profile->contains(STR_US_UnitSystem)) (*m_profile)[STR_US_UnitSystem]=US_Metric;
if (!m_profile->contains(US_STR_EventWindowSize)) (*m_profile)[US_STR_EventWindowSize]=4.0; if (!m_profile->contains(STR_US_EventWindowSize)) (*m_profile)[STR_US_EventWindowSize]=4.0;
if (!m_profile->contains(US_STR_SkipEmptyDays)) (*m_profile)[US_STR_SkipEmptyDays]=true; if (!m_profile->contains(STR_US_SkipEmptyDays)) (*m_profile)[STR_US_SkipEmptyDays]=true;
if (!m_profile->contains(US_STR_RebuildCache)) (*m_profile)[US_STR_RebuildCache]=false; // can't remember.. if (!m_profile->contains(STR_US_RebuildCache)) (*m_profile)[STR_US_RebuildCache]=false; // can't remember..
if (!m_profile->contains(US_STR_ShowDebug)) (*m_profile)[US_STR_ShowDebug]=false; if (!m_profile->contains(STR_US_ShowDebug)) (*m_profile)[STR_US_ShowDebug]=false;
if (!m_profile->contains(US_STR_LinkGroups)) (*m_profile)[US_STR_LinkGroups]=true; // can't remember.. if (!m_profile->contains(STR_US_LinkGroups)) (*m_profile)[STR_US_LinkGroups]=true; // can't remember..
if (!m_profile->contains(US_STR_CalculateRDI)) (*m_profile)[US_STR_CalculateRDI]=false; if (!m_profile->contains(STR_US_CalculateRDI)) (*m_profile)[STR_US_CalculateRDI]=false;
if (!m_profile->contains(STR_US_ShowSerialNumbers)) (*m_profile)[STR_US_ShowSerialNumbers]=false;
} }
~UserSettings() {} ~UserSettings() {}
void setProfile(Profile *p) { m_profile=p; } void setProfile(Profile *p) { m_profile=p; }
UnitSystem unitSystem() { return (UnitSystem)(*m_profile)[US_STR_UnitSystem].toInt(); } UnitSystem unitSystem() { return (UnitSystem)(*m_profile)[STR_US_UnitSystem].toInt(); }
double eventWindowSize() { return (*m_profile)[US_STR_EventWindowSize].toDouble(); } double eventWindowSize() { return (*m_profile)[STR_US_EventWindowSize].toDouble(); }
bool skipEmptyDays() { return (*m_profile)[US_STR_SkipEmptyDays].toBool(); } bool skipEmptyDays() { return (*m_profile)[STR_US_SkipEmptyDays].toBool(); }
bool rebuildCache() { return (*m_profile)[US_STR_RebuildCache].toBool(); } bool rebuildCache() { return (*m_profile)[STR_US_RebuildCache].toBool(); }
bool showDebug() { return (*m_profile)[US_STR_ShowDebug].toBool(); } bool showDebug() { return (*m_profile)[STR_US_ShowDebug].toBool(); }
bool linkGroups() { return (*m_profile)[US_STR_LinkGroups].toBool(); } bool linkGroups() { return (*m_profile)[STR_US_LinkGroups].toBool(); }
bool calculateRDI() { return (*m_profile)[US_STR_CalculateRDI].toBool(); } bool calculateRDI() { return (*m_profile)[STR_US_CalculateRDI].toBool(); }
bool showSerialNumbers() { return (*m_profile)[STR_US_ShowSerialNumbers].toBool(); }
void setUnitSystem(UnitSystem us) { (*m_profile)[US_STR_UnitSystem]=(int)us; }
void setEventWindowSize(double size) { (*m_profile)[US_STR_EventWindowSize]=size; }
void setSkipEmptyDays(bool skip) { (*m_profile)[US_STR_SkipEmptyDays]=skip; }
void setRebuildCache(bool rebuild) { (*m_profile)[US_STR_RebuildCache]=rebuild; }
void setShowDebug(bool b) { (*m_profile)[US_STR_ShowDebug]=b; }
void setLinkGroups(bool link) { (*m_profile)[US_STR_LinkGroups]=link; }
void setCalculateRDI(bool rdi) { (*m_profile)[US_STR_CalculateRDI]=rdi; }
void setUnitSystem(UnitSystem us) { (*m_profile)[STR_US_UnitSystem]=(int)us; }
void setEventWindowSize(double size) { (*m_profile)[STR_US_EventWindowSize]=size; }
void setSkipEmptyDays(bool skip) { (*m_profile)[STR_US_SkipEmptyDays]=skip; }
void setRebuildCache(bool rebuild) { (*m_profile)[STR_US_RebuildCache]=rebuild; }
void setShowDebug(bool b) { (*m_profile)[STR_US_ShowDebug]=b; }
void setLinkGroups(bool link) { (*m_profile)[STR_US_LinkGroups]=link; }
void setCalculateRDI(bool rdi) { (*m_profile)[STR_US_CalculateRDI]=rdi; }
void setShowSerialNumbers(bool enabled) { (*m_profile)[STR_US_ShowSerialNumbers]=enabled; }
Profile *m_profile; Profile *m_profile;
}; };

225
SleepLib/session.cpp
View File

@ -12,7 +12,9 @@
#include <QMessageBox> #include <QMessageBox>
#include <QMetaType> #include <QMetaType>
#include <algorithm> #include <algorithm>
#include <SleepLib/calcs.h>
#include "SleepLib/calcs.h"
#include "SleepLib/profiles.h"
using namespace std; using namespace std;
@ -23,7 +25,7 @@ const quint16 filetype_data=1;
// This is the uber important database version for SleepyHeads internal storage // This is the uber important database version for SleepyHeads internal storage
// Increment this after stuffing with Session's save & load code. // Increment this after stuffing with Session's save & load code.
const quint16 summary_version=11; const quint16 summary_version=11;
const quint16 events_version=8; const quint16 events_version=9;
Session::Session(Machine * m,SessionID session) Session::Session(Machine * m,SessionID session)
{ {
@ -337,27 +339,42 @@ bool Session::LoadSummary(QString filename)
return true; return true;
} }
const quint16 compress_method=1;
bool Session::StoreEvents(QString filename) bool Session::StoreEvents(QString filename)
{ {
QFile file(filename); QFile file(filename);
file.open(QIODevice::WriteOnly); file.open(QIODevice::WriteOnly);
QDataStream out(&file); QByteArray headerbytes;
QDataStream header(&headerbytes,QIODevice::WriteOnly);
header.setVersion(QDataStream::Qt_4_6);
header.setByteOrder(QDataStream::LittleEndian);
header << (quint32)magic; // New Magic Number
header << (quint16)events_version; // File Version
header << (quint16)filetype_data; // File type 1 == Event
header << (quint32)s_machine->id();// Machine Type
header << (quint32)s_session; // This session's ID
header << s_first;
header << s_last;
quint16 compress=0;
if (p_profile->session->compressSessionData())
compress=compress_method;
header << (quint16)compress;
header << (quint16)s_machine->GetType();// Machine Type
QByteArray databytes;
QDataStream out(&databytes,QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_6); out.setVersion(QDataStream::Qt_4_6);
out.setByteOrder(QDataStream::LittleEndian); out.setByteOrder(QDataStream::LittleEndian);
out << (quint32)magic; // Magic Number
out << (quint16)events_version; // File Version
out << (quint16)filetype_data; // File type 1 == Event
out << (quint32)s_machine->id();// Machine ID
out << (quint32)s_session; // This session's ID
out << s_first;
out << s_last;
out << (qint16)eventlist.size(); // Number of event categories out << (qint16)eventlist.size(); // Number of event categories
QHash<ChannelID,QVector<EventList *> >::iterator i; QHash<ChannelID,QVector<EventList *> >::iterator i;
for (i=eventlist.begin(); i!=eventlist.end(); i++) { for (i=eventlist.begin(); i!=eventlist.end(); i++) {
@ -386,26 +403,59 @@ bool Session::StoreEvents(QString filename)
for (int j=0;j<i.value().size();j++) { for (int j=0;j<i.value().size();j++) {
EventList &e=*i.value()[j]; EventList &e=*i.value()[j];
for (quint32 c=0;c<e.count();c++) { // Store the raw event list data in EventStoreType (16bit short)
out << e.raw(c); EventStoreType *ptr=e.m_data.data();
} out.writeRawData((char *)ptr,e.count() << 1);
// for (quint32 c=0;c<e.count();c++) {
// out << *ptr++;//e.raw(c);
// }
// Store the second field, only if there
if (e.hasSecondField()) { if (e.hasSecondField()) {
for (quint32 c=0;c<e.count();c++) { ptr=e.m_data2.data();
out << e.raw2(c); out.writeRawData((char *)ptr,e.count() << 1);
} // for (quint32 c=0;c<e.count();c++) {
// out << *ptr++; //e.raw2(c);
// }
} }
// Store the time delta fields for non-waveform EventLists
if (e.type()!=EVL_Waveform) { if (e.type()!=EVL_Waveform) {
for (quint32 c=0;c<e.count();c++) { quint32 * tptr=e.m_time.data();
out << e.getTime()[c]; out.writeRawData((char *)tptr,e.count() << 2);
} // for (quint32 c=0;c<e.count();c++) {
// out << *tptr++; //e.getTime()[c];
// }
} }
} }
} }
qint32 datasize=databytes.size();
// Checksum the _uncompressed_ data
quint16 chk=qChecksum(databytes.data(),databytes.size());
header << datasize;
header << chk;
QByteArray data;
if (compress>0) {
data=qCompress(databytes);
} else {
data=databytes;
}
file.write(headerbytes);
file.write(data);
file.close();
return true; return true;
} }
bool Session::LoadEvents(QString filename) bool Session::LoadEvents(QString filename)
{ {
quint32 t32,magicnum,machid,sessid;
quint16 t16,version,type,crc16,machtype,compmethod;
quint8 t8;
qint32 datasize;
if (filename.isEmpty()) { if (filename.isEmpty()) {
qDebug() << "Session::LoadEvents() Filename is empty"; qDebug() << "Session::LoadEvents() Filename is empty";
return false; return false;
@ -416,47 +466,67 @@ bool Session::LoadEvents(QString filename)
qDebug() << "Couldn't open file" << filename; qDebug() << "Couldn't open file" << filename;
return false; return false;
} }
QDataStream in(&file);
in.setVersion(QDataStream::Qt_4_6);
in.setByteOrder(QDataStream::LittleEndian);
quint32 t32; QByteArray headerbytes=file.read(42);
quint16 t16;
quint8 t8;
//qint16 i16;
qint16 version;
in >> t32; // Magic Number QDataStream header(headerbytes);
if (t32!=magic) { header.setVersion(QDataStream::Qt_4_6);
qWarning() << "Wrong Magic number in " << filename; header.setByteOrder(QDataStream::LittleEndian);
return false;
}
in >> version; // File Version bool compressed=true;
header >> magicnum; // Magic Number (quint32)
header >> version; // Version (quint16)
header >> type; // File type (quint16)
header >> machid; // Machine ID (quint32)
header >> sessid; //(quint32)
header >> s_first; //(qint64)
header >> s_last; //(qint64)
if (version<6) { // prior to version 6 is too old to deal with if (type!=filetype_data) {
qDebug() << "Old File Version";
//throw OldDBVersion();
//qWarning() << "Old dbversion "<< t16 << "summary file.. Sorry, you need to purge and reimport";
return false;
}
in >> t16; // File Type
if (t16!=filetype_data) {
qDebug() << "Wrong File Type in " << filename; qDebug() << "Wrong File Type in " << filename;
return false; return false;
} }
qint32 ts32; if (magicnum!=magic) {
in >> ts32; // MachineID qWarning() << "Wrong Magic number in " << filename;
if (ts32!=s_machine->id()) { return false;
qWarning() << "Machine ID does not match in" << filename << " I will try to load anyway in case you know what your doing.";
} }
in >> t32; // Sessionid if (version<6) { // prior to version 6 is too old to deal with
s_session=t32; qDebug() << "Old File Version, can't open file";
in >> s_first; return false;
in >> s_last; }
if (version<9) {
file.seek(32);
} else {
header >> compmethod; // Compression Method (quint16)
header >> machtype; // Machine Type (quint16)
header >> datasize; // Size of Uncompressed Data (quint32)
header >> crc16; // CRC16 of Uncompressed Data (quint16)
}
QByteArray databytes,temp=file.readAll();
file.close();
if (compmethod>0) {
databytes=qUncompress(temp);
} else {
databytes=temp;
}
if (databytes.size()!=datasize) {
qDebug() << "File" << filename << "has returned wrong datasize";
return false;
}
quint16 crc=qChecksum(databytes.data(),databytes.size());
if (crc!=crc16) {
qDebug() << "CRC Doesn't match in" << filename;
return false;
}
QDataStream in(databytes);
in.setVersion(QDataStream::Qt_4_6);
in.setByteOrder(QDataStream::LittleEndian);
qint16 mcsize; qint16 mcsize;
in >> mcsize; // number of Machine Code lists in >> mcsize; // number of Machine Code lists
@ -523,34 +593,39 @@ bool Session::LoadEvents(QString filename)
size2=sizevec[i]; size2=sizevec[i];
for (int j=0;j<size2;j++) { for (int j=0;j<size2;j++) {
EventList &evec=*eventlist[code][j]; EventList &evec=*eventlist[code][j];
evec.m_data.reserve(evec.m_count); evec.m_data.resize(evec.m_count);
for (quint32 c=0;c<evec.m_count;c++) { EventStoreType *ptr=evec.m_data.data();
in >> t;
evec.m_data.push_back(t); in.readRawData((char *)ptr, evec.m_count << 1);
} // for (quint32 c=0;c<evec.m_count;c++) {
// in >> t;
// *ptr++=t;
// }
if (evec.hasSecondField()) { if (evec.hasSecondField()) {
evec.m_data2.reserve(evec.m_count); evec.m_data2.resize(evec.m_count);
for (quint32 c=0;c<evec.m_count;c++) { ptr=evec.m_data2.data();
in >> t;
evec.m_data2.push_back(t); in.readRawData((char *)ptr,evec.m_count << 1);
} // for (quint32 c=0;c<evec.m_count;c++) {
// in >> t;
// *ptr++=t;
// }
} }
//last=evec.first(); //last=evec.first();
if (evec.type()!=EVL_Waveform) { if (evec.type()!=EVL_Waveform) {
evec.m_time.reserve(evec.m_count); evec.m_time.resize(evec.m_count);
for (quint32 c=0;c<evec.m_count;c++) { quint32 * tptr=evec.m_time.data();
in >> x; in.readRawData((char *)tptr,evec.m_count << 2);
//last+=x; // for (quint32 c=0;c<evec.m_count;c++) {
evec.m_time.push_back(x); // in >> x;
//evec.m_time[c]=x; // *tptr++=x;
// }
} }
} }
} }
}
file.close();
if (version<events_version) { if (version<events_version) {
qDebug() << "Upgrading Events file to version" << events_version; qDebug() << "Upgrading Events file" << filename << "to version" << events_version;
UpdateSummaries(); UpdateSummaries();
StoreEvents(filename); StoreEvents(filename);
} }
@ -619,7 +694,7 @@ void Session::UpdateSummaries()
EventDataType gain=el->gain(); EventDataType gain=el->gain();
m_gain[id]=gain; m_gain[id]=gain;
} }
if (!((id==CPAP_FlowRate) || (id==CPAP_MaskPressure))) if (!((id==CPAP_FlowRate) || (id==CPAP_MaskPressureHi) || (id==CPAP_RespEvent) || (id==CPAP_MaskPressure)))
updateCountSummary(id); updateCountSummary(id);
Min(id); Min(id);
@ -627,7 +702,8 @@ void Session::UpdateSummaries()
count(id); count(id);
last(id); last(id);
first(id); first(id);
if ((id==CPAP_FlowRate) || (id==CPAP_MaskPressure)) continue; if (((id==CPAP_FlowRate) || (id==CPAP_MaskPressureHi) || (id==CPAP_RespEvent) || (id==CPAP_MaskPressure)))
continue;
cph(id); cph(id);
sph(id); sph(id);
@ -1183,6 +1259,7 @@ EventList * Session::AddEventList(ChannelID code, EventListType et,EventDataType
//return NULL; //return NULL;
} }
EventList * el=new EventList(et,gain,offset,min,max,rate,second_field); EventList * el=new EventList(et,gain,offset,min,max,rate,second_field);
eventlist[code].push_back(el); eventlist[code].push_back(el);
//s_machine->registerChannel(chan); //s_machine->registerChannel(chan);
return el; return el;

19
daily.cpp
View File

@ -423,15 +423,17 @@ void Daily::ReloadGraphs()
{ {
ui->splitter->setVisible(true); ui->splitter->setVisible(true);
QDate d; QDate d;
if (previous_date.isValid()) { if (previous_date.isValid()) {
d=previous_date; d=previous_date;
Unload(d); // Unload(d);
} //else }
d=PROFILE.LastDay(); d=PROFILE.LastDay();
if (!d.isValid()) { if (!d.isValid()) {
d=ui->calendar->selectedDate(); d=ui->calendar->selectedDate();
} }
on_calendar_currentPageChanged(d.year(),d.month()); on_calendar_currentPageChanged(d.year(),d.month());
// this fires a signal which unloads the old and loads the new
ui->calendar->setSelectedDate(d); ui->calendar->setSelectedDate(d);
//Load(d); //Load(d);
} }
@ -582,15 +584,21 @@ void Daily::LoadDate(QDate date)
void Daily::on_calendar_selectionChanged() void Daily::on_calendar_selectionChanged()
{ {
this->setCursor(Qt::BusyCursor); QTime time;
time_t unload_time, load_time, other_time;
time.start();
this->setCursor(Qt::BusyCursor);
if (previous_date.isValid()) { if (previous_date.isValid()) {
// GraphView->fadeOut(); // GraphView->fadeOut();
Unload(previous_date); Unload(previous_date);
} }
unload_time=time.restart();
//bool fadedir=previous_date < ui->calendar->selectedDate(); //bool fadedir=previous_date < ui->calendar->selectedDate();
ZombieMeterMoved=false; ZombieMeterMoved=false;
Load(ui->calendar->selectedDate()); Load(ui->calendar->selectedDate());
load_time=time.restart();
//GraphView->fadeIn(fadedir); //GraphView->fadeIn(fadedir);
GraphView->redraw(); GraphView->redraw();
ui->calButton->setText(ui->calendar->selectedDate().toString(Qt::TextDate)); ui->calButton->setText(ui->calendar->selectedDate().toString(Qt::TextDate));
@ -607,6 +615,9 @@ void Daily::on_calendar_selectionChanged()
ui->weightSpinBox->setSuffix(STR_UNIT_KG); ui->weightSpinBox->setSuffix(STR_UNIT_KG);
} }
this->setCursor(Qt::ArrowCursor); this->setCursor(Qt::ArrowCursor);
other_time=time.restart();
qDebug() << "Page change time (in ms): Unload ="<<unload_time<<"Load =" << load_time << "Other =" << other_time;
} }
void Daily::ResetGraphLayout() void Daily::ResetGraphLayout()
{ {
@ -760,7 +771,7 @@ void Daily::Load(QDate date)
if (cpap->machine->properties.find(STR_PROP_SubModel)!=cpap->machine->properties.end()) if (cpap->machine->properties.find(STR_PROP_SubModel)!=cpap->machine->properties.end())
submodel=" <br/>"+cpap->machine->properties[STR_PROP_SubModel]; submodel=" <br/>"+cpap->machine->properties[STR_PROP_SubModel];
html+="<tr><td colspan=4 align=center><b>"+cpap->machine->properties[STR_PROP_Brand]+"</b> <br>"+cpap->machine->properties[STR_PROP_Model]+" "+cpap->machine->properties[STR_PROP_ModelNumber]+submodel+"</td></tr>\n"; html+="<tr><td colspan=4 align=center><b>"+cpap->machine->properties[STR_PROP_Brand]+"</b> <br>"+cpap->machine->properties[STR_PROP_Model]+" "+cpap->machine->properties[STR_PROP_ModelNumber]+submodel+"</td></tr>\n";
if (PROFILE.session->showSerialNumbers()) { if (PROFILE.general->showSerialNumbers()) {
html+="<tr><td colspan=4 align=center>"+cpap->machine->properties[STR_PROP_Serial]+"</td></tr>\n"; html+="<tr><td colspan=4 align=center>"+cpap->machine->properties[STR_PROP_Serial]+"</td></tr>\n";
} }
CPAPMode mode=(CPAPMode)(int)cpap->settings_max(CPAP_Mode); CPAPMode mode=(CPAPMode)(int)cpap->settings_max(CPAP_Mode);

8
mainwindow.cpp
View File

@ -560,7 +560,7 @@ void MainWindow::on_summaryButton_clicked()
if (mach.size()==0) { if (mach.size()==0) {
html+="<table cellpadding=2 cellspacing=0 border=0 width=100% height=70%>"; html+="<table cellpadding=2 cellspacing=0 border=0 width=100% height=70%>";
html+="<tr><td align=center><h1>Please Import Some Data</h1><br/><i>SleepyHead is pretty much useless without it.</i></td></tr></table>"; html+="<tr><td align=center><h1>Please Import Some Data</h1><br/><i>SleepyHead is pretty much useless without it.</i><br/>First import can take a few minutes.</td></tr></table>";
html+=htmlFooter(); html+=htmlFooter();
ui->summaryView->setHtml(html); ui->summaryView->setHtml(html);
return; return;
@ -813,7 +813,6 @@ void MainWindow::on_summaryButton_clicked()
QDate date=lastcpap; QDate date=lastcpap;
Day * day; Day * day;
bool lastchanged=false; bool lastchanged=false;
int cnt=0;
QVector<RXChange> rxchange; QVector<RXChange> rxchange;
do { do {
day=PROFILE.GetGoodDay(date,MT_CPAP); day=PROFILE.GetGoodDay(date,MT_CPAP);
@ -1531,7 +1530,7 @@ void MainWindow::PrintReport(gGraphView *gv,QString name, QDate date)
return; return;
} }
QString username=PROFILE.Get(QString("_{")+QString(UI_STR_UserName)+"}_"); QString username=PROFILE.Get(QString("_{")+QString(STR_UI_UserName)+"}_");
bool print_bookmarks=false; bool print_bookmarks=false;
if (name==STR_TR_Daily) { if (name==STR_TR_Daily) {
@ -1823,7 +1822,7 @@ void MainWindow::PrintReport(gGraphView *gv,QString name, QDate date)
if (name==STR_TR_Daily) { if (name==STR_TR_Daily) {
if (!print_bookmarks) { if (!print_bookmarks) {
for (int i=0;i<gv->size();i++) { for (int i=0;i<gv->size();i++) {
gGraph *g=(*gv)[i]; g=(*gv)[i];
if (g->isEmpty()) continue; if (g->isEmpty()) continue;
if (!g->visible()) continue; if (!g->visible()) continue;
@ -2251,6 +2250,7 @@ void MainWindow::on_actionAll_Data_for_current_CPAP_machine_triggered()
void MainWindow::keyPressEvent(QKeyEvent * event) void MainWindow::keyPressEvent(QKeyEvent * event)
{ {
Q_UNUSED(event)
//qDebug() << "Keypress:" << event->key(); //qDebug() << "Keypress:" << event->key();
} }

4
newprofile.cpp
View File

@ -140,7 +140,7 @@ void NewProfile::on_nextButton_clicked()
} }
} else { } else {
prof.Erase(UI_STR_Password); prof.Erase(STR_UI_Password);
} }
profile->user->setGender((Gender)ui->genderCombo->currentIndex()); profile->user->setGender((Gender)ui->genderCombo->currentIndex());
@ -246,7 +246,7 @@ void NewProfile::edit(const QString name)
ui->userNameEdit->setReadOnly(true); ui->userNameEdit->setReadOnly(true);
ui->firstNameEdit->setText(profile->user->firstName()); ui->firstNameEdit->setText(profile->user->firstName());
ui->lastNameEdit->setText(profile->user->lastName()); ui->lastNameEdit->setText(profile->user->lastName());
if (profile->contains(UI_STR_Password) && !profile->p_preferences[UI_STR_Password].toString().isEmpty()) { if (profile->contains(STR_UI_Password) && !profile->p_preferences[STR_UI_Password].toString().isEmpty()) {
// leave the password box blank.. // leave the password box blank..
QString a="******"; QString a="******";
ui->passwordEdit1->setText(a); ui->passwordEdit1->setText(a);

4
overview.cpp
View File

@ -430,7 +430,7 @@ void Overview::ResetGraphLayout()
} }
void Overview::on_printDailyButton_clicked() /*void Overview::on_printDailyButton_clicked()
{ {
qint64 st,et; qint64 st,et;
GraphView->GetXBounds(st,et); GraphView->GetXBounds(st,et);
@ -460,7 +460,7 @@ void Overview::on_printDailyButton_clicked()
} else mainwin->Notify("If this was implemented yet, You'd be able to print multiple daily reports right now."); } else mainwin->Notify("If this was implemented yet, You'd be able to print multiple daily reports right now.");
} }*/
void Overview::on_rangeCombo_activated(int index) void Overview::on_rangeCombo_activated(int index)
{ {

2
overview.h
View File

@ -94,7 +94,7 @@ private slots:
//! \brief Resets view to currently shown start & end dates //! \brief Resets view to currently shown start & end dates
void on_toolButton_clicked(); void on_toolButton_clicked();
void on_printDailyButton_clicked(); //void on_printDailyButton_clicked();
void on_rangeCombo_activated(int index); void on_rangeCombo_activated(int index);

22
overview.ui
View File

@ -42,13 +42,13 @@
<number>4</number> <number>4</number>
</property> </property>
<property name="leftMargin"> <property name="leftMargin">
<number>9</number> <number>4</number>
</property> </property>
<property name="topMargin"> <property name="topMargin">
<number>0</number> <number>0</number>
</property> </property>
<property name="rightMargin"> <property name="rightMargin">
<number>9</number> <number>4</number>
</property> </property>
<property name="bottomMargin"> <property name="bottomMargin">
<number>0</number> <number>0</number>
@ -62,6 +62,12 @@
</item> </item>
<item> <item>
<widget class="QComboBox" name="rangeCombo"> <widget class="QComboBox" name="rangeCombo">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<item> <item>
<property name="text"> <property name="text">
<string>Last Week</string> <string>Last Week</string>
@ -118,6 +124,12 @@
</item> </item>
<item> <item>
<widget class="QDateEdit" name="dateStart"> <widget class="QDateEdit" name="dateStart">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="calendarPopup"> <property name="calendarPopup">
<bool>true</bool> <bool>true</bool>
</property> </property>
@ -135,6 +147,12 @@
</item> </item>
<item> <item>
<widget class="QDateEdit" name="dateEnd"> <widget class="QDateEdit" name="dateEnd">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="calendarPopup"> <property name="calendarPopup">
<bool>true</bool> <bool>true</bool>
</property> </property>

32
preferencesdialog.cpp
View File

@ -168,6 +168,12 @@ PreferencesDialog::PreferencesDialog(QWidget *parent,Profile * _profile) :
ui->complianceGroupbox->setChecked(profile->cpap->showComplianceInfo()); ui->complianceGroupbox->setChecked(profile->cpap->showComplianceInfo());
ui->complianceHours->setValue(profile->cpap->complianceHours()); ui->complianceHours->setValue(profile->cpap->complianceHours());
bool bcd=profile->session->backupCardData();
ui->createSDBackups->setChecked(bcd);
ui->compressSDBackups->setEnabled(bcd);
ui->compressSDBackups->setChecked(profile->session->compressBackupData());
ui->compressSessionData->setChecked(profile->session->compressSessionData());
ui->graphHeight->setValue(profile->appearance->graphHeight()); ui->graphHeight->setValue(profile->appearance->graphHeight());
if (!PREF.contains(STR_GEN_UpdatesAutoCheck)) PREF[STR_GEN_UpdatesAutoCheck]=true; if (!PREF.contains(STR_GEN_UpdatesAutoCheck)) PREF[STR_GEN_UpdatesAutoCheck]=true;
@ -288,14 +294,16 @@ void PreferencesDialog::Save()
if ((profile->session->daySplitTime()!=ui->timeEdit->time()) || if ((profile->session->daySplitTime()!=ui->timeEdit->time()) ||
(profile->session->combineCloseSessions()!=ui->combineSlider->value()) || (profile->session->combineCloseSessions()!=ui->combineSlider->value()) ||
(profile->session->ignoreShortSessions()!=ui->IgnoreSlider->value())) { (profile->session->ignoreShortSessions()!=ui->IgnoreSlider->value())) {
profile->session->setTrashDayCache(true);
needs_restart=true; needs_restart=true;
} else profile->session->setTrashDayCache(false); }
if (profile->general->calculateRDI() != ui->AddRERAtoAHI->isChecked()) { if (profile->general->calculateRDI() != ui->AddRERAtoAHI->isChecked()) {
profile->general->setCalculateRDI(ui->AddRERAtoAHI->isChecked()); profile->general->setCalculateRDI(ui->AddRERAtoAHI->isChecked());
needs_restart=true; needs_restart=true;
} }
profile->session->setBackupCardData(ui->createSDBackups->isChecked());
profile->session->setCompressBackupData(ui->compressSDBackups->isChecked());
profile->session->setCompressSessionData(ui->compressSessionData->isChecked());
profile->session->setCombineCloseSessions(ui->combineSlider->value()); profile->session->setCombineCloseSessions(ui->combineSlider->value());
profile->session->setIgnoreShortSessions(ui->IgnoreSlider->value()); profile->session->setIgnoreShortSessions(ui->IgnoreSlider->value());
@ -712,3 +720,23 @@ void PreferencesDialog::on_maskTypeCombo_activated(int index)
} }
} }
} }
void PreferencesDialog::on_createSDBackups_toggled(bool checked)
{
if (profile->session->backupCardData() && !checked) {
QList<Machine *> mach=PROFILE.GetMachines(MT_CPAP);
bool haveS9=false;
for (int i=0;i<mach.size();i++) {
if (mach[i]->GetClass()==STR_MACH_ResMed) {
haveS9=true;
break;
}
}
if (haveS9 && QMessageBox::question(this,"This may not be a good idea","ResMed S9 machines routinely delete certain data from your SD card older than 7 and 30 days (depending on resolution). If you ever need to reimport this data again (whether in SleepyHead or ResScan) this data won't come back. If you need to conserve disk space, please remember to carry out manual backups. Are you sure you want to disable these backups?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::No) {
ui->createSDBackups->setChecked(true);
return;
}
}
if (!checked) ui->compressSDBackups->setChecked(false);
ui->compressSDBackups->setEnabled(checked);
}

2
preferencesdialog.h
View File

@ -87,6 +87,8 @@ private slots:
void on_maskTypeCombo_activated(int index); void on_maskTypeCombo_activated(int index);
void on_createSDBackups_toggled(bool checked);
private: private:
//! \brief Populates the Graph Model view with data from the Daily, Overview & Oximetry gGraphView objects //! \brief Populates the Graph Model view with data from the Daily, Overview & Oximetry gGraphView objects
void resetGraphModel(); void resetGraphModel();

800
preferencesdialog.ui
View File

@ -42,7 +42,7 @@
<item> <item>
<widget class="QTabWidget" name="tabWidget"> <widget class="QTabWidget" name="tabWidget">
<property name="currentIndex"> <property name="currentIndex">
<number>6</number> <number>0</number>
</property> </property>
<widget class="QWidget" name="importTab"> <widget class="QWidget" name="importTab">
<attribute name="title"> <attribute name="title">
@ -50,10 +50,10 @@
</attribute> </attribute>
<layout class="QVBoxLayout" name="verticalLayout_5"> <layout class="QVBoxLayout" name="verticalLayout_5">
<property name="spacing"> <property name="spacing">
<number>6</number> <number>4</number>
</property> </property>
<property name="margin"> <property name="margin">
<number>5</number> <number>4</number>
</property> </property>
<item> <item>
<widget class="QGroupBox" name="groupBox_6"> <widget class="QGroupBox" name="groupBox_6">
@ -62,7 +62,7 @@
</property> </property>
<layout class="QVBoxLayout" name="verticalLayout_10"> <layout class="QVBoxLayout" name="verticalLayout_10">
<property name="spacing"> <property name="spacing">
<number>0</number> <number>4</number>
</property> </property>
<property name="leftMargin"> <property name="leftMargin">
<number>0</number> <number>0</number>
@ -258,6 +258,16 @@ p, li { white-space: pre-wrap; }
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="QCheckBox" name="cacheSessionData">
<property name="toolTip">
<string>Keep session data in memory to speed up revisiting days.</string>
</property>
<property name="text">
<string>Cache Session Data (uses more system memory)</string>
</property>
</widget>
</item>
<item> <item>
<spacer name="horizontalSpacer"> <spacer name="horizontalSpacer">
<property name="orientation"> <property name="orientation">
@ -277,198 +287,73 @@ p, li { white-space: pre-wrap; }
</widget> </widget>
</item> </item>
<item> <item>
<widget class="QGroupBox" name="customEventGroupbox"> <widget class="QGroupBox" name="groupBox_7">
<property name="title"> <property name="title">
<string>Custom Event Flagging</string> <string>Session Storage Options</string>
</property> </property>
<property name="checkable"> <layout class="QGridLayout" name="gridLayout_9">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_6">
<property name="leftMargin"> <property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>4</number> <number>4</number>
</property> </property>
<property name="topMargin">
<number>9</number>
</property>
<property name="rightMargin"> <property name="rightMargin">
<number>0</number> <number>4</number>
</property> </property>
<property name="bottomMargin"> <property name="bottomMargin">
<number>0</number> <number>4</number>
</property> </property>
<property name="spacing"> <property name="spacing">
<number>4</number> <number>4</number>
</property> </property>
<item row="1" column="2">
<widget class="QDoubleSpinBox" name="apneaDuration">
<property name="suffix">
<string>s</string>
</property>
<property name="minimum">
<double>1.000000000000000</double>
</property>
<property name="value">
<double>10.000000000000000</double>
</property>
</widget>
</item>
<item row="1" column="4">
<widget class="QDoubleSpinBox" name="apneaFlowRestriction">
<property name="suffix">
<string>%</string>
</property>
<property name="value">
<double>10.000000000000000</double>
</property>
</widget>
</item>
<item row="1" column="0"> <item row="1" column="0">
<widget class="QLabel" name="label_34"> <widget class="QCheckBox" name="createSDBackups">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text"> <property name="text">
<string>Apnea</string> <string>Create SD Card Backups during Import (especially important for ResMed users)</string>
</property> </property>
</widget> </widget>
</item> </item>
<item row="0" column="2"> <item row="3" column="0">
<widget class="QLabel" name="label_38"> <widget class="QCheckBox" name="compressSessionData">
<property name="text"> <property name="text">
<string>Duration</string> <string>Compress Session Data (slower, but makes SleepyHead data smaller)</string>
</property>
</widget>
</item>
<item row="0" column="4">
<widget class="QLabel" name="label_35">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Flow Restriction</string>
</property>
</widget>
</item>
<item row="1" column="5">
<spacer name="horizontalSpacer_4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="2" column="4">
<widget class="QDoubleSpinBox" name="hypopneaFlowRestriction">
<property name="suffix">
<string>%</string>
</property>
<property name="value">
<double>40.000000000000000</double>
</property>
</widget>
</item>
<item row="2" column="2">
<widget class="QDoubleSpinBox" name="hypopneaDuration">
<property name="suffix">
<string>s</string>
</property>
<property name="value">
<double>10.000000000000000</double>
</property> </property>
</widget> </widget>
</item> </item>
<item row="2" column="0"> <item row="2" column="0">
<widget class="QLabel" name="label_37"> <widget class="QCheckBox" name="compressSDBackups">
<property name="text"> <property name="text">
<string>Hypopnea</string> <string>Compress SD Card Backups (slower, but makes backups smaller)</string>
</property> </property>
</widget> </widget>
</item> </item>
</layout> <item row="0" column="0">
</widget> <widget class="QLabel" name="label_32">
</item> <property name="font">
<item> <font>
<widget class="QGroupBox" name="ahiGraphGroupbox"> <italic>true</italic>
<property name="title"> </font>
<string>AHI/Hour Graph Settings</string>
</property> </property>
<property name="checkable"> <property name="text">
<string>The following options affect the amount of disk space SleepyHead uses, and all have an effect on how long import takes. This will only really be noticeable on first import.</string>
</property>
<property name="wordWrap">
<bool>true</bool> <bool>true</bool>
</property> </property>
<layout class="QGridLayout" name="gridLayout_8"> </widget>
<property name="leftMargin"> </item>
<number>0</number> <item row="4" column="0">
</property> <widget class="QLabel" name="label_41">
<property name="topMargin">
<number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<property name="horizontalSpacing">
<number>4</number>
</property>
<property name="verticalSpacing">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="label_36">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text"> <property name="text">
<string>Window Size</string> <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
p, li { white-space: pre-wrap; }
&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Sans'; font-size:10pt; font-weight:400; font-style:normal;&quot;&gt;
&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Note: &lt;span style=&quot; font-style:italic;&quot;&gt;Compression options don't automatically recompress already saved data.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
</property> </property>
</widget> </widget>
</item> </item>
<item row="0" column="1">
<widget class="QSpinBox" name="ahiGraphWindowSize">
<property name="suffix">
<string> minutes</string>
</property>
<property name="value">
<number>60</number>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QCheckBox" name="ahiGraphZeroReset">
<property name="text">
<string>Reset to zero after each window</string>
</property>
</widget>
</item>
<item row="0" column="3">
<spacer name="horizontalSpacer_6">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout> </layout>
</widget> </widget>
</item> </item>
@ -487,112 +372,17 @@ p, li { white-space: pre-wrap; }
</item> </item>
</layout> </layout>
</widget> </widget>
<widget class="QWidget" name="tabOther"> <widget class="QWidget" name="tabCPAP">
<attribute name="title"> <attribute name="title">
<string>Other</string> <string>&amp;CPAP</string>
</attribute> </attribute>
<layout class="QVBoxLayout" name="verticalLayout_13"> <layout class="QHBoxLayout" name="horizontalLayout_15">
<property name="spacing"> <property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>4</number> <number>4</number>
</property> </property>
<property name="topMargin"> <property name="margin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>4</number> <number>4</number>
</property> </property>
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
<string>Import Locations</string>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_10">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QListView" name="importListWidget">
<property name="editTriggers">
<set>QAbstractItemView::NoEditTriggers</set>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QPushButton" name="addImportLocation">
<property name="text">
<string>Add</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="removeImportLocation">
<property name="text">
<string>Remove</string>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer_5">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="maskTab">
<attribute name="title">
<string>&amp;Mask</string>
</attribute>
<layout class="QHBoxLayout" name="horizontalLayout_14">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>2</number>
</property>
<property name="topMargin">
<number>2</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>2</number>
</property>
<item> <item>
<widget class="QGroupBox" name="groupBox_5"> <widget class="QGroupBox" name="groupBox_5">
<property name="sizePolicy"> <property name="sizePolicy">
@ -771,53 +561,258 @@ p, li { white-space: pre-wrap; }
</widget> </widget>
</item> </item>
<item> <item>
<widget class="QGroupBox" name="groupBox_7"> <widget class="Line" name="line">
<property name="title"> <property name="orientation">
<string/> <enum>Qt::Vertical</enum>
</property> </property>
<layout class="QVBoxLayout" name="verticalLayout_6"> </widget>
<property name="leftMargin"> </item>
<number>0</number> <item>
</property> <layout class="QVBoxLayout" name="verticalLayout_13">
<property name="topMargin"> <property name="spacing">
<number>2</number> <number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property> </property>
<item> <item>
<widget class="QLabel" name="label_32"> <widget class="QCheckBox" name="AddRERAtoAHI">
<property name="frameShape"> <property name="font">
<enum>QFrame::StyledPanel</enum> <font>
<weight>75</weight>
<bold>true</bold>
</font>
</property> </property>
<property name="text"> <property name="text">
<string>Hmmm... Empty Space <string>Use RDI instead of AHI (PRS1 only)</string>
Mask History could go here one day
For now a reminder for PRS1 Users
The lower leak does not yet show unintentional
leaks. It currently showns the leak line
subtracted from the 0% percentile
(aka the minimum value)
&lt;--- None of this data is being used yet!
To solve this properly requires some fairly
complex forumulae derived from the
Mask Leak Profiles
(Believe it or not, I am not a maths geek)</string>
</property> </property>
<property name="alignment"> </widget>
<set>Qt::AlignCenter</set> </item>
<item>
<widget class="QGroupBox" name="complianceGroupbox">
<property name="title">
<string>Show Compliance</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_7">
<property name="margin">
<number>4</number>
</property>
<property name="spacing">
<number>4</number>
</property>
<item row="0" column="1">
<widget class="QDoubleSpinBox" name="complianceHours">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="toolTip">
<string>Regard days with under this usage as &quot;incompliant&quot;.</string>
</property>
<property name="suffix">
<string> hours</string>
</property>
<property name="decimals">
<number>1</number>
</property>
<property name="maximum">
<double>8.000000000000000</double>
</property>
<property name="value">
<double>4.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_39">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>as over</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="label_40">
<property name="text">
<string>of usage per night</string>
</property> </property>
</widget> </widget>
</item> </item>
</layout> </layout>
</widget> </widget>
</item> </item>
<item>
<widget class="QGroupBox" name="customEventGroupbox">
<property name="title">
<string>Custom Event Flagging</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_6">
<item row="0" column="1">
<widget class="QLabel" name="label_38">
<property name="text">
<string>Duration</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="label_35">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Flow Restriction</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_34">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Apnea</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QDoubleSpinBox" name="apneaDuration">
<property name="suffix">
<string>s</string>
</property>
<property name="minimum">
<double>1.000000000000000</double>
</property>
<property name="value">
<double>10.000000000000000</double>
</property>
</widget>
</item>
<item row="1" column="2">
<widget class="QDoubleSpinBox" name="apneaFlowRestriction">
<property name="suffix">
<string>%</string>
</property>
<property name="value">
<double>10.000000000000000</double>
</property>
</widget>
</item>
<item row="1" column="3">
<spacer name="horizontalSpacer_4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_37">
<property name="text">
<string>Hypopnea</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QDoubleSpinBox" name="hypopneaDuration">
<property name="suffix">
<string>s</string>
</property>
<property name="value">
<double>10.000000000000000</double>
</property>
</widget>
</item>
<item row="2" column="2">
<widget class="QDoubleSpinBox" name="hypopneaFlowRestriction">
<property name="suffix">
<string>%</string>
</property>
<property name="value">
<double>40.000000000000000</double>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="ahiGraphGroupbox">
<property name="title">
<string>AHI/Hour Graph Settings</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_8">
<item row="0" column="0">
<widget class="QLabel" name="label_36">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Window</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSpinBox" name="ahiGraphWindowSize">
<property name="suffix">
<string> minutes</string>
</property>
<property name="value">
<number>60</number>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QCheckBox" name="ahiGraphZeroReset">
<property name="text">
<string>Zero Reset</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer_7">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
</layout> </layout>
</widget> </widget>
<widget class="QWidget" name="colourTab"> <widget class="QWidget" name="colourTab">
@ -825,10 +820,25 @@ Mask Leak Profiles
<string>&amp;Events</string> <string>&amp;Events</string>
</attribute> </attribute>
<layout class="QVBoxLayout" name="verticalLayout_3"> <layout class="QVBoxLayout" name="verticalLayout_3">
<property name="spacing">
<number>4</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item> <item>
<widget class="QLabel" name="label_6"> <widget class="QLabel" name="label_6">
<property name="text"> <property name="text">
<string>This doesn't save yet...</string> <string>Not entirely sure if this will get to live or not..</string>
</property> </property>
</widget> </widget>
</item> </item>
@ -926,7 +936,7 @@ Mask Leak Profiles
<item> <item>
<widget class="QLabel" name="label_9"> <widget class="QLabel" name="label_9">
<property name="text"> <property name="text">
<string>Please Note: Graph visibility also depends on machine availability.</string> <string>Double click on the (Y-axis) min/max values to edit them</string>
</property> </property>
</widget> </widget>
</item> </item>
@ -940,6 +950,9 @@ Mask Leak Profiles
<string>&amp;Oximetry</string> <string>&amp;Oximetry</string>
</attribute> </attribute>
<layout class="QHBoxLayout" name="horizontalLayout_12"> <layout class="QHBoxLayout" name="horizontalLayout_12">
<property name="spacing">
<number>4</number>
</property>
<property name="margin"> <property name="margin">
<number>2</number> <number>2</number>
</property> </property>
@ -1169,6 +1182,12 @@ p, li { white-space: pre-wrap; }
<string>&amp;General</string> <string>&amp;General</string>
</attribute> </attribute>
<layout class="QVBoxLayout" name="verticalLayout_7"> <layout class="QVBoxLayout" name="verticalLayout_7">
<property name="spacing">
<number>4</number>
</property>
<property name="margin">
<number>4</number>
</property>
<item> <item>
<widget class="QGroupBox" name="groupBox_2"> <widget class="QGroupBox" name="groupBox_2">
<property name="title"> <property name="title">
@ -1181,7 +1200,7 @@ p, li { white-space: pre-wrap; }
<property name="spacing"> <property name="spacing">
<number>4</number> <number>4</number>
</property> </property>
<item row="0" column="0"> <item row="1" column="0">
<widget class="QCheckBox" name="skipLoginScreen"> <widget class="QCheckBox" name="skipLoginScreen">
<property name="toolTip"> <property name="toolTip">
<string>Bypass the login screen and load the most recent User Profile</string> <string>Bypass the login screen and load the most recent User Profile</string>
@ -1191,115 +1210,20 @@ p, li { white-space: pre-wrap; }
</property> </property>
</widget> </widget>
</item> </item>
<item row="1" column="0"> <item row="5" column="0">
<widget class="QCheckBox" name="enableMultithreading">
<property name="toolTip">
<string>Allow use of multiple CPU cores where available to improve performance. May cause problems.</string>
</property>
<property name="text">
<string>Enable Multithreading</string>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QCheckBox" name="skipEmptyDays"> <widget class="QCheckBox" name="skipEmptyDays">
<property name="text"> <property name="text">
<string>Skip over Empty Days</string> <string>Skip over Empty Days</string>
</property> </property>
</widget> </widget>
</item> </item>
<item row="0" column="1">
<widget class="QCheckBox" name="cacheSessionData">
<property name="toolTip">
<string>Keep session data in memory to speed up revisiting days.</string>
</property>
<property name="text">
<string>Cache Session Data</string>
</property>
</widget>
</item>
<item row="1" column="1"> <item row="1" column="1">
<widget class="QCheckBox" name="enableGraphSnapshots"> <widget class="QCheckBox" name="enableMultithreading">
<property name="toolTip"> <property name="toolTip">
<string>Allows graphs to be &quot;screenshotted&quot; for display purposes. <string>Allow use of multiple CPU cores where available to improve performance. May cause problems.</string>
The Event Breakdown PIE chart uses this method, as does
the printing code.
Unfortunately some older computers/versions of Qt can cause
this application to be unstable with this feature enabled.</string>
</property> </property>
<property name="text"> <property name="text">
<string>Enable event breakdown pie chart</string> <string>Enable Multithreading</string>
</property>
</widget>
</item>
<item row="4" column="1">
<widget class="QCheckBox" name="AddRERAtoAHI">
<property name="text">
<string>Use RDI instead of AHI (PRS1 only)</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="complianceGroupbox">
<property name="title">
<string>Show Compliance</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
<layout class="QGridLayout" name="gridLayout_7">
<property name="margin">
<number>4</number>
</property>
<property name="spacing">
<number>4</number>
</property>
<item row="0" column="1">
<widget class="QDoubleSpinBox" name="complianceHours">
<property name="toolTip">
<string>Regard days with under this usage as &quot;incompliant&quot;.</string>
</property>
<property name="suffix">
<string> hours</string>
</property>
<property name="decimals">
<number>1</number>
</property>
<property name="maximum">
<double>8.000000000000000</double>
</property>
<property name="value">
<double>4.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="3">
<spacer name="horizontalSpacer_7">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label_39">
<property name="text">
<string>Define compliance as over</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="label_40">
<property name="text">
<string>of usage per night</string>
</property> </property>
</widget> </widget>
</item> </item>
@ -1326,6 +1250,70 @@ this application to be unstable with this feature enabled.</string>
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="title">
<string>Import Locations</string>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_10">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>4</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QListView" name="importListWidget">
<property name="editTriggers">
<set>QAbstractItemView::NoEditTriggers</set>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="widget" native="true">
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QPushButton" name="addImportLocation">
<property name="text">
<string>Add</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="removeImportLocation">
<property name="text">
<string>Remove</string>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer_5">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</item>
<item> <item>
<widget class="QGroupBox" name="automaticallyCheckUpdates"> <widget class="QGroupBox" name="automaticallyCheckUpdates">
<property name="sizePolicy"> <property name="sizePolicy">
@ -1620,6 +1608,20 @@ this application to be unstable with this feature enabled.</string>
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="QCheckBox" name="enableGraphSnapshots">
<property name="toolTip">
<string>Allows graphs to be &quot;screenshotted&quot; for display purposes.
The Event Breakdown PIE chart uses this method, as does
the printing code.
Unfortunately some older computers/versions of Qt can cause
this application to be unstable with this feature enabled.</string>
</property>
<property name="text">
<string>Show event breakdown pie chart</string>
</property>
</widget>
</item>
<item> <item>
<widget class="QCheckBox" name="animationsAndTransitionsCheckbox"> <widget class="QCheckBox" name="animationsAndTransitionsCheckbox">
<property name="text"> <property name="text">