path: root/src/bm/plotter.cpp

/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information (qt-info@nokia.com)
**
** This file is part of the BM project on Qt Labs.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 or 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
** http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at qt-sales@nokia.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "plotter.h"
#include "bmmisc.h"
#include <QGraphicsScene>
#include <QGraphicsSimpleTextItem>
#include <QPainter>

// ### Note: There is a potential for refactoring in order to avoid code duplication
// in this file.


// Template method.
QImage Plotter::createImage(QString *error) const
{
    const QRectF sceneRect_ = sceneRect();

    QGraphicsScene scene_far(sceneRect_); // Background scene (rendered first)
    QGraphicsScene scene_mid_aa(sceneRect_); // Middle scene (antialiased)
    QGraphicsScene scene_near(sceneRect_); // Foreground scene (rendered last)

    if (!drawScenes(&scene_far, &scene_mid_aa, &scene_near, error))
        return QImage();

    Q_ASSERT(scene_far.sceneRect() == scene_mid_aa.sceneRect());
    Q_ASSERT(scene_far.sceneRect() == scene_near.sceneRect());

    QImage image(scene_far.width(), scene_far.height(), QImage::Format_ARGB32);
    {
        QPainter painter(&image);
        scene_far.render(&painter);
    }
    {
        QPainter painter(&image);
        painter.setRenderHint(QPainter::Antialiasing);
        scene_mid_aa.render(&painter);
    }
    {
        QPainter painter(&image);
        scene_near.render(&painter);
    }

    return image;
}

ResultHistoryPlotter::ResultHistoryPlotter(
    const QList<int> &timestamps, const QList<qreal> &values, const int resultId, const int basePos)
    : timestamps(timestamps), values(values), resultId(resultId), basePos(basePos)
    , width(1100), height(450)
{
}

QRectF ResultHistoryPlotter::sceneRect() const
{
    return QRectF(0, 0, width, height);
}

