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

Graphics Optimisations

Browse Source
This commit is contained in:
Mark Watkins 2012-01-05 21:35:23 +10:00
parent d9113e0a5e
commit 96ff7471d9
10 changed files with 450 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
Graphs/gFlagsLine.cpp
View File

@ -138,33 +138,87 @@ void gFlagsLine::paint(gGraph & w,int left, int top, int width, int height)
float bottom=top+height-2;
bool verts_exceeded=false;
qint64 X,X2,L;
lines->setColor(schema::channel[m_code].defaultColor().rgba());
lines->setColor(schema::channel[m_code].defaultColor());
qint64 start;
quint32 * tptr;
EventStoreType *dptr;
int idx;
for (QVector<Session *>::iterator s=m_day->begin();s!=m_day->end(); s++) {
if (!(*s)->enabled()) continue;
if ((*s)->eventlist.find(m_code)==(*s)->eventlist.end()) continue;
EventList & el=*((*s)->eventlist[m_code][0]);
start=el.first();
tptr=el.rawTime();
dptr=el.rawData();
int np=el.count();
for (quint32 i=0;i<el.count();i++) {
X=el.time(i);
L=el.data(i)*1000;
for (idx=0; idx < np; idx++) {
X=start + *tptr++;
L=*dptr++ * 1000;
if (X >= minx)
break;
X2=X-L;
if (X2 < minx) continue;
if (X > maxx) break;
x1=(X - minx) * xmult + left;
if (m_flt==FT_Bar) {
if (X2 >= minx)
break;
}
np-=idx;
if (m_flt==FT_Bar) {
///////////////////////////////////////////////////////////////////////////
// Draw Event Flag Bars
///////////////////////////////////////////////////////////////////////////
// Check bounds outside of loop is faster..
// This will have to be reverted if multithreaded drawing is ever brought back
int rem=lines->Max() - lines->cnt();
if ((np<<1) > rem) {
qDebug() << "gFlagsLine would overfill lines for" << schema::channel[m_code].label();
np=rem >> 1;
verts_exceeded=true;
}
for (int i=0;i<np;i++) {
X=start + * tptr++; //el.time(i);
if (X > maxx)
break;
x1=(X - minx) * xmult + left;
lines->add(x1,bartop,x1,bottom);
if (lines->full()) { verts_exceeded=true; break; }
} else if (m_flt==FT_Span) {
//if (lines->full()) { verts_exceeded=true; break; }
}
} else if (m_flt==FT_Span) {
///////////////////////////////////////////////////////////////////////////
// Draw Event Flag Spans
///////////////////////////////////////////////////////////////////////////
quads->setColor(m_flag_color);
int rem=quads->Max() - quads->cnt();
if ((np<<2) > rem) {
qDebug() << "gFlagsLine would overfill quads for" << schema::channel[m_code].label();
np=rem >> 2;
verts_exceeded=true;
}
for (int i=0;i < np; i++) {
X=start + * tptr++;
if (X > maxx)
break;
L=*dptr++ * 1000;
X2=X-L;
x1=(X - minx) * xmult + left;
x2=(X2-minx)*xmult+left;
//w1=x2-x1;
/*if (qAbs(x1-x2)<=1) {
x1-=1;
x2+=1;
}*/
quads->add(x2,bartop,x1,bartop, x1,bottom,x2,bottom,m_flag_color.rgba());
if (quads->full()) { verts_exceeded=true; break; }
quads->unsafe_add(x2,bartop,x1,bartop, x1,bottom,x2,bottom);
//if (quads->full()) { verts_exceeded=true; break; }
}
}
if (verts_exceeded) break;

4
Graphs/gFooBar.cpp
View File

@ -32,8 +32,8 @@ void gShadowArea::paint(gGraph & w,int left, int top, int width, int height)
//float h=top;
double rmx=w.rmax_x-w.rmin_x;
double px=((1/rmx)*(w.min_x-w.rmin_x))*width;
double py=((1/rmx)*(w.max_x-w.rmin_x))*width;
double px=((1.0/rmx)*(w.min_x-w.rmin_x))*width;
double py=((1.0/rmx)*(w.max_x-w.rmin_x))*width;
quads->add(start_px,top,start_px,top+height,start_px+px, top+height, start_px+px, top,m_shadow_color.rgba());
quads->add(start_px+py, top, start_px+py, top+height,end_px, top+height, end_px, top,m_shadow_color.rgba());

53
Graphs/gGraphView.cpp
View File

@ -321,18 +321,40 @@ void gVertexBuffer::add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort
m_cnt+=4;
}
}
void gVertexBuffer::unsafe_add(GLshort x1, GLshort y1)
{
gVertex & v=buffer[m_cnt++];
v.color=m_color;
v.x=x1;
v.y=y1;
}
void gVertexBuffer::add(GLshort x1, GLshort y1)
{
if (m_cnt<m_max) {
gVertex & v=buffer[m_cnt];
gVertex & v=buffer[m_cnt++];
v.color=m_color;
v.x=x1;
v.y=y1;
m_cnt++;
}
}
void gVertexBuffer::unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
gVertex * v=&buffer[m_cnt];
v->x=x1;
v->y=y1;
v->color=m_color;
v++;
v->x=x2;
v->y=y2;
v->color=m_color;
m_cnt+=2;
}
void gVertexBuffer::add(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
if (m_cnt < (m_max-1)) {
@ -377,6 +399,31 @@ void gVertexBuffer::add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort
m_cnt+=4;
}
}
void gVertexBuffer::unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort x3, GLshort y3, GLshort x4, GLshort y4)
{
gVertex *v=&buffer[m_cnt];
v->color=m_color;
v->x=x1;
v->y=y1;
v++;
v->color=m_color;
v->x=x2;
v->y=y2;
v++;
v->color=m_color;
v->x=x3;
v->y=y3;
v++;
v->color=m_color;
v->x=x4;
v->y=y4;
m_cnt+=4;
}
GLBuffer::GLBuffer(int max,int type, bool stippled)

