mirror of
https://gitlab.com/pholy/OSCAR-code.git
synced 2025-04-04 02:00:43 +00:00
987 lines
32 KiB
C++
987 lines
32 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
*
|
|
* gSummaryChart Implementation
|
|
*
|
|
* Copyright (c) 2011-2014 Mark Watkins <jedimark@users.sourceforge.net>
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file COPYING in the main directory of the Linux
|
|
* distribution for more details. */
|
|
|
|
#include <math.h>
|
|
#include <QLabel>
|
|
#include <QDateTime>
|
|
#include "gYAxis.h"
|
|
#include "gSummaryChart.h"
|
|
|
|
extern QLabel * qstatus2;
|
|
SummaryChart::SummaryChart(QString label,GraphType type)
|
|
:Layer(NoChannel),m_label(label),m_graphtype(type)
|
|
{
|
|
//QColor color=Qt::black;
|
|
addVertexBuffer(quads=new gVertexBuffer(20000,GL_QUADS));
|
|
addVertexBuffer(lines=new gVertexBuffer(20000,GL_LINES));
|
|
addVertexBuffer(outlines=new gVertexBuffer(20000,GL_LINES));
|
|
addVertexBuffer(points=new gVertexBuffer(20000,GL_POINTS));
|
|
quads->forceAntiAlias(true);
|
|
|
|
outlines->setSize(1);
|
|
|
|
//lines->setBlendFunc(GL_SRC_COLOR, GL_ZERO);
|
|
//lines->forceAntiAlias(false);
|
|
|
|
m_empty=true;
|
|
hl_day=-1;
|
|
m_machinetype=MT_CPAP;
|
|
|
|
QDateTime d1=QDateTime::currentDateTime();
|
|
QDateTime d2=d1;
|
|
d1.setTimeSpec(Qt::UTC);
|
|
tz_offset=d2.secsTo(d1);
|
|
tz_hours=tz_offset/3600.0;
|
|
|
|
}
|
|
SummaryChart::~SummaryChart()
|
|
{
|
|
}
|
|
void SummaryChart::SetDay(Day * nullday)
|
|
{
|
|
Day * day=nullday;
|
|
Layer::SetDay(day);
|
|
|
|
m_values.clear();
|
|
m_times.clear();
|
|
m_days.clear();
|
|
m_hours.clear();
|
|
m_goodcodes.clear();
|
|
m_miny=999999999;
|
|
m_maxy=-999999999;
|
|
m_physmaxy=0;
|
|
m_physminy=0;
|
|
m_minx=0;
|
|
m_maxx=0;
|
|
|
|
|
|
int dn;
|
|
EventDataType tmp,tmp2,total;
|
|
ChannelID code;
|
|
CPAPMode cpapmode=(CPAPMode)(int)PROFILE.calcSettingsMax(CPAP_Mode,MT_CPAP,PROFILE.FirstDay(MT_CPAP),PROFILE.LastDay(MT_CPAP));
|
|
if (m_label==STR_TR_Pressure) {
|
|
m_codes.clear();
|
|
m_colors.clear();
|
|
m_type.clear();
|
|
m_typeval.clear();
|
|
|
|
float perc=PROFILE.general->prefCalcPercentile()/100.0;
|
|
int mididx=PROFILE.general->prefCalcMiddle();
|
|
SummaryType mid;
|
|
if (mididx==0) mid=ST_PERC;
|
|
if (mididx==1) mid=ST_WAVG;
|
|
if (mididx==2) mid=ST_AVG;
|
|
|
|
if (cpapmode>=MODE_ASV) {
|
|
addSlice(CPAP_EPAP,QColor("green"),ST_SETMIN);
|
|
|
|
addSlice(CPAP_IPAPLo,QColor("light blue"),ST_SETMIN);
|
|
addSlice(CPAP_IPAP,QColor("cyan"),mid,0.5);
|
|
addSlice(CPAP_IPAP,QColor("dark cyan"),ST_PERC,perc);
|
|
//addSlice(CPAP_IPAP,QColor("light blue"),ST_PERC,0.95);
|
|
addSlice(CPAP_IPAPHi,QColor("blue"),ST_SETMAX);
|
|
} else if (cpapmode>=MODE_BIPAP) {
|
|
addSlice(CPAP_EPAP,QColor("green"),ST_SETMIN);
|
|
addSlice(CPAP_EPAP,QColor("light green"),ST_PERC,perc);
|
|
addSlice(CPAP_IPAP,QColor("light cyan"),mid,0.5);
|
|
addSlice(CPAP_IPAP,QColor("light blue"),ST_PERC,perc);
|
|
addSlice(CPAP_IPAP,QColor("blue"),ST_SETMAX);
|
|
} else if (cpapmode>=MODE_APAP) {
|
|
addSlice(CPAP_PressureMin,QColor("orange"),ST_SETMIN);
|
|
addSlice(CPAP_Pressure,QColor("dark green"),mid,0.5);
|
|
addSlice(CPAP_Pressure,QColor("grey"),ST_PERC,perc);
|
|
addSlice(CPAP_PressureMax,QColor("red"),ST_SETMAX);
|
|
} else {
|
|
addSlice(CPAP_Pressure,QColor("dark green"),ST_SETWAVG);
|
|
}
|
|
}
|
|
|
|
m_goodcodes.resize(m_codes.size());
|
|
for (int i=0;i<m_codes.size();i++) {
|
|
m_goodcodes[i]=false;
|
|
}
|
|
|
|
m_fday=0;
|
|
qint64 tt,zt;
|
|
m_empty=true;
|
|
if (m_graphtype==GT_SESSIONS) {
|
|
if (PROFILE.countDays(MT_CPAP,PROFILE.FirstDay(MT_CPAP), PROFILE.LastDay(MT_CPAP))==0)
|
|
return;
|
|
}
|
|
int suboffset;
|
|
SummaryType type;
|
|
bool first=true;
|
|
|
|
for (QMap<QDate,QList<Day *> >::iterator d=PROFILE.daylist.begin();d!=PROFILE.daylist.end();d++) {
|
|
tt=QDateTime(d.key(),QTime(0,0,0),Qt::UTC).toTime_t();
|
|
dn=tt/86400;
|
|
tt*=1000L;
|
|
if (!m_minx || tt<m_minx) m_minx=tt;
|
|
if (!m_maxx || tt>m_maxx) m_maxx=tt;
|
|
|
|
total=0;
|
|
bool fnd=false;
|
|
if (m_graphtype==GT_SESSIONS) {
|
|
for (int i=0;i<m_codes.size();i++)
|
|
m_goodcodes[i]=true;
|
|
for (int i=0;i<d.value().size();i++) { // for each day
|
|
day=d.value().at(i);
|
|
if (!day) continue;
|
|
if (day->machine_type()!=m_machinetype) continue;
|
|
int ft=qint64(day->first())/1000L;
|
|
ft+=tz_offset; // convert to local time
|
|
|
|
int dz2=ft/86400;
|
|
dz2*=86400; // ft = first sessions time, rounded back to midnight..
|
|
|
|
for (int s=0;s<day->size();s++) {
|
|
Session *sess=(*day)[s];
|
|
if (!sess->enabled()) continue;
|
|
|
|
tmp=sess->hours();
|
|
m_values[dn][s]=tmp;
|
|
total+=tmp;
|
|
zt=qint64(sess->first())/1000L;
|
|
zt+=tz_offset;
|
|
tmp2=zt-dn*86400;
|
|
tmp2/=3600.0;
|
|
|
|
m_times[dn][s]=tmp2;
|
|
|
|
if (first) {
|
|
m_miny=tmp2;
|
|
m_maxy=tmp2+tmp;
|
|
first=false;
|
|
} else {
|
|
if (tmp2 < m_miny)
|
|
m_miny=tmp2;
|
|
if (tmp2+tmp > m_maxy)
|
|
m_maxy=tmp2+tmp;
|
|
}
|
|
}
|
|
if (total>0) {
|
|
m_days[dn]=day;
|
|
m_hours[dn]=total;
|
|
m_empty=false;
|
|
}
|
|
}
|
|
} else {
|
|
for (int j=0;j<m_codes.size();j++) { // for each code slice
|
|
code=m_codes[j];
|
|
suboffset=0;
|
|
type=m_type[j];
|
|
EventDataType typeval=m_typeval[j];
|
|
for (int i=0;i<d.value().size();i++) { // for each machine object for this day
|
|
day=d.value()[i];
|
|
CPAPMode mode=(CPAPMode)(int)day->settings_max(CPAP_Mode);
|
|
if (day->machine_type()!=m_machinetype) continue;
|
|
|
|
bool hascode=//day->channelHasData(code) ||
|
|
type==ST_HOURS ||
|
|
type==ST_SESSIONS ||
|
|
day->settingExists(code) ||
|
|
day->hasData(code,type);
|
|
|
|
if (code==CPAP_Pressure) {
|
|
if ((cpapmode>MODE_CPAP) && (mode==MODE_CPAP)) {
|
|
hascode=false;
|
|
if ((type==ST_WAVG) || (type==ST_AVG) || ((type==ST_PERC) && (typeval==0.5))) {
|
|
type=ST_SETWAVG;
|
|
hascode=true;
|
|
}
|
|
} else {
|
|
type=m_type[j];
|
|
}
|
|
}
|
|
|
|
//if (code==CPAP_Hypopnea) { // Make sure at least one of the CPAP data gets through with 0
|
|
// hascode=true;
|
|
//}
|
|
if (hascode) {
|
|
m_days[dn]=day;
|
|
switch(type) {
|
|
case ST_AVG: tmp=day->avg(code); break;
|
|
case ST_SUM: tmp=day->sum(code); break;
|
|
case ST_WAVG: tmp=day->wavg(code); break;
|
|
case ST_90P: tmp=day->p90(code); break;
|
|
case ST_PERC: tmp=day->percentile(code,typeval); break;
|
|
case ST_MIN: tmp=day->Min(code); break;
|
|
case ST_MAX: tmp=day->Max(code); break;
|
|
case ST_CNT: tmp=day->count(code); break;
|
|
case ST_CPH: tmp=day->cph(code); break;
|
|
case ST_SPH: tmp=day->sph(code); break;
|
|
case ST_HOURS: tmp=day->hours(); break;
|
|
case ST_SESSIONS: tmp=day->size(); break;
|
|
case ST_SETMIN: tmp=day->settings_min(code); break;
|
|
case ST_SETMAX: tmp=day->settings_max(code); break;
|
|
case ST_SETAVG: tmp=day->settings_avg(code); break;
|
|
case ST_SETWAVG: tmp=day->settings_wavg(code); break;
|
|
case ST_SETSUM: tmp=day->settings_sum(code); break;
|
|
default:
|
|
tmp=0;
|
|
break;
|
|
}
|
|
if (suboffset>0) {
|
|
tmp-=suboffset;
|
|
if (tmp<0) tmp=0;
|
|
}
|
|
total+=tmp;
|
|
m_values[dn][j+1]=tmp;
|
|
if (tmp<m_miny) m_miny=tmp;
|
|
if (tmp>m_maxy) m_maxy=tmp;
|
|
m_goodcodes[j]=true;
|
|
fnd=true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (fnd) {
|
|
if (!m_fday) m_fday=dn;
|
|
m_values[dn][0]=total;
|
|
m_hours[dn]=day->hours();
|
|
if (m_graphtype==GT_BAR) {
|
|
if (total<m_miny) m_miny=total;
|
|
if (total>m_maxy) m_maxy=total;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_empty=true;
|
|
for (int i=0;i<m_goodcodes.size();i++) {
|
|
if (m_goodcodes[i]) {
|
|
m_empty=false;
|
|
break;
|
|
}
|
|
}
|
|
if (m_graphtype==GT_BAR) {
|
|
m_miny=0;
|
|
}
|
|
// m_minx=qint64(QDateTime(PROFILE.FirstDay(),QTime(0,0,0),Qt::UTC).toTime_t())*1000L;
|
|
m_maxx=qint64(QDateTime(PROFILE.LastDay(),QTime(23,59,0),Qt::UTC).toTime_t())*1000L;
|
|
m_physmaxy=m_maxy;
|
|
m_physminy=m_miny;
|
|
}
|
|
|
|
QColor brighten(QColor color)
|
|
{
|
|
int cr,cg,cb;
|
|
|
|
cr=color.red();
|
|
cg=color.green();
|
|
cb=color.blue();
|
|
|
|
if (cr<64) cr=64;
|
|
if (cg<64) cg=64;
|
|
if (cb<64) cb=64;
|
|
|
|
cr*=2;
|
|
cg*=2;
|
|
cb*=2;
|
|
|
|
if (cr>255) cr=255;
|
|
if (cg>255) cg=255;
|
|
if (cb>255) cb=255;
|
|
|
|
return QColor(cr,cg,cb,255);
|
|
|
|
}
|
|
|
|
void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
|
|
{
|
|
if (!m_visible) return;
|
|
|
|
points->setSize(10);
|
|
|
|
|
|
GraphType graphtype=m_graphtype;
|
|
|
|
if (graphtype==GT_LINE || graphtype==GT_POINTS) {
|
|
bool pts=PROFILE.appearance->overviewLinechartMode()==OLC_Lines;
|
|
graphtype=pts ? GT_POINTS : GT_LINE;
|
|
}
|
|
|
|
if (graphtype==GT_POINTS) {
|
|
lines->setSize(4);
|
|
} else
|
|
lines->setSize(1.5);
|
|
|
|
|
|
rtop=top;
|
|
gVertexBuffer *outlines2=w.lines();
|
|
// outlines2->setColor(Qt::black);
|
|
outlines2->add(left, top, left, top+height, left, top+height, left+width,top+height,QColor("black").rgba());
|
|
outlines2->add(left+width,top+height, left+width, top, left+width, top, left, top,QColor("black").rgba());
|
|
//if (outlines->full()) qDebug() << "WTF??? Outlines full in SummaryChart::paint()";
|
|
|
|
qint64 minx=w.min_x, maxx=w.max_x;
|
|
qint64 xx=maxx - minx;
|
|
float days=double(xx)/86400000.0;
|
|
|
|
|
|
EventDataType maxy;
|
|
EventDataType miny;
|
|
|
|
if (w.zoomY()==0 && PROFILE.appearance->allowYAxisScaling()) {
|
|
maxy=m_physmaxy;
|
|
miny=m_physminy;
|
|
w.roundY(miny,maxy);
|
|
} else {
|
|
maxy=m_maxy;
|
|
miny=m_miny;
|
|
w.roundY(miny,maxy);
|
|
}
|
|
|
|
EventDataType yy=maxy-miny;
|
|
EventDataType ymult=float(height-2)/yy;
|
|
|
|
barw=(float(width)/float(days));
|
|
|
|
float dpr=w.graphView()->devicePixelRatio();
|
|
|
|
graph=&w;
|
|
float px=left;
|
|
l_left=w.marginLeft()+gYAxis::Margin;
|
|
l_top=w.marginTop();
|
|
l_width=width;
|
|
l_height=height;
|
|
float py;
|
|
EventDataType total;
|
|
|
|
int daynum=0;
|
|
EventDataType h,tmp,tmp2;
|
|
|
|
|
|
l_offset=(minx) % 86400000L;
|
|
offset=float(l_offset)/86400000.0;
|
|
|
|
offset*=barw;
|
|
px=left-offset;
|
|
l_minx=minx;
|
|
l_maxx=maxx+86400000L;
|
|
|
|
int total_days=0;
|
|
double total_val=0;
|
|
double total_hours=0;
|
|
bool lastdaygood=false;
|
|
QVector<double> totalcounts;
|
|
QVector<double> totalvalues;
|
|
QVector<float> lastX;
|
|
QVector<short> lastY;
|
|
int numcodes=m_codes.size();
|
|
totalcounts.resize(numcodes);
|
|
totalvalues.resize(numcodes);
|
|
lastX.resize(numcodes);
|
|
lastY.resize(numcodes);
|
|
int zd=minx/86400000L;
|
|
zd--;
|
|
QHash<int,QHash<short,EventDataType> >::iterator d=m_values.find(zd);
|
|
|
|
QVector<bool> goodcodes;
|
|
goodcodes.resize(m_goodcodes.size());
|
|
|
|
points->setSize(5.0*dpr);
|
|
lastdaygood=true;
|
|
for (int i=0;i<numcodes;i++) {
|
|
totalcounts[i]=0;
|
|
|
|
// Set min and max to the opposite largest starting value
|
|
if ((m_type[i]==ST_MIN) || (m_type[i]==ST_SETMIN)) {
|
|
totalvalues[i]=maxy;
|
|
} else if ((m_type[i]==ST_MAX) || (m_type[i]==ST_SETMAX)) {
|
|
totalvalues[i]=miny;
|
|
} else {
|
|
totalvalues[i]=0;
|
|
}
|
|
// Turn off legend display.. It will only display if it's turned back on during draw.
|
|
goodcodes[i]=false;
|
|
|
|
if (!m_goodcodes[i]) continue;
|
|
|
|
lastX[i]=px;
|
|
if (d!=m_values.end() && d.value().contains(i+1)) {
|
|
|
|
tmp=d.value()[i+1];
|
|
h=tmp*ymult;
|
|
} else {
|
|
lastdaygood=false;
|
|
h=0;
|
|
}
|
|
lastY[i]=top+height-1-h;
|
|
}
|
|
float compliance_hours=0;
|
|
if (PROFILE.cpap->showComplianceInfo()) {
|
|
compliance_hours=PROFILE.cpap->complianceHours();
|
|
}
|
|
|
|
int incompliant=0;
|
|
Day * day;
|
|
EventDataType hours;
|
|
|
|
//quint32 * tptr;
|
|
//EventStoreType * dptr;
|
|
|
|
short px2,py2;
|
|
const qint64 ms_per_day=86400000L;
|
|
for (qint64 Q=minx;Q<=maxx+ms_per_day;Q+=ms_per_day) {
|
|
zd=Q/ms_per_day;
|
|
d=m_values.find(zd);
|
|
|
|
if (Q<minx)
|
|
goto jumpnext;
|
|
|
|
if (d!=m_values.end()) {
|
|
day=m_days[zd];
|
|
if (!m_hours.contains(zd))
|
|
goto jumpnext;
|
|
|
|
hours=m_hours[zd];
|
|
|
|
int x1=px;
|
|
//x1-=(barw/2.0);
|
|
int x2=px+barw;
|
|
|
|
if (x1<left) x1=left;
|
|
if (x2>left+width) x2=left+width;
|
|
// if (x2<x1)
|
|
// goto jumpnext;
|
|
|
|
|
|
if (zd==hl_day) {
|
|
QColor col=QColor("red");
|
|
col.setAlpha(64);
|
|
if (graphtype!=GT_POINTS) {
|
|
quads->add(x1-1,top,x1-1,top+height,x2,top+height,x2,top,col.rgba());
|
|
} else {
|
|
quads->add((x1+barw/2)-5,top,(x1+barw/2)-5,top+height,(x2-barw/2)+5,top+height,(x2-barw/2)+5,top,col.rgba());
|
|
}
|
|
}
|
|
|
|
if (graphtype==GT_SESSIONS) {
|
|
int j;
|
|
QHash<int,QHash<short,EventDataType> >::iterator times=m_times.find(zd);
|
|
QColor col=m_colors[0];
|
|
//if (hours<compliance_hours) col=QColor("#f03030");
|
|
|
|
if (zd==hl_day) {
|
|
col=QColor("gold");
|
|
}
|
|
GLuint col1=col.rgba();
|
|
GLuint col2=brighten(col).rgba();
|
|
//outlines->setColor(Qt::black);
|
|
|
|
int np=d.value().size();
|
|
if (np > 0) {
|
|
for (int i=0;i<goodcodes.size();i++) {
|
|
goodcodes[i]=true;
|
|
}
|
|
}
|
|
for (j=0;j < np;j++) {
|
|
tmp2=times.value()[j]-miny;
|
|
py=top+height-(tmp2*ymult);
|
|
|
|
tmp=d.value()[j]; // length
|
|
|
|
//tmp-=miny;
|
|
h=tmp*ymult;
|
|
|
|
quads->add(x1,py,x1,py-h,x2,py-h,x2,py,col1,col2);
|
|
if (h>0 && barw>2) {
|
|
outlines->add(x1,py,x1,py-h,x1,py-h,x2,py-h,QColor("black").rgba());
|
|
outlines->add(x1,py,x2,py,x2,py,x2,py-h,QColor("black").rgba());
|
|
}
|
|
totalvalues[0]+=hours*tmp;
|
|
}
|
|
totalcounts[0]+=hours;
|
|
totalvalues[1]+=j;
|
|
totalcounts[1]++;
|
|
total_val+=hours;
|
|
total_hours+=hours;
|
|
total_days++;
|
|
} else {
|
|
if (!d.value().contains(0))
|
|
goto jumpnext;
|
|
total=d.value()[0];
|
|
//if (total>0) {
|
|
if (day) {
|
|
EventDataType hours=m_hours[zd];
|
|
total_val+=total*hours;
|
|
total_hours+=hours;
|
|
total_days++;
|
|
}
|
|
py=top+height;
|
|
|
|
//}
|
|
bool good;
|
|
SummaryType type;
|
|
for (QHash<short,EventDataType>::iterator g=d.value().begin();g!=d.value().end();g++) {
|
|
short j=g.key();
|
|
if (!j) continue;
|
|
j--;
|
|
good=m_goodcodes[j];
|
|
if (!good)
|
|
continue;
|
|
|
|
type=m_type[j];
|
|
// code was actually used (to signal the display of the legend summary)
|
|
goodcodes[j]=good;
|
|
|
|
tmp=g.value();
|
|
|
|
QColor col=m_colors[j];
|
|
if (type==ST_HOURS) {
|
|
if (tmp<compliance_hours) {
|
|
col=QColor("#f04040");
|
|
incompliant++;
|
|
}
|
|
}
|
|
|
|
if (zd==hl_day) {
|
|
col=QColor("gold");
|
|
}
|
|
|
|
//if (!tmp) continue;
|
|
if ((type==ST_MAX) || (type==ST_SETMAX)) {
|
|
if (totalvalues[j]<tmp)
|
|
totalvalues[j]=tmp;
|
|
} else if ((type==ST_MIN) || (type==ST_SETMIN)) {
|
|
if (totalvalues[j]>tmp)
|
|
totalvalues[j]=tmp;
|
|
} else {
|
|
totalvalues[j]+=tmp*hours;
|
|
}
|
|
//if (tmp) {
|
|
totalcounts[j]+=hours;
|
|
//}
|
|
tmp-=miny;
|
|
h=tmp*ymult; // height in pixels
|
|
|
|
if (graphtype==GT_BAR) {
|
|
GLuint col1=col.rgba();
|
|
GLuint col2=brighten(col).rgba();
|
|
|
|
quads->add(x1,py,x1,py-h,col1);
|
|
quads->add(x2,py-h,x2,py,col2);
|
|
if (h>0 && barw>2) {
|
|
outlines->add(x1,py,x1,py-h,x1,py-h,x2,py-h,QColor("black").rgba());
|
|
outlines->add(x1,py,x2,py,x2,py,x2,py-h,QColor("black").rgba());
|
|
if (outlines->full()) qDebug() << "WTF??? Outlines full in SummaryChart::paint()";
|
|
} // if (bar
|
|
py-=h;
|
|
} else if (graphtype==GT_LINE) { // if (m_graphtype==GT_BAR
|
|
GLuint col1=col.rgba();
|
|
GLuint col2=m_colors[j].rgba();
|
|
px2=px+barw;
|
|
py2=(top+height-2)-h;
|
|
|
|
// If more than 1 day between records, skip the vertical crud.
|
|
if ((px2-lastX[j])>barw+1) {
|
|
lastdaygood=false;
|
|
}
|
|
if (lastdaygood) {
|
|
if (lastY[j]!=py2) {// vertical line
|
|
lines->add(lastX[j],lastY[j],px,py2,col2);
|
|
}
|
|
lines->add(px-1,py2,px2+1,py2,col1);
|
|
} else {
|
|
lines->add(x1-1,py2,x2+1,py2,col1);
|
|
}
|
|
lastX[j]=px2;
|
|
lastY[j]=py2;
|
|
} else if (graphtype==GT_POINTS) {
|
|
GLuint col1=col.rgba();
|
|
GLuint col2=m_colors[j].rgba();
|
|
px2=px+barw;
|
|
py2=(top+height-2)-h;
|
|
|
|
// If more than 1 day between records, skip the vertical crud.
|
|
if ((px2-lastX[j])>barw+1) {
|
|
lastdaygood=false;
|
|
}
|
|
|
|
if (zd==hl_day) {
|
|
points->add(px2-barw/2,py2,col2);
|
|
}
|
|
|
|
if (lastdaygood) {
|
|
lines->add(lastX[j]-barw/2,lastY[j],px2-barw/2,py2,col2);
|
|
} else {
|
|
lines->add(px+barw/2-1,py2,px+barw/2+1,py2,col1);
|
|
}
|
|
lastX[j]=px2;
|
|
lastY[j]=py2;
|
|
}
|
|
} // for(QHash<short
|
|
}
|
|
lastdaygood=true;
|
|
// if (Q>maxx+extra) break;
|
|
} else {
|
|
if (Q<maxx)
|
|
incompliant++;
|
|
lastdaygood=false;
|
|
}
|
|
jumpnext:
|
|
if (px>=left+width+barw)
|
|
break;
|
|
px+=barw;
|
|
|
|
daynum++;
|
|
//lastQ=Q;
|
|
}
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
|
|
quads->scissor(left*dpr,w.flipY(top+height+2)*dpr,(width)*dpr,(height+1)*dpr);
|
|
lines->scissor(left*dpr,w.flipY(top+height+2)*dpr,(width+1)*dpr,(height+1)*dpr);
|
|
outlines->scissor(left*dpr,w.flipY(top+height+2)*dpr,(width)*dpr,(height+1)*dpr);
|
|
#else
|
|
lines->scissor(left,w.flipY(top+height+2),width+1,height+2);
|
|
outlines->scissor(left,w.flipY(top+height+2),width,height+2);
|
|
quads->scissor(left,w.flipY(top+height+2),width,height+2);
|
|
#endif
|
|
// Draw Ledgend
|
|
px=left+width-3;
|
|
py=top-5;
|
|
int legendx=px;
|
|
QString a,b;
|
|
int x,y;
|
|
|
|
QFontMetrics fm(*defaultfont);
|
|
int bw=fm.width('X');
|
|
int bh=fm.height()/1.8;
|
|
|
|
bool ishours=false;
|
|
int good=0;
|
|
for (int j=0;j<m_codes.size();j++) {
|
|
if (!goodcodes[j]) continue;
|
|
good++;
|
|
SummaryType type=m_type[j];
|
|
ChannelID code=m_codes[j];
|
|
EventDataType tval=m_typeval[j];
|
|
switch(type) {
|
|
case ST_WAVG: b="Avg"; break;
|
|
case ST_AVG: b="Avg"; break;
|
|
case ST_90P: b="90%"; break;
|
|
case ST_PERC:
|
|
if (tval>=0.99) b="Max";
|
|
else if (tval==0.5) b="Med";
|
|
else b=QString("%1%").arg(tval*100.0,0,'f',0);
|
|
break;
|
|
//b=QString("%1%").arg(tval*100.0,0,'f',0); break;
|
|
case ST_MIN: b="Min"; break;
|
|
case ST_MAX: b="Max"; break;
|
|
case ST_SETMIN: b="Min"; break;
|
|
case ST_SETMAX: b="Max"; break;
|
|
case ST_CPH: b=""; break;
|
|
case ST_SPH: b="%"; break;
|
|
case ST_HOURS: b=STR_UNIT_Hours; break;
|
|
case ST_SESSIONS: b="Sessions"; break;
|
|
|
|
default:
|
|
b="";
|
|
break;
|
|
}
|
|
a=schema::channel[code].label();
|
|
if (a==w.title() && !b.isEmpty()) a=b; else a+=" "+b;
|
|
|
|
QString val;
|
|
float f=0;
|
|
if (totalcounts[j]>0) {
|
|
if ((type==ST_MIN) || (type==ST_MAX) || (type==ST_SETMIN) || (type==ST_SETMAX)) {
|
|
f=totalvalues[j];
|
|
} else {
|
|
f=totalvalues[j]/totalcounts[j];
|
|
}
|
|
}
|
|
if (type==ST_HOURS) {
|
|
int h=f;
|
|
int m=int(f*60) % 60;
|
|
val.sprintf("%02i:%02i",h,m);
|
|
ishours=true;
|
|
} else {
|
|
val=QString::number(f,'f',2);
|
|
}
|
|
a+="="+val;
|
|
//GetTextExtent(a,x,y);
|
|
//float wt=20*w.printScaleX();
|
|
//px-=wt+x;
|
|
//w.renderText(a,px+wt,py+1);
|
|
//quads->add(px+wt-y/4-y,py-y,px+wt-y/4,py-y,px+wt-y/4,py+1,px+wt-y/4-y,py+1,m_colors[j].rgba());
|
|
|
|
|
|
//QString text=schema::channel[code].label();
|
|
|
|
int wid,hi;
|
|
GetTextExtent(a,wid,hi);
|
|
legendx-=wid;
|
|
w.renderText(a,legendx,top-4);
|
|
// legendx-=bw/2;
|
|
|
|
int tp=top-5-bh/2;
|
|
w.quads()->add(legendx-bw,tp+bh/2,legendx,tp+bh/2,legendx,tp-bh/2,legendx-bw,tp-bh/2,m_colors[j].rgba());
|
|
legendx-=bw*2;
|
|
|
|
|
|
//lines->add(px,py,px+20,py,m_colors[j]);
|
|
//lines->add(px,py+1,px+20,py+1,m_colors[j]);
|
|
}
|
|
if ((m_graphtype==GT_BAR) && (good>0)) {
|
|
|
|
if (m_type.size()>1) {
|
|
float val=total_val/float(total_hours);
|
|
a=m_label+"="+QString::number(val,'f',2)+" ";
|
|
GetTextExtent(a,x,y);
|
|
legendx-=x;
|
|
w.renderText(a,legendx,py+1);
|
|
}
|
|
}
|
|
|
|
a="";
|
|
/*if (m_graphtype==GT_BAR) {
|
|
if (m_type.size()>1) {
|
|
float val=total_val/float(total_days);
|
|
a+=m_label+"="+QString::number(val,'f',2)+" ";
|
|
//
|
|
}
|
|
}*/
|
|
a+="Days="+QString::number(total_days,'f',0);
|
|
if (PROFILE.cpap->showComplianceInfo()) {
|
|
if (ishours && incompliant>0) {
|
|
a+=" Low Usage Days="+QString::number(incompliant,'f',0)+" (%"+QString::number((1.0/daynum)*(total_days-incompliant)*100.0,'f',2)+" compliant, defined as >"+QString::number(compliance_hours,'f',1)+" hours)";
|
|
}
|
|
}
|
|
|
|
|
|
//GetTextExtent(a,x,y);
|
|
//legendx-=30+x;
|
|
//w.renderText(a,px+24,py+5);
|
|
w.renderText(a,left,py+1);
|
|
}
|
|
|
|
QString formatTime(EventDataType v, bool show_seconds=false, bool duration=false,bool show_12hr=false)
|
|
{
|
|
int h=int(v);
|
|
|
|
if (!duration) {
|
|
h%=24;
|
|
} else show_12hr=false;
|
|
|
|
int m=int(v*60) % 60;
|
|
int s=int(v*3600) % 60;
|
|
|
|
char pm[3]={"am"};
|
|
|
|
if (show_12hr) {
|
|
h>=12 ? pm[0]='p' : pm[0]='a';
|
|
h %= 12;
|
|
if (h==0) h=12;
|
|
|
|
} else {
|
|
pm[0]=0;
|
|
}
|
|
if (show_seconds)
|
|
return QString().sprintf("%i:%02i:%02i%s",h,m,s,pm);
|
|
else
|
|
return QString().sprintf("%i:%02i%s",h,m,pm);
|
|
}
|
|
|
|
bool SummaryChart::mouseMoveEvent(QMouseEvent *event,gGraph * graph)
|
|
{
|
|
int x=event->x();
|
|
int y=event->y();
|
|
|
|
if (!m_rect.contains(x,y)) {
|
|
// if ((x<0 || y<0 || x>l_width || y>l_height)) {
|
|
hl_day=-1;
|
|
//graph->timedRedraw(2000);
|
|
return false;
|
|
}
|
|
|
|
x-=m_rect.left();
|
|
y-=m_rect.top();
|
|
|
|
double xx=l_maxx-l_minx;
|
|
|
|
double xmult=xx/double(l_width+barw);
|
|
|
|
qint64 mx=ceil(xmult*double(x-offset));
|
|
mx+=l_minx;
|
|
mx=mx+l_offset;//-86400000L;
|
|
int zd=mx/86400000L;
|
|
|
|
Day * day;
|
|
//if (hl_day!=zd) // This line is an optimization
|
|
|
|
{
|
|
hl_day=zd;
|
|
graph->Trigger(2000);
|
|
|
|
QHash<int,QHash<short,EventDataType> >::iterator d=m_values.find(hl_day);
|
|
|
|
QHash<short,EventDataType> & valhash=d.value();
|
|
|
|
x+=m_rect.left(); //gYAxis::Margin+gGraphView::titleWidth; //graph->m_marginleft+
|
|
int y=event->y()-m_rect.top()+rtop-15;
|
|
//QDateTime dt1=QDateTime::fromTime_t(hl_day*86400).toLocalTime();
|
|
QDateTime dt2=QDateTime::fromTime_t(hl_day*86400).toUTC();
|
|
|
|
//QTime t1=dt1.time();
|
|
//QTime t2=dt2.time();
|
|
|
|
QDate dt=dt2.date();
|
|
if (d!=m_values.end()) {
|
|
|
|
day=m_days[zd];
|
|
|
|
QString z=dt.toString(Qt::SystemLocaleShortDate);
|
|
|
|
// Day * day=m_days[hl_day];
|
|
//EventDataType val;
|
|
QString val;
|
|
if (m_graphtype==GT_SESSIONS) {
|
|
if (m_type[0]==ST_HOURS) {
|
|
|
|
int t=m_hours[zd]*3600.0;
|
|
int h=t/3600;
|
|
int m=(t / 60) % 60;
|
|
//int s=t % 60;
|
|
val.sprintf("%02i:%02i",h,m);
|
|
} else
|
|
val=QString::number(d.value()[0],'f',2);
|
|
z+="\r\n"+m_label+"="+val;
|
|
|
|
if (m_type[1]==ST_SESSIONS){
|
|
z+=" (Sess="+QString::number(day->size(),'f',0)+")";
|
|
}
|
|
|
|
EventDataType v=m_times[zd][0];
|
|
int lastt=m_times[zd].size()-1;
|
|
if (lastt<0) lastt=0;
|
|
z+="\r\nBedtime="+formatTime(v,false,false,true);
|
|
v=m_times[zd][lastt]+m_values[zd][lastt];
|
|
z+="\r\nWaketime="+formatTime(v,false,false,true);
|
|
|
|
} else
|
|
if (m_graphtype==GT_BAR){
|
|
if (m_type[0]==ST_HOURS) {
|
|
int t=d.value()[0]*3600.0;
|
|
int h=t/3600;
|
|
int m=(t / 60) % 60;
|
|
//int s=t % 60;
|
|
val.sprintf("%02i:%02i",h,m);
|
|
} else
|
|
val=QString::number(d.value()[0],'f',2);
|
|
z+="\r\n"+m_label+"="+val;
|
|
//z+="\r\nMode="+QString::number(day->settings_min("FlexSet"),'f',0);
|
|
|
|
} else {
|
|
QString a;
|
|
for (int i=0;i<m_type.size();i++) {
|
|
if (!m_goodcodes[i])
|
|
continue;
|
|
if (!valhash.contains(i+1))
|
|
continue;
|
|
EventDataType tval=m_typeval[i];
|
|
switch(m_type[i]) {
|
|
case ST_WAVG: a="W-avg"; break;
|
|
case ST_AVG: a="Avg"; break;
|
|
case ST_90P: a="90%"; break;
|
|
case ST_PERC:
|
|
if (tval>=0.99) a="Max";
|
|
else if (tval==0.5) a="Med";
|
|
else a=QString("%1%").arg(tval*100.0,0,'f',0);
|
|
break;
|
|
case ST_MIN: a="Min"; break;
|
|
case ST_MAX: a="Max"; break;
|
|
case ST_CPH: a=""; break;
|
|
case ST_SPH: a="%"; break;
|
|
case ST_HOURS: a=STR_UNIT_Hours; break;
|
|
case ST_SESSIONS: a="Sessions"; break;
|
|
case ST_SETMIN: a="Min"; break;
|
|
case ST_SETMAX: a="Max"; break;
|
|
default:
|
|
a="";
|
|
break;
|
|
}
|
|
if (m_type[i]==ST_SESSIONS) {
|
|
val=QString::number(d.value()[i+1],'f',0);
|
|
z+="\r\n"+a+"="+val;
|
|
} else {
|
|
//if (day && (day->channelExists(m_codes[i]) || day->settingExists(m_codes[i]))) {
|
|
schema::Channel & chan=schema::channel[m_codes[i]];
|
|
EventDataType v;
|
|
if (valhash.contains(i+1))
|
|
v=valhash[i+1];
|
|
else v=0;
|
|
|
|
if (m_codes[i]==Journal_Weight) {
|
|
val=weightString(v,PROFILE.general->unitSystem());
|
|
} else {
|
|
val=QString::number(v,'f',2);
|
|
}
|
|
z+="\r\n"+chan.label()+" "+a+"="+val;
|
|
//}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
graph->ToolTip(z,x,y-15,p_profile->general->tooltipTimeout());
|
|
return true;
|
|
} else {
|
|
QString z=dt.toString(Qt::SystemLocaleShortDate)+"\r\nNo Data";
|
|
graph->ToolTip(z,x,y-15,p_profile->general->tooltipTimeout());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SummaryChart::mousePressEvent(QMouseEvent * event,gGraph * graph)
|
|
{
|
|
if (event->modifiers() & Qt::ShiftModifier) {
|
|
//qDebug() << "Jump to daily view?";
|
|
return true;
|
|
}
|
|
Q_UNUSED(graph)
|
|
return false;
|
|
}
|
|
|
|
bool SummaryChart::keyPressEvent(QKeyEvent * event,gGraph * graph)
|
|
{
|
|
Q_UNUSED(event)
|
|
Q_UNUSED(graph)
|
|
//qDebug() << "Summarychart Keypress";
|
|
return false;
|
|
}
|
|
|
|
#include "mainwindow.h"
|
|
extern MainWindow *mainwin;
|
|
bool SummaryChart::mouseReleaseEvent(QMouseEvent * event,gGraph * graph)
|
|
{
|
|
if (event->modifiers() & Qt::ShiftModifier) {
|
|
if (hl_day<0) {
|
|
mouseMoveEvent(event,graph);
|
|
}
|
|
if (hl_day>0) {
|
|
QDateTime d=QDateTime::fromTime_t(hl_day*86400).toUTC();
|
|
mainwin->getDaily()->LoadDate(d.date());
|
|
mainwin->JumpDaily();
|
|
//qDebug() << "Jump to daily view?" << d;
|
|
return true;
|
|
}
|
|
}
|
|
Q_UNUSED(event)
|
|
hl_day=-1;
|
|
graph->timedRedraw(2000);
|
|
return false;
|
|
}
|
|
|