// ### 2 B DOCUMENTED!
// ### 2 B DONE: Maybe factor out parts that this function has in common with
//     IndexPlotter::drawScenes()
bool ResultHistoryPlotter::drawScenes(
    QGraphicsScene *scene_far, QGraphicsScene *scene_mid_aa, QGraphicsScene *scene_near,
    QString *error) const
{
    if (timestamps.isEmpty()) {
        if (error)
            *error = "no data to plot (no values)";
        return false;
    }
    Q_ASSERT(timestamps.size() == values.size());
    for (int i = 1; i < timestamps.size(); ++i) {
        Q_ASSERT(timestamps.at(i - 1) <= timestamps.at(i));
    }
    Q_ASSERT(basePos < timestamps.size());

    const qreal pad_left = 150;
    const qreal pad_right = 150;
    const qreal pad_top = 50;
    const qreal pad_bottom = 50;
    const qreal xmin = pad_left;
    const qreal xmax = width - pad_right;
    const qreal xdefault = 0.5 * (xmin + xmax);
    const qreal ymin = pad_top;
    const qreal ymax = height - pad_bottom; // ### specific
    const qreal ydefault = 0.5 * (ymin + ymax);

    qreal loTimestamp = timestamps.first();
    qreal hiTimestamp = timestamps.last();

    qreal xfact = xdefault;
    if (loTimestamp < hiTimestamp) {
        const qreal tfact = 1.0 / (hiTimestamp - loTimestamp);
        xfact = tfact * (xmax - xmin);
    }

    qreal vmin = -1;
    qreal vmax = -1;
    vmin = vmax = values.first();
    for (int i = 1; i < values.size(); ++i) {
        vmin = qMin(vmin, values.at(i));
        vmax = qMax(vmax, values.at(i));
    }

    const qreal vfact = 1 / (vmax - vmin); // zero division handled elsewhere
    const qreal yfact = vfact * (ymax - ymin);

    // Compute scene coordinates of history curve ...
    QList<qreal> x;
    QList<qreal> y;
    for (int i = 0; i < values.size(); ++i) {
        const qreal t = timestamps.at(i);
        const qreal v = values.at(i);
        x.append(((timestamps.size() > 1) || (loTimestamp < hiTimestamp))
                 ? (xmin + (t - loTimestamp) * xfact)
                 : xdefault);
        y.append(BMMisc::v2y(v, ymax, vmin, yfact, ydefault));
    }

    // Draw background ...
    scene_far->setBackgroundBrush(QBrush(Qt::white));

    // Draw axis indicators ...
    const qreal indicatorSize = 5;
    const QColor indicatorColor(119, 119, 255, 255);
    // ... x-axis (all values) ...
    {
        QPainterPath path;
        for (int i = 0; i < x.size(); ++i) {
            path.moveTo(x.at(i), ymax);
            path.lineTo(x.at(i), ymax + indicatorSize);
        }
        scene_far->addPath(path, QPen(indicatorColor));
    }
    // ... y-axises (min and max value only) ...
    {
        QPainterPath path;
        path.moveTo(xmin, ymin);
        path.lineTo(xmin - indicatorSize, ymin);
        path.moveTo(xmin, ymax);
        path.lineTo(xmin - indicatorSize, ymax);
        path.moveTo(xmax, ymin);
        path.lineTo(xmax + indicatorSize, ymin);
        path.moveTo(xmax, ymax);
        path.lineTo(xmax + indicatorSize, ymax);
        scene_far->addPath(path, QPen(indicatorColor));
    }

    // Draw border rectangle  ...
    scene_far->addRect(xmin, ymin, xmax - xmin, ymax - ymin, QPen(QColor(220, 220, 220, 255)));

    // ### BEGIN specific

    if (basePos >= 0) {
        // Draw line indicating the base position ...
        QColor color(0, 0, 255);
        color.setAlpha(100);
        scene_far->addLine(xmin, y.at(basePos), xmax, y.at(basePos), QPen(color, 2));
    }

    // ### END specific

    const qreal dpSize = 4;

    // Draw history curve between data points ...
    {
        QPainterPath path(QPointF(x.first(), y.first()));
        for (int i = 0; i < x.size(); ++i)
            path.lineTo(x.at(i), y.at(i));
        scene_mid_aa->addPath(path, QPen(QColor(128, 128, 128, 255)));
    }

    // Draw data points (except the one representing the base position if any) ...
    {
        QPainterPath path;
        path.setFillRule(Qt::WindingFill);
        const qreal dpSize_2 = 0.5 * dpSize;
        for (int i = 0; i < x.size(); ++i)
            if ((basePos < 0) || (i != basePos))
                path.addRect(x.at(i) - dpSize_2, y.at(i) - dpSize_2, dpSize, dpSize);

        const QColor color(0, 0, 0, 255);
        scene_near->addPath(path, QPen(color), QBrush(color));
    }

    if (basePos >= 0) {
        // Draw the data point representing the base position ...
        QPainterPath path;
        path.addRect(x.at(basePos) - dpSize / 2, y.at(basePos) - dpSize / 2, dpSize, dpSize);
        const QColor color(0, 0, 0, 255);
        scene_near->addPath(path, QPen(color), QBrush(Qt::yellow)); // ### 4 NOW
    }


    // Draw labels ...
    const qreal labelPad = 10;
    const qreal captionPad = 4;
    qreal captionHeight;

    // ... left y axis ...
    {
        const QString yCaption = "value"; // ### 4 NOW (could e.g. be metric name)
        QFont font;
        font.setPointSize(14);
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(yCaption, font);
        const qreal x_ = xmin - text->boundingRect().height() - captionPad;
        const qreal y_ = (ymin + ymax) / 2 + text->boundingRect().width() / 2;
        text->setTransform(QTransform().translate(x_, y_).rotate(-90));
        captionHeight = text->boundingRect().height();
    }
    {
        QGraphicsSimpleTextItem *text =
            scene_near->addSimpleText(QString().setNum(vmin));
        text->setPos(
            xmin - captionPad - captionHeight - labelPad - text->boundingRect().width(),
            ymax - text->boundingRect().height() / 2);
    }
    {
        QGraphicsSimpleTextItem *text =
            scene_near->addSimpleText(QString().setNum(vmax));
        text->setPos(
            xmin - captionPad - captionHeight - labelPad - text->boundingRect().width(),
            ymin - text->boundingRect().height() / 2);
    }

    if (basePos >= 0) {
        QGraphicsSimpleTextItem *text =
            scene_near->addSimpleText(QString().setNum(values.at(basePos)));
        text->setPos(
            xmin - captionPad - captionHeight - labelPad - text->boundingRect().width(),
            y.at(basePos) - text->boundingRect().height() / 2);

        // Avoid overlap
        if (!scene_near->collidingItems(text).isEmpty()) {
            scene_near->removeItem(text);
            delete text;
        }
    }

    const bool showNormDiff = true; // ### 4 NOW

    if ((basePos >= 0) && showNormDiff) {
        // ... right y axis ...
        {
            QFont font;
            font.setPointSize(14);
            QGraphicsSimpleTextItem *text =
                scene_near->addSimpleText("norm. diff. between baseline value and value", font);
            const qreal x_ = xmax + captionPad;
            const qreal y_ = (ymin + ymax) / 2 + text->boundingRect().width() / 2;
            text->setTransform(QTransform().translate(x_, y_).rotate(-90));
            captionHeight = text->boundingRect().height();
        }
        {
            QGraphicsSimpleTextItem *text =
                scene_near->addSimpleText(
                    QString().setNum(
                        BMMisc::normalizedDifference(values.at(basePos), vmin), 'f', 4));
            text->setPos(
                xmax + captionPad + captionHeight + labelPad,
                ymax - text->boundingRect().height() / 2);
        }
        {
            QGraphicsSimpleTextItem *text =
                scene_near->addSimpleText(
                    QString().setNum(
                        BMMisc::normalizedDifference(values.at(basePos), vmax), 'f', 4));
            text->setPos(
                xmax + captionPad + captionHeight + labelPad,
                ymin - text->boundingRect().height() / 2);
        }
        {
            QGraphicsSimpleTextItem *text =
                scene_near->addSimpleText(QString().setNum(0.0, 'f', 4));
            text->setPos(
                xmax + captionPad + captionHeight + labelPad,
                y.last() - text->boundingRect().height() / 2);

            // Avoid overlap
            if (!scene_near->collidingItems(text).isEmpty()) {
                scene_near->removeItem(text);
                delete text;
            }
        }
    }

    // ... top x axis ...
    {
        QFont font;
        font.setPointSize(16);
        const QString title = QString("Result history containing baseline result %1").arg(resultId);
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(title, font);
        const qreal x_ = (xmin + xmax) / 2 - text->boundingRect().width() / 2;
        const qreal y_ = ymin - labelPad - text->boundingRect().height();
        text->translate(x_, y_);
    }

    // ... bottom x axis ...
    QDateTime dateTime;
    dateTime.setTime_t(loTimestamp);
    const QString xLabel_lo = dateTime.toString();
    dateTime.setTime_t(hiTimestamp);
    const QString xLabel_hi = dateTime.toString();
    {
        QFont font;
        font.setPointSize(14);
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText("time", font);
        const qreal x_ = (xmin + xmax) / 2 - text->boundingRect().width() / 2;
        const qreal y_ = ymax + labelPad;
        text->translate(x_, y_);
    }
    {
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(xLabel_lo);
        text->setPos(
            xmin - text->boundingRect().width() / 2,
            ymax + labelPad);
    }
    {
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(xLabel_hi);
        text->setPos(
            xmax - text->boundingRect().width() / 2,
            ymax + labelPad);
    }

    return true;
}


