Jungfraujoch/reader/JFJochReader.h

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

#ifndef JFJOCHIMAGEREADER_H
#define JFJOCHIMAGEREADER_H

#include <unordered_set>
#include <map>
#include <mutex>

#include "../common/JFJochMessages.h"
#include "../common/Plot.h"
#include "../common/ROIBox.h"
#include "../common/DiffractionExperiment.h"
#include "JFJochReaderDataset.h"
#include "JFJochReaderImage.h"
#include "JFJochReaderSpots.h"

class JFJochReader {
    // Reads each of its inputs' frames through them (JFJochMultiReader.h).
    friend class JFJochMultiReader;

    mutable std::mutex m;
    std::shared_ptr<JFJochReaderDataset> dataset;

    virtual bool LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
                             DataMessage& message,
                             std::vector<uint8_t> &buffer,
                             int64_t image_number,
                             bool update_dataset) = 0;

    mutable std::mutex summation_mutex;
    void SummationThread(int64_t image0,
                         int64_t n_image,
                         int64_t image_jump,
                         JFJochReaderImage &image);
protected:
    void SetStartMessage(const std::shared_ptr<JFJochReaderDataset> &val);
    DiffractionExperiment default_experiment;
public:
    virtual ~JFJochReader() = default;

    JFJochReader& Experiment(const DiffractionExperiment& experiment);

    std::shared_ptr<const JFJochReaderDataset> GetDataset() const;
    [[nodiscard]] virtual uint64_t GetNumberOfImages() const = 0;

    virtual void Close() = 0;

    std::shared_ptr<JFJochReaderImage> LoadImage(int64_t image_number, int64_t summation_factor = 1);

    void UpdateGeomMetadata(const DiffractionExperiment& experiment);
    void UpdateUserMask(const std::vector<uint32_t>& mask);

    // Read one image into a raw image the caller owns, false where there is nothing to read. A
    // worker that walks a whole sweep hands the same object back on every frame and so keeps its
    // buffer: GetRawImage() allocates a fresh one per call, which on a 4-byte 16 Mpx frame is 72 MB
    // of untouched pages the decoder then faults in one by one, measurably more than the decode.
    virtual bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) = 0;

    // The same image in a freshly allocated raw image.
    std::shared_ptr<JFJochReaderRawImage> GetRawImage(int64_t image_number);

    virtual std::vector<SpotToSave> ReadSpots(int64_t image) const = 0;
    std::shared_ptr<JFJochReaderSpots> ReadAllSpots(int64_t start_image, int64_t end_image, int64_t stride = 1) const;
};

#endif //JFJOCHIMAGEREADER_H