OSCAR-code/sleepyhead/Graphs/gLineChart.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=8 sts=4 et sw=4 tw=99:
 *
 * gLineChart 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 "Graphs/gLineChart.h"

#include <QString>
#include <QDebug>

#include <math.h>

#include "Graphs/glcommon.h"
#include "Graphs/gGraph.h"
#include "Graphs/gGraphView.h"
#include "SleepLib/profiles.h"
#include "Graphs/gLineOverlay.h"

#define EXTRA_ASSERTS 1
gLineChart::gLineChart(ChannelID code, QColor col, bool square_plot, bool disable_accel)
    : Layer(code), m_square_plot(square_plot), m_disable_accel(disable_accel)
{
    addPlot(code, col, square_plot);
    m_line_color = col;
    m_report_empty = false;
    lines.reserve(50000);
    lasttime = 0;
}
gLineChart::~gLineChart()
{
    QHash<ChannelID, gLineOverlayBar *>::iterator fit;
    for (fit = flags.begin(); fit != flags.end(); ++fit) {
        // destroy any overlay bar from previous day
        delete fit.value();
    }

    flags.clear();

}

bool gLineChart::isEmpty()
{
    if (!m_day) { return true; }

    for (int j = 0; j < m_codes.size(); j++) {
        ChannelID code = m_codes[j];

        for (int i = 0; i < m_day->size(); i++) {
            Session *sess = m_day->sessions[i];

            if (sess->channelExists(code)) {
                return false;
            }
        }
    }

    return true;
}

