Files
leonarski_fandClaude Opus 5.5 6fa1797f8e jfjoch_viewer: keep showing the images of a raw sweep after processing it
A processing job on a CBF, marCCD, SMV or SFRM sweep writes a _process.h5 that
holds the per-image analysis but no images: there is nothing in a directory of
frames for it to link to. The viewer showed that run by reading the file on its
own, so after processing the image area stayed empty.

JFJochHDF5Reader::ReadFile now takes the reader of the sweep the file was made
from; for a file without pixels each image is read from that sweep (frame
/entry/detector/number[i]) and the file's analysis is laid over it. The viewer
passes its open raw reader when it shows such a run. HDF5 inputs are unchanged:
their runs already link the original images.

Tests: JFJochHDF5Reader_ProcessFileOfRawSweep_PixelsFromSweep (a run over one
frame of a two-frame miniCBF sweep shows that frame's pixels under the run's
analysis) and OpenableFilePatterns (the browser/dialog wildcards). The viewer
documentation said the process file carried the images; corrected.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQrPqZ52Tp6rzzZGxf3
2026-11-20 02:41:11 +01:00

72 lines
2.8 KiB
C++

// 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 {
// Read each of their inputs' frames through them (JFJochMultiReader.h), or the frames of the sweep a
// file without pixels was made from (JFJochHDF5Reader.h).
friend class JFJochMultiReader;
friend class JFJochHDF5Reader;
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);
void AddDeadPixelMask(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