chunk2dview.h

#ifndef CTL_CHUNK2DVIEW_H
#define CTL_CHUNK2DVIEW_H

#include <QGraphicsView>

#include "img/chunk2d.h"
#include "mat/matrix.h"

class QLabel;

namespace CTL {
namespace gui {

class Chunk2DView : public QGraphicsView
{
    Q_OBJECT

public:
    explicit Chunk2DView(QWidget* parent = nullptr);
    Chunk2DView(Chunk2D<float> data, QWidget* parent = nullptr);
    //~Chunk2DView();

    // factory
    template<typename T>
    static void plot(const Chunk2D<T>& data,
                     QPair<double,double> windowing = qMakePair(0.0, 0.0), double zoom = 1.0);
    static void plot(Chunk2D<float> data,
                     QPair<double,double> windowing = qMakePair(0.0, 0.0), double zoom = 1.0);

    // getter methods
    const Chunk2D<float>& data() const;
    QPixmap pixmap() const;
    QPair<double, double> windowingFromTo() const;
    QPair<double, double> windowingCenterWidth() const;
    double zoom() const;

    // setter methods
    void setColorTable(const QVector<QRgb>& colorTable);
    template<typename T>
    void setData(const Chunk2D<T>& data);
    void setData(Chunk2D<float> data);
    void setMouseWindowingScaling(double centerScale, double widthScale);
    void setWheelZoomPerTurn(double zoomPerTurn);

    QList<QPointF> contrastLine() const;
    QImage image(const QSize& renderSize = QSize());
    void setContrastLinePlotLabels(const QString& labelX, const QString& labelY);
    void showContrastLinePlot();

public Q_SLOTS:
    void autoResize();
    bool save(const QString& fileName);
    void saveDialog();
    void setAutoMouseWindowScaling();
    void setLivePixelDataEnabled(bool enabled);
    void setWindowing(double from, double to);
    void setWindowingCenterWidth(double center, double width);
    void setWindowingMinMax();
    void setZoom(double zoom);

protected:
    void keyPressEvent(QKeyEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;
    void mousePressEvent(QMouseEvent* event) override;
    void wheelEvent(QWheelEvent* event) override;

Q_SIGNALS:
    void pixelInfoUnderCursor(int x, int y, float value);
    void viewChangeRequested(int requestedChange);
    void windowingChanged(double from, double to);
    void zoomChanged(double zoom);

private:
    QGraphicsScene _scene;
    QGraphicsPixmapItem* _imageItem;
    QGraphicsLineItem* _contrastLineItem;

    Chunk2D<float> _data = Chunk2D<float>(0,0);
    QVector<QRgb> _colorTable;
    QPair<double, double> _window;
    double _zoom = 1.0;
    QPointF _actualZoom = QPointF(1.0, 1.0);
    QString _contrLineLabelX = QStringLiteral("Position on line");
    QString _contrLineLabelY = QStringLiteral("Value");

    // event handling
    QPoint _mouseDragStart;
    QPair<double, double> _windowDragStartValue;
    QPair<double, double> _mouseWindowingScaling = {1.0, 1.0};
    double _wheelZoomPerTurn = 0.25; // i.e 0.25 zoom per 15.0 deg;

    QPixmap checkerboard() const;
    void contrastLineFromClipbord();
    void contrastLineToClipbord() const;
    QPoint pixelIdxFromPos(const QPoint& pos);
    void setGrayscaleColorTable();
    void updateImage();
};

template<typename T>
void Chunk2DView::setData(const Chunk2D<T>& data)
{
    setData(assist::convertTo<float>(data));
}

template<typename T>
void Chunk2DView::plot(const Chunk2D<T>& data, QPair<double, double> windowing, double zoom)
{
    plot(assist::convertTo<float>(data), windowing, zoom);
}


// free function plot()
inline void plot(Chunk2D<float> data,
                 QPair<double,double> windowing = qMakePair(0.0, 0.0), double zoom = 1.0)
{ Chunk2DView::plot(std::move(data), windowing, zoom); }

template<typename T>
inline void plot(const Chunk2D<T>& data,
                 QPair<double,double> windowing = qMakePair(0.0, 0.0), double zoom = 1.0)
{ Chunk2DView::plot(data, windowing, zoom); }

template<uint Rows, uint Cols>
void plot(mat::Matrix<Rows, Cols> data,
          QPair<double,double> windowing = qMakePair(0.0, 0.0), double zoom = 50.0)
{
    Chunk2D<float> chunk(Cols, Rows);
    chunk.allocateMemory();
    std::copy(data.constBegin(), data.constEnd(), chunk.rawData());
    Chunk2DView::plot(std::move(chunk), windowing, zoom);
}

} // namespace gui

namespace assist {
inline QVector<QRgb> colortableGrayscale()
{
    QVector<QRgb> ret(256);

    for(int i = 0; i <= 255; ++i)
        ret[i] = qRgb(i,i,i);

    return ret;
}
inline QVector<QRgb> colortableHue()
{
    QVector<QRgb> ret(256);

    for(int i = 0; i <= 255; ++i)
        ret[i] = QColor::fromHsvF(double(i)/255.0, 1.0, 1.0).rgb();

    return ret;
}
inline QVector<QRgb> colortableJet()
{
    QVector<QRgb> ret(256);

    for(int i = 0; i <= 255; ++i)
        ret[i] = QColor::fromHsv(240 - int(240.0 * double(i)/255.0), 255, 255).rgb();

    return ret;
}

} // namespace assist

} // namespace CTL

#endif // CTL_CHUNK2DVIEW_H