void gLineChart::SetDay(Day *d)
{
    //    Layer::SetDay(d);
    m_day = d;

    m_minx = 0, m_maxx = 0;
    m_miny = 0, m_maxy = 0;
    m_physminy = 0, m_physmaxy = 0;

    if (!d) {
        return;
    }

    qint64 t64;
    EventDataType tmp;

    bool first = true;

    for (int j = 0; j < m_codes.size(); j++) {
        ChannelID code = m_codes[j];

        for (int i = 0; i < d->size(); i++) {
            Session *sess = d->sessions[i];

            if (code == CPAP_MaskPressure) {
                if (sess->channelExists(CPAP_MaskPressureHi)) {
                    code = m_codes[j] = CPAP_MaskPressureHi;
                    goto skipcheck; // why not :P
                }
            }

            if (!sess->channelExists(code)) {
                continue;
            }

skipcheck:
            if (first) {
                m_miny = sess->Min(code);
                m_maxy = sess->Max(code);
                m_physminy = sess->physMin(code);
                m_physmaxy = sess->physMax(code);
                m_minx = sess->first(code);
                m_maxx = sess->last(code);
                first = false;
            } else {
                tmp = sess->physMin(code);

                if (m_physminy > tmp) {
                    m_physminy = tmp;
                }

                tmp = sess->physMax(code);

                if (m_physmaxy < tmp) {
                    m_physmaxy = tmp;
                }

                tmp = sess->Min(code);

                if (m_miny > tmp) {
                    m_miny = tmp;
                }

                tmp = sess->Max(code);

                if (m_maxy < tmp) {
                    m_maxy = tmp;
                }

                t64 = sess->first(code);

                if (m_minx > t64) {
                    m_minx = t64;
                }

                t64 = sess->last(code);

                if (m_maxx < t64) {
                    m_maxx = t64;
                }
            }
        }

    }

    subtract_offset = 0;

    QHash<ChannelID, gLineOverlayBar *>::iterator fit;
    for (fit = flags.begin(); fit != flags.end(); ++fit) {
        // destroy any overlay bar from previous day
        delete fit.value();
    }

    flags.clear();

    quint32 z = schema::FLAG | schema::MINOR_FLAG | schema::SPAN;
    if (p_profile->general->showUnknownFlags()) z |= schema::UNKNOWN;
    QList<ChannelID> available = m_day->getSortedMachineChannels(z);

    for (int i=0; i < available.size(); ++i) {
        ChannelID code = available.at(i);

        schema::Channel * chan = &schema::channel[code];
        gLineOverlayBar * lob = nullptr;

        if (chan->type() == schema::FLAG) {
            lob = new gLineOverlayBar(code, chan->defaultColor(), chan->label(), FT_Bar);
        } else if ((chan->type() == schema::MINOR_FLAG) || (chan->type() == schema::UNKNOWN)) {
            lob = new gLineOverlayBar(code, chan->defaultColor(), chan->label(), FT_Dot);
        } else if (chan->type() == schema::SPAN) {
            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->SetDay(m_day);
            flags[code] = lob;
        }
    }

//    for (int i=0; i< m_day->size(); ++i) {
//        Session * sess = m_day->sessions.at(i);
//        QHash<ChannelID, QVector<EventList *> >::iterator it;
//        for (it = sess->eventlist.begin(); it != sess->eventlist.end(); ++it) {
//            ChannelID code = it.key();

//            if (flags.contains(code)) continue;

//            schema::Channel * chan = &schema::channel[code];
//            gLineOverlayBar * lob = nullptr;

//            if (chan->type() == schema::FLAG) {
//                lob = new gLineOverlayBar(code, chan->defaultColor(), chan->label(), FT_Bar);
//            } else if (chan->type() == schema::MINOR_FLAG) {
//                lob = new gLineOverlayBar(code, chan->defaultColor(), chan->label(), FT_Dot);
//            } else if (chan->type() == schema::SPAN) {
//                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->SetDay(m_day);
//                flags[code] = lob;
//            }
//        }
//    }
    CPAPMode mode = (CPAPMode)m_day->settings_wavg(CPAP_Mode);
    float perc = p_profile->general->prefCalcPercentile();
    for (int i=0; i<m_codes.size(); ++i) {
        ChannelID code = m_codes.at(i);
        schema::Channel & chan = schema::channel[code];
        if (code == CPAP_Pressure) {
            if (mode == MODE_APAP) {
                float f = m_day->percentile(code, perc / 100.0);
                chan.setUpperThreshold(f);
                chan.setUpperThresholdColor(Qt::black);
                m_threshold.push_back(QString("%1% %2 %3").arg(perc, 0, 'f', 0).arg(chan.fullname()).arg(f,0,'f',2));
            } else {
                chan.setUpperThreshold(0);
                m_threshold.push_back(QString());
            }
        } else if (code == CPAP_IPAP) {
            if (mode >= MODE_BILEVEL_AUTO_FIXED_PS) {
                float f = m_day->percentile(code,perc / 100.0);
                chan.setUpperThreshold(f);
                chan.setUpperThresholdColor(Qt::black);
                m_threshold.push_back(QString("%1% %2 %3").arg(perc, 0, 'f', 0).arg(chan.fullname()).arg(f,0,'f',2));
            } else {
                chan.setUpperThreshold(0);
                m_threshold.push_back(QString());
            }
        } else if (code == CPAP_EPAP) {
            if ((mode >= MODE_BILEVEL_AUTO_FIXED_PS) && (mode != MODE_ASV)) {
                float f = m_day->percentile(code,perc / 100.0);
                chan.setUpperThreshold(f);
                chan.setUpperThresholdColor(Qt::black);
                m_threshold.push_back(QString("%1% %2 %3").arg(perc, 0, 'f', 0).arg(chan.fullname()).arg(f,0,'f',2));
            } else {
                chan.setUpperThreshold(0);
                m_threshold.push_back(QString());
            }
        } else if (code == CPAP_Leak) {
            m_threshold.push_back(QObject::tr("%1 threshold").arg(chan.fullname()));
        } else m_threshold.push_back(QString());
    }
}
EventDataType gLineChart::Miny()
{
    int m = Layer::Miny();

    if (subtract_offset > 0) {
        m -= subtract_offset;

        if (m < 0) { m = 0; }
    }

    return m;
}
EventDataType gLineChart::Maxy()
{
    return Layer::Maxy() - subtract_offset;
}

bool gLineChart::mouseMoveEvent(QMouseEvent *event, gGraph *graph)
{
    Q_UNUSED(event)
    Q_UNUSED(graph)
    return true;
}

