899 lines
34 KiB
C++
899 lines
34 KiB
C++
// Copyright (2019-2023) Paul Scherrer Institute
|
|
|
|
#include "CBORStream2Deserializer.h"
|
|
#include "tinycbor/src/cbor.h"
|
|
#include "CborErr.h"
|
|
#include "CborUtil.h"
|
|
#include <nlohmann/json.hpp>
|
|
|
|
inline std::string GetCBORString(CborValue &value) {
|
|
if (!cbor_value_is_text_string(&value))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "String expected");
|
|
|
|
std::vector<char> s(16384);
|
|
size_t len = s.size() - 1;
|
|
cborErr(cbor_value_copy_text_string(&value, s.data(), &len, nullptr));
|
|
s[len+1] = 0;
|
|
cborErr(cbor_value_advance(&value));
|
|
return {s.data()};
|
|
}
|
|
|
|
inline int64_t GetCBORInt(CborValue &value) {
|
|
if (!cbor_value_is_integer(&value) )
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Integer expected");
|
|
int64_t tmp;
|
|
cborErr(cbor_value_get_int64(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return tmp;
|
|
}
|
|
|
|
|
|
inline uint64_t GetCBORUInt(CborValue &value) {
|
|
if (!cbor_value_is_unsigned_integer(&value) )
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Unsigned integer expected");
|
|
uint64_t tmp;
|
|
cborErr(cbor_value_get_uint64(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return tmp;
|
|
}
|
|
|
|
inline float GetCBORFloat(CborValue &value) {
|
|
if (cbor_value_is_double(&value)) {
|
|
double tmp;
|
|
cborErr(cbor_value_get_double(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return static_cast<float>(tmp);
|
|
} else if (cbor_value_is_float(&value)) {
|
|
float tmp;
|
|
cborErr(cbor_value_get_float(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return tmp;
|
|
} else if (cbor_value_is_half_float(&value)) {
|
|
float tmp;
|
|
cborErr(cbor_value_get_half_float_as_float(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return tmp;
|
|
}
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Float expected");
|
|
}
|
|
|
|
inline bool GetCBORBool(CborValue &value) {
|
|
if (!cbor_value_is_boolean(&value) ) {
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Bool expected " + std::to_string(cbor_value_get_type(&value)));
|
|
}
|
|
bool tmp;
|
|
cborErr(cbor_value_get_boolean(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return tmp;
|
|
}
|
|
|
|
inline CborTag GetCBORTag(CborValue &value) {
|
|
if (!cbor_value_is_tag(&value) )
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Tag expected");
|
|
CborTag tmp;
|
|
cborErr(cbor_value_get_tag(&value, &tmp));
|
|
cborErr(cbor_value_advance(&value));
|
|
return tmp;
|
|
}
|
|
|
|
inline std::string GetCBORDateTime(CborValue &value) {
|
|
auto tag = GetCBORTag(value);
|
|
if (tag == CborDateTimeStringTag)
|
|
return GetCBORString(value);
|
|
else if (tag == CborUnixTime_tTag) {
|
|
time_t t = GetCBORUInt(value);
|
|
char buf1[255];
|
|
strftime(buf1, sizeof(buf1), "%FT%T", gmtime(&t));
|
|
return std::string(buf1) + "Z";
|
|
} else
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Time/date tag error");
|
|
}
|
|
|
|
inline uint64_t GetCBORArrayLen(CborValue &value) {
|
|
if (!cbor_value_is_array(&value) )
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Array expected");
|
|
|
|
size_t array_len;
|
|
cborErr(cbor_value_get_array_length(&value, &array_len));
|
|
return array_len;
|
|
}
|
|
|
|
inline uint64_t GetCBORMapLen(CborValue &value) {
|
|
if (!cbor_value_is_map(&value) )
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Map expected");
|
|
size_t map_len;
|
|
cborErr(cbor_value_get_map_length(&value, &map_len));
|
|
return map_len;
|
|
}
|
|
|
|
inline std::pair<uint64_t, uint64_t> GetRational(CborValue &value) {
|
|
std::pair<uint64_t, uint64_t> ret;
|
|
if (GetCBORArrayLen(value) != 2)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError,
|
|
"Rational number expects array of 2 elements");
|
|
CborValue array_value;
|
|
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
ret.first = GetCBORUInt(array_value);
|
|
ret.second = GetCBORUInt(array_value);
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
|
|
return ret;
|
|
}
|
|
|
|
inline std::pair<uint64_t, uint64_t> GetCBORDimension2DArray(CborValue &value) {
|
|
std::pair<uint64_t, uint64_t> ret;
|
|
|
|
if (GetCBORArrayLen(value) != 2)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Only 2D arrays allowed");
|
|
|
|
CborValue array_value;
|
|
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
|
|
ret.second = GetCBORUInt(array_value);
|
|
ret.first = GetCBORUInt(array_value);
|
|
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
|
|
return ret;
|
|
}
|
|
|
|
inline std::pair<const uint8_t *, size_t> GetCBORByteString(CborValue &value) {
|
|
if (!cbor_value_is_byte_string(&value) )
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Bool expected");
|
|
|
|
size_t len;
|
|
cborErr(cbor_value_get_string_length(&value, &len));
|
|
|
|
// Code below from: https://github.com/dectris/documentation/blob/main/stream_v2/examples/stream2.c
|
|
|
|
const uint8_t *ptr = cbor_value_get_next_byte(&value);
|
|
uint8_t val = *ptr;
|
|
|
|
if (val < 0x40)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Something wrong with byte string tag");
|
|
|
|
val -= 0x40;
|
|
if (val < 24)
|
|
ptr += 1;
|
|
else if (val == 24)
|
|
ptr += 1 + 1;
|
|
else if (val == 25)
|
|
ptr += 1 + 2;
|
|
else if (val == 26)
|
|
ptr += 1 + 4;
|
|
else if (val == 27)
|
|
ptr += 1 + 8;
|
|
else
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Something wrong with byte string tag");
|
|
|
|
cborErr(cbor_value_advance(&value));
|
|
return {ptr, len};
|
|
}
|
|
|
|
inline void GetCBORFloatArray(CborValue &value, std::vector<float> &v) {
|
|
if (GetCBORTag(value) != TagFloatLE)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Incorrect array type tag");
|
|
|
|
auto [ptr, len] = GetCBORByteString(value);
|
|
|
|
if (len % sizeof(float))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Size mismatch");
|
|
|
|
v.resize(len / sizeof(float));
|
|
memcpy(v.data(), ptr, len);
|
|
}
|
|
|
|
inline void GetCBORStringArray(CborValue &value, std::vector<std::string> &v) {
|
|
if (!cbor_value_is_array(&value))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Array expected");
|
|
CborValue array_value;
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
while (! cbor_value_at_end(&array_value)) {
|
|
v.emplace_back(GetCBORString(array_value));
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
}
|
|
|
|
inline void GetCBORUInt64Array(CborValue &value, std::vector<uint64_t> &v) {
|
|
if (GetCBORTag(value) != TagUnsignedInt64BitLE)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Incorrect array type tag");
|
|
|
|
auto [ptr, len] = GetCBORByteString(value);
|
|
|
|
if (len % sizeof(uint64_t))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Size mismatch");
|
|
|
|
v.resize(len / sizeof(uint64_t));
|
|
memcpy(v.data(), ptr, len);
|
|
}
|
|
|
|
inline void GetCBORTypedArray(CompressedImage &v, CborValue &value) {
|
|
CborTag tag = GetCBORTag(value);
|
|
|
|
switch (tag) {
|
|
case TagFloatLE:
|
|
v.pixel_is_signed = true;
|
|
v.pixel_depth_bytes = sizeof(float);
|
|
v.pixel_is_float = true;
|
|
break;
|
|
case TagSignedInt8Bit:
|
|
v.pixel_is_signed = true;
|
|
v.pixel_depth_bytes = 1;
|
|
v.pixel_is_float = false;
|
|
break;
|
|
case TagUnsignedInt8Bit:
|
|
v.pixel_is_signed = false;
|
|
v.pixel_depth_bytes = 1;
|
|
v.pixel_is_float = false;
|
|
break;
|
|
case TagSignedInt16BitLE:
|
|
v.pixel_is_signed = true;
|
|
v.pixel_depth_bytes = 2;
|
|
v.pixel_is_float = false;
|
|
break;
|
|
case TagUnsignedInt16BitLE:
|
|
v.pixel_is_signed = false;
|
|
v.pixel_depth_bytes = 2;
|
|
v.pixel_is_float = false;
|
|
break;
|
|
case TagSignedInt32BitLE:
|
|
v.pixel_is_signed = true;
|
|
v.pixel_depth_bytes = 4;
|
|
v.pixel_is_float = false;
|
|
break;
|
|
case TagUnsignedInt32BitLE:
|
|
v.pixel_is_signed = false;
|
|
v.pixel_depth_bytes = 4;
|
|
v.pixel_is_float = false;
|
|
break;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::CBORError,
|
|
"Only int/uint arrays of 1, 2, 4 bytes per element allowed");
|
|
}
|
|
|
|
if (cbor_value_is_tag(&value)) {
|
|
if (GetCBORTag(value) != TagDECTRISCompression)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Unsupported tag");
|
|
|
|
if (GetCBORArrayLen(value) != 3)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Expected 3 element array");
|
|
|
|
CborValue array_value;
|
|
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
|
|
auto algorithm_text = GetCBORString(array_value);
|
|
if (algorithm_text == "bslz4")
|
|
v.algorithm = CompressionAlgorithm::BSHUF_LZ4;
|
|
else if (algorithm_text == "bszstd")
|
|
v.algorithm = CompressionAlgorithm::BSHUF_ZSTD;
|
|
else
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Unsupported compression algorithm");
|
|
|
|
v.pixel_depth_bytes = GetCBORUInt(array_value);
|
|
auto ret = GetCBORByteString(array_value);
|
|
v.data = ret.first;
|
|
v.size = ret.second;
|
|
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
|
|
} else if (cbor_value_is_byte_string(&value)) {
|
|
v.algorithm = CompressionAlgorithm::NO_COMPRESSION;
|
|
auto ret = GetCBORByteString(value);
|
|
v.data = ret.first;
|
|
v.size = ret.second;
|
|
} else
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Byte string or compressed array expected");
|
|
}
|
|
|
|
void GetCBORMultidimTypedArray(CompressedImage &v, CborValue &value) {
|
|
|
|
if (GetCBORTag(value) != TagMultiDimArray)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Multidim array expected");
|
|
|
|
if (GetCBORArrayLen(value) != 2)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "2 element array expected");
|
|
|
|
CborValue array_value;
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
|
|
auto [x,y] = GetCBORDimension2DArray(array_value);
|
|
v.xpixel = x;
|
|
v.ypixel = y;
|
|
|
|
GetCBORTypedArray(v, array_value);
|
|
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
}
|
|
|
|
|
|
bool CheckMagicNumber(CborValue &v) {
|
|
auto key = GetCBORString(v);
|
|
if (key != "magic_number") {
|
|
cbor_value_advance(&v);
|
|
return false;
|
|
} else {
|
|
return GetCBORUInt(v) == user_data_magic_number;
|
|
}
|
|
}
|
|
|
|
inline SpotToSave GetSpot(CborValue& value) {
|
|
SpotToSave s;
|
|
CborValue map_value;
|
|
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (!cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
if (key == "x")
|
|
s.x = GetCBORFloat(map_value);
|
|
else if (key == "y")
|
|
s.y = GetCBORFloat(map_value);
|
|
else if (key == "I")
|
|
s.intensity = GetCBORFloat(map_value);
|
|
else if (key == "indexed")
|
|
s.indexed = GetCBORBool(map_value);
|
|
else
|
|
cbor_value_advance(&map_value);
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
return s;
|
|
}
|
|
|
|
|
|
void CBORStream2Deserializer::GetCBORSpots(CborValue &value) {
|
|
size_t array_len = GetCBORArrayLen(value);
|
|
CborValue array_value;
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
for (int i = 0; i < array_len; i++)
|
|
data_message.spots.push_back(GetSpot(array_value));
|
|
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::DecodeType(CborValue &value) {
|
|
if (cbor_value_at_end(&value))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Message empty");
|
|
auto key = GetCBORString(value);
|
|
|
|
if (key != "type")
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "First CBOR entry must by type");
|
|
|
|
if (cbor_value_at_end(&value))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Message empty");
|
|
|
|
auto type_str = GetCBORString(value);
|
|
if (type_str == "start")
|
|
msg_type = Type::START;
|
|
else if (type_str == "end")
|
|
msg_type = Type::END;
|
|
else if (type_str == "image")
|
|
msg_type = Type::IMAGE;
|
|
else
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Unknown message type");
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessGoniometerMap(CborValue &value) {
|
|
CborValue map_value;
|
|
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
if (key == "omega")
|
|
ProcessGoniometerOmega(map_value);
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessAxis(CborValue &value, float v[3]) {
|
|
if (GetCBORArrayLen(value) != 3)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Array with 3 floats expected");
|
|
CborValue array_value;
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
v[i] = GetCBORFloat(array_value);
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessGoniometerOmega(CborValue &value) {
|
|
CborValue map_value;
|
|
GoniometerAxis ret{};
|
|
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
if (key == "increment")
|
|
start_message.omega.increment = GetCBORFloat(map_value);
|
|
else if (key == "start")
|
|
start_message.omega.start = GetCBORFloat(map_value);
|
|
else
|
|
cbor_value_advance(&value);
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
bool CBORStream2Deserializer::ProcessImageMessageElement(CborValue &value) {
|
|
if (cbor_value_at_end(&value))
|
|
return false;
|
|
else {
|
|
auto key = GetCBORString(value);
|
|
try {
|
|
if (key == "image_id")
|
|
data_message.number = GetCBORInt(value);
|
|
else if (key == "data")
|
|
ProcessImageData(value);
|
|
else if (key == "series_unique_id")
|
|
data_message.series_unique_id = GetCBORString(value);
|
|
else if (key == "series_id")
|
|
data_message.series_id = GetCBORUInt(value);
|
|
else if (key == "real_time") {
|
|
auto r = GetRational(value);
|
|
data_message.exptime = r.first;
|
|
data_message.exptime_base = r.second;
|
|
} else if (key == "start_time") {
|
|
auto r = GetRational(value);
|
|
data_message.timestamp = r.first;
|
|
data_message.timestamp_base = r.second;
|
|
} else if (key == "user_data")
|
|
data_message.user_data = GetCBORString(value);
|
|
else if (key == "spots")
|
|
GetCBORSpots(value);
|
|
else if (key == "az_int_profile")
|
|
GetCBORFloatArray(value, data_message.az_int_profile);
|
|
else if (key == "indexing_result")
|
|
data_message.indexing_result = GetCBORUInt(value);
|
|
else if (key == "indexing_lattice")
|
|
GetCBORFloatArray(value, data_message.indexing_lattice);
|
|
else if (key == "jf_info")
|
|
data_message.jf_info = GetCBORUInt(value) & UINT32_MAX;
|
|
else if (key == "receiver_aq_dev_delay")
|
|
data_message.receiver_aq_dev_delay = GetCBORInt(value);
|
|
else if (key == "storage_cell")
|
|
data_message.storage_cell = GetCBORUInt(value) & UINT32_MAX;
|
|
else if (key == "xfel_pulse_id")
|
|
data_message.xfel_pulse_id = GetCBORUInt(value);
|
|
else if (key == "xfel_event_code")
|
|
data_message.xfel_event_code = GetCBORUInt(value);
|
|
else if (key == "saturated_pixel_count")
|
|
data_message.saturated_pixel_count = GetCBORUInt(value);
|
|
else if (key == "error_pixel_count")
|
|
data_message.error_pixel_count = GetCBORUInt(value);
|
|
else if (key == "strong_pixel_count")
|
|
data_message.strong_pixel_count = GetCBORUInt(value);
|
|
else if (key == "data_collection_efficiency")
|
|
data_message.image_collection_efficiency = GetCBORFloat(value);
|
|
else if (key == "bkg_estimate")
|
|
data_message.bkg_estimate = GetCBORFloat(value);
|
|
else if (key == "adu_histogram")
|
|
GetCBORUInt64Array(value, data_message.adu_histogram);
|
|
else if (key == "roi_integrals")
|
|
ProcessROIElementMap(value);
|
|
else {
|
|
if (cbor_value_is_tag(&value))
|
|
cbor_value_advance(&value);
|
|
cbor_value_advance(&value);
|
|
}
|
|
return true;
|
|
} catch (const JFJochException &e) {
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Error processing image message, key " + key + ":" + e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessCalibration(CborValue &value) {
|
|
// For calibration and mask - image might be accessed later on - so it is saved in internal storage of the object
|
|
// It allows the original start message to be lost
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
CompressedImage image;
|
|
image.channel = key;
|
|
GetCBORMultidimTypedArray(image, map_value);
|
|
image.Save();
|
|
start_message.calibration.emplace_back(std::move(image));
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessPixelMaskElement(CborValue &value) {
|
|
// For calibration and mask - image might be accessed later on - so it is saved in internal storage of the object
|
|
// It allows the original start message to be lost
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
CompressedImage image;
|
|
image.channel = key;
|
|
GetCBORMultidimTypedArray(image, map_value);
|
|
image.Save();
|
|
start_message.pixel_mask.emplace_back(std::move(image));
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessRadIntResultElement(CborValue &value) {
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
std::vector<float> val;
|
|
GetCBORFloatArray(map_value, val);
|
|
end_message.az_int_result[key] = val;
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessADUHistogramElement(CborValue &value) {
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
std::vector<uint64_t> val;
|
|
GetCBORUInt64Array(map_value, val);
|
|
end_message.adu_histogram[key] = val;
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessChannels(CborValue &value) {
|
|
if (!cbor_value_is_array(&value))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Array expected");
|
|
CborValue array_value;
|
|
cborErr(cbor_value_enter_container(&value, &array_value));
|
|
while (! cbor_value_at_end(&array_value)) {
|
|
const std::string s = GetCBORString(array_value);
|
|
start_message.channels.push_back(s);
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &array_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessUnitCellElement(CborValue &value) {
|
|
UnitCell unit_cell{};
|
|
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
|
|
if (key == "a")
|
|
unit_cell.a = GetCBORFloat(map_value);
|
|
else if (key == "b")
|
|
unit_cell.b = GetCBORFloat(map_value);
|
|
else if (key == "c")
|
|
unit_cell.c = GetCBORFloat(map_value);
|
|
else if (key == "alpha")
|
|
unit_cell.alpha = GetCBORFloat(map_value);
|
|
else if (key == "beta")
|
|
unit_cell.beta = GetCBORFloat(map_value);
|
|
else if (key == "gamma")
|
|
unit_cell.gamma = GetCBORFloat(map_value);
|
|
else
|
|
cbor_value_advance(&map_value);
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
|
|
start_message.unit_cell = unit_cell;
|
|
}
|
|
void CBORStream2Deserializer::ProcessROIElementMap(CborValue &value) {
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value))
|
|
ProcessROIElement(map_value);
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessROIElement(CborValue &value) {
|
|
ROIMessage msg{};
|
|
|
|
// key
|
|
const std::string roi_name = GetCBORString(value);
|
|
|
|
// value
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
while (! cbor_value_at_end(&map_value)) {
|
|
auto key = GetCBORString(map_value);
|
|
|
|
if (key == "sum")
|
|
msg.sum = GetCBORInt(map_value);
|
|
else if (key == "sum_square")
|
|
msg.sum_square = GetCBORUInt(map_value);
|
|
else if (key == "max_count")
|
|
msg.max_count = GetCBORInt(map_value);
|
|
else if (key == "pixels")
|
|
msg.pixels = GetCBORUInt(map_value);
|
|
else
|
|
cbor_value_advance(&map_value);
|
|
}
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
|
|
data_message.roi[roi_name] = msg;
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessStartUserData(CborValue &value) {
|
|
try {
|
|
const std::string s = GetCBORString(value);
|
|
auto j = nlohmann::json::parse(s);
|
|
if (!j.is_object())
|
|
return;
|
|
if (j.contains("file_prefix"))
|
|
start_message.file_prefix = j["file_prefix"];
|
|
if (j.contains("data_file_count"))
|
|
start_message.data_file_count = j["data_file_count"];
|
|
if (j.contains("user"))
|
|
start_message.user_data = j["user"];
|
|
if (j.contains("sample_name"))
|
|
start_message.sample_name = j["sample_name"];
|
|
if (j.contains("source_name"))
|
|
start_message.source_name = j["source_name"];
|
|
if (j.contains("source_name_short"))
|
|
start_message.source_name_short = j["source_name_short"];
|
|
if (j.contains("instrument_name"))
|
|
start_message.instrument_name = j["instrument_name"];
|
|
if (j.contains("instrument_name_short"))
|
|
start_message.instrument_name_short = j["instrument_name_short"];
|
|
if (j.contains("total_flux"))
|
|
start_message.total_flux = j["total_flux"];
|
|
if (j.contains("attenuator_transmission"))
|
|
start_message.attenuator_transmission = j["attenuator_transmission"];
|
|
if (j.contains("omega_rotation_axis") && j["omega_rotation_axis"].is_array() &&
|
|
(j["omega_rotation_axis"].size() == 3)) {
|
|
for (int i = 0; i < 3; i++)
|
|
start_message.omega.axis[i] = j["omega_rotation_axis"][i];
|
|
}
|
|
if (j.contains("space_group_number"))
|
|
start_message.space_group_number = j["space_group_number"];
|
|
if (j.contains("gain_file_names"))
|
|
start_message.gain_file_names = j["gain_file_names"];
|
|
if (j.contains("roi_names"))
|
|
start_message.roi_names = j["roi_names"];
|
|
|
|
} catch (const std::exception &e) {
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Cannot parse user_data as valid JSON " + std::string(e.what()));
|
|
}
|
|
}
|
|
|
|
bool CBORStream2Deserializer::ProcessStartMessageElement(CborValue &value) {
|
|
if (cbor_value_at_end(&value))
|
|
return false;
|
|
else {
|
|
auto key = GetCBORString(value);
|
|
try {
|
|
if (key == "beam_center_x")
|
|
start_message.beam_center_x = GetCBORFloat(value);
|
|
else if (key == "beam_center_y")
|
|
start_message.beam_center_y = GetCBORFloat(value);
|
|
else if (key == "detector_distance")
|
|
start_message.detector_distance = GetCBORFloat(value);
|
|
else if (key == "number_of_images")
|
|
start_message.number_of_images = GetCBORUInt(value);
|
|
else if (key == "countrate_correction_enabled")
|
|
start_message.countrate_correction_enabled = GetCBORBool(value);
|
|
else if (key == "flatfield_enabled")
|
|
start_message.flatfield_enabled = GetCBORBool(value);
|
|
else if (key == "image_size_x")
|
|
start_message.image_size_x = GetCBORUInt(value);
|
|
else if (key == "image_size_y")
|
|
start_message.image_size_y = GetCBORUInt(value);
|
|
else if (key == "incident_energy")
|
|
start_message.incident_energy = GetCBORFloat(value);
|
|
else if (key == "incident_wavelength")
|
|
start_message.incident_wavelength = GetCBORFloat(value);
|
|
else if (key == "frame_time")
|
|
start_message.frame_time = GetCBORFloat(value);
|
|
else if (key == "count_time")
|
|
start_message.count_time = GetCBORFloat(value);
|
|
else if (key == "saturation_value")
|
|
start_message.saturation_value = GetCBORInt(value);
|
|
else if (key == "error_value")
|
|
start_message.error_value = GetCBORInt(value);
|
|
else if (key == "pixel_size_x")
|
|
start_message.pixel_size_x = GetCBORFloat(value);
|
|
else if (key == "pixel_size_y")
|
|
start_message.pixel_size_y = GetCBORFloat(value);
|
|
else if (key == "sensor_thickness")
|
|
start_message.sensor_thickness = GetCBORFloat(value);
|
|
else if (key == "sensor_material")
|
|
start_message.sensor_material = GetCBORString(value);
|
|
else if (key == "detector_description")
|
|
start_message.detector_description = GetCBORString(value);
|
|
else if (key == "detector_serial_number")
|
|
start_message.detector_serial_number = GetCBORString(value);
|
|
else if (key == "series_unique_id")
|
|
start_message.series_unique_id = GetCBORString(value);
|
|
else if (key == "series_id")
|
|
start_message.series_id = GetCBORUInt(value);
|
|
else if (key == "pixel_mask")
|
|
ProcessPixelMaskElement(value);
|
|
else if (key == "channels")
|
|
GetCBORStringArray(value, start_message.channels);
|
|
else if (key == "detector_translation")
|
|
ProcessAxis(value, start_message.detector_translation);
|
|
else if (key == "goniometer")
|
|
ProcessGoniometerMap(value);
|
|
else if (key == "pixel_mask_enabled")
|
|
start_message.pixel_mask_enabled = GetCBORBool(value);
|
|
else if (key == "arm_date")
|
|
start_message.arm_date = GetCBORDateTime(value);
|
|
else if (key == "user_data")
|
|
ProcessStartUserData(value);
|
|
else if (key == "unit_cell")
|
|
ProcessUnitCellElement(value);
|
|
else if (key == "max_spot_count")
|
|
start_message.max_spot_count = GetCBORUInt(value);
|
|
else if (key == "image_dtype") {
|
|
auto val = GetCBORString(value);
|
|
if (val == "uint8") {
|
|
start_message.pixel_signed = false;
|
|
start_message.pixel_bit_depth = 8;
|
|
} else if (val == "int8") {
|
|
start_message.pixel_signed = true;
|
|
start_message.pixel_bit_depth = 8;
|
|
} else if (val == "uint16") {
|
|
start_message.pixel_signed = false;
|
|
start_message.pixel_bit_depth = 16;
|
|
} else if (val == "int16") {
|
|
start_message.pixel_signed = true;
|
|
start_message.pixel_bit_depth = 16;
|
|
} else if (val == "uint32") {
|
|
start_message.pixel_signed = false;
|
|
start_message.pixel_bit_depth = 32;
|
|
} else if (val == "int32") {
|
|
start_message.pixel_signed = true;
|
|
start_message.pixel_bit_depth = 32;
|
|
}
|
|
} else if (key == "az_int_bin_number")
|
|
start_message.az_int_bin_number = GetCBORInt(value);
|
|
else if (key == "az_int_bin_to_q")
|
|
GetCBORFloatArray(value, start_message.az_int_bin_to_q);
|
|
else if (key == "summation")
|
|
start_message.summation = GetCBORUInt(value);
|
|
else if (key == "storage_cell_number")
|
|
start_message.storage_cell_number = GetCBORUInt(value);
|
|
else if (key == "storage_cell_delay")
|
|
start_message.storage_cell_delay_ns = GetRational(value).first;
|
|
else if (key == "calibration")
|
|
ProcessCalibration(value);
|
|
else {
|
|
if (cbor_value_is_tag(&value))
|
|
cbor_value_advance(&value);
|
|
cbor_value_advance(&value);
|
|
}
|
|
return true;
|
|
} catch (const JFJochException &e) {
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Error processing start message, key " + key + ":" + e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CBORStream2Deserializer::ProcessEndMessageElement(CborValue &value) {
|
|
if (cbor_value_at_end(&value))
|
|
return false;
|
|
else {
|
|
auto key = GetCBORString(value);
|
|
try {
|
|
if (key == "end_date")
|
|
end_message.end_date = GetCBORString(value);
|
|
else if (key == "series_unique_id")
|
|
end_message.series_unique_id = GetCBORString(value);
|
|
else if (key == "series_id")
|
|
end_message.series_id = GetCBORUInt(value);
|
|
else if (key == "max_image_number")
|
|
end_message.max_image_number = GetCBORUInt(value);
|
|
else if (key == "images_collected")
|
|
end_message.images_collected_count = GetCBORUInt(value);
|
|
else if (key == "images_sent_to_write")
|
|
end_message.images_sent_to_write_count = GetCBORUInt(value);
|
|
else if (key == "max_receiver_delay")
|
|
end_message.max_receiver_delay = GetCBORUInt(value);
|
|
else if (key == "data_collection_efficiency")
|
|
end_message.efficiency = GetCBORFloat(value);
|
|
else if (key == "write_master_file")
|
|
end_message.write_master_file = GetCBORBool(value);
|
|
else if (key == "az_int_result")
|
|
ProcessRadIntResultElement(value);
|
|
else if (key == "adu_histogram")
|
|
ProcessADUHistogramElement(value);
|
|
else if (key == "adu_histogram_bin_width")
|
|
end_message.adu_histogram_bin_width = GetCBORUInt(value);
|
|
else
|
|
cbor_value_advance(&value);
|
|
return true;
|
|
} catch (const JFJochException &e) {
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Error processing end message, key " + key + ":" + e.what());
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBORStream2Deserializer::ProcessImageData(CborValue &value) {
|
|
if (!cbor_value_is_map(&value))
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "Map expected");
|
|
|
|
if (GetCBORMapLen(value) != 1)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError,
|
|
"Single channel images only supported at the moment");
|
|
|
|
CborValue map_value;
|
|
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
|
|
data_message.image.channel = GetCBORString(map_value);
|
|
GetCBORMultidimTypedArray(data_message.image, map_value);
|
|
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
}
|
|
|
|
void CBORStream2Deserializer::Process(const std::vector<uint8_t> &buffer) {
|
|
Process(buffer.data(), buffer.size());
|
|
}
|
|
|
|
void CBORStream2Deserializer::Process(const uint8_t *msg, size_t msg_size) {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
data_message = DataMessage();
|
|
|
|
CborParser parser;
|
|
CborValue value;
|
|
|
|
try {
|
|
cborErr(cbor_parser_init(msg, msg_size, 0, &parser, &value));
|
|
|
|
if (GetCBORTag(value) != CborSignatureTag)
|
|
throw JFJochException(JFJochExceptionCategory::CBORError, "CBOR must start with dedicated tag");
|
|
|
|
|
|
if (cbor_value_is_map(&value)) {
|
|
CborValue map_value;
|
|
cborErr(cbor_value_enter_container(&value, &map_value));
|
|
|
|
DecodeType(map_value);
|
|
switch (msg_type) {
|
|
case Type::IMAGE:
|
|
while (ProcessImageMessageElement(map_value));
|
|
break;
|
|
case Type::START:
|
|
start_message = StartMessage{
|
|
.data_file_count = 1
|
|
};
|
|
while (ProcessStartMessageElement(map_value));
|
|
break;
|
|
case Type::END:
|
|
end_message = EndMessage{};
|
|
while (ProcessEndMessageElement(map_value));
|
|
break;
|
|
case Type::NONE:
|
|
break;
|
|
}
|
|
|
|
cborErr(cbor_value_leave_container(&value, &map_value));
|
|
} else
|
|
throw JFJochException(JFJochExceptionCategory::CBORError,
|
|
"Serialized frame must be map in top level");
|
|
} catch (...) {
|
|
msg_type = Type::NONE;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
DataMessage CBORStream2Deserializer::GetDataMessage() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return data_message;
|
|
}
|
|
|
|
CBORStream2Deserializer::Type CBORStream2Deserializer::GetType() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return msg_type;
|
|
}
|
|
|
|
EndMessage CBORStream2Deserializer::GetEndMessage() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return end_message;
|
|
}
|
|
|
|
StartMessage CBORStream2Deserializer::GetStartMessage() const {
|
|
std::unique_lock<std::mutex> ul(m);
|
|
return start_message;
|
|
} |