Jungfraujoch/viewer/windows/JFJochViewerImageListWindow.cpp

// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include "JFJochViewerImageListWindow.h"

#include <QVBoxLayout>
#include <QHeaderView>
#include <QCloseEvent>

namespace {
    constexpr int ScaleSortRole = Qt::UserRole + 1;
    constexpr double ScaleNotAvailableSortValue = -1.0e100;
}

JFJochViewerImageListWindow::JFJochViewerImageListWindow(QWidget *parent) : JFJochHelperWindow(parent) {

    QWidget *centralWidget = new QWidget(this);
    setCentralWidget(centralWidget);

    QVBoxLayout *layout = new QVBoxLayout(centralWidget);

    tableView = new QTableView(this);

    tableModel = new QStandardItemModel(this);
    setupTableModel();

    proxyModel = new QSortFilterProxyModel(this);
    proxyModel->setSourceModel(tableModel);
    proxyModel->setSortRole(ScaleSortRole);

    tableView->setModel(proxyModel);
    tableView->sortByColumn(0, Qt::AscendingOrder);
    tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
    tableView->setSortingEnabled(true);
    tableView->verticalHeader()->setVisible(false);
    tableView->horizontalHeader()->setSectionsClickable(true);
    tableView->horizontalHeader()->setSortIndicatorShown(true);

    tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
    tableView->setSelectionMode(QAbstractItemView::SingleSelection);

    tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);

    layout->addWidget(tableView);

    setWindowTitle("Image statistics");
    resize(800, 600);

    connect(tableView, &QTableView::doubleClicked, this, &JFJochViewerImageListWindow::onTableRowDoubleClicked);
}

void JFJochViewerImageListWindow::setupTableModel()
{
    tableModel->setColumnCount(8);
    tableModel->setHeaderData(0, Qt::Horizontal, "#");
    tableModel->setHeaderData(1, Qt::Horizontal, "Bkg");
    tableModel->setHeaderData(2, Qt::Horizontal, "Index");
    tableModel->setHeaderData(3, Qt::Horizontal, "Spots");
    tableModel->setHeaderData(4, Qt::Horizontal, "Res. [A]");
    tableModel->setHeaderData(5, Qt::Horizontal, "Max val");
    tableModel->setHeaderData(6, Qt::Horizontal, "Scale factor");
    tableModel->setHeaderData(7, Qt::Horizontal, "Scale CC");
}

void JFJochViewerImageListWindow::addDataRow(int imageNumber, double backgroundEstimate,
                                             const QString& indexingResult,
                                             int spotCount,
                                             double resolutionEstimate,
                                             int64_t max_value,
                                             double image_scale_factor,
                                             double image_scale_cc_percent) {
    QList<QStandardItem*> rowItems;

    QStandardItem *imageItem = new QStandardItem();
    imageItem->setData(imageNumber, Qt::DisplayRole);
    imageItem->setData(imageNumber, ScaleSortRole);
    rowItems.append(imageItem);

    QStandardItem *bgItem = new QStandardItem();
    bgItem->setData(backgroundEstimate, Qt::DisplayRole);
    bgItem->setData(backgroundEstimate, ScaleSortRole);
    rowItems.append(bgItem);

    QStandardItem *indexingItem = new QStandardItem(indexingResult);
    if (indexingResult == "Yes")
        indexingItem->setData(1, ScaleSortRole);
    else if (indexingResult == "No")
        indexingItem->setData(0, ScaleSortRole);
    else
        indexingItem->setData(-1, ScaleSortRole);
    rowItems.append(indexingItem);

    QStandardItem *spotItem = new QStandardItem();
    spotItem->setData(spotCount, Qt::DisplayRole);
    spotItem->setData(spotCount, ScaleSortRole);
    rowItems.append(spotItem);

    QStandardItem *resolutionItem = new QStandardItem();
    resolutionItem->setData(QString::number(resolutionEstimate, 'f', 2), Qt::DisplayRole);
    resolutionItem->setData(resolutionEstimate, ScaleSortRole);
    rowItems.append(resolutionItem);

    QStandardItem *maxValueItem = new QStandardItem();
    maxValueItem->setData(static_cast<int32_t>(max_value), Qt::DisplayRole);
    maxValueItem->setData(static_cast<int32_t>(max_value), ScaleSortRole);
    rowItems.append(maxValueItem);

    QStandardItem *scaleFactorItem = new QStandardItem();
    if (std::isfinite(image_scale_factor)) {
        scaleFactorItem->setData(image_scale_factor, Qt::DisplayRole);
        scaleFactorItem->setData(image_scale_factor, ScaleSortRole);
    } else {
        scaleFactorItem->setData("N/A", Qt::DisplayRole);
        scaleFactorItem->setData(ScaleNotAvailableSortValue, ScaleSortRole);
    }
    rowItems.append(scaleFactorItem);

    QStandardItem *scaleCCItem = new QStandardItem();
    if (std::isfinite(image_scale_cc_percent)) {
        scaleCCItem->setData(QString::number(image_scale_cc_percent, 'f', 1) + "%", Qt::DisplayRole);

        scaleCCItem->setData(image_scale_cc_percent, ScaleSortRole);
    } else {
        scaleCCItem->setData("N/A", Qt::DisplayRole);
        scaleCCItem->setData(ScaleNotAvailableSortValue, ScaleSortRole);
    }
    rowItems.append(scaleCCItem);

    tableModel->appendRow(rowItems);
}

