Fichiers
moteur-terrain/signature/src/spectre.rs
T

190 lignes
6.5 KiB
Rust

//! Spectre de puissance radial (FFT 2D radix-2, fenêtre de Hann) : octaves et exposant de Hurst.
use crate::Raster;
fn fft(re: &mut [f64], im: &mut [f64]) {
let n = re.len();
let mut j = 0;
for i in 1..n {
let mut bit = n >> 1;
while j & bit != 0 {
j ^= bit;
bit >>= 1;
}
j ^= bit;
if i < j {
re.swap(i, j);
im.swap(i, j);
}
}
let mut len = 2;
while len <= n {
let ang = -2.0 * std::f64::consts::PI / len as f64;
let (wr, wi) = (ang.cos(), ang.sin());
for s in (0..n).step_by(len) {
let (mut cr, mut ci) = (1.0, 0.0);
for k in 0..len / 2 {
let (a, b) = (s + k, s + k + len / 2);
let (tr, ti) = (re[b] * cr - im[b] * ci, re[b] * ci + im[b] * cr);
re[b] = re[a] - tr;
im[b] = im[a] - ti;
re[a] += tr;
im[a] += ti;
let nr = cr * wr - ci * wi;
ci = cr * wi + ci * wr;
cr = nr;
}
}
len <<= 1;
}
}
/// Puissance moyenne par anneau entier r=1..N/2 (cycles par fenêtre) ; `n` = côté (puissance de 2), `pas` en m.
#[allow(clippy::needless_range_loop)]
pub fn anneaux(g: &Raster, nmax: usize) -> (usize, Vec<f64>) {
let mut n = 1;
while n * 2 <= g.w.min(g.h).min(nmax) {
n *= 2;
}
let (x0, y0) = ((g.w - n) / 2, (g.h - n) / 2);
// retrait du plan moyen (régression)
let nn = (n * n) as f64;
let (mut sz, mut sx, mut sy) = (0.0, 0.0, 0.0);
let c = (n as f64 - 1.0) / 2.0;
for y in 0..n {
for x in 0..n {
let z = g.at(x0 + x, y0 + y) as f64;
sz += z;
sx += z * (x as f64 - c);
sy += z * (y as f64 - c);
}
}
let var = (n as f64 * n as f64 - 1.0) / 12.0 * nn;
let (mz, ax, ay) = (sz / nn, sx / var, sy / var);
let mut re = vec![0.0; n * n];
let mut im = vec![0.0; n * n];
let hann = |i: usize| 0.5 - 0.5 * (2.0 * std::f64::consts::PI * (i as f64 + 0.5) / n as f64).cos();
for y in 0..n {
for x in 0..n {
let z = g.at(x0 + x, y0 + y) as f64 - mz - ax * (x as f64 - c) - ay * (y as f64 - c);
re[y * n + x] = z * hann(x) * hann(y);
}
}
for y in 0..n {
fft(&mut re[y * n..(y + 1) * n], &mut im[y * n..(y + 1) * n]);
}
let (mut cr, mut ci) = (vec![0.0; n], vec![0.0; n]);
for x in 0..n {
for y in 0..n {
cr[y] = re[y * n + x];
ci[y] = im[y * n + x];
}
fft(&mut cr, &mut ci);
for y in 0..n {
re[y * n + x] = cr[y];
im[y * n + x] = ci[y];
}
}
let half = n / 2;
let (mut sum, mut cnt) = (vec![0.0; half + 1], vec![0u32; half + 1]);
for ky in 0..n {
for kx in 0..n {
let fx = if kx > half { kx as f64 - n as f64 } else { kx as f64 };
let fy = if ky > half { ky as f64 - n as f64 } else { ky as f64 };
let r = (fx * fx + fy * fy).sqrt().round() as usize;
if r >= 1 && r <= half {
sum[r] += re[ky * n + kx].powi(2) + im[ky * n + kx].powi(2);
cnt[r] += 1;
}
}
}
(n, (0..=half).map(|r| if cnt[r] > 0 { sum[r] / cnt[r] as f64 } else { 0.0 }).collect())
}
/// (spectre[12] en log10 de puissance par octave de longueur d'onde, hurst).
/// Octave k : longueurs d'onde de 2·2^k à 2·2^(k+1) m (k=0 : 2-4 m ... k=11 : 4096-8192 m). 0.0 si hors de portée.
#[allow(clippy::needless_range_loop)]
pub fn spectre_et_hurst(g: &Raster) -> ([f32; 12], f32) {
let (n, p) = anneaux(g, 2048);
let mut out = [0.0f32; 12];
if n < 8 {
return (out, 0.0);
}
let l = n as f64 * g.pas_m as f64; // côté physique
for (k, o) in out.iter_mut().enumerate() {
let (lmin, lmax) = (2.0 * 2f64.powi(k as i32), 4.0 * 2f64.powi(k as i32));
let (mut s, mut c) = (0.0, 0);
for r in 1..p.len() {
let lam = l / r as f64;
if lam >= lmin && lam < lmax && p[r] > 0.0 {
s += p[r];
c += 1;
}
}
if c > 0 {
*o = (s / c as f64).log10() as f32;
}
}
// Hurst : P(k) ∝ k^-(2H+2) ; régression log-log sur les anneaux 2..N/4, en pondérant de façon égale par octave.
let (mut xs, mut ys) = (vec![], vec![]);
for r in 2..=(n / 4).max(3).min(p.len() - 1) {
if p[r] > 0.0 {
xs.push((r as f64).log10());
ys.push(p[r].log10());
}
}
if xs.len() < 3 {
return (out, 0.0);
}
let m = xs.len() as f64;
let (mx, my) = (xs.iter().sum::<f64>() / m, ys.iter().sum::<f64>() / m);
let slope = xs.iter().zip(&ys).map(|(x, y)| (x - mx) * (y - my)).sum::<f64>() / xs.iter().map(|x| (x - mx).powi(2)).sum::<f64>();
let h = ((-slope - 2.0) / 2.0).clamp(0.0, 1.0);
(out, h as f32)
}
/// Synthèse spectrale d'un fBm de Hurst `h` (côté `n` puissance de 2), utile aux tests et au calage.
pub fn fbm_spectral(n: usize, pas_m: f32, h: f64, seed: u64) -> Raster {
let mut s = seed.wrapping_mul(0x9E3779B97F4A7C15) | 1;
let mut rnd = || {
s ^= s << 13;
s ^= s >> 7;
s ^= s << 17;
(s >> 11) as f64 / (1u64 << 53) as f64
};
let (mut re, mut im) = (vec![0.0; n * n], vec![0.0; n * n]);
for ky in 0..n {
for kx in 0..n {
let fx = if kx > n / 2 { kx as f64 - n as f64 } else { kx as f64 };
let fy = if ky > n / 2 { ky as f64 - n as f64 } else { ky as f64 };
let k = (fx * fx + fy * fy).sqrt();
if k == 0.0 {
continue;
}
let amp = k.powf(-(h + 1.0));
let ph = 2.0 * std::f64::consts::PI * rnd();
re[ky * n + kx] = amp * ph.cos();
im[ky * n + kx] = amp * ph.sin();
}
}
// FFT inverse via conjugaison ; on garde la partie réelle (équivaut à symétriser).
for v in im.iter_mut() {
*v = -*v;
}
for y in 0..n {
fft(&mut re[y * n..(y + 1) * n], &mut im[y * n..(y + 1) * n]);
}
let (mut cr, mut ci) = (vec![0.0; n], vec![0.0; n]);
for x in 0..n {
for y in 0..n {
cr[y] = re[y * n + x];
ci[y] = im[y * n + x];
}
fft(&mut cr, &mut ci);
for y in 0..n {
re[y * n + x] = cr[y];
}
}
let mx = re.iter().fold(0.0f64, |a, v| a.max(v.abs()));
Raster::new(n, n, pas_m, re.iter().map(|v| (v / mx * 500.0) as f32).collect())
}