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

Disabled ResMed STR.edf summary import as it causes double up issues

Browse Source
This commit is contained in:
Mark Watkins 2012-04-05 13:14:02 +10:00
parent c7b66c5267
commit 94dc1c7f64
3 changed files with 434 additions and 416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
SleepLib/loader_plugins/prs1_loader.cpp
View File

@ -600,7 +600,6 @@ bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *b
int ncodes=sizeof(Codes)/sizeof(QString); int ncodes=sizeof(Codes)/sizeof(QString);
EventList * Code[0x20]={NULL}; EventList * Code[0x20]={NULL};
EventList * OA=session->AddEventList(CPAP_Obstructive, EVL_Event); EventList * OA=session->AddEventList(CPAP_Obstructive, EVL_Event);
EventList * HY=session->AddEventList(CPAP_Hypopnea, EVL_Event); EventList * HY=session->AddEventList(CPAP_Hypopnea, EVL_Event);
EventList * CSR=session->AddEventList(CPAP_CSR, EVL_Event); EventList * CSR=session->AddEventList(CPAP_CSR, EVL_Event);
@ -635,11 +634,23 @@ bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *b
short delta;//,duration; short delta;//,duration;
QDateTime d; QDateTime d;
bool badcode=false; bool badcode=false;
unsigned char lastcode3=0,lastcode2=0,lastcode=0,code=0;
int lastpos=0,startpos=0,lastpos2=0,lastpos3=0;
while (pos<size) { while (pos<size) {
unsigned char code=buffer[pos++]; lastcode3=lastcode2;
lastcode2=lastcode;
lastcode=code;
lastpos3=lastpos2;
lastpos2=lastpos;
lastpos=startpos;
startpos=pos;
code=buffer[pos++];
if (code>=ncodes) { if (code>=ncodes) {
qDebug() << "Illegal PRS1 code " << hex << int(code) << " appeared at " << hex << pos; qDebug() << "Illegal PRS1 code " << hex << int(code) << " appeared at " << hex << startpos;
qDebug() << "1: (" << int(lastcode ) << lastpos << ")";
qDebug() << "2: (" << int(lastcode2) << lastpos2 <<")";
qDebug() << "3: (" << int(lastcode3) << lastpos3 <<")";
return false; return false;
} }
if (code==0) { if (code==0) {
@ -715,12 +726,15 @@ bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *b
tt-=qint64(data[0])*1000L; // Subtract Time Offset tt-=qint64(data[0])*1000L; // Subtract Time Offset
HY->AddEvent(tt,data[0]); HY->AddEvent(tt,data[0]);
break; break;
case 0x08: // ASV Codes case 0x08: // ???
data[0]=buffer[pos++]; data[0]=buffer[pos++];
tt-=qint64(data[0])*1000L; // Subtract Time Offset tt-=qint64(data[0])*1000L; // Subtract Time Offset
if (!Code[10]) { if (!Code[10]) {
if (!(Code[10]=session->AddEventList(cpapcode,EVL_Event))) return false; if (!(Code[10]=session->AddEventList(cpapcode,EVL_Event))) return false;
} }
//????
//data[1]=buffer[pos++]; // ???
Code[10]->AddEvent(tt,data[0]); Code[10]->AddEvent(tt,data[0]);
break; break;
case 0x09: // ASV Codes case 0x09: // ASV Codes
@ -1211,7 +1225,9 @@ bool PRS1Loader::OpenFile(Machine *mach, QString filename)
ParseSummary(mach,sequence,timestamp,data,datasize,version); ParseSummary(mach,sequence,timestamp,data,datasize,version);
} else if (ext==2) { } else if (ext==2) {
if (version==5) { if (version==5) {
Parse002v5(sequence,timestamp,data,datasize); if (!Parse002v5(sequence,timestamp,data,datasize)) {
qDebug() << "in file: " << filename;
}
} else { } else {
Parse002(sequence,timestamp,data,datasize); Parse002(sequence,timestamp,data,datasize);
} }

816
SleepLib/loader_plugins/resmed_loader.cpp
View File

@ -482,49 +482,49 @@ int ResmedLoader::Open(QString & path,Profile *profile)
qint16 o1[10],o2[10]; qint16 o1[10],o2[10];
time_t st,et; time_t st,et;
time_t time=stredf.startdate/1000L; // == 12pm on first day time_t time=stredf.startdate/1000L; // == 12pm on first day
for (int i=0;i<days;i++) { // for (int i=0;i<days;i++) {
EDFSignal *maskon=stredf.lookup["Mask On"]; // EDFSignal *maskon=stredf.lookup["Mask On"];
EDFSignal *maskoff=stredf.lookup["Mask Off"]; // EDFSignal *maskoff=stredf.lookup["Mask Off"];
int j=i*10; // int j=i*10;
// Counts for on and off don't line up, and I'm not sure why // // Counts for on and off don't line up, and I'm not sure why
// The extra 'off' always seems to start with a 1 at the beginning // // The extra 'off' always seems to start with a 1 at the beginning
// A signal it's carried over from the day before perhaps? (noon boundary) // // A signal it's carried over from the day before perhaps? (noon boundary)
int ckon=0,ckoff=0; // int ckon=0,ckoff=0;
for (int k=0;k<10;k++) { // for (int k=0;k<10;k++) {
on=maskon->data[j+k]; // on=maskon->data[j+k];
off=maskoff->data[j+k]; // off=maskoff->data[j+k];
o1[k]=on; // o1[k]=on;
o2[k]=off; // o2[k]=off;
if (on >= 0) ckon++; // if (on >= 0) ckon++;
if (off >= 0) ckoff++; // if (off >= 0) ckoff++;
} // }
// set to true if day starts with machine running // // set to true if day starts with machine running
int offset=ckoff-ckon; // int offset=ckoff-ckon;
dayfoo.push_back(offset>0); // dayfoo.push_back(offset>0);
st=0,et=0; // st=0,et=0;
time_t l,f; // time_t l,f;
// Find the Min & Max times for this day // // Find the Min & Max times for this day
for (int k=0;k<ckon;k++) { // for (int k=0;k<ckon;k++) {
on=o1[k]; // on=o1[k];
off=o2[k+offset]; // off=o2[k+offset];
f=time+on*60; // f=time+on*60;
l=time+off*60; // l=time+off*60;
daystarttimes[i].push_back(f); // daystarttimes[i].push_back(f);
dayendtimes[i].push_back(l); // dayendtimes[i].push_back(l);
if (!st || (st > f)) st=f; // if (!st || (st > f)) st=f;
if (!et || (et < l)) et=l; // if (!et || (et < l)) et=l;
} // }
strfirst.push_back(st); // strfirst.push_back(st);
strlast.push_back(et); // strlast.push_back(et);
strday.push_back(i); // strday.push_back(i);
dayused[i]=ckon; // dayused[i]=ckon;
time+=86400; // time+=86400;
} // }
// reset time to first day // reset time to first day
time=stredf.startdate/1000; time=stredf.startdate/1000;
@ -618,7 +618,7 @@ int ResmedLoader::Open(QString & path,Profile *profile)
sessfiles[sessionid].push_back(filename); sessfiles[sessionid].push_back(filename);
} }
if ((i%10) ==0) { if ((i % 10)==0) {
// 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));
QApplication::processEvents(); QApplication::processEvents();
@ -637,415 +637,415 @@ 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; int dn;
for (QMap<SessionID,QStringList>::iterator si=sessfiles.begin();si!=sessfiles.end();si++) { // for (QMap<SessionID,QStringList>::iterator si=sessfiles.begin();si!=sessfiles.end();si++) {
sessionid=si.key(); // sessionid=si.key();
// Earliest possible day number // // Earliest possible day number
int edn=((sessionid-time)/86400)-1; // int edn=((sessionid-time)/86400)-1;
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.
dn=-1; // dn=-1;
for (int j=edn;j<strfirst.size();j++){ // for (int j=edn;j<strfirst.size();j++){
st=strfirst.at(j); // st=strfirst.at(j);
if (sessionid>=st) { // if (sessionid>=st) {
et=strlast.at(j); // 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 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;
} // }
} // }
EDFSignal *sig; EDFSignal *sig;
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// 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 (dn=0;dn<days;dn++) { // for (dn=0;dn<days;dn++) {
// Skip days with loadable data. // // Skip days with loadable data.
if (!dayused[dn]) // if (!dayused[dn])
continue; // continue;
if (!daystarttimes.contains(dn)) // if (!daystarttimes.contains(dn))
continue; // continue;
sess=NULL; // sess=NULL;
int scnt=daystarttimes[dn].size(); // count of sessions for this day // int scnt=daystarttimes[dn].size(); // count of sessions for this day
// Create a new session for each mask on/off segment in a day // // Create a new session for each mask on/off segment in a day
// But only populate the last one with summary data. // // But only populate the last one with summary data.
for (int j=0;j<scnt;j++) { // 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
if (m->SessionExists(st)) // if (m->SessionExists(st))
continue; // continue;
et=dayendtimes[dn].at(j); // et=dayendtimes[dn].at(j);
// Create the 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;
if (sess) { // if (sess) {
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// CPAP Mode // // CPAP Mode
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
int mode; // int mode;
sig=stredf.lookupSignal(CPAP_Mode); // sig=stredf.lookupSignal(CPAP_Mode);
if (sig) { // if (sig) {
mode=sig->data[dn]; // mode=sig->data[dn];
} else mode=0; // } else mode=0;
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// EPR Settings // // EPR Settings
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
sess->settings[CPAP_PresReliefType]=PR_EPR; // sess->settings[CPAP_PresReliefType]=PR_EPR;
// Note: AutoSV machines don't have both fields // // Note: AutoSV machines don't have both fields
sig=stredf.lookupSignal(RMS9_EPR); // sig=stredf.lookupSignal(RMS9_EPR);
if (sig) { // if (sig) {
sess->settings[CPAP_PresReliefMode]=EventDataType(sig->data[dn])*sig->gain; // sess->settings[CPAP_PresReliefMode]=EventDataType(sig->data[dn])*sig->gain;
} // }
sig=stredf.lookupSignal(RMS9_EPRSet); // sig=stredf.lookupSignal(RMS9_EPRSet);
if (sig) { // if (sig) {
sess->settings[CPAP_PresReliefSet]=EventDataType(sig->data[dn])*sig->gain; // sess->settings[CPAP_PresReliefSet]=EventDataType(sig->data[dn])*sig->gain;
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Set Min & Max pressures depending on CPAP mode // // Set Min & Max pressures depending on CPAP mode
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
if (mode==0) { // if (mode==0) {
sess->settings[CPAP_Mode]=MODE_CPAP; // sess->settings[CPAP_Mode]=MODE_CPAP;
sig=stredf.lookupSignal(RMS9_SetPressure); // ?? What's meant by Set Pressure? // sig=stredf.lookupSignal(RMS9_SetPressure); // ?? What's meant by Set Pressure?
if (sig) { // if (sig) {
EventDataType pressure=sig->data[dn]*sig->gain; // EventDataType pressure=sig->data[dn]*sig->gain;
sess->settings[CPAP_Pressure]=pressure; // sess->settings[CPAP_Pressure]=pressure;
} // }
} else { // VPAP or Auto // } else { // VPAP or Auto
if (mode>5) { // if (mode>5) {
if (mode>=7) // if (mode>=7)
sess->settings[CPAP_Mode]=MODE_ASV; // sess->settings[CPAP_Mode]=MODE_ASV;
else // else
sess->settings[CPAP_Mode]=MODE_BIPAP; // sess->settings[CPAP_Mode]=MODE_BIPAP;
EventDataType tmp,epap=0,ipap=0; // EventDataType tmp,epap=0,ipap=0;
if ((sig=stredf.lookupName("EPAP"))) { // if ((sig=stredf.lookupName("EPAP"))) {
epap=sig->data[dn]*sig->gain; // epap=sig->data[dn]*sig->gain;
sess->settings[CPAP_EPAP]=epap; // sess->settings[CPAP_EPAP]=epap;
sess->setMin(CPAP_EPAP,epap); // sess->setMin(CPAP_EPAP,epap);
} // }
if ((sig=stredf.lookupName("IPAP"))) { // if ((sig=stredf.lookupName("IPAP"))) {
ipap=sig->data[dn]*sig->gain; // ipap=sig->data[dn]*sig->gain;
sess->settings[CPAP_IPAP]=ipap; // sess->settings[CPAP_IPAP]=ipap;
} // }
if ((sig=stredf.lookupName("PS"))) { // if ((sig=stredf.lookupName("PS"))) {
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
sess->settings[CPAP_PS]=tmp; // technically this is IPAP-EPAP // sess->settings[CPAP_PS]=tmp; // technically this is IPAP-EPAP
if (!ipap) { // if (!ipap) {
// not really possible. but anyway, just in case.. // // not really possible. but anyway, just in case..
sess->settings[CPAP_IPAP]=epap+tmp; // sess->settings[CPAP_IPAP]=epap+tmp;
} // }
} // }
if ((sig=stredf.lookupName("Min PS"))) { // if ((sig=stredf.lookupName("Min PS"))) {
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
sess->settings[CPAP_PSMin]=tmp; // sess->settings[CPAP_PSMin]=tmp;
sess->settings[CPAP_IPAPLo]=epap+tmp; // sess->settings[CPAP_IPAPLo]=epap+tmp;
sess->setMin(CPAP_IPAP,epap+tmp); // sess->setMin(CPAP_IPAP,epap+tmp);
} // }
if ((sig=stredf.lookupName("Max PS"))) { // if ((sig=stredf.lookupName("Max PS"))) {
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
sess->settings[CPAP_PSMax]=tmp; // sess->settings[CPAP_PSMax]=tmp;
sess->settings[CPAP_IPAPHi]=epap+tmp; // sess->settings[CPAP_IPAPHi]=epap+tmp;
} // }
if ((sig=stredf.lookupName("RR"))) { // Is this a setting to force respiratory rate on S/T machines? // if ((sig=stredf.lookupName("RR"))) { // Is this a setting to force respiratory rate on S/T machines?
tmp=sig->data[dn]; // tmp=sig->data[dn];
sess->settings[CPAP_RespRate]=tmp*sig->gain; // sess->settings[CPAP_RespRate]=tmp*sig->gain;
} // }
if ((sig=stredf.lookupName("Easy-Breathe"))) { // if ((sig=stredf.lookupName("Easy-Breathe"))) {
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
sess->settings[CPAP_PresReliefSet]=tmp; // sess->settings[CPAP_PresReliefSet]=tmp;
sess->settings[CPAP_PresReliefType]=(int)PR_EASYBREATHE; // sess->settings[CPAP_PresReliefType]=(int)PR_EASYBREATHE;
sess->settings[CPAP_PresReliefMode]=(int)PM_FullTime; // sess->settings[CPAP_PresReliefMode]=(int)PM_FullTime;
} // }
} else { // } else {
sess->settings[CPAP_Mode]=MODE_APAP; // sess->settings[CPAP_Mode]=MODE_APAP;
sig=stredf.lookupSignal(CPAP_PressureMin); // sig=stredf.lookupSignal(CPAP_PressureMin);
if (sig) { // if (sig) {
EventDataType pressure=sig->data[dn]*sig->gain; // EventDataType pressure=sig->data[dn]*sig->gain;
sess->settings[CPAP_PressureMin]=pressure; // sess->settings[CPAP_PressureMin]=pressure;
//sess->setMin(CPAP_Pressure,pressure); // //sess->setMin(CPAP_Pressure,pressure);
} // }
sig=stredf.lookupSignal(CPAP_PressureMax); // sig=stredf.lookupSignal(CPAP_PressureMax);
if (sig) { // if (sig) {
EventDataType pressure=sig->data[dn]*sig->gain; // EventDataType pressure=sig->data[dn]*sig->gain;
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 // // Leak Summary
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Leak Med"))) { // if ((sig=stredf.lookupName("Leak Med"))) {
valmed=sig->data[dn]; // valmed=sig->data[dn];
if (valmed>=0) { // if (valmed>=0) {
sess->m_gain[CPAP_Leak]=sig->gain*60.0; // sess->m_gain[CPAP_Leak]=sig->gain*60.0;
sess->m_valuesummary[CPAP_Leak][valmed]=51; // sess->m_valuesummary[CPAP_Leak][valmed]=51;
} // }
} // }
if ((sig=stredf.lookupName("Leak 95"))) { // if ((sig=stredf.lookupName("Leak 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
if (val95>=0) // if (val95>=0)
sess->m_valuesummary[CPAP_Leak][val95]=45; // sess->m_valuesummary[CPAP_Leak][val95]=45;
} // }
if ((sig=stredf.lookupName("Leak Max"))) { // if ((sig=stredf.lookupName("Leak Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
if (valmax>=0) { // if (valmax>=0) {
sess->setMax(CPAP_Leak,valmax*sig->gain*60.0); // sess->setMax(CPAP_Leak,valmax*sig->gain*60.0);
sess->m_valuesummary[CPAP_Leak][valmax]=4; // sess->m_valuesummary[CPAP_Leak][valmax]=4;
} // }
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Minute Ventilation Summary // // 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;
sess->m_valuesummary[CPAP_MinuteVent][valmed]=51; // sess->m_valuesummary[CPAP_MinuteVent][valmed]=51;
} // }
if ((sig=stredf.lookupName("Min Vent 95"))) { // if ((sig=stredf.lookupName("Min Vent 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_MinuteVent][val95]=45; // sess->m_valuesummary[CPAP_MinuteVent][val95]=45;
} // }
if ((sig=stredf.lookupName("Min Vent Max"))) { // if ((sig=stredf.lookupName("Min Vent Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
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 // // 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;
sess->m_valuesummary[CPAP_RespRate][valmed]=51; // sess->m_valuesummary[CPAP_RespRate][valmed]=51;
} // }
if ((sig=stredf.lookupName("RR 95"))) { // if ((sig=stredf.lookupName("RR 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_RespRate][val95]=45; // sess->m_valuesummary[CPAP_RespRate][val95]=45;
} // }
if ((sig=stredf.lookupName("RR Max"))) { // if ((sig=stredf.lookupName("RR Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
sess->setMax(CPAP_RespRate,valmax*sig->gain); // sess->setMax(CPAP_RespRate,valmax*sig->gain);
sess->m_valuesummary[CPAP_RespRate][valmax]=4; // sess->m_valuesummary[CPAP_RespRate][valmax]=4;
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Tidal Volume Summary // // 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;
sess->m_valuesummary[CPAP_TidalVolume][valmed]=51; // sess->m_valuesummary[CPAP_TidalVolume][valmed]=51;
} // }
if ((sig=stredf.lookupName("Tid Vol 95"))) { // if ((sig=stredf.lookupName("Tid Vol 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_TidalVolume][val95]=45; // sess->m_valuesummary[CPAP_TidalVolume][val95]=45;
} // }
if ((sig=stredf.lookupName("Tid Vol Max"))) { // if ((sig=stredf.lookupName("Tid Vol Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
sess->setMax(CPAP_TidalVolume,valmax*sig->gain*1000.0); // sess->setMax(CPAP_TidalVolume,valmax*sig->gain*1000.0);
sess->m_valuesummary[CPAP_TidalVolume][valmax]=4; // sess->m_valuesummary[CPAP_TidalVolume][valmax]=4;
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Target Minute Ventilation Summary // // 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;
sess->m_valuesummary[CPAP_TgMV][valmed]=51; // sess->m_valuesummary[CPAP_TgMV][valmed]=51;
} // }
if ((sig=stredf.lookupName("Targ Vent 95"))) { // if ((sig=stredf.lookupName("Targ Vent 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_TgMV][val95]=45; // sess->m_valuesummary[CPAP_TgMV][val95]=45;
} // }
if ((sig=stredf.lookupName("Targ Vent Max"))) { // if ((sig=stredf.lookupName("Targ Vent Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
sess->setMax(CPAP_TgMV,valmax*sig->gain); // sess->setMax(CPAP_TgMV,valmax*sig->gain);
sess->m_valuesummary[CPAP_TgMV][valmax]=4; // sess->m_valuesummary[CPAP_TgMV][valmax]=4;
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// I:E Summary // // 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;
sess->m_valuesummary[CPAP_IE][valmed]=51; // sess->m_valuesummary[CPAP_IE][valmed]=51;
} // }
if ((sig=stredf.lookupName("I:E 95"))) { // if ((sig=stredf.lookupName("I:E 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_IE][val95]=45; // sess->m_valuesummary[CPAP_IE][val95]=45;
} // }
if ((sig=stredf.lookupName("I:E Max"))) { // if ((sig=stredf.lookupName("I:E Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
sess->setMax(CPAP_IE,valmax*sig->gain); // sess->setMax(CPAP_IE,valmax*sig->gain);
sess->m_valuesummary[CPAP_IE][valmax]=4; // sess->m_valuesummary[CPAP_IE][valmax]=4;
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Mask Pressure Summary // // 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];
if (valmed >= 0) { // if (valmed >= 0) {
sess->m_gain[CPAP_Pressure]=sig->gain; // sess->m_gain[CPAP_Pressure]=sig->gain;
sess->m_valuesummary[CPAP_Pressure][valmed]=51; // sess->m_valuesummary[CPAP_Pressure][valmed]=51;
} // }
} // }
if ((sig=stredf.lookupName("Mask Pres 95"))) { // if ((sig=stredf.lookupName("Mask Pres 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
if (val95 >= 0) { // if (val95 >= 0) {
sess->m_valuesummary[CPAP_Pressure][val95]=45;
}
}
if ((sig=stredf.lookupName("Mask Pres Max"))) {
valmax=sig->data[dn];
if (valmax >= 0) {
sess->setMax(CPAP_Pressure,valmax*sig->gain);
sess->m_valuesummary[CPAP_Pressure][valmax]=4;
}
}
/////////////////////////////////////////////////////////////////////
// Therapy Pressure Summary
/////////////////////////////////////////////////////////////////////
if ((sig=stredf.lookupName("Therapy Pres Me"))) {
valmed=sig->data[dn];
if (valmed >= 0) {
//sess->m_gain[CPAP_Pressure]=sig->gain;
//sess->m_valuesummary[CPAP_Pressure][valmed]=51;
}
}
if ((sig=stredf.lookupName("Therapy Pres 95"))) {
val95=sig->data[dn];
if (val95 >= 0) {
// sess->m_valuesummary[CPAP_Pressure][val95]=45; // sess->m_valuesummary[CPAP_Pressure][val95]=45;
} // }
} // }
if ((sig=stredf.lookupName("Therapy Pres Ma"))) { // if ((sig=stredf.lookupName("Mask Pres Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
if (valmax >= 0) { // if (valmax >= 0) {
// sess->setMax(CPAP_Pressure,valmax*sig->gain); // sess->setMax(CPAP_Pressure,valmax*sig->gain);
// sess->m_valuesummary[CPAP_Pressure][valmax]=4; // sess->m_valuesummary[CPAP_Pressure][valmax]=4;
} // }
} // }
// /////////////////////////////////////////////////////////////////////
// // Therapy Pressure Summary
// /////////////////////////////////////////////////////////////////////
// if ((sig=stredf.lookupName("Therapy Pres Me"))) {
// valmed=sig->data[dn];
// if (valmed >= 0) {
// //sess->m_gain[CPAP_Pressure]=sig->gain;
// //sess->m_valuesummary[CPAP_Pressure][valmed]=51;
// }
// }
// if ((sig=stredf.lookupName("Therapy Pres 95"))) {
// val95=sig->data[dn];
// if (val95 >= 0) {
//// sess->m_valuesummary[CPAP_Pressure][val95]=45;
// }
// }
// if ((sig=stredf.lookupName("Therapy Pres Ma"))) {
// valmax=sig->data[dn];
// if (valmax >= 0) {
//// sess->setMax(CPAP_Pressure,valmax*sig->gain);
//// sess->m_valuesummary[CPAP_Pressure][valmax]=4;
// }
// }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Inspiratory Pressure (IPAP) Summary // // 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;
sess->m_valuesummary[CPAP_IPAP][valmed]=51; // sess->m_valuesummary[CPAP_IPAP][valmed]=51;
} // }
if ((sig=stredf.lookupName("Insp Pres 95"))) { // if ((sig=stredf.lookupName("Insp Pres 95"))) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_IPAP][val95]=45; // sess->m_valuesummary[CPAP_IPAP][val95]=45;
} // }
if ((sig=stredf.lookupName("Insp Pres Max"))) { // if ((sig=stredf.lookupName("Insp Pres Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
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 // // 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];
if (valmed>=0) { // if (valmed>=0) {
sess->m_gain[CPAP_EPAP]=sig->gain; // sess->m_gain[CPAP_EPAP]=sig->gain;
sess->m_valuesummary[CPAP_EPAP][valmed]=51; // sess->m_valuesummary[CPAP_EPAP][valmed]=51;
} // }
} // }
if ((sig=stredf.lookupName("Exp Pres 95"))) { // if ((sig=stredf.lookupName("Exp Pres 95"))) {
if (val95>=0) { // if (val95>=0) {
val95=sig->data[dn]; // val95=sig->data[dn];
sess->m_valuesummary[CPAP_EPAP][val95]=45; // sess->m_valuesummary[CPAP_EPAP][val95]=45;
} // }
} // }
if ((sig=stredf.lookupName("Exp Pres Max"))) { // if ((sig=stredf.lookupName("Exp Pres Max"))) {
valmax=sig->data[dn]; // valmax=sig->data[dn];
if (valmax>=0) { // if (valmax>=0) {
sess->setMax(CPAP_EPAP,valmax*sig->gain); // sess->setMax(CPAP_EPAP,valmax*sig->gain);
sess->m_valuesummary[CPAP_EPAP][valmax]=4; // sess->m_valuesummary[CPAP_EPAP][valmax]=4;
} // }
} // }
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
// Duration and Event Indices // // Duration and Event Indices
///////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////
dur=0; // dur=0;
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. // dur/=60.0f; // convert to hours.
} // }
if ((sig=stredf.lookupName("OAI"))) { // Obstructive Apnea Index // if ((sig=stredf.lookupName("OAI"))) { // Obstructive Apnea Index
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
if (tmp>=0) { // if (tmp>=0) {
sess->setCph(CPAP_Obstructive,tmp); // sess->setCph(CPAP_Obstructive,tmp);
sess->setCount(CPAP_Obstructive,tmp*dur); // Converting from indice to counts.. // sess->setCount(CPAP_Obstructive,tmp*dur); // Converting from indice to counts..
} // }
} // }
if ((sig=stredf.lookupName("HI"))) { // Hypopnea Index // if ((sig=stredf.lookupName("HI"))) { // Hypopnea Index
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
if (tmp>=0) { // if (tmp>=0) {
sess->setCph(CPAP_Hypopnea,tmp); // sess->setCph(CPAP_Hypopnea,tmp);
sess->setCount(CPAP_Hypopnea,tmp*dur); // sess->setCount(CPAP_Hypopnea,tmp*dur);
} // }
} // }
if ((sig=stredf.lookupName("UAI"))) { // Unspecified Apnea Index // if ((sig=stredf.lookupName("UAI"))) { // Unspecified Apnea Index
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
if (tmp>=0) { // if (tmp>=0) {
sess->setCph(CPAP_Apnea,tmp); // sess->setCph(CPAP_Apnea,tmp);
sess->setCount(CPAP_Apnea,tmp*dur); // sess->setCount(CPAP_Apnea,tmp*dur);
} // }
} // }
if ((sig=stredf.lookupName("CAI"))) { // "Central" Apnea Index // if ((sig=stredf.lookupName("CAI"))) { // "Central" Apnea Index
tmp=sig->data[dn]*sig->gain; // tmp=sig->data[dn]*sig->gain;
if (tmp>=0) { // if (tmp>=0) {
sess->setCph(CPAP_ClearAirway,tmp); // sess->setCph(CPAP_ClearAirway,tmp);
sess->setCount(CPAP_ClearAirway,tmp*dur); // sess->setCount(CPAP_ClearAirway,tmp*dur);
} // }
} // }
} // }
} // }
backup_path+=datalog+"/"; backup_path+=datalog+"/";
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

8
SleepLib/profiles.cpp
View File

@ -260,9 +260,11 @@ void Profile::AddDay(QDate date,Day *day,MachineType mt) {
QList<Day *> & dl=daylist[date]; QList<Day *> & dl=daylist[date];
for (QList<Day *>::iterator a=dl.begin();a!=dl.end();a++) { for (QList<Day *>::iterator a=dl.begin();a!=dl.end();a++) {
if ((*a)->machine->GetType()==mt) { if ((*a)->machine->GetType()==mt) {
if (QMessageBox::question(NULL,"Different Machine Detected","This data comes from another machine to what's usually imported, and has overlapping data.\nThis new data will override any older data from the old machine. Are you sure you want to do this?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::No) {
throw OneTypePerDay(); // disabled this because two machines isn't all that bad
} // if (QMessageBox::question(NULL,"Different Machine Detected","This data comes from another machine to what's usually imported, and has overlapping data.\nThis new data will override any older data from the old machine. Are you sure you want to do this?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::No) {
// throw OneTypePerDay();
// }
daylist[date].erase(a); daylist[date].erase(a);
break; break;
} }