void JFJochViewerImageListWindow::clearAllData() {
    tableModel->removeRows(0, tableModel->rowCount());
}

void JFJochViewerImageListWindow::datasetLoaded(std::shared_ptr<const JFJochReaderDataset> dataset) {
    clearAllData();

    if (!dataset)
        return;

    for (int i = 0; i < dataset->experiment.GetImageNum(); i++) {
        float bkg_estimate = 0;
        if (dataset->bkg_estimate.size() > i)
            bkg_estimate = dataset->bkg_estimate[i];

        int32_t spot_count = 0;
        if (dataset->spot_count.size() > i)
            spot_count = dataset->spot_count[i];

        float res_estimation = 0.0f;
        if (dataset->resolution_estimate.size() > i)
            res_estimation = dataset->resolution_estimate[i];

        QString indexing_result = "N/A";
        if (dataset->indexing_result.size() > i) {
            if (dataset->indexing_result[i] == 0)
                indexing_result = "No";
            else
                indexing_result = "Yes";
        }

        int64_t max_value = 0;
        if (dataset->max_value.size() > i)
            max_value = dataset->max_value[i];

        double image_scale_factor = NAN;
        if (dataset->image_scale_factor.size() > i)
            image_scale_factor = dataset->image_scale_factor[i];

        double image_scale_cc_percent = NAN;
        if (dataset->image_scale_cc.size() > i)
            image_scale_cc_percent = dataset->image_scale_cc[i] * 100.0;

        addDataRow(i + 1,
                   bkg_estimate,
                   indexing_result,
                   spot_count,
                   res_estimation,
                   max_value,
                   image_scale_factor,
                   image_scale_cc_percent);
    }
}

void JFJochViewerImageListWindow::imageLoaded(std::shared_ptr<const JFJochReaderImage> image) {
    int curr_row = -1;
    if (image)
        curr_row = image->ImageData().number;

    for (int row = 0; row < tableModel->rowCount(); row++) {
        for (int col = 0; col < tableModel->columnCount(); ++col) {
            QStandardItem *item = tableModel->item(row, col);
            if (item) {
                if (row == curr_row)
                    item->setBackground(Qt::blue);
                else
                    item->setBackground(Qt::white);
            }
        }
    }
}

void JFJochViewerImageListWindow::onTableRowDoubleClicked(const QModelIndex &index) {
    if (!index.isValid())
        return;

    QModelIndex sourceIndex = proxyModel->mapToSource(index);
    int imageNumber = tableModel->item(sourceIndex.row(), 0)->data(Qt::DisplayRole).toInt();
    emit imageSelected(imageNumber - 1, 1);
}