MinutesAtPressure graph test

sleepyhead/Graphs/MinutesAtPressure.cpp

@@ -0,0 +1,374 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ *
+ * MinutesAtPressure Graph 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 <cmath>
+#include <QApplication>
+#include <QThreadPool>
+#include <QMutexLocker>
+
+#include "MinutesAtPressure.h"
+#include "Graphs/gGraph.h"
+#include "Graphs/gGraphView.h"
+#include "SleepLib/profiles.h"
+
+#include "Graphs/gXAxis.h"
+
+
+MinutesAtPressure::MinutesAtPressure() :Layer(NoChannel)
+{
+    m_remap = nullptr;
+}
+MinutesAtPressure::~MinutesAtPressure()
+{
+    while (recalculating()) {};
+}
+
+RecalcMAP::~RecalcMAP()
+{
+}
+void RecalcMAP::quit() {
+    m_quit = true;
+    map->mutex.lock();
+    map->mutex.unlock();
+}
+
+
+void MinutesAtPressure::SetDay(Day *day)
+{
+    Layer::SetDay(day);
+
+
+    m_empty = false;
+    m_recalculating = false;
+    m_lastminx = 0;
+    m_lastmaxx = 0;
+}
+
+
+bool MinutesAtPressure::isEmpty()
+{
+    return m_empty;
+}
+
+void MinutesAtPressure::paint(QPainter &painter, gGraph &graph, const QRegion &region)
+{
+    QRect rect = region.boundingRect();
+
+    float width = rect.width();
+
+    float cells = 28;
+
+    float pix = width / cells;
+
+    float left = rect.left();
+
+    m_minx = graph.min_x;
+    m_maxx = graph.max_x;
+
+    if ((m_lastminx != m_minx) || (m_lastmaxx != m_maxx)) {
+        recalculate(&graph);
+    }
+    m_lastminx = m_minx;
+    m_lastmaxx = m_maxx;
+
+    QMap<EventStoreType, int>::iterator it;
+    int top = rect.top();
+    painter.setFont(*defaultfont);
+    painter.setPen(Qt::black);
+
+    // Lock the stuff we need to draw
+    timelock.lock();
+
+    QMap<EventStoreType, int>::iterator times_end = times.end();
+
+    QString text = STR_TR_Pressure;
+    QRect rec(left,top, pix * 3,0);
+    rec = painter.boundingRect(rec, Qt::AlignTop | Qt::AlignRight, text);
+    rec.moveRight(left-4);
+    painter.drawText(rec, Qt::AlignRight | Qt::AlignVCenter, text);
+
+    text = STR_UNIT_Minutes;
+    QRect rec2(left, top + rec.height(),pix * 3, 0);
+    rec2 = painter.boundingRect(rec2, Qt::AlignTop | Qt::AlignRight, text);
+    rec2.moveRight(left-4);
+    painter.drawText(rec2, Qt::AlignRight | Qt::AlignVCenter, text);
+
+    int xpos = left;
+    for (it = times.begin(); it != times_end; ++it) {
+        QString text = QString::number(it.key());
+        QString value = QString("%1").arg(float(it.value()) / 60.0, 5, 'f', 1);
+        QRect rec(xpos, top, pix-1, 0);
+        rec = painter.boundingRect(rec, Qt::AlignTop | Qt::AlignLeft, text);
+        rec = painter.boundingRect(rec, Qt::AlignTop | Qt::AlignLeft, value);
+        rec.setWidth(pix - 1);
+
+        painter.fillRect(rec, QColor("orange"));
+        painter.drawText(rec, Qt::AlignCenter, text);
+        rec.moveTop(top + rec.height());
+        painter.drawText(rec, Qt::AlignCenter, value);
+
+        xpos += pix;
+    }
+
+    float hh = rec.height();
+
+    int ypos = top + hh * 2;
+
+    QHash<ChannelID, QMap<EventStoreType, EventDataType> >::iterator eit;
+    QHash<ChannelID, QMap<EventStoreType, EventDataType> >::iterator ev_end = events.end();
+    QMap<EventStoreType, EventDataType>::iterator vit;
+
+    int row = 0;
+    for (eit = events.begin(); eit != ev_end; ++eit) {
+        ChannelID code = eit.key();
+
+        schema::Channel & chan = schema::channel[code];
+        xpos = left;
+
+        QMap<EventStoreType, EventDataType>::iterator eit_end = eit.value().end();
+
+        QString text = chan.label();
+        QRect rec2(xpos, ypos, pix * 3, hh);
+        rec2 = painter.boundingRect(rec2, Qt::AlignTop | Qt::AlignRight, text);
+        rec2.moveRight(left-4);
+        painter.drawText(rec2, Qt::AlignRight | Qt::AlignVCenter, text);
+
+        for (it = times.begin(), vit = eit.value().begin(); vit != eit_end; ++vit, ++it) {
+            float duration = float(it.value()) * 60.0;
+            float value = (vit.value()) ;
+
+            QRect rec(xpos, ypos, pix-1, hh);
+            if (row & 1) {
+                painter.fillRect(rec, QColor(240,240,240,240));
+            }
+            painter.drawText(rec, Qt::AlignCenter, QString("%1").arg(value,5,'f',1));
+            xpos += pix;
+
+        }
+        ypos += hh;
+        row++;
+    }
+
+
+
+    timelock.unlock();
+
+    if (m_recalculating) {
+        painter.setFont(*defaultfont);
+        painter.setPen(QColor(0,0,0,125));
+        painter.drawText(region.boundingRect(), Qt::AlignCenter, QObject::tr("Recalculating..."));
+    }
+
+    // Draw the goodies...
+}
+
+
+void RecalcMAP::run()
+{
+    QMutexLocker locker(&map->mutex);
+    map->m_recalculating = true;
+    Day * day = map->m_day;
+    if (!day) return;
+
+    QList<Session *>::iterator sit;
+    QList<Session *>::iterator sess_end = day->end();
+
+
+    QMap<EventStoreType, int> times;
+
+    QHash<ChannelID, QMap<EventStoreType, EventDataType> > events;
+
+    QList<ChannelID> chans = day->getSortedMachineChannels(schema::SPAN | schema::FLAG | schema::MINOR_FLAG);
+
+    ChannelID code;
+
+    QList<ChannelID> badchans;
+    for (int i=0 ; i < chans.size(); ++i) {
+        code = chans.at(i);
+        if (!day->channelExists(code)) badchans.push_back(code);
+    }
+
+    for (int i=0; i < badchans.size(); ++i) {
+        code = badchans.at(i);
+        chans.removeAll(code);
+    }
+
+
+    int numchans = chans.size();
+    // Zero the pressure counts
+    for (int i=3; i<=30; i++) {
+        times[i] = 0;
+
+        for (int c = 0; c < numchans; ++c) {
+            code = chans.at(c);
+            events[code].insert(i, 0);
+        }
+    }
+
+
+    ChannelID prescode;
+    if (day->channelExists(CPAP_Pressure)) {
+        prescode = CPAP_Pressure;
+    } else if (day->channelExists(CPAP_IPAP)) {
+        prescode = CPAP_IPAP;
+    } else if (day->channelExists(CPAP_EPAP)) {
+        prescode = CPAP_EPAP;
+    }
+
+    qint64 minx, maxx;
+    map->m_graph->graphView()->GetXBounds(minx, maxx);
+
+    for (sit = day->begin(); sit != sess_end; ++sit) {
+        Session * sess = (*sit);
+        QHash<ChannelID, QVector<EventList *> >::iterator ei = sess->eventlist.find(prescode);
+        if (ei == sess->eventlist.end())
+            break;
+
+        const QVector<EventList *> & evec = ei.value();
+        int esize = evec.size();
+        for (int ei = 0; ei < esize; ++ei) {
+            EventList *EL = evec[ei];
+            EventDataType gain = EL->gain();
+            quint32 ELsize = EL->count();
+            if (ELsize < 1)  return;
+            qint64 lasttime = 0; //EL->time(0);
+            EventStoreType lastdata = 0; // EL->raw(0);
+
+            bool first = true;
+            if ((EL->first() > maxx) || (EL->last() < minx)) {
+                continue;
+            }
+
+            for (quint32 e = 0; e < ELsize; ++e) {
+                qint64 time = EL->time(e);
+                EventStoreType data = EL->raw(e);
+
+                if ((time < minx)) {
+                    if (first) {
+                        lasttime = time;
+                        lastdata = data;
+                        first = false;
+                    }
+                    goto skip;
+                }
+
+                if (first) {
+                    lasttime = time;
+                    lastdata = data;
+                    first = false;
+                }
+
+                if ((lastdata != data) || (time > maxx)) {
+
+                    int duration = (time - lasttime) / 1000L;
+                    EventStoreType key = floor(lastdata * gain);
+                    if (key <= 30) {
+                        times[key] += duration;
+                        for (int c = 0; c < chans.size(); ++c) {
+                            ChannelID code = chans.at(c);
+                            schema::Channel & chan = schema::channel[code];
+                            if (chan.type() == schema::SPAN) {
+                                events[code][key] += sess->rangeSum(code, qMax(minx, lasttime), qMin(maxx, time));
+                            } else {
+                                events[code][key] += sess->rangeCount(code, qMax(minx, lasttime), qMin(maxx, time));
+                            }
+                        }
+                    }
+                    lasttime = time;
+                    lastdata = data;
+                }
+                if (time > maxx) break;
+skip:
+                if (m_quit) {
+                    m_done = true;
+                    return;
+                }
+            }
+
+        }
+    }
+
+
+    QMap<EventStoreType, int>::iterator it;
+    QMap<EventStoreType, int>::iterator times_end = times.end();
+    int maxtime = 0;
+
+    for (it = times.begin(); it != times_end; ++it) {
+        maxtime = qMax(it.value(), maxtime);
+    }
+
+
+    QMutexLocker timelock(&map->timelock);
+    map->times = times;
+    map->events = events;
+    map->maxtime = maxtime;
+    map->chans = chans;
+    timelock.unlock();
+
+    map->recalcFinished();
+    m_done = true;
+}
+
+void MinutesAtPressure::recalculate(gGraph * graph)
+{
+
+    while (recalculating())
+        m_remap->quit();
+
+    m_remap = new RecalcMAP(this);
+    m_remap->setAutoDelete(true);
+
+    m_graph = graph;
+
+    QThreadPool * tp = QThreadPool::globalInstance();
+//    tp->reserveThread();
+
+    while(!tp->tryStart(m_remap));
+
+
+    // Start recalculating in another thread, organize a callback to redraw when done..
+
+
+}
+
+void MinutesAtPressure::recalcFinished()
+{
+    if (m_graph) {
+        m_graph->timedRedraw(0);
+    }
+    m_recalculating = false;
+    m_remap = nullptr;
+//    QThreadPool * tp = QThreadPool::globalInstance();
+//    tp->releaseThread();
+
+}
+
+
+bool MinutesAtPressure::mouseMoveEvent(QMouseEvent *event, gGraph *graph)
+{
+    Q_UNUSED(event);
+    Q_UNUSED(graph);
+    return true;
+}
+
+bool MinutesAtPressure::mousePressEvent(QMouseEvent *event, gGraph *graph)
+{
+    Q_UNUSED(event);
+    Q_UNUSED(graph);
+    return true;
+}
+
+bool MinutesAtPressure::mouseReleaseEvent(QMouseEvent *event, gGraph *graph)
+{
+    Q_UNUSED(event);
+    Q_UNUSED(graph);
+    return true;
+}