QString gLineChart::getMetaString(qint64 time)
{
    lasttext = QString();
    if (!m_day) return lasttext;


    EventDataType val;

    EventDataType ipap = 0, epap = 0;
    bool addPS = false;

    for (int i=0; i<m_codes.size(); ++i) {
        ChannelID code = m_codes[i];
        if (m_day->channelHasData(code)) {
            val = m_day->lookupValue(code, time, m_square_plot);
            lasttext += " "+QString("%1: %2 %3").arg(schema::channel[code].label()).arg(val,0,'f',2).arg(schema::channel[code].units());

            if (code == CPAP_IPAP) {
                ipap = val;
                addPS = true;
            }
            if (code == CPAP_EPAP) {
                epap = val;
            }
        }

    }
    if (addPS) {
        val = ipap - epap;
        lasttext += " "+QString("%1: %2 %3").arg(schema::channel[CPAP_PS].label()).arg(val,0,'f',2).arg(schema::channel[CPAP_PS].units());
    }

    lasttime = time;
    return lasttext;
}

// Time Domain Line Chart
void gLineChart::paint(QPainter &painter, gGraph &w, const QRegion &region)
{
    QRect rect = region.boundingRect();
    // TODO: Just use QRect directly.
    int left = rect.left();
    int top = rect.top();
    int width = rect.width();
    int height = rect.height();

    if (!m_visible) {
        return;
    }

    if (!m_day) {
        return;
    }

    //if (!m_day->channelExists(m_code)) return;

    if (width < 0) {
        return;
    }


    top++;

    double minx, maxx;


    if (w.blockZoom()) {
        minx = w.rmin_x, maxx = w.rmax_x;
    } else {
        maxx = w.max_x, minx = w.min_x;
    }

    // hmmm.. subtract_offset..

    EventDataType miny = m_physminy;
    EventDataType maxy = m_physmaxy;

    w.roundY(miny, maxy);


//#define DEBUG_AUTOSCALER
#ifdef DEBUG_AUTOSCALER
    QString a = QString().sprintf("%.2f - %.2f",miny, maxy);
    w.renderText(a,width/2,top-5);
#endif

    // the middle of minx and maxy does not have to be the center...


    double xx = maxx - minx;
    double xmult = double(width) / xx;

    EventDataType yy = maxy - miny;
    EventDataType ymult = EventDataType(height - 3) / yy; // time to pixel conversion multiplier

    // Return on screwy min/max conditions
    if (xx < 0) {
        return;
    }

    if (yy <= 0) {
        if (miny == 0) {
            return;
        }
    }

    bool mouseover = false;
    if (rect.contains(w.graphView()->currentMousePos())) {
        mouseover = true;

        painter.fillRect(rect, QBrush(QColor(255,255,245,128)));
    }


    // Display Line Cursor
    if (p_profile->appearance->lineCursorMode()) {
        double time = w.currentTime();

        if ((time > minx) && (time < maxx)) {
            double xpos = (time - double(minx)) * xmult;
            painter.setPen(QPen(QBrush(QColor(0,255,0,255)),1));
            painter.drawLine(left+xpos, top-w.marginTop()-3, left+xpos, top+height+w.bottom-1);
        }

        if ((time != lasttime) || lasttext.isEmpty()) {
            getMetaString(time);
        }

        QString text = w.graphView()->currentTimeString() + lasttext;

        int wid, h;
        GetTextExtent(text, wid, h);
        w.renderText(text, left + width/2 - wid/2, top-h+5);

    }

    EventDataType lastpx, lastpy;
    EventDataType px, py;
    int idx;
    bool done;
    double x0, xL;
    double sr;
    int sam;
    int minz, maxz;

    // Draw bounding box
    painter.setPen(QColor(Qt::black));
    painter.drawLine(left, top, left, top + height);
    painter.drawLine(left, top + height, left + width, top + height);
    painter.drawLine(left + width, top + height, left + width, top);
    painter.drawLine(left + width, top, left, top);

    width--;
    height -= 2;

    int num_points = 0;
    int visible_points = 0;
    int total_points = 0;
    int total_visible = 0;
    bool square_plot, accel;
    qint64 clockdrift = qint64(p_profile->cpap->clockDrift()) * 1000L;
    qint64 drift = 0;

    QHash<ChannelID, QVector<EventList *> >::iterator ci;

    //m_line_color=schema::channel[m_code].defaultColor();
    int legendx = left + width;

    int codepoints;

    painter.setClipRect(left, top, width, height+1);
    painter.setClipping(true);
    painter.setRenderHint(QPainter::Antialiasing, p_profile->appearance->antiAliasing());


    for (int gi = 0; gi < m_codes.size(); gi++) {
        ChannelID code = m_codes[gi];
        schema::Channel &chan = schema::channel[code];

        if (chan.upperThreshold() > 0) {
            QColor color = chan.upperThresholdColor();
            color.setAlpha(100);
            painter.setPen(QPen(QBrush(color),1,Qt::DotLine));

            EventDataType y=top + height + 1 - ((chan.upperThreshold() - miny) * ymult);
            painter.drawLine(left + 1, y, left + 1 + width, y);
            painter.drawText(left+4, y-2, m_threshold.at(gi));
        }
        if (chan.lowerThreshold() > 0) {
            QColor color = chan.lowerThresholdColor();
            color.setAlpha(100);
            painter.setPen(QPen(QBrush(color),1,Qt::DotLine));

            EventDataType y=top + height + 1 - ((chan.lowerThreshold() - miny) * ymult);
            painter.drawLine(left+1, y, left + 1 + width, y);
            painter.drawText(left+4, y-2, m_threshold.at(gi));
        }

        lines.clear();

        codepoints = 0;

        int daysize = m_day->size();
        for (int svi = 0; svi < daysize; svi++) {
            Session *sess = (*m_day)[svi];

            if (!sess) {
                qWarning() << "gLineChart::Plot() nullptr Session Record.. This should not happen";
                continue;
            }

            drift = (sess->machine()->type() == MT_CPAP) ? clockdrift : 0;

            if (!sess->enabled()) { continue; }

            schema::Channel ch = schema::channel[code];
            bool fndbetter = false;

            QList<schema::Channel *>::iterator mlend=ch.m_links.end();
            for (QList<schema::Channel *>::iterator l = ch.m_links.begin(); l != mlend; l++) {
                schema::Channel &c = *(*l);
                ci = (*m_day)[svi]->eventlist.find(c.id());

                if (ci != (*m_day)[svi]->eventlist.end()) {
                    fndbetter = true;
                    break;
                }

            }

            if (!fndbetter) {
                ci = (*m_day)[svi]->eventlist.find(code);

                if (ci == (*m_day)[svi]->eventlist.end()) { continue; }
            }


            QVector<EventList *> &evec = ci.value();
            num_points = 0;
            int evecsize=evec.size();

            for (int i = 0; i < evecsize; i++) {
                num_points += evec[i]->count();
            }

            total_points += num_points;
            codepoints += num_points;

            // Max number of samples taken from samples per pixel for better min/max values
            const int num_averages = 20;

            for (int n = 0; n < evecsize; ++n) { // for each segment
                EventList &el = *evec[n];

                accel = (el.type() == EVL_Waveform); // Turn on acceleration if this is a waveform.

                if (accel) {
                    sr = el.rate();         // Time distance between samples

                    if (sr <= 0) {
                        qWarning() << "qLineChart::Plot() assert(sr>0)";
                        continue;
                    }
                }

                if (m_disable_accel) { accel = false; }


                square_plot = m_square_plot;

                if (accel || num_points > 20000) { // Don't square plot if too many points or waveform
                    square_plot = false;
                }

                int siz = evec[n]->count();

                if (siz <= 1) { continue; } // Don't bother drawing 1 point or less.

                x0 = el.time(0) + drift;
                xL = el.time(siz - 1) + drift;

                if (maxx < x0) { continue; }

                if (xL < minx) { continue; }

                if (x0 > xL) {
                    if (siz == 2) { // this happens on CPAP
                        quint32 t = el.getTime()[0];
                        el.getTime()[0] = el.getTime()[1];
                        el.getTime()[1] = t;
                        EventStoreType d = el.getData()[0];
                        el.getData()[0] = el.getData()[1];
                        el.getData()[1] = d;

                    } else {
                        qDebug() << "Reversed order sample fed to gLineChart - ignored.";
                        continue;
                        //assert(x1<x2);
                    }
                }

                if (accel) {
                    //x1=el.time(1);

                    double XR = xx / sr;
                    double Z1 = MAX(x0, minx);
                    double Z2 = MIN(xL, maxx);
                    double ZD = Z2 - Z1;
                    double ZR = ZD / sr;
                    double ZQ = ZR / XR;
                    double ZW = ZR / (width * ZQ);
                    visible_points += ZR * ZQ;

                    if (accel && n > 0) {
                        sam = 1;
                    }

                    if (ZW < num_averages) {
                        sam = 1;
                        accel = false;
                    } else {
                        sam = ZW / num_averages;

                        if (sam < 1) {
                            sam = 1;
                            accel = false;
                        }
                    }

                    // Prepare the min max y values if we still are accelerating this plot
                    if (accel) {
                        for (int i = 0; i < width; i++) {
                            m_drawlist[i].setX(height);
                            m_drawlist[i].setY(0);
                        }

                        minz = width;
                        maxz = 0;
                    }

                    total_visible += visible_points;
                } else {
                    sam = 1;
                }

                // these calculations over estimate
                // The Z? values are much more accurate

                idx = 0;

                if (el.type() == EVL_Waveform)  {
                    // We can skip data previous to minx if this is a waveform

                    if (minx > x0) {
                        double j = minx - x0; // == starting min of first sample in this segment
                        idx = (j / sr);
                        //idx/=(sam*num_averages);
                        //idx*=(sam*num_averages);
                        // Loose the precision
                        idx += sam - (idx % sam);

                    } // else just start from the beginning
                }

                int xst = left + 1;
                int yst = top + height + 1;

                double time;
                EventDataType data;
                EventDataType gain = el.gain();

                done = false;

                if (el.type() == EVL_Waveform) { // Waveform Plot
                    if (idx > sam) { idx -= sam; }

                    time = el.time(idx) + drift;
                    double rate = double(sr) * double(sam);
                    EventStoreType *ptr = el.rawData() + idx;

                    if (accel) {
                        //////////////////////////////////////////////////////////////////
                        // Accelerated Waveform Plot
                        //////////////////////////////////////////////////////////////////

                        for (int i = idx; i < siz; i += sam, ptr += sam) {
                            time += rate;
                            // This is much faster than QVector access.
                            data = *ptr + el.offset();
                            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 (minz < 0) {
                                qDebug() << "gLineChart::Plot() minz<0  should never happen!! minz =" << minz;
                                minz = 0;
                            }

                            if (maxz > max_drawlist_size) {
                                qDebug() << "gLineChart::Plot() maxz>max_drawlist_size!!!! maxz = " << maxz <<
                                         " max_drawlist_size =" << max_drawlist_size;
                                maxz = max_drawlist_size;
                            }

                            // 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 (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;

                        for (int i = minz; i < maxz; i++, drl++) {
                            ax1 = drl->x();
                            ay1 = drl->y();
                            lines.append(QLine(xst + i, yst - ax1, xst + i, yst - ay1));
                        }

                    } else { // Zoomed in Waveform
                        //////////////////////////////////////////////////////////////////
                        // Normal Waveform Plot
                        //////////////////////////////////////////////////////////////////

                        // Prime first point
                        data = (*ptr + el.offset()) * gain;
                        lastpx = xst + ((time - minx) * xmult);
                        lastpy = yst - ((data - miny) * ymult);

                        siz--;
                        for (int i = idx; i < siz; i += sam) {
                            ptr += sam;
                            time += rate;

                            data = (*ptr + el.offset()) * 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.append(QLine(lastpx, lastpy, px, py));

                            lastpx = px;
                            lastpy = py;

                            if (time > maxx) {
                                done = true;
                                break;
                            }
                        }
                    }

                    painter.setPen(QPen(chan.defaultColor(), p_profile->appearance->lineThickness()));
                    painter.drawLines(lines);
                    w.graphView()->lines_drawn_this_frame += lines.count();
                    lines.clear();


                } else  {
                    //////////////////////////////////////////////////////////////////
                    // Standard events/zoomed in Plot
                    //////////////////////////////////////////////////////////////////

                    double start = el.first() + drift;

                    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--;
                        }
                    }

                    // 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++ + el.offset()) * 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;

                    int gs = siz << 1;

                    if (square_plot) {
                        gs <<= 1;
                    }

                    // Unrolling square plot outside of loop to gain a minor speed improvement.
                    EventStoreType *eptr = dptr + siz;

                    if (square_plot) {
                        for (; dptr < eptr; dptr++) {
                            time = start + *tptr++;
                            data = gain * (*dptr + el.offset());

                            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.append(QLine(lastpx, lastpy, px, lastpy));
//                                lines.append(QLine(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.append(QLine(lastpx, lastpy, px, lastpy));
                                lines.append(QLine(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;
                            }
                        }
                    } else {
                        for (; dptr < eptr; dptr++) {
                            //for (int i=0;i<siz;i++) {
                            time = start + *tptr++;
                            data = gain * (*dptr + el.offset());

                            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.append(QLine(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.append(QLine(lastpx, lastpy, px, py));
                            //}

                            lastpx = px;
                            lastpy = py;

                            if (time > maxx) { // Past right edge, abort further drawing..
                                done = true;
                                break;
                            }
                        }
                    }
                    painter.setPen(QPen(chan.defaultColor(),p_profile->appearance->lineThickness()));
                    painter.drawLines(lines);
                    w.graphView()->lines_drawn_this_frame+=lines.count();
                    lines.clear();

                }

                if (done) { break; }
            }
        }


//        painter.setPen(QPen(m_colors[gi],p_profile->appearance->lineThickness()));
//        painter.drawLines(lines);
//        w.graphView()->lines_drawn_this_frame+=lines.count();
//        lines.clear();

        ////////////////////////////////////////////////////////////////////
        // Draw Legends on the top line
        ////////////////////////////////////////////////////////////////////

        QFontMetrics fm(*defaultfont);
        int bw = fm.width('X');
        int bh = fm.height() / 1.8;


        if ((codepoints > 0)) {
            QString text = schema::channel[code].label();
            int wid, hi;
            GetTextExtent(text, wid, hi);
            legendx -= wid;
            painter.setClipping(false);
            w.renderText(text, legendx, top - 4);
            legendx -= bw /2;
            painter.fillRect(legendx - bw, top - w.marginTop()-2, bh, w.marginTop()+1, QBrush(chan.defaultColor()));
            painter.setClipping(true);

            legendx -= bw*2;
        }
    }


    if (!total_points) { // No Data?

        if (m_report_empty) {
            QString msg = QObject::tr("No Waveform Available");
            int x, y;
            GetTextExtent(msg, x, y, bigfont);
            //DrawText(w,msg,left+(width/2.0)-(x/2.0),scry-w.GetBottomMargin()-height/2.0+y/2.0,0,Qt::gray,bigfont);
        }
    }
    painter.setClipping(false);


    // Calculate combined session times within selected area...
    double first, last;
    double time = 0;

    // Calculate the session time.
    for (QList<Session *>::iterator s = m_day->begin(); s != m_day->end(); s++) {
        if (!(*s)->enabled()) { continue; }

        first = (*s)->first();
        last = (*s)->last();

        if (last < w.min_x) { continue; }
        if (first > w.max_x) { continue; }

        if (first < w.min_x) {
            first = w.min_x;
        }

        if (last > w.max_x) {
            last = w.max_x;
        }

        time += last - first;
    }


    time /= 1000;

    QList<ChannelID> ahilist;
    ahilist.push_back(CPAP_Hypopnea);
    ahilist.push_back(CPAP_Obstructive);
    ahilist.push_back(CPAP_Apnea);
    ahilist.push_back(CPAP_ClearAirway);

    QList<ChannelID> extras;
    ahilist.push_back(CPAP_NRI);
    ahilist.push_back(CPAP_UserFlag1);
    ahilist.push_back(CPAP_UserFlag2);

    double sum = 0;
    int cnt = 0;

    // Draw the linechart overlays
    if (m_day && (p_profile->appearance->lineCursorMode() || (m_codes[0]==CPAP_FlowRate))) {
        QHash<ChannelID, gLineOverlayBar *>::iterator fit;
        bool blockhover = false;

        for (fit = flags.begin(); fit != flags.end(); ++fit) {
            ChannelID code = fit.key();
            gLineOverlayBar * lob = fit.value();
            lob->setBlockHover(blockhover);
            lob->paint(painter, w, region);
            if (lob->hover()) blockhover = true; // did it render a hover over?

            if (ahilist.contains(code)) {
                sum += lob->sum();
                cnt += lob->count();
            }
        }
    }
    if (m_codes[0] == CPAP_FlowRate) {
        float hours = float(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);
        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);
        w.renderText(txt,left,top-4);
    }

    painter.setRenderHint(QPainter::Antialiasing, false);
}