mx/Jungfraujoch
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 38 Wiki Activity

* Enhancements for XFEL

Browse Source 
* Enhancements for EIGER
* Writer is more flexible and capable of handling DECTRIS data
This commit is contained in:
leonarski_f
2024-03-05 20:41:47 +01:00
parent 71d862b706
commit d315506633
165 changed files with 5440 additions and 2230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
frame_serialize/CBORStream2Serializer.cpp
View File

@@ -4,6 +4,7 @@
#include "tinycbor/src/cbor.h"
#include "CborErr.h"
#include "CborUtil.h"
#include <nlohmann/json.hpp>
inline void CBOR_ENC(CborEncoder &encoder, const char* key, const char* value) {
cborErr(cbor_encode_text_stringz(&encoder, key));
@@ -47,6 +48,12 @@ inline void CBOR_ENC(CborEncoder &encoder, const char* key, int64_t value) {
cborErr(cbor_encode_int(&encoder, value));
}
template <class T>
inline void CBOR_ENC(CborEncoder &encoder, const char* key, const std::optional<T> &value) {
if (value)
CBOR_ENC(encoder, key, value.value());
}
void CBOR_ENC_COMPRESSED(CborEncoder &encoder,
const void *image, size_t image_size,
CompressionAlgorithm algorithm,
@@ -223,27 +230,23 @@ inline void CBOR_ENC_GONIOMETER(CborEncoder &encoder, const char* key, const Gon
CborEncoder mapEncoder;
cborErr(cbor_encode_text_stringz(&encoder, key));
cborErr(cbor_encoder_create_map(&encoder, &mapEncoder, 3));
cborErr(cbor_encoder_create_map(&encoder, &mapEncoder, 2));
CBOR_ENC(mapEncoder, "increment", g.increment);
CBOR_ENC(mapEncoder, "start", g.start);
CBOR_ENC_AXIS(mapEncoder, "axis", g.axis);
cborErr(cbor_encoder_close_container(&encoder, &mapEncoder));
}
inline void CBOR_ENC_GONIOMETER_MAP(CborEncoder &encoder, const char* key,
const std::map<std::string, GoniometerAxis> &g) {
inline void CBOR_ENC_GONIOMETER_MAP(CborEncoder &encoder, const char* key, const StartMessage &msg) {
CborEncoder mapEncoder;
cborErr(cbor_encode_text_stringz(&encoder, key));
cborErr(cbor_encoder_create_map(&encoder, &mapEncoder, g.size()));
for (const auto& [x, y]: g)
CBOR_ENC_GONIOMETER(mapEncoder, x.c_str(), y);
cborErr(cbor_encoder_create_map(&encoder, &mapEncoder, 1));
CBOR_ENC_GONIOMETER(mapEncoder, "omega", msg.omega);
cborErr(cbor_encoder_close_container(&encoder, &mapEncoder));
}
inline void CBOR_ENC_CHANNELS(CborEncoder &encoder, const char* key, const std::vector<std::string> &v) {
inline void CBOR_ENC(CborEncoder &encoder, const char* key, const std::vector<std::string> &v) {
CborEncoder arrayEncoder;
cborErr(cbor_encode_text_stringz(&encoder, key));
@@ -277,6 +280,28 @@ inline void CBOR_ENC(CborEncoder &encoder, const char* key, const std::vector<Co
cborErr(cbor_encoder_close_container(&encoder, &mapEncoder));
}
inline void CBOR_ENC_START_USER_DATA(CborEncoder& encoder, const char* key,
const StartMessage& message) {
nlohmann::json j;
j["file_prefix"] = message.file_prefix;
j["data_file_count"] = message.data_file_count;
j["source_name"] = message.source_name;
j["source_name_short"] = message.source_name_short;
j["instrument_name"] = message.instrument_name;
j["instrument_name_short"] = message.instrument_name_short;
j["sample_name"] = message.sample_name;
j["user"] = message.user_data;
if (message.attenuator_transmission)
j["attenuator_transmission"] = message.attenuator_transmission.value();
if (message.total_flux)
j["total_flux"] = message.total_flux.value();
j["omega_rotation_axis"] = {message.omega.axis[0], message.omega.axis[1], message.omega.axis[2]};
j["space_group_number"] = message.space_group_number;
auto str = j.dump();
CBOR_ENC(encoder, key, str);
}
CBORStream2Serializer::CBORStream2Serializer(uint8_t *in_buffer, size_t buffer_size) :
buffer(in_buffer), max_buffer_size(buffer_size), curr_size(0) {}
@@ -298,7 +323,8 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message)
CBOR_ENC(mapEncoder, "detector_distance", message.detector_distance);
CBOR_ENC(mapEncoder, "beam_center_x", message.beam_center_x);
CBOR_ENC(mapEncoder, "beam_center_y", message.beam_center_y);
CBOR_ENC(mapEncoder, "countrate_correction_enabled", message.countrate_correction_enabled);
CBOR_ENC(mapEncoder, "flatfield_enabled", message.flatfield_enabled);
CBOR_ENC(mapEncoder, "number_of_images", message.number_of_images);
CBOR_ENC(mapEncoder, "image_size_x", message.image_size_x);
CBOR_ENC(mapEncoder, "image_size_y", message.image_size_y);
@@ -323,53 +349,40 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message)
CBOR_ENC(mapEncoder, "series_id", message.series_id);
CBOR_ENC_AXIS(mapEncoder, "detector_translation", message.detector_translation);
CBOR_ENC_GONIOMETER_MAP(mapEncoder, "goniometer", message.goniometer);
CBOR_ENC_GONIOMETER_MAP(mapEncoder, "goniometer", message);
CBOR_ENC(mapEncoder, "pixel_mask", message.pixel_mask);
CBOR_ENC_CHANNELS(mapEncoder, "channels", message.channels);
CBOR_ENC(mapEncoder, "file_prefix", message.file_prefix);
CBOR_ENC(mapEncoder, "sample_name", message.sample_name);
CBOR_ENC(mapEncoder, "space_group_number", message.space_group_number);
CBOR_ENC(mapEncoder, "channels", message.channels);
CBOR_ENC(mapEncoder, "max_spot_count", message.max_spot_count);
CBOR_ENC(mapEncoder, "data_file_count", message.data_file_count);
CBOR_ENC(mapEncoder, "storage_cell_number", message.storage_cell_number);
CBOR_ENC_RATIONAL(mapEncoder, "storage_cell_delay", message.storage_cell_delay_ns, 1000*1000*1000UL);
if (message.roi_summation_area)
CBOR_ENC(mapEncoder, "roi_sum_area", message.roi_summation_area.value());
CBOR_ENC(mapEncoder, "pixel_bit_depth", message.pixel_bit_depth);
CBOR_ENC(mapEncoder, "pixel_signed", message.pixel_signed);
switch (message.compression_algorithm) {
case CompressionAlgorithm::BSHUF_LZ4:
CBOR_ENC(mapEncoder, "compression_algorithm", "bslz4");
CBOR_ENC(mapEncoder, "roi_sum_area", message.roi_summation_area);
switch (message.pixel_bit_depth) {
case 8:
CBOR_ENC(mapEncoder, "image_dtype", message.pixel_signed ? "int8" : "uint8");
break;
case CompressionAlgorithm::BSHUF_ZSTD:
case CompressionAlgorithm::BSHUF_ZSTD_RLE:
CBOR_ENC(mapEncoder, "compression_algorithm", "bszstd");
case 16:
CBOR_ENC(mapEncoder, "image_dtype", message.pixel_signed ? "int16" : "uint16");
break;
default:
CBOR_ENC(mapEncoder, "compression_algorithm", "none");
case 32:
CBOR_ENC(mapEncoder, "image_dtype", message.pixel_signed ? "int32" : "uint32");
break;
}
CBOR_ENC(mapEncoder, "compression_block_size", message.compression_block_size);
if (message.unit_cell)
CBOR_ENC_UNIT_CELL(mapEncoder, "unit_cell", message.unit_cell.value());
if (message.attenuator_transmission)
CBOR_ENC(mapEncoder, "attenuator_transmission", message.attenuator_transmission.value());
if (message.total_flux)
CBOR_ENC(mapEncoder, "total_flux", message.total_flux.value());
CBOR_ENC(mapEncoder, "source_name", message.source_name);
CBOR_ENC(mapEncoder, "source_name_short", message.source_name_short);
CBOR_ENC(mapEncoder, "instrument_name", message.instrument_name);
CBOR_ENC(mapEncoder, "instrument_name_short", message.instrument_name_short);
CBOR_ENC(mapEncoder, "az_int_bin_number", message.az_int_bin_number);
CBOR_ENC(mapEncoder, "az_int_bin_to_q", message.az_int_bin_to_q);
CBOR_ENC(mapEncoder, "summation", message.summation);
CBOR_ENC(mapEncoder, "gain_file_names", message.gain_file_names);
if (!message.calibration.empty())
CBOR_ENC(mapEncoder, "calibration", message.calibration);
CBOR_ENC(mapEncoder, "user_data", message.user_data);
CBOR_ENC_START_USER_DATA(mapEncoder, "user_data", message);
cborErr(cbor_encoder_close_container(&encoder, &mapEncoder));
curr_size = cbor_encoder_get_buffer_size(&encoder, buffer);
}
@@ -423,11 +436,11 @@ void CBORStream2Serializer::SerializeImage(const DataMessage& message) {
CBOR_ENC(mapEncoder, "indexing_result", message.indexing_result);
if (!message.indexing_lattice.empty())
CBOR_ENC(mapEncoder, "indexing_lattice", message.indexing_lattice);
CBOR_ENC(mapEncoder, "xfel_bunch_id", message.xfel_bunch_id);
CBOR_ENC(mapEncoder, "xfel_pulse_id", message.xfel_pulse_id);
CBOR_ENC(mapEncoder, "xfel_event_code", message.xfel_event_code);
CBOR_ENC(mapEncoder, "jf_info", (uint64_t) message.jf_info);
CBOR_ENC(mapEncoder, "jf_info", message.jf_info);
CBOR_ENC(mapEncoder, "receiver_aq_dev_delay", message.receiver_aq_dev_delay);
CBOR_ENC(mapEncoder, "storage_cell", (uint64_t) message.storage_cell);
CBOR_ENC(mapEncoder, "storage_cell", message.storage_cell);
CBOR_ENC(mapEncoder, "saturated_pixel_count", message.saturated_pixel_count);
CBOR_ENC(mapEncoder, "error_pixel_count", message.error_pixel_count);
CBOR_ENC(mapEncoder, "strong_pixel_count", message.strong_pixel_count);
@@ -435,10 +448,6 @@ void CBORStream2Serializer::SerializeImage(const DataMessage& message) {
CBOR_ENC(mapEncoder, "bkg_estimate", message.bkg_estimate);
CBOR_ENC(mapEncoder, "adu_histogram", message.adu_histogram);
CBOR_ENC(mapEncoder, "user_data", message.user_data);
CBOR_ENC(mapEncoder, "detector_distance", message.detector_distance);
CBOR_ENC(mapEncoder, "beam_center_x", message.beam_center_x);
CBOR_ENC(mapEncoder, "beam_center_y", message.beam_center_y);
CBOR_ENC(mapEncoder, "incident_energy", message.incident_energy);
if (message.roi_sum)
CBOR_ENC(mapEncoder, "roi_sum", message.roi_sum.value());