sleepyhead/Graphs/MinutesAtPressure.h

@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ *
+ * Minutes At Pressure Graph Header
+ *
+ * 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. */
+
+#ifndef MINUTESATPRESSURE_H
+#define MINUTESATPRESSURE_H
+
+#include "Graphs/layer.h"
+#include "SleepLib/day.h"
+
+class MinutesAtPressure;
+class RecalcMAP:public QRunnable
+{
+    friend class MinutesAtPressure;
+public:
+    explicit RecalcMAP(MinutesAtPressure * map) :map(map), m_quit(false), m_done(false) {}
+    virtual ~RecalcMAP();
+    virtual void run();
+    void quit();
+protected:
+    MinutesAtPressure * map;
+    volatile bool m_quit;
+    volatile bool m_done;
+};
+
+class MinutesAtPressure:public Layer
+{
+    friend class RecalcMAP;
+public:
+    MinutesAtPressure();
+    virtual ~MinutesAtPressure();
+
+    virtual void recalculate(gGraph * graph);
+
+    virtual void SetDay(Day *d);
+
+    virtual bool isEmpty();
+
+    //! Draw filled rectangles behind Event Flag's, and an outlines around them all, Calls the individual paint for each gFlagLine
+    virtual void paint(QPainter &painter, gGraph &w, const QRegion &region);
+
+
+    bool mouseMoveEvent(QMouseEvent *event, gGraph *graph);
+    bool mousePressEvent(QMouseEvent *event, gGraph *graph);
+    bool mouseReleaseEvent(QMouseEvent *event, gGraph *graph);
+
+    virtual void recalcFinished();
+
+protected:
+    QMutex timelock;
+    QMutex mutex;
+
+    bool m_empty;
+
+    qint64 m_lastminx;
+    qint64 m_lastmaxx;
+    gGraph * m_graph;
+    RecalcMAP * m_remap;
+    QMap<EventStoreType, int> times;
+    QList<ChannelID> chans;
+    QHash<ChannelID, QMap<EventStoreType, EventDataType> > events;
+    int maxtime;
+
+    QMap<EventStoreType, EventDataType> ahis;
+};
+
+#endif // MINUTESATPRESSURE_H

