leonarski_fandClaude Opus 5.5
a277b8c458
Conflicts in the three CPU pixel loops the fused pipeline split per block, resolved by carrying this branch's loop bodies into the new functions with the per-pixel arithmetic unchanged: - AdaptiveSpotFinderCPU: the register-held ring sums now live in AccumulateRingsBlock (stored at the end of each block, so the additions stay in pixel order). - ImagePreprocessorCPU::AnalyzeBlock reads the PixelMask-derived 32-pixel mask words at first + i. - ImageSpotFinderCPU::DetectPass: rc173's new_row() marking/fill_row calls kept in place, the vertical update replaced by the vectorised slide with the prev_strong fix-up. Byte-identical p.hkl, p.mtz, p_P1.mtz, p_unmerged.mtz vs rc173 references on myob, cytc, lyso, sparse (CPU-only build) and myob (GPU build); targeted tests (ImageSpotFinderCPU*, AdaptiveSpotFinder, SpotFinding, PixelMask, Bragg*, RotationScale, AzimuthalIntegration, portable) pass. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01D1G8gJVAy6gp1K5Dz3NE5C
70 lines
3.4 KiB
C++
70 lines
3.4 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include "ImagePreprocessorCPU.h"
|
|
|
|
ImagePreprocessorCPU::ImagePreprocessorCPU(const DiffractionExperiment &experiment, const PixelMask &mask)
|
|
: ImagePreprocessor(experiment),
|
|
mask_bits(mask.GetPackedMask()) {}
|
|
|
|
ImageStatistics ImagePreprocessorCPU::Analyze(ImagePreprocessorBuffer &processed_image, const uint8_t *image_ptr, CompressedImageMode image_mode) {
|
|
if (processed_image.size() != npixels)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Processed image size mismatch");
|
|
|
|
ImageStatistics ret{};
|
|
AnalyzeBlock(processed_image, 0, image_ptr, npixels, image_mode, ret);
|
|
return ret;
|
|
}
|
|
|
|
void ImagePreprocessorCPU::AnalyzeBlock(ImagePreprocessorBuffer &processed_image, size_t first, const uint8_t *input,
|
|
size_t n, CompressedImageMode image_mode, ImageStatistics &stats) {
|
|
switch (image_mode) {
|
|
case CompressedImageMode::Int8:
|
|
return AnalyzeBlock<int8_t>(processed_image, first, input, n, INT8_MIN, INT8_MAX, stats);
|
|
case CompressedImageMode::Int16:
|
|
return AnalyzeBlock<int16_t>(processed_image, first, input, n, INT16_MIN, INT16_MAX, stats);
|
|
case CompressedImageMode::Int32:
|
|
return AnalyzeBlock<int32_t>(processed_image, first, input, n, INT32_MIN, INT32_MAX, stats);
|
|
case CompressedImageMode::Uint8:
|
|
return AnalyzeBlock<uint8_t>(processed_image, first, input, n, UINT8_MAX, UINT8_MAX, stats);
|
|
case CompressedImageMode::Uint16:
|
|
return AnalyzeBlock<uint16_t>(processed_image, first, input, n, UINT16_MAX, UINT16_MAX, stats);
|
|
case CompressedImageMode::Uint32:
|
|
return AnalyzeBlock<uint32_t>(processed_image, first, input, n, UINT32_MAX, UINT32_MAX, stats);
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "RGB/float mode not supported");
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
void ImagePreprocessorCPU::AnalyzeBlock(ImagePreprocessorBuffer &processed_image, size_t first, const uint8_t *input,
|
|
size_t n, T err_pixel_val, T sat_pixel_val, ImageStatistics &ret) {
|
|
auto image = reinterpret_cast<const T *>(input);
|
|
int32_t *out = processed_image.data() + first;
|
|
|
|
if (sat_pixel_val > saturation_limit)
|
|
sat_pixel_val = static_cast<T>(saturation_limit);
|
|
|
|
for (size_t i = 0; i < n; i++) {
|
|
if ((mask_bits[(first + i) / 32] >> ((first + i) % 32)) & 1U) {
|
|
out[i] = INT32_MIN;
|
|
++ret.masked_pixel_count;
|
|
} else if (image[i] == err_pixel_val) {
|
|
// Error/invalid marker = the pixel type's extreme value (0xFFFFFFFF for EIGER uint32).
|
|
// Tested before saturation, since for unsigned types the marker also exceeds sat_pixel_val
|
|
// (which is clipped above to the HDF5 saturation_value).
|
|
out[i] = INT32_MIN;
|
|
++ret.error_pixel_count;
|
|
} else if (image[i] >= sat_pixel_val) {
|
|
out[i] = INT32_MAX;
|
|
++ret.saturated_pixel_count;
|
|
} else {
|
|
out[i] = static_cast<int32_t>(image[i]);
|
|
if (image[i] > ret.max_value)
|
|
ret.max_value = image[i];
|
|
if (image[i] < ret.min_value)
|
|
ret.min_value = image[i];
|
|
}
|
|
}
|
|
}
|