Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
190 lignes
6.5 KiB
Rust
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())
|
|
}
|