sleepyhead/Graphs/gFlagsLine.cpp

@@ -64,23 +64,6 @@ void gFlagsGroup::SetDay(Day *d)
         return;
     }
 
-    schema::channel[CPAP_CSR].setOrder(1);
-    schema::channel[CPAP_CSR].setOrder(1);
-    schema::channel[CPAP_Ramp].setOrder(2);
-    schema::channel[CPAP_LargeLeak].setOrder(2);
-    schema::channel[CPAP_ClearAirway].setOrder(3);
-    schema::channel[CPAP_Obstructive].setOrder(4);
-    schema::channel[CPAP_Apnea].setOrder(4);
-    schema::channel[CPAP_NRI].setOrder(3);
-    schema::channel[CPAP_Hypopnea].setOrder(5);
-    schema::channel[CPAP_FlowLimit].setOrder(6);
-    schema::channel[CPAP_RERA].setOrder(6);
-    schema::channel[CPAP_VSnore].setOrder(7);
-    schema::channel[CPAP_VSnore2].setOrder(8);
-    schema::channel[CPAP_ExP].setOrder(6);
-    schema::channel[CPAP_UserFlag1].setOrder(256);
-    schema::channel[CPAP_UserFlag2].setOrder(257);
-
 
     quint32 z = schema::FLAG | schema::SPAN;
     if (p_profile->general->showUnknownFlags()) z |= schema::UNKNOWN;

sleepyhead/Graphs/gLineChart.cpp

