fn align_phase_correlation(
y1: &[f32], y2: &[f32],
max_shift: usize, confidence_threshold: f32,
) -> (i64, f32) {
let fft_len = y1.len().min(y2.len()).next_power_of_two();
let mut planner = FftPlanner::<f32>::new();
let fft = planner.plan_fft_forward(fft_len);
let ifft = planner.plan_fft_inverse(fft_len);
fft.process(&mut a);
fft.process(&mut b);
for i in 0..fft_len {
let cps = a[i] * b[i].conj();
a[i] = cps / (cps.norm() + EPSILON);
}
ifft.process(&mut a);
let mut lag = if peak_idx <= fft_len / 2 {
peak_idx as i64
} else {
peak_idx as i64 - fft_len as i64
};
if peak_val < confidence_threshold || lag.unsigned_abs() as usize > max_shift {
lag = 0;
}
(lag, peak_val)
} pub fn calculate_psf_mask(
stft1: &ComplexSpec2D, stft2: &ComplexSpec2D, psf_power: f32,
) -> (Spec2D, Spec2D) {
let mut m1 = Spec2D::full(stft1.bins, stft1.frames, 0.5);
let mut m2 = Spec2D::full(stft1.bins, stft1.frames, 0.5);
let p = psf_power.clamp(1.0, 4.0);
for i in 0..stft1.data.len() {
let mix = stft1.data[i] + stft2.data[i];
let den = mix.norm_sqr() + EPSILON;
let a1 = ((stft1.data[i] * mix.conj()).re / den).max(0.0).powf(p);
let a2 = ((stft2.data[i] * mix.conj()).re / den).max(0.0).powf(p);
let v1 = (a1 / (a1 + a2 + EPSILON)).clamp(0.0, 1.0);
m1.data[i] = v1;
m2.data[i] = 1.0 - v1;
}
(m1, m2)
} pub fn phase_reconstruction_explicit(
mag: &Spec2D, n_fft: usize, hop_length: usize,
sr: u32, params: &ProcessingParams,
) -> Spec2D {
let sigma_sec = params.explicit_relation_window_len as f32 / (6.0 * sr as f32);
let sigma_sq = sigma_sec * sigma_sec;
for b in 0..bins {
let omega = 2.0 * PI * freqs[b];
for t in 0..frames {
dphi_dt.set(b, t, omega + dlog_dw.get(b, t) / (2.0 * PI * sigma_sq + EPSILON));
dphi_dw.set(b, t, -sigma_sq * dlog_dt.get(b, t) - t_half);
}
}
for b in 0..bins {
for t in 0..frames {
let lap = if b == 0 && t == 0 { EPSILON } else { -(kx * kx + ky * ky) };
div[b * frames + t] /= lap;
}
}
solve_2d_ifft(&mut div, bins, frames)
} fn decompose_emd_1d(
signal: &[f32], max_imfs: usize, method: EmdMethod,
) -> Vec<Vec<f32>> {
let ensembles = match method {
EmdMethod::Emd => 1,
EmdMethod::Eemd | EmdMethod::Ceemdan => 4,
};
let ensemble_imfs: Vec<_> = (0..ensembles)
.into_par_iter()
.map(|e| {
let mut residual = add_ensemble_noise(signal, e, noise_amp);
(0..k_imfs).map(|_| {
let imf = sift_single_imf(&residual, 5);
subtract_in_place(&mut residual, &imf);
imf
}).collect::<Vec<_>>()
})
.collect();
average_ensembles(ensemble_imfs, signal.len(), k_imfs)
}