Files
Jungfraujoch/reader/JFJochHDF5Reader.cpp
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

256 lines
9.9 KiB
C++

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#include "JFJochHDF5Reader.h"
#include "../common/JFJochException.h"
void JFJochHDF5Reader::ReadFile(const std::string &filename, JFJochReader *pixels) {
std::unique_lock ul(hdf5_mutex);
image_source_.Clear();
snapshots_.clear();
active_metadata_.reset();
active_snapshot_.clear();
number_of_images = 0;
try {
auto metadata = std::make_shared<HDF5MetadataSource>();
auto open_result = metadata->Open(filename, default_experiment);
has_pixels = open_result.image_layout.format != FileWriterFormat::NoFile;
pixel_reader_ = has_pixels ? nullptr : pixels;
image_source_.Configure(std::move(open_result.image_layout));
// Original file: per-image metadata is co-located with the pixels.
metadata->UseImageSourceForMetadata(&image_source_);
number_of_images = open_result.number_of_images;
snapshots_["Original"] = metadata;
active_metadata_ = metadata;
active_snapshot_ = "Original";
SetStartMessage(metadata->Dataset());
} catch (const std::exception &e) {
image_source_.Clear();
snapshots_.clear();
active_metadata_.reset();
active_snapshot_.clear();
number_of_images = 0;
SetStartMessage({});
throw;
}
}
uint64_t JFJochHDF5Reader::GetNumberOfImages() const {
std::unique_lock ul(hdf5_mutex);
return number_of_images;
}
void JFJochHDF5Reader::Close() {
std::unique_lock ul(hdf5_mutex);
image_source_.Clear();
pixel_reader_ = nullptr;
snapshots_.clear();
active_metadata_.reset();
active_snapshot_.clear();
number_of_images = 0;
SetStartMessage({});
}
HDF5ImageLocator::Location JFJochHDF5Reader::GetImageLocation(int64_t image_number) const {
if (image_number >= static_cast<int64_t>(number_of_images) || image_number < 0)
throw JFJochException(JFJochExceptionCategory::HDF5, "Image out of bounds");
return image_source_.Resolve(image_number);
}
bool JFJochHDF5Reader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &ret) {
// Every worker thread of an offline run comes through here, and HDF5 lets only one of them in at
// a time. So ask HDF5 only where the image is - a chunk-index lookup - and read the bytes after
// dropping the lock, which is the part that takes any time and the part that parallelises.
std::optional<HDF5ImageSource::DirectChunk> chunk;
{
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Cannot load image if file not loaded");
if (!has_pixels)
return false;
auto loc = GetImageLocation(image_number);
chunk = image_source_.PrepareDirectRead(loc);
if (!chunk) {
ret.image = image_source_.ReadImageAt(ret.image_buffer, loc);
return true;
}
}
ret.image = HDF5ImageSource::ReadDirect(ret.image_buffer, *chunk);
return true;
}
bool JFJochHDF5Reader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
DataMessage &message,
std::vector<uint8_t> &buffer,
int64_t image_number,
bool update_dataset) {
(void) update_dataset;
if (!dataset)
return false;
// A file without images takes its pixels from the sweep it was processed from. That reader is asked
// outside hdf5_mutex, which it may take itself.
int64_t metadata_number = image_number;
if (!has_pixels) {
if (!pixel_reader_)
return false;
if (!dataset->source_image_number.empty())
metadata_number = dataset->source_image_number.at(image_number);
auto pixel_dataset = std::const_pointer_cast<JFJochReaderDataset>(pixel_reader_->GetDataset());
if (!pixel_reader_->LoadImage_i(pixel_dataset, message, buffer, metadata_number, false))
return false;
}
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Cannot load image if file not loaded");
// Pixels from the shared image source, per-image metadata from the active snapshot.
if (has_pixels)
message.image = image_source_.ReadImageAt(buffer, GetImageLocation(image_number));
message.number = image_number;
active_metadata_->FillPerImage(message, metadata_number, dataset);
return true;
}
std::vector<HDF5DataSourceMessage> JFJochHDF5Reader::GetHDF5DataSource(uint64_t first_image,
std::optional<uint64_t> image_count,
uint64_t stride) const {
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Cannot generate HDF5 source mapping if file not loaded");
return image_source_.GetSourceMapping(first_image, image_count, number_of_images, stride);
}
StoredPixelFormat JFJochHDF5Reader::GetStoredPixelFormat() const {
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Cannot read stored pixel format if file not loaded");
return image_source_.GetStoredPixelFormat();
}
std::vector<IntegrationOutcome> JFJochHDF5Reader::ReadReflections(size_t start_image,
std::optional<size_t> end_image) const {
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Cannot read reflections if file not loaded");
return active_metadata_->ReadReflections(start_image, end_image);
}
std::vector<SpotToSave> JFJochHDF5Reader::ReadSpots(int64_t image) const {
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Cannot read spots if file not loaded");
return active_metadata_->ReadSpots(image);
}
bool JFJochHDF5Reader::HasStoredSpots() const {
std::unique_lock ul(hdf5_mutex);
return active_metadata_ && active_metadata_->HasSpots();
}
CompressedImage JFJochHDF5Reader::ReadCalibration(std::vector<uint8_t> &tmp, const std::string &name) const {
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Master file not loaded");
return active_metadata_->ReadCalibration(tmp, name);
}
void JFJochHDF5Reader::RegisterSnapshot(const std::string &name, const std::string &master_path) {
std::unique_lock ul(hdf5_mutex);
if (!active_metadata_)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Open a dataset before registering a snapshot");
auto metadata = std::make_shared<HDF5MetadataSource>();
auto open_result = metadata->Open(master_path, default_experiment);
// A snapshot may cover a subset of the images (a sub-range or filtered reprocessing); its
// /entry/detector/number map (read in Open) ties each snapshot image back to an original one.
// It just must not claim more images than the dataset has.
if (open_result.number_of_images > number_of_images)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Snapshot has more images than the open dataset");
// Snapshot pixels come from the existing image source; its own (integrated) master holds the
// per-image metadata at the global index.
metadata->UseImageSourceForMetadata(nullptr);
snapshots_[name] = metadata;
}
void JFJochHDF5Reader::RemoveSnapshot(const std::string &name) {
std::unique_lock ul(hdf5_mutex);
if (name == "Original")
return; // the original file metadata is always kept
snapshots_.erase(name);
if (active_snapshot_ == name) {
active_metadata_ = snapshots_.at("Original");
active_snapshot_ = "Original";
SetStartMessage(active_metadata_->Dataset());
}
}
void JFJochHDF5Reader::SetActiveSnapshot(const std::string &name) {
std::unique_lock ul(hdf5_mutex);
auto it = snapshots_.find(name);
if (it == snapshots_.end())
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown snapshot: " + name);
active_metadata_ = it->second;
active_snapshot_ = name;
SetStartMessage(active_metadata_->Dataset());
}
std::vector<std::string> JFJochHDF5Reader::SnapshotNames() const {
std::unique_lock ul(hdf5_mutex);
std::vector<std::string> names;
names.reserve(snapshots_.size());
for (const auto &[name, _]: snapshots_)
names.push_back(name);
return names;
}
std::string JFJochHDF5Reader::ActiveSnapshot() const {
std::unique_lock ul(hdf5_mutex);
return active_snapshot_;
}
std::vector<std::pair<std::string, std::shared_ptr<const JFJochReaderDataset>>>
JFJochHDF5Reader::AllSnapshotDatasets() const {
std::unique_lock ul(hdf5_mutex);
std::vector<std::pair<std::string, std::shared_ptr<const JFJochReaderDataset>>> out;
out.reserve(snapshots_.size());
// "Original" first, then the rest, so overlay colours stay stable across updates.
if (auto it = snapshots_.find("Original"); it != snapshots_.end())
out.emplace_back(it->first, it->second->Dataset());
for (const auto &[name, source]: snapshots_)
if (name != "Original")
out.emplace_back(name, source->Dataset());
return out;
}