@@ -176,7 +176,7 @@ skipcheck:
             lob = new gLineOverlayBar(code, chan->defaultColor(), chan->label(), FT_Span);
         }
         if (lob != nullptr) {
-            lob->setOverlayDisplayType((m_codes[0] == CPAP_FlowRate) ? (OverlayDisplayType)p_profile->appearance->overlayType() : ODT_TopAndBottom);
+            lob->setOverlayDisplayType(((m_codes[0] == CPAP_FlowRate) || (m_codes[0] == CPAP_MaskPressureHi))? (OverlayDisplayType)p_profile->appearance->overlayType() : ODT_TopAndBottom);
             lob->SetDay(m_day);
             flags[code] = lob;
         }
@@ -207,6 +207,15 @@ skipcheck:
 //            }
 //        }
 //    }
+
+    QList<ChannelID> middles;
+
+    middles.push_back(CPAP_RespRate);
+    middles.push_back(CPAP_TidalVolume);
+    middles.push_back(CPAP_MinuteVent);
+    middles.push_back(CPAP_Ti);
+    middles.push_back(CPAP_Te);
+
     CPAPMode mode = (CPAPMode)m_day->settings_wavg(CPAP_Mode);
     float perc = p_profile->general->prefCalcPercentile();
     for (int i=0; i<m_codes.size(); ++i) {
@@ -244,7 +253,16 @@ skipcheck:
             }
         } else if (code == CPAP_Leak) {
             m_threshold.push_back(QObject::tr("%1 threshold").arg(chan.fullname()));
-        } else m_threshold.push_back(QString());
+        } else if (middles.contains(code)) {
+            float f = m_day->calcMiddle(code);
+
+            chan.setUpperThreshold(f);
+            chan.setUpperThresholdColor(Qt::black);
+            m_threshold.push_back(m_day->calcMiddleLabel(code));
+        } else {
+            chan.setUpperThreshold(0);
+            m_threshold.push_back(QString());
+        }
     }
 }
 EventDataType gLineChart::Miny()
@@ -445,6 +463,7 @@ void gLineChart::paint(QPainter &painter, gGraph &w, const QRegion &region)
     painter.setClipping(true);
     painter.setRenderHint(QPainter::Antialiasing, p_profile->appearance->antiAliasing());
 
+    painter.setFont(*defaultfont);
 
     for (int gi = 0; gi < m_codes.size(); gi++) {
         ChannelID code = m_codes[gi];
@@ -986,6 +1005,7 @@ void gLineChart::paint(QPainter &painter, gGraph &w, const QRegion &region)
 
         for (fit = flags.begin(); fit != flags.end(); ++fit) {
             ChannelID code = fit.key();
+            if (!m_day->channelExists(code)) continue;
             gLineOverlayBar * lob = fit.value();
             lob->setBlockHover(blockhover);
             lob->paint(painter, w, region);
@@ -998,14 +1018,16 @@ void gLineChart::paint(QPainter &painter, gGraph &w, const QRegion &region)
         }
     }
     if (m_codes[0] == CPAP_FlowRate) {
-        float hours = float(time) / 3600.0;
+        float hours = time / 3600.0;
         int h = time / 3600;
         int m = int(time / 60) % 60;
         int s = int(time) % 60;
 
-        float f = float(cnt) / hours; // / (sum / 3600.0);
+        double f = double(cnt) / hours; // / (sum / 3600.0);
         QString txt = QObject::tr("Duration %1:%2:%3").arg(h,2,10,QChar('0')).arg(m,2,10,QChar('0')).arg(s,2,10,QChar('0')) + " "+
-                QObject::tr("AHI %1").arg(f,0,'f',2);
+                QObject::tr("AHI %1").arg(f,0,'f',2) +" " +
+                QObject::tr("Events %1").arg(cnt) + " " +
+                QObject::tr("Hours %1").arg(hours,0,'f',2);
         w.renderText(txt,left,top-4);
     }
 

sleepyhead/Graphs/gdailysummary.cpp

