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

Fixes after MAX IV experiment

Browse Source
This commit is contained in:
leonarski_f
2024-02-05 17:18:16 +01:00
parent 91a0960303
commit babb1a5c8d
151 changed files with 4395 additions and 1477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
image_analysis/StrongPixelSet.cpp
View File

@@ -2,27 +2,63 @@
#include "StrongPixelSet.h"
struct intensity_id {
int64_t I;
uint32_t id;
};
struct res_id {
float res;
uint32_t id;
};
void FilterSpotsByCount(const DiffractionExperiment& experiment,
const std::vector<DiffractionSpot> &input,
std::vector<DiffractionSpot> &output) {
if (input.size() < experiment.GetMaxSpotCount())
output = input;
size_t output_size = std::min<size_t>(input.size(), experiment.GetMaxSpotCount());
std::vector<intensity_id> intensity_id_vector(input.size());
for (int i = 0; i < input.size(); i++) {
intensity_id_vector[i].I = input[i].Count();
intensity_id_vector[i].id = i;
}
std::partial_sort(intensity_id_vector.begin(), intensity_id_vector.begin() + output_size, intensity_id_vector.end(),
[](const intensity_id& a,const intensity_id& b ) { return a.I > b.I;});
output.reserve(output_size);
for (int i = 0; i < output_size; i++)
output.push_back(input[intensity_id_vector[i].id]);
}
void FilterSpotsByResolution(const DiffractionExperiment& experiment,
const std::vector<DiffractionSpot> &input,
std::vector<DiffractionSpot> &output) {
std::multimap<double, DiffractionSpot> spots_map;
if (input.size() < experiment.GetMaxSpotCount())
output = input;
for (const auto &i: input) {
double d = i.GetResolution(experiment);
spots_map.insert(std::make_pair(-static_cast<float>(d), i));
size_t output_size = std::min<size_t>(input.size(), experiment.GetMaxSpotCount());
std::vector<res_id> res_id_vector(input.size());
for (int i = 0; i < input.size(); i++) {
res_id_vector[i].res = input[i].GetResolution(experiment);
res_id_vector[i].id = i;
}
std::partial_sort(res_id_vector.begin(), res_id_vector.begin() + output_size, res_id_vector.end(),
[](const res_id& a,const res_id& b ) { return a.res > b.res;});
for (auto &[x, spot]: spots_map)
output.push_back(spot);
if (experiment.GetMaxSpotCount() > 0)
output.resize(std::min<size_t>(output.size(), experiment.GetMaxSpotCount()));
output.reserve(output_size);
for (int i = 0; i < output_size; i++)
output.push_back(input[res_id_vector[i].id]);
}
StrongPixelSet::StrongPixelSet(const DiffractionExperiment &experiment)
: xpixel(experiment.GetXPixelsNum()),
ypixel(experiment.GetYPixelsNum()),
strong_pixel_vector(experiment.GetPixelsNum(), false),
StrongPixelSet::StrongPixelSet()
: strong_pixel_vector(RAW_MODULE_SIZE, false),
strong_pixel_count(0) {
}
@@ -32,6 +68,12 @@ void StrongPixelSet::AddStrongPixel(uint16_t col, uint16_t line, int32_t photons
strong_pixel_vector.at(line * xpixel + col) = true;
}
void StrongPixelSet::AddSingleStrongPixel(uint16_t col, uint16_t line, int32_t photons) {
auto key = strong_pixel_coord(col, line);
auto p = std::pair<uint32_t, int32_t>(key, photons);
single_pixels.emplace_back(p);
}
inline void StrongPixelSet::AddNeighbor(DiffractionSpot &spot, uint16_t col, uint16_t line) {
if (strong_pixel_vector[line * xpixel + col]) {
uint64_t coord = strong_pixel_coord(col, line);
@@ -107,17 +149,23 @@ void StrongPixelSet::ExtendSpot(DiffractionSpot &spot, std::unordered_map<uint32
void StrongPixelSet::FindSpots(const DiffractionExperiment &experiment, const SpotFindingSettings &settings,
std::vector<DiffractionSpot> &spots, uint16_t module_number) {
if (settings.min_pix_per_spot == 1) {
for (const auto &i: single_pixels) {
uint16_t col = col_from_strong_pixel(i.first);
uint16_t line = line_from_strong_pixel(i.first);
DiffractionSpot spot(col, line, i.second);
spots.emplace_back(spot);
}
}
while (!strong_pixel_map.empty()) {
auto iter = strong_pixel_map.begin();
DiffractionSpot spot = BuildSpot(iter);
spot.ConvertToImageCoordinates(experiment, module_number);
double d = spot.GetResolution(experiment);
if ((spot.PixelCount() <= settings.max_pix_per_spot)
&& (spot.PixelCount() >= settings.min_pix_per_spot)
&& ((settings.low_resolution_limit <= 0) || (d <= settings.low_resolution_limit))
&& ((settings.high_resolution_limit <= 0) || (d >= settings.high_resolution_limit)))
&& (spot.PixelCount() >= settings.min_pix_per_spot))
spots.push_back(spot);
}
}
@@ -138,24 +186,16 @@ size_t StrongPixelSet::Common(const StrongPixelSet &set) const {
void StrongPixelSet::ReadFPGAOutput(const DeviceOutput &output) {
strong_pixel_count += output.spot_finding_result.strong_pixel_count;
// Too many strong pixels will kill performance in data processing, so protection is needed
// Also if there are no strong pixels, there is no point in looking for them
if ((output.spot_finding_result.strong_pixel_count == 0) ||
(output.spot_finding_result.strong_pixel_count > max_strong_pixels_fpga))
return;
auto out_ptr = (uint32_t *) output.spot_finding_result.strong_pixel;
for (int line = 0; line < RAW_MODULE_LINES; line++) {
auto line_ptr = out_ptr + line * RAW_MODULE_COLS / (8 * sizeof(out_ptr[0]));
for (int i = 0; i < RAW_MODULE_COLS / (8 * sizeof(line_ptr[0])); i++) {
if (line_ptr[i]) {
for (int j = 0; j < 8 * sizeof(line_ptr[0]); j++) {
if (line_ptr[i] & (1 << j)) {
size_t npixel = i * 8 * sizeof(line_ptr[0]) | j;
AddStrongPixel(npixel, line, output.pixels[line * RAW_MODULE_COLS + i * sizeof(line_ptr[0]) + j]);
}
}
}
for (int i = 0; i < std::min<uint32_t>(output.spot_finding_result.max_memory_index * 32,
SPOT_FINDER_MAX_STRONG_PIXEL); i++) {
uint32_t val = output.spot_finding_result.strong_pixel_number[i];
if (val != UINT32_MAX) {
uint32_t pixel = (val & ((1LU << 20) - 1));
uint8_t conn = ((val >> 24) & UINT8_MAX);
if (conn == 0)
AddSingleStrongPixel(pixel % RAW_MODULE_COLS, pixel / RAW_MODULE_COLS, output.pixels[pixel]);
else
AddStrongPixel(pixel % RAW_MODULE_COLS, pixel / RAW_MODULE_COLS, output.pixels[pixel]);
}
}
}