4
Graphs/gGraphView.h
View File

@ -94,6 +94,10 @@ public:
void add(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
void add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort x3, GLshort y3, GLshort x4, GLshort y4);
void unsafe_add(GLshort x1, GLshort y1);
void unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
void unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort x3, GLshort y3, GLshort x4, GLshort y4);
void draw();
void scissor(GLshort x, GLshort y, GLshort width, GLshort height) { s_x=x; s_y=y; s_width=width; s_height=height; m_scissor=true; }

361
Graphs/gLineChart.cpp
View File

@ -153,7 +153,7 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
EventDataType lastpx,lastpy;
EventDataType px,py;
int idx;
bool done,first;
bool done;
double x0,xL;
double sr;
int sam;
@ -326,45 +326,61 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
double time;
EventDataType data;
EventDataType gain=el.gain();
EventDataType nmult=ymult*gain;
EventDataType ymin=EventDataType(miny)/gain;
//EventDataType nmult=ymult*gain;
//EventDataType ymin=EventDataType(miny)/gain;
const QVector<EventStoreType> & dat=el.getData();
const QVector<quint32> & tim=el.getTime();
//const QVector<EventStoreType> & dat=el.getData();
//const QVector<quint32> & tim=el.getTime();
//quint32 * tptr;
//qint64 stime=el.first();
done=false;
first=true;
if (!accel) {
lines->setSize(1.5);
} else lines->setSize(1);
bool firstpx=true;
if (el.type()==EVL_Waveform) { // Waveform Plot
if (idx>sam) idx-=sam;
time=el.time(idx);
double rate=double(sr)*double(sam);
EventStoreType * ptr=el.rawData()+idx;
if (accel) {
//////////////////////////////////////////////////////////////////
// Accelerated Waveform Plot
//////////////////////////////////////////////////////////////////
for (int i=idx;i<siz;i+=sam) {
time+=rate;
//time=el.time(i);
//if (time < minx)
// continue; // Skip stuff before the start of our data window
//////////////////////////////////////////////////////////////////
// Accelerated Waveform Plot
//////////////////////////////////////////////////////////////////
//data=el.data(i);
data=dat[i];//*gain;
px=((time - minx) * xmult); // Scale the time scale X to pixel scale X
py=((data - ymin) * nmult); // Same for Y scale
// qint64 tmax=(maxx-time)/rate;
// if ((tmax*sam) < siz) {
// siz=idx+tmax*sam;
// done=true;
// }
for (int i=idx;i<siz;i+=sam,ptr+=sam) {
time+=rate;
// This is much faster than QVector access.
data=*ptr;
data *= gain;
// Scale the time scale X to pixel scale X
px=((time - minx) * xmult);
// Same for Y scale, with gain factored in nmult
py=((data - miny) * ymult);
// In accel mode, each pixel has a min/max Y value.
// m_drawlist's index is the pixel index for the X pixel axis.
int z=round(px); // Hmmm... round may screw this up.
if (z<minz) minz=z; // minz=First pixel
if (z>maxz) maxz=z; // maxz=Last pixel
if (z<minz)
minz=z; // minz=First pixel
if (z>maxz)
maxz=z; // maxz=Last pixel
if (minz<0) {
qDebug() << "gLineChart::Plot() minz<0 should never happen!! minz =" << minz;
minz=0;
@ -375,151 +391,210 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
}
// Update the Y pixel bounds.
if (py<m_drawlist[z].x()) m_drawlist[z].setX(py);
if (py>m_drawlist[z].y()) m_drawlist[z].setY(py);
if (py<m_drawlist[z].x())
m_drawlist[z].setX(py);
if (py>m_drawlist[z].y())
m_drawlist[z].setY(py);
if (time>maxx) {
done=true;
break;
}
}
// Plot compressed accelerated vertex list
if (maxz>width) {
maxz=width;
}
float ax1,ay1;
QPoint * drl=m_drawlist+minz;
// Don't need to cap VertexBuffer here, as it's limited to max_drawlist_size anyway
// Cap within VertexBuffer capacity, one vertex per line point
int np=(maxz-minz)*2;
int j=lines->Max()-lines->cnt();
if (np < j) {
for (int i=minz;i<maxz;i++, drl++) {
ax1=drl->x();
ay1=drl->y();
lines->unsafe_add(xst+i,yst-ax1,xst+i,yst-ay1);
//if (lines->full()) break;
}
} else {
qDebug() << "gLineChart full trying to draw" << schema::channel[code].label();
done=true;
}
} else { // Zoomed in Waveform
//////////////////////////////////////////////////////////////////
// Normal Waveform Plot
//////////////////////////////////////////////////////////////////
// Cap within VertexBuffer capacity, one vertex per line point
// int np=((siz-idx)/sam)*2;
// int j=lines->Max()-lines->cnt();
// if (np > j) {
// siz=j*sam;
// }
// Prime first point
data=*ptr * gain;
lastpx=xst+((time - minx) * xmult);
lastpy=yst-((data - miny) * ymult);
for (int i=idx;i<siz;i+=sam) {
ptr+=sam;
time+=rate;
data=*ptr * gain;
px=xst+((time - minx) * xmult); // Scale the time scale X to pixel scale X
py=yst-((data - miny) * ymult); // Same for Y scale, with precomputed gain
//py=yst-((data - ymin) * nmult); // Same for Y scale, with precomputed gain
lines->add(lastpx,lastpy,px,py);
lastpx=px;
lastpy=py;
if (time>maxx) {
done=true;
break;
}
if (lines->full())
break;
}
}
} else {
//////////////////////////////////////////////////////////////////
// Standard events/zoomed in Plot
//////////////////////////////////////////////////////////////////
double start=el.first();
quint32 * tptr=el.rawTime();
int idx=0;
if (siz>15) {
for (;idx<siz;++idx) {
time=start + *tptr++;
if (time >= minx) {
break;
}
}
if (idx > 0) {
idx--;
//tptr--;
}
}
// Step one backwards if possible (to draw through the left margin)
EventStoreType * dptr=el.rawData() + idx;
tptr=el.rawTime() + idx;
time=start + *tptr++;
data=*dptr++ * gain;
idx++;
lastpx=xst+((time - minx) * xmult); // Scale the time scale X to pixel scale X
lastpy=yst-((data - miny) * ymult); // Same for Y scale without precomputed gain
siz-=idx;
// Check if would overflow lines gVertexBuffer
int gs=siz << 1;
int j=lines->Max()-lines->cnt();
if (square_plot)
gs <<= 1;
if (gs > j) {
qDebug() << "Would overflow line points.. increase default VertexBuffer size in gLineChart";
siz=j >> square_plot ? 2 : 1;
done=true; // end after this partial draw..
}
// Unrolling square plot outside of loop to gain a minor speed improvement.
if (square_plot) {
for (int i=0;i<siz;i++) {
time=start + *tptr++;
data=gain * *dptr++;
px=xst+((time - minx) * xmult); // Scale the time scale X to pixel scale X
py=yst-((data - miny) * ymult); // Same for Y scale without precomputed gain
// Horizontal lines are easy to cap
if (py==lastpy) {
// Cap px to left margin
if (lastpx<xst) lastpx=xst;
// Cap px to right margin
if (px>xst+width) px=xst+width;
lines->unsafe_add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
} else {
// Letting the scissor do the dirty work for non horizontal lines
// This really should be changed, as it might be cause that weird
// display glitch on Linux..
lines->unsafe_add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
}
lastpx=px;
lastpy=py;
if (time > maxx) {
done=true; // Let this iteration finish.. (This point will be in far clipping)
break;
}
}
// Plot compressed accelerated vertex list
if (maxz>width) {
//qDebug() << "gLineChart::Plot() maxz exceeded graph width" << "maxz = " << maxz << "width =" << width;
maxz=width;
}
float ax1,ay1;
for (int i=minz;i<maxz;i++) {
// ax1=(m_drawlist[i-1].x()+m_drawlist[i].x()+m_drawlist[i+1].x())/3.0;
// ay1=(m_drawlist[i-1].y()+m_drawlist[i].y()+m_drawlist[i+1].y())/3.0;
ax1=m_drawlist[i].x();
ay1=m_drawlist[i].y();
lines->add(xst+i,yst-ax1,xst+i,yst-ay1);
if (lines->full()) break;
}
} else { // Zoomed in Waveform
//////////////////////////////////////////////////////////////////
// Normal Waveform Plot
//////////////////////////////////////////////////////////////////
if (idx>sam) {
idx-=sam;
time=el.time(idx);
//double rate=double(sr)*double(sam);
}
for (int i=idx;i<siz;i+=sam) {
time+=rate;
//if (time < minx)
// continue; // Skip stuff before the start of our data window
data=dat[i];//el.data(i);
} else {
for (int i=0;i<siz;i++) {
time=start + *tptr++;
data=gain * *dptr++;
px=xst+((time - minx) * xmult); // Scale the time scale X to pixel scale X
py=yst-((data - ymin) * nmult); // Same for Y scale, with precomputed gain
py=yst-((data - miny) * ymult); // Same for Y scale without precomputed gain
if (firstpx) {
lastpx=px;
lastpy=py;
firstpx=false;
continue;
}
lines->add(lastpx,lastpy,px,py);
// Horizontal lines are easy to cap
if (py==lastpy) {
// Cap px to left margin
if (lastpx<xst) lastpx=xst;
if (lines->full()) {
done=true;
break;
}
if (time > maxx) {
//done=true; // Let this iteration finish.. (This point will be in far clipping)
break;
// Cap px to right margin
if (px>xst+width) px=xst+width;
lines->unsafe_add(lastpx,lastpy,px,py);
} else {
// Letting the scissor do the dirty work for non horizontal lines
// This really should be changed, as it might be cause that weird
// display glitch on Linux..
lines->unsafe_add(lastpx,lastpy,px,py);
}
lastpx=px;
lastpy=py;
}
}
} else {
//////////////////////////////////////////////////////////////////
// Standard events/zoomed in Plot
//////////////////////////////////////////////////////////////////
first=true;
double start=el.first();
/*if (siz==2) {
time=start+tim[0];
data=dat[0]*gain;
data-=subtract_offset;
lastpy=yst-((data - miny) * ymult); // Same for Y scale with precomputed gain
lastpx=xst+((time - minx) * xmult); // Scale the time scale X to pixel scale X
if (lastpx<xst-1) lastpx=xst-1;
EventDataType data2=(dat[1]*gain)-subtract_offset;
qint64 time2=start+tim[1];
py=yst-((data2 - miny) * ymult);
px=xst+((time2 - minx) * xmult);
if (px>xst+width) px=xst+width;
lines->add(lastpx,lastpy,px,py);
} else*/
for (int i=0;i<siz;i++) {
time=start+tim[i];
if (first) {
if (num_points>15 && (time < minx)) continue; // Skip stuff before the start of our data window
first=false;
if (i>0) i--; // Start with the previous sample (which will be in clipping area)
time=start+tim[i];
}
data=dat[i]*gain; //
data-=subtract_offset;
//data=el.data(i); // raw access is faster
px=xst+((time - minx) * xmult); // Scale the time scale X to pixel scale X
//py=yst+((data - ymin) * nmult); // Same for Y scale with precomputed gain
py=yst-((data - miny) * ymult); // Same for Y scale with precomputed gain
//if (px<left) px=left;
//if (px>left+width) px=left+width;
if (firstpx) {
firstpx=false;
} else {
if (py==lastpy) {
if (lastpx<xst) lastpx=xst;
if (px>xst+width) px=xst+width;
if (square_plot) {
lines->add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
} else {
lines->add(lastpx,lastpy,px,py);
}
} else {
if (square_plot) {
lines->add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
} else {
lines->add(lastpx,lastpy,px,py);
}
}
//lines->add(px,py,m_line_color);
if (lines->full()) {
if (time > maxx) { // Past right edge, abort further drawing..
done=true;
break;
}
}
lastpx=px;
lastpy=py;
//if (lastpx>start_px+width) done=true;
if (time > maxx) {
done=true; // Let this iteration finish.. (This point will be in far clipping)
break;
}
}
}
if (done) break;
}
}
////////////////////////////////////////////////////////////////////
// Draw Legends on the top line
////////////////////////////////////////////////////////////////////
if ((codepoints>0)) { //(m_codes.size()>1) &&
// Draw Legends for plots..
QString text=schema::channel[code].label();
int wid,hi;
GetTextExtent(text,wid,hi);
@ -601,7 +676,7 @@ void AHIChart::paint(gGraph & w,int left, int top, int width, int height)
double lastpx,lastpy;
double top1=top+height;
bool done=false;
GLuint color=m_color.rgba();
//GLuint color=m_color.rgba();
for (int i=0;i<m_time.size();i++) {
qint64 ti=m_time[i];
EventDataType v=m_data[i];

105
Graphs/gLineOverlay.cpp
View File

@ -63,33 +63,49 @@ void gLineOverlayBar::paint(gGraph & w, int left, int topp, int width, int heigh
}
EventStoreType raw;
quint32 * tptr;
EventStoreType * ptr;
qint64 stime;
OverlayDisplayType odt=PROFILE.appearance->overlayType();
// For each session, process it's eventlist
for (QVector<Session *>::iterator s=m_day->begin();s!=m_day->end(); s++) {
if (!(*s)->enabled()) continue;
cei=(*s)->eventlist.find(m_code);
if (cei==(*s)->eventlist.end()) continue;
if (cei.value().size()==0) continue;
// Could loop through here, but nowhere uses more than one yet..
EventList & el=*cei.value()[0];
stime=el.first();
ptr=el.rawData();
tptr=el.rawTime();
for (quint32 i=0;i<el.count();i++) {
X=el.time(i);
raw=el.data(i);
if (m_flt==FT_Span) {
////////////////////////////////////////////////////////////////////////////
// Skip data previous to minx bounds
////////////////////////////////////////////////////////////////////////////
quint32 idx;
for (idx=0;idx<el.count();idx++) {
X=stime + *tptr;
if (X >= w.min_x)
break;
tptr++;
ptr++;
}
if (m_flt==FT_Span) {
////////////////////////////////////////////////////////////////////////////
// FT_Span
////////////////////////////////////////////////////////////////////////////
for (quint32 i=idx;i<el.count();i++) {
X=stime + *tptr++; //el.time(i);
raw=*ptr++; //el.data(i);
Y=X-(qint64(raw)*1000.0L); // duration
if (X < w.min_x) continue;
if (Y > w.max_x) break;
} else {
if (X < w.min_x) continue;
if (X > w.max_x) break;
}
//x1=w.x2p(X);
x1=double(width)/double(xx)*double(X-w.min_x)+left;
m_count++;
m_sum+=raw;
if (m_flt==FT_Span) {
//x2=w.x2p(Y);
x1=double(width)/double(xx)*double(X-w.min_x)+left;
m_count++;
m_sum+=raw;
x2=double(width)/double(xx)*double(Y-w.min_x)+left;
if (int(x1)==int(x2)) x2+=1;
if (x2<left) x2=left;
@ -97,8 +113,19 @@ void gLineOverlayBar::paint(gGraph & w, int left, int topp, int width, int heigh
//double w1=x2-x1;
quads->add(x2,start_py, x1,start_py, x1,start_py+height, x2,start_py+height,m_flag_color.rgba());
if (quads->full()) { verts_exceeded=true; break; }
} else if (m_flt==FT_Dot) {
if ((PROFILE.appearance->overlayType()==ODT_Bars) || (xx<3600000)) {
}
} else if (m_flt==FT_Dot) {
////////////////////////////////////////////////////////////////////////////
// FT_Dot
////////////////////////////////////////////////////////////////////////////
for (quint32 i=idx;i<el.count();i++) {
X=stime + *tptr++; //el.time(i);
raw=*ptr++; //el.data(i);
if (X > w.max_x) break;
x1=double(width)/double(xx)*double(X-w.min_x)+left;
m_count++;
m_sum+=raw;
if ((odt==ODT_Bars) || (xx<3600000)) {
// show the fat dots in the middle
points->add(x1,double(height)/double(yy)*double(-20-w.min_y)+topp);
if (points->full()) { verts_exceeded=true; break; }
@ -106,32 +133,38 @@ void gLineOverlayBar::paint(gGraph & w, int left, int topp, int width, int heigh
// thin lines down the bottom
lines->add(x1,start_py+1,x1,start_py+1+12);
if (lines->full()) { verts_exceeded=true; break; }
}
} else if (m_flt==FT_Bar) {
}
} else if (m_flt==FT_Bar) {
////////////////////////////////////////////////////////////////////////////
// FT_Bar
////////////////////////////////////////////////////////////////////////////
for (quint32 i=idx;i<el.count();i++) {
X=stime + *tptr++;
raw=*ptr++;
if (X > w.max_x) break;
x1=double(width)/double(xx)*double(X-w.min_x)+left;
m_count++;
m_sum+=raw;
int z=start_py+height;
if ((PROFILE.appearance->overlayType()==ODT_Bars) || (xx<3600000)) {
if ((odt==ODT_Bars) || (xx<3600000)) {
z=top;
points->add(x1,top);
lines->add(x1,top,x1,bottom);
if (points->full()) { verts_exceeded=true; break; }
} else {
} else {
lines->add(x1,z,x1,z-12);
}
if (lines->full()) { verts_exceeded=true; break; }
if (xx<(1800000)) {
GetTextExtent(m_label,x,y);
w.renderText(m_label,x1-(x/2),top-y+(3*w.printScaleY()));
// The follow lines enable the duration display underneath
// QString a=QString::number(int(el.data(i)));
// GetTextExtent(a,x,y);
// w.renderText(a,x1-(x/2),bottom+y+(3*w.printScaleY()));
}
}
}
if (lines->full()) { verts_exceeded=true; break; }
if (xx<(1800000)) {
GetTextExtent(m_label,x,y);
w.renderText(m_label,x1-(x/2),top-y+(3*w.printScaleY()));
}
}
}
if (verts_exceeded) break;
}
if (verts_exceeded) {

72
Graphs/gSummaryChart.cpp
View File

@ -60,7 +60,6 @@ void SummaryChart::SetDay(Day * nullday)
m_codes.clear();
m_colors.clear();
m_type.clear();
//m_zeros.clear();
m_typeval.clear();
if (cpapmode>=MODE_ASV) {
@ -133,19 +132,8 @@ void SummaryChart::SetDay(Day * nullday)
zt=qint64(sess->first())/1000L;
zt+=tz_offset;
tmp2=zt-dn*86400;
//zt %= 86400;
tmp2/=3600.0;
//tmp2-=24.0;
//if (zdn>dn2) {
//if (tmp2<12) {
// tmp2-=24;
//m_times[dn][s]=(tmp2+12);
//}/* else {
// tmp2-=12;
//m_times[dn][s]=(tmp2)-12;
//}*/
m_times[dn][s]=tmp2;
if (tmp2 < m_miny)
@ -162,8 +150,6 @@ void SummaryChart::SetDay(Day * nullday)
} else {
for (int j=0;j<m_codes.size();j++) { // for each code slice
code=m_codes[j];
//m_values[dn][0]=0;
//if (code==CPAP_Leak) suboffset=PROFILE.cpap->IntentionalLeak(); else
suboffset=0;
type=m_type[j];
EventDataType typeval=m_typeval[j];
@ -171,7 +157,6 @@ void SummaryChart::SetDay(Day * nullday)
day=d.value()[i];
CPAPMode mode=(CPAPMode)(int)day->settings_max(CPAP_Mode);
if (day->machine_type()!=m_machinetype) continue;
//m_values[dn][j+1]=0;
bool hascode=//day->channelHasData(code) ||
type==ST_HOURS ||
@ -234,35 +219,9 @@ void SummaryChart::SetDay(Day * nullday)
if (total<m_miny) m_miny=total;
if (total>m_maxy) m_maxy=total;
}
//m_empty=false;
}// else m_hours[dn]=0;
}
}
/* if (m_graphtype!=GT_SESSIONS)
for (int j=0;j<m_codes.size();j++) { // for each code slice
ChannelID code=m_codes[j];
if (type==ST_HOURS || type==ST_SESSIONS || m_zeros[j]) continue;
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;
for (int i=0;i<d.value().size();i++) { // for each machine object for this day
day=d.value().at(i);
if (day->machine_type()!=m_machinetype) continue;
if (!m_values[dn].contains(j+1)) {
m_days[dn]=day;
m_values[dn][j+1]=0;
if (!m_values[dn].contains(0)) {
m_values[dn][0]=0;
}
if (0<m_miny) m_miny=0;
if (0>m_maxy) m_maxy=0;
m_hours[dn]=day->hours();
}
break;
}
}
} */
}
m_empty=true;
for (int i=0;i<m_goodcodes.size();i++) {
if (m_goodcodes[i]) {
@ -314,7 +273,6 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
//if (outlines->full()) qDebug() << "WTF??? Outlines full in SummaryChart::paint()";
qint64 minx=w.min_x, maxx=w.max_x;
//qint64 minx=m_minx, maxx=m_maxx;
qint64 xx=maxx - minx;
float days=double(xx)/86400000.0;
@ -327,8 +285,6 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
barw=(float(width)/float(days));
//qint64 ts;
graph=&w;
float px=left;
l_left=w.marginLeft()+gYAxis::Margin;
@ -350,21 +306,17 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
l_minx=minx;
l_maxx=maxx+86400000L;
//QHash<short, EventDataType> lastvalues;
int total_days=0;
double total_val=0;
double total_hours=0;
//qint64 lastQ=0;
bool lastdaygood=false;
QVector<double> totalcounts;
QVector<double> totalvalues;
//QVector<EventDataType> lastvalues;
QVector<float> lastX;
QVector<short> lastY;
int numcodes=m_codes.size();
totalcounts.resize(numcodes);
totalvalues.resize(numcodes);
//lastvalues.resize(numcodes);
lastX.resize(numcodes);
lastY.resize(numcodes);
int zd=minx/86400000L;
@ -373,9 +325,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
QVector<bool> goodcodes;
goodcodes.resize(m_goodcodes.size());
// if (d==m_values.end()) {
// d=m_values.find(zd--);
// }
lastdaygood=true;
for (int i=0;i<numcodes;i++) {
totalcounts[i]=0;
@ -392,7 +342,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
goodcodes[i]=false;
if (!m_goodcodes[i]) continue;
// lastvalues[i]=0;
lastX[i]=px;
if (d!=m_values.end() && d.value().contains(i+1)) {
@ -413,6 +363,9 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
Day * day;
EventDataType hours;
quint32 * tptr;
EventStoreType * dptr;
short px2,py2;
for (qint64 Q=minx;Q<=maxx+86400000L;Q+=86400000L) {
zd=Q/86400000L;
@ -421,12 +374,11 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
qint64 extra=86400000;
if (Q<minx)
goto jumpnext;
//continue;
if (d!=m_values.end()) {
day=m_days[zd];
if (!m_hours.contains(zd))
goto jumpnext;
//continue;
hours=m_hours[zd];
@ -438,8 +390,6 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
if (x2>left+width) x2=left+width;
if (x2<x1)
goto jumpnext;
//continue;
//ChannelID code;
if (m_graphtype==GT_SESSIONS) {
int j;
@ -454,12 +404,13 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
GLuint col2=brighten(col).rgba();
outlines->setColor(Qt::black);
if (d.value().size()>0) {
int np=d.value().size();
if (np > 0) {
for (int i=0;i<goodcodes.size();i++) {
goodcodes[i]=true;
}
}
for (j=0;j<d.value().size();j++) {
for (j=0;j < np;j++) {
tmp2=times.value()[j]-miny;
py=top+height-(tmp2*ymult);
@ -472,8 +423,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
if (h>0 && barw>2) {
outlines->add(x1,py,x1,py-h,x1,py-h,x2,py-h);
outlines->add(x1,py,x2,py,x2,py,x2,py-h);
} // if (bar
//py-=h;
}
totalvalues[0]+=hours*tmp;
}
totalcounts[0]+=hours;

19
Graphs/gXAxis.cpp
View File

@ -165,22 +165,24 @@ void gXAxis::paint(gGraph & w,int left,int top, int width, int height)
if (py<start_px) continue;
lines->add(py,top,py,mintop);
}
static QString dow[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
int ms,m,h,s,d;
qint64 j;
for (qint64 i=aligned_start;i<maxx;i+=step) {
px=(i-minx)*xmult;
px+=left;
lines->add(px,top,px,majtop);
qint64 j=i;
j=i;
if (!m_utcfix) j+=tz_offset;
int ms=j % 1000;
int m=(j/60000L) % 60L;
int h=(j/3600000L) % 24L;
int s=(j/1000L) % 60L;
static QString dow[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
ms=j % 1000;
m=(j/60000L) % 60L;
h=(j/3600000L) % 24L;
s=(j/1000L) % 60L;
//int d=(j/86400000) % 7;
if (fitmode==0) {
int d=(j/1000);
d=(j/1000);
QDateTime dt=QDateTime::fromTime_t(d).toUTC();
tmpstr=dt.toString("MMM dd");
//} else if (fitmode==0) {
@ -195,9 +197,6 @@ void gXAxis::paint(gGraph & w,int left,int top, int width, int height)
int tx=px-x/2.0;
// Massive bottle neck..
//GetTextExtent(tmpstr,x,y); // this only really needs running once :(
if (m_utcfix)
tx+=step_pixels/2.0;
if ((tx+x)<(left+width))

28
SleepLib/session.cpp
View File

@ -41,6 +41,8 @@ Session::Session(Machine * m,SessionID session)
s_first=s_last=0;
s_eventfile="";
s_evchecksum_checked=false;
}
Session::~Session()
{
@ -80,7 +82,7 @@ bool Session::OpenEvents() {
return s_events_loaded=true;
};
}
bool Session::Store(QString path)
// Storing Session Data in our format
@ -511,23 +513,23 @@ bool Session::LoadEvents(QString filename)
if (version>=10) {
if (compmethod>0) {
databytes=qUncompress(temp);
if (!s_evchecksum_checked) {
if (databytes.size()!=datasize) {
qDebug() << "File" << filename << "has returned wrong datasize";
return false;
}
quint16 crc=qChecksum(databytes.data(),databytes.size());
if (crc!=crc16) {
qDebug() << "CRC Doesn't match in" << filename;
return false;
}
s_evchecksum_checked=true;
}
} else {
databytes=temp;
}
} else databytes=temp;
if (version>=10) {
if (databytes.size()!=datasize) {
qDebug() << "File" << filename << "has returned wrong datasize";
return false;
}
quint16 crc=qChecksum(databytes.data(),databytes.size());
if (crc!=crc16) {
qDebug() << "CRC Doesn't match in" << filename;
return false;
}
}
QDataStream in(databytes);
in.setVersion(QDataStream::Qt_4_6);
in.setByteOrder(QDataStream::LittleEndian);

1
SleepLib/session.h
View File

@ -258,6 +258,7 @@ protected:
qint64 s_last;
bool s_changed;
bool s_lonesession;
bool s_evchecksum_checked;
bool _first_session;
bool s_events_loaded;