leonarski_fandClaude Opus 4.8
9b209d335d
Add --soft-weight (implies --adaptive-spots): give every detected spot a
continuous quality weight in (0,1] and keep the highest-weight spots rather than
the brightest, so a deliberately loose detector self-cleans -- bright ice / salt
/ jet blobs and single-pixel noise no longer evict faint clean Bragg spots from
the max-spots cut.
The weight is a product of dimensionless gates (AdaptiveSpotFinderCPU::ApplyWeights,
computed against the per-ring background the adaptive finder already builds): a
logistic ramp in the spot's SNR and a soft size band (rises from one pixel,
plateaus, falls for oversized ice/salt/streak blobs). It carries on
DiffractionSpot -> SpotToSave and is consumed by FilterSpotsByCount, which ranks
by {non-ice, weight, intensity} when requested and by intensity otherwise, so the
classic and FPGA paths are unchanged.
Honest result: on the serial-stills battery this is index-rate-NEUTRAL. The
weighted ranking only changes the outcome when the spot count exceeds the
max-spots cap and the weight disagrees with intensity in a way that affects
indexing; the adaptive detectors already produce clean spot lists and the weak
sets sit under the cap, so re-ranking is a wash there (and a wash, not a
regression, on the one set that floods). Its intended benefit -- robustness to
ice/jet-contaminated frames and to a loosened detector -- is not exercised by
this battery; kept opt-in as the substrate for that.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
93 lines
2.8 KiB
C++
93 lines
2.8 KiB
C++
// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include "DiffractionSpot.h"
|
|
#include "DiffractionGeometry.h"
|
|
#include "RawToConvertedGeometry.h"
|
|
|
|
DiffractionSpot::DiffractionSpot(uint32_t col, uint32_t line, int64_t in_photons) {
|
|
if (in_photons < 0) in_photons = 0;
|
|
x = col * static_cast<float>(in_photons);
|
|
y = line * static_cast<float>(in_photons);
|
|
pixel_count = 1;
|
|
photons = in_photons;
|
|
max_photons = in_photons;
|
|
}
|
|
|
|
DiffractionSpot& DiffractionSpot::operator+=(const DiffractionSpot &other) {
|
|
this->x += other.x;
|
|
this->y += other.y;
|
|
this->photons += other.photons;
|
|
this->max_photons = std::max(this->max_photons, other.max_photons);
|
|
this->pixel_count += other.pixel_count;
|
|
return *this;
|
|
}
|
|
|
|
DiffractionSpot::DiffractionSpot(const SpotToSave &save) {
|
|
x = save.x * static_cast<float>(save.intensity);
|
|
y = save.y * static_cast<float>(save.intensity);
|
|
pixel_count = 1;
|
|
photons = std::lround(save.intensity);
|
|
max_photons = save.maxc;
|
|
}
|
|
|
|
int64_t DiffractionSpot::Count() const {
|
|
return photons;
|
|
}
|
|
|
|
int64_t DiffractionSpot::MaxCount() const {
|
|
return max_photons;
|
|
}
|
|
|
|
Coord DiffractionSpot::RawCoord() const {
|
|
if (photons == 0)
|
|
return {0, 0, 0};
|
|
return {x / (float)photons, y / (float)photons, 0};
|
|
}
|
|
|
|
int64_t DiffractionSpot::PixelCount() const {
|
|
return pixel_count;
|
|
}
|
|
|
|
void DiffractionSpot::AddPixel(uint32_t col, uint32_t line, int64_t photons) {
|
|
this->x += col * (float) photons;
|
|
this->y += line * (float) photons;
|
|
this->photons += photons;
|
|
this->max_photons = std::max(this->max_photons, photons);
|
|
this->pixel_count += 1;
|
|
}
|
|
|
|
void DiffractionSpot::ConvertToImageCoordinates(const DiffractionExperiment &experiment, uint16_t module_number) {
|
|
auto c_out = RawToConvertedCoordinate(experiment, module_number, RawCoord());
|
|
this->x = c_out.x * (float) photons;
|
|
this->y = c_out.y * (float) photons;
|
|
}
|
|
|
|
std::optional<SpotToSave> DiffractionSpot::Export(const DiffractionGeometry &geometry, int64_t image_num) const {
|
|
if (photons == 0)
|
|
return std::nullopt;
|
|
|
|
auto d = geometry.PxlToRes(x / (float) photons, y / (float) photons);
|
|
|
|
float phi = 0.0f;
|
|
if (geometry.GetRotation()) {
|
|
// Rotation angle is considered as increment + half wedge.
|
|
// It ignores the starting angle.
|
|
phi = geometry.GetRotation()->GetAngle_deg(image_num) + geometry.GetRotation()->GetWedge_deg() / 2.0f;
|
|
}
|
|
|
|
return SpotToSave{
|
|
.x = x / static_cast<float>(photons),
|
|
.y = y / static_cast<float>(photons),
|
|
.phi = phi,
|
|
.intensity = static_cast<float>(photons),
|
|
.maxc = max_photons,
|
|
.lattice = -1,
|
|
.image = image_num,
|
|
.d_A = d,
|
|
.weight = weight,
|
|
.ice_ring = false,
|
|
.indexed = false
|
|
};
|
|
}
|