Files
leonarski_fandClaude Opus 5.5 01017c4bb7 FFTW removed: every CPU FFT is pocketfft's (common/CpuFFT)
FFTW is no longer fetched, built or linked - not even by jfjoch_test. The
JFJOCH_USE_FFTW define and its #ifdefs are gone: the CPU FFT indexer, the
viewer's FFT chart and the rest are always built. The test that checked
pocketfft against FFTW now checks it against a direct double-precision DFT
(forward) and a round trip (backward), on the same shapes.

The user-facing name stays: -X FFTW, the OpenAPI enum value, the CBOR and
HDF5 strings - the CPU FFT indexer is still called FFTW, only the
implementation changed; the CLI page says so. Under MSVC pocketfft is told
explicitly to run scalar (it already decides so itself: its vector code needs
the GCC/Clang vector extension).

Licences: licenses/fftw.txt, its COLLECT.sh line, the THIRD_PARTY_NOTICES row
and note, and the viewer's embedded copy removed; docs/THIRD_PARTY_NOTICES.md
regenerated with update_version.sh's own sed block. CLAUDE.md and the docs
that named FFTW as the library now name pocketfft.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
2026-11-16 06:11:40 +01:00

83 lines
5.0 KiB
C++

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include <cstdint>
#include <vector>
#include "BeamCenterFFT.h"
// The transform half of BeamCenterFFTScore, with a CPU (pocketfft) and a GPU (cuFFT) implementation
// chosen the way the FFT indexer's are. Everything that decides anything - the preparation of the
// image, the masked Pearson combination, the shortlist and the margins - is shared, so the two
// engines can differ only in how the four convolutions are computed. That is what makes them
// comparable: the parity test scores one image with each and compares the shortlists.
//
// The masked Pearson needs four convolutions of the prepared image `a` and its valid-pixel mask
// `m`: C = a (*) a, S = a (*) m, Q = a^2 (*) m and D = m (*) m.
// The 2D point-inversion score: each surface cropped to 2h x 2w, row-major.
struct BeamCenterConvSurfaces2D {
std::vector<float> C, S, Q, D;
};
class BeamCenterFFTEngine {
public:
virtual ~BeamCenterFFTEngine() = default;
// `a` and `m` are h x w row-major, as PrepareImage leaves them.
virtual BeamCenterConvSurfaces2D PointSurfaces(const std::vector<float> &a,
const std::vector<float> &m, int64_t h,
int64_t w) = 0;
// The 2D point score all the way to its shortlist. The default - and the whole of the CPU
// path - is PointSurfaces followed by BeamCenterPointScore and BeamCenterShortlist2D below.
// An engine whose surfaces are already somewhere else overrides it rather than moving them:
// on a 16 Mpixel detector the two host steps are 1.8 s and bringing the four surfaces back is
// another 0.9 s, against 26 ms of transform.
virtual std::vector<BeamCenterFFTCandidate>
PointShortlist(const std::vector<float> &a, const std::vector<float> &m, int64_t h, int64_t w,
const BeamCenterFFTSettings &settings, double global_variance);
};
// The masked Pearson r(t) = (D*C - S^2) / (D*Q - S^2) from the four convolution surfaces, combined
// elementwise in double: the numerator and denominator are cancellations of large near-equal terms,
// and the shortlist margins ride on differences of ~0.3 %. Centres whose mirror overlap holds fewer
// than `min_pair_fraction` of the largest pair count, and those whose overlap carries no variance
// (see BEAM_CENTER_VARIANCE_FLOOR), score -infinity.
//
// This is the reference implementation. An engine that computes the same thing where its surfaces
// already are is held to it element by element by the parity test.
[[nodiscard]] std::vector<float> BeamCenterPointScore(const BeamCenterConvSurfaces2D &conv,
float min_pair_fraction,
double global_variance);
// Greedy shortlist of a 2D score surface: strongest peak first, a square of half-width `nms_pxl`
// around each taken peak suppressed. Ties go to the lowest index, and a non-finite entry is never a
// peak. The surface is indexed by t = 2c, so the centre grid is half-pixel. Reference, as above.
// `surface` is consumed - the suppression is written into it.
[[nodiscard]] std::vector<BeamCenterFFTCandidate> BeamCenterShortlist2D(std::vector<float> &surface,
int64_t h, int64_t w,
float nms_pxl, int budget);
// The denominator D*Q - S^2 equals D^2 times the image variance over the mirror overlap, so an
// overlap with (nearly) no variance - a mirrored empty corner, everything clamped to zero by the
// preparation - carries no evidence and its r is pure roundoff (measured: such a region minted
// r = 4..274 on a synthetic image, in float64 as much as float32). This is the fraction of the
// whole image's variance an overlap must reach to be scored at all; on real detector images every
// overlap that passes the pair-count gate is orders of magnitude above it.
constexpr double BEAM_CENTER_VARIANCE_FLOOR = 1e-4;
// Smallest 2-3-5-7-smooth transform length >= n. Both engines pad to it, so both score the same
// grid. A smooth length is not a micro-optimisation here: the naive next-power-of-two pad of a
// 16 Mpixel detector costs 3x the time of the smooth one on both the CPU FFT and cuFFT, and 2.5 GB of
// cuFFT plan memory against a few hundred MB (measured).
[[nodiscard]] int64_t BeamCenterFFTPadSize(int64_t n);
// BeamCenterFFTScore with the engine named rather than chosen, for the GPU/CPU parity test.
[[nodiscard]] BeamCenterFFTResult BeamCenterFFTScore(int64_t width, int64_t height,
const std::vector<float> &mean,
const BeamCenterFFTSettings &settings,
BeamCenterFFTEngine &engine);