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
83 lines
5.0 KiB
C++
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);
|