IndexPlotter::IndexPlotter(
    const QList<int> &timestamps, const QList<qreal> &values, const QList<int> &contributions,
    const int baseTimestamp, const bool showBaseValue, const qreal baseValue)
    : timestamps(timestamps), values(values), contributions(contributions)
    , baseTimestamp(baseTimestamp), showBaseValue(showBaseValue), baseValue(baseValue)
{
    width = 1100;
    height = 450;
}

QRectF IndexPlotter::sceneRect() const
{
    return QRectF(0, 0, width, height);
}

// ### 2 B DOCUMENTED!
// ### 2 B DONE: Maybe factor out parts that this function has in common with
//     ResultHistoryPlotter::drawScenes()
bool IndexPlotter::drawScenes(
    QGraphicsScene *scene_far, QGraphicsScene *scene_mid_aa, QGraphicsScene *scene_near,
    QString *error) const
{
    // --- BEGIN main graph ---

    if (timestamps.isEmpty()) {
        if (error)
            *error = "no data to plot (no values)";
        return false;
    }
    Q_ASSERT(timestamps.size() == values.size());
    Q_ASSERT(timestamps.size() == contributions.size());
    for (int i = 1; i < timestamps.size(); ++i) {
        Q_ASSERT(timestamps.at(i - 1) <= timestamps.at(i));
    }

    const qreal pad_left = 150;
    const qreal pad_right = 150;
    const qreal pad_top = 50;
    const qreal pad_bottom = 50;

    const qreal xmin = pad_left;
    const qreal xmax = width - pad_right;
    const qreal xdefault = 0.5 * (xmin + xmax);
    const qreal ymin = pad_top;
    const qreal ymax = height - pad_bottom;
    const qreal ydefault = 0.5 * (ymin + ymax);

    qreal loTimestamp = timestamps.first();
    qreal hiTimestamp = timestamps.last();

    qreal xfact = xdefault;
    if (loTimestamp < hiTimestamp) {
        const qreal tfact = 1.0 / (hiTimestamp - loTimestamp);
        xfact = tfact * (xmax - xmin);
    }

    QList<bool> missing;
    for (int i = 0; i < contributions.size(); ++i)
        missing.append(contributions.at(i) == 0);

    qreal vmin = -1;
    qreal vmax = -1;
    const int firstNonMissing = missing.indexOf(false);
    if (firstNonMissing >= 0) {
        vmin = vmax = values.at(firstNonMissing);
        for (int i = firstNonMissing + 1; i < values.size(); ++i) {
            if (!missing.at(i)) {
                vmin = qMin(vmin, values.at(i));
                vmax = qMax(vmax, values.at(i));
            }
        }
    }

    const qreal vfact = 1 / (vmax - vmin); // zero division handled elsewhere
    const qreal yfact = vfact * (ymax - ymin);

    // Compute scene coordinates of history curve ...
    QList<qreal> x;
    QList<qreal> y;
    for (int i = 0; i < values.size(); ++i) {
        const qreal t = timestamps.at(i);
        const qreal v = values.at(i);
        x.append(((timestamps.size() > 1) || (loTimestamp < hiTimestamp))
                 ? (xmin + (t - loTimestamp) * xfact)
                 : xdefault);
        y.append(BMMisc::v2y(v, ymax, vmin, yfact, ydefault));
    }

    // Draw background ...
    scene_far->setBackgroundBrush(QBrush(Qt::white));

    // Draw axis indicators ...
    const qreal indicatorSize = 5;
    const QColor indicatorColor(119, 119, 255, 255);
    // ... x-axis (all values) ...
    {
        QPainterPath path;
        for (int i = 0; i < x.size(); ++i) {
            path.moveTo(x.at(i), ymax);
            path.lineTo(x.at(i), ymax + indicatorSize);
        }
        scene_far->addPath(path, QPen(indicatorColor));
    }
    // ... y-axises (min and max value only) ...
    {
        QPainterPath path;
        path.moveTo(xmin, ymin);
        path.lineTo(xmin - indicatorSize, ymin);
        path.moveTo(xmin, ymax);
        path.lineTo(xmin - indicatorSize, ymax);
        path.moveTo(xmax, ymin);
        path.lineTo(xmax + indicatorSize, ymin);
        path.moveTo(xmax, ymax);
        path.lineTo(xmax + indicatorSize, ymax);
        scene_far->addPath(path, QPen(indicatorColor));
    }

    // Draw border rectangle  ...
    scene_far->addRect(xmin, ymin, xmax - xmin, ymax - ymin, QPen(QColor(220, 220, 220, 255)));

    if (showBaseValue) {
        // Draw line indicating the base value ...
        QColor color(0, 0, 255);
        color.setAlpha(100);
        const qreal y_base = BMMisc::v2y(baseValue, ymax, vmin, yfact, ydefault);
        scene_far->addLine(xmin, y_base, xmax, y_base, QPen(color, 1));
    }

    if ((baseTimestamp >= timestamps.first()) && (baseTimestamp <= timestamps.last())) {
        // Draw line indicating the base timestamp ...
        QColor color(0, 0, 255);
        color.setAlpha(100);
        const qreal btx = xmin + (baseTimestamp - loTimestamp) * xfact;
        scene_far->addLine(btx, ymin, btx, ymax, QPen(color, 1));
    }

    const qreal dpSize = 3;

    // Draw history curve between data points that are not missing ...
    if (missing.count(false) > 1)
    {
        int pos = missing.indexOf(false, 0);
        QPainterPath path(QPointF(x.at(pos), y.at(pos)));
        while (true) {
            pos = missing.indexOf(false, pos + 1);
            if (pos == -1)
                break;
            path.lineTo(x.at(pos), y.at(pos));
        }
        scene_mid_aa->addPath(path, QPen(QColor(128, 128, 128, 255)));
    }

    // Draw data points (except the one representing the base value if any) ...
    {
        QPainterPath path;
        path.setFillRule(Qt::WindingFill);
        QPainterPath missingPath;
        const qreal ymid = 0.5 * (ymin + ymax);
        const qreal dpSize_2 = 0.5 * dpSize;
        for (int i = 0; i < x.size(); ++i)
            if (missing.at(i)) {
                missingPath.moveTo(x.at(i) - dpSize_2, ymid - dpSize_2);
                missingPath.lineTo(x.at(i) + dpSize_2, ymid + dpSize_2);
                missingPath.moveTo(x.at(i) - dpSize_2, ymid + dpSize_2);
                missingPath.lineTo(x.at(i) + dpSize_2, ymid - dpSize_2);
            } else {
                path.addRect(x.at(i) - dpSize_2, y.at(i) - dpSize_2, dpSize, dpSize);
            }

        const QColor color(0, 0, 0, 255);
        scene_near->addPath(path, QPen(color), QBrush(color));
        const QColor missingColor(255, 0, 0, 255);
        scene_near->addPath(missingPath, QPen(missingColor, 1), QBrush(missingColor));
    }

    // Draw labels ...
    const qreal labelPad = 10;
    const qreal captionPad = 4;
    qreal captionHeight;

    // ... left y axis ...
    {
        const QString yCaption = "value"; // ### 4 NOW
        QFont font;
        font.setPointSize(14);
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(yCaption, font);
        const qreal x_ = xmin - text->boundingRect().height() - captionPad;
        const qreal y_ = (ymin + ymax) / 2 + text->boundingRect().width() / 2;
        text->setTransform(QTransform().translate(x_, y_).rotate(-90));
        captionHeight = text->boundingRect().height();
    }
    {
        QGraphicsSimpleTextItem *text =
            scene_near->addSimpleText(QString().setNum(vmin));
        text->setPos(
            xmin - captionPad - captionHeight - labelPad - text->boundingRect().width(),
            ymax - text->boundingRect().height() / 2);
    }
    {
        QGraphicsSimpleTextItem *text =
            scene_near->addSimpleText(QString().setNum(vmax));
        text->setPos(
            xmin - captionPad - captionHeight - labelPad - text->boundingRect().width(),
            ymin - text->boundingRect().height() / 2);
    }

    if (showBaseValue && ((baseValue >= vmin) && (baseValue <= vmax))) {
        QGraphicsSimpleTextItem *text =
            scene_near->addSimpleText(QString().setNum(baseValue));
        const qreal y_base = BMMisc::v2y(baseValue, ymax, vmin, yfact, ydefault);
        text->setPos(
            xmin - captionPad - captionHeight - labelPad - text->boundingRect().width(),
            y_base - text->boundingRect().height() / 2);

        // Avoid overlap
        if (!scene_near->collidingItems(text).isEmpty()) {
            scene_near->removeItem(text);
            delete text;
        }
    }

    // ... top x axis ...
    {
        QFont font;
        font.setPointSize(16);
        const QString title = QString("Qt Performance Index (<description>)");
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(title, font);
        const qreal x_ = (xmin + xmax) / 2 - text->boundingRect().width() / 2;
        const qreal y_ = ymin - labelPad - text->boundingRect().height();
        text->translate(x_, y_);
    }

    // ... bottom x axis ...
    QDateTime dateTime;
    dateTime.setTime_t(loTimestamp);
    const QString xLabel_lo = dateTime.toString();
    dateTime.setTime_t(hiTimestamp);
    const QString xLabel_hi = dateTime.toString();
    {
        QFont font;
        font.setPointSize(14);
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText("time", font);
        const qreal x_ = (xmin + xmax) / 2 - text->boundingRect().width() / 2;
        const qreal y_ = ymax + labelPad;
        text->translate(x_, y_);
    }
    {
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(xLabel_lo);
        text->setPos(
            xmin - text->boundingRect().width() / 2,
            ymax + labelPad);
    }
    {
        QGraphicsSimpleTextItem *text = scene_near->addSimpleText(xLabel_hi);
        text->setPos(
            xmax - text->boundingRect().width() / 2,
            ymax + labelPad);
    }


    return true;
}