v1.0.0-rc.153 (#63)

This is an UNSTABLE release. It includes many experimental features, as well as many AI generated fixes. We recommend using rc.152 for production use.

* jfjoch_broker: Add EXPERIMENTAL pixelrefine mode for image processing
* jfjoch_broker: Allow to load user mask from 8-bit and 16-bit TIFF files
* jfjoch_broker: Add ROI calculation in non-FPGA workflow
* jfjoch_broker: Fixes to TCP image pusher
* jfjoch_broker: Remove NUMA bindings
* jfjoch_broker: Improvements to indexing
* jfjoch_broker: For PSI EIGER, trimming energies are taken from the detector configuration (now compulsory) instead of hardcoded values
* jfjoch_writer: Save ROI definitions and the per-pixel ROI bitmap in the master file; azimuthal ROIs support phi (angular) sectors
* jfjoch_viewer: Major redesign with dockable panels and saved layouts, plus on-canvas creation/move/resize of box, circle and azimuthal ROIs
* jfjoch_viewer: Run jfjoch_process reprocessing jobs from inside the GUI and overlay per-run results

Reviewed-on: #63

frame_serialize/CBORStream2Serializer.cpp

@@ -446,6 +446,23 @@ inline void CBOR_ENC_AZINT_MAP(CborEncoder &encoder, const StartMessage &msg) {
     CBOR_ENC_2D_TYPED_ARRAY(encoder, image);
 }
 
+inline void CBOR_ENC_ROI_MAP(CborEncoder &encoder, const StartMessage &msg) {
+    if (msg.roi_map.empty())
+        return;
+
+    if (msg.roi_map.size() != msg.image_size_x * msg.image_size_y)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Mismatch in size of ROI map");
+
+    JFJochBitShuffleCompressor compressor(CompressionAlgorithm::BSHUF_LZ4);
+    auto mask_compressed = compressor.Compress(msg.roi_map);
+    CompressedImage image(mask_compressed.data(), mask_compressed.size(),
+                          msg.image_size_x, msg.image_size_y,
+                          CompressedImageMode::Uint16,
+                          CompressionAlgorithm::BSHUF_LZ4, "roi_map");
+    CBOR_ENC_2D_TYPED_ARRAY(encoder, image);
+}
+
 inline void CBOR_ENC(CborEncoder &encoder, const char* key, const UnitCell &val) {
     CborEncoder mapEncoder;
 
@@ -504,6 +521,11 @@ inline nlohmann::json CBOR_ENC_ROI_CONFIG(const std::vector<ROIConfig> &roi) {
                 jr["type"] = "azim";
                 jr["qmin"] = r.azim.qmin;
                 jr["qmax"] = r.azim.qmax;
+                // phi_min == phi_max means a full ring; only emit a sector.
+                if (r.azim.phi_min != r.azim.phi_max) {
+                    jr["phi_min"] = r.azim.phi_min;
+                    jr["phi_max"] = r.azim.phi_max;
+                }
                 break;
         }
         j.push_back(jr);
@@ -632,6 +654,7 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message)
 
     CBOR_ENC(mapEncoder, "incident_energy", message.incident_energy);
     CBOR_ENC(mapEncoder, "incident_wavelength", message.incident_wavelength);
+    CBOR_ENC(mapEncoder, "incident_wavelength_spread", message.incident_wavelength_spread);
 
     CBOR_ENC(mapEncoder, "frame_time", message.frame_time);
     CBOR_ENC(mapEncoder, "count_time", message.count_time);
@@ -661,6 +684,7 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message)
 
     CBOR_ENC_PIXEL_MASK(mapEncoder, message);
     CBOR_ENC_AZINT_MAP(mapEncoder, message);
+    CBOR_ENC_ROI_MAP(mapEncoder, message);
 
     CBOR_ENC(mapEncoder, "channels", message.channels);
     CBOR_ENC(mapEncoder, "max_spot_count", message.max_spot_count);
@@ -916,12 +940,13 @@ void CBORStream2Serializer::AppendImage(size_t image_size) {
 
     buffer[curr_size - 2] = 0x40 + 27;
     curr_size--;
-#ifdef LITTLE_ENDIAN
-    size_t image_size_be = __builtin_bswap64(image_size);
-#else
-    size_t image_size_be = image_size;
-#endif
-    memcpy(buffer + curr_size, &image_size_be, sizeof(size_t));
+    // CBOR encodes the byte-string length as a big-endian 64-bit integer (major
+    // type 2, additional info 27). Write it big-endian byte-by-byte so the result
+    // is correct on any host endianness and needs no compiler-specific byte-swap
+    // intrinsic (__builtin_bswap64 is GCC/Clang-only; MSVC lacks it).
+    const uint64_t image_size_be = image_size;
+    for (size_t k = 0; k < sizeof(uint64_t); ++k)
+        buffer[curr_size + k] = static_cast<uint8_t>(image_size_be >> (8 * (sizeof(uint64_t) - 1 - k)));
     curr_size += sizeof(size_t);
     curr_size += image_size + 0;
     buffer[curr_size] = 0xFF;