@@ -22,6 +22,20 @@ gDailySummary::gDailySummary() : Layer(NoChannel)
 
 void gDailySummary::SetDay(Day *day)
 {
+    QList<ChannelID> piechans;
+
+    piechans.append(CPAP_ClearAirway);
+    piechans.append(CPAP_Obstructive);
+    piechans.append(CPAP_Apnea);
+    piechans.append(CPAP_Hypopnea);
+    piechans.append(CPAP_RERA);
+    piechans.append(CPAP_FlowLimit);
+
+    pie_data.clear();
+    pie_chan.clear();
+    pie_labels.clear();
+    pie_total = 0;
+
     m_day = day;
     if (day) {
         m_minx = m_day->first();
@@ -48,20 +62,27 @@ void gDailySummary::SetDay(Day *day)
         for (int i=0; i < available.size(); ++i) {
             ChannelID code = available.at(i);
             schema::Channel & chan = schema::channel[code];
-            QString data;
+            QString str;
             if (chan.type() == schema::SPAN) {
                 val = (100.0 / hours)*(day->sum(code)/3600.0);
-                data = QString("%1%").arg(val,0,'f',2);
+                str = QString("%1%").arg(val,0,'f',2);
             } else {
                 val = day->count(code) / hours;
-                data = QString("%1").arg(val,0,'f',2);
+                str = QString("%1").arg(val,0,'f',2);
             }
-            flag_values.push_back(data);
+            flag_values.push_back(str);
             flag_codes.push_back(code);
             flag_background.push_back(chan.defaultColor());
             flag_foreground.push_back((brightness(chan.defaultColor()) < 0.3) ? Qt::white : Qt::black); // pick a contrasting color
-
             QString label = chan.fullname();
+
+            if (piechans.contains(code)) {
+                pie_data.push_back(val);
+                pie_labels.push_back(chan.label());
+                pie_chan.append(code);
+                pie_total += val;
+            }
+
             flag_labels.push_back(label);
             GetTextExtent(label, x, y, defaultfont);
 
@@ -69,15 +90,16 @@ void gDailySummary::SetDay(Day *day)
             if (y > flag_height) flag_height = y;
             if (x > flag_label_width) flag_label_width  = x;
 
-            GetTextExtent(data, x, y, defaultfont);
+            GetTextExtent(str, x, y, defaultfont);
             if (x > flag_value_width) flag_value_width = x;
             if (y > flag_height) flag_height = y;
         }
-        m_empty = (available.size() > 0);
 
         info_labels.clear();
         info_values.clear();
 
+        ahi = day->calcAHI();
+
         QDateTime dt = QDateTime::fromMSecsSinceEpoch(day->first());
         info_labels.append(QObject::tr("Date"));
         info_values.append(dt.date().toString(Qt::LocaleDate));
@@ -107,6 +129,9 @@ void gDailySummary::SetDay(Day *day)
 
         m_minimum_height = flag_values.size() * flag_height;
 
+        m_empty = !(day->channelExists(CPAP_Pressure) || day->channelExists(CPAP_IPAP));
+
+
     } else {
         m_minx = m_maxx = 0;
         m_miny = m_maxy = 0;
@@ -118,8 +143,7 @@ void gDailySummary::SetDay(Day *day)
 
 bool gDailySummary::isEmpty()
 {
-
+    return m_empty;
-    return false;
 }
 
 
@@ -128,10 +152,10 @@ void gDailySummary::paint(QPainter &painter, gGraph &w, const QRegion &region)
 
     QRect rect = region.boundingRect();
 
-    int top = rect.top();
+    int top = rect.top()-10;
     int left = rect.left();
     int width = rect.width();
-    int height = rect.height();
+    int height = rect.height()+10;
 
     // Draw bounding box
     painter.setPen(QColor(Qt::black));
@@ -140,6 +164,8 @@ void gDailySummary::paint(QPainter &painter, gGraph &w, const QRegion &region)
 
     QRectF rect1, rect2;
     int size;
+
+
 //    QFontMetrics fm(*mediumfont);
 //    top += fm.height();
 //    painter.setFont(*mediumfont);
@@ -157,16 +183,29 @@ void gDailySummary::paint(QPainter &painter, gGraph &w, const QRegion &region)
 //    row += rect1.height()+rect2.height()-5;
 //    column = left + 10;
 
+    float row = top + 10;
+    float column = left+10;
+
+    rect1 = QRectF(column - 10, row -5, 0, 0);
+    painter.setFont(*mediumfont);
+    QString txt = QString::number(ahi, 'f', 2);
+    QString ahi = QString("%1: %2").arg(STR_TR_AHI).arg(txt);
+    rect1 = painter.boundingRect(rect1, Qt::AlignTop || Qt::AlignLeft, ahi);
+    rect1.setWidth(rect1.width()*2);
+    rect1.setHeight(rect1.height() * 1.5);
+    painter.fillRect(rect1, QColor("orange"));
+    painter.setPen(Qt::black);
+    painter.drawText(rect1, Qt::AlignCenter, ahi);
+    painter.drawRoundedRect(rect1, 5, 5);
+
+    column += rect1.width() + 10;
+
     size = flag_values.size();
-
-
     int vis = 0;
     for (int i=0; i < size; ++i) {
         schema::Channel & chan = schema::channel[flag_codes.at(i)];
         if (chan.enabled()) vis++;
     }
-    float row = top + 10;
-    float column = left+10;
 
     flag_value_width = 0;
     flag_label_width = 0;
@@ -176,6 +215,8 @@ void gDailySummary::paint(QPainter &painter, gGraph &w, const QRegion &region)
     QFont font(defaultfont->family());
     font.setPixelSize(hpl*0.75);
 
+    font.setBold(true);
+    font.setItalic(true);
     painter.setFont(font);
 
     for (int i=0; i < size; ++i) {
@@ -197,6 +238,10 @@ void gDailySummary::paint(QPainter &painter, gGraph &w, const QRegion &region)
     painter.setPen(QPen(Qt::gray, 1));
     painter.drawRoundedRect(flag_outline, 5, 5);
 
+    font.setBold(false);
+    font.setItalic(false);
+    painter.setFont(font);
+
 
     for (int i=0; i < size; ++i) {
         schema::Channel & chan = schema::channel[flag_codes.at(i)];
@@ -226,13 +271,63 @@ void gDailySummary::paint(QPainter &painter, gGraph &w, const QRegion &region)
 
         row += (flag_height);
 
-//        if (row > (top + rect.height() - flag_height - 4)) {
-//            row = top;
-//            column += flag_label_width + 20 + flag_value_width + 5;
-//        }
     }
+    column += 22 + flag_label_width + flag_value_width + 20;
+    row = top + 10;
+
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Pie Chart
+    ////////////////////////////////////////////////////////////////////////////////
+    painter.setRenderHint(QPainter::Antialiasing);
+    QRect pierect(column, row, height-30, height-30);
+
+    float sum = -90.0;
+
+    int slices = pie_data.size();
+    EventDataType data;
+    for (int i=0; i < slices; ++i) {
+        data = pie_data[i];
+
+        if (data == 0) { continue; }
+
+        // Setup the shiny radial gradient
+        float len = 360.0 / float(pie_total) * float(data);
+        QColor col = schema::channel[pie_chan[i]].defaultColor();
+
+        painter.setPen(QPen(col, 0));
+        QRadialGradient gradient(pierect.center(), float(pierect.width()) / 2.0, pierect.center());
+        gradient.setColorAt(0, Qt::white);
+        gradient.setColorAt(1, col);
+
+        // draw filled pie
+        painter.setBrush(gradient);
+        painter.setBackgroundMode(Qt::OpaqueMode);
+        painter.drawPie(pierect, -sum * 16.0, -len * 16.0);
+
+        // draw outline
+        painter.setBackgroundMode(Qt::TransparentMode);
+        painter.setBrush(QBrush(col,Qt::NoBrush));
+        painter.setPen(QPen(QColor(Qt::black),1.5));
+        painter.drawPie(pierect, -sum * 16.0, -len * 16.0);
+        sum += len;
+
+    }
+
 }
 
+bool gDailySummary::mousePressEvent(QMouseEvent *event, gGraph *graph)
+{
+    Q_UNUSED(event)
+    Q_UNUSED(graph)
+    return true;
+}
+bool gDailySummary::mouseReleaseEvent(QMouseEvent *event, gGraph *graph)
+{
+    Q_UNUSED(event)
+    Q_UNUSED(graph)
+    return true;
+}
 
 bool gDailySummary::mouseMoveEvent(QMouseEvent *event, gGraph *graph)
 {

sleepyhead/Graphs/gdailysummary.h

@@ -1,7 +1,7 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  *
- * gDailySummary Graph Implementation
+ * gDailySummary Graph Header
  *
  * Copyright (c) 2011-2014 Mark Watkins <jedimark@users.sourceforge.net>
  *
@@ -30,6 +30,8 @@ public:
 
     virtual int minimumHeight() { return m_minimum_height; }
     bool mouseMoveEvent(QMouseEvent *event, gGraph *graph);
+    bool mousePressEvent(QMouseEvent *event, gGraph *graph);
+    bool mouseReleaseEvent(QMouseEvent *event, gGraph *graph);
 
 protected:
     QList<QString> flag_values;
@@ -38,6 +40,12 @@ protected:
     QList<QColor> flag_foreground;
     QList<QColor> flag_background;
 
+
+    QList<ChannelID> pie_chan;
+    QList<EventDataType> pie_data;
+    QList<QString> pie_labels;
+    EventDataType pie_total;
+
     QList<QString> info_labels;
     QList<QString> info_values;
 
@@ -45,6 +53,8 @@ protected:
     float flag_label_width;
     float flag_value_width;
 
+    double ahi;
+
     int info_height;
     int info_label_width;
     int info_value_width;

sleepyhead/Graphs/layer.h

@@ -48,9 +48,11 @@ class Layer
           m_width(0), m_height(0),
           m_X(0), m_Y(0),
           m_order(0),
-          m_position(LayerCenter)
+          m_position(LayerCenter),
+          m_recalculating(false)
     { }
 
+    virtual void recalculate(gGraph * graph) { Q_UNUSED(graph)};
     virtual ~Layer();
 
     //! \brief This gets called on day selection, allowing this layer to precalculate any drawing data
@@ -107,13 +109,15 @@ class Layer
     void setVisible(bool b) { m_visible = b; }
 
     //! \brief Return this layers Visibility status
-    bool visible() const { return m_visible; }
+    inline bool visible() const { return m_visible; }
 
     //! \brief Set this layers Moveability status (not really used yet)
     void setMovable(bool b) { m_movable = b; }
 
     //! \brief Return this layers Moveability status (not really used yet)
-    bool movable() const { return m_movable; }
+    inline bool movable() const { return m_movable; }
+
+    inline bool recalculating() const { return m_recalculating; }
 
     /*! \brief Override this for the drawing code, using GLBuffer components for drawing
         \param gGraph & gv    Graph Object that holds this layer
@@ -129,8 +133,8 @@ class Layer
 
     void setPos(short x, short y) { m_X = x; m_Y = y; }
 
-    int Width() { return m_width; }
+    inline int Width() const { return m_width; }
-    int Height() { return m_height; }
+    inline int Height() const { return m_height; }
 
     //! \brief Return this Layers Layout Position.
     LayerPosition position() { return m_position; }
@@ -169,6 +173,8 @@ class Layer
     LayerPosition m_position;
     QRect m_rect;
     bool m_mouseover;
+    volatile bool m_recalculating;
+
 
 //    //! \brief A vector containing all this layers custom drawing buffers
 //    QVector<GLBuffer *> mgl_buffers;
@@ -272,6 +278,7 @@ class LayerGroup : public Layer
 
     //! \brief A key was pressed on the keyboard while the graph area was focused.
     virtual bool keyPressEvent(QKeyEvent *event, gGraph *graph);
+
 };
 
 #endif // graphs_layer_h

sleepyhead/SleepLib/day.cpp

@@ -54,6 +54,48 @@ void Day::AddSession(Session *s)
 
     sessions.push_back(s);
 }
+EventDataType Day::calcMiddle(ChannelID code)
+{
+    int c = p_profile->general->prefCalcMiddle();
+
+    if (c == 0) {
+        return percentile(code, 0.5); // Median
+    } else if (c == 1 ) {
+        return wavg(code); // Weighted Average
+    } else {
+        return avg(code); // Average
+    }
+}
+EventDataType Day::calcMax(ChannelID code)
+{
+    return p_profile->general->prefCalcMax() ? percentile(code, 0.995) : Max(code);
+}
+EventDataType Day::calcPercentile(ChannelID code)
+{
+    double p = p_profile->general->prefCalcPercentile() / 100.0;
+    return percentile(code, p);
+}
+
+QString Day::calcMiddleLabel(ChannelID code)
+{
+    int c = p_profile->general->prefCalcMiddle();
+    if (c == 0) {
+        return QObject::tr("%1 %2").arg(STR_TR_Median).arg(schema::channel[code].fullname());
+    } else if (c == 1) {
+        return QObject::tr("%1 %2").arg(STR_TR_Average).arg(schema::channel[code].fullname());
+    } else {
+        return QObject::tr("%1 %2").arg(STR_TR_Average).arg(schema::channel[code].fullname());
+    }
+}
+QString Day::calcMaxLabel(ChannelID code)
+{
+    return QObject::tr("%1 %2").arg(p_profile->general->prefCalcMax() ? QObject::tr("Peak") : QObject::tr("Maximum")).arg(schema::channel[code].fullname());
+}
+QString Day::calcPercentileLabel(ChannelID code)
+{
+    return QObject::tr("%1% %2").arg(p_profile->general->prefCalcPercentile(),0, 'f').arg(schema::channel[code].fullname());
+}
+
 
 
 EventDataType Day::countInsideSpan(ChannelID span, ChannelID code)

sleepyhead/SleepLib/day.h

@@ -187,6 +187,58 @@ class Day
     QString getPressureRelief();
     QString getPressureSettings();
 
+    // Some more very much CPAP only related stuff
+
+    //! \brief Calculate AHI (Apnea Hypopnea Index)
+    EventDataType calcAHI() {
+        EventDataType c = count(CPAP_Hypopnea) + count(CPAP_Obstructive) + count(CPAP_Apnea) + count(CPAP_ClearAirway);
+        EventDataType minutes = hours() * 60.0;
+        return (c * 60.0) / minutes;
+    }
+
+    //! \brief Calculate RDI (Respiratory Disturbance Index)
+    EventDataType calcRDI() {
+        EventDataType c = count(CPAP_Hypopnea) + count(CPAP_Obstructive) + count(CPAP_Apnea) + count(CPAP_ClearAirway) + count(CPAP_RERA);
+        EventDataType minutes = hours() * 60.0;
+        return (c * 60.0) / minutes;
+    }
+
+    //! \brief Percent of night for specified channel
+    EventDataType calcPON(ChannelID code) {
+        EventDataType c = sum(code);
+        EventDataType minutes = hours() * 60.0;
+
+        return (100.0 / minutes) * (c / 60.0);
+    }
+
+    //! \brief Calculate index (count per hour) for specified channel
+    EventDataType calcIdx(ChannelID code) {
+        EventDataType c = count(code);
+        EventDataType minutes = hours() * 60.0;
+
+        return (c * 60.0) / minutes;
+    }
+
+    //! \brief SleepyyHead Events Index, AHI combined with SleepyHead detected events.. :)
+    EventDataType calcSHEI() {
+        EventDataType c = count(CPAP_Hypopnea) + count(CPAP_Obstructive) + count(CPAP_Apnea) + count(CPAP_ClearAirway) + count(CPAP_UserFlag1) + count(CPAP_UserFlag2);
+        EventDataType minutes = hours() * 60.0;
+        return (c * 60.0) / minutes;
+    }
+    //! \brief Total duration of all Apnea/Hypopnea events in seconds,
+    EventDataType calcTTIA() {
+        EventDataType c = sum(CPAP_Hypopnea) + sum(CPAP_Obstructive) + sum(CPAP_Apnea) + sum(CPAP_ClearAirway);
+        return c;
+    }
+
+    // According to preferences..
+    EventDataType calcMiddle(ChannelID code);
+    EventDataType calcMax(ChannelID code);
+    EventDataType calcPercentile(ChannelID code);
+    QString calcMiddleLabel(ChannelID code);
+    QString calcMaxLabel(ChannelID code);
+    QString calcPercentileLabel(ChannelID code);
+
     QList<Session *> sessions;
 
   protected:

sleepyhead/daily.cpp

@@ -43,6 +43,7 @@
 #include "Graphs/gSegmentChart.h"
 #include "Graphs/gStatsLine.h"
 #include "Graphs/gdailysummary.h"
+#include "Graphs/MinutesAtPressure.h"
 
 //extern QProgressBar *qprogress;
 extern MainWindow * mainwin;
@@ -149,6 +150,7 @@ Daily::Daily(QWidget *parent,gGraphView * shared)
             *AHI = nullptr;
 
     const QString STR_GRAPH_DailySummary = "DailySummary";
+    const QString STR_GRAPH_TAP = "TimeAtPressure";
 
 //    gGraph * SG;
 //    graphlist[STR_GRAPH_DailySummary] = SG = new gGraph(STR_GRAPH_DailySummary, GraphView, QObject::tr("Summary"), QObject::tr("Summary of this daily information"), default_height);
@@ -269,6 +271,7 @@ Daily::Daily(QWidget *parent,gGraphView * shared)
     skipgraph.push_back(STR_GRAPH_EventBreakdown);
     skipgraph.push_back(STR_GRAPH_SleepFlags);
     skipgraph.push_back(STR_GRAPH_DailySummary);
+    skipgraph.push_back(STR_GRAPH_TAP);
 
     QHash<QString, gGraph *>::iterator it;
 
@@ -335,6 +338,11 @@ Daily::Daily(QWidget *parent,gGraphView * shared)
     pc->addPlot(CPAP_IPAP, COLOR_IPAP, square);
     pc->addPlot(CPAP_IPAPHi, COLOR_IPAPHi, square);
 
+    gGraph * TAP2;
+    graphlist[STR_GRAPH_TAP] = TAP2 = new gGraph(STR_GRAPH_TAP, GraphView, QObject::tr("Time @ Pressure"), QObject::tr("Time at Pressure"), default_height);
+    TAP2->AddLayer(new gFlagsLabelArea(nullptr),LayerLeft,gYAxis::Margin);
+    TAP2->AddLayer(AddCPAP(new MinutesAtPressure()));
+
     if (p_profile->general->calculateRDI()) {
         AHI->AddLayer(AddCPAP(new gLineChart(CPAP_RDI, COLOR_RDI, square)));
 //        AHI->AddLayer(AddCPAP(new AHIChart(QColor("#37a24b"))));

sleepyhead/main.cpp

@@ -59,6 +59,25 @@ void initialize()
     schema::init();
 }
 
+void setOrders() {
+    schema::channel[CPAP_CSR].setOrder(1);
+    schema::channel[CPAP_Ramp].setOrder(2);
+    schema::channel[CPAP_LargeLeak].setOrder(2);
+    schema::channel[CPAP_ClearAirway].setOrder(3);
+    schema::channel[CPAP_Obstructive].setOrder(4);
+    schema::channel[CPAP_Apnea].setOrder(4);
+    schema::channel[CPAP_NRI].setOrder(3);
+    schema::channel[CPAP_Hypopnea].setOrder(5);
+    schema::channel[CPAP_FlowLimit].setOrder(6);
+    schema::channel[CPAP_RERA].setOrder(6);
+    schema::channel[CPAP_VSnore].setOrder(7);
+    schema::channel[CPAP_VSnore2].setOrder(8);
+    schema::channel[CPAP_ExP].setOrder(6);
+    schema::channel[CPAP_UserFlag1].setOrder(256);
+    schema::channel[CPAP_UserFlag2].setOrder(257);
+}
+
+
 void release_notes()
 {
     QDialog relnotes;
@@ -273,6 +292,8 @@ retry_directory:
     MD300W1Loader::Register();
     //ZEOLoader::Register(); // Use outside of directory importer..
 
+    setOrders();
+
     p_pref = new Preferences("Preferences");
     p_layout = new Preferences("Layout");
 

sleepyhead/overview.cpp

@@ -306,8 +306,6 @@ Overview::Overview(QWidget *parent, gGraphView *shared) :
     nll->addSlice(CPAP_LargeLeak, schema::channel[CPAP_LargeLeak].defaultColor(), ST_SPH);
     // <--- The code to the previous marker is crap
 
-    GraphView->resetLayout();
-    GraphView->LoadSettings("Overview"); //no trans
     AHI->setPinned(false);
     ui->rangeCombo->setCurrentIndex(6);
     icon_on = new QIcon(":/icons/session-on.png");
@@ -315,6 +313,9 @@ Overview::Overview(QWidget *parent, gGraphView *shared) :
     SES->setRecMinY(1);
     SET->setRecMinY(0);
     //SET->setRecMaxY(5);
+
+    GraphView->resetLayout();
+    GraphView->LoadSettings("Overview"); //no trans
 }
 Overview::~Overview()
 {

sleepyhead/sleepyhead.pro

@@ -179,7 +179,8 @@ SOURCES += \
     welcome.cpp \
     SleepLib/machine_common.cpp \
     SleepLib/loader_plugins/weinmann_loader.cpp \
-    Graphs/gdailysummary.cpp
+    Graphs/gdailysummary.cpp \
+    Graphs/MinutesAtPressure.cpp
 
 HEADERS  += \
     common_gui.h \
@@ -236,7 +237,8 @@ HEADERS  += \
     Graphs/gSessionTimesChart.h \
     logger.h \
     SleepLib/loader_plugins/weinmann_loader.h \
-    Graphs/gdailysummary.h
+    Graphs/gdailysummary.h \
+    Graphs/MinutesAtPressure.h
 
 FORMS += \
     daily.ui \