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

Auto-convert the SleepLib/ subdirectory with astyle.

Browse Source 
Signed-off-by: Mark Watkins <jedimark@users.sourceforge.net>
This commit is contained in:
Sean Stangl 2014-04-16 22:58:57 -07:00 committed by Mark Watkins
parent b5d5b82b59
commit c29313ab88
37 changed files with 8855 additions and 6883 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1707
sleepyhead/SleepLib/calcs.cpp
View File

File diff suppressed because it is too large Load Diff

107
sleepyhead/SleepLib/calcs.h
View File

@ -17,29 +17,30 @@
//! param samples Number of samples
//! width number of surrounding samples to consider
//! percentile fractional percentage, between 0 and 1
void percentileFilter(EventDataType * input, EventDataType * output, int samples, int width, EventDataType percentile);
void xpassFilter(EventDataType * input, EventDataType * output, int samples, EventDataType weight);
void percentileFilter(EventDataType *input, EventDataType *output, int samples, int width,
EventDataType percentile);
void xpassFilter(EventDataType *input, EventDataType *output, int samples, EventDataType weight);
enum FilterType { FilterNone=0, FilterPercentile, FilterXPass };
enum FilterType { FilterNone = 0, FilterPercentile, FilterXPass };
struct Filter {
Filter(FilterType t,EventDataType p1,EventDataType p2,EventDataType p3) {
type=t;
param1=p1;
param2=p2;
param3=p3;
Filter(FilterType t, EventDataType p1, EventDataType p2, EventDataType p3) {
type = t;
param1 = p1;
param2 = p2;
param3 = p3;
}
Filter() {
type=FilterNone;
param1=0;
param2=0;
param3=0;
type = FilterNone;
param1 = 0;
param2 = 0;
param3 = 0;
}
Filter(const Filter & copy) {
type=copy.type;
param1=copy.param1;
param2=copy.param2;
param3=copy.param3;
Filter(const Filter &copy) {
type = copy.type;
param1 = copy.param1;
param2 = copy.param2;
param3 = copy.param3;
}
FilterType type;
@ -49,28 +50,29 @@ struct Filter {
};
struct BreathPeak {
BreathPeak() { min=0; max=0; start=0; middle=0; end=0; } // peakmin=0; peakmax=0; }
BreathPeak(EventDataType _min, EventDataType _max, qint32 _start, qint32 _middle, qint32 _end) {//, qint64 _peakmin, qint64 _peakmax) {
min=_min;
max=_max;
start=_start;
middle=_middle;
end=_end;
BreathPeak() { min = 0; max = 0; start = 0; middle = 0; end = 0; } // peakmin=0; peakmax=0; }
BreathPeak(EventDataType _min, EventDataType _max, qint32 _start, qint32 _middle,
qint32 _end) {//, qint64 _peakmin, qint64 _peakmax) {
min = _min;
max = _max;
start = _start;
middle = _middle;
end = _end;
//peakmax=_peakmax;
//peakmin=_peakmin;
}
BreathPeak(const BreathPeak & copy) {
min=copy.min;
max=copy.max;
start=copy.start;
middle=copy.middle;
end=copy.end;
BreathPeak(const BreathPeak &copy) {
min = copy.min;
max = copy.max;
start = copy.start;
middle = copy.middle;
end = copy.end;
//peakmin=copy.peakmin;
//peakmax=copy.peakmax;
}
int samplelength() { return end-start; }
int upperLength() { return middle-start; }
int lowerLength() { return end-middle; }
int samplelength() { return end - start; }
int upperLength() { return middle - start; }
int lowerLength() { return end - middle; }
EventDataType min; // peak value
EventDataType max; // peak value
@ -81,15 +83,16 @@ struct BreathPeak {
//qint64 peakmax; // max peak index
};
bool operator<(const BreathPeak & p1, const BreathPeak & p2);
bool operator<(const BreathPeak &p1, const BreathPeak &p2);
const int num_filter_buffers=2;
const int num_filter_buffers = 2;
const int max_filter_buf_size=2097152*sizeof(EventDataType);
const int max_filter_buf_size = 2097152 * sizeof(EventDataType);
//! \brief Class to process Flow Rate waveform data
class FlowParser {
public:
class FlowParser
{
public:
FlowParser();
~FlowParser();
@ -97,17 +100,17 @@ public:
void clearFilters();
//! \brief Applies the filter chain to input, with supplied number of samples
EventDataType * applyFilters(EventDataType * input, int samples);
EventDataType *applyFilters(EventDataType *input, int samples);
//! \brief Add the filter
void addFilter(FilterType ft, EventDataType p1=0, EventDataType p2=0, EventDataType p3=0) {
m_filters.push_back(Filter(ft,p1,p2,p3));
void addFilter(FilterType ft, EventDataType p1 = 0, EventDataType p2 = 0, EventDataType p3 = 0) {
m_filters.push_back(Filter(ft, p1, p2, p3));
}
//! \brief Opens the flow rate EventList, applies the input filter chain, and calculates peaks
void openFlow(Session * session, EventList * flow);
void openFlow(Session *session, EventList *flow);
//! \brief Calculates the upper and lower breath peaks
void calcPeaks(EventDataType * input, int samples);
void calcPeaks(EventDataType *input, int samples);
// Minute vent needs Resp & TV calcs made here..
void calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool calcMv);
@ -119,33 +122,33 @@ public:
QList<Filter> m_filters;
protected:
protected:
QVector<BreathPeak> breaths;
int m_samples;
EventList * m_flow;
Session * m_session;
EventList *m_flow;
Session *m_session;
EventDataType m_gain;
EventDataType m_rate;
EventDataType m_minutes;
//! \brief The filtered waveform
EventDataType * m_filtered;
EventDataType *m_filtered;
//! \brief BreathPeak's start on positive cycle?
bool m_startsUpper;
private:
EventDataType * m_buffers[num_filter_buffers];
private:
EventDataType *m_buffers[num_filter_buffers];
};
bool SearchApnea(Session *session, qint64 time, qint64 dist=15000);
bool SearchApnea(Session *session, qint64 time, qint64 dist = 15000);
//! \brief Calculate Respiratory Rate, Tidal Volume & Minute Ventilation for PRS1 data
void calcRespRate(Session *session, FlowParser * flowparser=NULL);
void calcRespRate(Session *session, FlowParser *flowparser = NULL);
//! \brief Calculates the sliding window AHI graph
int calcAHIGraph(Session *session);
//! \brief Calculates AHI for a session between start & end (a support function for the sliding window graph)
EventDataType calcAHI(Session *session,qint64 start=-1, qint64 end=-1);
EventDataType calcAHI(Session *session, qint64 start = -1, qint64 end = -1);
//! \brief Leaks calculations for PRS1
int calcLeaks(Session *session);

320
sleepyhead/SleepLib/common.cpp
View File

@ -24,64 +24,69 @@ const QString getDeveloperName()
const QString getAppName()
{
QString name=STR_AppName;
QString name = STR_AppName;
#ifdef UNSTABLE_BUILD
name+=STR_Unstable;
name += STR_Unstable;
#endif
return name;
}
const QString getDefaultAppRoot()
{
QString approot=STR_AppRoot;
QString approot = STR_AppRoot;
#ifdef UNSTABLE_BUILD
approot+=STR_Unstable;
approot += STR_Unstable;
#endif
return approot;
}
qint64 timezoneOffset() {
static bool ok=false;
static qint64 _TZ_offset=0;
qint64 timezoneOffset()
{
static bool ok = false;
static qint64 _TZ_offset = 0;
if (ok) return _TZ_offset;
QDateTime d1=QDateTime::currentDateTime();
QDateTime d2=d1;
if (ok) { return _TZ_offset; }
QDateTime d1 = QDateTime::currentDateTime();
QDateTime d2 = d1;
d1.setTimeSpec(Qt::UTC);
_TZ_offset=d2.secsTo(d1);
_TZ_offset*=1000L;
_TZ_offset = d2.secsTo(d1);
_TZ_offset *= 1000L;
return _TZ_offset;
}
QString weightString(float kg, UnitSystem us)
{
if (us==US_Undefined)
us=PROFILE.general->unitSystem();
if (us==US_Metric) {
return QString("%1kg").arg(kg,0,'f',2);
} else if (us==US_Archiac) {
int oz=(kg*1000.0) / (float)ounce_convert;
int lb=oz / 16.0;
oz = oz % 16;
return QString("%1lb %2oz").arg(lb,0,10).arg(oz);
if (us == US_Undefined) {
us = PROFILE.general->unitSystem();
}
return("Bad UnitSystem");
if (us == US_Metric) {
return QString("%1kg").arg(kg, 0, 'f', 2);
} else if (us == US_Archiac) {
int oz = (kg * 1000.0) / (float)ounce_convert;
int lb = oz / 16.0;
oz = oz % 16;
return QString("%1lb %2oz").arg(lb, 0, 10).arg(oz);
}
return ("Bad UnitSystem");
}
bool operator <(const ValueCount & a, const ValueCount & b)
bool operator <(const ValueCount &a, const ValueCount &b)
{
return a.value < b.value;
return a.value < b.value;
}
bool removeDir(const QString & path)
bool removeDir(const QString &path)
{
bool result = true;
QDir dir(path);
if (dir.exists(path)) {
Q_FOREACH(QFileInfo info, dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst)) {
Q_FOREACH(QFileInfo info, dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden |
QDir::AllDirs | QDir::Files, QDir::DirsFirst)) {
if (info.isDir()) { // Recurse to remove this child directory
result = removeDir(info.absoluteFilePath());
} else { // File
@ -254,157 +259,158 @@ QString STR_TR_WAvg; // Short form of Weighted Average
void initializeStrings()
{
STR_UNIT_CM=QObject::tr("cm");
STR_UNIT_INCH=QObject::tr("\"");
STR_UNIT_FOOT=QObject::tr("ft");
STR_UNIT_POUND=QObject::tr("lb");
STR_UNIT_OUNCE=QObject::tr("oz");
STR_UNIT_KG=QObject::tr("Kg");
STR_UNIT_CMH2O=QObject::tr("cmH2O");
STR_UNIT_Hours=QObject::tr("Hours");
STR_UNIT_CM = QObject::tr("cm");
STR_UNIT_INCH = QObject::tr("\"");
STR_UNIT_FOOT = QObject::tr("ft");
STR_UNIT_POUND = QObject::tr("lb");
STR_UNIT_OUNCE = QObject::tr("oz");
STR_UNIT_KG = QObject::tr("Kg");
STR_UNIT_CMH2O = QObject::tr("cmH2O");
STR_UNIT_Hours = QObject::tr("Hours");
STR_UNIT_BPM=QObject::tr("bpm"); // Beats per Minute
STR_UNIT_LPM=QObject::tr("L/m"); // Litres per Minute
STR_UNIT_BPM = QObject::tr("bpm"); // Beats per Minute
STR_UNIT_LPM = QObject::tr("L/m"); // Litres per Minute
STR_MESSAGE_ERROR=QObject::tr("Error");
STR_MESSAGE_WARNING=QObject::tr("Warning");
STR_MESSAGE_ERROR = QObject::tr("Error");
STR_MESSAGE_WARNING = QObject::tr("Warning");
STR_TR_BMI=QObject::tr("BMI"); // Short form of Body Mass Index
STR_TR_Weight=QObject::tr("Weight");
STR_TR_Zombie=QObject::tr("Zombie");
STR_TR_PulseRate=QObject::tr("Pulse Rate"); // Pulse / Heart rate
STR_TR_SpO2=QObject::tr("SpO2");
STR_TR_Plethy=QObject::tr("Plethy"); // Plethysomogram
STR_TR_Pressure=QObject::tr("Pressure");
STR_TR_BMI = QObject::tr("BMI"); // Short form of Body Mass Index
STR_TR_Weight = QObject::tr("Weight");
STR_TR_Zombie = QObject::tr("Zombie");
STR_TR_PulseRate = QObject::tr("Pulse Rate"); // Pulse / Heart rate
STR_TR_SpO2 = QObject::tr("SpO2");
STR_TR_Plethy = QObject::tr("Plethy"); // Plethysomogram
STR_TR_Pressure = QObject::tr("Pressure");
STR_TR_Daily=QObject::tr("Daily");
STR_TR_Overview=QObject::tr("Overview");
STR_TR_Oximetry=QObject::tr("Oximetry");
STR_TR_Daily = QObject::tr("Daily");
STR_TR_Overview = QObject::tr("Overview");
STR_TR_Oximetry = QObject::tr("Oximetry");
STR_TR_Oximeter=QObject::tr("Oximeter");
STR_TR_EventFlags=QObject::tr("Event Flags");
STR_TR_Oximeter = QObject::tr("Oximeter");
STR_TR_EventFlags = QObject::tr("Event Flags");
// Machine type names.
STR_TR_CPAP=QObject::tr("CPAP"); // Constant Positive Airway Pressure
STR_TR_BIPAP=QObject::tr("BiPAP"); // Bi-Level Positive Airway Pressure
STR_TR_BiLevel=QObject::tr("Bi-Level"); // Another name for BiPAP
STR_TR_EPAP=QObject::tr("EPAP"); // Expiratory Positive Airway Pressure
STR_TR_EPAPLo=QObject::tr("Min EPAP"); // Lower Expiratory Positive Airway Pressure
STR_TR_EPAPHi=QObject::tr("Max EPAP"); // Higher Expiratory Positive Airway Pressure
STR_TR_IPAP=QObject::tr("IPAP"); // Inspiratory Positive Airway Pressure
STR_TR_IPAPLo=QObject::tr("Min IPAP"); // Lower Inspiratory Positive Airway Pressure
STR_TR_IPAPHi=QObject::tr("Max IPAP"); // Higher Inspiratory Positive Airway Pressure
STR_TR_APAP=QObject::tr("APAP"); // Automatic Positive Airway Pressure
STR_TR_ASV=QObject::tr("ASV"); // Assisted Servo Ventilator
STR_TR_STASV=QObject::tr("ST/ASV");
STR_TR_CPAP = QObject::tr("CPAP"); // Constant Positive Airway Pressure
STR_TR_BIPAP = QObject::tr("BiPAP"); // Bi-Level Positive Airway Pressure
STR_TR_BiLevel = QObject::tr("Bi-Level"); // Another name for BiPAP
STR_TR_EPAP = QObject::tr("EPAP"); // Expiratory Positive Airway Pressure
STR_TR_EPAPLo = QObject::tr("Min EPAP"); // Lower Expiratory Positive Airway Pressure
STR_TR_EPAPHi = QObject::tr("Max EPAP"); // Higher Expiratory Positive Airway Pressure
STR_TR_IPAP = QObject::tr("IPAP"); // Inspiratory Positive Airway Pressure
STR_TR_IPAPLo = QObject::tr("Min IPAP"); // Lower Inspiratory Positive Airway Pressure
STR_TR_IPAPHi = QObject::tr("Max IPAP"); // Higher Inspiratory Positive Airway Pressure
STR_TR_APAP = QObject::tr("APAP"); // Automatic Positive Airway Pressure
STR_TR_ASV = QObject::tr("ASV"); // Assisted Servo Ventilator
STR_TR_STASV = QObject::tr("ST/ASV");
STR_TR_Humidifier=QObject::tr("Humidifier");
STR_TR_Humidifier = QObject::tr("Humidifier");
STR_TR_H=QObject::tr("H"); // Short form of Hypopnea
STR_TR_OA=QObject::tr("OA"); // Short form of Obstructive Apnea
STR_TR_UA=QObject::tr("A"); // Short form of Unspecified Apnea
STR_TR_CA=QObject::tr("CA"); // Short form of Clear Airway Apnea
STR_TR_FL=QObject::tr("FL"); // Short form of Flow Limitation
STR_TR_LE=QObject::tr("LE"); // Short form of Leak Event
STR_TR_EP=QObject::tr("EP"); // Short form of Expiratory Puff
STR_TR_VS=QObject::tr("VS"); // Short form of Vibratory Snore
STR_TR_VS2=QObject::tr("VS2"); // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
STR_TR_RERA=QObject::tr("RERA"); // Acronym for Respiratory Effort Related Arousal
STR_TR_PP=QObject::tr("PP"); // Short form for Pressure Pulse
STR_TR_P=QObject::tr("P"); // Short form for Pressure Event
STR_TR_RE=QObject::tr("RE"); // Short form of Respiratory Effort Related Arousal
STR_TR_NR=QObject::tr("NR"); // Short form of Non Responding event? (forgot sorry)
STR_TR_NRI=QObject::tr("NRI"); // Sorry I Forgot.. it's a flag on Intellipap machines
STR_TR_O2=QObject::tr("O2"); // SpO2 Desaturation
STR_TR_PC=QObject::tr("PC"); // Short form for Pulse Change
STR_TR_UF1=QObject::tr("UF1"); // Short form for User Flag 1
STR_TR_UF2=QObject::tr("UF2"); // Short form for User Flag 2
STR_TR_UF3=QObject::tr("UF3"); // Short form for User Flag 3
STR_TR_H = QObject::tr("H"); // Short form of Hypopnea
STR_TR_OA = QObject::tr("OA"); // Short form of Obstructive Apnea
STR_TR_UA = QObject::tr("A"); // Short form of Unspecified Apnea
STR_TR_CA = QObject::tr("CA"); // Short form of Clear Airway Apnea
STR_TR_FL = QObject::tr("FL"); // Short form of Flow Limitation
STR_TR_LE = QObject::tr("LE"); // Short form of Leak Event
STR_TR_EP = QObject::tr("EP"); // Short form of Expiratory Puff
STR_TR_VS = QObject::tr("VS"); // Short form of Vibratory Snore
STR_TR_VS2 =
QObject::tr("VS2"); // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
STR_TR_RERA = QObject::tr("RERA"); // Acronym for Respiratory Effort Related Arousal
STR_TR_PP = QObject::tr("PP"); // Short form for Pressure Pulse
STR_TR_P = QObject::tr("P"); // Short form for Pressure Event
STR_TR_RE = QObject::tr("RE"); // Short form of Respiratory Effort Related Arousal
STR_TR_NR = QObject::tr("NR"); // Short form of Non Responding event? (forgot sorry)
STR_TR_NRI = QObject::tr("NRI"); // Sorry I Forgot.. it's a flag on Intellipap machines
STR_TR_O2 = QObject::tr("O2"); // SpO2 Desaturation
STR_TR_PC = QObject::tr("PC"); // Short form for Pulse Change
STR_TR_UF1 = QObject::tr("UF1"); // Short form for User Flag 1
STR_TR_UF2 = QObject::tr("UF2"); // Short form for User Flag 2
STR_TR_UF3 = QObject::tr("UF3"); // Short form for User Flag 3
STR_TR_PS=QObject::tr("PS"); // Short form of Pressure Support
STR_TR_AHI=QObject::tr("AHI"); // Short form of Apnea Hypopnea Index
STR_TR_RDI=QObject::tr("RDI"); // Short form of Respiratory Distress Index
STR_TR_AI=QObject::tr("AI"); // Short form of Apnea Index
STR_TR_HI=QObject::tr("HI"); // Short form of Hypopnea Index
STR_TR_UAI=QObject::tr("UAI"); // Short form of Uncatagorized Apnea Index
STR_TR_CAI=QObject::tr("CAI"); // Short form of Clear Airway Index
STR_TR_FLI=QObject::tr("FLI"); // Short form of Flow Limitation Index
STR_TR_REI=QObject::tr("REI"); // Short form of RERA Index
STR_TR_EPI=QObject::tr("EPI"); // Short form of Expiratory Puff Index
STR_TR_CSR=QObject::tr("ÇSR"); // Short form of Cheyne Stokes Respiration
STR_TR_PB=QObject::tr("PB"); // Short form of Periodic Breathing
STR_TR_PS = QObject::tr("PS"); // Short form of Pressure Support
STR_TR_AHI = QObject::tr("AHI"); // Short form of Apnea Hypopnea Index
STR_TR_RDI = QObject::tr("RDI"); // Short form of Respiratory Distress Index
STR_TR_AI = QObject::tr("AI"); // Short form of Apnea Index
STR_TR_HI = QObject::tr("HI"); // Short form of Hypopnea Index
STR_TR_UAI = QObject::tr("UAI"); // Short form of Uncatagorized Apnea Index
STR_TR_CAI = QObject::tr("CAI"); // Short form of Clear Airway Index
STR_TR_FLI = QObject::tr("FLI"); // Short form of Flow Limitation Index
STR_TR_REI = QObject::tr("REI"); // Short form of RERA Index
STR_TR_EPI = QObject::tr("EPI"); // Short form of Expiratory Puff Index
STR_TR_CSR = QObject::tr("ÇSR"); // Short form of Cheyne Stokes Respiration
STR_TR_PB = QObject::tr("PB"); // Short form of Periodic Breathing
// Graph Titles
STR_TR_IE=QObject::tr("IE"); // Inspiratory Expiratory Ratio
STR_TR_InspTime=QObject::tr("Insp. Time"); // Inspiratory Time
STR_TR_ExpTime=QObject::tr("Exp. Time"); // Expiratory Time
STR_TR_RespEvent=QObject::tr("Resp. Event"); // Respiratory Event
STR_TR_FlowLimitation=QObject::tr("Flow Limitation");
STR_TR_FlowLimit=QObject::tr("Flow Limit");
STR_TR_PatTrigBreath=QObject::tr("Pat. Trig. Breath"); // Patient Triggered Breath
STR_TR_TgtMinVent=QObject::tr("Tgt. Min. Vent"); // Target Minute Ventilation
STR_TR_TargetVent=QObject::tr("Target Vent."); // Target Ventilation
STR_TR_MinuteVent=QObject::tr("Minute Vent."); // Minute Ventilation
STR_TR_TidalVolume=QObject::tr("Tidal Volume");
STR_TR_RespRate=QObject::tr("Resp. Rate"); // Respiratory Rate
STR_TR_Snore=QObject::tr("Snore");
STR_TR_Leak=QObject::tr("Leak");
STR_TR_Leaks=QObject::tr("Leaks");
STR_TR_TotalLeaks=QObject::tr("Total Leaks");
STR_TR_UnintentionalLeaks=QObject::tr("Unintentional Leaks");
STR_TR_MaskPressure=QObject::tr("MaskPressure");
STR_TR_FlowRate=QObject::tr("Flow Rate");
STR_TR_SleepStage=QObject::tr("Sleep Stage");
STR_TR_Usage=QObject::tr("Usage");
STR_TR_Sessions=QObject::tr("Sessions");
STR_TR_PrRelief=QObject::tr("Pr. Relief"); // Pressure Relief
STR_TR_IE = QObject::tr("IE"); // Inspiratory Expiratory Ratio
STR_TR_InspTime = QObject::tr("Insp. Time"); // Inspiratory Time
STR_TR_ExpTime = QObject::tr("Exp. Time"); // Expiratory Time
STR_TR_RespEvent = QObject::tr("Resp. Event"); // Respiratory Event
STR_TR_FlowLimitation = QObject::tr("Flow Limitation");
STR_TR_FlowLimit = QObject::tr("Flow Limit");
STR_TR_PatTrigBreath = QObject::tr("Pat. Trig. Breath"); // Patient Triggered Breath
STR_TR_TgtMinVent = QObject::tr("Tgt. Min. Vent"); // Target Minute Ventilation
STR_TR_TargetVent = QObject::tr("Target Vent."); // Target Ventilation
STR_TR_MinuteVent = QObject::tr("Minute Vent."); // Minute Ventilation
STR_TR_TidalVolume = QObject::tr("Tidal Volume");
STR_TR_RespRate = QObject::tr("Resp. Rate"); // Respiratory Rate
STR_TR_Snore = QObject::tr("Snore");
STR_TR_Leak = QObject::tr("Leak");
STR_TR_Leaks = QObject::tr("Leaks");
STR_TR_TotalLeaks = QObject::tr("Total Leaks");
STR_TR_UnintentionalLeaks = QObject::tr("Unintentional Leaks");
STR_TR_MaskPressure = QObject::tr("MaskPressure");
STR_TR_FlowRate = QObject::tr("Flow Rate");
STR_TR_SleepStage = QObject::tr("Sleep Stage");
STR_TR_Usage = QObject::tr("Usage");
STR_TR_Sessions = QObject::tr("Sessions");
STR_TR_PrRelief = QObject::tr("Pr. Relief"); // Pressure Relief
STR_TR_NoData=QObject::tr("No Data");
STR_TR_Bookmarks=QObject::tr("Bookmarks");
STR_TR_SleepyHead=QObject::tr("SleepyHead");
STR_TR_SleepyHeadVersion=STR_TR_SleepyHead+" v"+VersionString;
STR_TR_NoData = QObject::tr("No Data");
STR_TR_Bookmarks = QObject::tr("Bookmarks");
STR_TR_SleepyHead = QObject::tr("SleepyHead");
STR_TR_SleepyHeadVersion = STR_TR_SleepyHead + " v" + VersionString;
STR_TR_Mode=QObject::tr("Mode");
STR_TR_Model=QObject::tr("Model");
STR_TR_Brand=QObject::tr("Brand");
STR_TR_Serial=QObject::tr("Serial");
STR_TR_Machine=QObject::tr("Machine");
STR_TR_Channel=QObject::tr("Channel");
STR_TR_Settings=QObject::tr("Settings");
STR_TR_Mode = QObject::tr("Mode");
STR_TR_Model = QObject::tr("Model");
STR_TR_Brand = QObject::tr("Brand");
STR_TR_Serial = QObject::tr("Serial");
STR_TR_Machine = QObject::tr("Machine");
STR_TR_Channel = QObject::tr("Channel");
STR_TR_Settings = QObject::tr("Settings");
STR_TR_Inclination=QObject::tr("Inclination");
STR_TR_Orientation=QObject::tr("Orientation");
STR_TR_Inclination = QObject::tr("Inclination");
STR_TR_Orientation = QObject::tr("Orientation");
STR_TR_Name=QObject::tr("Name");
STR_TR_DOB=QObject::tr("DOB"); // Date of Birth
STR_TR_Phone=QObject::tr("Phone");
STR_TR_Address=QObject::tr("Address");
STR_TR_Email=QObject::tr("Email");
STR_TR_PatientID=QObject::tr("Patient ID");
STR_TR_Date=QObject::tr("Date");
STR_TR_Name = QObject::tr("Name");
STR_TR_DOB = QObject::tr("DOB"); // Date of Birth
STR_TR_Phone = QObject::tr("Phone");
STR_TR_Address = QObject::tr("Address");
STR_TR_Email = QObject::tr("Email");
STR_TR_PatientID = QObject::tr("Patient ID");
STR_TR_Date = QObject::tr("Date");
STR_TR_BedTime=QObject::tr("Bedtime");
STR_TR_WakeUp=QObject::tr("Wake-up");
STR_TR_MaskTime=QObject::tr("Mask Time");
STR_TR_Unknown=QObject::tr("Unknown");
STR_TR_None=QObject::tr("None");
STR_TR_Ready=QObject::tr("Ready");
STR_TR_BedTime = QObject::tr("Bedtime");
STR_TR_WakeUp = QObject::tr("Wake-up");
STR_TR_MaskTime = QObject::tr("Mask Time");
STR_TR_Unknown = QObject::tr("Unknown");
STR_TR_None = QObject::tr("None");
STR_TR_Ready = QObject::tr("Ready");
STR_TR_First=QObject::tr("First");
STR_TR_Last=QObject::tr("Last");
STR_TR_Start=QObject::tr("Start");
STR_TR_End=QObject::tr("End");
STR_TR_On=QObject::tr("On");
STR_TR_Off=QObject::tr("Off");
STR_TR_First = QObject::tr("First");
STR_TR_Last = QObject::tr("Last");
STR_TR_Start = QObject::tr("Start");
STR_TR_End = QObject::tr("End");
STR_TR_On = QObject::tr("On");
STR_TR_Off = QObject::tr("Off");
STR_TR_Min=QObject::tr("Min"); // Minimum
STR_TR_Max=QObject::tr("Max"); // Maximum
STR_TR_Min = QObject::tr("Min"); // Minimum
STR_TR_Max = QObject::tr("Max"); // Maximum
STR_TR_Average=QObject::tr("Average");
STR_TR_Median=QObject::tr("Median");
STR_TR_Avg=QObject::tr("Avg"); // Average
STR_TR_WAvg=QObject::tr("W-Avg"); // Weighted Average
STR_TR_Average = QObject::tr("Average");
STR_TR_Median = QObject::tr("Median");
STR_TR_Avg = QObject::tr("Avg"); // Average
STR_TR_WAvg = QObject::tr("W-Avg"); // Weighted Average
}

91
sleepyhead/SleepLib/common.h
View File

@ -28,11 +28,11 @@ 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;
ValueCount() { value = 0; count = 0; p = 0; }
ValueCount(const ValueCount &copy) {
value = copy.value;
count = copy.count;
p = copy.p;
}
EventDataType value;
qint64 count;
@ -40,21 +40,21 @@ struct ValueCount {
};
// Primarily sort by value
bool operator <(const ValueCount & a, const ValueCount & b);
bool operator <(const ValueCount &a, const ValueCount &b);
const float ounce_convert=28.3495231F; // grams
const float pound_convert=ounce_convert*16;
const float ounce_convert = 28.3495231F; // grams
const float pound_convert = ounce_convert * 16;
QString weightString(float kg, UnitSystem us=US_Undefined);
QString weightString(float kg, UnitSystem us = US_Undefined);
//! \brief Mercilessly trash a directory
bool removeDir(const QString & path);
bool removeDir(const QString &path);
#ifdef UNSTABLE_BUILD
const QString STR_Unstable="-Unstable";
const QString STR_Unstable = "-Unstable";
#else
const QString STR_Unstable="";
const QString STR_Unstable = "";
#endif
const QString getAppName();
@ -68,44 +68,44 @@ void initializeStrings();
// Preference Name Strings
///////////////////////////////////////////////////////////////////////////////////////////////
const QString STR_GEN_Profile="Profile";
const QString STR_GEN_SkipLogin="SkipLoginScreen";
const QString STR_GEN_UpdatesLastChecked="UpdatesLastChecked";
const QString STR_GEN_UpdatesAutoCheck="Updates_AutoCheck";
const QString STR_GEN_UpdateCheckFrequency="Updates_CheckFrequency";
const QString STR_GEN_DataFolder="DataFolder";
const QString STR_GEN_Profile = "Profile";
const QString STR_GEN_SkipLogin = "SkipLoginScreen";
const QString STR_GEN_UpdatesLastChecked = "UpdatesLastChecked";
const QString STR_GEN_UpdatesAutoCheck = "Updates_AutoCheck";
const QString STR_GEN_UpdateCheckFrequency = "Updates_CheckFrequency";
const QString STR_GEN_DataFolder = "DataFolder";
const QString STR_GEN_On=QObject::tr("On");
const QString STR_GEN_Off=QObject::tr("Off");
const QString STR_GEN_On = QObject::tr("On");
const QString STR_GEN_Off = QObject::tr("Off");
const QString STR_PREF_AllowEarlyUpdates="AllowEarlyUpdates";
const QString STR_PREF_AllowEarlyUpdates = "AllowEarlyUpdates";
const QString STR_PROP_Brand="Brand";
const QString STR_PROP_Model="Model";
const QString STR_PROP_Series="Series";
const QString STR_PROP_ModelNumber="ModelNumber";
const QString STR_PROP_SubModel="SubModel";
const QString STR_PROP_Serial="Serial";
const QString STR_PROP_DataVersion="DataVersion";
const QString STR_PROP_Path="Path";
const QString STR_PROP_BackupPath="BackupPath";
const QString STR_PROP_LastImported="LastImported";
const QString STR_PROP_Brand = "Brand";
const QString STR_PROP_Model = "Model";
const QString STR_PROP_Series = "Series";
const QString STR_PROP_ModelNumber = "ModelNumber";
const QString STR_PROP_SubModel = "SubModel";
const QString STR_PROP_Serial = "Serial";
const QString STR_PROP_DataVersion = "DataVersion";
const QString STR_PROP_Path = "Path";
const QString STR_PROP_BackupPath = "BackupPath";
const QString STR_PROP_LastImported = "LastImported";
const QString STR_MACH_ResMed="ResMed";
const QString STR_MACH_PRS1="PRS1";
const QString STR_MACH_Journal="Journal";
const QString STR_MACH_Intellipap="Intellipap";
const QString STR_MACH_FPIcon="FPIcon";
const QString STR_MACH_MSeries="MSeries";
const QString STR_MACH_CMS50="CMS50";
const QString STR_MACH_ZEO="Zeo";
const QString STR_MACH_ResMed = "ResMed";
const QString STR_MACH_PRS1 = "PRS1";
const QString STR_MACH_Journal = "Journal";
const QString STR_MACH_Intellipap = "Intellipap";
const QString STR_MACH_FPIcon = "FPIcon";
const QString STR_MACH_MSeries = "MSeries";
const QString STR_MACH_CMS50 = "CMS50";
const QString STR_MACH_ZEO = "Zeo";
const QString STR_PREF_VersionString="VersionString";
const QString STR_PREF_Language="Language";
const QString STR_PREF_VersionString = "VersionString";
const QString STR_PREF_Language = "Language";
const QString STR_AppName="SleepyHead";
const QString STR_DeveloperName="Jedimark";
const QString STR_AppRoot="SleepyHeadData";
const QString STR_AppName = "SleepyHead";
const QString STR_DeveloperName = "Jedimark";
const QString STR_AppRoot = "SleepyHeadData";
///////////////////////////////////////////////////////////////////////////////////////////////
// Commonly used translatable text strings
@ -167,7 +167,8 @@ extern QString STR_TR_FL; // Short form of Flow Limitation
extern QString STR_TR_LE; // Short form of Leak Event
extern QString STR_TR_EP; // Short form of Expiratory Puff
extern QString STR_TR_VS; // Short form of Vibratory Snore
extern QString STR_TR_VS2; // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
extern QString
STR_TR_VS2; // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
extern QString STR_TR_RERA; // Acronym for Respiratory Effort Related Arousal
extern QString STR_TR_PP; // Short form for Pressure Pulse
extern QString STR_TR_P; // Short form for Pressure Event

719
sleepyhead/SleepLib/day.cpp
View File

File diff suppressed because it is too large Load Diff

16
sleepyhead/SleepLib/day.h
View File

@ -33,7 +33,7 @@ class Session;
*/
class Day
{
public:
public:
Day(Machine *m);
~Day();
@ -77,7 +77,7 @@ public:
EventDataType wavg(ChannelID code);
//! \brief Returns a requested Percentile of all this sessions' events for this day
EventDataType percentile(ChannelID code,EventDataType percentile);
EventDataType percentile(ChannelID code, EventDataType percentile);
//! \brief Returns if the cache contains SummaryType information about the requested code
bool hasData(ChannelID code, SummaryType type);
@ -122,7 +122,7 @@ public:
bool hasEnabledSessions();
//! \brief Return the total time in decimal hours for this day
EventDataType hours() { return double(total_time())/3600000.0; }
EventDataType hours() { return double(total_time()) / 3600000.0; }
//! \brief Return the session indexed by i
Session *operator [](int i) { return sessions[i]; }
@ -133,7 +133,7 @@ public:
QList<Session *>::iterator end() { return sessions.end(); }
//! \brief Finds and returns the index of a session, otherwise -1 if it's not there
int find(Session * sess) { return sessions.indexOf(sess); }
int find(Session *sess) { return sessions.indexOf(sess); }
Session *find(SessionID sessid);
@ -149,7 +149,7 @@ public:
void CloseEvents();
//! \brief Returns this days sessions list
QList<Session *> & getSessions() { return sessions; }
QList<Session *> &getSessions() { return sessions; }
//! \brief Returns true if this Day contains loaded Event Data for this channel.
bool channelExists(ChannelID id);
@ -163,14 +163,14 @@ public:
//! \brief Returns true if this day contains the supplied settings Channel id
bool settingExists(ChannelID id);
void removeSession(Session * sess);
void removeSession(Session *sess);
protected:
protected:
//! \brief A Vector containing all sessions for this day
QList<Session *> sessions;
QHash<ChannelID, QHash<EventDataType, EventDataType> > perc_cache;
//qint64 d_first,d_last;
private:
private:
bool d_firstsession;
};

294
sleepyhead/SleepLib/event.cpp
View File

@ -12,19 +12,21 @@
#include <QDebug>
#include "event.h"
EventList::EventList(EventListType et,EventDataType gain, EventDataType offset, EventDataType min, EventDataType max,double rate,bool second_field)
:m_type(et),m_gain(gain),m_offset(offset),m_min(min),m_max(max),m_rate(rate),m_second_field(second_field)
EventList::EventList(EventListType et, EventDataType gain, EventDataType offset, EventDataType min,
EventDataType max, double rate, bool second_field)
: m_type(et), m_gain(gain), m_offset(offset), m_min(min), m_max(max), m_rate(rate),
m_second_field(second_field)
{
m_first=m_last=0;
m_count=0;
m_first = m_last = 0;
m_count = 0;
if (min==max) { // Update Min & Max unless forceably set here..
m_update_minmax=true;
m_min2=m_min=999999999;
m_max2=m_max=-999999999;
if (min == max) { // Update Min & Max unless forceably set here..
m_update_minmax = true;
m_min2 = m_min = 999999999;
m_max2 = m_max = -999999999;
} else {
m_update_minmax=false;
m_update_minmax = false;
}
m_data.reserve(2048);
@ -36,11 +38,11 @@ EventList::~EventList()
}
void EventList::clear()
{
m_min2=m_min=999999999;
m_max2=m_max=-999999999;
m_update_minmax=true;
m_first=m_last=0;
m_count=0;
m_min2 = m_min = 999999999;
m_max2 = m_max = -999999999;
m_update_minmax = true;
m_first = m_last = 0;
m_count = 0;
m_data.clear();
m_data2.clear();
@ -50,16 +52,16 @@ void EventList::clear()
qint64 EventList::time(quint32 i)
{
if (m_type==EVL_Event) {
return m_first+qint64(m_time[i]);
if (m_type == EVL_Event) {
return m_first + qint64(m_time[i]);
}
return m_first+qint64((EventDataType(i)*m_rate));
return m_first + qint64((EventDataType(i) * m_rate));
}
EventDataType EventList::data(quint32 i)
{
return EventDataType(m_data[i])*m_gain;
return EventDataType(m_data[i]) * m_gain;
}
EventDataType EventList::data2(quint32 i)
{
@ -71,35 +73,41 @@ void EventList::AddEvent(qint64 time, EventStoreType data)
m_data.push_back(data);
// Apply gain & offset
EventDataType val=EventDataType(data)*m_gain; // ignoring m_offset
EventDataType val = EventDataType(data) * m_gain; // ignoring m_offset
if (m_update_minmax) {
if (m_count==0) {
m_max=m_min=val;
if (m_count == 0) {
m_max = m_min = val;
} else {
if (m_min>val) m_min=val;
if (m_max<val) m_max=val;
if (m_min > val) { m_min = val; }
if (m_max < val) { m_max = val; }
}
}
if (!m_first) {
m_first=time;
m_last=time;
m_first = time;
m_last = time;
}
if (m_first>time) {
if (m_first > time) {
// Crud.. Update all the previous records
// This really shouldn't happen.
qint32 t=(m_first-time);
for (quint32 i=0;i<m_count;i++) {
m_time[i]-=t;
}
m_first=time;
}
if (m_last < time)
m_last=time;
qint32 t = (m_first - time);
quint32 t=(time-m_first);
for (quint32 i = 0; i < m_count; i++) {
m_time[i] -= t;
}
m_first = time;
}
if (m_last < time) {
m_last = time;
}
quint32 t = (time - m_first);
m_time.push_back(t);
m_count++;
@ -112,182 +120,213 @@ void EventList::AddEvent(qint64 time, EventStoreType data, EventStoreType data2)
if (m_second_field) {
m_data2.push_back(data2);
if (m_min2>data2) m_min2=data2;
if (m_max2<data2) m_max2=data2;
if (m_min2 > data2) { m_min2 = data2; }
if (m_max2 < data2) { m_max2 = data2; }
}
EventDataType val=EventDataType(data)*m_gain+m_offset;
EventDataType val = EventDataType(data) * m_gain + m_offset;
if (m_update_minmax) {
if (m_min>val) m_min=val;
if (m_max<val) m_max=val;
if (m_min > val) { m_min = val; }
if (m_max < val) { m_max = val; }
}
if (!m_first) {
m_first=time;
m_last=time;
m_first = time;
m_last = time;
}
if (m_first>time) {
if (m_first > time) {
// Crud.. Update all the previous records
// This really shouldn't happen.
qint32 t=(m_first-time);
for (quint32 i=0;i<m_count;i++) {
m_time[i]-=t;
}
m_first=time;
}
if (m_last < time)
m_last=time;
qint32 t = (m_first - time);
quint32 t=(time-m_first);
for (quint32 i = 0; i < m_count; i++) {
m_time[i] -= t;
}
m_first = time;
}
if (m_last < time) {
m_last = time;
}
quint32 t = (time - m_first);
m_time.push_back(t);
m_count++;
}
// Adds a consecutive waveform chunk
void EventList::AddWaveform(qint64 start, qint16 * data, int recs, qint64 duration)
void EventList::AddWaveform(qint64 start, qint16 *data, int recs, qint64 duration)
{
if (m_type!=EVL_Waveform) {
if (m_type != EVL_Waveform) {
qWarning() << "Attempted to add waveform data to non-waveform object";
return;
}
if (!m_rate) {
qWarning() << "Attempted to add waveform without setting sample rate";
return;
}
qint64 last=start+duration;
qint64 last = start + duration;
if (!m_first) {
m_first=start;
m_last=last;
m_first = start;
m_last = last;
}
if (m_last>start) {
if (m_last > start) {
//qWarning() << "Attempted to add waveform with previous timestamp";
// return;
// return;
// technically start should equal m_last+1 sample.. check this too.
}
if (m_last<last) {
m_last=last;
if (m_last < last) {
m_last = last;
}
// TODO: Check waveform chunk really is contiguos
//double rate=duration/recs;
//realloc buffers.
int r=m_count;
m_count+=recs;
int r = m_count;
m_count += recs;
m_data.resize(m_count);
EventStoreType *edata=m_data.data();
EventStoreType *edata = m_data.data();
EventStoreType raw;
qint16 * ep=data+recs;
qint16 * sp;
EventStoreType * dp=&edata[r];
qint16 *ep = data + recs;
qint16 *sp;
EventStoreType *dp = &edata[r];
if (m_update_minmax) {
register EventDataType min=m_min,max=m_max,val,gain=m_gain;
register EventDataType min = m_min, max = m_max, val, gain = m_gain;
//if (m_offset;
for (sp=data; sp<ep; sp++) {
*dp++=raw=*sp;
val=EventDataType(*sp)*gain+m_offset;
if (min > val) min=val;
if (max < val) max=val;
for (sp = data; sp < ep; sp++) {
*dp++ = raw = *sp;
val = EventDataType(*sp) * gain + m_offset;
if (min > val) { min = val; }
if (max < val) { max = val; }
}
m_min=min;
m_max=max;
m_min = min;
m_max = max;
} else {
//register EventDataType val,gain=m_gain;
for (sp=data; sp < ep; sp++) {
*dp++=raw=*sp;
for (sp = data; sp < ep; sp++) {
*dp++ = raw = *sp;
//val=EventDataType(raw)*gain;
}
}
}
void EventList::AddWaveform(qint64 start, unsigned char * data, int recs, qint64 duration)
void EventList::AddWaveform(qint64 start, unsigned char *data, int recs, qint64 duration)
{
if (m_type!=EVL_Waveform) {
if (m_type != EVL_Waveform) {
qWarning() << "Attempted to add waveform data to non-waveform object";
return;
}
if (!m_rate) {
qWarning() << "Attempted to add waveform without setting sample rate";
return;
}
// duration=recs*rate;
qint64 last=start+duration;
qint64 last = start + duration;
if (!m_first) {
m_first=start;
m_last=last;
m_first = start;
m_last = last;
}
if (m_last>start) {
if (m_last > start) {
//qWarning() << "Attempted to add waveform with previous timestamp";
// return;
// return;
// technically start should equal m_last+1 sample.. check this too.
}
if (m_last<last) {
m_last=last;
if (m_last < last) {
m_last = last;
}
// TODO: Check waveform chunk really is contiguos
//realloc buffers.
int r=m_count;
m_count+=recs;
int r = m_count;
m_count += recs;
m_data.resize(m_count);
EventStoreType *edata=m_data.data();
EventStoreType *edata = m_data.data();
EventStoreType raw;
EventDataType val;
unsigned char * sp;
unsigned char * ep=data+recs;
EventStoreType * dp=&edata[r];
unsigned char *sp;
unsigned char *ep = data + recs;
EventStoreType *dp = &edata[r];
if (m_update_minmax) {
// ignoring m_offset
for (sp=data; sp < ep; sp++) {
raw=*sp;
val=EventDataType(raw)*m_gain;
if (m_min>val) m_min=val;
if (m_max<val) m_max=val;
*dp++=raw;
for (sp = data; sp < ep; sp++) {
raw = *sp;
val = EventDataType(raw) * m_gain;
if (m_min > val) { m_min = val; }
if (m_max < val) { m_max = val; }
*dp++ = raw;
}
} else {
for (sp=data; sp < ep; sp++) {
raw=*sp;
val=EventDataType(raw)*m_gain;
*dp++=raw;
for (sp = data; sp < ep; sp++) {
raw = *sp;
val = EventDataType(raw) * m_gain;
*dp++ = raw;
}
}
}
void EventList::AddWaveform(qint64 start, char * data, int recs, qint64 duration)
void EventList::AddWaveform(qint64 start, char *data, int recs, qint64 duration)
{
if (m_type!=EVL_Waveform) {
if (m_type != EVL_Waveform) {
qWarning() << "Attempted to add waveform data to non-waveform object";
return;
}
if (!m_rate) {
qWarning() << "Attempted to add waveform without setting sample rate";
return;
}
// duration=recs*rate;
qint64 last=start+duration;
qint64 last = start + duration;
if (!m_first) {
m_first=start;
m_last=last;
m_first = start;
m_last = last;
} else {
if (m_last>start) {
if (m_last > start) {
//qWarning() << "Attempted to add waveform with previous timestamp";
//return;
// technically start should equal m_last+1 sample.. check this too.
}
if (m_last<last) {
m_last=last;
if (m_last < last) {
m_last = last;
}
}
@ -295,31 +334,34 @@ void EventList::AddWaveform(qint64 start, char * data, int recs, qint64 duration
//realloc buffers.
int r=m_count;
m_count+=recs;
int r = m_count;
m_count += recs;
m_data.resize(m_count);
EventStoreType *edata=m_data.data();
EventStoreType *edata = m_data.data();
EventStoreType raw;
EventDataType val;
char * sp;
char * ep=data+recs;
EventStoreType * dp=&edata[r];
char *sp;
char *ep = data + recs;
EventStoreType *dp = &edata[r];
if (m_update_minmax) {
for (sp=data; sp < ep; sp++) {
raw=*sp;
val=EventDataType(val)*m_gain+m_offset;
if (m_min>val) m_min=val;
if (m_max<val) m_max=val;
*dp++=raw;
for (sp = data; sp < ep; sp++) {
raw = *sp;
val = EventDataType(val) * m_gain + m_offset;
if (m_min > val) { m_min = val; }
if (m_max < val) { m_max = val; }
*dp++ = raw;
}
} else {
for (sp=data; sp < ep; sp++) {
raw=*sp;
val=EventDataType(val)*m_gain+m_offset;
*dp++=raw;
for (sp = data; sp < ep; sp++) {
raw = *sp;
val = EventDataType(val) * m_gain + m_offset;
*dp++ = raw;
}
}
}

87
sleepyhead/SleepLib/event.h
View File

@ -26,8 +26,9 @@ enum EventListType { EVL_Waveform, EVL_Event };
class EventList
{
friend class Session;
public:
EventList(EventListType et,EventDataType gain=1.0, EventDataType offset=0.0, EventDataType min=0.0, EventDataType max=0.0, double rate=0.0,bool second_field=false);
public:
EventList(EventListType et, EventDataType gain = 1.0, EventDataType offset = 0.0,
EventDataType min = 0.0, EventDataType max = 0.0, double rate = 0.0, bool second_field = false);
~EventList();
//! \brief Wipe the event list so it can be reused
@ -37,15 +38,15 @@ public:
Note, data2 is only used if second_field is specified in the constructor */
void AddEvent(qint64 time, EventStoreType data);
void AddEvent(qint64 time, EventStoreType data, EventStoreType data2);
void AddWaveform(qint64 start, qint16 * data, int recs, qint64 duration);
void AddWaveform(qint64 start, unsigned char * data, int recs, qint64 duration);
void AddWaveform(qint64 start, char * data, int recs, qint64 duration);
void AddWaveform(qint64 start, qint16 *data, int recs, qint64 duration);
void AddWaveform(qint64 start, unsigned char *data, int recs, qint64 duration);
void AddWaveform(qint64 start, char *data, int recs, qint64 duration);
//! \brief Returns a count of records contained in this EventList
inline const quint32 & count() { return m_count; }
inline const quint32 &count() { return m_count; }
//! \brief Manually sets a count of records contained in this EventList
void setCount(quint32 count) { m_count=count; }
void setCount(quint32 count) { m_count = count; }
//! \brief Returns a raw ("ungained") data value from index position i
inline EventStoreType raw(int i) { return m_data[i]; }
@ -66,96 +67,96 @@ public:
bool hasSecondField() { return m_second_field; }
//! \brief Returns the first events/waveforms starting time in milliseconds since epoch
inline const qint64 & first() { return m_first; }
inline const qint64 &first() { return m_first; }
//! \brief Returns the last events/waveforms ending time in milliseconds since epoch
inline const qint64 & last() { return m_last; }
inline const qint64 &last() { return m_last; }
//! \brief Returns the timespan covered by this EventList, in milliseconds since epoch
inline qint64 duration() { return m_last-m_first; }
inline qint64 duration() { return m_last - m_first; }
//! \brief Sets the first events/waveforms starting time in milliseconds since epoch
void setFirst(qint64 val) { m_first=val; }
void setFirst(qint64 val) { m_first = val; }
//! \brief Sets the last events/waveforms ending time in milliseconds since epoch
void setLast(qint64 val) { m_last=val; }
void setLast(qint64 val) { m_last = val; }
//! \brief Set this EventList to either EVL_Waveform or EVL_Event type
void setType(EventListType type) { m_type=type; }
void setType(EventListType type) { m_type = type; }
//! \brief Change the gain multiplier value
void setGain(EventDataType v) { m_gain=v; }
void setGain(EventDataType v) { m_gain = v; }
//! \brief Change the gain offset value
void setOffset(EventDataType v) { m_offset=v; }
void setOffset(EventDataType v) { m_offset = v; }
//! \brief Set the Minimum value for data
void setMin(EventDataType v) { m_min=v; }
void setMin(EventDataType v) { m_min = v; }
//! \brief Set the Maximum value for data
void setMax(EventDataType v) { m_max=v; }
void setMax(EventDataType v) { m_max = v; }
//! \brief Set the Minimum value for data2
void setMin2(EventDataType v) { m_min2=v; }
void setMin2(EventDataType v) { m_min2 = v; }
//! \brief Set the Maximum value for data2
void setMax2(EventDataType v) { m_max2=v; }
void setMax2(EventDataType v) { m_max2 = v; }
//! \brief Set the sample rate
void setRate(EventDataType v) { m_rate=v; }
void setRate(EventDataType v) { m_rate = v; }
//void setCode(ChannelID id) { m_code=id; }
//! \brief Return the Minimum data value
inline const EventDataType & Min() { return m_min; }
inline const EventDataType &Min() { return m_min; }
//! \brief Return the Maximum data value
inline const EventDataType & Max() { return m_max; }
inline const EventDataType &Max() { return m_max; }
//! \brief Return the Minimum data2 value
inline const EventDataType & min2() { return m_min2; }
inline const EventDataType &min2() { return m_min2; }
//! \brief Return the Maximum data value
inline const EventDataType & max2() { return m_max2; }
inline const EventDataType &max2() { return m_max2; }
//! \brief Return the gain value
inline const EventDataType & gain() { return m_gain; }
inline const EventDataType &gain() { return m_gain; }
//! \brief Return the gain offset
inline const EventDataType & offset() { return m_offset; }
inline const EventDataType &offset() { return m_offset; }
//! \brief Return the sample rate
inline const EventDataType & rate() { return m_rate; }
inline const EventDataType &rate() { return m_rate; }
//! \brief Return the EventList type, either EVL_Waveform or EVL_Event
inline const EventListType & type() { return m_type; }
inline const EventListType &type() { return m_type; }
//inline const ChannelID & code() { return m_code; }
//! \brief Returns whether or not min/max values are updated while adding events
inline const bool & update_minmax() { return m_update_minmax; }
inline const bool &update_minmax() { return m_update_minmax; }
//! \brief Returns the dimension (units type) of the contained data object
QString dimension() { return m_dimension; }
//! \brief Sets the dimension (units type) of the contained data object
void setDimension(QString dimension) { m_dimension=dimension; }
void setDimension(QString dimension) { m_dimension = dimension; }
//! \brief Returns the data storage vector
QVector<EventStoreType> & getData() { return m_data; }
QVector<EventStoreType> &getData() { return m_data; }
//! \brief Returns the data2 storage vector
QVector<EventStoreType> & getData2() { return m_data2; }
QVector<EventStoreType> &getData2() { return m_data2; }
//! \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:
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:
//! \brief The time storage vector, in 32bits delta format, added as offsets to m_first
QVector<quint32> m_time;
@ -175,13 +176,13 @@ protected:
EventDataType m_gain;
EventDataType m_offset;
EventDataType m_min,m_min2;
EventDataType m_max,m_max2;
EventDataType m_min, m_min2;
EventDataType m_max, m_max2;
EventDataType m_rate; // Waveform sample rate
QString m_dimension;
qint64 m_first,m_last;
qint64 m_first, m_last;
bool m_update_minmax;
bool m_second_field;
};

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

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

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

@ -14,8 +14,8 @@
#include "SleepLib/machine_loader.h"
const QString cms50_class_name="CMS50";
const int cms50_data_version=4;
const QString cms50_class_name = "CMS50";
const int cms50_data_version = 4;
/*! \class CMS50Loader
@ -23,26 +23,26 @@ const int cms50_data_version=4;
*/
class CMS50Loader : public MachineLoader
{
public:
public:
CMS50Loader();
virtual ~CMS50Loader();
virtual int Open(QString & path,Profile *profile);
static void Register();
CMS50Loader();
virtual ~CMS50Loader();
virtual int Open(QString &path, Profile *profile);
static void Register();
virtual int Version() { return cms50_data_version; }
virtual const QString & ClassName() { return cms50_class_name; }
virtual int Version() { return cms50_data_version; }
virtual const QString &ClassName() { return cms50_class_name; }
Machine *CreateMachine(Profile *profile);
Machine *CreateMachine(Profile *profile);
protected:
int OpenCMS50(QString & path, Profile *profile);
bool OpenSPORFile(QString path, Machine * machine,Profile *profile);
protected:
int OpenCMS50(QString &path, Profile *profile);
bool OpenSPORFile(QString path, Machine *machine, Profile *profile);
private:
char *buffer;
private:
char *buffer;
};
#endif // CMS50LOADER_H

729
sleepyhead/SleepLib/loader_plugins/icon_loader.cpp
View File

File diff suppressed because it is too large Load Diff

38
sleepyhead/SleepLib/loader_plugins/icon_loader.h
View File

@ -23,25 +23,25 @@
//********************************************************************************************
// Please INCREMENT the following value when making changes to this loaders implementation.
//
const int fpicon_data_version=2;
const int fpicon_data_version = 2;
//
//********************************************************************************************
/*! \class FPIcon
\brief F&P Icon customized machine object
*/
class FPIcon:public CPAP
class FPIcon: public CPAP
{
public:
FPIcon(Profile *p,MachineID id=0);
public:
FPIcon(Profile *p, MachineID id = 0);
virtual ~FPIcon();
};
const int fpicon_load_buffer_size=1024*1024;
const int fpicon_load_buffer_size = 1024 * 1024;
const QString fpicon_class_name=STR_MACH_FPIcon;
const QString fpicon_class_name = STR_MACH_FPIcon;
/*! \class FPIconLoader
\brief Loader for Fisher & Paykel Icon data
@ -50,38 +50,38 @@ const QString fpicon_class_name=STR_MACH_FPIcon;
class FPIconLoader : public MachineLoader
{
public:
public:
FPIconLoader();
virtual ~FPIconLoader();
//! \brief Scans path for F&P Icon data signature, and Loads any new data
virtual int Open(QString & path,Profile *profile);
virtual int Open(QString &path, Profile *profile);
int OpenMachine(Machine *mach, QString & path, Profile * profile);
int OpenMachine(Machine *mach, QString &path, Profile *profile);
bool OpenSummary(Machine *mach, QString path, Profile * profile);
bool OpenDetail(Machine *mach, QString path, Profile * profile);
bool OpenFLW(Machine * mach,QString filename, Profile * profile);
bool OpenSummary(Machine *mach, QString path, Profile *profile);
bool OpenDetail(Machine *mach, QString path, Profile *profile);
bool OpenFLW(Machine *mach, QString filename, Profile *profile);
//! \brief Returns SleepLib database version of this F&P Icon loader
virtual int Version() { return fpicon_data_version; }
//! \brief Returns the machine class name of this CPAP machine, "FPIcon"
virtual const QString & ClassName() { return fpicon_class_name; }
virtual const QString &ClassName() { return fpicon_class_name; }
//! \brief Creates a machine object, indexed by serial number
Machine *CreateMachine(QString serial,Profile *profile);
Machine *CreateMachine(QString serial, Profile *profile);
//! \brief Registers this MachineLoader with the master list, so F&P Icon data can load
static void Register();
protected:
QDateTime readFPDateTime(quint8 * data);
protected:
QDateTime readFPDateTime(quint8 *data);
QString last;
QHash<QString,Machine *> MachList;
QHash<QString, Machine *> MachList;
QMap<SessionID, Session *> Sessions;
QMultiMap<QDate,Session *> SessDate;
QMultiMap<QDate, Session *> SessDate;
//QMap<int,QList<EventList *> > FLWMapFlow;
//QMap<int,QList<EventList *> > FLWMapLeak;
//QMap<int,QList<EventList *> > FLWMapPres;
@ -89,7 +89,7 @@ protected:
//QMap<int,QList<qint64> > FLWTS;
//QMap<int,QDate> FLWDate;
unsigned char * m_buffer;
unsigned char *m_buffer;
};
#endif // ICON_LOADER_H

419
sleepyhead/SleepLib/loader_plugins/intellipap_loader.cpp
View File

@ -17,10 +17,10 @@
extern QProgressBar *qprogress;
Intellipap::Intellipap(Profile *p,MachineID id)
:CPAP(p,id)
Intellipap::Intellipap(Profile *p, MachineID id)
: CPAP(p, id)
{
m_class=intellipap_class_name;
m_class = intellipap_class_name;
}
Intellipap::~Intellipap()
@ -29,27 +29,28 @@ Intellipap::~Intellipap()
IntellipapLoader::IntellipapLoader()
{
m_buffer=NULL;
m_buffer = NULL;
}
IntellipapLoader::~IntellipapLoader()
{
}
int IntellipapLoader::Open(QString & path,Profile *profile)
int IntellipapLoader::Open(QString &path, Profile *profile)
{
// Check for SL directory
// Check for DV5MFirm.bin?
QString newpath;
path=path.replace("\\","/");
path = path.replace("\\", "/");
QString dirtag="SL";
if (path.endsWith("/"+dirtag)) {
QString dirtag = "SL";
if (path.endsWith("/" + dirtag)) {
return 0;
//newpath=path;
} else {
newpath=path+"/"+dirtag;
newpath = path + "/" + dirtag;
}
QString filename;
@ -57,84 +58,94 @@ int IntellipapLoader::Open(QString & path,Profile *profile)
//////////////////////////
// Parse the Settings File
//////////////////////////
filename=newpath+"/SET1";
filename = newpath + "/SET1";
QFile f(filename);
if (!f.exists()) return 0;
if (!f.exists()) { return 0; }
f.open(QFile::ReadOnly);
QTextStream tstream(&f);
QHash<QString,QString> lookup;
lookup["Sn"]=STR_PROP_Serial;
lookup["Mn"]=STR_PROP_ModelNumber;
lookup["Mo"]="PAPMode"; // 0=cpap, 1=auto
QHash<QString, QString> lookup;
lookup["Sn"] = STR_PROP_Serial;
lookup["Mn"] = STR_PROP_ModelNumber;
lookup["Mo"] = "PAPMode"; // 0=cpap, 1=auto
//lookup["Pn"]="Pn";
lookup["Pu"]="MaxPressure";
lookup["Pl"]="MinPressure";
lookup["Pu"] = "MaxPressure";
lookup["Pl"] = "MinPressure";
//lookup["Ds"]="Ds";
//lookup["Pc"]="Pc";
lookup["Pd"]="RampPressure"; // Delay Pressure
lookup["Dt"]="RampTime"; // Delay Time
lookup["Pd"] = "RampPressure"; // Delay Pressure
lookup["Dt"] = "RampTime"; // Delay Time
//lookup["Ld"]="Ld";
//lookup["Lh"]="Lh";
//lookup["FC"]="FC";
//lookup["FE"]="FE";
//lookup["FL"]="FL";
lookup["A%"]="ApneaThreshold";
lookup["Ad"]="ApneaDuration";
lookup["H%"]="HypopneaThreshold";
lookup["Hd"]="HypopneaDuration";
lookup["A%"] = "ApneaThreshold";
lookup["Ad"] = "ApneaDuration";
lookup["H%"] = "HypopneaThreshold";
lookup["Hd"] = "HypopneaDuration";
//lookup["Pi"]="Pi"; //080
//lookup["Pe"]="Pe"; //WF
lookup["Ri"]="SmartFlexIRnd"; // Inhale Rounding (0-5)
lookup["Re"]="SmartFlexERnd"; // Exhale Rounding (0-5)
lookup["Ri"] = "SmartFlexIRnd"; // Inhale Rounding (0-5)
lookup["Re"] = "SmartFlexERnd"; // Exhale Rounding (0-5)
//lookup["Bu"]="Bu"; //WF
//lookup["Ie"]="Ie"; //20
//lookup["Se"]="Se"; //05
//lookup["Si"]="Si"; //05
//lookup["Mi"]="Mi"; //0
lookup["Uh"]="HoursMeter"; //0000.0
lookup["Up"]="ComplianceMeter"; //0000.0
lookup["Uh"] = "HoursMeter"; //0000.0
lookup["Up"] = "ComplianceMeter"; //0000.0
//lookup["Er"]="ErrorCode"; // E00
//lookup["El"]="LastErrorCode"; // E00 00/00/0000
//lookup["Hp"]="Hp"; //1
//lookup["Hs"]="Hs"; //02
//lookup["Lu"]="LowUseThreshold"; // defaults to 0 (4 hours)
lookup["Sf"]="SmartFlex";
lookup["Sm"]="SmartFlexMode";
lookup["Ks=s"]="Ks_s";
lookup["Ks=i"]="Ks_i";
lookup["Sf"] = "SmartFlex";
lookup["Sm"] = "SmartFlexMode";
lookup["Ks=s"] = "Ks_s";
lookup["Ks=i"] = "Ks_i";
QHash<QString, QString> set1;
QHash<QString, QString>::iterator hi;
QHash<QString,QString> set1;
QHash<QString,QString>::iterator hi;
while (1) {
QString line=tstream.readLine();
if ((line.length()<=2) ||
(line.isNull())) break;
QString key=line.section("\t",0,0).trimmed();
hi=lookup.find(key);
if (hi!=lookup.end()) {
key=hi.value();
QString line = tstream.readLine();
if ((line.length() <= 2) ||
(line.isNull())) { break; }
QString key = line.section("\t", 0, 0).trimmed();
hi = lookup.find(key);
if (hi != lookup.end()) {
key = hi.value();
}
QString value=line.section("\t",1).trimmed();
set1[key]=value;
QString value = line.section("\t", 1).trimmed();
set1[key] = value;
qDebug() << key << "=" << value;
}
Machine *mach=NULL;
Machine *mach = NULL;
if (set1.contains(STR_PROP_Serial)) {
mach=CreateMachine(set1[STR_PROP_Serial],profile);
mach = CreateMachine(set1[STR_PROP_Serial], profile);
}
if (!mach) {
qDebug() << "Couldn't get Intellipap machine record";
return 0;
}
// Refresh properties data..
for (QHash<QString,QString>::iterator i=set1.begin();i!=set1.end();i++) {
mach->properties[i.key()]=i.value();
for (QHash<QString, QString>::iterator i = set1.begin(); i != set1.end(); i++) {
mach->properties[i.key()] = i.value();
}
mach->properties[STR_PROP_Model]=STR_MACH_Intellipap+" "+mach->properties[STR_PROP_ModelNumber];
mach->properties[STR_PROP_Model] = STR_MACH_Intellipap + " " +
mach->properties[STR_PROP_ModelNumber];
f.close();
@ -142,85 +153,92 @@ int IntellipapLoader::Open(QString & path,Profile *profile)
// Parse the Session Index
//////////////////////////
unsigned char buf[27];
filename=newpath+"/U";
filename = newpath + "/U";
f.setFileName(filename);
if (!f.exists()) return 0;
if (!f.exists()) { return 0; }
QVector<quint32> SessionStart;
QVector<quint32> SessionEnd;
QHash<SessionID,Session *> Sessions;
QHash<SessionID, Session *> Sessions;
quint32 ts1, ts2;//, length;
//unsigned char cs;
f.open(QFile::ReadOnly);
int cnt=0;
QDateTime epoch(QDate(2002,1,1),QTime(0,0,0),Qt::UTC); // Intellipap Epoch
int ep=epoch.toTime_t();
int cnt = 0;
QDateTime epoch(QDate(2002, 1, 1), QTime(0, 0, 0), Qt::UTC); // Intellipap Epoch
int ep = epoch.toTime_t();
do {
cnt=f.read((char *)buf,9);
ts1=(buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
ts2=(buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
ts1+=ep;
ts2+=ep;
cnt = f.read((char *)buf, 9);
ts1 = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
ts2 = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
ts1 += ep;
ts2 += ep;
SessionStart.append(ts1);
SessionEnd.append(ts2);
//cs=buf[8];
} while (cnt>0);
} while (cnt > 0);
qDebug() << "U file logs" << SessionStart.size() << "sessions.";
f.close();
//////////////////////////
// Parse the Session Data
//////////////////////////
filename=newpath+"/L";
filename = newpath + "/L";
f.setFileName(filename);
if (!f.exists()) return 0;
if (!f.exists()) { return 0; }
f.open(QFile::ReadOnly);
long size=f.size();
int recs=size/26;
m_buffer=new unsigned char [size];
long size = f.size();
int recs = size / 26;
m_buffer = new unsigned char [size];
if (size!=f.read((char *)m_buffer,size)) {
qDebug() << "Couldn't read 'L' data"<< filename;
if (size != f.read((char *)m_buffer, size)) {
qDebug() << "Couldn't read 'L' data" << filename;
return 0;
}
Session *sess;
SessionID sid;
for (int i=0;i<SessionStart.size();i++) {
sid=SessionStart[i];
for (int i = 0; i < SessionStart.size(); i++) {
sid = SessionStart[i];
if (mach->SessionExists(sid)) {
// knock out the already imported sessions..
SessionStart[i]=0;
SessionEnd[i]=0;
SessionStart[i] = 0;
SessionEnd[i] = 0;
} else if (!Sessions.contains(sid)) {
sess=Sessions[sid]=new Session(mach,sid);
sess = Sessions[sid] = new Session(mach, sid);
sess->SetChanged(true);
sess->AddEventList(CPAP_IPAP,EVL_Event);
sess->AddEventList(CPAP_EPAP,EVL_Event);
sess->AddEventList(CPAP_Pressure,EVL_Event);
sess->AddEventList(CPAP_IPAP, EVL_Event);
sess->AddEventList(CPAP_EPAP, EVL_Event);
sess->AddEventList(CPAP_Pressure, EVL_Event);
sess->AddEventList(INTELLIPAP_Unknown1,EVL_Event);
sess->AddEventList(INTELLIPAP_Unknown2,EVL_Event);
sess->AddEventList(INTELLIPAP_Unknown1, EVL_Event);
sess->AddEventList(INTELLIPAP_Unknown2, EVL_Event);
sess->AddEventList(CPAP_LeakTotal,EVL_Event);
sess->AddEventList(CPAP_MaxLeak,EVL_Event);
sess->AddEventList(CPAP_TidalVolume,EVL_Event);
sess->AddEventList(CPAP_MinuteVent,EVL_Event);
sess->AddEventList(CPAP_RespRate,EVL_Event);
sess->AddEventList(CPAP_Snore,EVL_Event);
sess->AddEventList(CPAP_LeakTotal, EVL_Event);
sess->AddEventList(CPAP_MaxLeak, EVL_Event);
sess->AddEventList(CPAP_TidalVolume, EVL_Event);
sess->AddEventList(CPAP_MinuteVent, EVL_Event);
sess->AddEventList(CPAP_RespRate, EVL_Event);
sess->AddEventList(CPAP_Snore, EVL_Event);
} else {
// If there is a double up, null out the earlier session
// otherwise there will be a crash on shutdown.
for (int z=0;z<SessionStart.size();z++) {
if (SessionStart[z]==(quint32)sid) {
SessionStart[z]=0;
SessionEnd[z]=0;
for (int z = 0; z < SessionStart.size(); z++) {
if (SessionStart[z] == (quint32)sid) {
SessionStart[z] = 0;
SessionEnd[z] = 0;
break;
}
}
QDateTime d=QDateTime::fromTime_t(sid);
QDateTime d = QDateTime::fromTime_t(sid);
qDebug() << sid << "has double ups" << d;
/*Session *sess=Sessions[sid];
Sessions.erase(Sessions.find(sid));
@ -230,197 +248,226 @@ int IntellipapLoader::Open(QString & path,Profile *profile)
}
}
long pos=0;
for (int i=0;i<recs;i++) {
long pos = 0;
for (int i = 0; i < recs; i++) {
// convert timestamp to real epoch
ts1=((m_buffer[pos] << 24) | (m_buffer[pos+1] << 16) | (m_buffer[pos+2] << 8) | m_buffer[pos+3]) + ep;
ts1 = ((m_buffer[pos] << 24) | (m_buffer[pos + 1] << 16) | (m_buffer[pos + 2] << 8) | m_buffer[pos
+ 3]) + ep;
for (int j=0;j<SessionStart.size();j++) {
sid=SessionStart[j];
if (!sid) continue;
if ((ts1>=(quint32)sid) && (ts1<=SessionEnd[j])){
Session *sess=Sessions[sid];
qint64 time=quint64(ts1)*1000L;
sess->eventlist[CPAP_Pressure][0]->AddEvent(time,m_buffer[pos+0xd]/10.0); // current pressure
sess->eventlist[CPAP_EPAP][0]->AddEvent(time,m_buffer[pos+0x13]/10.0); // epap / low
sess->eventlist[CPAP_IPAP][0]->AddEvent(time,m_buffer[pos+0x14]/10.0); // ipap / high
for (int j = 0; j < SessionStart.size(); j++) {
sid = SessionStart[j];
sess->eventlist[CPAP_LeakTotal][0]->AddEvent(time,m_buffer[pos+0x7]); // "Average Leak"
sess->eventlist[CPAP_MaxLeak][0]->AddEvent(time,m_buffer[pos+0x6]); // "Max Leak"
if (!sid) { continue; }
int rr=m_buffer[pos+0xa];
sess->eventlist[CPAP_RespRate][0]->AddEvent(time,rr); // Respiratory Rate
sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time,m_buffer[pos+0xf]); //
sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time,m_buffer[pos+0xc]);
if ((ts1 >= (quint32)sid) && (ts1 <= SessionEnd[j])) {
Session *sess = Sessions[sid];
qint64 time = quint64(ts1) * 1000L;
sess->eventlist[CPAP_Pressure][0]->AddEvent(time, m_buffer[pos + 0xd] / 10.0); // current pressure
sess->eventlist[CPAP_EPAP][0]->AddEvent(time, m_buffer[pos + 0x13] / 10.0); // epap / low
sess->eventlist[CPAP_IPAP][0]->AddEvent(time, m_buffer[pos + 0x14] / 10.0); // ipap / high
sess->eventlist[CPAP_Snore][0]->AddEvent(time,m_buffer[pos+0x4]); //4/5??
sess->eventlist[CPAP_LeakTotal][0]->AddEvent(time, m_buffer[pos + 0x7]); // "Average Leak"
sess->eventlist[CPAP_MaxLeak][0]->AddEvent(time, m_buffer[pos + 0x6]); // "Max Leak"
int rr = m_buffer[pos + 0xa];
sess->eventlist[CPAP_RespRate][0]->AddEvent(time, rr); // Respiratory Rate
sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time, m_buffer[pos + 0xf]); //
sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time, m_buffer[pos + 0xc]);
sess->eventlist[CPAP_Snore][0]->AddEvent(time, m_buffer[pos + 0x4]); //4/5??
// 0x0f == Leak Event
// 0x04 == Snore?
if (m_buffer[pos+0xf]>0) { // Leak Event
if (m_buffer[pos + 0xf] > 0) { // Leak Event
if (!sess->eventlist.contains(CPAP_LeakFlag)) {
sess->AddEventList(CPAP_LeakFlag,EVL_Event);
sess->AddEventList(CPAP_LeakFlag, EVL_Event);
}
sess->eventlist[CPAP_LeakFlag][0]->AddEvent(time,m_buffer[pos+0xf]);
sess->eventlist[CPAP_LeakFlag][0]->AddEvent(time, m_buffer[pos + 0xf]);
}
if (m_buffer[pos+0x5]>4) { // This matches Exhale Puff.. not sure why 4
if (m_buffer[pos + 0x5] > 4) { // This matches Exhale Puff.. not sure why 4
if (!sess->eventlist.contains(CPAP_ExP)) {
sess->AddEventList(CPAP_ExP,EVL_Event);
sess->AddEventList(CPAP_ExP, EVL_Event);
}
for (int q=0;q<m_buffer[pos+0x5];q++)
sess->eventlist[CPAP_ExP][0]->AddEvent(time,m_buffer[pos+0x5]);
for (int q = 0; q < m_buffer[pos + 0x5]; q++) {
sess->eventlist[CPAP_ExP][0]->AddEvent(time, m_buffer[pos + 0x5]);
}
}
if (m_buffer[pos+0x10]>0) {
if (m_buffer[pos + 0x10] > 0) {
if (!sess->eventlist.contains(CPAP_Obstructive)) {
sess->AddEventList(CPAP_Obstructive,EVL_Event);
sess->AddEventList(CPAP_Obstructive, EVL_Event);
}
for (int q = 0; q < m_buffer[pos + 0x10]; q++) {
sess->eventlist[CPAP_Obstructive][0]->AddEvent(time, m_buffer[pos + 0x10]);
}
for (int q=0;q<m_buffer[pos+0x10];q++)
sess->eventlist[CPAP_Obstructive][0]->AddEvent(time,m_buffer[pos+0x10]);
}
if (m_buffer[pos+0x11]>0) {
if (m_buffer[pos + 0x11] > 0) {
if (!sess->eventlist.contains(CPAP_Hypopnea)) {
sess->AddEventList(CPAP_Hypopnea,EVL_Event);
sess->AddEventList(CPAP_Hypopnea, EVL_Event);
}
for (int q = 0; q < m_buffer[pos + 0x11]; q++) {
sess->eventlist[CPAP_Hypopnea][0]->AddEvent(time, m_buffer[pos + 0x11]);
}
for (int q=0;q<m_buffer[pos+0x11];q++)
sess->eventlist[CPAP_Hypopnea][0]->AddEvent(time,m_buffer[pos+0x11]);
}
if (m_buffer[pos+0x12]>0) { // NRI // is this == to RERA?? CA??
if (m_buffer[pos + 0x12] > 0) { // NRI // is this == to RERA?? CA??
if (!sess->eventlist.contains(CPAP_NRI)) {
sess->AddEventList(CPAP_NRI,EVL_Event);
sess->AddEventList(CPAP_NRI, EVL_Event);
}
for (int q = 0; q < m_buffer[pos + 0x12]; q++) {
sess->eventlist[CPAP_NRI][0]->AddEvent(time, m_buffer[pos + 0x12]);
}
for (int q=0;q<m_buffer[pos+0x12];q++)
sess->eventlist[CPAP_NRI][0]->AddEvent(time,m_buffer[pos+0x12]);
}
quint16 tv=(m_buffer[pos+0x8] << 8) | m_buffer[pos+0x9]; // correct
sess->eventlist[CPAP_TidalVolume][0]->AddEvent(time,tv);
quint16 tv = (m_buffer[pos + 0x8] << 8) | m_buffer[pos + 0x9]; // correct
EventDataType mv=tv*rr; // MinuteVent=TidalVolume * Respiratory Rate
sess->eventlist[CPAP_MinuteVent][0]->AddEvent(time,mv/1000.0);
sess->eventlist[CPAP_TidalVolume][0]->AddEvent(time, tv);
EventDataType mv = tv * rr; // MinuteVent=TidalVolume * Respiratory Rate
sess->eventlist[CPAP_MinuteVent][0]->AddEvent(time, mv / 1000.0);
break;
}
}
pos+=26;
pos += 26;
}
for (int i=0;i<SessionStart.size();i++) {
SessionID sid=SessionStart[i];
for (int i = 0; i < SessionStart.size(); i++) {
SessionID sid = SessionStart[i];
if (sid) {
sess=Sessions[sid];
sess = Sessions[sid];
//if (sess->eventlist.size()==0) {
// delete sess;
// continue;
// delete sess;
// continue;
//}
quint64 first=qint64(sid)*1000L;
quint64 last=qint64(SessionEnd[i])*1000L;
quint64 first = qint64(sid) * 1000L;
quint64 last = qint64(SessionEnd[i]) * 1000L;
sess->settings[CPAP_PresReliefType]=(PRTypes)PR_SMARTFLEX;
int i=set1["SmartFlex"].toInt();
sess->settings[CPAP_PresReliefSet]=i;
int sfm=set1["SmartFlexMode"].toInt();
if (sfm==0) {
sess->settings[CPAP_PresReliefMode]=PM_FullTime;
sess->settings[CPAP_PresReliefType] = (PRTypes)PR_SMARTFLEX;
int i = set1["SmartFlex"].toInt();
sess->settings[CPAP_PresReliefSet] = i;
int sfm = set1["SmartFlexMode"].toInt();
if (sfm == 0) {
sess->settings[CPAP_PresReliefMode] = PM_FullTime;
} else {
sess->settings[CPAP_PresReliefMode]=PM_RampOnly;
sess->settings[CPAP_PresReliefMode] = PM_RampOnly;
}
EventDataType max=sess->Max(CPAP_IPAP);
EventDataType min=sess->Min(CPAP_EPAP);
EventDataType pres=sess->Min(CPAP_Pressure);
if (max==min) {
sess->settings[CPAP_Mode]=(int)MODE_CPAP;
sess->settings[CPAP_Pressure]=min;
EventDataType max = sess->Max(CPAP_IPAP);
EventDataType min = sess->Min(CPAP_EPAP);
EventDataType pres = sess->Min(CPAP_Pressure);
if (max == min) {
sess->settings[CPAP_Mode] = (int)MODE_CPAP;
sess->settings[CPAP_Pressure] = min;
} else {
sess->settings[CPAP_Mode]=(int)MODE_APAP;
sess->settings[CPAP_PressureMin]=min;
sess->settings[CPAP_PressureMax]=max;
sess->settings[CPAP_Mode] = (int)MODE_APAP;
sess->settings[CPAP_PressureMin] = min;
sess->settings[CPAP_PressureMax] = max;
}
sess->eventlist.erase(sess->eventlist.find(CPAP_IPAP));
sess->eventlist.erase(sess->eventlist.find(CPAP_EPAP));
sess->m_min.erase(sess->m_min.find(CPAP_EPAP));
sess->m_max.erase(sess->m_max.find(CPAP_EPAP));
if (pres<min) {
sess->settings[CPAP_RampPressure]=pres;
if (pres < min) {
sess->settings[CPAP_RampPressure] = pres;
}
//quint64 len=last-first;
//if (len>0) {
//if (!sess->first()) {
sess->set_first(first);
sess->set_last(last);
// }
sess->UpdateSummaries();
mach->AddSession(sess,profile);
//if (!sess->first()) {
sess->set_first(first);
sess->set_last(last);
// }
sess->UpdateSummaries();
mach->AddSession(sess, profile);
/*} else {
delete sess;
}*/
}
}
mach->properties[STR_PROP_DataVersion]=QString().sprintf("%i",intellipap_data_version);
mach->properties[STR_PROP_DataVersion] = QString().sprintf("%i", intellipap_data_version);
mach->Save();
delete [] m_buffer;
if (qprogress) qprogress->setValue(100);
if (qprogress) { qprogress->setValue(100); }
f.close();
return 1;
}
Machine *IntellipapLoader::CreateMachine(QString serial,Profile *profile)
Machine *IntellipapLoader::CreateMachine(QString serial, Profile *profile)
{
if (!profile)
if (!profile) {
return NULL;
}
qDebug() << "Create Machine " << serial;
QList<Machine *> ml=profile->GetMachines(MT_CPAP);
bool found=false;
QList<Machine *> ml = profile->GetMachines(MT_CPAP);
bool found = false;
QList<Machine *>::iterator i;
Machine *m=NULL;
for (i=ml.begin(); i!=ml.end(); i++) {
if (((*i)->GetClass()==intellipap_class_name) && ((*i)->properties[STR_PROP_Serial]==serial)) {
MachList[serial]=*i; //static_cast<CPAP *>(*i);
found=true;
m=*i;
Machine *m = NULL;
for (i = ml.begin(); i != ml.end(); i++) {
if (((*i)->GetClass() == intellipap_class_name) && ((*i)->properties[STR_PROP_Serial] == serial)) {
MachList[serial] = *i; //static_cast<CPAP *>(*i);
found = true;
m = *i;
break;
}
}
if (!found) {
m=new Intellipap(profile,0);
m = new Intellipap(profile, 0);
}
m->properties[STR_PROP_Brand]="DeVilbiss";
m->properties[STR_PROP_Series]=STR_MACH_Intellipap;
if (found)
m->properties[STR_PROP_Brand] = "DeVilbiss";
m->properties[STR_PROP_Series] = STR_MACH_Intellipap;
if (found) {
return m;
}
MachList[serial]=m;
MachList[serial] = m;
profile->AddMachine(m);
m->properties[STR_PROP_Serial]=serial;
m->properties[STR_PROP_DataVersion]=QString::number(intellipap_data_version);
m->properties[STR_PROP_Serial] = 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/";
QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
m->properties[STR_PROP_Path] = path;
m->properties[STR_PROP_BackupPath] = path + "Backup/";
return m;
}
bool intellipap_initialized=false;
bool intellipap_initialized = false;
void IntellipapLoader::Register()
{
if (intellipap_initialized) return;
if (intellipap_initialized) { return; }
qDebug() << "Registering IntellipapLoader";
RegisterLoader(new IntellipapLoader());
//InitModelMap();
intellipap_initialized=true;
intellipap_initialized = true;
}

26
sleepyhead/SleepLib/loader_plugins/intellipap_loader.h
View File

@ -22,25 +22,25 @@
//********************************************************************************************
// Please INCREMENT the following value when making changes to this loaders implementation.
//
const int intellipap_data_version=2;
const int intellipap_data_version = 2;
//
//********************************************************************************************
/*! \class Intellipap
\brief Intellipap customized machine object
*/
class Intellipap:public CPAP
class Intellipap: public CPAP
{
public:
Intellipap(Profile *p,MachineID id=0);
public:
Intellipap(Profile *p, MachineID id = 0);
virtual ~Intellipap();
};
const int intellipap_load_buffer_size=1024*1024;
const int intellipap_load_buffer_size = 1024 * 1024;
const QString intellipap_class_name=STR_MACH_Intellipap;
const QString intellipap_class_name = STR_MACH_Intellipap;
/*! \class IntellipapLoader
\brief Loader for DeVilbiss Intellipap Auto data
@ -48,28 +48,28 @@ const QString intellipap_class_name=STR_MACH_Intellipap;
*/
class IntellipapLoader : public MachineLoader
{
public:
public:
IntellipapLoader();
virtual ~IntellipapLoader();
//! \brief Scans path for Intellipap data signature, and Loads any new data
virtual int Open(QString & path,Profile *profile);
virtual int Open(QString &path, Profile *profile);
//! \brief Returns SleepLib database version of this IntelliPap loader
virtual int Version() { return intellipap_data_version; }
//! \brief Returns the machine class name of this IntelliPap, "Intellipap"
virtual const QString & ClassName() { return intellipap_class_name; }
virtual const QString &ClassName() { return intellipap_class_name; }
//! \brief Creates a machine object, indexed by serial number
Machine *CreateMachine(QString serial,Profile *profile);
Machine *CreateMachine(QString serial, Profile *profile);
//! \brief Registers this MachineLoader with the master list, so Intellipap data can load
static void Register();
protected:
protected:
QString last;
QHash<QString,Machine *> MachList;
QHash<QString, Machine *> MachList;
unsigned char * m_buffer;
unsigned char *m_buffer;
};

427
sleepyhead/SleepLib/loader_plugins/mseries_loader.cpp
View File

@ -17,12 +17,12 @@ extern QProgressBar *qprogress;
MSeries::MSeries(Profile *p,MachineID id)
:CPAP(p,id)
MSeries::MSeries(Profile *p, MachineID id)
: CPAP(p, id)
{
m_class=mseries_class_name;
properties[STR_PROP_Brand]="Respironics";
properties[STR_PROP_Model]=STR_MACH_MSeries;
m_class = mseries_class_name;
properties[STR_PROP_Brand] = "Respironics";
properties[STR_PROP_Model] = STR_MACH_MSeries;
}
MSeries::~MSeries()
@ -31,8 +31,8 @@ MSeries::~MSeries()
MSeriesLoader::MSeriesLoader()
{
epoch=QDateTime(QDate(2000,1,1),QTime(0,0,0),Qt::UTC).toTime_t();
epoch-=QDateTime(QDate(1970,1,1),QTime(0,0,0),Qt::UTC).toTime_t();
epoch = QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0), Qt::UTC).toTime_t();
epoch -= QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0), Qt::UTC).toTime_t();
}
MSeriesLoader::~MSeriesLoader()
@ -113,284 +113,322 @@ blockLayoutOffsets {
*/
int MSeriesLoader::Open(QString & path,Profile *profile)
int MSeriesLoader::Open(QString &path, Profile *profile)
{
Q_UNUSED(profile);
// Until a smartcard reader is written, this is not an auto-scanner.. it just opens a block file..
QFile file(path);
if (!file.exists()) return 0;
if (file.size()!=32768) // Check filesize matches smartcard?
if (!file.exists()) { return 0; }
if (file.size() != 32768) { // Check filesize matches smartcard?
return 0;
}
if (!file.open(QFile::ReadOnly)) {
qDebug() << "Couldn't open M-Series file:" << path;
return 0;
}
QByteArray block=file.readAll();
QByteArray block = file.readAll();
// Thanks to Phil Gillam for the pointers on this one..
const unsigned char * cardinfo=(unsigned char *)block.data();
quint16 magic=cardinfo[0] << 8 | cardinfo[1];
if (magic!=0x5249) { // "RI" Respironics Magic number
const unsigned char *cardinfo = (unsigned char *)block.data();
quint16 magic = cardinfo[0] << 8 | cardinfo[1];
if (magic != 0x5249) { // "RI" Respironics Magic number
return 0;
}
//quint8 cardtype=cardinfo[2];
//quint8 cardver=cardinfo[3];
quint16 user_offset=(cardinfo[4] << 8) | cardinfo[5];
quint16 user_offset = (cardinfo[4] << 8) | cardinfo[5];
//quint16 rx_offset=(cardinfo[8] << 8) | cardinfo[9];
quint16 control_offset=(cardinfo[12] << 8) | cardinfo[13];
quint16 control_offset = (cardinfo[12] << 8) | cardinfo[13];
//quint16 data_offset=(cardinfo[16] << 8) | cardinfo[17];
const char * userinfo=block.data()+user_offset;
QString setname=QString(userinfo+0x1);
QString firstname=QString(userinfo+0x11);
QString lastname=QString(userinfo+0x2a);
QString serial=QString(userinfo+0x43);
const char *userinfo = block.data() + user_offset;
QString setname = QString(userinfo + 0x1);
QString firstname = QString(userinfo + 0x11);
QString lastname = QString(userinfo + 0x2a);
QString serial = QString(userinfo + 0x43);
serial.truncate(10);
QString model=QString(userinfo+0x4d);
QString textdata=QString(userinfo+0x57);
quint8 userinfochk=*(userinfo+0x77);
quint8 tmp=0;
for (int i=0;i<0x77;i++) {
tmp+=userinfo[i];
QString model = QString(userinfo + 0x4d);
QString textdata = QString(userinfo + 0x57);
quint8 userinfochk = *(userinfo + 0x77);
quint8 tmp = 0;
for (int i = 0; i < 0x77; i++) {
tmp += userinfo[i];
}
if (tmp!=userinfochk) {
if (tmp != userinfochk) {
qDebug() << "MSeries UserInfo block checksum failure" << path;
}
//const unsigned char * rxblock=(unsigned char *)block.data()+rx_offset;
unsigned char * controlblock=(unsigned char *)block.data()+control_offset;
quint16 count=controlblock[0] << 8 | controlblock[1]; // number of control blocks
if (controlblock[1]!=controlblock[2]) {
unsigned char *controlblock = (unsigned char *)block.data() + control_offset;
quint16 count = controlblock[0] << 8 | controlblock[1]; // number of control blocks
if (controlblock[1] != controlblock[2]) {
qDebug() << "Control block count does not match." << path;
}
QList<quint16> head, tail;
controlblock+=3;
quint16 datastarts,dataends,tmp16,h16,t16;
if (controlblock[0]) {
datastarts=controlblock[1] | (controlblock[2] << 8);
dataends=controlblock[3] | (controlblock[4] << 8);
}
controlblock+=6;
controlblock += 3;
quint16 datastarts, dataends, tmp16, h16, t16;
if (controlblock[0]) {
if ((controlblock[1] | (controlblock[2] << 8))!=datastarts) {
datastarts = controlblock[1] | (controlblock[2] << 8);
dataends = controlblock[3] | (controlblock[4] << 8);
}
controlblock += 6;
if (controlblock[0]) {
if ((controlblock[1] | (controlblock[2] << 8)) != datastarts) {
qDebug() << "Non matching card size start identifier" << path;
}
if ((controlblock[3] | (controlblock[4] << 8))!=dataends) {
if ((controlblock[3] | (controlblock[4] << 8)) != dataends) {
qDebug() << "Non matching card size end identifier" << path;
}
}
controlblock+=6;
count-=2;
tmp16=controlblock[0] | controlblock[1] << 8;
controlblock += 6;
count -= 2;
controlblock+=2;
for (int i=0;i<count/2;i++) {
tmp16 = controlblock[0] | controlblock[1] << 8;
controlblock += 2;
for (int i = 0; i < count / 2; i++) {
if (controlblock[0]) {
h16=controlblock[1] | (controlblock[2] << 8);
t16=controlblock[3] | (controlblock[4] << 8);
h16 = controlblock[1] | (controlblock[2] << 8);
t16 = controlblock[3] | (controlblock[4] << 8);
head.push_back(h16);
tail.push_back(t16);
}
controlblock+=6;
controlblock += 6;
if (controlblock[0]) {
if ((controlblock[1] | (controlblock[2] << 8))!=h16) {
if ((controlblock[1] | (controlblock[2] << 8)) != h16) {
qDebug() << "Non matching control block head value" << path;
}
if ((controlblock[3] | (controlblock[4] << 8))!=t16) {
if ((controlblock[3] | (controlblock[4] << 8)) != t16) {
qDebug() << "Non matching control block tail value" << path;
}
}
controlblock+=6;
controlblock += 6;
}
unsigned char *cb=controlblock;
quint16 u1,u2,u3,u4,d1;
quint32 ts,st,lt;
unsigned char *cb = controlblock;
quint16 u1, u2, u3, u4, d1;
quint32 ts, st, lt;
QDateTime dt;
QDate date;
QTime time;
for (int chk=0;chk<7;chk++) {
ts=cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
for (int chk = 0; chk < 7; chk++) {
ts = cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
//ts-=epoch;
dt=QDateTime::fromTime_t(ts);
date=dt.date();
time=dt.time();
dt = QDateTime::fromTime_t(ts);
date = dt.date();
time = dt.time();
qDebug() << "New Sparse Chunk" << chk << dt << hex << ts;
cb+=4;
quint8 sum=0;
for (int i=0;i<0x268;i++) sum+=cb[i];
if (cb[0x268]==sum) {
cb += 4;
quint8 sum = 0;
for (int i = 0; i < 0x268; i++) { sum += cb[i]; }
if (cb[0x268] == sum) {
qDebug() << "Checksum bad for block" << chk << path;
}
cb+=0x26a;
cb += 0x26a;
}
unsigned char * endcard=(unsigned char *)block.data()+dataends;
bool done=false;
unsigned char *endcard = (unsigned char *)block.data() + dataends;
bool done = false;
qint64 ti;
int cnt=0;
int cnt = 0;
do {
ts=cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
lt=st=ts;
ti=qint64(ts)*1000L;
dt=QDateTime::fromTime_t(ts);
date=dt.date();
time=dt.time();
ts = cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
lt = st = ts;
ti = qint64(ts) * 1000L;
dt = QDateTime::fromTime_t(ts);
date = dt.date();
time = dt.time();
qDebug() << "Details New Data Chunk" << cnt << dt << hex << ts;
cb+=4;
cb += 4;
do {
if (cb[0]==0xfe) { // not sure what this means
if (cb[0] == 0xfe) { // not sure what this means
cb++;
}
u1=cb[0] << 8 | cb[1]; // expecting 0xCXXX
if (u1==0xffff) { // adjust timestamp code
cb+=2;
u1=cb[0];
u1 = cb[0] << 8 | cb[1]; // expecting 0xCXXX
if (u1 == 0xffff) { // adjust timestamp code
cb += 2;
u1 = cb[0];
cb++;
if (cb[0]==0xfe) {
u1=cb[0] << 8 | cb[1]; // fe 0a, followed by timestamp
cb+=2;
if (cb[0] == 0xfe) {
u1 = cb[0] << 8 | cb[1]; // fe 0a, followed by timestamp
cb += 2;
break; // start on the next timestamp
}
} else {
if ((cb[0] & 0xc0) == 0xc0) {
cb+=2;
cb += 2;
u1 &= 0x0fff; // time delta??
lt=ts;
ts=st+(u1*60);
ti=qint64(ts) * 1000L;
lt = ts;
ts = st + (u1 * 60);
ti = qint64(ts) * 1000L;
d1=cb[0] << 8 | cb[1];
u2=cb[2] << 8 | cb[3];
u3=cb[4] << 8 | cb[5];
u4=cb[6] << 8 | cb[7];
if ((d1!=0xf302) || (u2!=0xf097) || (u3!=0xf2ff) || (u4!=0xf281)) {
d1 = cb[0] << 8 | cb[1];
u2 = cb[2] << 8 | cb[3];
u3 = cb[4] << 8 | cb[5];
u4 = cb[6] << 8 | cb[7];
if ((d1 != 0xf302) || (u2 != 0xf097) || (u3 != 0xf2ff) || (u4 != 0xf281)) {
qDebug() << "Lost details sync reading M-Series file" << path;
return false;
}
cb+=8;
} else cb++;
dt=QDateTime::fromTime_t(ts);
cb += 8;
} else { cb++; }
dt = QDateTime::fromTime_t(ts);
qDebug() << "Details Data Chunk" << cnt++ << dt;
do {
d1=cb[0] << 8 | cb[1];
cb+=2;
d1 = cb[0] << 8 | cb[1];
cb += 2;
if (d1==0x7f0a) { // end of entire block
done=true;
if (d1 == 0x7f0a) { // end of entire block
done = true;
break;
}
if ((d1 & 0xb000) == 0xb000) {
qDebug() << "Duration" << (d1 & 0x7ff);
break; // end of section
}
// process binary data..
// 64 c0
} while (cb<endcard);
} while (cb < endcard);
}
} while (cb<endcard && !done);
} while (cb < endcard && !done);
} while (cb < endcard && !done);
done=false;
done = false;
//bool first=true;
quint8 exch;
cnt=0;
cnt = 0;
do {
u1=cb[0] << 8 | cb[1];
if (u1!=0xfe0b) {
done=true;
u1 = cb[0] << 8 | cb[1];
if (u1 != 0xfe0b) {
done = true;
break;
}
cb+=2;
st=ts=cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
dt=QDateTime::fromTime_t(ts);
date=dt.date();
time=dt.time();
cb += 2;
st = ts = cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
dt = QDateTime::fromTime_t(ts);
date = dt.date();
time = dt.time();
//qDebug() << "Summary Data Chunk" << cnt << dt << hex << ts;
cb+=4;
cb += 4;
while (cb < endcard) {
if (((cb[0]&0xc0)!=0xc0) || ((cb[0]&0xf0)==0xf0)) {
if (((cb[0] & 0xc0) != 0xc0) || ((cb[0] & 0xf0) == 0xf0)) {
// what is this for??
exch=cb[0];
exch = cb[0];
cb++;
}
u1=(cb[0] << 8 | cb[1]) & 0x7ff; // time delta
u1 = (cb[0] << 8 | cb[1]) & 0x7ff; // time delta
u2=(cb[2] << 8 | cb[3]) & 0x7ff; // 0xBX XX??
ts=st+u1*60;
dt=QDateTime::fromTime_t(ts);
u2 = (cb[2] << 8 | cb[3]) & 0x7ff; // 0xBX XX??
ts = st + u1 * 60;
dt = QDateTime::fromTime_t(ts);
//qDebug() << "Summary Sub Chunk" << dt << u1 << u2 << hex << ts;
cb+=4;
if (cb[0]==0xff) break;
cb += 4;
if (cb[0] == 0xff) { break; }
}
cb++; // ff;
// 05905: "22 48 00 00 04 01 01 5C 9E 30 00 F0 00 01 73 00 00 00 F2 Sat Jul 9 2011 10:44:25"
// 05905: "20 58 00 00 00 00 00 32 69 88 00 70 00 01 73 00 00 00 AF Sun Jul 10 2011 05:09:21"
// 05906: "22 00 00 00 0B 00 01 4E 79 F8 02 70 00 01 73 00 00 00 56 Sun Jul 10 2011 10:27:05"
// 05907: "21 4C 00 00 11 00 01 5C 95 F8 01 F0 00 01 73 00 00 00 54 Mon Jul 11 2011 10:59:42"
// 05908: "20 A8 00 00 02 00 01 4E 7D 88 00 F0 00 01 73 00 00 00 90 Tue Jul 12 2011 03:44:38"
// 05909: "21 94 00 00 34 01 01 6A 96 D8 01 70 00 01 73 00 00 00 FC Tue Jul 12 2011 10:30:49"
// 05910: "21 84 00 00 19 01 01 6A A2 30 00 F0 00 01 73 00 00 00 3E Wed Jul 13 2011 10:30:14"
// 05911: "22 38 00 00 3F 01 01 86 B2 A0 00 F1 00 01 73 00 00 00 F4 Thu Jul 14 2011 10:01:50"
// 05912: "21 68 00 00 36 01 01 5C 91 F8 02 70 00 01 73 00 00 00 BF Fri Jul 15 2011 10:46:33"
// 05913: "22 6C 0E 00 A1 01 01 78 AB 10 00 F0 00 01 73 00 00 00 9A Sat Jul 16 2011 10:44:56"
// 05905: "22 48 00 00 04 01 01 5C 9E 30 00 F0 00 01 73 00 00 00 F2 Sat Jul 9 2011 10:44:25"
// 05905: "20 58 00 00 00 00 00 32 69 88 00 70 00 01 73 00 00 00 AF Sun Jul 10 2011 05:09:21"
// 05906: "22 00 00 00 0B 00 01 4E 79 F8 02 70 00 01 73 00 00 00 56 Sun Jul 10 2011 10:27:05"
// 05907: "21 4C 00 00 11 00 01 5C 95 F8 01 F0 00 01 73 00 00 00 54 Mon Jul 11 2011 10:59:42"
// 05908: "20 A8 00 00 02 00 01 4E 7D 88 00 F0 00 01 73 00 00 00 90 Tue Jul 12 2011 03:44:38"
// 05909: "21 94 00 00 34 01 01 6A 96 D8 01 70 00 01 73 00 00 00 FC Tue Jul 12 2011 10:30:49"
// 05910: "21 84 00 00 19 01 01 6A A2 30 00 F0 00 01 73 00 00 00 3E Wed Jul 13 2011 10:30:14"
// 05911: "22 38 00 00 3F 01 01 86 B2 A0 00 F1 00 01 73 00 00 00 F4 Thu Jul 14 2011 10:01:50"
// 05912: "21 68 00 00 36 01 01 5C 91 F8 02 70 00 01 73 00 00 00 BF Fri Jul 15 2011 10:46:33"
// 05913: "22 6C 0E 00 A1 01 01 78 AB 10 00 F0 00 01 73 00 00 00 9A Sat Jul 16 2011 10:44:56"
// 0x04 Vibratory Snore
cnt++;
QString a;
for (int i=0;i<0x13;i++) {
a+=QString().sprintf("%02X ",cb[i]);
for (int i = 0; i < 0x13; i++) {
a += QString().sprintf("%02X ", cb[i]);
}
a+=" "+date.toString()+" "+time.toString();
a += " " + date.toString() + " " + time.toString();
qDebug() << a;
cb+=0x13;
cb += 0x13;
} while (cb < endcard && !done);
//graph data
//starts with timestamp.. or time delta if high bit is set.
// validFlagOne = 3,
// headPtrOne = 4,
// tailPtrOne = 6,
// cdbChecksumOne = 8,
// validFlagTwo = 9
// headPtrTwo = 10,
// tailPtrTwo = 12,
// cdbChecksumTwo = 14,
// validFlagOne = 3,
// headPtrOne = 4,
// tailPtrOne = 6,
// cdbChecksumOne = 8,
// validFlagTwo = 9
// headPtrTwo = 10,
// tailPtrTwo = 12,
// cdbChecksumTwo = 14,
// const char * datablock=block.data()+data_offset;
// quint8 basicCompliance=datablock[1];
// quint8 fosq=datablock[2];
// quint8 smartAutoCPAPProfile=datablock[3];
// quint8 smartAutoCPAPTrend=datablock[4];
// quint8 ventProfile=datablock[6];
// quint8 ventCompliance1=datablock[7];
// quint8 sleepProfile1=datablock[8];
// quint8 sleepTrend1=datablock[9];
// quint8 sleepProfile2=datablock[10];
// quint8 sleepTrend2=datablock[11];
// quint8 ventProfile2=datablock[12];
// quint8 ventCompliance2=datablock[13];
// quint8 sleepProfile3=datablock[14];
// quint8 sleepTrend3=datablock[15];
// const char * datablock=block.data()+data_offset;
// quint8 basicCompliance=datablock[1];
// quint8 fosq=datablock[2];
// quint8 smartAutoCPAPProfile=datablock[3];
// quint8 smartAutoCPAPTrend=datablock[4];
// quint8 ventProfile=datablock[6];
// quint8 ventCompliance1=datablock[7];
// quint8 sleepProfile1=datablock[8];
// quint8 sleepTrend1=datablock[9];
// quint8 sleepProfile2=datablock[10];
// quint8 sleepTrend2=datablock[11];
// quint8 ventProfile2=datablock[12];
// quint8 ventCompliance2=datablock[13];
// quint8 sleepProfile3=datablock[14];
// quint8 sleepTrend3=datablock[15];
// 0xa6: 01 00 b2 7f ff 31
@ -415,24 +453,24 @@ int MSeriesLoader::Open(QString & path,Profile *profile)
// idx 0x159 =
// basicCompliance = 1,
// fosq = 2,
// sleepProfile = 8,
// sleepProfile2 = 10,
// sleepProfile3 = 14,
// sleepTrend = 9,
// sleepTrend2 = 11,
// sleepTrend3 = 15,
// smartAutoCPAPProfile = 3,
// smartAutoCPAPTrend = 4,
// ventCompliance2 = 13,
// ventilatorCompliance = 7,
// ventilatorProfile = 6,
// ventProfile2 = 12
// basicCompliance = 1,
// fosq = 2,
// sleepProfile = 8,
// sleepProfile2 = 10,
// sleepProfile3 = 14,
// sleepTrend = 9,
// sleepTrend2 = 11,
// sleepTrend3 = 15,
// smartAutoCPAPProfile = 3,
// smartAutoCPAPTrend = 4,
// ventCompliance2 = 13,
// ventilatorCompliance = 7,
// ventilatorProfile = 6,
// ventProfile2 = 12
// Invalid = 0xff,
// startChar = 0xfe,
// stopChar = 0x7f
// Invalid = 0xff,
// startChar = 0xfe,
// stopChar = 0x7f
//Machine *mach=CreateMachine(serial,profile);
@ -445,45 +483,50 @@ int MSeriesLoader::Open(QString & path,Profile *profile)
return 1;
}
Machine *MSeriesLoader::CreateMachine(QString serial,Profile *profile)
Machine *MSeriesLoader::CreateMachine(QString serial, Profile *profile)
{
if (!profile)
if (!profile) {
return NULL;
}
qDebug() << "Create Machine " << serial;
QList<Machine *> ml=profile->GetMachines(MT_CPAP);
bool found=false;
QList<Machine *> ml = profile->GetMachines(MT_CPAP);
bool found = false;
QList<Machine *>::iterator i;
for (i=ml.begin(); i!=ml.end(); i++) {
if (((*i)->GetClass()==mseries_class_name) && ((*i)->properties[STR_PROP_Serial]==serial)) {
MachList[serial]=*i;
found=true;
for (i = ml.begin(); i != ml.end(); i++) {
if (((*i)->GetClass() == mseries_class_name) && ((*i)->properties[STR_PROP_Serial] == serial)) {
MachList[serial] = *i;
found = true;
break;
}
}
if (found) return *i;
Machine *m=new MSeries(profile,0);
if (found) { return *i; }
MachList[serial]=m;
Machine *m = new MSeries(profile, 0);
MachList[serial] = m;
profile->AddMachine(m);
m->properties[STR_PROP_Serial]=serial;
m->properties[STR_PROP_DataVersion]=QString::number(mseries_data_version);
m->properties[STR_PROP_Serial] = serial;
m->properties[STR_PROP_DataVersion] = QString::number(mseries_data_version);
QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
m->properties[STR_PROP_Path]=path;
m->properties[STR_PROP_BackupPath]=path+"Backup/";
QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
m->properties[STR_PROP_Path] = path;
m->properties[STR_PROP_BackupPath] = path + "Backup/";
return m;
}
bool mseries_initialized=false;
bool mseries_initialized = false;
void MSeriesLoader::Register()
{
if (mseries_initialized) return;
if (mseries_initialized) { return; }
qDebug() << "Registering RemStar M-Series Loader";
RegisterLoader(new MSeriesLoader());
//InitModelMap();
mseries_initialized=true;
mseries_initialized = true;
}

24
sleepyhead/SleepLib/loader_plugins/mseries_loader.h
View File

@ -21,48 +21,48 @@
//********************************************************************************************
// Please INCREMENT the following value when making changes to this loaders implementation.
//
const int mseries_data_version=2;
const int mseries_data_version = 2;
//
//********************************************************************************************
/*! \class MSeries
\brief RemStar M-Series customized machine object
*/
class MSeries:public CPAP
class MSeries: public CPAP
{
public:
MSeries(Profile *p,MachineID id=0);
public:
MSeries(Profile *p, MachineID id = 0);
virtual ~MSeries();
};
const int mseries_load_buffer_size=1024*1024;
const int mseries_load_buffer_size = 1024 * 1024;
const QString mseries_class_name=STR_MACH_MSeries;
const QString mseries_class_name = STR_MACH_MSeries;
class MSeriesLoader : public MachineLoader
{
public:
public:
MSeriesLoader();
virtual ~MSeriesLoader();
//! \brief Opens M-Series block device
virtual int Open(QString & file,Profile *profile);
virtual int Open(QString &file, Profile *profile);
//! \brief Returns the database version of this loader
virtual int Version() { return mseries_data_version; }
//! \brief Return the ClassName, in this case "MSeries"
virtual const QString & ClassName() { return mseries_class_name; }
virtual const QString &ClassName() { return mseries_class_name; }
//! \brief Create a new PRS1 machine record, indexed by Serial number.
Machine *CreateMachine(QString serial,Profile *profile);
Machine *CreateMachine(QString serial, Profile *profile);
//! \brief Register this Module to the list of Loaders, so it knows to search for PRS1 data.
static void Register();
protected:
QHash<QString,Machine *> MachList;
protected:
QHash<QString, Machine *> MachList;
quint32 epoch;
};

1578
sleepyhead/SleepLib/loader_plugins/prs1_loader.cpp
View File

File diff suppressed because it is too large Load Diff

36
sleepyhead/SleepLib/loader_plugins/prs1_loader.h
View File

@ -23,57 +23,57 @@
//********************************************************************************************
// Please INCREMENT the following value when making changes to this loaders implementation.
//
const int prs1_data_version=10;
const int prs1_data_version = 10;
//
//********************************************************************************************
/*! \class PRS1
\brief PRS1 customized machine object (via CPAP)
*/
class PRS1:public CPAP
class PRS1: public CPAP
{
public:
PRS1(Profile *p,MachineID id=0);
public:
PRS1(Profile *p, MachineID id = 0);
virtual ~PRS1();
};
const int max_load_buffer_size=1024*1024;
const int max_load_buffer_size = 1024 * 1024;
const QString prs1_class_name=STR_MACH_PRS1;
const QString prs1_class_name = STR_MACH_PRS1;
/*! \class PRS1Loader
\brief Philips Respironics System One Loader Module
*/
class PRS1Loader : public MachineLoader
{
public:
public:
PRS1Loader();
virtual ~PRS1Loader();
//! \brief Scans directory path for valid PRS1 signature
virtual int Open(QString & path,Profile *profile);
virtual int Open(QString &path, Profile *profile);
//! \brief Returns the database version of this loader
virtual int Version() { return prs1_data_version; }
//! \brief Return the ClassName, in this case "PRS1"
virtual const QString & ClassName() { return prs1_class_name; }
virtual const QString &ClassName() { return prs1_class_name; }
//! \brief Create a new PRS1 machine record, indexed by Serial number.
Machine *CreateMachine(QString serial,Profile *profile);
Machine *CreateMachine(QString serial, Profile *profile);
//! \brief Register this Module to the list of Loaders, so it knows to search for PRS1 data.
static void Register();
protected:
protected:
QString last;
QHash<QString,Machine *> PRS1List;
QHash<QString, Machine *> PRS1List;
//! \brief Opens the SD folder structure for this machine, scans for data files and imports any new sessions
int OpenMachine(Machine *m,QString path,Profile *profile);
int OpenMachine(Machine *m, QString path, Profile *profile);
//! \brief Parses "properties.txt" file containing machine information
bool ParseProperties(Machine *m,QString filename);
bool ParseProperties(Machine *m, QString filename);
//bool OpenSummary(Session *session,QString filename);
//bool OpenEvents(Session *session,QString filename);
@ -85,10 +85,12 @@ protected:
//bool ParseWaveform(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, quint16 duration, quint16 num_signals, quint16 interleave, quint8 sample_format);
//! \brief Parse a data chunk from the .000 (brick) and .001 (summary) files.
bool ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family, int familyVersion);
bool ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp, unsigned char *data,
quint16 size, int family, int familyVersion);
//! \brief Parse a single data chunk from a .002 file containing event data for a standard system one machine
bool Parse002(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family, int familyVersion);
bool Parse002(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family,
int familyVersion);
//! \brief Parse a single data chunk from a .002 file containing event data for a family 5 ASV machine (which has a different format)
bool Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size);
@ -98,7 +100,7 @@ protected:
//bool Parse002(Session *session,unsigned char *buffer,int size,qint64 timestamp,long fpos);
//bool Parse002ASV(Session *session,unsigned char *buffer,int size,qint64 timestamp,long fpos);
unsigned char * m_buffer;
unsigned char *m_buffer;
QHash<SessionID, Session *> extra_session;
//! \brief PRS1 Data files can store multiple sessions, so store them in this list for later processing.

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

File diff suppressed because it is too large Load Diff

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

@ -23,12 +23,12 @@
//********************************************************************************************
// Please INCREMENT the following value when making changes to this loaders implementation.
//
const int resmed_data_version=6;
const int resmed_data_version = 6;
//
//********************************************************************************************
const QString resmed_class_name=STR_MACH_ResMed;
const QString resmed_class_name = STR_MACH_ResMed;
/*! \struct EDFHeader
\brief Represents the EDF+ header structure, used as a place holder while processing the text data.
@ -46,18 +46,18 @@ struct EDFHeader {
char num_signals[4];
}
#ifndef BUILD_WITH_MSVC
__attribute__ ((packed))
__attribute__((packed))
#endif
;
const int EDFHeaderSize=sizeof(EDFHeader);
const int EDFHeaderSize = sizeof(EDFHeader);
/*! \struct EDFSignal
\brief Contains information about a single EDF+ Signal
\note More information on the EDF+ file format can be obtained from http://edfplus.info
*/
struct EDFSignal {
public:
public:
//! \brief Name of this Signal
QString label;
@ -95,7 +95,7 @@ public:
QString reserved;
//! \brief Pointer to the signals sample data
qint16 * data;
qint16 *data;
//! \brief a non-EDF extra used internally to count the signal data
int pos;
@ -108,9 +108,9 @@ public:
*/
class EDFParser
{
public:
public:
//! \brief Constructs an EDFParser object, opening the filename if one supplied
EDFParser(QString filename="");
EDFParser(QString filename = "");
~EDFParser();
@ -127,11 +127,11 @@ public:
QVector<EDFSignal> edfsignals;
//! \brief An by-name indexed into the EDFSignal data
QHash<QString,EDFSignal *> lookup;
QHash<QString, EDFSignal *> lookup;
//! \brief Look up signal names by SleepLib ChannelID.. A little "ResMed"ified.. :/
EDFSignal * lookupSignal(ChannelID);
EDFSignal * lookupName(QString name);
EDFSignal *lookupSignal(ChannelID);
EDFSignal *lookupName(QString name);
//! \brief Returns the number of signals contained in this EDF file
long GetNumSignals() { return num_signals; }
@ -176,52 +176,53 @@ public:
*/
class ResmedLoader : public MachineLoader
{
public:
public:
ResmedLoader();
virtual ~ResmedLoader();
//! \brief Scans for S9 SD folder structure signature, and loads any new data if found
virtual int Open(QString & path,Profile *profile);
virtual int Open(QString &path, Profile *profile);
//! \brief Returns the version number of this ResMed loader
virtual int Version() { return resmed_data_version; }
//! \brief Returns the Machine class name of this loader. ("ResMed")
virtual const QString & ClassName() { return resmed_class_name; }
virtual const QString &ClassName() { return resmed_class_name; }
//! \brief Converts EDFSignal data to time delta packed EventList, and adds to Session
void ToTimeDelta(Session *sess,EDFParser &edf, EDFSignal & es, ChannelID code, long recs,qint64 duration,EventDataType min=0,EventDataType max=0,bool square=false);
void ToTimeDelta(Session *sess, EDFParser &edf, EDFSignal &es, ChannelID code, long recs,
qint64 duration, EventDataType min = 0, EventDataType max = 0, bool square = false);
//! \brief Create Machine record, and index it by serial number
Machine *CreateMachine(QString serial,Profile *profile);
Machine *CreateMachine(QString serial, Profile *profile);
//! \brief Register the ResmedLoader with the list of other machine loaders
static void Register();
protected:
QHash<QString,Machine *> ResmedList;
protected:
QHash<QString, Machine *> ResmedList;
//! \brief Parse the EVE Event annotation data, and save to Session * sess
//! This contains all Hypopnea, Obstructive Apnea, Central and Apnea codes
bool LoadEVE(Session *sess,EDFParser &edf);
bool LoadEVE(Session *sess, EDFParser &edf);
//! \brief Parse the BRP High Resolution data, and save to Session * sess
//! This contains Flow Rate, Mask Pressure, and Resp. Event data
bool LoadBRP(Session *sess,EDFParser &edf);
bool LoadBRP(Session *sess, EDFParser &edf);
//! \brief Parse the SAD Pulse oximetry attachment data, and save to Session * sess
//! This contains Pulse Rate and SpO2 Oxygen saturation data
bool LoadSAD(Session *sess,EDFParser &edf);
bool LoadSAD(Session *sess, EDFParser &edf);
//! \brief Parse the PRD low resolution data, and save to Session * sess
//! This contains the Pressure, Leak, Respiratory Rate, Minute Ventilation, Tidal Volume, etc..
bool LoadPLD(Session *sess,EDFParser &edf);
bool LoadPLD(Session *sess, EDFParser &edf);
QString backup(QString file, QString backup_path, bool compress=false);
QString backup(QString file, QString backup_path, bool compress = false);
QMap<SessionID,QStringList> sessfiles;
QMap<SessionID, QStringList> sessfiles;
#ifdef DEBUG_EFFICIENCY
QHash<ChannelID,qint64> channel_efficiency;
QHash<ChannelID,qint64> channel_time;
QHash<ChannelID, qint64> channel_efficiency;
QHash<ChannelID, qint64> channel_time;
#endif
};

147
sleepyhead/SleepLib/loader_plugins/somnopose_loader.cpp
View File

@ -30,24 +30,24 @@ SomnoposeLoader::~SomnoposeLoader()
{
//dtor
}
int SomnoposeLoader::Open(QString & path,Profile *profile)
int SomnoposeLoader::Open(QString &path, Profile *profile)
{
Q_UNUSED(path)
Q_UNUSED(profile)
QString newpath;
QString dirtag="somnopose";
QString dirtag = "somnopose";
// Could Scan the ZEO folder for a list of CSVs
path=path.replace("\\","/");
path = path.replace("\\", "/");
if (path.toLower().endsWith("/"+dirtag)) {
if (path.toLower().endsWith("/" + dirtag)) {
return 0;
//newpath=path;
} else {
newpath=path+"/"+dirtag.toUpper();
newpath = path + "/" + dirtag.toUpper();
}
//QString filename;
@ -58,13 +58,14 @@ int SomnoposeLoader::Open(QString & path,Profile *profile)
}
Machine *SomnoposeLoader::CreateMachine(Profile *profile)
{
if (!profile)
if (!profile) {
return NULL;
}
QList<Machine *> ml=profile->GetMachines(MT_POSITION);
QList<Machine *> ml = profile->GetMachines(MT_POSITION);
for (QList<Machine *>::iterator i=ml.begin(); i!=ml.end(); i++) {
if ((*i)->GetClass()==somnopose_class_name) {
for (QList<Machine *>::iterator i = ml.begin(); i != ml.end(); i++) {
if ((*i)->GetClass() == somnopose_class_name) {
return (*i);
break;
}
@ -72,18 +73,18 @@ Machine *SomnoposeLoader::CreateMachine(Profile *profile)
qDebug("Create Somnopose Machine Record");
Machine *m=new PositionSensor(profile,0);
Machine *m = new PositionSensor(profile, 0);
m->SetType(MT_POSITION);
m->SetClass(somnopose_class_name);
m->properties[STR_PROP_Brand]="Somnopose";
m->properties[STR_PROP_Model]="Somnopose Position Data";
m->properties[STR_PROP_DataVersion]=QString::number(somnopose_data_version);
m->properties[STR_PROP_Brand] = "Somnopose";
m->properties[STR_PROP_Model] = "Somnopose Position Data";
m->properties[STR_PROP_DataVersion] = QString::number(somnopose_data_version);
profile->AddMachine(m);
QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/";
m->properties[STR_PROP_Path]=path;
m->properties[STR_PROP_BackupPath]=path+"Backup/";
QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + m->hexid() + "/";
m->properties[STR_PROP_Path] = path;
m->properties[STR_PROP_BackupPath] = path + "Backup/";
return m;
}
@ -91,6 +92,7 @@ Machine *SomnoposeLoader::CreateMachine(Profile *profile)
int SomnoposeLoader::OpenFile(QString filename)
{
QFile file(filename);
if (filename.toLower().endsWith(".csv")) {
if (!file.open(QFile::ReadOnly)) {
qDebug() << "Couldn't open Somnopose data file" << filename;
@ -104,79 +106,95 @@ int SomnoposeLoader::OpenFile(QString filename)
QTextStream ts(&file);
// Read header line and determine order of fields
QString hdr=ts.readLine();
QStringList headers=hdr.split(",");
QString hdr = ts.readLine();
QStringList headers = hdr.split(",");
int col_inclination=-1, col_orientation=-1, col_timestamp=-1;
int col_inclination = -1, col_orientation = -1, col_timestamp = -1;
int hdr_size=headers.size();
for (int i=0;i<hdr_size;i++) {
if (headers.at(i).compare("timestamp",Qt::CaseInsensitive)==0)
col_timestamp=i;
if (headers.at(i).compare("inclination",Qt::CaseInsensitive)==0)
col_inclination=i;
if (headers.at(i).compare("orientation",Qt::CaseInsensitive)==0)
col_orientation=i;
int hdr_size = headers.size();
for (int i = 0; i < hdr_size; i++) {
if (headers.at(i).compare("timestamp", Qt::CaseInsensitive) == 0) {
col_timestamp = i;
}
if (headers.at(i).compare("inclination", Qt::CaseInsensitive) == 0) {
col_inclination = i;
}
if (headers.at(i).compare("orientation", Qt::CaseInsensitive) == 0) {
col_orientation = i;
}
}
// Check we have all fields available
if ((col_timestamp<0) || (col_inclination<0) || (col_orientation<0)) {
if ((col_timestamp < 0) || (col_inclination < 0) || (col_orientation < 0)) {
return 0;
}
QDateTime epoch(QDate(2001,1,1),QTime(0,0,0));
qint64 ep=qint64(epoch.toTime_t())*1000,time;
QDateTime epoch(QDate(2001, 1, 1), QTime(0, 0, 0));
qint64 ep = qint64(epoch.toTime_t()) * 1000, time;
double timestamp,orientation, inclination;
double timestamp, orientation, inclination;
QString data;
QStringList fields;
bool ok;
bool first=true;
Machine *mach=CreateMachine(p_profile);
Session *sess=NULL;
bool first = true;
Machine *mach = CreateMachine(p_profile);
Session *sess = NULL;
SessionID sid;
EventList *ev_orientation=NULL, *ev_inclination=NULL;
EventList *ev_orientation = NULL, *ev_inclination = NULL;
while (!(data=ts.readLine()).isEmpty()) {
fields=data.split(",");
while (!(data = ts.readLine()).isEmpty()) {
fields = data.split(",");
if (fields.size() < hdr_size) // missing fields.. skip this record
if (fields.size() < hdr_size) { // missing fields.. skip this record
continue;
}
timestamp=fields[col_timestamp].toDouble(&ok);
if (!ok) continue;
orientation=fields[col_orientation].toDouble(&ok);
if (!ok) continue;
inclination=fields[col_inclination].toDouble(&ok);
if (!ok) continue;
timestamp = fields[col_timestamp].toDouble(&ok);
if (!ok) { continue; }
orientation = fields[col_orientation].toDouble(&ok);
if (!ok) { continue; }
inclination = fields[col_inclination].toDouble(&ok);
if (!ok) { continue; }
// convert to milliseconds since epoch
time=(timestamp*1000.0)+ep;
time = (timestamp * 1000.0) + ep;
if (first) {
sid=time/1000;
sid = time / 1000;
if (mach->SessionExists(sid)) {
return 0; // Already imported
}
sess=new Session(mach,sid);
sess->really_set_first(time);
ev_orientation=sess->AddEventList(POS_Orientation,EVL_Event,1,0,0,0);
ev_inclination=sess->AddEventList(POS_Inclination,EVL_Event,1,0,0,0);
first=false;
}
sess->set_last(time);
ev_orientation->AddEvent(time,orientation);
ev_inclination->AddEvent(time,inclination);
// QDateTime dt=QDateTime::fromMSecsSinceEpoch(time);
// qDebug() << dt << orientation << inclination;
sess = new Session(mach, sid);
sess->really_set_first(time);
ev_orientation = sess->AddEventList(POS_Orientation, EVL_Event, 1, 0, 0, 0);
ev_inclination = sess->AddEventList(POS_Inclination, EVL_Event, 1, 0, 0, 0);
first = false;
}
sess->set_last(time);
ev_orientation->AddEvent(time, orientation);
ev_inclination->AddEvent(time, inclination);
// QDateTime dt=QDateTime::fromMSecsSinceEpoch(time);
// qDebug() << dt << orientation << inclination;
}
sess->setMin(POS_Orientation,ev_orientation->Min());
sess->setMax(POS_Orientation,ev_orientation->Max());
sess->setMin(POS_Inclination,ev_inclination->Min());
sess->setMax(POS_Inclination,ev_inclination->Max());
sess->setMin(POS_Orientation, ev_orientation->Min());
sess->setMax(POS_Orientation, ev_orientation->Max());
sess->setMin(POS_Inclination, ev_inclination->Min());
sess->setMax(POS_Inclination, ev_inclination->Max());
sess->really_set_last(time);
sess->SetChanged(true);
@ -188,14 +206,15 @@ int SomnoposeLoader::OpenFile(QString filename)
}
static bool somnopose_initialized=false;
static bool somnopose_initialized = false;
void SomnoposeLoader::Register()
{
if (somnopose_initialized) return;
if (somnopose_initialized) { return; }
qDebug("Registering SomnoposeLoader");
RegisterLoader(new SomnoposeLoader());
//InitModelMap();
somnopose_initialized=true;
somnopose_initialized = true;
}

26
sleepyhead/SleepLib/loader_plugins/somnopose_loader.h
View File

@ -14,8 +14,8 @@
#include "SleepLib/machine_loader.h"
const QString somnopose_class_name="Somnopose";
const int somnopose_data_version=1;
const QString somnopose_class_name = "Somnopose";
const int somnopose_data_version = 1;
/*! \class SomnoposeLoader
@ -23,21 +23,21 @@ const int somnopose_data_version=1;
*/
class SomnoposeLoader : public MachineLoader
{
public:
SomnoposeLoader();
virtual ~SomnoposeLoader();
virtual int Open(QString & path,Profile *profile);
virtual int OpenFile(QString filename);
static void Register();
public:
SomnoposeLoader();
virtual ~SomnoposeLoader();
virtual int Open(QString &path, Profile *profile);
virtual int OpenFile(QString filename);
static void Register();
virtual int Version() { return somnopose_data_version; }
virtual const QString & ClassName() { return somnopose_class_name; }
virtual int Version() { return somnopose_data_version; }
virtual const QString &ClassName() { return somnopose_class_name; }
Machine *CreateMachine(Profile *profile);
Machine *CreateMachine(Profile *profile);
protected:
private:
protected:
private:
};
#endif // SOMNOPOSELOADER_H

313
sleepyhead/SleepLib/loader_plugins/zeo_loader.cpp
View File

@ -30,24 +30,24 @@ ZEOLoader::~ZEOLoader()
{
//dtor
}
int ZEOLoader::Open(QString & path,Profile *profile)
int ZEOLoader::Open(QString &path, Profile *profile)
{
Q_UNUSED(path)
Q_UNUSED(profile)
QString newpath;
QString dirtag="zeo";
QString dirtag = "zeo";
// Could Scan the ZEO folder for a list of CSVs
path=path.replace("\\","/");
path = path.replace("\\", "/");
if (path.toLower().endsWith("/"+dirtag)) {
if (path.toLower().endsWith("/" + dirtag)) {
return 0;
//newpath=path;
} else {
newpath=path+"/"+dirtag.toUpper();
newpath = path + "/" + dirtag.toUpper();
}
//QString filename;
@ -58,16 +58,17 @@ int ZEOLoader::Open(QString & path,Profile *profile)
}
Machine *ZEOLoader::CreateMachine(Profile *profile)
{
if (!profile)
if (!profile) {
return NULL;
}
// NOTE: This only allows for one ZEO machine per profile..
// Upgrading their ZEO will use this same record..
QList<Machine *> ml=profile->GetMachines(MT_SLEEPSTAGE);
QList<Machine *> ml = profile->GetMachines(MT_SLEEPSTAGE);
for (QList<Machine *>::iterator i=ml.begin(); i!=ml.end(); i++) {
if ((*i)->GetClass()==zeo_class_name) {
for (QList<Machine *>::iterator i = ml.begin(); i != ml.end(); i++) {
if ((*i)->GetClass() == zeo_class_name) {
return (*i);
break;
}
@ -75,18 +76,18 @@ Machine *ZEOLoader::CreateMachine(Profile *profile)
qDebug("Create ZEO Machine Record");
Machine *m=new SleepStage(profile,0);
Machine *m = new SleepStage(profile, 0);
m->SetType(MT_SLEEPSTAGE);
m->SetClass(zeo_class_name);
m->properties[STR_PROP_Brand]="ZEO";
m->properties[STR_PROP_Model]="Personal Sleep Coach";
m->properties[STR_PROP_DataVersion]=QString::number(zeo_data_version);
m->properties[STR_PROP_Brand] = "ZEO";
m->properties[STR_PROP_Model] = "Personal Sleep Coach";
m->properties[STR_PROP_DataVersion] = QString::number(zeo_data_version);
profile->AddMachine(m);
QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/";
m->properties[STR_PROP_Path]=path;
m->properties[STR_PROP_BackupPath]=path+"Backup/";
QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + m->hexid() + "/";
m->properties[STR_PROP_Path] = path;
m->properties[STR_PROP_BackupPath] = path + "Backup/";
return m;
}
@ -120,6 +121,7 @@ Machine *ZEOLoader::CreateMachine(Profile *profile)
int ZEOLoader::OpenFile(QString filename)
{
QFile file(filename);
if (filename.toLower().endsWith(".csv")) {
if (!file.open(QFile::ReadOnly)) {
qDebug() << "Couldn't open zeo file" << filename;
@ -130,16 +132,17 @@ int ZEOLoader::OpenFile(QString filename)
return 0;
// not supported.
}
QTextStream text(&file);
QString headerdata=text.readLine();
QStringList header=headerdata.split(",");
QString headerdata = text.readLine();
QStringList header = headerdata.split(",");
QString line;
QStringList linecomp;
QDateTime start_of_night, end_of_night, rise_time;
SessionID sid;
//const qint64 WindowSize=30000;
qint64 st,tt;
qint64 st, tt;
int stage;
int ZQ, TotalZ, TimeToZ, TimeInWake, TimeInREM, TimeInLight, TimeInDeep, Awakenings;
@ -150,159 +153,217 @@ int ZEOLoader::OpenFile(QString filename)
QStringList SG, DSG;
Machine *mach=CreateMachine(p_profile);
Machine *mach = CreateMachine(p_profile);
int idxZQ=header.indexOf("ZQ");
int idxTotalZ=header.indexOf("Total Z");
int idxAwakenings=header.indexOf("Awakenings");
int idxSG=header.indexOf("Sleep Graph");
int idxDSG=header.indexOf("Detailed Sleep Graph");
int idxTimeInWake=header.indexOf("Time in Wake");
int idxTimeToZ=header.indexOf("Time to Z");
int idxTimeInREM=header.indexOf("Time in REM");
int idxTimeInLight=header.indexOf("Time in Light");
int idxTimeInDeep=header.indexOf("Time in Deep");
int idxStartOfNight=header.indexOf("Start of Night");
int idxEndOfNight=header.indexOf("End of Night");
int idxRiseTime=header.indexOf("Rise Time");
int idxAlarmReason=header.indexOf("Alarm Reason");
int idxSnoozeTime=header.indexOf("Snooze Time");
int idxWakeTone=header.indexOf("Wake Tone");
int idxWakeWindow=header.indexOf("Wake Window");
int idxAlarmType=header.indexOf("Alarm Type");
int idxFirstAlaramRing=header.indexOf("First Alarm Ring");
int idxLastAlaramRing=header.indexOf("Last Alarm Ring");
int idxFirstSnoozeTime=header.indexOf("First Snooze Time");
int idxLastSnoozeTime=header.indexOf("Last Snooze Time");
int idxSetAlarmTime=header.indexOf("Set Alarm Time");
int idxMorningFeel=header.indexOf("Morning Feel");
int idxFirmwareVersion=header.indexOf("Firmware Version");
int idxMyZEOVersion=header.indexOf("My ZEO Version");
int idxZQ = header.indexOf("ZQ");
int idxTotalZ = header.indexOf("Total Z");
int idxAwakenings = header.indexOf("Awakenings");
int idxSG = header.indexOf("Sleep Graph");
int idxDSG = header.indexOf("Detailed Sleep Graph");
int idxTimeInWake = header.indexOf("Time in Wake");
int idxTimeToZ = header.indexOf("Time to Z");
int idxTimeInREM = header.indexOf("Time in REM");
int idxTimeInLight = header.indexOf("Time in Light");
int idxTimeInDeep = header.indexOf("Time in Deep");
int idxStartOfNight = header.indexOf("Start of Night");
int idxEndOfNight = header.indexOf("End of Night");
int idxRiseTime = header.indexOf("Rise Time");
int idxAlarmReason = header.indexOf("Alarm Reason");
int idxSnoozeTime = header.indexOf("Snooze Time");
int idxWakeTone = header.indexOf("Wake Tone");
int idxWakeWindow = header.indexOf("Wake Window");
int idxAlarmType = header.indexOf("Alarm Type");
int idxFirstAlaramRing = header.indexOf("First Alarm Ring");
int idxLastAlaramRing = header.indexOf("Last Alarm Ring");
int idxFirstSnoozeTime = header.indexOf("First Snooze Time");
int idxLastSnoozeTime = header.indexOf("Last Snooze Time");
int idxSetAlarmTime = header.indexOf("Set Alarm Time");
int idxMorningFeel = header.indexOf("Morning Feel");
int idxFirmwareVersion = header.indexOf("Firmware Version");
int idxMyZEOVersion = header.indexOf("My ZEO Version");
bool ok;
bool dodgy;
do {
line=text.readLine();
dodgy=false;
if (line.isEmpty()) continue;
linecomp=line.split(",");
ZQ=linecomp[idxZQ].toInt(&ok);
if (!ok) dodgy=true;
TotalZ=linecomp[idxTotalZ].toInt(&ok);
if (!ok) dodgy=true;
TimeToZ=linecomp[idxTimeToZ].toInt(&ok);
if (!ok) dodgy=true;
TimeInWake=linecomp[idxTimeInWake].toInt(&ok);
if (!ok) dodgy=true;
TimeInREM=linecomp[idxTimeInREM].toInt(&ok);
if (!ok) dodgy=true;
TimeInLight=linecomp[idxTimeInLight].toInt(&ok);
if (!ok) dodgy=true;
TimeInDeep=linecomp[idxTimeInDeep].toInt(&ok);
if (!ok) dodgy=true;
Awakenings=linecomp[idxAwakenings].toInt(&ok);
if (!ok) dodgy=true;
start_of_night=QDateTime::fromString(linecomp[idxStartOfNight],"MM/dd/yyyy HH:mm");
if (!start_of_night.isValid()) dodgy=true;
end_of_night=QDateTime::fromString(linecomp[idxEndOfNight],"MM/dd/yyyy HH:mm");
if (!end_of_night.isValid()) dodgy=true;
rise_time=QDateTime::fromString(linecomp[idxRiseTime],"MM/dd/yyyy HH:mm");
if (!rise_time.isValid()) dodgy=true;
AlarmReason=linecomp[idxAlarmReason].toInt(&ok);
if (!ok) dodgy=true;
SnoozeTime=linecomp[idxSnoozeTime].toInt(&ok);
if (!ok) dodgy=true;
WakeTone=linecomp[idxWakeTone].toInt(&ok);
if (!ok) dodgy=true;
WakeWindow=linecomp[idxWakeWindow].toInt(&ok);
if (!ok) dodgy=true;
AlarmType=linecomp[idxAlarmType].toInt(&ok);
if (!ok) dodgy=true;
do {
line = text.readLine();
dodgy = false;
if (line.isEmpty()) { continue; }
linecomp = line.split(",");
ZQ = linecomp[idxZQ].toInt(&ok);
if (!ok) { dodgy = true; }
TotalZ = linecomp[idxTotalZ].toInt(&ok);
if (!ok) { dodgy = true; }
TimeToZ = linecomp[idxTimeToZ].toInt(&ok);
if (!ok) { dodgy = true; }
TimeInWake = linecomp[idxTimeInWake].toInt(&ok);
if (!ok) { dodgy = true; }
TimeInREM = linecomp[idxTimeInREM].toInt(&ok);
if (!ok) { dodgy = true; }
TimeInLight = linecomp[idxTimeInLight].toInt(&ok);
if (!ok) { dodgy = true; }
TimeInDeep = linecomp[idxTimeInDeep].toInt(&ok);
if (!ok) { dodgy = true; }
Awakenings = linecomp[idxAwakenings].toInt(&ok);
if (!ok) { dodgy = true; }
start_of_night = QDateTime::fromString(linecomp[idxStartOfNight], "MM/dd/yyyy HH:mm");
if (!start_of_night.isValid()) { dodgy = true; }
end_of_night = QDateTime::fromString(linecomp[idxEndOfNight], "MM/dd/yyyy HH:mm");
if (!end_of_night.isValid()) { dodgy = true; }
rise_time = QDateTime::fromString(linecomp[idxRiseTime], "MM/dd/yyyy HH:mm");
if (!rise_time.isValid()) { dodgy = true; }
AlarmReason = linecomp[idxAlarmReason].toInt(&ok);
if (!ok) { dodgy = true; }
SnoozeTime = linecomp[idxSnoozeTime].toInt(&ok);
if (!ok) { dodgy = true; }
WakeTone = linecomp[idxWakeTone].toInt(&ok);
if (!ok) { dodgy = true; }
WakeWindow = linecomp[idxWakeWindow].toInt(&ok);
if (!ok) { dodgy = true; }
AlarmType = linecomp[idxAlarmType].toInt(&ok);
if (!ok) { dodgy = true; }
if (!linecomp[idxFirstAlaramRing].isEmpty()) {
FirstAlarmRing=QDateTime::fromString(linecomp[idxFirstAlaramRing],"MM/dd/yyyy HH:mm");
if (!FirstAlarmRing.isValid()) dodgy=true;
FirstAlarmRing = QDateTime::fromString(linecomp[idxFirstAlaramRing], "MM/dd/yyyy HH:mm");
if (!FirstAlarmRing.isValid()) { dodgy = true; }
}
if (!linecomp[idxLastAlaramRing].isEmpty()) {
LastAlarmRing=QDateTime::fromString(linecomp[idxLastAlaramRing],"MM/dd/yyyy HH:mm");
if (!LastAlarmRing.isValid()) dodgy=true;
LastAlarmRing = QDateTime::fromString(linecomp[idxLastAlaramRing], "MM/dd/yyyy HH:mm");
if (!LastAlarmRing.isValid()) { dodgy = true; }
}
if (!linecomp[idxFirstSnoozeTime].isEmpty()) {
FirstSnoozeTime=QDateTime::fromString(linecomp[idxFirstSnoozeTime],"MM/dd/yyyy HH:mm");
if (!FirstSnoozeTime.isValid()) dodgy=true;
FirstSnoozeTime = QDateTime::fromString(linecomp[idxFirstSnoozeTime], "MM/dd/yyyy HH:mm");
if (!FirstSnoozeTime.isValid()) { dodgy = true; }
}
if (!linecomp[idxLastSnoozeTime].isEmpty()) {
LastSnoozeTime=QDateTime::fromString(linecomp[idxLastSnoozeTime],"MM/dd/yyyy HH:mm");
if (!LastSnoozeTime.isValid()) dodgy=true;
LastSnoozeTime = QDateTime::fromString(linecomp[idxLastSnoozeTime], "MM/dd/yyyy HH:mm");
if (!LastSnoozeTime.isValid()) { dodgy = true; }
}
if (!linecomp[idxSetAlarmTime].isEmpty()) {
SetAlarmTime=QDateTime::fromString(linecomp[idxSetAlarmTime],"MM/dd/yyyy HH:mm");
if (!SetAlarmTime.isValid()) dodgy=true;
SetAlarmTime = QDateTime::fromString(linecomp[idxSetAlarmTime], "MM/dd/yyyy HH:mm");
if (!SetAlarmTime.isValid()) { dodgy = true; }
}
MorningFeel=linecomp[idxMorningFeel].toInt(&ok);
if (!ok) MorningFeel=0;
MorningFeel = linecomp[idxMorningFeel].toInt(&ok);
FirmwareVersion=linecomp[idxFirmwareVersion];
if (idxMyZEOVersion>=0) MyZeoVersion=linecomp[idxMyZEOVersion];
if (!ok) { MorningFeel = 0; }
if (dodgy)
FirmwareVersion = linecomp[idxFirmwareVersion];
if (idxMyZEOVersion >= 0) { MyZeoVersion = linecomp[idxMyZEOVersion]; }
if (dodgy) {
continue;
SG=linecomp[idxSG].split(" ");
DSG=linecomp[idxDSG].split(" ");
}
const int WindowSize=30000;
sid=start_of_night.toTime_t();
if (DSG.size()==0)
SG = linecomp[idxSG].split(" ");
DSG = linecomp[idxDSG].split(" ");
const int WindowSize = 30000;
sid = start_of_night.toTime_t();
if (DSG.size() == 0) {
continue;
if (mach->SessionExists(sid))
}
if (mach->SessionExists(sid)) {
continue;
Session *sess=new Session(mach,sid);
}
sess->settings[ZEO_Awakenings]=Awakenings;
sess->settings[ZEO_MorningFeel]=MorningFeel;
sess->settings[ZEO_TimeToZ]=TimeToZ;
sess->settings[ZEO_ZQ]=ZQ;
sess->settings[ZEO_TimeInWake]=TimeInWake;
sess->settings[ZEO_TimeInREM]=TimeInREM;
sess->settings[ZEO_TimeInLight]=TimeInLight;
sess->settings[ZEO_TimeInDeep]=TimeInDeep;
Session *sess = new Session(mach, sid);
st=qint64(start_of_night.toTime_t()) * 1000L;
sess->settings[ZEO_Awakenings] = Awakenings;
sess->settings[ZEO_MorningFeel] = MorningFeel;
sess->settings[ZEO_TimeToZ] = TimeToZ;
sess->settings[ZEO_ZQ] = ZQ;
sess->settings[ZEO_TimeInWake] = TimeInWake;
sess->settings[ZEO_TimeInREM] = TimeInREM;
sess->settings[ZEO_TimeInLight] = TimeInLight;
sess->settings[ZEO_TimeInDeep] = TimeInDeep;
st = qint64(start_of_night.toTime_t()) * 1000L;
sess->really_set_first(st);
tt=st;
EventList * sleepstage=sess->AddEventList(ZEO_SleepStage,EVL_Event,1,0,0,4);
for (int i=0;i<DSG.size();i++) {
stage=DSG[i].toInt(&ok);
tt = st;
EventList *sleepstage = sess->AddEventList(ZEO_SleepStage, EVL_Event, 1, 0, 0, 4);
for (int i = 0; i < DSG.size(); i++) {
stage = DSG[i].toInt(&ok);
if (ok) {
sleepstage->AddEvent(tt,stage);
sleepstage->AddEvent(tt, stage);
}
tt+=WindowSize;
tt += WindowSize;
}
sess->really_set_last(tt);
int size=DSG.size();
int size = DSG.size();
sess->SetChanged(true);
mach->AddSession(sess,p_profile);
mach->AddSession(sess, p_profile);
qDebug() << linecomp[0] << start_of_night << end_of_night << rise_time << size << "30 second chunks";
qDebug() << linecomp[0] << start_of_night << end_of_night << rise_time << size <<
"30 second chunks";
} while (!line.isNull());
mach->Save();
return true;
}
static bool zeo_initialized=false;
static bool zeo_initialized = false;
void ZEOLoader::Register()
{
if (zeo_initialized) return;
if (zeo_initialized) { return; }
qDebug("Registering ZEOLoader");
RegisterLoader(new ZEOLoader());
//InitModelMap();
zeo_initialized=true;
zeo_initialized = true;
}

26
sleepyhead/SleepLib/loader_plugins/zeo_loader.h
View File

@ -14,8 +14,8 @@
#include "SleepLib/machine_loader.h"
const QString zeo_class_name="ZEO";
const int zeo_data_version=1;
const QString zeo_class_name = "ZEO";
const int zeo_data_version = 1;
/*! \class ZEOLoader
@ -23,21 +23,21 @@ const int zeo_data_version=1;
*/
class ZEOLoader : public MachineLoader
{
public:
ZEOLoader();
virtual ~ZEOLoader();
virtual int Open(QString & path,Profile *profile);
virtual int OpenFile(QString filename);
static void Register();
public:
ZEOLoader();
virtual ~ZEOLoader();
virtual int Open(QString &path, Profile *profile);
virtual int OpenFile(QString filename);
static void Register();
virtual int Version() { return zeo_data_version; }
virtual const QString & ClassName() { return zeo_class_name; }
virtual int Version() { return zeo_data_version; }
virtual const QString &ClassName() { return zeo_class_name; }
Machine *CreateMachine(Profile *profile);
Machine *CreateMachine(Profile *profile);
protected:
private:
protected:
private:
};
#endif // ZEOLOADER_H

393
sleepyhead/SleepLib/machine.cpp
View File

@ -22,40 +22,44 @@
#include <algorithm>
#include "SleepLib/schema.h"
extern QProgressBar * qprogress;
extern QProgressBar *qprogress;
//////////////////////////////////////////////////////////////////////////////////////////
// Machine Base-Class implmementation
//////////////////////////////////////////////////////////////////////////////////////////
Machine::Machine(Profile *p,MachineID id)
Machine::Machine(Profile *p, MachineID id)
{
day.clear();
highest_sessionid=0;
profile=p;
highest_sessionid = 0;
profile = p;
if (!id) {
srand(time(NULL));
MachineID temp;
do {
temp = rand();
} while (profile->machlist.find(temp)!=profile->machlist.end());
} while (profile->machlist.find(temp) != profile->machlist.end());
m_id=temp;
m_id = temp;
} else { m_id = id; }
} else m_id=id;
//qDebug() << "Create Machine: " << hex << m_id; //%lx",m_id);
m_type=MT_UNKNOWN;
firstsession=true;
m_type = MT_UNKNOWN;
firstsession = true;
}
Machine::~Machine()
{
qDebug() << "Destroy Machine" << m_class;
for (QMap<QDate,Day *>::iterator d=day.begin();d!=day.end();d++) {
for (QMap<QDate, Day *>::iterator d = day.begin(); d != day.end(); d++) {
delete d.value();
}
}
Session *Machine::SessionExists(SessionID session)
{
if (sessionlist.find(session)!=sessionlist.end()) {
if (sessionlist.find(session) != sessionlist.end()) {
return sessionlist[session];
} else {
return NULL;
@ -65,25 +69,27 @@ Session *Machine::SessionExists(SessionID session)
// Find date this session belongs in
QDate Machine::pickDate(qint64 first)
{
QTime split_time=PROFILE.session->daySplitTime();
int combine_sessions=PROFILE.session->combineCloseSessions();
QTime split_time = PROFILE.session->daySplitTime();
int combine_sessions = PROFILE.session->combineCloseSessions();
QDateTime d2=QDateTime::fromTime_t(first/1000);
QDateTime d2 = QDateTime::fromTime_t(first / 1000);
QDate date=d2.date();
QTime time=d2.time();
QDate date = d2.date();
QTime time = d2.time();
int closest_session=0;
int closest_session = 0;
if (time<split_time) {
date=date.addDays(-1);
if (time < split_time) {
date = date.addDays(-1);
} else if (combine_sessions > 0) {
QMap<QDate,Day *>::iterator dit=day.find(date.addDays(-1)); // Check Day Before
QMap<QDate, Day *>::iterator dit = day.find(date.addDays(-1)); // Check Day Before
if (dit != day.end()) {
QDateTime lt=QDateTime::fromTime_t(dit.value()->last()/1000L);
closest_session=lt.secsTo(d2)/60;
QDateTime lt = QDateTime::fromTime_t(dit.value()->last() / 1000L);
closest_session = lt.secsTo(d2) / 60;
if (closest_session < combine_sessions) {
date=date.addDays(-1);
date = date.addDays(-1);
}
}
}
@ -91,104 +97,118 @@ QDate Machine::pickDate(qint64 first)
return date;
}
QDate Machine::AddSession(Session *s,Profile *p)
QDate Machine::AddSession(Session *s, Profile *p)
{
if (!s) {
qWarning() << "Empty Session in Machine::AddSession()";
return QDate();
}
if (!p) {
qWarning() << "Empty Profile in Machine::AddSession()";
return QDate();
}
if (s->session()>highest_sessionid)
highest_sessionid=s->session();
if (s->session() > highest_sessionid) {
highest_sessionid = s->session();
}
QTime split_time=PROFILE.session->daySplitTime();
int combine_sessions=PROFILE.session->combineCloseSessions();
int ignore_sessions=PROFILE.session->ignoreShortSessions();
QTime split_time = PROFILE.session->daySplitTime();
int combine_sessions = PROFILE.session->combineCloseSessions();
int ignore_sessions = PROFILE.session->ignoreShortSessions();
int session_length=s->last()-s->first();
session_length/=60000;
int session_length = s->last() - s->first();
session_length /= 60000;
sessionlist[s->session()]=s; // To make sure it get's saved later even if it's not wanted.
sessionlist[s->session()] = s; // To make sure it get's saved later even if it's not wanted.
//int drift=PROFILE.cpap->clockDrift();
QDateTime d2=QDateTime::fromTime_t(s->first()/1000);
QDateTime d2 = QDateTime::fromTime_t(s->first() / 1000);
QDate date=d2.date();
QTime time=d2.time();
QDate date = d2.date();
QTime time = d2.time();
QMap<QDate,Day *>::iterator dit,nextday;
QMap<QDate, Day *>::iterator dit, nextday;
bool combine_next_day=false;
int closest_session=0;
bool combine_next_day = false;
int closest_session = 0;
if (time<split_time) {
date=date.addDays(-1);
if (time < split_time) {
date = date.addDays(-1);
} else if (combine_sessions > 0) {
dit=day.find(date.addDays(-1)); // Check Day Before
if (dit!=day.end()) {
QDateTime lt=QDateTime::fromTime_t(dit.value()->last()/1000);
closest_session=lt.secsTo(d2)/60;
if (closest_session<combine_sessions) {
date=date.addDays(-1);
dit = day.find(date.addDays(-1)); // Check Day Before
if (dit != day.end()) {
QDateTime lt = QDateTime::fromTime_t(dit.value()->last() / 1000);
closest_session = lt.secsTo(d2) / 60;
if (closest_session < combine_sessions) {
date = date.addDays(-1);
}
} else {
nextday=day.find(date.addDays(1));// Check Day Afterwards
if (nextday!=day.end()) {
QDateTime lt=QDateTime::fromTime_t(nextday.value()->first()/1000);
closest_session=d2.secsTo(lt)/60;
nextday = day.find(date.addDays(1)); // Check Day Afterwards
if (nextday != day.end()) {
QDateTime lt = QDateTime::fromTime_t(nextday.value()->first() / 1000);
closest_session = d2.secsTo(lt) / 60;
if (closest_session < combine_sessions) {
// add todays here. pull all tomorrows records to this date.
combine_next_day=true;
combine_next_day = true;
}
}
}
}
if (session_length<ignore_sessions) {
if (session_length < ignore_sessions) {
//if (!closest_session || (closest_session>=60))
return QDate();
}
if (!firstsession) {
if (firstday>date) firstday=date;
if (lastday<date) lastday=date;
if (firstday > date) { firstday = date; }
if (lastday < date) { lastday = date; }
} else {
firstday=lastday=date;
firstsession=false;
firstday = lastday = date;
firstsession = false;
}
Day *dd=NULL;
dit=day.find(date);
if (dit==day.end()) {
Day *dd = NULL;
dit = day.find(date);
if (dit == day.end()) {
//QString dstr=date.toString("yyyyMMdd");
//qDebug("Adding Profile Day %s",dstr.toLatin1().data());
dd=new Day(this);
day[date]=dd;
dd = new Day(this);
day[date] = dd;
// Add this Day record to profile
p->AddDay(date,dd,m_type);
p->AddDay(date, dd, m_type);
} else {
dd=*dit;
dd = *dit;
}
dd->AddSession(s);
if (combine_next_day) {
for (QList<Session *>::iterator i=nextday.value()->begin();i!=nextday.value()->end();i++) {
for (QList<Session *>::iterator i = nextday.value()->begin(); i != nextday.value()->end(); i++) {
dd->AddSession(*i);
}
QMap<QDate,QList<Day *> >::iterator nd=p->daylist.find(date.addDays(1));
for (QList<Day *>::iterator i=nd->begin();i!=nd->end();i++) {
if (*i==nextday.value()) {
QMap<QDate, QList<Day *> >::iterator nd = p->daylist.find(date.addDays(1));
for (QList<Day *>::iterator i = nd->begin(); i != nd->end(); i++) {
if (*i == nextday.value()) {
nd.value().erase(i);
}
}
day.erase(nextday);
}
return date;
}
@ -197,20 +217,23 @@ QDate Machine::AddSession(Session *s,Profile *p)
bool Machine::Purge(int secret)
{
// Boring api key to stop this function getting called by accident :)
if (secret!=3478216) return false;
if (secret != 3478216) { return false; }
// It would be joyous if this function screwed up..
QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_";
QString path = profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_";
//if (properties.contains(STR_PROP_Serial)) path+=properties[STR_PROP_Serial]; else path+=hexid();
QDir dir(path);
if (!dir.exists()) // It doesn't exist anyway.
if (!dir.exists()) { // It doesn't exist anyway.
return true;
if (!dir.isReadable())
}
if (!dir.isReadable()) {
return false;
}
qDebug() << "Purging " << QDir::toNativeSeparators(path);
@ -218,26 +241,28 @@ bool Machine::Purge(int secret)
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Name);
QFileInfoList list=dir.entryInfoList();
int could_not_kill=0;
QFileInfoList list = dir.entryInfoList();
int could_not_kill = 0;
for (int i=0;i<list.size();++i) {
QFileInfo fi=list.at(i);
QString fullpath=fi.canonicalFilePath();
for (int i = 0; i < list.size(); ++i) {
QFileInfo fi = list.at(i);
QString fullpath = fi.canonicalFilePath();
//int j=fullpath.lastIndexOf(".");
QString ext_s=fullpath.section('.',-1);//right(j);
QString ext_s = fullpath.section('.', -1); //right(j);
bool ok;
ext_s.toInt(&ok,10);
ext_s.toInt(&ok, 10);
if (ok) {
qDebug() << "Deleting " << QDir::toNativeSeparators(fullpath);
dir.remove(fullpath);
} else could_not_kill++;
} else { could_not_kill++; }
}
if (could_not_kill>0) {
// qWarning() << "Could not purge path\n" << path << "\n\n" << could_not_kill << " file(s) remain.. Suggest manually deleting this path\n";
// return false;
if (could_not_kill > 0) {
// qWarning() << "Could not purge path\n" << path << "\n\n" << could_not_kill << " file(s) remain.. Suggest manually deleting this path\n";
// return false;
}
return true;
@ -248,130 +273,159 @@ bool Machine::Purge(int secret)
bool Machine::Load()
{
QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
QString path = profile->Get(
properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
QDir dir(path);
qDebug() << "Loading " << QDir::toNativeSeparators(path);
if (!dir.exists() || !dir.isReadable())
if (!dir.exists() || !dir.isReadable()) {
return false;
}
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Name);
QFileInfoList list=dir.entryInfoList();
QFileInfoList list = dir.entryInfoList();
typedef QVector<QString> StringList;
QMap<SessionID,StringList> sessfiles;
QMap<SessionID,StringList>::iterator s;
QMap<SessionID, StringList> sessfiles;
QMap<SessionID, StringList>::iterator s;
QString fullpath,ext_s,sesstr;
QString fullpath, ext_s, sesstr;
int ext;
SessionID sessid;
bool ok;
for (int i=0;i<list.size();i++) {
QFileInfo fi=list.at(i);
fullpath=fi.canonicalFilePath();
ext_s=fi.fileName().section(".",-1);
ext=ext_s.toInt(&ok,10);
if (!ok) continue;
sesstr=fi.fileName().section(".",0,-2);
sessid=sesstr.toLong(&ok,16);
if (!ok) continue;
if (sessfiles[sessid].capacity()==0) sessfiles[sessid].resize(3);
sessfiles[sessid][ext]=fi.canonicalFilePath();
for (int i = 0; i < list.size(); i++) {
QFileInfo fi = list.at(i);
fullpath = fi.canonicalFilePath();
ext_s = fi.fileName().section(".", -1);
ext = ext_s.toInt(&ok, 10);
if (!ok) { continue; }
sesstr = fi.fileName().section(".", 0, -2);
sessid = sesstr.toLong(&ok, 16);
if (!ok) { continue; }
if (sessfiles[sessid].capacity() == 0) { sessfiles[sessid].resize(3); }
sessfiles[sessid][ext] = fi.canonicalFilePath();
}
int size=sessfiles.size();
int cnt=0;
for (s=sessfiles.begin(); s!=sessfiles.end(); s++) {
if ((++cnt % 50)==0) { // This is slow.. :-/
if (qprogress) qprogress->setValue((float(cnt)/float(size)*100.0));
int size = sessfiles.size();
int cnt = 0;
for (s = sessfiles.begin(); s != sessfiles.end(); s++) {
if ((++cnt % 50) == 0) { // This is slow.. :-/
if (qprogress) { qprogress->setValue((float(cnt) / float(size) * 100.0)); }
QApplication::processEvents();
}
Session *sess=new Session(this,s.key());
Session *sess = new Session(this, s.key());
if (sess->LoadSummary(s.value()[0])) {
sess->SetEventFile(s.value()[1]);
//sess->OpenEvents();
AddSession(sess,profile);
sess->SetEventFile(s.value()[1]);
//sess->OpenEvents();
AddSession(sess, profile);
} else {
qWarning() << "Error unpacking summary data";
delete sess;
}
}
if (qprogress) qprogress->setValue(100);
if (qprogress) { qprogress->setValue(100); }
return true;
}
bool Machine::SaveSession(Session *sess)
{
QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
if (sess->IsChanged()) sess->Store(path);
QString path = profile->Get(
properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
if (sess->IsChanged()) { sess->Store(path); }
return true;
}
bool Machine::Save()
{
//int size;
int cnt=0;
int cnt = 0;
QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
QString path = profile->Get(
properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
QDir dir(path);
if (!dir.exists()) {
dir.mkdir(path);
}
QHash<SessionID,Session *>::iterator s;
QHash<SessionID, Session *>::iterator s;
m_savelist.clear();
for (s=sessionlist.begin(); s!=sessionlist.end(); s++) {
for (s = sessionlist.begin(); s != sessionlist.end(); s++) {
cnt++;
if ((*s)->IsChanged()) {
m_savelist.push_back(*s);
}
}
savelistCnt=0;
savelistSize=m_savelist.size();
bool cachesessions=PROFILE.session->cacheSessions();
savelistCnt = 0;
savelistSize = m_savelist.size();
bool cachesessions = PROFILE.session->cacheSessions();
if (!PROFILE.session->multithreading()) {
for (int i=0;i<savelistSize;i++) {
if ((i % 10) ==0) {
qprogress->setValue(0+(float(savelistCnt)/float(savelistSize)*100.0));
for (int i = 0; i < savelistSize; i++) {
if ((i % 10) == 0) {
qprogress->setValue(0 + (float(savelistCnt) / float(savelistSize) * 100.0));
QApplication::processEvents();
}
Session *s=m_savelist.at(i);
Session *s = m_savelist.at(i);
s->UpdateSummaries();
s->Store(path);
if (!cachesessions)
if (!cachesessions) {
s->TrashEvents();
}
savelistCnt++;
}
return true;
}
int threads=QThread::idealThreadCount();
savelistSem=new QSemaphore(threads);
int threads = QThread::idealThreadCount();
savelistSem = new QSemaphore(threads);
savelistSem->acquire(threads);
QVector<SaveThread*>thread;
for (int i=0;i<threads;i++) {
thread.push_back(new SaveThread(this,path));
QObject::connect(thread[i],SIGNAL(UpdateProgress(int)),qprogress,SLOT(setValue(int)));
QVector<SaveThread *>thread;
for (int i = 0; i < threads; i++) {
thread.push_back(new SaveThread(this, path));
QObject::connect(thread[i], SIGNAL(UpdateProgress(int)), qprogress, SLOT(setValue(int)));
thread[i]->start();
}
while (!savelistSem->tryAcquire(threads,250)) {
while (!savelistSem->tryAcquire(threads, 250)) {
if (qprogress) {
// qprogress->setValue(66.0+(float(savelistCnt)/float(savelistSize)*33.0));
QApplication::processEvents();
// qprogress->setValue(66.0+(float(savelistCnt)/float(savelistSize)*33.0));
QApplication::processEvents();
}
}
for (int i=0;i<threads;i++) {
for (int i = 0; i < threads; i++) {
while (thread[i]->isRunning()) {
SaveThread::msleep(250);
QApplication::processEvents();
}
delete thread[i];
}
@ -387,29 +441,34 @@ bool Machine::Save()
void SaveThread::run()
{
bool cachesessions=PROFILE.session->cacheSessions();
bool cachesessions = PROFILE.session->cacheSessions();
while (Session *sess=machine->popSaveList()) {
int i=(float(machine->savelistCnt)/float(machine->savelistSize)*100.0);
while (Session *sess = machine->popSaveList()) {
int i = (float(machine->savelistCnt) / float(machine->savelistSize) * 100.0);
emit UpdateProgress(i);
sess->UpdateSummaries();
sess->Store(path);
if (!cachesessions)
if (!cachesessions) {
sess->TrashEvents();
}
}
machine->savelistSem->release(1);
}
Session *Machine::popSaveList()
{
Session *sess=NULL;
Session *sess = NULL;
savelistMutex.lock();
if (m_savelist.size()>0) {
sess=m_savelist.at(0);
if (m_savelist.size() > 0) {
sess = m_savelist.at(0);
m_savelist.pop_front();
savelistCnt++;
}
savelistMutex.unlock();
return sess;
}
@ -417,9 +476,9 @@ Session *Machine::popSaveList()
//////////////////////////////////////////////////////////////////////////////////////////
// CPAP implmementation
//////////////////////////////////////////////////////////////////////////////////////////
CPAP::CPAP(Profile *p,MachineID id):Machine(p,id)
CPAP::CPAP(Profile *p, MachineID id): Machine(p, id)
{
m_type=MT_CPAP;
m_type = MT_CPAP;
}
CPAP::~CPAP()
@ -429,9 +488,9 @@ CPAP::~CPAP()
//////////////////////////////////////////////////////////////////////////////////////////
// Oximeter Class implmementation
//////////////////////////////////////////////////////////////////////////////////////////
Oximeter::Oximeter(Profile *p,MachineID id):Machine(p,id)
Oximeter::Oximeter(Profile *p, MachineID id): Machine(p, id)
{
m_type=MT_OXIMETER;
m_type = MT_OXIMETER;
}
Oximeter::~Oximeter()
@ -441,9 +500,9 @@ Oximeter::~Oximeter()
//////////////////////////////////////////////////////////////////////////////////////////
// SleepStage Class implmementation
//////////////////////////////////////////////////////////////////////////////////////////
SleepStage::SleepStage(Profile *p,MachineID id):Machine(p,id)
SleepStage::SleepStage(Profile *p, MachineID id): Machine(p, id)
{
m_type=MT_SLEEPSTAGE;
m_type = MT_SLEEPSTAGE;
}
SleepStage::~SleepStage()
{
@ -452,9 +511,9 @@ SleepStage::~SleepStage()
//////////////////////////////////////////////////////////////////////////////////////////
// PositionSensor Class implmementation
//////////////////////////////////////////////////////////////////////////////////////////
PositionSensor::PositionSensor(Profile *p,MachineID id):Machine(p,id)
PositionSensor::PositionSensor(Profile *p, MachineID id): Machine(p, id)
{
m_type=MT_POSITION;
m_type = MT_POSITION;
}
PositionSensor::~PositionSensor()
{
@ -462,14 +521,19 @@ PositionSensor::~PositionSensor()
ChannelID NoChannel, SESSION_ENABLED;
ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi, CPAP_Pressure, CPAP_PS, CPAP_Mode, CPAP_AHI,
CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive, CPAP_Hypopnea,
CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore, CPAP_VSnore2,
CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure, CPAP_MaskPressureHi,
CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_PSMin, CPAP_PSMax, CPAP_Test1, CPAP_Test2;
ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi, CPAP_Pressure,
CPAP_PS, CPAP_Mode, CPAP_AHI,
CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive,
CPAP_Hypopnea,
CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore,
CPAP_VSnore2,
CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure,
CPAP_MaskPressureHi,
CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_PSMin, CPAP_PSMax, CPAP_Test1,
CPAP_Test2;
ChannelID RMS9_E01, RMS9_E02, RMS9_EPR, RMS9_EPRSet, RMS9_SetPressure;
@ -477,16 +541,21 @@ ChannelID INTP_SmartFlex;
ChannelID INTELLIPAP_Unknown1, INTELLIPAP_Unknown2;
ChannelID PRS1_00, PRS1_01, PRS1_08, PRS1_0A, PRS1_0B, PRS1_0C, PRS1_0E, PRS1_0F, PRS1_10, PRS1_12,
PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock, PRS1_SysOneResistStat,
PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock,
PRS1_SysOneResistStat,
PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
ChannelID OXI_Pulse, OXI_SPO2, OXI_PulseChange, OXI_SPO2Drop, OXI_Plethy;
ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start, Bookmark_End, Bookmark_Notes;
ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start,
Bookmark_End, Bookmark_Notes;
ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM, ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel, ZEO_FirmwareVersion,
ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime, ZEO_RiseTime;
ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM,
ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel,
ZEO_FirmwareVersion,
ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime,
ZEO_RiseTime;
ChannelID POS_Orientation, POS_Inclination;

76
sleepyhead/SleepLib/machine.h
View File

@ -40,21 +40,21 @@ class Machine;
/*! \class SaveThread
\brief This class is used in the multithreaded save code.. It accelerates the indexing of summary data.
*/
class SaveThread:public QThread
class SaveThread: public QThread
{
Q_OBJECT
public:
SaveThread(Machine *m,QString p) { machine=m; path=p; }
public:
SaveThread(Machine *m, QString p) { machine = m; path = p; }
//! \brief Static millisecond sleep function.. Can be used from anywhere
static void msleep(unsigned long msecs) { QThread::msleep(msecs); }
//! \brief Start Save processing thread running
virtual void run();
protected:
protected:
Machine *machine;
QString path;
signals:
signals:
//! \brief Signal sent to update the Progress Bar
void UpdateProgress(int i);
};
@ -66,13 +66,13 @@ signals:
*/
class Machine
{
public:
public:
/*! \fn Machine(Profile *p,MachineID id=0);
\brief Constructs a Machine object in Profile p, and with MachineID id
If supplied MachineID is zero, it will generate a new unused random one.
*/
Machine(Profile *p,MachineID id=0);
Machine(Profile *p, MachineID id = 0);
virtual ~Machine();
//! \brief Load all Machine summary data
@ -87,50 +87,50 @@ public:
bool Purge(int secret);
//! \brief Contains a secondary index of day data, containing just this machines sessions
QMap<QDate,Day *> day;
QMap<QDate, Day *> day;
//! \brief Contains all sessions for this machine, indexed by SessionID
QHash<SessionID,Session *> sessionlist;
QHash<SessionID, Session *> sessionlist;
//! \brief List of text machine properties, like brand, model, etc...
QHash<QString,QString> properties;
QHash<QString, QString> properties;
//! \brief Returns a pointer to a valid Session object if SessionID exists
Session * SessionExists(SessionID session);
Session *SessionExists(SessionID session);
//! \brief Adds the session to this machine object, and the Master Profile list. (used during load)
QDate AddSession(Session *s,Profile *p);
QDate AddSession(Session *s, Profile *p);
//! \brief Find the date this session belongs in, according to profile settings
QDate pickDate(qint64 start);
//! \brief Sets the Class of machine (Used to reference the particular loader that created it)
void SetClass(QString t) { m_class=t; }
void SetClass(QString t) { m_class = t; }
//! \brief Sets the type of machine, according to MachineType enum
void SetType(MachineType t) { m_type=t; }
void SetType(MachineType t) { m_type = t; }
//! \brief Returns the Class of machine (Used to reference the particular loader that created it)
const QString & GetClass() { return m_class; }
const QString &GetClass() { return m_class; }
//! \brief Returns the type of machine, according to MachineType enum
const MachineType & GetType() { return m_type; }
const MachineType &GetType() { return m_type; }
//! \brief Returns the machineID as a lower case hexadecimal string
QString hexid() { return QString().sprintf("%08lx",m_id); }
QString hexid() { return QString().sprintf("%08lx", m_id); }
//! \brief Unused, increments the most recent sessionID
SessionID CreateSessionID() { return highest_sessionid+1; }
SessionID CreateSessionID() { return highest_sessionid + 1; }
//! \brief Returns this objects MachineID
const MachineID & id() { return m_id; }
const MachineID &id() { return m_id; }
//! \brief Returns the date of the first loaded Session
const QDate & FirstDay() { return firstday; }
const QDate &FirstDay() { return firstday; }
//! \brief Returns the date of the most recent loaded Session
const QDate & LastDay() { return lastday; }
const QDate &LastDay() { return lastday; }
//! \brief Grab the next task in the multithreaded save code
Session *popSaveList();
@ -143,8 +143,8 @@ public:
QMutex savelistMutex;
QSemaphore *savelistSem;
protected:
QDate firstday,lastday;
protected:
QDate firstday, lastday;
SessionID highest_sessionid;
MachineID m_id;
QString m_class;
@ -159,10 +159,10 @@ protected:
/*! \class CPAP
\brief A CPAP classed machine object..
*/
class CPAP:public Machine
class CPAP: public Machine
{
public:
CPAP(Profile *p,MachineID id=0);
public:
CPAP(Profile *p, MachineID id = 0);
virtual ~CPAP();
};
@ -170,34 +170,34 @@ public:
/*! \class Oximeter
\brief An Oximeter classed machine object..
*/
class Oximeter:public Machine
class Oximeter: public Machine
{
public:
Oximeter(Profile *p,MachineID id=0);
public:
Oximeter(Profile *p, MachineID id = 0);
virtual ~Oximeter();
protected:
protected:
};
/*! \class SleepStage
\brief A SleepStage classed machine object..
*/
class SleepStage:public Machine
class SleepStage: public Machine
{
public:
SleepStage(Profile *p,MachineID id=0);
public:
SleepStage(Profile *p, MachineID id = 0);
virtual ~SleepStage();
protected:
protected:
};
/*! \class PositionSensor
\brief A PositionSensor classed machine object..
*/
class PositionSensor:public Machine
class PositionSensor: public Machine
{
public:
PositionSensor(Profile *p,MachineID id=0);
public:
PositionSensor(Profile *p, MachineID id = 0);
virtual ~PositionSensor();
protected:
protected:
};
#endif // MACHINE_H

65
sleepyhead/SleepLib/machine_common.h
View File

@ -33,7 +33,7 @@ class BoundsError {};
//! \brief Exception class for to trap old database versions.
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 int max_number_event_fields=10;
// This should probably move somewhere else
@ -50,28 +50,25 @@ enum SummaryType { ST_CNT, ST_SUM, ST_AVG, ST_WAVG, ST_PERC, ST_90P, ST_MIN, ST_
/*! \enum MachineType
\brief Generalized type of a machine
*/
enum MachineType { MT_UNKNOWN=0,MT_CPAP,MT_OXIMETER,MT_SLEEPSTAGE,MT_JOURNAL,MT_POSITION };
enum MachineType { MT_UNKNOWN = 0, MT_CPAP, MT_OXIMETER, MT_SLEEPSTAGE, MT_JOURNAL, MT_POSITION };
//void InitMapsWithoutAwesomeInitializerLists();
/*! \enum CPAPMode
\brief CPAP Machines mode of operation
*/
enum CPAPMode//:short
{
MODE_UNKNOWN=0,MODE_CPAP,MODE_APAP,MODE_BIPAP,MODE_ASV
enum CPAPMode { //:short
MODE_UNKNOWN = 0, MODE_CPAP, MODE_APAP, MODE_BIPAP, MODE_ASV
};
/*! \enum PRTypes
\brief Pressure Relief Types, used by CPAP machines
*/
enum PRTypes//:short
{
PR_UNKNOWN=0,PR_NONE,PR_CFLEX,PR_CFLEXPLUS,PR_AFLEX,PR_BIFLEX,PR_EPR,PR_SMARTFLEX,PR_EASYBREATHE,PR_SENSAWAKE
enum PRTypes { //:short
PR_UNKNOWN = 0, PR_NONE, PR_CFLEX, PR_CFLEXPLUS, PR_AFLEX, PR_BIFLEX, PR_EPR, PR_SMARTFLEX, PR_EASYBREATHE, PR_SENSAWAKE
};
enum PRModes//:short
{
PM_UNKNOWN=0,PM_RampOnly,PM_FullTime
enum PRModes { //:short
PM_UNKNOWN = 0, PM_RampOnly, PM_FullTime
};
@ -85,35 +82,45 @@ enum PRModes//:short
*/
enum MCDataType
{ MC_bool=0, MC_int, MC_long, MC_float, MC_double, MC_string, MC_datetime };
{ MC_bool = 0, MC_int, MC_long, MC_float, MC_double, MC_string, MC_datetime };
extern ChannelID NoChannel,SESSION_ENABLED;
extern ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi, CPAP_Pressure, CPAP_PS, CPAP_PSMin, CPAP_PSMax,
CPAP_Mode, CPAP_AHI,
CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive, CPAP_Hypopnea,
CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore, CPAP_VSnore2,
CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure, CPAP_MaskPressureHi,
CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_Test1, CPAP_Test2;
extern ChannelID NoChannel, SESSION_ENABLED;
extern ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi,
CPAP_Pressure, CPAP_PS, CPAP_PSMin, CPAP_PSMax,
CPAP_Mode, CPAP_AHI,
CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive,
CPAP_Hypopnea,
CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore,
CPAP_VSnore2,
CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure,
CPAP_MaskPressureHi,
CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_Test1, CPAP_Test2;
extern ChannelID RMS9_E01, RMS9_E02, RMS9_EPR, RMS9_EPRSet, RMS9_SetPressure;
extern ChannelID INTP_SmartFlex;
extern ChannelID PRS1_00, PRS1_01, PRS1_08, PRS1_0A, PRS1_0B, PRS1_0C, PRS1_0E, PRS1_0F, PRS1_10, PRS1_12,
PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock, PRS1_SysOneResistStat,
PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
extern ChannelID PRS1_00, PRS1_01, PRS1_08, PRS1_0A, PRS1_0B, PRS1_0C, PRS1_0E, PRS1_0F, PRS1_10,
PRS1_12,
PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock,
PRS1_SysOneResistStat,
PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
extern ChannelID INTELLIPAP_Unknown1, INTELLIPAP_Unknown2;
extern ChannelID OXI_Pulse, OXI_SPO2, OXI_PulseChange, OXI_SPO2Drop, OXI_Plethy;
extern ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start, Bookmark_End, Bookmark_Notes;
extern ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start,
Bookmark_End, Bookmark_Notes;
extern ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM, ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel, ZEO_FirmwareVersion,
ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime, ZEO_RiseTime;
extern ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM,
ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel,
ZEO_FirmwareVersion,
ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime,
ZEO_RiseTime;
extern ChannelID POS_Orientation, POS_Inclination;

35
sleepyhead/SleepLib/machine_loader.cpp
View File

@ -28,9 +28,10 @@ void RegisterLoader(MachineLoader *loader)
}
void DestroyLoaders()
{
for (QList<MachineLoader *>::iterator i=m_loaders.begin(); i!=m_loaders.end(); i++) {
delete (*i);
for (QList<MachineLoader *>::iterator i = m_loaders.begin(); i != m_loaders.end(); i++) {
delete(*i);
}
m_loaders.clear();
}
@ -45,44 +46,52 @@ MachineLoader::MachineLoader()
}*/
MachineLoader::~MachineLoader()
{
for (QList<Machine *>::iterator m=m_machlist.begin();m!=m_machlist.end();m++) {
for (QList<Machine *>::iterator m = m_machlist.begin(); m != m_machlist.end(); m++) {
delete *m;
}
}
bool MachineLoader::compressFile(QString inpath, QString outpath)
{
if (outpath.isEmpty())
outpath=inpath+".gz";
else if (!outpath.endsWith(".gz")) {
outpath+=".gz";
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();
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)) {
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.toLatin1(),"wb");
gzFile gz = gzopen(outpath.toLatin1(), "wb");
//gzbuffer(gz,65536*2);
if (!gz) {
qDebug() << "compressFile() Couldn't open" << outpath <<"for writing";
qDebug() << "compressFile() Couldn't open" << outpath << "for writing";
delete buf;
return false;
}
gzwrite(gz,buf,size);
gzwrite(gz, buf, size);
gzclose(gz);
delete buf;
return true;

46
sleepyhead/SleepLib/machine_loader.h
View File

@ -21,7 +21,7 @@
*/
class MachineLoader
{
public:
public:
MachineLoader();
virtual ~MachineLoader();
@ -29,43 +29,43 @@ public:
//virtual Machine * CreateMachine() {};
//! \brief Override this to scan path and detect new machine data
virtual int Open(QString & path,Profile *)=0; // Scans for new content
virtual int Open(QString &path, Profile *) = 0; // Scans for new content
//! \brief Override to returns the Version number of this MachineLoader
virtual int Version()=0;
virtual int Version() = 0;
//! \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="");
bool compressFile(QString inpath, QString outpath = "");
/*
MachineLoader(Profile *profile,QString & classname);
virtual void LoadMachineList();
virtual void SaveMachineList();
virtual bool LoadSummaries();
virtual bool LoadEvents();
virtual bool LoadWaveforms();
virtual bool Scan(QString &)=0; // Scans for new content
/*
MachineLoader(Profile *profile,QString & classname);
virtual void LoadMachineList();
virtual void SaveMachineList();
virtual bool LoadSummaries();
virtual bool LoadEvents();
virtual bool LoadWaveforms();
virtual bool Scan(QString &)=0; // Scans for new content
virtual bool LoadAll();
virtual bool SaveAll();
virtual bool LoadAll();
virtual bool SaveAll();
virtual bool LoadSummary(Machine * m, QString & filename);
virtual bool LoadEvent(Machine * m, QString & filename);
virtual bool LoadWaveform(Machine * m, QString & filename);
virtual bool LoadSummary(Machine * m, QString & filename);
virtual bool LoadEvent(Machine * m, QString & filename);
virtual bool LoadWaveform(Machine * m, QString & filename);
virtual bool SaveSummary(Machine * m, QString & filename);
virtual bool SaveEvent(Machine * m, QString & filename);
virtual bool SaveWaveform(Machine * m, QString & filename);*/
virtual bool SaveSummary(Machine * m, QString & filename);
virtual bool SaveEvent(Machine * m, QString & filename);
virtual bool SaveWaveform(Machine * m, QString & filename);*/
protected:
protected:
//! \brief Contains a list of Machine records known by this loader
QList<Machine *> m_machlist;
QString m_class;
MachineType m_type;
Profile * m_profile;
Profile *m_profile;
};
// Put in machine loader class as static??

250
sleepyhead/SleepLib/preferences.cpp
View File

@ -27,29 +27,31 @@
#include "common.h"
#include "preferences.h"
const QString & getUserName()
const QString &getUserName()
{
static QString userName;
userName=getenv("USER");
userName = getenv("USER");
if (userName.isEmpty()) {
userName=QObject::tr("Windows User");
userName = QObject::tr("Windows User");
#if defined (Q_OS_WIN32)
#if defined(UNICODE)
if (QSysInfo::WindowsVersion >= QSysInfo::WV_NT) {
TCHAR winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
DWORD winUserNameSize = sizeof(winUserName);
GetUserNameW( winUserName, &winUserNameSize );
userName = QString::fromStdWString( winUserName );
} else
#endif
{
char winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
DWORD winUserNameSize = sizeof(winUserName);
GetUserNameA( winUserName, &winUserNameSize );
userName = QString::fromLocal8Bit( winUserName );
}
#if defined(UNICODE)
if (QSysInfo::WindowsVersion >= QSysInfo::WV_NT) {
TCHAR winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
DWORD winUserNameSize = sizeof(winUserName);
GetUserNameW(winUserName, &winUserNameSize);
userName = QString::fromStdWString(winUserName);
} else
#endif
{
char winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
DWORD winUserNameSize = sizeof(winUserName);
GetUserNameA(winUserName, &winUserNameSize);
userName = QString::fromLocal8Bit(winUserName);
}
#endif
}
@ -61,16 +63,18 @@ QString GetAppRoot()
{
QSettings settings(getDeveloperName(), getAppName());
QString HomeAppRoot=settings.value("Settings/AppRoot").toString();
QString HomeAppRoot = settings.value("Settings/AppRoot").toString();
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
const QString desktopFolder=QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
const QString desktopFolder = QDesktopServices::storageLocation(
QDesktopServices::DocumentsLocation);
#else
const QString desktopFolder=QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
const QString desktopFolder = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
#endif
if (HomeAppRoot.isEmpty())
HomeAppRoot=desktopFolder+"/"+getDefaultAppRoot();
if (HomeAppRoot.isEmpty()) {
HomeAppRoot = desktopFolder + "/" + getDefaultAppRoot();
}
return HomeAppRoot;
}
@ -78,28 +82,28 @@ QString GetAppRoot()
Preferences::Preferences()
{
p_name="Preferences";
p_path=GetAppRoot();
p_name = "Preferences";
p_path = GetAppRoot();
}
Preferences::Preferences(QString name,QString filename)
Preferences::Preferences(QString name, QString filename)
{
if (name.endsWith(STR_ext_XML)) {
p_name=name.section(".",0,0);
p_name = name.section(".", 0, 0);
} else {
p_name=name;
p_name = name;
}
if (filename.isEmpty()) {
p_filename=GetAppRoot()+"/"+p_name+STR_ext_XML;
p_filename = GetAppRoot() + "/" + p_name + STR_ext_XML;
} else {
if (!filename.contains("/")) {
p_filename=GetAppRoot()+"/";
} else p_filename="";
p_filename = GetAppRoot() + "/";
} else { p_filename = ""; }
p_filename+=filename;
p_filename += filename;
if (!p_filename.endsWith(STR_ext_XML)) p_filename+=STR_ext_XML;
if (!p_filename.endsWith(STR_ext_XML)) { p_filename += STR_ext_XML; }
}
}
@ -122,41 +126,48 @@ Preferences::~Preferences()
const QString Preferences::Get(QString name)
{
QString temp;
QChar obr=QChar('{');
QChar cbr=QChar('}');
QString t,a,ref; // How I miss Regular Expressions here..
if (p_preferences.find(name)!=p_preferences.end()) {
temp="";
t=p_preferences[name].toString();
if (p_preferences[name].type()!=QVariant::String) {
QChar obr = QChar('{');
QChar cbr = QChar('}');
QString t, a, ref; // How I miss Regular Expressions here..
if (p_preferences.find(name) != p_preferences.end()) {
temp = "";
t = p_preferences[name].toString();
if (p_preferences[name].type() != QVariant::String) {
return t;
}
} else {
t=name; // parse the string..
t = name; // parse the string..
}
while (t.contains(obr)) {
temp+=t.section(obr,0,0);
a=t.section(obr,1);
temp += t.section(obr, 0, 0);
a = t.section(obr, 1);
if (a.startsWith("{")) {
temp+=obr;
t=a.section(obr,1);
temp += obr;
t = a.section(obr, 1);
continue;
}
ref=a.section(cbr,0,0);
if (ref.toLower()=="home") {
temp+=GetAppRoot();
} else if (ref.toLower()=="user") {
temp+=getUserName();
} else if (ref.toLower()=="sep") { // redundant in QT
temp+="/";
ref = a.section(cbr, 0, 0);
if (ref.toLower() == "home") {
temp += GetAppRoot();
} else if (ref.toLower() == "user") {
temp += getUserName();
} else if (ref.toLower() == "sep") { // redundant in QT
temp += "/";
} else {
temp+=Get(ref);
temp += Get(ref);
}
t=a.section(cbr,1);
t = a.section(cbr, 1);
}
temp+=t;
temp.replace("}}","}"); // Make things look a bit better when escaping braces.
temp += t;
temp.replace("}}", "}"); // Make things look a bit better when escaping braces.
return temp;
}
@ -164,133 +175,154 @@ const QString Preferences::Get(QString name)
bool Preferences::Open(QString filename)
{
if (!filename.isEmpty())
p_filename=filename;
if (!filename.isEmpty()) {
p_filename = filename;
}
QDomDocument doc(p_name);
QFile file(p_filename);
qDebug() << "Scanning " << QDir::toNativeSeparators(p_filename);
if (!file.open(QIODevice::ReadOnly)) {
qWarning() << "Could not open" << QDir::toNativeSeparators(p_filename);
return false;
}
if (!doc.setContent(&file)) {
qWarning() << "Invalid XML Content in" << QDir::toNativeSeparators(p_filename);
return false;
}
file.close();
QDomElement root=doc.documentElement();
QDomElement root = doc.documentElement();
if (root.tagName() != STR_AppName) {
return false;
}
root=root.firstChildElement();
root = root.firstChildElement();
if (root.tagName() != p_name) {
return false;
}
bool ok;
p_preferences.clear();
QDomNode n=root.firstChild();
QDomNode n = root.firstChild();
while (!n.isNull()) {
QDomElement e=n.toElement();
QDomElement e = n.toElement();
if (!e.isNull()) {
QString name=e.tagName();
QString type=e.attribute("type").toLower();
QString value=e.text();;
if (type=="double") {
QString name = e.tagName();
QString type = e.attribute("type").toLower();
QString value = e.text();;
if (type == "double") {
double d;
d=value.toDouble(&ok);
d = value.toDouble(&ok);
if (ok) {
p_preferences[name]=d;
p_preferences[name] = d;
} else {
qDebug() << "XML Error:" << name << "=" << value << "??";
}
} else if (type=="qlonglong") {
} else if (type == "qlonglong") {
qint64 d;
d=value.toLongLong(&ok);
d = value.toLongLong(&ok);
if (ok) {
p_preferences[name]=d;
p_preferences[name] = d;
} else {
qDebug() << "XML Error:" << name << "=" << value << "??";
}
} else if (type=="int") {
} else if (type == "int") {
int d;
d=value.toInt(&ok);
d = value.toInt(&ok);
if (ok) {
p_preferences[name]=d;
p_preferences[name] = d;
} else {
qDebug() << "XML Error:" << name << "=" << value << "??";
}
} else
if (type=="bool") {
QString v=value.toLower();
if ((v=="true") || (v=="on") || (v=="yes")) {
p_preferences[name]=true;
} else
if ((v=="false") || (v=="off") || (v=="no")) {
p_preferences[name]=false;
} else if (type == "bool") {
QString v = value.toLower();
if ((v == "true") || (v == "on") || (v == "yes")) {
p_preferences[name] = true;
} else if ((v == "false") || (v == "off") || (v == "no")) {
p_preferences[name] = false;
} else {
int d;
d=value.toInt(&ok);
d = value.toInt(&ok);
if (ok) {
p_preferences[name]=d!=0;
p_preferences[name] = d != 0;
} else {
qDebug() << "XML Error:" << name << "=" << value << "??";
}
}
} else if (type=="qdatetime") {
} else if (type == "qdatetime") {
QDateTime d;
d=QDateTime::fromString(value,"yyyy-MM-dd HH:mm:ss");
if (d.isValid())
p_preferences[name]=d;
else
qWarning() << "XML Error: Invalid DateTime record" << name << value;
d = QDateTime::fromString(value, "yyyy-MM-dd HH:mm:ss");
} else if (type=="qtime") {
if (d.isValid()) {
p_preferences[name] = d;
} else {
qWarning() << "XML Error: Invalid DateTime record" << name << value;
}
} else if (type == "qtime") {
QTime d;
d=QTime::fromString(value,"hh:mm:ss");
if (d.isValid())
p_preferences[name]=d;
else
d = QTime::fromString(value, "hh:mm:ss");
if (d.isValid()) {
p_preferences[name] = d;
} else {
qWarning() << "XML Error: Invalid Time record" << name << value;
}
} else {
p_preferences[name]=value;
p_preferences[name] = value;
}
}
n=n.nextSibling();
n = n.nextSibling();
}
root=root.nextSiblingElement();
root = root.nextSiblingElement();
ExtraLoad(root);
return true;
}
bool Preferences::Save(QString filename)
{
if (!filename.isEmpty())
p_filename=filename;
if (!filename.isEmpty()) {
p_filename = filename;
}
QDomDocument doc(p_name);
QDomElement droot = doc.createElement(STR_AppName);
doc.appendChild( droot );
doc.appendChild(droot);
QDomElement root=doc.createElement(p_name);
QDomElement root = doc.createElement(p_name);
droot.appendChild(root);
for (QHash<QString,QVariant>::iterator i=p_preferences.begin(); i!=p_preferences.end(); i++) {
QVariant::Type type=i.value().type();
if (type==QVariant::Invalid) continue;
for (QHash<QString, QVariant>::iterator i = p_preferences.begin(); i != p_preferences.end(); i++) {
QVariant::Type type = i.value().type();
QDomElement cn=doc.createElement(i.key());
cn.setAttribute("type",i.value().typeName());
if (type==QVariant::DateTime) {
if (type == QVariant::Invalid) { continue; }
QDomElement cn = doc.createElement(i.key());
cn.setAttribute("type", i.value().typeName());
if (type == QVariant::DateTime) {
cn.appendChild(doc.createTextNode(i.value().toDateTime().toString("yyyy-MM-dd HH:mm:ss")));
} else if (type==QVariant::Time) {
} else if (type == QVariant::Time) {
cn.appendChild(doc.createTextNode(i.value().toTime().toString("hh:mm:ss")));
} else {
cn.appendChild(doc.createTextNode(i.value().toString()));
@ -302,9 +334,11 @@ bool Preferences::Save(QString filename)
droot.appendChild(ExtraSave(doc));
QFile file(p_filename);
if (!file.open(QIODevice::WriteOnly)) {
return false;
}
QTextStream ts(&file);
ts << doc.toString();
file.close();

54
sleepyhead/SleepLib/preferences.h
View File

@ -19,17 +19,17 @@
#include <QDomDocument>
#include <map>
const QString STR_ext_XML=".xml";
const QString STR_ext_XML = ".xml";
extern QString GetAppRoot(); //returns app root path plus trailing path separator.
inline QString PrefMacro(QString s)
{
return "{"+s+"}";
return "{" + s + "}";
}
//! \brief Returns a QString containing the Username, according to the Operating System
const QString & getUserName();
const QString &getUserName();
/*! \class Preferences
@ -38,9 +38,9 @@ const QString & getUserName();
*/
class Preferences
{
public:
public:
//! \brief Constructs a Preferences object 'name', and remembers sets the filename
Preferences(QString name,QString filename="");
Preferences(QString name, QString filename = "");
Preferences();
virtual ~Preferences();
@ -48,13 +48,13 @@ public:
const QString Get(QString name);
//! \brief Returns the QVariant value of the selected preference.. Note, preference must exist, and will not expand {} macros
QVariant & operator[](QString name) {
QVariant &operator[](QString name) {
return p_preferences[name];
}
//! \brief Sets the Preference 'name' to QVariant 'value'
void Set(QString name,QVariant value) {
p_preferences[name]=value;
void Set(QString name, QVariant value) {
p_preferences[name] = value;
}
//! \brief Returns true if preference 'name' exists
@ -64,61 +64,65 @@ public:
//! \brief Returns true if preference 'name' exists, and contains a boolean true value
bool ExistsAndTrue(QString name) {
QHash<QString,QVariant>::iterator i=p_preferences.find(name);
if (i==p_preferences.end()) return false;
QHash<QString, QVariant>::iterator i = p_preferences.find(name);
if (i == p_preferences.end()) { return false; }
return i.value().toBool();
}
//! \brief Removes preference 'name' from this Preferences group
void Erase(QString name) {
QHash<QString,QVariant>::iterator i=p_preferences.find(name);
if (i!=p_preferences.end())
QHash<QString, QVariant>::iterator i = p_preferences.find(name);
if (i != p_preferences.end()) {
p_preferences.erase(i);
}
}
//! \brief Derive from this to handle Loading of any custom XML sections
virtual void ExtraLoad(QDomElement & root) { root=root; }
virtual void ExtraLoad(QDomElement &root) { root = root; }
//! \brief Derive from this to handle Saving of any custom XML sections
//! \return Must return a QDomElement to be inserted into the generated XML
virtual QDomElement ExtraSave(QDomDocument & doc) { doc=doc; QDomElement e; return e; }
virtual QDomElement ExtraSave(QDomDocument &doc) { doc = doc; QDomElement e; return e; }
//! \brief Opens, processes the XML for this Preferences group, loading all preferences stored therein.
//! \note If filename is empty, it will use the one specified in the constructor
//! \returns true if succesful
virtual bool Open(QString filename="");
virtual bool Open(QString filename = "");
//! \brief Saves all preferences to XML file.
//! \note If filename is empty, it will use the one specified in the constructor
//! \returns true if succesful
virtual bool Save(QString filename="");
virtual bool Save(QString filename = "");
//! \note Sets a comment string whici will be stored in the XML
void SetComment(const QString & str) {
p_comment=str;
void SetComment(const QString &str) {
p_comment = str;
}
//! \brief Finds a given preference.
//! \returns a QHash<QString,QString>::iterator pointing to the preference named 'key', or an empty end() iterator
inline QHash<QString,QVariant>::iterator find(QString key) { return p_preferences.find(key); }
inline QHash<QString, QVariant>::iterator find(QString key) { return p_preferences.find(key); }
//! \brief Returns an empty iterator pointing to the end of the preferences list
inline QHash<QString,QVariant>::iterator end() { return p_preferences.end(); }
inline QHash<QString, QVariant>::iterator end() { return p_preferences.end(); }
//! \brief Returns an iterator pointing to the first item in the preferences list
inline QHash<QString,QVariant>::iterator begin() { return p_preferences.begin(); }
inline QHash<QString, QVariant>::iterator begin() { return p_preferences.begin(); }
//int GetCode(QString name); // For registering/looking up new preference code.
//! \brief Stores all the variants indexed by a QString name for this Preferences object
QHash<QString,QVariant> p_preferences;
QHash<QString, QVariant> p_preferences;
void setPath(const QString & path) { p_path=path; }
void setFilename(const QString & filename) { p_filename=filename; }
void setPath(const QString &path) { p_path = path; }
void setFilename(const QString &filename) { p_filename = filename; }
const QString name() { return p_name; }
protected:
protected:
//QHash<int,QString> p_codes;
QString p_comment;
QString p_name;

1125
sleepyhead/SleepLib/profiles.cpp
View File

File diff suppressed because it is too large Load Diff

677
sleepyhead/SleepLib/profiles.h
View File

@ -43,9 +43,9 @@ class SessionSettings;
\date 28/04/11
\brief The User profile system, containing all information for a user, and an index into all Machine data
*/
class Profile:public Preferences
class Profile: public Preferences
{
public:
public:
//! \brief Creates a new Profile object 'name' (which is usually just set to "Profile", the XML filename is derived from this)
Profile(QString name);
@ -53,15 +53,15 @@ public:
Profile();
virtual ~Profile();
virtual bool Open(QString filename="");
virtual bool Open(QString filename = "");
//! \brief Save Profile object (This is an extension to Preference::Save(..))
virtual bool Save(QString filename="");
virtual bool Save(QString filename = "");
bool is_first_day;
//! \brief List of machines, indexed by MachineID
QHash<MachineID,Machine *> machlist;
QHash<MachineID, Machine *> machlist;
//! \brief Add machine to this profiles machlist
void AddMachine(Machine *m);
@ -81,54 +81,63 @@ public:
int Import(QString path);
//! \brief Remove a session from day object, without deleting the Session object
void RemoveSession(Session * sess);
void RemoveSession(Session *sess);
//! \brief Add Day record to Profile Day list
void AddDay(QDate date,Day *day,MachineType mt);
void AddDay(QDate date, Day *day, MachineType mt);
//! \brief Get Day record if data available for date and machine type, else return NULL
Day * GetDay(QDate date,MachineType type=MT_UNKNOWN);
Day *GetDay(QDate date, MachineType type = MT_UNKNOWN);
//! \brief Get Day record if data available for date and machine type, and has enabled session data, else return NULL
Day * GetGoodDay(QDate date,MachineType type);
Day *GetGoodDay(QDate date, MachineType type);
//! \brief Returns a list of all machines of type t
QList<Machine *> GetMachines(MachineType t=MT_UNKNOWN);
QList<Machine *> GetMachines(MachineType t = MT_UNKNOWN);
//! \brief Returns the machine of type t used on date, NULL if none..
Machine * GetMachine(MachineType t,QDate date);
Machine *GetMachine(MachineType t, QDate date);
//! \brief return the first machine of type t
Machine * GetMachine(MachineType t);
Machine *GetMachine(MachineType t);
//! \brief Returns true if this profile stores this variable identified by key
bool contains(QString key) { return p_preferences.contains(key); }
int countDays(MachineType mt=MT_UNKNOWN, QDate start=QDate(), QDate end=QDate());
EventDataType calcCount(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
double calcSum(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcHours(MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcAvg(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcWavg(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcMin(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcMax(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcPercentile(ChannelID code, EventDataType percent, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
int countDays(MachineType mt = MT_UNKNOWN, QDate start = QDate(), QDate end = QDate());
EventDataType calcCount(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
double calcSum(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
EventDataType calcHours(MachineType mt = MT_CPAP, QDate start = QDate(), QDate end = QDate());
EventDataType calcAvg(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
EventDataType calcWavg(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
EventDataType calcMin(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
EventDataType calcMax(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
EventDataType calcPercentile(ChannelID code, EventDataType percent, MachineType mt = MT_CPAP,
QDate start = QDate(), QDate end = QDate());
bool hasChannel(ChannelID code);
EventDataType calcSettingsMin(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcSettingsMax(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
EventDataType calcSettingsMin(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
EventDataType calcSettingsMax(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
QDate end = QDate());
virtual void ExtraLoad(QDomElement & root);
virtual QDomElement ExtraSave(QDomDocument & doc);
virtual void ExtraLoad(QDomElement &root);
virtual QDomElement ExtraSave(QDomDocument &doc);
QMap<QDate,QList<Day *> > daylist;
QDate FirstDay(MachineType mt=MT_UNKNOWN);
QDate LastDay(MachineType mt=MT_UNKNOWN);
QMap<QDate, QList<Day *> > daylist;
QDate FirstDay(MachineType mt = MT_UNKNOWN);
QDate LastDay(MachineType mt = MT_UNKNOWN);
QDate FirstGoodDay(MachineType mt=MT_UNKNOWN);
QDate LastGoodDay(MachineType mt=MT_UNKNOWN);
QDate FirstGoodDay(MachineType mt = MT_UNKNOWN);
QDate LastGoodDay(MachineType mt = MT_UNKNOWN);
QString dataFolder() { return (*this).Get("{DataFolder}"); }
@ -141,17 +150,17 @@ public:
SessionSettings *session;
protected:
QDate m_first,m_last;
protected:
QDate m_first, m_last;
};
class MachineLoader;
extern MachineLoader * GetLoader(QString name);
extern MachineLoader *GetLoader(QString name);
extern Preferences *p_pref;
extern Preferences *p_layout;
extern Profile * p_profile;
extern Profile *p_profile;
// these are bad and must change
#define PREF (*p_pref)
@ -159,111 +168,115 @@ extern Profile * p_profile;
#define PROFILE (*p_profile)
// DoctorInfo Strings
const QString STR_DI_Name="DoctorName";
const QString STR_DI_Phone="DoctorPhone";
const QString STR_DI_Email="DoctorEmail";
const QString STR_DI_Practice="DoctorPractice";
const QString STR_DI_Address="DoctorAddress";
const QString STR_DI_PatientID="DoctorPatientID";
const QString STR_DI_Name = "DoctorName";
const QString STR_DI_Phone = "DoctorPhone";
const QString STR_DI_Email = "DoctorEmail";
const QString STR_DI_Practice = "DoctorPractice";
const QString STR_DI_Address = "DoctorAddress";
const QString STR_DI_PatientID = "DoctorPatientID";
// UserInfo Strings
const QString STR_UI_DOB="DOB";
const QString STR_UI_FirstName="FirstName";
const QString STR_UI_LastName="LastName";
const QString STR_UI_UserName="UserName";
const QString STR_UI_Password="Password";
const QString STR_UI_Address="Address";
const QString STR_UI_Phone="Phone";
const QString STR_UI_EmailAddress="EmailAddress";
const QString STR_UI_Country="Country";
const QString STR_UI_Height="Height";
const QString STR_UI_Gender="Gender";
const QString STR_UI_TimeZone="TimeZone";
const QString STR_UI_DST="DST";
const QString STR_UI_DOB = "DOB";
const QString STR_UI_FirstName = "FirstName";
const QString STR_UI_LastName = "LastName";
const QString STR_UI_UserName = "UserName";
const QString STR_UI_Password = "Password";
const QString STR_UI_Address = "Address";
const QString STR_UI_Phone = "Phone";
const QString STR_UI_EmailAddress = "EmailAddress";
const QString STR_UI_Country = "Country";
const QString STR_UI_Height = "Height";
const QString STR_UI_Gender = "Gender";
const QString STR_UI_TimeZone = "TimeZone";
const QString STR_UI_DST = "DST";
// OxiSettings Strings
const QString STR_OS_EnableOximetry="EnableOximetry";
const QString STR_OS_SyncOximetry="SyncOximetry";
const QString STR_OS_OximeterType="OximeterType";
const QString STR_OS_OxiDiscardThreshold="OxiDiscardThreshold";
const QString STR_OS_SPO2DropDuration="SPO2DropDuration";
const QString STR_OS_SPO2DropPercentage="SPO2DropPercentage";
const QString STR_OS_PulseChangeDuration="PulseChangeDuration";
const QString STR_OS_PulseChangeBPM="PulseChangeBPM";
const QString STR_OS_EnableOximetry = "EnableOximetry";
const QString STR_OS_SyncOximetry = "SyncOximetry";
const QString STR_OS_OximeterType = "OximeterType";
const QString STR_OS_OxiDiscardThreshold = "OxiDiscardThreshold";
const QString STR_OS_SPO2DropDuration = "SPO2DropDuration";
const QString STR_OS_SPO2DropPercentage = "SPO2DropPercentage";
const QString STR_OS_PulseChangeDuration = "PulseChangeDuration";
const QString STR_OS_PulseChangeBPM = "PulseChangeBPM";
// CPAPSettings Strings
const QString STR_CS_ComplianceHours="ComplianceHours";
const QString STR_CS_ShowCompliance="ShowCompliance";
const QString STR_CS_ShowLeaksMode="ShowLeaksMode";
const QString STR_CS_MaskStartDate="MaskStartDate";
const QString STR_CS_MaskDescription="MaskDescription";
const QString STR_CS_MaskType="MaskType";
const QString STR_CS_PrescribedMode="CPAPPrescribedMode";
const QString STR_CS_PrescribedMinPressure="CPAPPrescribedMinPressure";
const QString STR_CS_PrescribedMaxPressure="CPAPPrescribedMaxPressure";
const QString STR_CS_UntreatedAHI="UntreatedAHI";
const QString STR_CS_Notes="CPAPNotes";
const QString STR_CS_DateDiagnosed="DateDiagnosed";
const QString STR_CS_UserEventFlagging="UserEventFlagging";
const QString STR_CS_UserFlowRestriction="UserFlowRestriction";
const QString STR_CS_UserEventDuration="UserEventDuration";
const QString STR_CS_UserEventDuplicates="UserEventDuplicates";
const QString STR_CS_AHIWindow="AHIWindow";
const QString STR_CS_AHIReset="AHIReset";
const QString STR_CS_ClockDrift="ClockDrift";
const QString STR_CS_ComplianceHours = "ComplianceHours";
const QString STR_CS_ShowCompliance = "ShowCompliance";
const QString STR_CS_ShowLeaksMode = "ShowLeaksMode";
const QString STR_CS_MaskStartDate = "MaskStartDate";
const QString STR_CS_MaskDescription = "MaskDescription";
const QString STR_CS_MaskType = "MaskType";
const QString STR_CS_PrescribedMode = "CPAPPrescribedMode";
const QString STR_CS_PrescribedMinPressure = "CPAPPrescribedMinPressure";
const QString STR_CS_PrescribedMaxPressure = "CPAPPrescribedMaxPressure";
const QString STR_CS_UntreatedAHI = "UntreatedAHI";
const QString STR_CS_Notes = "CPAPNotes";
const QString STR_CS_DateDiagnosed = "DateDiagnosed";
const QString STR_CS_UserEventFlagging = "UserEventFlagging";
const QString STR_CS_UserFlowRestriction = "UserFlowRestriction";
const QString STR_CS_UserEventDuration = "UserEventDuration";
const QString STR_CS_UserEventDuplicates = "UserEventDuplicates";
const QString STR_CS_AHIWindow = "AHIWindow";
const QString STR_CS_AHIReset = "AHIReset";
const QString STR_CS_ClockDrift = "ClockDrift";
// ImportSettings Strings
const QString STR_IS_DaySplitTime="DaySplitTime";
const QString STR_IS_CacheSessions="MemoryHog";
const QString STR_IS_CombineCloseSessions="CombineCloserSessions";
const QString STR_IS_IgnoreShorterSessions="IgnoreShorterSessions";
const QString STR_IS_Multithreading="EnableMultithreading";
const QString STR_IS_BackupCardData="BackupCardData";
const QString STR_IS_CompressBackupData="CompressBackupData";
const QString STR_IS_CompressSessionData="CompressSessionData";
const QString STR_IS_DaySplitTime = "DaySplitTime";
const QString STR_IS_CacheSessions = "MemoryHog";
const QString STR_IS_CombineCloseSessions = "CombineCloserSessions";
const QString STR_IS_IgnoreShorterSessions = "IgnoreShorterSessions";
const QString STR_IS_Multithreading = "EnableMultithreading";
const QString STR_IS_BackupCardData = "BackupCardData";
const QString STR_IS_CompressBackupData = "CompressBackupData";
const QString STR_IS_CompressSessionData = "CompressSessionData";
// AppearanceSettings Strings
const QString STR_AS_GraphHeight="GraphHeight";
const QString STR_AS_AntiAliasing="UseAntiAliasing";
const QString STR_AS_GraphSnapshots="EnableGraphSnapshots";
const QString STR_AS_Animations="AnimationsAndTransitions";
const QString STR_AS_SquareWave="SquareWavePlots";
const QString STR_AS_OverlayType="OverlayType";
const QString STR_AS_OverviewLinechartMode="OverviewLinechartMode";
const QString STR_AS_UsePixmapCaching="UsePixmapCaching";
const QString STR_AS_AllowYAxisScaling="AllowYAxisScaling";
const QString STR_AS_GraphTooltips="GraphTooltips";
const QString STR_AS_GraphHeight = "GraphHeight";
const QString STR_AS_AntiAliasing = "UseAntiAliasing";
const QString STR_AS_GraphSnapshots = "EnableGraphSnapshots";
const QString STR_AS_Animations = "AnimationsAndTransitions";
const QString STR_AS_SquareWave = "SquareWavePlots";
const QString STR_AS_OverlayType = "OverlayType";
const QString STR_AS_OverviewLinechartMode = "OverviewLinechartMode";
const QString STR_AS_UsePixmapCaching = "UsePixmapCaching";
const QString STR_AS_AllowYAxisScaling = "AllowYAxisScaling";
const QString STR_AS_GraphTooltips = "GraphTooltips";
// UserSettings Strings
const QString STR_US_UnitSystem="UnitSystem";
const QString STR_US_EventWindowSize="EventWindowSize";
const QString STR_US_SkipEmptyDays="SkipEmptyDays";
const QString STR_US_RebuildCache="RebuildCache";
const QString STR_US_ShowDebug="ShowDebug";
const QString STR_US_LinkGroups="LinkGroups";
const QString STR_US_CalculateRDI="CalculateRDI";
const QString STR_US_ShowSerialNumbers="ShowSerialNumbers";
const QString STR_US_PrefCalcMiddle="PrefCalcMiddle";
const QString STR_US_PrefCalcPercentile="PrefCalcPercentile";
const QString STR_US_PrefCalcMax="PrefCalcMax";
const QString STR_US_TooltipTimeout="TooltipTimeout";
const QString STR_US_ScrollDampening="ScrollDampening";
const QString STR_US_UnitSystem = "UnitSystem";
const QString STR_US_EventWindowSize = "EventWindowSize";
const QString STR_US_SkipEmptyDays = "SkipEmptyDays";
const QString STR_US_RebuildCache = "RebuildCache";
const QString STR_US_ShowDebug = "ShowDebug";
const QString STR_US_LinkGroups = "LinkGroups";
const QString STR_US_CalculateRDI = "CalculateRDI";
const QString STR_US_ShowSerialNumbers = "ShowSerialNumbers";
const QString STR_US_PrefCalcMiddle = "PrefCalcMiddle";
const QString STR_US_PrefCalcPercentile = "PrefCalcPercentile";
const QString STR_US_PrefCalcMax = "PrefCalcMax";
const QString STR_US_TooltipTimeout = "TooltipTimeout";
const QString STR_US_ScrollDampening = "ScrollDampening";
class DoctorInfo
{
public:
DoctorInfo(Profile *p) : m_profile(p)
{
if (!m_profile->contains(STR_DI_Name)) (*m_profile)[STR_DI_Name]=QString();
if (!m_profile->contains(STR_DI_Phone)) (*m_profile)[STR_DI_Phone]=QString();
if (!m_profile->contains(STR_DI_Email)) (*m_profile)[STR_DI_Email]=QString();
if (!m_profile->contains(STR_DI_Practice)) (*m_profile)[STR_DI_Practice]=QString();
if (!m_profile->contains(STR_DI_Address)) (*m_profile)[STR_DI_Address]=QString();
if (!m_profile->contains(STR_DI_PatientID)) (*m_profile)[STR_DI_PatientID]=QString();
public:
DoctorInfo(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_DI_Name)) { (*m_profile)[STR_DI_Name] = QString(); }
if (!m_profile->contains(STR_DI_Phone)) { (*m_profile)[STR_DI_Phone] = QString(); }
if (!m_profile->contains(STR_DI_Email)) { (*m_profile)[STR_DI_Email] = QString(); }
if (!m_profile->contains(STR_DI_Practice)) { (*m_profile)[STR_DI_Practice] = QString(); }
if (!m_profile->contains(STR_DI_Address)) { (*m_profile)[STR_DI_Address] = QString(); }
if (!m_profile->contains(STR_DI_PatientID)) { (*m_profile)[STR_DI_PatientID] = QString(); }
}
~DoctorInfo() {}
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
const QString name() { return (*m_profile)[STR_DI_Name].toString(); }
const QString phone() { return (*m_profile)[STR_DI_Phone].toString(); }
@ -272,12 +285,12 @@ public:
const QString address() { return (*m_profile)[STR_DI_Address].toString(); }
const QString patientID() { return (*m_profile)[STR_DI_PatientID].toString(); }
void setName(QString name) { (*m_profile)[STR_DI_Name]=name; }
void setPhone(QString phone) { (*m_profile)[STR_DI_Phone]=phone; }
void setEmail(QString phone) { (*m_profile)[STR_DI_Email]=phone; }
void setPracticeName(QString practice) { (*m_profile)[STR_DI_Practice]=practice; }
void setAddress(QString address) { (*m_profile)[STR_DI_Address]=address; }
void setPatientID(QString pid) { (*m_profile)[STR_DI_PatientID]=pid; }
void setName(QString name) { (*m_profile)[STR_DI_Name] = name; }
void setPhone(QString phone) { (*m_profile)[STR_DI_Phone] = phone; }
void setEmail(QString phone) { (*m_profile)[STR_DI_Email] = phone; }
void setPracticeName(QString practice) { (*m_profile)[STR_DI_Practice] = practice; }
void setAddress(QString address) { (*m_profile)[STR_DI_Address] = address; }
void setPatientID(QString pid) { (*m_profile)[STR_DI_PatientID] = pid; }
Profile *m_profile;
};
@ -288,28 +301,39 @@ public:
*/
class UserInfo
{
public:
public:
//! \brief Create UserInfo object given Profile *p, and initialize the defaults
UserInfo(Profile *p) : m_profile(p)
{
if (!m_profile->contains(STR_UI_DOB)) (*m_profile)[STR_UI_DOB]=QDate(1970,1,1);
if (!m_profile->contains(STR_UI_FirstName)) (*m_profile)[STR_UI_FirstName]=QString();
if (!m_profile->contains(STR_UI_LastName)) (*m_profile)[STR_UI_LastName]=QString();
if (!m_profile->contains(STR_UI_UserName)) (*m_profile)[STR_UI_UserName]=QString();
if (!m_profile->contains(STR_UI_Password)) (*m_profile)[STR_UI_Password]=QString();
if (!m_profile->contains(STR_UI_Address)) (*m_profile)[STR_UI_Address]=QString();
if (!m_profile->contains(STR_UI_Phone)) (*m_profile)[STR_UI_Phone]=QString();
if (!m_profile->contains(STR_UI_EmailAddress)) (*m_profile)[STR_UI_EmailAddress]=QString();
if (!m_profile->contains(STR_UI_Country)) (*m_profile)[STR_UI_Country]=QString();
if (!m_profile->contains(STR_UI_Height)) (*m_profile)[STR_UI_Height]=0.0;
if (!m_profile->contains(STR_UI_Gender)) (*m_profile)[STR_UI_Gender]=(int)GenderNotSpecified;
if (!m_profile->contains(STR_UI_TimeZone)) (*m_profile)[STR_UI_TimeZone]=QString();
if (!m_profile->contains(STR_UI_DST)) (*m_profile)[STR_UI_DST]=false;
UserInfo(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_UI_DOB)) { (*m_profile)[STR_UI_DOB] = QDate(1970, 1, 1); }
if (!m_profile->contains(STR_UI_FirstName)) { (*m_profile)[STR_UI_FirstName] = QString(); }
if (!m_profile->contains(STR_UI_LastName)) { (*m_profile)[STR_UI_LastName] = QString(); }
if (!m_profile->contains(STR_UI_UserName)) { (*m_profile)[STR_UI_UserName] = QString(); }
if (!m_profile->contains(STR_UI_Password)) { (*m_profile)[STR_UI_Password] = QString(); }
if (!m_profile->contains(STR_UI_Address)) { (*m_profile)[STR_UI_Address] = QString(); }
if (!m_profile->contains(STR_UI_Phone)) { (*m_profile)[STR_UI_Phone] = QString(); }
if (!m_profile->contains(STR_UI_EmailAddress)) { (*m_profile)[STR_UI_EmailAddress] = QString(); }
if (!m_profile->contains(STR_UI_Country)) { (*m_profile)[STR_UI_Country] = QString(); }
if (!m_profile->contains(STR_UI_Height)) { (*m_profile)[STR_UI_Height] = 0.0; }
if (!m_profile->contains(STR_UI_Gender)) { (*m_profile)[STR_UI_Gender] = (int)GenderNotSpecified; }
if (!m_profile->contains(STR_UI_TimeZone)) { (*m_profile)[STR_UI_TimeZone] = QString(); }
if (!m_profile->contains(STR_UI_DST)) { (*m_profile)[STR_UI_DST] = false; }
}
~UserInfo() {}
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
QDate DOB() { return (*m_profile)[STR_UI_DOB].toDate(); }
const QString firstName() { return (*m_profile)[STR_UI_FirstName].toString(); }
@ -324,30 +348,32 @@ public:
const QString timeZone() { return (*m_profile)[STR_UI_TimeZone].toString(); }
bool daylightSaving() { return (*m_profile)[STR_UI_DST].toBool(); }
void setDOB(QDate date) { (*m_profile)[STR_UI_DOB]=date; }
void setFirstName(QString name) { (*m_profile)[STR_UI_FirstName]=name; }
void setLastName(QString name) { (*m_profile)[STR_UI_LastName]=name; }
void setUserName(QString username) { (*m_profile)[STR_UI_UserName]=username; }
void setAddress(QString address) { (*m_profile)[STR_UI_Address]=address; }
void setPhone(QString phone) { (*m_profile)[STR_UI_Phone]=phone; }
void setEmail(QString email) { (*m_profile)[STR_UI_EmailAddress]=email; }
void setHeight(double height) { (*m_profile)[STR_UI_Height]=height; }
void setCountry(QString country) { (*m_profile)[STR_UI_Country]=country; }
void setGender(Gender g) { (*m_profile)[STR_UI_Gender]=(int)g; }
void setTimeZone(QString tz) { (*m_profile)[STR_UI_TimeZone]=tz; }
void setDaylightSaving(bool ds) { (*m_profile)[STR_UI_DST]=ds; }
void setDOB(QDate date) { (*m_profile)[STR_UI_DOB] = date; }
void setFirstName(QString name) { (*m_profile)[STR_UI_FirstName] = name; }
void setLastName(QString name) { (*m_profile)[STR_UI_LastName] = name; }
void setUserName(QString username) { (*m_profile)[STR_UI_UserName] = username; }
void setAddress(QString address) { (*m_profile)[STR_UI_Address] = address; }
void setPhone(QString phone) { (*m_profile)[STR_UI_Phone] = phone; }
void setEmail(QString email) { (*m_profile)[STR_UI_EmailAddress] = email; }
void setHeight(double height) { (*m_profile)[STR_UI_Height] = height; }
void setCountry(QString country) { (*m_profile)[STR_UI_Country] = country; }
void setGender(Gender g) { (*m_profile)[STR_UI_Gender] = (int)g; }
void setTimeZone(QString tz) { (*m_profile)[STR_UI_TimeZone] = tz; }
void setDaylightSaving(bool ds) { (*m_profile)[STR_UI_DST] = ds; }
bool hasPassword() {
return !((*m_profile)[STR_UI_Password].toString().isEmpty());
}
bool checkPassword(QString password) {
QByteArray ba=password.toUtf8();
return ((*m_profile)[STR_UI_Password].toString()==QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex()));
QByteArray ba = password.toUtf8();
return ((*m_profile)[STR_UI_Password].toString() == QString(QCryptographicHash::hash(ba,
QCryptographicHash::Sha1).toHex()));
}
void setPassword(QString password) {
QByteArray ba=password.toUtf8();
QByteArray ba = password.toUtf8();
// Hash me.
(*m_profile)[STR_UI_Password]=QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex());
(*m_profile)[STR_UI_Password] = QString(QCryptographicHash::hash(ba,
QCryptographicHash::Sha1).toHex());
}
Profile *m_profile;
@ -359,22 +385,28 @@ public:
*/
class OxiSettings
{
public:
public:
//! \brief Create OxiSettings object given Profile *p, and initialize the defaults
OxiSettings(Profile *p) :m_profile(p)
{
if (!m_profile->contains(STR_OS_EnableOximetry)) (*m_profile)[STR_OS_EnableOximetry]=false;
if (!m_profile->contains(STR_OS_SyncOximetry)) (*m_profile)[STR_OS_SyncOximetry]=true;
if (!m_profile->contains(STR_OS_OximeterType)) (*m_profile)[STR_OS_OximeterType]="CMS50";
if (!m_profile->contains(STR_OS_OxiDiscardThreshold)) (*m_profile)[STR_OS_OxiDiscardThreshold]=0.0;
if (!m_profile->contains(STR_OS_SPO2DropDuration)) (*m_profile)[STR_OS_SPO2DropDuration]=8.0;
if (!m_profile->contains(STR_OS_SPO2DropPercentage)) (*m_profile)[STR_OS_SPO2DropPercentage]=3.0;
if (!m_profile->contains(STR_OS_PulseChangeDuration)) (*m_profile)[STR_OS_PulseChangeDuration]=8.0;
if (!m_profile->contains(STR_OS_PulseChangeBPM)) (*m_profile)[STR_OS_PulseChangeBPM]=5.0;
OxiSettings(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_OS_EnableOximetry)) { (*m_profile)[STR_OS_EnableOximetry] = false; }
if (!m_profile->contains(STR_OS_SyncOximetry)) { (*m_profile)[STR_OS_SyncOximetry] = true; }
if (!m_profile->contains(STR_OS_OximeterType)) { (*m_profile)[STR_OS_OximeterType] = "CMS50"; }
if (!m_profile->contains(STR_OS_OxiDiscardThreshold)) { (*m_profile)[STR_OS_OxiDiscardThreshold] = 0.0; }
if (!m_profile->contains(STR_OS_SPO2DropDuration)) { (*m_profile)[STR_OS_SPO2DropDuration] = 8.0; }
if (!m_profile->contains(STR_OS_SPO2DropPercentage)) { (*m_profile)[STR_OS_SPO2DropPercentage] = 3.0; }
if (!m_profile->contains(STR_OS_PulseChangeDuration)) { (*m_profile)[STR_OS_PulseChangeDuration] = 8.0; }
if (!m_profile->contains(STR_OS_PulseChangeBPM)) { (*m_profile)[STR_OS_PulseChangeBPM] = 5.0; }
}
~OxiSettings() {}
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
bool oximetryEnabled() { return (*m_profile)[STR_OS_EnableOximetry].toBool(); }
bool syncOximetry() { return (*m_profile)[STR_OS_SyncOximetry].toBool(); }
@ -385,14 +417,14 @@ public:
double pulseChangeDuration() { return (*m_profile)[STR_OS_PulseChangeDuration].toDouble(); }
double pulseChangeBPM() { return (*m_profile)[STR_OS_PulseChangeBPM].toDouble(); }
void setOximetryEnabled(bool enabled) { (*m_profile)[STR_OS_EnableOximetry]=enabled; }
void setSyncOximetry(bool synced) { (*m_profile)[STR_OS_SyncOximetry]=synced; }
void setOximeterType(QString oxitype) { (*m_profile)[STR_OS_OximeterType]=oxitype; }
void setOxiDiscardThreshold(double thresh) { (*m_profile)[STR_OS_OxiDiscardThreshold]=thresh; }
void setSpO2DropDuration(double duration) { (*m_profile)[STR_OS_SPO2DropDuration]=duration; }
void setSpO2DropPercentage(double percentage) { (*m_profile)[STR_OS_SPO2DropPercentage]=percentage; }
void setPulseChangeDuration(double duration) { (*m_profile)[STR_OS_PulseChangeDuration]=duration; }
void setPulseChangeBPM(double bpm) { (*m_profile)[STR_OS_PulseChangeBPM]=bpm; }
void setOximetryEnabled(bool enabled) { (*m_profile)[STR_OS_EnableOximetry] = enabled; }
void setSyncOximetry(bool synced) { (*m_profile)[STR_OS_SyncOximetry] = synced; }
void setOximeterType(QString oxitype) { (*m_profile)[STR_OS_OximeterType] = oxitype; }
void setOxiDiscardThreshold(double thresh) { (*m_profile)[STR_OS_OxiDiscardThreshold] = thresh; }
void setSpO2DropDuration(double duration) { (*m_profile)[STR_OS_SPO2DropDuration] = duration; }
void setSpO2DropPercentage(double percentage) { (*m_profile)[STR_OS_SPO2DropPercentage] = percentage; }
void setPulseChangeDuration(double duration) { (*m_profile)[STR_OS_PulseChangeDuration] = duration; }
void setPulseChangeBPM(double bpm) { (*m_profile)[STR_OS_PulseChangeBPM] = bpm; }
Profile *m_profile;
};
@ -402,36 +434,53 @@ public:
*/
class CPAPSettings
{
public:
public:
//! \brief Create CPAPSettings object given Profile *p, and initialize the defaults
CPAPSettings(Profile *p) :m_profile(p)
{
if (!m_profile->contains(STR_CS_ComplianceHours)) (*m_profile)[STR_CS_ComplianceHours]=4;
if (!m_profile->contains(STR_CS_ShowCompliance)) (*m_profile)[STR_CS_ShowCompliance]=true;
if (!m_profile->contains(STR_CS_ShowLeaksMode)) (*m_profile)[STR_CS_ShowLeaksMode]=0;
CPAPSettings(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_CS_ComplianceHours)) { (*m_profile)[STR_CS_ComplianceHours] = 4; }
if (!m_profile->contains(STR_CS_ShowCompliance)) { (*m_profile)[STR_CS_ShowCompliance] = true; }
if (!m_profile->contains(STR_CS_ShowLeaksMode)) { (*m_profile)[STR_CS_ShowLeaksMode] = 0; }
// TODO: Check if this date is initiliazed yet
if (!m_profile->contains(STR_CS_MaskStartDate)) (*m_profile)[STR_CS_MaskStartDate]=QDate();
if (!m_profile->contains(STR_CS_MaskDescription)) (*m_profile)[STR_CS_MaskDescription]=QString();
if (!m_profile->contains(STR_CS_MaskType)) (*m_profile)[STR_CS_MaskType]=Mask_Unknown;
if (!m_profile->contains(STR_CS_PrescribedMode)) (*m_profile)[STR_CS_PrescribedMode]=MODE_UNKNOWN;
if (!m_profile->contains(STR_CS_PrescribedMinPressure)) (*m_profile)[STR_CS_PrescribedMinPressure]=0.0;
if (!m_profile->contains(STR_CS_PrescribedMaxPressure)) (*m_profile)[STR_CS_PrescribedMaxPressure]=0.0;
if (!m_profile->contains(STR_CS_UntreatedAHI)) (*m_profile)[STR_CS_UntreatedAHI]=0.0;
if (!m_profile->contains(STR_CS_Notes)) (*m_profile)[STR_CS_Notes]=QString();
if (!m_profile->contains(STR_CS_DateDiagnosed)) (*m_profile)[STR_CS_DateDiagnosed]=QDate();
if (!m_profile->contains(STR_CS_UserFlowRestriction)) (*m_profile)[STR_CS_UserFlowRestriction]=20.0;
if (!m_profile->contains(STR_CS_UserEventDuration)) (*m_profile)[STR_CS_UserEventDuration]=10.0;
if (!m_profile->contains(STR_CS_UserEventDuplicates)) (*m_profile)[STR_CS_UserEventDuplicates]=false;
if (!m_profile->contains(STR_CS_UserEventFlagging)) (*m_profile)[STR_CS_UserEventFlagging]=false;
if (!m_profile->contains(STR_CS_AHIWindow)) (*m_profile)[STR_CS_AHIWindow]=60.0;
if (!m_profile->contains(STR_CS_AHIReset)) (*m_profile)[STR_CS_AHIReset]=false;
if (!m_profile->contains(STR_CS_ClockDrift)) (*m_profile)[STR_CS_ClockDrift]=m_clock_drift=(int)0;
else m_clock_drift=(*m_profile)[STR_CS_ClockDrift].toInt();
if (!m_profile->contains(STR_CS_MaskStartDate)) { (*m_profile)[STR_CS_MaskStartDate] = QDate(); }
if (!m_profile->contains(STR_CS_MaskDescription)) { (*m_profile)[STR_CS_MaskDescription] = QString(); }
if (!m_profile->contains(STR_CS_MaskType)) { (*m_profile)[STR_CS_MaskType] = Mask_Unknown; }
if (!m_profile->contains(STR_CS_PrescribedMode)) { (*m_profile)[STR_CS_PrescribedMode] = MODE_UNKNOWN; }
if (!m_profile->contains(STR_CS_PrescribedMinPressure)) { (*m_profile)[STR_CS_PrescribedMinPressure] = 0.0; }
if (!m_profile->contains(STR_CS_PrescribedMaxPressure)) { (*m_profile)[STR_CS_PrescribedMaxPressure] = 0.0; }
if (!m_profile->contains(STR_CS_UntreatedAHI)) { (*m_profile)[STR_CS_UntreatedAHI] = 0.0; }
if (!m_profile->contains(STR_CS_Notes)) { (*m_profile)[STR_CS_Notes] = QString(); }
if (!m_profile->contains(STR_CS_DateDiagnosed)) { (*m_profile)[STR_CS_DateDiagnosed] = QDate(); }
if (!m_profile->contains(STR_CS_UserFlowRestriction)) { (*m_profile)[STR_CS_UserFlowRestriction] = 20.0; }
if (!m_profile->contains(STR_CS_UserEventDuration)) { (*m_profile)[STR_CS_UserEventDuration] = 10.0; }
if (!m_profile->contains(STR_CS_UserEventDuplicates)) { (*m_profile)[STR_CS_UserEventDuplicates] = false; }
if (!m_profile->contains(STR_CS_UserEventFlagging)) { (*m_profile)[STR_CS_UserEventFlagging] = false; }
if (!m_profile->contains(STR_CS_AHIWindow)) { (*m_profile)[STR_CS_AHIWindow] = 60.0; }
if (!m_profile->contains(STR_CS_AHIReset)) { (*m_profile)[STR_CS_AHIReset] = false; }
if (!m_profile->contains(STR_CS_ClockDrift)) { (*m_profile)[STR_CS_ClockDrift] = m_clock_drift = (int)0; }
else { m_clock_drift = (*m_profile)[STR_CS_ClockDrift].toInt(); }
}
~CPAPSettings() { }
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
//Getters
double complianceHours() { return (*m_profile)[STR_CS_ComplianceHours].toDouble(); }
@ -455,25 +504,25 @@ public:
int clockDrift() { return m_clock_drift; }
//Setters
void setMode(CPAPMode mode) { (*m_profile)[STR_CS_PrescribedMode]=(int)mode; }
void setMinPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMinPressure]=pressure; }
void setMaxPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMaxPressure]=pressure; }
void setUntreatedAHI(double ahi) { (*m_profile)[STR_CS_UntreatedAHI]=ahi; }
void setNotes(QString notes) { (*m_profile)[STR_CS_Notes]=notes; }
void setDateDiagnosed(QDate date) { (*m_profile)[STR_CS_DateDiagnosed]=date; }
void setComplianceHours(double hours) { (*m_profile)[STR_CS_ComplianceHours]=hours; }
void setShowComplianceInfo(bool b) { (*m_profile)[STR_CS_ShowCompliance]=b; }
void setLeakMode(int leakmode) { (*m_profile)[STR_CS_ShowLeaksMode]=(int)leakmode; }
void setMaskStartDate(QDate date) { (*m_profile)[STR_CS_MaskStartDate]=date; }
void setMaskDescription(QString description) { (*m_profile)[STR_CS_MaskDescription]=description; }
void setMaskType(MaskType masktype) { (*m_profile)[STR_CS_MaskType]=(int)masktype; }
void setUserFlowRestriction(double flow) { (*m_profile)[STR_CS_UserFlowRestriction]=flow; }
void setUserEventDuration(double duration) { (*m_profile)[STR_CS_UserEventDuration]=duration; }
void setAHIWindow(double window) { (*m_profile)[STR_CS_AHIWindow]=window; }
void setAHIReset(bool reset) { (*m_profile)[STR_CS_AHIReset]=reset; }
void setUserEventFlagging(bool flagging) { (*m_profile)[STR_CS_UserEventFlagging]=flagging; }
void setUserEventDuplicates(bool dup) { (*m_profile)[STR_CS_UserEventDuplicates]=dup; }
void setClockDrift(int seconds) { (*m_profile)[STR_CS_ClockDrift]=m_clock_drift=(int)seconds; }
void setMode(CPAPMode mode) { (*m_profile)[STR_CS_PrescribedMode] = (int)mode; }
void setMinPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMinPressure] = pressure; }
void setMaxPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMaxPressure] = pressure; }
void setUntreatedAHI(double ahi) { (*m_profile)[STR_CS_UntreatedAHI] = ahi; }
void setNotes(QString notes) { (*m_profile)[STR_CS_Notes] = notes; }
void setDateDiagnosed(QDate date) { (*m_profile)[STR_CS_DateDiagnosed] = date; }
void setComplianceHours(double hours) { (*m_profile)[STR_CS_ComplianceHours] = hours; }
void setShowComplianceInfo(bool b) { (*m_profile)[STR_CS_ShowCompliance] = b; }
void setLeakMode(int leakmode) { (*m_profile)[STR_CS_ShowLeaksMode] = (int)leakmode; }
void setMaskStartDate(QDate date) { (*m_profile)[STR_CS_MaskStartDate] = date; }
void setMaskDescription(QString description) { (*m_profile)[STR_CS_MaskDescription] = description; }
void setMaskType(MaskType masktype) { (*m_profile)[STR_CS_MaskType] = (int)masktype; }
void setUserFlowRestriction(double flow) { (*m_profile)[STR_CS_UserFlowRestriction] = flow; }
void setUserEventDuration(double duration) { (*m_profile)[STR_CS_UserEventDuration] = duration; }
void setAHIWindow(double window) { (*m_profile)[STR_CS_AHIWindow] = window; }
void setAHIReset(bool reset) { (*m_profile)[STR_CS_AHIReset] = reset; }
void setUserEventFlagging(bool flagging) { (*m_profile)[STR_CS_UserEventFlagging] = flagging; }
void setUserEventDuplicates(bool dup) { (*m_profile)[STR_CS_UserEventDuplicates] = dup; }
void setClockDrift(int seconds) { (*m_profile)[STR_CS_ClockDrift] = m_clock_drift = (int)seconds; }
Profile *m_profile;
@ -485,22 +534,28 @@ public:
*/
class SessionSettings
{
public:
public:
//! \brief Create ImportSettings object given Profile *p, and initialize the defaults
SessionSettings(Profile *p) :m_profile(p)
{
if (!m_profile->contains(STR_IS_DaySplitTime)) (*m_profile)[STR_IS_DaySplitTime]=QTime(12,0,0);
if (!m_profile->contains(STR_IS_CacheSessions)) (*m_profile)[STR_IS_CacheSessions]=false;
if (!m_profile->contains(STR_IS_CombineCloseSessions)) (*m_profile)[STR_IS_CombineCloseSessions]=240;
if (!m_profile->contains(STR_IS_IgnoreShorterSessions)) (*m_profile)[STR_IS_IgnoreShorterSessions]=5;
if (!m_profile->contains(STR_IS_Multithreading)) (*m_profile)[STR_IS_Multithreading]=QThread::idealThreadCount() > 1;
if (!m_profile->contains(STR_IS_BackupCardData)) (*m_profile)[STR_IS_BackupCardData]=true;
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(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_IS_DaySplitTime)) { (*m_profile)[STR_IS_DaySplitTime] = QTime(12, 0, 0); }
if (!m_profile->contains(STR_IS_CacheSessions)) { (*m_profile)[STR_IS_CacheSessions] = false; }
if (!m_profile->contains(STR_IS_CombineCloseSessions)) { (*m_profile)[STR_IS_CombineCloseSessions] = 240; }
if (!m_profile->contains(STR_IS_IgnoreShorterSessions)) { (*m_profile)[STR_IS_IgnoreShorterSessions] = 5; }
if (!m_profile->contains(STR_IS_Multithreading)) { (*m_profile)[STR_IS_Multithreading] = QThread::idealThreadCount() > 1; }
if (!m_profile->contains(STR_IS_BackupCardData)) { (*m_profile)[STR_IS_BackupCardData] = true; }
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() {}
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
QTime daySplitTime() { return (*m_profile)[STR_IS_DaySplitTime].toTime(); }
bool cacheSessions() { return (*m_profile)[STR_IS_CacheSessions].toBool(); }
@ -511,14 +566,14 @@ public:
bool compressBackupData() { return (*m_profile)[STR_IS_CompressBackupData].toBool(); }
bool backupCardData() { return (*m_profile)[STR_IS_BackupCardData].toBool(); }
void setDaySplitTime(QTime time) { (*m_profile)[STR_IS_DaySplitTime]=time; }
void setCacheSessions(bool c) { (*m_profile)[STR_IS_CacheSessions]=c; }
void setCombineCloseSessions(double val) { (*m_profile)[STR_IS_CombineCloseSessions]=val; }
void setIgnoreShortSessions(double val) { (*m_profile)[STR_IS_IgnoreShorterSessions]=val; }
void setMultithreading(bool enabled) { (*m_profile)[STR_IS_Multithreading]=enabled; }
void setBackupCardData(bool enabled) { (*m_profile)[STR_IS_BackupCardData]=enabled; }
void setCompressBackupData(bool enabled) { (*m_profile)[STR_IS_CompressBackupData]=enabled; }
void setCompressSessionData(bool enabled) { (*m_profile)[STR_IS_CompressSessionData]=enabled; }
void setDaySplitTime(QTime time) { (*m_profile)[STR_IS_DaySplitTime] = time; }
void setCacheSessions(bool c) { (*m_profile)[STR_IS_CacheSessions] = c; }
void setCombineCloseSessions(double val) { (*m_profile)[STR_IS_CombineCloseSessions] = val; }
void setIgnoreShortSessions(double val) { (*m_profile)[STR_IS_IgnoreShorterSessions] = val; }
void setMultithreading(bool enabled) { (*m_profile)[STR_IS_Multithreading] = enabled; }
void setBackupCardData(bool enabled) { (*m_profile)[STR_IS_BackupCardData] = enabled; }
void setCompressBackupData(bool enabled) { (*m_profile)[STR_IS_CompressBackupData] = enabled; }
void setCompressSessionData(bool enabled) { (*m_profile)[STR_IS_CompressSessionData] = enabled; }
Profile *m_profile;
};
@ -528,24 +583,32 @@ public:
*/
class AppearanceSettings
{
public:
public:
//! \brief Create AppearanceSettings object given Profile *p, and initialize the defaults
AppearanceSettings(Profile *p) :m_profile(p)
{
if (!m_profile->contains(STR_AS_GraphHeight)) (*m_profile)[STR_AS_GraphHeight]=180.0;
if (!m_profile->contains(STR_AS_AntiAliasing)) (*m_profile)[STR_AS_AntiAliasing]=false; // i think it's ugly
if (!m_profile->contains(STR_AS_GraphSnapshots)) (*m_profile)[STR_AS_GraphSnapshots]=true;
if (!m_profile->contains(STR_AS_Animations)) (*m_profile)[STR_AS_Animations]=true;
if (!m_profile->contains(STR_AS_SquareWave)) (*m_profile)[STR_AS_SquareWave]=false;
if (!m_profile->contains(STR_AS_AllowYAxisScaling)) (*m_profile)[STR_AS_AllowYAxisScaling]=true;
if (!m_profile->contains(STR_AS_GraphTooltips)) (*m_profile)[STR_AS_GraphTooltips]=true;
if (!m_profile->contains(STR_AS_UsePixmapCaching)) (*m_profile)[STR_AS_UsePixmapCaching]=true;
if (!m_profile->contains(STR_AS_OverlayType)) (*m_profile)[STR_AS_OverlayType]=ODT_Bars;
if (!m_profile->contains(STR_AS_OverviewLinechartMode)) (*m_profile)[STR_AS_OverviewLinechartMode]=OLC_Bartop;
AppearanceSettings(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_AS_GraphHeight)) { (*m_profile)[STR_AS_GraphHeight] = 180.0; }
if (!m_profile->contains(STR_AS_AntiAliasing)) { (*m_profile)[STR_AS_AntiAliasing] = false; } // i think it's ugly
if (!m_profile->contains(STR_AS_GraphSnapshots)) { (*m_profile)[STR_AS_GraphSnapshots] = true; }
if (!m_profile->contains(STR_AS_Animations)) { (*m_profile)[STR_AS_Animations] = true; }
if (!m_profile->contains(STR_AS_SquareWave)) { (*m_profile)[STR_AS_SquareWave] = false; }
if (!m_profile->contains(STR_AS_AllowYAxisScaling)) { (*m_profile)[STR_AS_AllowYAxisScaling] = true; }
if (!m_profile->contains(STR_AS_GraphTooltips)) { (*m_profile)[STR_AS_GraphTooltips] = true; }
if (!m_profile->contains(STR_AS_UsePixmapCaching)) { (*m_profile)[STR_AS_UsePixmapCaching] = true; }
if (!m_profile->contains(STR_AS_OverlayType)) { (*m_profile)[STR_AS_OverlayType] = ODT_Bars; }
if (!m_profile->contains(STR_AS_OverviewLinechartMode)) { (*m_profile)[STR_AS_OverviewLinechartMode] = OLC_Bartop; }
}
~AppearanceSettings() {}
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
//! \brief Returns the normal (unscaled) height of a graph
int graphHeight() { return (*m_profile)[STR_AS_GraphHeight].toInt(); }
@ -564,31 +627,31 @@ public:
//! \brief Whether to show graph tooltips
bool graphTooltips() { return (*m_profile)[STR_AS_GraphTooltips].toBool(); }
//! \brief Returns the type of overlay flags (which are displayed over the Flow Waveform)
OverlayDisplayType overlayType() { return (OverlayDisplayType )(*m_profile)[STR_AS_OverlayType].toInt(); }
OverlayDisplayType overlayType() { return (OverlayDisplayType)(*m_profile)[STR_AS_OverlayType].toInt(); }
//! \brief Returns the display type of Overview pages linechart
OverviewLinechartModes overviewLinechartMode() { return (OverviewLinechartModes )(*m_profile)[STR_AS_OverviewLinechartMode].toInt(); }
OverviewLinechartModes overviewLinechartMode() { return (OverviewLinechartModes)(*m_profile)[STR_AS_OverviewLinechartMode].toInt(); }
//! \brief Set the normal (unscaled) height of a graph.
void setGraphHeight(int height) { (*m_profile)[STR_AS_GraphHeight]=height; }
void setGraphHeight(int height) { (*m_profile)[STR_AS_GraphHeight] = height; }
//! \brief Set to true to turn on AntiAliasing (the graphical smoothing method)
void setAntiAliasing(bool aa) { (*m_profile)[STR_AS_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.
void setGraphSnapshots(bool gs) { (*m_profile)[STR_AS_GraphSnapshots]=gs; }
void setGraphSnapshots(bool gs) { (*m_profile)[STR_AS_GraphSnapshots] = gs; }
//! \brief Set to true if Graphical animations & Transitions will be drawn
void setAnimations(bool anim) { (*m_profile)[STR_AS_Animations]=anim; }
void setAnimations(bool anim) { (*m_profile)[STR_AS_Animations] = anim; }
//! \brief Set to true to use Pixmap Caching of Text and other graphics caching speedup techniques
void setUsePixmapCaching(bool b) { (*m_profile)[STR_AS_UsePixmapCaching]=b; }
void setUsePixmapCaching(bool b) { (*m_profile)[STR_AS_UsePixmapCaching] = b; }
//! \brief Set whether or not to useSquare Wave plots (where possible)
void setSquareWavePlots(bool sw) { (*m_profile)[STR_AS_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)
void setOverlayType(OverlayDisplayType od) { (*m_profile)[STR_AS_OverlayType]=(int)od; }
void setOverlayType(OverlayDisplayType od) { (*m_profile)[STR_AS_OverlayType] = (int)od; }
//! \brief Sets the type of overlay flags (which are displayed over the Flow Waveform)
void setOverviewLinechartMode(OverviewLinechartModes od) { (*m_profile)[STR_AS_OverviewLinechartMode]=(int)od; }
void setOverviewLinechartMode(OverviewLinechartModes od) { (*m_profile)[STR_AS_OverviewLinechartMode] = (int)od; }
//! \brief Sets whether to allow double clicking on Y-Axis labels to change vertical scaling mode
void setAllowYAxisScaling(bool b) { (*m_profile)[STR_AS_AllowYAxisScaling]=b; }
void setAllowYAxisScaling(bool b) { (*m_profile)[STR_AS_AllowYAxisScaling] = b; }
//! \brief Sets whether to allow double clicking on Y-Axis labels to change vertical scaling mode
void setGraphTooltips(bool b) { (*m_profile)[STR_AS_GraphTooltips]=b; }
void setGraphTooltips(bool b) { (*m_profile)[STR_AS_GraphTooltips] = b; }
Profile *m_profile;
};
@ -598,27 +661,38 @@ public:
*/
class UserSettings
{
public:
public:
//! \brief Create UserSettings object given Profile *p, and initialize the defaults
UserSettings(Profile *p) :m_profile(p)
{
if (!m_profile->contains(STR_US_UnitSystem)) (*m_profile)[STR_US_UnitSystem]=US_Metric;
if (!m_profile->contains(STR_US_EventWindowSize)) (*m_profile)[STR_US_EventWindowSize]=4.0;
if (!m_profile->contains(STR_US_SkipEmptyDays)) (*m_profile)[STR_US_SkipEmptyDays]=true;
if (!m_profile->contains(STR_US_RebuildCache)) (*m_profile)[STR_US_RebuildCache]=false; // can't remember..
if (!m_profile->contains(STR_US_ShowDebug)) (*m_profile)[STR_US_ShowDebug]=false;
if (!m_profile->contains(STR_US_LinkGroups)) (*m_profile)[STR_US_LinkGroups]=true; // can't remember..
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;
if (!m_profile->contains(STR_US_PrefCalcMiddle)) (*m_profile)[STR_US_PrefCalcMiddle]=(int)0;
if (!m_profile->contains(STR_US_PrefCalcPercentile)) (*m_profile)[STR_US_PrefCalcPercentile]=(double)95.0;
if (!m_profile->contains(STR_US_PrefCalcMax)) (*m_profile)[STR_US_PrefCalcMax]=(int)0;
if (!m_profile->contains(STR_US_TooltipTimeout)) (*m_profile)[STR_US_TooltipTimeout]=(int)2500;
if (!m_profile->contains(STR_US_ScrollDampening)) (*m_profile)[STR_US_ScrollDampening]=(int)50;
UserSettings(Profile *p) : m_profile(p) {
if (!m_profile->contains(STR_US_UnitSystem)) { (*m_profile)[STR_US_UnitSystem] = US_Metric; }
if (!m_profile->contains(STR_US_EventWindowSize)) { (*m_profile)[STR_US_EventWindowSize] = 4.0; }
if (!m_profile->contains(STR_US_SkipEmptyDays)) { (*m_profile)[STR_US_SkipEmptyDays] = true; }
if (!m_profile->contains(STR_US_RebuildCache)) { (*m_profile)[STR_US_RebuildCache] = false; } // can't remember..
if (!m_profile->contains(STR_US_ShowDebug)) { (*m_profile)[STR_US_ShowDebug] = false; }
if (!m_profile->contains(STR_US_LinkGroups)) { (*m_profile)[STR_US_LinkGroups] = true; } // can't remember..
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; }
if (!m_profile->contains(STR_US_PrefCalcMiddle)) { (*m_profile)[STR_US_PrefCalcMiddle] = (int)0; }
if (!m_profile->contains(STR_US_PrefCalcPercentile)) { (*m_profile)[STR_US_PrefCalcPercentile] = (double)95.0; }
if (!m_profile->contains(STR_US_PrefCalcMax)) { (*m_profile)[STR_US_PrefCalcMax] = (int)0; }
if (!m_profile->contains(STR_US_TooltipTimeout)) { (*m_profile)[STR_US_TooltipTimeout] = (int)2500; }
if (!m_profile->contains(STR_US_ScrollDampening)) { (*m_profile)[STR_US_ScrollDampening] = (int)50; }
}
~UserSettings() {}
void setProfile(Profile *p) { m_profile=p; }
void setProfile(Profile *p) { m_profile = p; }
UnitSystem unitSystem() { return (UnitSystem)(*m_profile)[STR_US_UnitSystem].toInt(); }
double eventWindowSize() { return (*m_profile)[STR_US_EventWindowSize].toDouble(); }
@ -635,28 +709,27 @@ public:
int scrollDampening() { return (*m_profile)[STR_US_ScrollDampening].toInt(); }
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; }
void setPrefCalcMiddle(int i) { (*m_profile)[STR_US_PrefCalcMiddle]=i; }
void setPrefCalcPercentile(double p) { (*m_profile)[STR_US_PrefCalcPercentile]=p; }
void setPrefCalcMax(int i) { (*m_profile)[STR_US_PrefCalcMax]=i; }
void setTooltipTimeout(int i) { (*m_profile)[STR_US_TooltipTimeout]=i; }
void setScrollDampening(int i) { (*m_profile)[STR_US_ScrollDampening]=i; }
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; }
void setPrefCalcMiddle(int i) { (*m_profile)[STR_US_PrefCalcMiddle] = i; }
void setPrefCalcPercentile(double p) { (*m_profile)[STR_US_PrefCalcPercentile] = p; }
void setPrefCalcMax(int i) { (*m_profile)[STR_US_PrefCalcMax] = i; }
void setTooltipTimeout(int i) { (*m_profile)[STR_US_TooltipTimeout] = i; }
void setScrollDampening(int i) { (*m_profile)[STR_US_ScrollDampening] = i; }
Profile *m_profile;
};
namespace Profiles
{
namespace Profiles {
extern QMap<QString,Profile *> profiles;
extern QMap<QString, Profile *> profiles;
void Scan(); // Initialize and load Profile
void Done(); // Save all Profile objects and clear list

830
sleepyhead/SleepLib/schema.cpp
View File

@ -29,288 +29,444 @@ ChannelList channel;
Channel EmptyChannel;
Channel *SessionEnabledChannel;
QHash<QString,ChanType> ChanTypes;
QHash<QString,DataType> DataTypes;
QHash<QString,ScopeType> Scopes;
QHash<QString, ChanType> ChanTypes;
QHash<QString, DataType> DataTypes;
QHash<QString, ScopeType> Scopes;
bool schema_initialized=false;
bool schema_initialized = false;
void init()
{
if (schema_initialized) return;
schema_initialized=true;
if (schema_initialized) { return; }
EmptyChannel=Channel(0,DATA,DAY,"Empty","Empty", "Empty Channel","","");
SessionEnabledChannel=new Channel(1,DATA,DAY,"Enabled","Enabled","Session Enabled","","");
schema_initialized = true;
channel.channels[1]=SessionEnabledChannel;
channel.names["Enabled"]=SessionEnabledChannel;
SESSION_ENABLED=1;
ChanTypes["data"]=DATA;
EmptyChannel = Channel(0, DATA, DAY, "Empty", "Empty", "Empty Channel", "", "");
SessionEnabledChannel = new Channel(1, DATA, DAY, "Enabled", "Enabled", "Session Enabled", "", "");
channel.channels[1] = SessionEnabledChannel;
channel.names["Enabled"] = SessionEnabledChannel;
SESSION_ENABLED = 1;
ChanTypes["data"] = DATA;
//Types["waveform"]=WAVEFORM;
ChanTypes["setting"]=SETTING;
ChanTypes["setting"] = SETTING;
Scopes["session"]=SESSION;
Scopes["day"]=DAY;
Scopes["machine"]=MACHINE;
Scopes["global"]=GLOBAL;
Scopes["session"] = SESSION;
Scopes["day"] = DAY;
Scopes["machine"] = MACHINE;
Scopes["global"] = GLOBAL;
DataTypes[""]=DEFAULT;
DataTypes["bool"]=BOOL;
DataTypes["double"]=DOUBLE;
DataTypes["integer"]=INTEGER;
DataTypes["string"]=STRING;
DataTypes["richtext"]=RICHTEXT;
DataTypes["date"]=DATE;
DataTypes["datetime"]=DATETIME;
DataTypes["time"]=TIME;
DataTypes[""] = DEFAULT;
DataTypes["bool"] = BOOL;
DataTypes["double"] = DOUBLE;
DataTypes["integer"] = INTEGER;
DataTypes["string"] = STRING;
DataTypes["richtext"] = RICHTEXT;
DataTypes["date"] = DATE;
DataTypes["datetime"] = DATETIME;
DataTypes["time"] = TIME;
if (!schema::channel.Load(":/docs/channels.xml")) {
QMessageBox::critical(0,QObject::tr("Error"),QObject::tr("Couldn't parse Channels.xml, this build is seriously borked, no choice but to abort!!"),QMessageBox::Ok);
QMessageBox::critical(0, QObject::tr("Error"),
QObject::tr("Couldn't parse Channels.xml, this build is seriously borked, no choice but to abort!!"),
QMessageBox::Ok);
QApplication::exit(-1);
}
// <channel id="0x110c" class="data" name="Pressure" details="Pressure" label="Pressure" unit="cmH20" color="dark green"/>
// <channel id="0x110d" class="data" name="IPAP" details="Inspiratory Pressure" label="IPAP" unit="cmH20" color="orange"/>
// <channel id="0x110e" class="data" name="EPAP" details="Expiratory Pressure" label="EPAP" unit="cmH20" color="light blue"/>
// <channel id="0x110f" class="data" name="PS" details="Pressure Support" label="PS" unit="cmH20" color="dark blue"/>
// <channel id="0x1110" class="data" name="IPAPLo" details="Inspiratory Pressure Lo" label="IPAP Lo" unit="cmH20" color="grey"/>
// <channel id="0x1111" class="data" name="IPAPHi" details="Inspiratory Pressure Hi" label="IPAP Hi" unit="cmH20" color="grey"/>
// <channel id="0x111a" class="setting" name="PSMin" details="Pressure Support Min" label="PS Min" unit="cmH20" color="dark cyan"/>
// <channel id="0x111b" class="setting" name="PSMax" details="Pressure Support Max" label="PS Max" unit="cmH20" color="dark magenta"/>
// <channel id="0x1020" class="data" name="PressureMin" details="Min Therapy Pressure" label="Pressure" color="black"/>
// <channel id="0x1021" class="data" name="PressureMax" details="Max Therapy Pressure" label="Pressure" color="black"/>
// <channel id="0x1022" class="data" name="RampTime" details="Ramp Time" label="Ramp Time" color="black"/>
// <channel id="0x1023" class="data" name="RampPressure" details="Ramp Starting Pressure" label="Ramp Pr." color="black"/>
// <channel id="0x110c" class="data" name="Pressure" details="Pressure" label="Pressure" unit="cmH20" color="dark green"/>
// <channel id="0x110d" class="data" name="IPAP" details="Inspiratory Pressure" label="IPAP" unit="cmH20" color="orange"/>
// <channel id="0x110e" class="data" name="EPAP" details="Expiratory Pressure" label="EPAP" unit="cmH20" color="light blue"/>
// <channel id="0x110f" class="data" name="PS" details="Pressure Support" label="PS" unit="cmH20" color="dark blue"/>
// <channel id="0x1110" class="data" name="IPAPLo" details="Inspiratory Pressure Lo" label="IPAP Lo" unit="cmH20" color="grey"/>
// <channel id="0x1111" class="data" name="IPAPHi" details="Inspiratory Pressure Hi" label="IPAP Hi" unit="cmH20" color="grey"/>
// <channel id="0x111a" class="setting" name="PSMin" details="Pressure Support Min" label="PS Min" unit="cmH20" color="dark cyan"/>
// <channel id="0x111b" class="setting" name="PSMax" details="Pressure Support Max" label="PS Max" unit="cmH20" color="dark magenta"/>
// <channel id="0x1020" class="data" name="PressureMin" details="Min Therapy Pressure" label="Pressure" color="black"/>
// <channel id="0x1021" class="data" name="PressureMax" details="Max Therapy Pressure" label="Pressure" color="black"/>
// <channel id="0x1022" class="data" name="RampTime" details="Ramp Time" label="Ramp Time" color="black"/>
// <channel id="0x1023" class="data" name="RampPressure" details="Ramp Starting Pressure" label="Ramp Pr." color="black"/>
QString GRP_CPAP="CPAP";
QString GRP_POS="POS";
QString GRP_OXI="OXI";
QString GRP_CPAP = "CPAP";
QString GRP_POS = "POS";
QString GRP_OXI = "OXI";
// Pressure Related Settings
// Lookup Code strings are used internally and not meant to be tranlsated
// Group ChannelID Code Type Scope Lookup Code Translable Name Description Shortened Name Units String FieldType Default Color
schema::channel.add(GRP_CPAP,new Channel(CPAP_Pressure = 0x110C, DATA, SESSION, "Pressure", STR_TR_Pressure, QObject::tr("Therapy Pressure"), STR_TR_Pressure, STR_UNIT_CMH2O, DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_IPAP = 0x110D, DATA, SESSION, "IPAP", STR_TR_IPAP, QObject::tr("Inspiratory Pressure"), STR_TR_IPAP, STR_UNIT_CMH2O, DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_IPAPLo = 0x1110, DATA, SESSION, "IPAPLo", STR_TR_IPAPLo, QObject::tr("Lower Inspiratory Pressure"), STR_TR_IPAPLo, STR_UNIT_CMH2O, DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_IPAPHi = 0x1111, DATA, SESSION, "IPAPHi", STR_TR_IPAPHi, QObject::tr("Higher Inspiratory Pressure"), STR_TR_IPAPHi, STR_UNIT_CMH2O, DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_EPAP = 0x110E, DATA, SESSION, "EPAP", STR_TR_EPAP, QObject::tr("Expiratory Pressure"), STR_TR_EPAP, STR_UNIT_CMH2O, DEFAULT, QColor("light blue")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_EPAPLo = 0x111C, DATA, SESSION, "EPAPLo", STR_TR_EPAPLo, QObject::tr("Lower Expiratory Pressure"), STR_TR_EPAPLo, STR_UNIT_CMH2O, DEFAULT, QColor("light blue")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_EPAPHi = 0x111D, DATA, SESSION, "EPAPHi", STR_TR_EPAPHi, QObject::tr("Higher Expiratory Pressure"), STR_TR_EPAPHi, STR_UNIT_CMH2O, DEFAULT, QColor("aqua")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PS = 0x110F, DATA, SESSION, "PS", STR_TR_PS, QObject::tr("Pressure Support"), STR_TR_PS, STR_UNIT_CMH2O, DEFAULT, QColor("grey")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PSMin = 0x111A, SETTING, SESSION, "PSMin", QObject::tr("PS Min") , QObject::tr("Pressure Support Minimum"), QObject::tr("PS Min"), STR_UNIT_CMH2O, DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PSMax = 0x111B, SETTING, SESSION, "PSMax", QObject::tr("PS Max"), QObject::tr("Pressure Support Maximum"), QObject::tr("PS Max"), STR_UNIT_CMH2O, DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PressureMin = 0x1020, SETTING, SESSION, "PressureMin", QObject::tr("Min Pressure") , QObject::tr("Minimum Therapy Pressure"), QObject::tr("Pr. Min"), STR_UNIT_CMH2O, DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PressureMax = 0x1021, SETTING, SESSION, "PressureMax", QObject::tr("Max Pressure"), QObject::tr("Maximum Therapy Pressure"), QObject::tr("Pr. Max"), STR_UNIT_CMH2O, DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_RampTime = 0x1022, SETTING, SESSION, "RampTime", QObject::tr("Ramp Time") , QObject::tr("Ramp Delay Period"), QObject::tr("Ramp Time"), QObject::tr("minutes"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_RampPressure = 0x1023, SETTING, SESSION, "RampPressure", QObject::tr("Ramp Pressure"), QObject::tr("Starting Ramp Pressure"), QObject::tr("Ramp Pr."), STR_UNIT_CMH2O, DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Pressure = 0x110C, DATA, SESSION,
"Pressure", STR_TR_Pressure, QObject::tr("Therapy Pressure"),
STR_TR_Pressure, STR_UNIT_CMH2O, DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_IPAP = 0x110D, DATA, SESSION, "IPAP",
STR_TR_IPAP, QObject::tr("Inspiratory Pressure"), STR_TR_IPAP,
STR_UNIT_CMH2O, DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_IPAPLo = 0x1110, DATA, SESSION, "IPAPLo",
STR_TR_IPAPLo, QObject::tr("Lower Inspiratory Pressure"), STR_TR_IPAPLo,
STR_UNIT_CMH2O, DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_IPAPHi = 0x1111, DATA, SESSION, "IPAPHi",
STR_TR_IPAPHi, QObject::tr("Higher Inspiratory Pressure"), STR_TR_IPAPHi,
STR_UNIT_CMH2O, DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_EPAP = 0x110E, DATA, SESSION, "EPAP",
STR_TR_EPAP, QObject::tr("Expiratory Pressure"), STR_TR_EPAP,
STR_UNIT_CMH2O, DEFAULT, QColor("light blue")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_EPAPLo = 0x111C, DATA, SESSION, "EPAPLo",
STR_TR_EPAPLo, QObject::tr("Lower Expiratory Pressure"), STR_TR_EPAPLo,
STR_UNIT_CMH2O, DEFAULT, QColor("light blue")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_EPAPHi = 0x111D, DATA, SESSION, "EPAPHi",
STR_TR_EPAPHi, QObject::tr("Higher Expiratory Pressure"), STR_TR_EPAPHi,
STR_UNIT_CMH2O, DEFAULT, QColor("aqua")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PS = 0x110F, DATA, SESSION, "PS",
STR_TR_PS, QObject::tr("Pressure Support"), STR_TR_PS,
STR_UNIT_CMH2O, DEFAULT, QColor("grey")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PSMin = 0x111A, SETTING, SESSION, "PSMin",
QObject::tr("PS Min") , QObject::tr("Pressure Support Minimum"),
QObject::tr("PS Min"), STR_UNIT_CMH2O, DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PSMax = 0x111B, SETTING, SESSION, "PSMax",
QObject::tr("PS Max"), QObject::tr("Pressure Support Maximum"),
QObject::tr("PS Max"), STR_UNIT_CMH2O, DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PressureMin = 0x1020, SETTING, SESSION,
"PressureMin", QObject::tr("Min Pressure") , QObject::tr("Minimum Therapy Pressure"),
QObject::tr("Pr. Min"), STR_UNIT_CMH2O, DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PressureMax = 0x1021, SETTING, SESSION,
"PressureMax", QObject::tr("Max Pressure"), QObject::tr("Maximum Therapy Pressure"),
QObject::tr("Pr. Max"), STR_UNIT_CMH2O, DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_RampTime = 0x1022, SETTING, SESSION,
"RampTime", QObject::tr("Ramp Time") , QObject::tr("Ramp Delay Period"),
QObject::tr("Ramp Time"), QObject::tr("minutes"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_RampPressure = 0x1023, SETTING, SESSION,
"RampPressure", QObject::tr("Ramp Pressure"), QObject::tr("Starting Ramp Pressure"),
QObject::tr("Ramp Pr."), STR_UNIT_CMH2O, DEFAULT, QColor("black")));
// <channel id="0x1000" class="data" name="CSR" details="Periodic Breathing" label="PB" unit="% of night" color="light green"/>
// <channel id="0x1001" class="data" name="ClearAirway" details="Clear Airway Apnea" label="CA" unit="events/hour" color="purple"/>
// <channel id="0x1002" class="data" name="Obstructive" details="Obstructive Apnea" label="OA" unit="events/hour" color="#40c0ff"/>
// <channel id="0x1003" class="data" name="Hypopnea" details="Hypopnea" label="H" unit="events/hour" color="blue"/>
// <channel id="0x1004" class="data" name="Apnea" details="Unspecified Apnea" label="UA" unit="events/hour" color="dark green"/>
// <channel id="0x1005" class="data" name="FlowLimit" details="Flow Limitation" label="FL" unit="events/hour" color="#404040"/>
// <channel id="0x1006" class="data" name="RERA" details="Resp. Effort Related Arousal" unit="events/hour" label="RERA" color="gold"/>
// <channel id="0x1007" class="data" name="VSnore" details="Vibratory Snore" label="VS" unit="events/hour" color="red"/>
// <channel id="0x1008" class="data" name="VSnore2" details="Vibratory Snore #2" label="VS2" unit="events/hour" color="orange"/>
// <channel id="0x1009" class="data" name="PressurePulse" details="Pressure Pulse" label="PP" unit="events/hour" color="dark red"/>
// <channel id="0x100a" class="data" name="LeakFlag" details="Leak Event" label="L" unit="events/hour" color="dark blue"/>
// <channel id="0x100b" class="data" name="NRI" details="Non-Responding Event" label="NRI" unit="events/hour" color="orange"/>
// <channel id="0x100c" class="data" name="ExP" details="Exhale Puff" label="EP" unit="events/hour" color="dark magenta"/>
// <channel id="0x101e" class="data" name="UserFlag1" details="User Flag #1" label="UF1" unit="events/hour" color="dark cyan"/>
// <channel id="0x101f" class="data" name="UserFlag2" details="User Flag #2" label="UF2" unit="events/hour" color="dark blue"/>
// <channel id="0x1024" class="data" name="UserFlag3" details="User Flag #3" label="UF3" unit="events/hour" color="dark grey"/>
schema::channel.add(GRP_CPAP,new Channel(CPAP_CSR = 0x1000, DATA, SESSION, "CSR", QObject::tr("Periodic Breathing"), QObject::tr("A period of periodic breathing"), QObject::tr("PB"), QObject::tr("%"), DEFAULT, QColor("light green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_ClearAirway = 0x1001, DATA, SESSION, "ClearAirway", QObject::tr("Clear Airway Apnea"), QObject::tr("An apnea where the airway is open"), QObject::tr("CA"), QObject::tr("events/hr"), DEFAULT, QColor("purple")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Obstructive = 0x1002, DATA, SESSION, "Obstructive", QObject::tr("Obstructive Apnea"), QObject::tr("An apnea caused by airway obstruction"), QObject::tr("OA"), QObject::tr("events/hr"), DEFAULT, QColor("#40c0ff")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Hypopnea = 0x1003, DATA, SESSION, "Hypopnea", QObject::tr("Hypopnea"), QObject::tr("A partially obstructed airway"), QObject::tr("H"), QObject::tr("events/hr"), DEFAULT, QColor("blue")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Apnea = 0x1004, DATA, SESSION, "Apnea", QObject::tr("Unclassified Apnea"), QObject::tr("An apnea that could not fit into a category"), QObject::tr("UA"), QObject::tr("events/hr"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_FlowLimit = 0x1005, DATA, SESSION, "FlowLimit", QObject::tr("Flow Limitation"), QObject::tr("An restriction in breathing from normal, causing a flattening of the flow waveform."), QObject::tr("FL"), QObject::tr("events/hr"), DEFAULT, QColor("#404040")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_RERA = 0x1006, DATA, SESSION, "RERA", QObject::tr("Respiratory Effort Related Arousal"), QObject::tr("An restriction in breathing that causes an either an awakening or sleep disturbance."), QObject::tr("RE"), QObject::tr("events/hr"), DEFAULT, QColor("gold")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_VSnore = 0x1007, DATA, SESSION, "VSnore", QObject::tr("Vibratory Snore"), QObject::tr("A vibratory snore"), QObject::tr("VS"), QObject::tr("events/hr"), DEFAULT, QColor("red")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_VSnore2 = 0x1008, DATA, SESSION, "VSnore2", QObject::tr("Vibratory Snore"), QObject::tr("A vibratory snore as detcted by a System One machine"), QObject::tr("VS2"), QObject::tr("events/hr"), DEFAULT, QColor("red")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PressurePulse = 0x1009, DATA, SESSION, "PressurePulse", QObject::tr("Pressure Pulse"), QObject::tr("A pulse of pressure 'pinged' to detect a closed airway."), QObject::tr("PP"), QObject::tr("events/hr"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_LeakFlag = 0x100a, DATA, SESSION, "LeakFlag", QObject::tr("Large Leak"), QObject::tr("A large mask leak affecting machine performance."), QObject::tr("LL"), QObject::tr("events/hr"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_NRI = 0x100b, DATA, SESSION, "NRI", QObject::tr("Non Responding Event"), QObject::tr("A type of respiratory event that won't respond to a pressure increase."), QObject::tr("NR"), QObject::tr("events/hr"), DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_ExP = 0x100c, DATA, SESSION, "ExP", QObject::tr("Expiratory Puff"), QObject::tr("Intellipap event where you breathe out your mouth."), QObject::tr("EP"), QObject::tr("events/hr"), DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_UserFlag1 = 0x101e, DATA, SESSION, "UserFlag1", QObject::tr("User Flag #1"), QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."), QObject::tr("UF1"), QObject::tr("events/hr"), DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_UserFlag2 = 0x101f, DATA, SESSION, "UserFlag2", QObject::tr("User Flag #2"), QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."), QObject::tr("UF2"), QObject::tr("events/hr"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_UserFlag3 = 0x1024, DATA, SESSION, "UserFlag3", QObject::tr("User Flag #3"), QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."), QObject::tr("UF3"), QObject::tr("events/hr"), DEFAULT, QColor("dark grey")));
// <channel id="0x1000" class="data" name="CSR" details="Periodic Breathing" label="PB" unit="% of night" color="light green"/>
// <channel id="0x1001" class="data" name="ClearAirway" details="Clear Airway Apnea" label="CA" unit="events/hour" color="purple"/>
// <channel id="0x1002" class="data" name="Obstructive" details="Obstructive Apnea" label="OA" unit="events/hour" color="#40c0ff"/>
// <channel id="0x1003" class="data" name="Hypopnea" details="Hypopnea" label="H" unit="events/hour" color="blue"/>
// <channel id="0x1004" class="data" name="Apnea" details="Unspecified Apnea" label="UA" unit="events/hour" color="dark green"/>
// <channel id="0x1005" class="data" name="FlowLimit" details="Flow Limitation" label="FL" unit="events/hour" color="#404040"/>
// <channel id="0x1006" class="data" name="RERA" details="Resp. Effort Related Arousal" unit="events/hour" label="RERA" color="gold"/>
// <channel id="0x1007" class="data" name="VSnore" details="Vibratory Snore" label="VS" unit="events/hour" color="red"/>
// <channel id="0x1008" class="data" name="VSnore2" details="Vibratory Snore #2" label="VS2" unit="events/hour" color="orange"/>
// <channel id="0x1009" class="data" name="PressurePulse" details="Pressure Pulse" label="PP" unit="events/hour" color="dark red"/>
// <channel id="0x100a" class="data" name="LeakFlag" details="Leak Event" label="L" unit="events/hour" color="dark blue"/>
// <channel id="0x100b" class="data" name="NRI" details="Non-Responding Event" label="NRI" unit="events/hour" color="orange"/>
// <channel id="0x100c" class="data" name="ExP" details="Exhale Puff" label="EP" unit="events/hour" color="dark magenta"/>
// <channel id="0x101e" class="data" name="UserFlag1" details="User Flag #1" label="UF1" unit="events/hour" color="dark cyan"/>
// <channel id="0x101f" class="data" name="UserFlag2" details="User Flag #2" label="UF2" unit="events/hour" color="dark blue"/>
// <channel id="0x1024" class="data" name="UserFlag3" details="User Flag #3" label="UF3" unit="events/hour" color="dark grey"/>
schema::channel.add(GRP_CPAP, new Channel(CPAP_CSR = 0x1000, DATA, SESSION, "CSR",
QObject::tr("Periodic Breathing"),
QObject::tr("A period of periodic breathing"),
QObject::tr("PB"), QObject::tr("%"), DEFAULT, QColor("light green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_ClearAirway = 0x1001, DATA, SESSION,
"ClearAirway", QObject::tr("Clear Airway Apnea"),
QObject::tr("An apnea where the airway is open"),
QObject::tr("CA"), QObject::tr("events/hr"), DEFAULT, QColor("purple")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Obstructive = 0x1002, DATA, SESSION,
"Obstructive", QObject::tr("Obstructive Apnea"),
QObject::tr("An apnea caused by airway obstruction"),
QObject::tr("OA"), QObject::tr("events/hr"), DEFAULT, QColor("#40c0ff")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Hypopnea = 0x1003, DATA, SESSION,
"Hypopnea", QObject::tr("Hypopnea"),
QObject::tr("A partially obstructed airway"),
QObject::tr("H"), QObject::tr("events/hr"), DEFAULT, QColor("blue")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Apnea = 0x1004, DATA, SESSION, "Apnea",
QObject::tr("Unclassified Apnea"),
QObject::tr("An apnea that could not fit into a category"),
QObject::tr("UA"), QObject::tr("events/hr"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_FlowLimit = 0x1005, DATA, SESSION,
"FlowLimit", QObject::tr("Flow Limitation"),
QObject::tr("An restriction in breathing from normal, causing a flattening of the flow waveform."),
QObject::tr("FL"), QObject::tr("events/hr"), DEFAULT, QColor("#404040")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_RERA = 0x1006, DATA, SESSION, "RERA",
QObject::tr("Respiratory Effort Related Arousal"),
QObject::tr("An restriction in breathing that causes an either an awakening or sleep disturbance."),
QObject::tr("RE"), QObject::tr("events/hr"), DEFAULT, QColor("gold")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_VSnore = 0x1007, DATA, SESSION, "VSnore",
QObject::tr("Vibratory Snore"), QObject::tr("A vibratory snore"),
QObject::tr("VS"), QObject::tr("events/hr"), DEFAULT, QColor("red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_VSnore2 = 0x1008, DATA, SESSION, "VSnore2",
QObject::tr("Vibratory Snore"),
QObject::tr("A vibratory snore as detcted by a System One machine"),
QObject::tr("VS2"), QObject::tr("events/hr"), DEFAULT, QColor("red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PressurePulse = 0x1009, DATA, SESSION,
"PressurePulse", QObject::tr("Pressure Pulse"),
QObject::tr("A pulse of pressure 'pinged' to detect a closed airway."),
QObject::tr("PP"), QObject::tr("events/hr"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_LeakFlag = 0x100a, DATA, SESSION,
"LeakFlag", QObject::tr("Large Leak"),
QObject::tr("A large mask leak affecting machine performance."),
QObject::tr("LL"), QObject::tr("events/hr"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_NRI = 0x100b, DATA, SESSION, "NRI",
QObject::tr("Non Responding Event"),
QObject::tr("A type of respiratory event that won't respond to a pressure increase."),
QObject::tr("NR"), QObject::tr("events/hr"), DEFAULT, QColor("orange")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_ExP = 0x100c, DATA, SESSION, "ExP",
QObject::tr("Expiratory Puff"),
QObject::tr("Intellipap event where you breathe out your mouth."),
QObject::tr("EP"), QObject::tr("events/hr"), DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_UserFlag1 = 0x101e, DATA, SESSION,
"UserFlag1", QObject::tr("User Flag #1"),
QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),
QObject::tr("UF1"), QObject::tr("events/hr"), DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_UserFlag2 = 0x101f, DATA, SESSION,
"UserFlag2", QObject::tr("User Flag #2"),
QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),
QObject::tr("UF2"), QObject::tr("events/hr"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_UserFlag3 = 0x1024, DATA, SESSION,
"UserFlag3", QObject::tr("User Flag #3"),
QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),
QObject::tr("UF3"), QObject::tr("events/hr"), DEFAULT, QColor("dark grey")));
// <channel id="0x1800" class="data" name="Pulse" details="Pulse Rate" label="Pulse Rate" unit="bpm" color="red"/>
// <channel id="0x1801" class="data" name="SPO2" details="Oxygen Saturation" label="SpO2" unit="%" color="blue"/>
// <channel id="0x1802" class="data" name="Plethy" details="Plethysomogram" label="Plethy" color="black"/>
// <channel id="0x1803" class="data" name="PulseChange" details="Pulse Change" label="Pulse Change" color="light gray"/>
// <channel id="0x1804" class="data" name="SPO2Drop" details="SPO2Drop" label="SPO2 Drop" color="light blue"/>
schema::channel.add(GRP_OXI,new Channel(OXI_Pulse = 0x1800, DATA, SESSION, "Pulse", QObject::tr("Pulse Rate"), QObject::tr("Heart rate in beats per minute"), QObject::tr("Pulse Rate"), QObject::tr("%"), DEFAULT, QColor("red")));
schema::channel.add(GRP_OXI,new Channel(OXI_SPO2 = 0x1801, DATA, SESSION, "SPO2", QObject::tr("SpO2 %"), QObject::tr("Blood-oxygen saturation percentage"), QObject::tr("SpO2"), QObject::tr("bpm"), DEFAULT, QColor("blue")));
schema::channel.add(GRP_OXI,new Channel(OXI_Plethy = 0x1802, DATA, SESSION, "Plethy", QObject::tr("Plethysomogram"), QObject::tr("An optical Photo-plethysomogram showing heart rhythm"), QObject::tr("Plethy"), QObject::tr("hz"), DEFAULT, QColor("#404040")));
schema::channel.add(GRP_OXI,new Channel(OXI_PulseChange = 0x1803, DATA, SESSION, "PulseChange", QObject::tr("Pulse Change"), QObject::tr("A sudden (user definable) change in heart rate"), QObject::tr("PC"), QObject::tr("events/hr"), DEFAULT, QColor("light grey")));
schema::channel.add(GRP_OXI,new Channel(OXI_SPO2Drop = 0x1804, DATA, SESSION, "SPO2Drop", QObject::tr("SpO2 Drop"), QObject::tr("A sudden (user definable) drop in blood oxygen saturation"), QObject::tr("SD"), QObject::tr("events/hr"), DEFAULT, QColor("light blue")));
// <channel id="0x1800" class="data" name="Pulse" details="Pulse Rate" label="Pulse Rate" unit="bpm" color="red"/>
// <channel id="0x1801" class="data" name="SPO2" details="Oxygen Saturation" label="SpO2" unit="%" color="blue"/>
// <channel id="0x1802" class="data" name="Plethy" details="Plethysomogram" label="Plethy" color="black"/>
// <channel id="0x1803" class="data" name="PulseChange" details="Pulse Change" label="Pulse Change" color="light gray"/>
// <channel id="0x1804" class="data" name="SPO2Drop" details="SPO2Drop" label="SPO2 Drop" color="light blue"/>
schema::channel.add(GRP_OXI, new Channel(OXI_Pulse = 0x1800, DATA, SESSION, "Pulse",
QObject::tr("Pulse Rate"), QObject::tr("Heart rate in beats per minute"),
QObject::tr("Pulse Rate"), QObject::tr("%"), DEFAULT, QColor("red")));
schema::channel.add(GRP_OXI, new Channel(OXI_SPO2 = 0x1801, DATA, SESSION, "SPO2",
QObject::tr("SpO2 %"), QObject::tr("Blood-oxygen saturation percentage"),
QObject::tr("SpO2"), QObject::tr("bpm"), DEFAULT, QColor("blue")));
schema::channel.add(GRP_OXI, new Channel(OXI_Plethy = 0x1802, DATA, SESSION, "Plethy",
QObject::tr("Plethysomogram"),
QObject::tr("An optical Photo-plethysomogram showing heart rhythm"),
QObject::tr("Plethy"), QObject::tr("hz"), DEFAULT, QColor("#404040")));
schema::channel.add(GRP_OXI, new Channel(OXI_PulseChange = 0x1803, DATA, SESSION,
"PulseChange", QObject::tr("Pulse Change"),
QObject::tr("A sudden (user definable) change in heart rate"),
QObject::tr("PC"), QObject::tr("events/hr"), DEFAULT, QColor("light grey")));
schema::channel.add(GRP_OXI, new Channel(OXI_SPO2Drop = 0x1804, DATA, SESSION,
"SPO2Drop", QObject::tr("SpO2 Drop"),
QObject::tr("A sudden (user definable) drop in blood oxygen saturation"),
QObject::tr("SD"), QObject::tr("events/hr"), DEFAULT, QColor("light blue")));
// <channel id="0x1100" class="data" name="FlowRate" details="Flow Rate" label="Flow Rate" unit="L/min" color="black"/>
// <channel id="0x1101" class="data" name="MaskPressure" details="Mask Pressure" label="Mask Pressure" unit="cmH20" color="blue"/>
// <channel id="0x1102" class="data" name="MaskPressureHi" details="Mask Pressure" label="Mask Pressure (Hi-Res)" unit="cmH20" color="blue" link="0x1101"/>
// <channel id="0x1103" class="data" name="TidalVolume" details="Tidal Volume" label="Tidal Volume" unit="ml" color="magenta"/>
// <channel id="0x1104" class="data" name="Snore" details="Snore" label="Snore" unit="unknown" color="grey"/>
// <channel id="0x1105" class="data" name="MinuteVent" details="Minute Ventilation" label="Minute Vent." unit="L/min" color="dark cyan"/>
// <channel id="0x1106" class="data" name="RespRate" details="Respiratory Rate" label="Resp. Rate" unit="breaths/min" color="dark magenta"/>
// <channel id="0x1107" class="data" name="PTB" details="Patient Triggered Breaths" label="Pat. Trig. Breaths" unit="%" color="dark grey"/>
// <channel id="0x1108" class="data" name="Leak" details="Leak Rate" label="Leaks" unit="L/min" color="dark green"/>
// <channel id="0x1100" class="data" name="FlowRate" details="Flow Rate" label="Flow Rate" unit="L/min" color="black"/>
// <channel id="0x1101" class="data" name="MaskPressure" details="Mask Pressure" label="Mask Pressure" unit="cmH20" color="blue"/>
// <channel id="0x1102" class="data" name="MaskPressureHi" details="Mask Pressure" label="Mask Pressure (Hi-Res)" unit="cmH20" color="blue" link="0x1101"/>
// <channel id="0x1103" class="data" name="TidalVolume" details="Tidal Volume" label="Tidal Volume" unit="ml" color="magenta"/>
// <channel id="0x1104" class="data" name="Snore" details="Snore" label="Snore" unit="unknown" color="grey"/>
// <channel id="0x1105" class="data" name="MinuteVent" details="Minute Ventilation" label="Minute Vent." unit="L/min" color="dark cyan"/>
// <channel id="0x1106" class="data" name="RespRate" details="Respiratory Rate" label="Resp. Rate" unit="breaths/min" color="dark magenta"/>
// <channel id="0x1107" class="data" name="PTB" details="Patient Triggered Breaths" label="Pat. Trig. Breaths" unit="%" color="dark grey"/>
// <channel id="0x1108" class="data" name="Leak" details="Leak Rate" label="Leaks" unit="L/min" color="dark green"/>
// <channel id="0x1109" class="data" name="IE" details="Inspiratory:Expiratory" label="I:E" unit="ratio" color="dark red"/>
// <channel id="0x110a" class="data" name="Te" details="Expiratory Time" label="Exp Time" unit="seconds" color="dark green"/>
// <channel id="0x110b" class="data" name="Ti" details="Inspiratory Time" label="Insp Time" unit="seconds" color="dark blue"/>
// <channel id="0x1112" class="data" name="RespEvent" details="Respiratory Events" label="Resp Events" unit="" color="black"/>
// <channel id="0x1113" class="data" name="FLG" details="Flow Limit Graph" label="Flow Limit" unit="0-1" color="dark grey"/>
// <channel id="0x1114" class="data" name="TgMV" details="Target Minute Ventilation" label="Target Vent." unit="" color="dark cyan"/>
// <channel id="0x1115" class="data" name="MaxLeak" details="Maximum Leak" label="MaxLeaks" unit="L/min" color="dark red"/>
// <channel id="0x1116" class="data" name="AHI" details="Apnea / Hypopnea Index" label="AHI/Hr" unit="events/hr" color="dark red"/>
// <channel id="0x1117" class="data" name="LeakTotal" details="Total Leak Rate" label="Total Leaks" unit="L/min" color="dark green"/>
// <channel id="0x1118" class="data" name="LeakMedian" details="Median Leak Rate" label="Median Leaks" unit="L/min" color="dark green"/>
// <channel id="0x1119" class="data" name="RDI" details="Respiratory Disturbance Index" label="RDI" unit="events/hr" color="dark red"/>
// <channel id="0x1109" class="data" name="IE" details="Inspiratory:Expiratory" label="I:E" unit="ratio" color="dark red"/>
// <channel id="0x110a" class="data" name="Te" details="Expiratory Time" label="Exp Time" unit="seconds" color="dark green"/>
// <channel id="0x110b" class="data" name="Ti" details="Inspiratory Time" label="Insp Time" unit="seconds" color="dark blue"/>
// <channel id="0x1112" class="data" name="RespEvent" details="Respiratory Events" label="Resp Events" unit="" color="black"/>
// <channel id="0x1113" class="data" name="FLG" details="Flow Limit Graph" label="Flow Limit" unit="0-1" color="dark grey"/>
// <channel id="0x1114" class="data" name="TgMV" details="Target Minute Ventilation" label="Target Vent." unit="" color="dark cyan"/>
// <channel id="0x1115" class="data" name="MaxLeak" details="Maximum Leak" label="MaxLeaks" unit="L/min" color="dark red"/>
// <channel id="0x1116" class="data" name="AHI" details="Apnea / Hypopnea Index" label="AHI/Hr" unit="events/hr" color="dark red"/>
// <channel id="0x1117" class="data" name="LeakTotal" details="Total Leak Rate" label="Total Leaks" unit="L/min" color="dark green"/>
// <channel id="0x1118" class="data" name="LeakMedian" details="Median Leak Rate" label="Median Leaks" unit="L/min" color="dark green"/>
// <channel id="0x1119" class="data" name="RDI" details="Respiratory Disturbance Index" label="RDI" unit="events/hr" color="dark red"/>
schema::channel.add(GRP_CPAP,new Channel(CPAP_FlowRate = 0x1100, DATA, SESSION, "FlowRate", QObject::tr("Flow Rate"), QObject::tr("Breathing flow rate waveform"), QObject::tr("Flow Rate"), QObject::tr("L/min"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_MaskPressure = 0x1101, DATA, SESSION, "MaskPressure", QObject::tr("Mask Pressure"), QObject::tr("Mask Pressure"), QObject::tr("Mask Pressure"), QObject::tr("cmH2O"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_MaskPressureHi = 0x1102, DATA, SESSION, "MaskPressureHi", QObject::tr("Mask Pressure"), QObject::tr("Mask Pressure (High resolution)"), QObject::tr("Mask Pressure"), QObject::tr("cmH2O"), DEFAULT, QColor("black"),0x1101)); // linked to CPAP_MaskPressure
schema::channel.add(GRP_CPAP,new Channel(CPAP_TidalVolume = 0x1103, DATA, SESSION, "TidalVolume", QObject::tr("Tidal Volume"), QObject::tr("Amount of air displaced per breath"), QObject::tr("Tidal Volume"), QObject::tr("L/min"), DEFAULT, QColor("magenta")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Snore = 0x1104, DATA, SESSION, "Snore", QObject::tr("Snore"), QObject::tr("Graph displaying snore volume"), QObject::tr("Snore"), QObject::tr("??"), DEFAULT, QColor("grey")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_MinuteVent = 0x1105, DATA, SESSION, "MinuteVent", QObject::tr("Minute Ventilation"), QObject::tr("Amount of air displaced per minute"), QObject::tr("Minute Vent."), QObject::tr("L/min"), DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_RespRate = 0x1106, DATA, SESSION, "RespRate", QObject::tr("Respiratory Rate"), QObject::tr("Rate of breaths per minute"), QObject::tr("Resp. Rate"), QObject::tr("Bpm"), DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_PTB = 0x1107, DATA, SESSION, "PTB", QObject::tr("Patient Triggered Breaths"), QObject::tr("Percentage of breaths triggered by patient"), QObject::tr("Pat. Trig. Breaths"), QObject::tr("%"), DEFAULT, QColor("dark grey")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Leak = 0x1108, DATA, SESSION, "Leak", QObject::tr("Leak Rate"), QObject::tr("Rate of detected mask leakage"), QObject::tr("Leak Rate"), QObject::tr("L/min"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_IE = 0x1109, DATA, SESSION, "IE", QObject::tr("I:E Ratio"), QObject::tr("Ratio between Inspiratory and Expiratory time"),QObject::tr("I:E Ratio"), QObject::tr("ratio"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Te = 0x110A, DATA, SESSION, "Te", QObject::tr("Expiratory Time"), QObject::tr("Time taken to breathe out"), QObject::tr("Exp. Time"), QObject::tr("seconds"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_Ti = 0x110B, DATA, SESSION, "Ti", QObject::tr("Inspiratory Time"), QObject::tr("Time taken to breathe in"), QObject::tr("Insp. Time"), QObject::tr("seconds"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_RespEvent = 0x1112, DATA, SESSION, "RespEvent", QObject::tr("Respiratory Event"), QObject::tr("A ResMed data source showing Respiratory Events"), QObject::tr("Resp. Event"), QObject::tr("events"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_FLG = 0x1113, DATA, SESSION, "FLG", QObject::tr("Flow Limitation"), QObject::tr("Graph showing severity of flow limitations"), QObject::tr("Flow Limit."), QObject::tr("0-1"), DEFAULT, QColor("dark gray")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_TgMV = 0x1114, DATA, SESSION, "TgMV", QObject::tr("Target Minute Ventilation"), QObject::tr("Target Minute Ventilation?"), QObject::tr("Target Vent."), QObject::tr("??"), DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_MaxLeak = 0x1115, DATA, SESSION, "MaxLeak", QObject::tr("Maximum Leak"), QObject::tr("The maximum rate of mask leakage"), QObject::tr("Max Leaks"), QObject::tr("L/min"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_AHI = 0x1116, DATA, SESSION, "AHI", QObject::tr("Apnea Hypopnea Index"), QObject::tr("Graph showing running AHI for the past hour"), QObject::tr("AHI"), QObject::tr("events/hour"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_LeakTotal = 0x1117, DATA, SESSION, "LeakTotal", QObject::tr("Total Leak Rate"), QObject::tr("Detected mask leakage including natural Mask leakages"), QObject::tr("Total Leaks"), QObject::tr("L/min"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_LeakMedian = 0x1118, DATA, SESSION, "LeakMedian", QObject::tr("Median Leak Rate"), QObject::tr("Median rate of detected mask leakage"), QObject::tr("Median Leaks"), QObject::tr("L/min"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP,new Channel(CPAP_RDI = 0x1119, DATA, SESSION, "RDI", QObject::tr("Respiratory Disturbance Index"), QObject::tr("Graph showing running RDI for the past hour"), QObject::tr("RDI"), QObject::tr("events/hour"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_FlowRate = 0x1100, DATA, SESSION,
"FlowRate", QObject::tr("Flow Rate"),
QObject::tr("Breathing flow rate waveform"), QObject::tr("Flow Rate"),
QObject::tr("L/min"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_MaskPressure = 0x1101, DATA, SESSION,
"MaskPressure", QObject::tr("Mask Pressure"),
QObject::tr("Mask Pressure"), QObject::tr("Mask Pressure"),
QObject::tr("cmH2O"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_MaskPressureHi = 0x1102, DATA, SESSION,
"MaskPressureHi", QObject::tr("Mask Pressure"),
QObject::tr("Mask Pressure (High resolution)"), QObject::tr("Mask Pressure"),
QObject::tr("cmH2O"), DEFAULT, QColor("black"), 0x1101)); // linked to CPAP_MaskPressure
schema::channel.add(GRP_CPAP, new Channel(CPAP_TidalVolume = 0x1103, DATA, SESSION,
"TidalVolume", QObject::tr("Tidal Volume"),
QObject::tr("Amount of air displaced per breath"), QObject::tr("Tidal Volume"),
QObject::tr("L/min"), DEFAULT, QColor("magenta")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Snore = 0x1104, DATA, SESSION,
"Snore", QObject::tr("Snore"),
QObject::tr("Graph displaying snore volume"), QObject::tr("Snore"),
QObject::tr("??"), DEFAULT, QColor("grey")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_MinuteVent = 0x1105, DATA, SESSION,
"MinuteVent", QObject::tr("Minute Ventilation"),
QObject::tr("Amount of air displaced per minute"), QObject::tr("Minute Vent."),
QObject::tr("L/min"), DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_RespRate = 0x1106, DATA, SESSION,
"RespRate", QObject::tr("Respiratory Rate"),
QObject::tr("Rate of breaths per minute"), QObject::tr("Resp. Rate"),
QObject::tr("Bpm"), DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_PTB = 0x1107, DATA, SESSION, "PTB",
QObject::tr("Patient Triggered Breaths"),
QObject::tr("Percentage of breaths triggered by patient"), QObject::tr("Pat. Trig. Breaths"),
QObject::tr("%"), DEFAULT, QColor("dark grey")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Leak = 0x1108, DATA, SESSION,
"Leak", QObject::tr("Leak Rate"),
QObject::tr("Rate of detected mask leakage"), QObject::tr("Leak Rate"),
QObject::tr("L/min"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_IE = 0x1109, DATA, SESSION, "IE",
QObject::tr("I:E Ratio"),
QObject::tr("Ratio between Inspiratory and Expiratory time"), QObject::tr("I:E Ratio"),
QObject::tr("ratio"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Te = 0x110A, DATA, SESSION, "Te",
QObject::tr("Expiratory Time"), QObject::tr("Time taken to breathe out"),
QObject::tr("Exp. Time"), QObject::tr("seconds"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_Ti = 0x110B, DATA, SESSION, "Ti",
QObject::tr("Inspiratory Time"), QObject::tr("Time taken to breathe in"),
QObject::tr("Insp. Time"), QObject::tr("seconds"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_RespEvent = 0x1112, DATA, SESSION,
"RespEvent", QObject::tr("Respiratory Event"),
QObject::tr("A ResMed data source showing Respiratory Events"), QObject::tr("Resp. Event"),
QObject::tr("events"), DEFAULT, QColor("black")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_FLG = 0x1113, DATA, SESSION, "FLG",
QObject::tr("Flow Limitation"),
QObject::tr("Graph showing severity of flow limitations"), QObject::tr("Flow Limit."),
QObject::tr("0-1"), DEFAULT, QColor("dark gray")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_TgMV = 0x1114, DATA, SESSION,
"TgMV", QObject::tr("Target Minute Ventilation"),
QObject::tr("Target Minute Ventilation?"), QObject::tr("Target Vent."),
QObject::tr("??"), DEFAULT, QColor("dark cyan")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_MaxLeak = 0x1115, DATA, SESSION,
"MaxLeak", QObject::tr("Maximum Leak"),
QObject::tr("The maximum rate of mask leakage"), QObject::tr("Max Leaks"),
QObject::tr("L/min"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_AHI = 0x1116, DATA, SESSION, "AHI",
QObject::tr("Apnea Hypopnea Index"),
QObject::tr("Graph showing running AHI for the past hour"), QObject::tr("AHI"),
QObject::tr("events/hour"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_LeakTotal = 0x1117, DATA, SESSION,
"LeakTotal", QObject::tr("Total Leak Rate"),
QObject::tr("Detected mask leakage including natural Mask leakages"), QObject::tr("Total Leaks"),
QObject::tr("L/min"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_LeakMedian = 0x1118, DATA, SESSION,
"LeakMedian", QObject::tr("Median Leak Rate"),
QObject::tr("Median rate of detected mask leakage"), QObject::tr("Median Leaks"),
QObject::tr("L/min"), DEFAULT, QColor("dark green")));
schema::channel.add(GRP_CPAP, new Channel(CPAP_RDI = 0x1119, DATA, SESSION, "RDI",
QObject::tr("Respiratory Disturbance Index"),
QObject::tr("Graph showing running RDI for the past hour"), QObject::tr("RDI"),
QObject::tr("events/hour"), DEFAULT, QColor("dark red")));
schema::channel.add(GRP_POS,new Channel(POS_Orientation = 0x2990, DATA, SESSION, "Orientation", QObject::tr("Orientation"), QObject::tr("Sleep position in degrees"), QObject::tr("Orientation"), QObject::tr("degrees"), DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_POS,new Channel(POS_Inclination = 0x2991, DATA, SESSION, "Inclination", QObject::tr("Inclination"), QObject::tr("Upright angle in degrees"), QObject::tr("Inclination"), QObject::tr("degrees"), DEFAULT, QColor("dark magenta")));
schema::channel.add(GRP_POS, new Channel(POS_Orientation = 0x2990, DATA, SESSION,
"Orientation", QObject::tr("Orientation"),
QObject::tr("Sleep position in degrees"), QObject::tr("Orientation"), QObject::tr("degrees"),
DEFAULT, QColor("dark blue")));
schema::channel.add(GRP_POS, new Channel(POS_Inclination = 0x2991, DATA, SESSION,
"Inclination", QObject::tr("Inclination"),
QObject::tr("Upright angle in degrees"), QObject::tr("Inclination"), QObject::tr("degrees"),
DEFAULT, QColor("dark magenta")));
NoChannel=0;
// CPAP_IPAP=schema::channel["IPAP"].id();
// CPAP_IPAPLo=schema::channel["IPAPLo"].id();
// CPAP_IPAPHi=schema::channel["IPAPHi"].id();
// CPAP_EPAP=schema::channel["EPAP"].id();
// CPAP_Pressure=schema::channel["Pressure"].id();
// CPAP_PS=schema::channel["PS"].id();
// CPAP_PSMin=schema::channel["PSMin"].id();
// CPAP_PSMax=schema::channel["PSMax"].id();
CPAP_Mode=schema::channel["PAPMode"].id();
CPAP_BrokenSummary=schema::channel["BrokenSummary"].id();
CPAP_BrokenWaveform=schema::channel["BrokenWaveform"].id();
// CPAP_PressureMin=schema::channel["PressureMin"].id();
// CPAP_PressureMax=schema::channel["PressureMax"].id();
// CPAP_RampTime=schema::channel["RampTime"].id();
// CPAP_RampPressure=schema::channel["RampPressure"].id();
// CPAP_Obstructive=schema::channel["Obstructive"].id();
// CPAP_Hypopnea=schema::channel["Hypopnea"].id();
// CPAP_ClearAirway=schema::channel["ClearAirway"].id();
// CPAP_Apnea=schema::channel["Apnea"].id();
// CPAP_CSR=schema::channel["CSR"].id();
// CPAP_LeakFlag=schema::channel["LeakFlag"].id();
// CPAP_ExP=schema::channel["ExP"].id();
// CPAP_NRI=schema::channel["NRI"].id();
// CPAP_VSnore=schema::channel["VSnore"].id();
// CPAP_VSnore2=schema::channel["VSnore2"].id();
// CPAP_RERA=schema::channel["RERA"].id();
// CPAP_PressurePulse=schema::channel["PressurePulse"].id();
// CPAP_FlowLimit=schema::channel["FlowLimit"].id();
// CPAP_FlowRate=schema::channel["FlowRate"].id();
// CPAP_MaskPressure=schema::channel["MaskPressure"].id();
// CPAP_MaskPressureHi=schema::channel["MaskPressureHi"].id();
// CPAP_RespEvent=schema::channel["RespEvent"].id();
// CPAP_Snore=schema::channel["Snore"].id();
// CPAP_MinuteVent=schema::channel["MinuteVent"].id();
// CPAP_RespRate=schema::channel["RespRate"].id();
// CPAP_TidalVolume=schema::channel["TidalVolume"].id();
// CPAP_PTB=schema::channel["PTB"].id();
// CPAP_Leak=schema::channel["Leak"].id();
// CPAP_LeakMedian=schema::channel["LeakMedian"].id();
// CPAP_LeakTotal=schema::channel["LeakTotal"].id();
// CPAP_MaxLeak=schema::channel["MaxLeak"].id();
// CPAP_FLG=schema::channel["FLG"].id();
// CPAP_IE=schema::channel["IE"].id();
// CPAP_Te=schema::channel["Te"].id();
// CPAP_Ti=schema::channel["Ti"].id();
// CPAP_TgMV=schema::channel["TgMV"].id();
CPAP_Test1=schema::channel["TestChan1"].id();
CPAP_Test2=schema::channel["TestChan2"].id();
NoChannel = 0;
// CPAP_IPAP=schema::channel["IPAP"].id();
// CPAP_IPAPLo=schema::channel["IPAPLo"].id();
// CPAP_IPAPHi=schema::channel["IPAPHi"].id();
// CPAP_EPAP=schema::channel["EPAP"].id();
// CPAP_Pressure=schema::channel["Pressure"].id();
// CPAP_PS=schema::channel["PS"].id();
// CPAP_PSMin=schema::channel["PSMin"].id();
// CPAP_PSMax=schema::channel["PSMax"].id();
CPAP_Mode = schema::channel["PAPMode"].id();
CPAP_BrokenSummary = schema::channel["BrokenSummary"].id();
CPAP_BrokenWaveform = schema::channel["BrokenWaveform"].id();
// CPAP_PressureMin=schema::channel["PressureMin"].id();
// CPAP_PressureMax=schema::channel["PressureMax"].id();
// CPAP_RampTime=schema::channel["RampTime"].id();
// CPAP_RampPressure=schema::channel["RampPressure"].id();
// CPAP_Obstructive=schema::channel["Obstructive"].id();
// CPAP_Hypopnea=schema::channel["Hypopnea"].id();
// CPAP_ClearAirway=schema::channel["ClearAirway"].id();
// CPAP_Apnea=schema::channel["Apnea"].id();
// CPAP_CSR=schema::channel["CSR"].id();
// CPAP_LeakFlag=schema::channel["LeakFlag"].id();
// CPAP_ExP=schema::channel["ExP"].id();
// CPAP_NRI=schema::channel["NRI"].id();
// CPAP_VSnore=schema::channel["VSnore"].id();
// CPAP_VSnore2=schema::channel["VSnore2"].id();
// CPAP_RERA=schema::channel["RERA"].id();
// CPAP_PressurePulse=schema::channel["PressurePulse"].id();
// CPAP_FlowLimit=schema::channel["FlowLimit"].id();
// CPAP_FlowRate=schema::channel["FlowRate"].id();
// CPAP_MaskPressure=schema::channel["MaskPressure"].id();
// CPAP_MaskPressureHi=schema::channel["MaskPressureHi"].id();
// CPAP_RespEvent=schema::channel["RespEvent"].id();
// CPAP_Snore=schema::channel["Snore"].id();
// CPAP_MinuteVent=schema::channel["MinuteVent"].id();
// CPAP_RespRate=schema::channel["RespRate"].id();
// CPAP_TidalVolume=schema::channel["TidalVolume"].id();
// CPAP_PTB=schema::channel["PTB"].id();
// CPAP_Leak=schema::channel["Leak"].id();
// CPAP_LeakMedian=schema::channel["LeakMedian"].id();
// CPAP_LeakTotal=schema::channel["LeakTotal"].id();
// CPAP_MaxLeak=schema::channel["MaxLeak"].id();
// CPAP_FLG=schema::channel["FLG"].id();
// CPAP_IE=schema::channel["IE"].id();
// CPAP_Te=schema::channel["Te"].id();
// CPAP_Ti=schema::channel["Ti"].id();
// CPAP_TgMV=schema::channel["TgMV"].id();
CPAP_Test1 = schema::channel["TestChan1"].id();
CPAP_Test2 = schema::channel["TestChan2"].id();
CPAP_PresReliefSet=schema::channel["PresRelSet"].id();
CPAP_PresReliefMode=schema::channel["PresRelMode"].id();
CPAP_PresReliefType=schema::channel["PresRelType"].id();
CPAP_PresReliefSet = schema::channel["PresRelSet"].id();
CPAP_PresReliefMode = schema::channel["PresRelMode"].id();
CPAP_PresReliefType = schema::channel["PresRelType"].id();
// CPAP_UserFlag1=schema::channel["UserFlag1"].id();
// CPAP_UserFlag2=schema::channel["UserFlag2"].id();
// CPAP_UserFlag3=schema::channel["UserFlag3"].id();
RMS9_E01=schema::channel["RMS9_E01"].id();
RMS9_E02=schema::channel["RMS9_E02"].id();
RMS9_EPR=schema::channel["EPR"].id();
RMS9_EPRSet=schema::channel["EPRSet"].id();
RMS9_SetPressure=schema::channel["SetPressure"].id();
PRS1_00=schema::channel["PRS1_00"].id();
PRS1_01=schema::channel["PRS1_01"].id();
PRS1_08=schema::channel["PRS1_08"].id();
PRS1_0A=schema::channel["PRS1_0A"].id();
PRS1_0B=schema::channel["PRS1_0B"].id();
PRS1_0C=schema::channel["PRS1_0C"].id();
PRS1_0E=schema::channel["PRS1_0E"].id();
PRS1_0F=schema::channel["PRS1_0F"].id();
PRS1_10=schema::channel["PRS1_10"].id();
PRS1_12=schema::channel["PRS1_12"].id();
PRS1_FlexMode=schema::channel["FlexMode"].id();
PRS1_FlexSet=schema::channel["FlexSet"].id();
PRS1_HumidStatus=schema::channel["HumidStat"].id();
CPAP_HumidSetting=schema::channel["HumidSet"].id();
PRS1_SysLock=schema::channel["SysLock"].id();
PRS1_SysOneResistStat=schema::channel["SysOneResistStat"].id();
PRS1_SysOneResistSet=schema::channel["SysOneResistSet"].id();
PRS1_HoseDiam=schema::channel["HoseDiam"].id();
PRS1_AutoOn=schema::channel["AutoOn"].id();
PRS1_AutoOff=schema::channel["AutoOff"].id();
PRS1_MaskAlert=schema::channel["MaskAlert"].id();
PRS1_ShowAHI=schema::channel["ShowAHI"].id();
INTELLIPAP_Unknown1=schema::channel["IntUnk1"].id();
INTELLIPAP_Unknown2=schema::channel["IntUnk2"].id();
// OXI_Pulse=schema::channel["Pulse"].id();
// OXI_SPO2=schema::channel["SPO2"].id();
// OXI_PulseChange=schema::channel["PulseChange"].id();
// OXI_SPO2Drop=schema::channel["SPO2Drop"].id();
// OXI_Plethy=schema::channel["Plethy"].id();
// CPAP_AHI=schema::channel["AHI"].id();
// CPAP_RDI=schema::channel["RDI"].id();
Journal_Notes=schema::channel["Journal"].id();
Journal_Weight=schema::channel["Weight"].id();
Journal_BMI=schema::channel["BMI"].id();
Journal_ZombieMeter=schema::channel["ZombieMeter"].id();
Bookmark_Start=schema::channel["BookmarkStart"].id();
Bookmark_End=schema::channel["BookmarkEnd"].id();
Bookmark_Notes=schema::channel["BookmarkNotes"].id();
// CPAP_UserFlag1=schema::channel["UserFlag1"].id();
// CPAP_UserFlag2=schema::channel["UserFlag2"].id();
// CPAP_UserFlag3=schema::channel["UserFlag3"].id();
RMS9_E01 = schema::channel["RMS9_E01"].id();
RMS9_E02 = schema::channel["RMS9_E02"].id();
RMS9_EPR = schema::channel["EPR"].id();
RMS9_EPRSet = schema::channel["EPRSet"].id();
RMS9_SetPressure = schema::channel["SetPressure"].id();
PRS1_00 = schema::channel["PRS1_00"].id();
PRS1_01 = schema::channel["PRS1_01"].id();
PRS1_08 = schema::channel["PRS1_08"].id();
PRS1_0A = schema::channel["PRS1_0A"].id();
PRS1_0B = schema::channel["PRS1_0B"].id();
PRS1_0C = schema::channel["PRS1_0C"].id();
PRS1_0E = schema::channel["PRS1_0E"].id();
PRS1_0F = schema::channel["PRS1_0F"].id();
PRS1_10 = schema::channel["PRS1_10"].id();
PRS1_12 = schema::channel["PRS1_12"].id();
PRS1_FlexMode = schema::channel["FlexMode"].id();
PRS1_FlexSet = schema::channel["FlexSet"].id();
PRS1_HumidStatus = schema::channel["HumidStat"].id();
CPAP_HumidSetting = schema::channel["HumidSet"].id();
PRS1_SysLock = schema::channel["SysLock"].id();
PRS1_SysOneResistStat = schema::channel["SysOneResistStat"].id();
PRS1_SysOneResistSet = schema::channel["SysOneResistSet"].id();
PRS1_HoseDiam = schema::channel["HoseDiam"].id();
PRS1_AutoOn = schema::channel["AutoOn"].id();
PRS1_AutoOff = schema::channel["AutoOff"].id();
PRS1_MaskAlert = schema::channel["MaskAlert"].id();
PRS1_ShowAHI = schema::channel["ShowAHI"].id();
INTELLIPAP_Unknown1 = schema::channel["IntUnk1"].id();
INTELLIPAP_Unknown2 = schema::channel["IntUnk2"].id();
// OXI_Pulse=schema::channel["Pulse"].id();
// OXI_SPO2=schema::channel["SPO2"].id();
// OXI_PulseChange=schema::channel["PulseChange"].id();
// OXI_SPO2Drop=schema::channel["SPO2Drop"].id();
// OXI_Plethy=schema::channel["Plethy"].id();
// CPAP_AHI=schema::channel["AHI"].id();
// CPAP_RDI=schema::channel["RDI"].id();
Journal_Notes = schema::channel["Journal"].id();
Journal_Weight = schema::channel["Weight"].id();
Journal_BMI = schema::channel["BMI"].id();
Journal_ZombieMeter = schema::channel["ZombieMeter"].id();
Bookmark_Start = schema::channel["BookmarkStart"].id();
Bookmark_End = schema::channel["BookmarkEnd"].id();
Bookmark_Notes = schema::channel["BookmarkNotes"].id();
ZEO_SleepStage=schema::channel["SleepStage"].id();
ZEO_ZQ=schema::channel["ZeoZQ"].id();
ZEO_Awakenings=schema::channel["Awakenings"].id();
ZEO_MorningFeel=schema::channel["MorningFeel"].id();
ZEO_TimeInWake=schema::channel["TimeInWake"].id();
ZEO_TimeInREM=schema::channel["TimeInREM"].id();
ZEO_TimeInLight=schema::channel["TimeInLight"].id();
ZEO_TimeInDeep=schema::channel["TimeInDeep"].id();
ZEO_TimeToZ=schema::channel["TimeToZ"].id();
ZEO_SleepStage = schema::channel["SleepStage"].id();
ZEO_ZQ = schema::channel["ZeoZQ"].id();
ZEO_Awakenings = schema::channel["Awakenings"].id();
ZEO_MorningFeel = schema::channel["MorningFeel"].id();
ZEO_TimeInWake = schema::channel["TimeInWake"].id();
ZEO_TimeInREM = schema::channel["TimeInREM"].id();
ZEO_TimeInLight = schema::channel["TimeInLight"].id();
ZEO_TimeInDeep = schema::channel["TimeInDeep"].id();
ZEO_TimeToZ = schema::channel["TimeToZ"].id();
}
Channel::Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname, QString description, QString label, QString unit, DataType datatype, QColor color, int link):
Channel::Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname,
QString description, QString label, QString unit, DataType datatype, QColor color, int link):
m_id(id),
m_type(type),
m_scope(scope),
@ -326,16 +482,16 @@ Channel::Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QSt
}
bool Channel::isNull()
{
return (this==&EmptyChannel);
return (this == &EmptyChannel);
}
ChannelList::ChannelList()
:m_doctype("channels")
: m_doctype("channels")
{
}
ChannelList::~ChannelList()
{
for (QHash<ChannelID,Channel *>::iterator i=channels.begin();i!=channels.end();i++) {
for (QHash<ChannelID, Channel *>::iterator i = channels.begin(); i != channels.end(); i++) {
delete i.value();
}
}
@ -344,40 +500,47 @@ bool ChannelList::Load(QString filename)
QDomDocument doc(m_doctype);
QFile file(filename);
qDebug() << "Opening " << filename;
if (!file.open(QIODevice::ReadOnly)) {
qWarning() << "Could not open" << filename;
return false;
}
QString errorMsg;
int errorLine;
if (!doc.setContent(&file,false,&errorMsg,&errorLine)) {
if (!doc.setContent(&file, false, &errorMsg, &errorLine)) {
qWarning() << "Invalid XML Content in" << filename;
qWarning() << "Error line" << errorLine <<":" << errorMsg;
qWarning() << "Error line" << errorLine << ":" << errorMsg;
return false;
}
file.close();
QDomElement root=doc.documentElement();
QDomElement root = doc.documentElement();
if (root.tagName().toLower() != "channels") {
return false;
}
QString language=root.attribute("language","en");
QString version=root.attribute("version","");
QString language = root.attribute("language", "en");
QString version = root.attribute("version", "");
if (version.isEmpty()) {
qWarning() << "No Version Field in" << m_doctype << "Schema, assuming 1.0" << filename;
version="1.0";
version = "1.0";
}
qDebug() << "Processing xml file:" << m_doctype << language << version;
QDomNodeList grp=root.elementsByTagName("group");
QDomNode node,n,ch;
QDomNodeList grp = root.elementsByTagName("group");
QDomNode node, n, ch;
QDomElement e;
bool ok;
int id,linkid;
QString chantype,scopestr,typestr,name,group,idtxt,details,label,unit,datatypestr,defcolor,link;
int id, linkid;
QString chantype, scopestr, typestr, name, group, idtxt, details, label, unit, datatypestr,
defcolor, link;
ChanType type;
DataType datatype;
Channel *chan;
@ -385,121 +548,138 @@ bool ChannelList::Load(QString filename)
//bool multi;
ScopeType scope;
int line;
for (int i=0;i<grp.size();i++) {
node=grp.at(i);
group=node.toElement().attribute("name");
for (int i = 0; i < grp.size(); i++) {
node = grp.at(i);
group = node.toElement().attribute("name");
//qDebug() << "Group Name" << group;
// Why do I have to skip the first node here? (shows up empty)
n=node.firstChildElement();
n = node.firstChildElement();
while (!n.isNull()) {
line=n.lineNumber();
e=n.toElement();
line = n.lineNumber();
e = n.toElement();
if (e.nodeName().toLower()!="channel") {
qWarning() << "Ignoring unrecognized schema type "<< e.nodeName() << "in" << filename << "line" << line;
if (e.nodeName().toLower() != "channel") {
qWarning() << "Ignoring unrecognized schema type " << e.nodeName() << "in" << filename << "line" <<
line;
continue;
}
ch=n.firstChild();
n=n.nextSibling();
ch = n.firstChild();
n = n.nextSibling();
idtxt = e.attribute("id");
id = idtxt.toInt(&ok, 16);
idtxt=e.attribute("id");
id=idtxt.toInt(&ok,16);
if (!ok) {
qWarning() << "Dodgy ID number "<< e.nodeName() << "in" << filename << "line" << line;
qWarning() << "Dodgy ID number " << e.nodeName() << "in" << filename << "line" << line;
continue;
}
chantype=e.attribute("class","data").toLower();
chantype = e.attribute("class", "data").toLower();
if (!ChanTypes.contains(chantype)) {
qWarning() << "Dodgy class "<< chantype << "in" << filename << "line" << line;
qWarning() << "Dodgy class " << chantype << "in" << filename << "line" << line;
continue;
}
type=ChanTypes[chantype];
scopestr=e.attribute("scope","session");
if (scopestr.at(0)==QChar('!')) {
scopestr=scopestr.mid(1);
type = ChanTypes[chantype];
scopestr = e.attribute("scope", "session");
if (scopestr.at(0) == QChar('!')) {
scopestr = scopestr.mid(1);
//multi=true;
} //multi=false;
if (!Scopes.contains(scopestr)) {
qWarning() << "Dodgy Scope "<< scopestr << "in" << filename << "line" << line;
qWarning() << "Dodgy Scope " << scopestr << "in" << filename << "line" << line;
continue;
}
scope=Scopes[scopestr];
name=e.attribute("name","");
details=e.attribute("details","");
label=e.attribute("label","");
scope = Scopes[scopestr];
name = e.attribute("name", "");
details = e.attribute("details", "");
label = e.attribute("label", "");
if (name.isEmpty() || details.isEmpty() || label.isEmpty()) {
qWarning() << "Missing name,details or label attribute in" << filename << "line" << line;
continue;
}
unit=e.attribute("unit");
defcolor=e.attribute("color","black");
color=QColor(defcolor);
unit = e.attribute("unit");
defcolor = e.attribute("color", "black");
color = QColor(defcolor);
if (!color.isValid()) {
qWarning() << "Invalid Color "<< defcolor<< "in" << filename << "line" << line;
color=Qt::black;
qWarning() << "Invalid Color " << defcolor << "in" << filename << "line" << line;
color = Qt::black;
}
datatypestr=e.attribute("type","").toLower();
datatypestr = e.attribute("type", "").toLower();
link = e.attribute("link", "");
link=e.attribute("link","");
if (!link.isEmpty()) {
linkid=link.toInt(&ok,16);
linkid = link.toInt(&ok, 16);
if (!ok) {
qWarning() << "Dodgy Link ID number "<< e.nodeName() << "in" << filename << " line" << line;
qWarning() << "Dodgy Link ID number " << e.nodeName() << "in" << filename << " line" << line;
}
} else linkid=0;
} else { linkid = 0; }
if (DataTypes.contains(datatypestr)) {
datatype=DataTypes[typestr];
datatype = DataTypes[typestr];
} else {
qWarning() << "Ignoring unrecognized schema datatype in" << filename <<"line" << line;
qWarning() << "Ignoring unrecognized schema datatype in" << filename << "line" << line;
continue;
}
if (channels.contains(id)) {
qWarning() << "Schema already contains id" << id << "in" << filename <<"line" << line;
qWarning() << "Schema already contains id" << id << "in" << filename << "line" << line;
continue;
}
if (names.contains(name)) {
qWarning() << "Schema already contains name" << name << "in" << filename <<"line" << line;
qWarning() << "Schema already contains name" << name << "in" << filename << "line" << line;
continue;
}
chan=new Channel(id,type,scope,name,name,details,label,unit,datatype,color,linkid);
channels[id]=chan;
names[name]=chan;
chan = new Channel(id, type, scope, name, name, details, label, unit, datatype, color, linkid);
channels[id] = chan;
names[name] = chan;
//qDebug() << "Channel" << id << name << label;
groups[group][name]=chan;
if (linkid>0) {
groups[group][name] = chan;
if (linkid > 0) {
if (channels.contains(linkid)) {
Channel *it=channels[linkid];
Channel *it = channels[linkid];
it->m_links.push_back(chan);
//int i=0;
} else {
qWarning() << "Linked channel must be defined first in" << filename <<"line" << line;
qWarning() << "Linked channel must be defined first in" << filename << "line" << line;
}
}
// process children
while(!ch.isNull()) {
e=ch.toElement();
QString sub=ch.nodeName().toLower();
QString id2str,name2str;
while (!ch.isNull()) {
e = ch.toElement();
QString sub = ch.nodeName().toLower();
QString id2str, name2str;
int id2;
if (sub=="option") {
id2str=e.attribute("id");
id2=id2str.toInt(&ok,10);
name2str=e.attribute("value");
if (sub == "option") {
id2str = e.attribute("id");
id2 = id2str.toInt(&ok, 10);
name2str = e.attribute("value");
//qDebug() << sub << id2 << name2str;
chan->addOption(id2,name2str);
} else if (sub=="color") {
chan->addOption(id2, name2str);
} else if (sub == "color") {
}
ch=ch.nextSibling();
ch = ch.nextSibling();
}
}
}
@ -507,24 +687,28 @@ bool ChannelList::Load(QString filename)
return true;
}
void ChannelList::add(QString group,Channel * chan)
void ChannelList::add(QString group, Channel *chan)
{
Q_ASSERT(chan!=NULL);
Q_ASSERT(chan != NULL);
if (channels.contains(chan->id())) {
qWarning() << "Channels already contains id" << chan->id() << chan->code();
Q_ASSERT(false);
return;
}
if (names.contains(chan->code())) {
qWarning() << "Channels already contains name" << chan->id() << chan->code();
Q_ASSERT(false);
return;
}
channels[chan->id()]=chan;
names[chan->code()]=chan;
groups[group][chan->code()]=chan;
channels[chan->id()] = chan;
names[chan->code()] = chan;
groups[group][chan->code()] = chan;
if (channels.contains(chan->linkid())) {
Channel *it=channels[chan->linkid()];
Channel *it = channels[chan->linkid()];
it->m_links.push_back(chan);
//int i=0;
} else {

92
sleepyhead/SleepLib/schema.h
View File

@ -19,29 +19,29 @@
#include "machine_common.h"
namespace GraphFlags {
const quint32 Shadow=1;
const quint32 Foobar=2;
const quint32 XTicker=4;
const quint32 YTicker=8;
const quint32 XGrid=16;
const quint32 YGrid=32;
const quint32 Shadow = 1;
const quint32 Foobar = 2;
const quint32 XTicker = 4;
const quint32 YTicker = 8;
const quint32 XGrid = 16;
const quint32 YGrid = 32;
}
namespace schema {
enum Function {
NONE=0, AVG, WAVG, MIN, MAX, SUM, CNT, P90, CPH, SPH, HOURS, SET
NONE = 0, AVG, WAVG, MIN, MAX, SUM, CNT, P90, CPH, SPH, HOURS, SET
};
enum ChanType {
DATA=0, SETTING
DATA = 0, SETTING
};
enum DataType {
DEFAULT=0, INTEGER, BOOL, DOUBLE, STRING, RICHTEXT, DATE, TIME, DATETIME
DEFAULT = 0, INTEGER, BOOL, DOUBLE, STRING, RICHTEXT, DATE, TIME, DATETIME
};
enum ScopeType {
GLOBAL=0, MACHINE, DAY, SESSION
GLOBAL = 0, MACHINE, DAY, SESSION
};
class Channel;
extern Channel EmptyChannel;
@ -51,36 +51,40 @@ extern Channel EmptyChannel;
*/
class Channel
{
public:
Channel() { m_id=0; }
Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname, QString description, QString label, QString unit,DataType datatype=DEFAULT, QColor=Qt::black, int link=0);
void addColor(Function f, QColor color) { m_colors[f]=color; }
void addOption(int i, QString option) { m_options[i]=option; }
public:
Channel() { m_id = 0; }
Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname,
QString description, QString label, QString unit, DataType datatype = DEFAULT, QColor = Qt::black,
int link = 0);
void addColor(Function f, QColor color) { m_colors[f] = color; }
void addOption(int i, QString option) { m_options[i] = option; }
const int & id() { return m_id; }
const ChanType & type() { return m_type; }
const QString & code() { return m_code; }
const QString & fullname() { return m_fullname; }
const QString & description() { return m_description; }
const QString & label() { return m_label; }
const QString & units() { return m_unit; }
const int & linkid() { return m_link; }
const int &id() { return m_id; }
const ChanType &type() { return m_type; }
const QString &code() { return m_code; }
const QString &fullname() { return m_fullname; }
const QString &description() { return m_description; }
const QString &label() { return m_label; }
const QString &units() { return m_unit; }
const int &linkid() { return m_link; }
void setLabel(QString label) { m_label=label; }
void setUnit(QString unit) { m_unit=unit; }
void setDescription(QString desc) { m_description=desc; }
void setLabel(QString label) { m_label = label; }
void setUnit(QString unit) { m_unit = unit; }
void setDescription(QString desc) { m_description = desc; }
QString option(int i) {
if (m_options.contains(i))
if (m_options.contains(i)) {
return m_options[i];
}
return QString();
}
QColor & defaultColor() { return m_defaultcolor; }
void setDefaultColor(QColor color) { m_defaultcolor=color; }
QHash<int,QString> m_options;
QHash<Function,QColor> m_colors;
QColor &defaultColor() { return m_defaultcolor; }
void setDefaultColor(QColor color) { m_defaultcolor = color; }
QHash<int, QString> m_options;
QHash<Function, QColor> m_colors;
QList<Channel *> m_links; // better versions of this data type
bool isNull();
protected:
protected:
int m_id;
ChanType m_type;
ScopeType m_scope;
@ -101,7 +105,7 @@ protected:
*/
class ChannelList
{
public:
public:
ChannelList();
virtual ~ChannelList();
@ -111,31 +115,33 @@ public:
//! \brief Stores Channel list to XML file specified by filename
bool Save(QString filename);
void add(QString group,Channel * chan);
void add(QString group, Channel *chan);
//! \brief Looks up Channel in this List with the index idx, returns EmptyChannel if not found
Channel & operator[](ChannelID idx) {
if (channels.contains(idx))
Channel &operator[](ChannelID idx) {
if (channels.contains(idx)) {
return *channels[idx];
else
} else {
return EmptyChannel;
}
}
//! \brief Looks up Channel from this list by name, returns Empty Channel if not found.
Channel & operator[](QString name) {
if (names.contains(name))
Channel &operator[](QString name) {
if (names.contains(name)) {
return *names[name];
else
} else {
return EmptyChannel;
}
}
//! \brief Channel List indexed by integer ID
QHash<ChannelID,Channel *> channels;
QHash<ChannelID, Channel *> channels;
//! \brief Channel List index by name
QHash<QString,Channel *> names;
QHash<QString, Channel *> names;
//! \brief Channel List indexed by group
QHash<QString,QHash<QString,Channel *> > groups;
QHash<QString, QHash<QString, Channel *> > groups;
QString m_doctype;
};
extern ChannelList channel;

1486
sleepyhead/SleepLib/session.cpp
View File

File diff suppressed because it is too large Load Diff

147
sleepyhead/SleepLib/session.h
View File

@ -30,12 +30,12 @@ class Machine;
*/
class Session
{
public:
public:
/*! \fn Session(Machine *,SessionID);
\brief Create a session object belonging to Machine, with supplied SessionID
If sessionID is 0, the next in sequence will be picked
*/
Session(Machine *,SessionID);
Session(Machine *, SessionID);
virtual ~Session();
//! \brief Stores the session in the directory supplied by path
@ -62,10 +62,10 @@ public:
void TrashEvents();
//! \brief Search for Event code happening within dist milliseconds of supplied time (ms since epoch)
bool SearchEvent(ChannelID code, qint64 time, qint64 dist=15000);
bool SearchEvent(ChannelID code, qint64 time, qint64 dist = 15000);
//! \brief Return the sessionID
inline const SessionID & session() {
inline const SessionID &session() {
return s_session;
}
@ -83,46 +83,47 @@ public:
//! \brief Return the millisecond length of this session
qint64 length() {
return s_last-s_first;
return s_last - s_first;
}
//! \brief Set this Sessions ID (Not does not update indexes)
void SetSessionID(SessionID s) {
s_session=s;
s_session = s;
}
//! \brief Moves all of this session data by offset d milliseconds
void offsetSession(qint64 d);
//! \brief Just set the start of the timerange without comparing
void really_set_first(qint64 d) { s_first=d; }
void really_set_first(qint64 d) { s_first = d; }
//! \brief Just set the end of the timerange without comparing
void really_set_last(qint64 d) { s_last=d; }
void really_set_last(qint64 d) { s_last = d; }
void set_first(qint64 d) {
if (!s_first) s_first=d;
else if (d<s_first) s_first=d;
if (!s_first) { s_first = d; }
else if (d < s_first) { s_first = d; }
}
void set_last(qint64 d) {
if (d<=s_first) {
if (d <= s_first) {
qWarning() << "Session::set_last() d<=s_first";
return;
}
if (!s_last) s_last=d;
else if (s_last<d) s_last=d;
if (!s_last) { s_last = d; }
else if (s_last < d) { s_last = d; }
}
//! \brief Return Session Length in decimal hours
double hours() {
double t=(s_last-s_first)/3600000.0;
double t = (s_last - s_first) / 3600000.0;
return t;
}
//! \brief Flag this Session as dirty, so Machine object can save it
void SetChanged(bool val) {
s_changed=val;
s_events_loaded=val; // dirty hack putting this here
s_changed = val;
s_events_loaded = val; // dirty hack putting this here
}
//! \brief Return this Sessions dirty status
@ -131,33 +132,33 @@ public:
}
//! \brief Contains all the EventLists, indexed by ChannelID
QHash<ChannelID,QVector<EventList *> > eventlist;
QHash<ChannelID, QVector<EventList *> > eventlist;
//! \brief Sessions Settings List, contianing single settings for this session.
QHash<ChannelID,QVariant> settings;
QHash<ChannelID, QVariant> settings;
// Session caches
QHash<ChannelID,int> m_cnt;
QHash<ChannelID,double> m_sum;
QHash<ChannelID,EventDataType> m_avg;
QHash<ChannelID,EventDataType> m_wavg;
QHash<ChannelID, int> m_cnt;
QHash<ChannelID, double> m_sum;
QHash<ChannelID, EventDataType> m_avg;
QHash<ChannelID, EventDataType> m_wavg;
QHash<ChannelID,EventDataType> m_min; // The actual minimum
QHash<ChannelID,EventDataType> m_max;
QHash<ChannelID, EventDataType> m_min; // The actual minimum
QHash<ChannelID, EventDataType> m_max;
// This could go in channels, but different machines interpret it differently
// Under the new SleepyLib data Device model this can be done, but unfortunately not here..
QHash<ChannelID,EventDataType> m_physmin; // The physical minimum for graph display purposes
QHash<ChannelID,EventDataType> m_physmax; // The physical maximum
QHash<ChannelID, EventDataType> m_physmin; // The physical minimum for graph display purposes
QHash<ChannelID, EventDataType> m_physmax; // The physical maximum
QHash<ChannelID,EventDataType> m_cph; // Counts per hour (eg AHI)
QHash<ChannelID,EventDataType> m_sph; // % indice (eg % night in CSR)
QHash<ChannelID,quint64> m_firstchan;
QHash<ChannelID,quint64> m_lastchan;
QHash<ChannelID, EventDataType> m_cph; // Counts per hour (eg AHI)
QHash<ChannelID, EventDataType> m_sph; // % indice (eg % night in CSR)
QHash<ChannelID, quint64> m_firstchan;
QHash<ChannelID, quint64> m_lastchan;
QHash<ChannelID,QHash<EventStoreType, EventStoreType> > m_valuesummary;
QHash<ChannelID,QHash<EventStoreType, quint32> > m_timesummary;
QHash<ChannelID,EventDataType> m_gain;
QHash<ChannelID, QHash<EventStoreType, EventStoreType> > m_valuesummary;
QHash<ChannelID, QHash<EventStoreType, quint32> > m_timesummary;
QHash<ChannelID, EventDataType> m_gain;
//! \brief Generates sum and time data for each distinct value in 'code' events..
void updateCountSummary(ChannelID code);
@ -166,50 +167,54 @@ public:
void destroyEvent(ChannelID code);
// UpdateSummaries may recalculate all these, but it may be faster setting upfront
void setCount(ChannelID id,int val) { m_cnt[id]=val; }
void setSum(ChannelID id,EventDataType val) { m_sum[id]=val; }
void setMin(ChannelID id,EventDataType val) { m_min[id]=val; }
void setMax(ChannelID id,EventDataType val) { m_max[id]=val; }
void setPhysMin(ChannelID id,EventDataType val) { m_physmin[id]=val; }
void setPhysMax(ChannelID id,EventDataType val) { m_physmax[id]=val; }
void updateMin(ChannelID id,EventDataType val) {
QHash<ChannelID,EventDataType>::iterator i=m_min.find(id);
if (i==m_min.end())
m_min[id]=val;
else if (i.value() > val)
void setCount(ChannelID id, int val) { m_cnt[id] = val; }
void setSum(ChannelID id, EventDataType val) { m_sum[id] = val; }
void setMin(ChannelID id, EventDataType val) { m_min[id] = val; }
void setMax(ChannelID id, EventDataType val) { m_max[id] = val; }
void setPhysMin(ChannelID id, EventDataType val) { m_physmin[id] = val; }
void setPhysMax(ChannelID id, EventDataType val) { m_physmax[id] = val; }
void updateMin(ChannelID id, EventDataType val) {
QHash<ChannelID, EventDataType>::iterator i = m_min.find(id);
if (i == m_min.end()) {
m_min[id] = val;
} else if (i.value() > val) {
i.value() = val;
}
}
void updateMax(ChannelID id,EventDataType val) {
QHash<ChannelID,EventDataType>::iterator i=m_max.find(id);
if (i==m_max.end())
m_max[id]=val;
else if (i.value() < val)
void updateMax(ChannelID id, EventDataType val) {
QHash<ChannelID, EventDataType>::iterator i = m_max.find(id);
if (i == m_max.end()) {
m_max[id] = val;
} else if (i.value() < val) {
i.value() = val;
}
}
void setAvg(ChannelID id,EventDataType val) { m_avg[id]=val; }
void setWavg(ChannelID id,EventDataType val) { m_wavg[id]=val; }
// void setMedian(ChannelID id,EventDataType val) { m_med[id]=val; }
// void set90p(ChannelID id,EventDataType val) { m_90p[id]=val; }
// void set95p(ChannelID id,EventDataType val) { m_95p[id]=val; }
void setCph(ChannelID id,EventDataType val) { m_cph[id]=val; }
void setSph(ChannelID id,EventDataType val) { m_sph[id]=val; }
void setFirst(ChannelID id,qint64 val) { m_firstchan[id]=val; }
void setLast(ChannelID id,qint64 val) { m_lastchan[id]=val; }
void setAvg(ChannelID id, EventDataType val) { m_avg[id] = val; }
void setWavg(ChannelID id, EventDataType val) { m_wavg[id] = val; }
// void setMedian(ChannelID id,EventDataType val) { m_med[id]=val; }
// void set90p(ChannelID id,EventDataType val) { m_90p[id]=val; }
// void set95p(ChannelID id,EventDataType val) { m_95p[id]=val; }
void setCph(ChannelID id, EventDataType val) { m_cph[id] = val; }
void setSph(ChannelID id, EventDataType val) { m_sph[id] = val; }
void setFirst(ChannelID id, qint64 val) { m_firstchan[id] = val; }
void setLast(ChannelID id, qint64 val) { m_lastchan[id] = val; }
int count(ChannelID id);
//! \brief Returns the Count of all events of type id between time range
int rangeCount(ChannelID id, qint64 first,qint64 last);
int rangeCount(ChannelID id, qint64 first, qint64 last);
//! \brief Returns the Sum of all events of type id between time range
double rangeSum(ChannelID id, qint64 first,qint64 last);
double rangeSum(ChannelID id, qint64 first, qint64 last);
//! \brief Returns the minimum of events of type id between time range
EventDataType rangeMin(ChannelID id, qint64 first,qint64 last);
EventDataType rangeMin(ChannelID id, qint64 first, qint64 last);
//! \brief Returns the maximum of events of type id between time range
EventDataType rangeMax(ChannelID id, qint64 first,qint64 last);
EventDataType rangeMax(ChannelID id, qint64 first, qint64 last);
//! \brief Returns (and caches) the Sum of all events of type id
double sum(ChannelID id);
@ -248,7 +253,7 @@ public:
EventDataType sph(ChannelID id);
//! \brief Returns (without caching) the requested Percentile of all events of type id
EventDataType percentile(ChannelID id,EventDataType percentile);
EventDataType percentile(ChannelID id, EventDataType percentile);
//! \brief Returns true if the channel has events loaded, or a record of a count for when they are not
bool channelExists(ChannelID name);
@ -257,18 +262,18 @@ public:
bool channelDataExists(ChannelID id);
bool IsLoneSession() { return s_lonesession; }
void SetLoneSession(bool b) { s_lonesession=b; }
void SetLoneSession(bool b) { s_lonesession = b; }
bool eventsLoaded() { return s_events_loaded; }
//! \brief Sets the event file linked to the summary (during load, for ondemand loading)
void SetEventFile(QString & filename) { s_eventfile=filename; }
void SetEventFile(QString &filename) { s_eventfile = filename; }
//! \brief Update this sessions first time if it's less than the current record
inline void updateFirst(qint64 v) { if (!s_first) s_first=v; else if (s_first>v) s_first=v; }
inline void updateFirst(qint64 v) { if (!s_first) { s_first = v; } else if (s_first > v) { s_first = v; } }
//! \brief Update this sessions latest time if it's more than the current record
inline void updateLast(qint64 v) { if (!s_last) s_last=v; else if (s_last<v) s_last=v; }
inline void updateLast(qint64 v) { if (!s_last) { s_last = v; } else if (s_last < v) { s_last = v; } }
//! \brief Returns (and caches) the first time for Channel code
qint64 first(ChannelID code);
@ -280,11 +285,13 @@ public:
void UpdateSummaries();
//! \brief Creates and returns a new EventList for the supplied Channel code
EventList * AddEventList(ChannelID code, EventListType et, EventDataType gain=1.0, EventDataType offset=0.0, EventDataType min=0.0, EventDataType max=0.0, EventDataType rate=0.0, bool second_field=false);
EventList *AddEventList(ChannelID code, EventListType et, EventDataType gain = 1.0,
EventDataType offset = 0.0, EventDataType min = 0.0, EventDataType max = 0.0,
EventDataType rate = 0.0, bool second_field = false);
//! \brief Returns this sessions MachineID
Machine * machine() { return s_machine; }
protected:
Machine *machine() { return s_machine; }
protected:
SessionID s_session;
Machine *s_machine;