Struct nnnoiseless::DenoiseSignal

pub struct DenoiseSignal<'model, S: Signal> { /* private fields */ }

Applies denoising to a Signal (from the dasp crate).

Instantiate one of these with a Signal as input, and you’ll get a Signal that yields denoised audio. Note that the denoised Signal will be in floating-point, even if the original signal wasn’t.

Example

use nnnoiseless::dasp::signal::{self, Signal};
use nnnoiseless::dasp::sample::Sample;
use nnnoiseless::DenoiseSignal;

let noise = signal::noise(0);
let mut denoised = DenoiseSignal::new(noise);
for n in denoised.take(10_000) {
// ... do something with your denoised noise.
}

Implementations

impl<'model, S: Signal> DenoiseSignal<'model, S>

pub fn new(input: S) -> DenoiseSignal<'static, S>

Creates a new DenoiseSignal using the built-in default noise model.

pub fn with_model(input: S, model: &'model RnnModel) -> DenoiseSignal<'model, S>

Creates a new DenoiseSignal using a custom noise model.

The main difference between this method and DenoiseSignal::from_model is that here DenoiseSignal will borrow the model and reuse it for the different channels in the signal.

pub fn from_model(input: S, model: RnnModel) -> DenoiseSignal<'static, S>

Creates a new DenoiseSignal owning a custom noise model.

The main difference between this method and DenoiseSignal::with_model is that here DenoiseSignal will take ownership of the model and make a clone for each channel in the signal. If the model is cheap to clone (for example, because it was created with RnnModel::from_static_bytes then this is fine.

Trait Implementations

impl<'model, S: Clone + Signal> Clone for DenoiseSignal<'model, S>

fn clone(&self) -> DenoiseSignal<'model, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'model, S: Signal> Signal for DenoiseSignal<'model, S>

type Frame = <<S as Signal>::Frame as Frame>::Float

The Frame type returned by the Signal.

fn is_exhausted(&self) -> bool

Whether or not the signal is exhausted of meaningful frames.

fn next(&mut self) -> Self::Frame

Yield the next Frame in the Signal.

fn map<M, F>(self, map: M) -> Map<Self, M, F>where
    Self: Sized,
    M: FnMut(Self::Frame) -> F,
    F: Frame,

A signal that maps one set of frames to another.

fn zip_map<O, M, F>(self, other: O, map: M) -> ZipMap<Self, O, M, F>where
    Self: Sized,
    M: FnMut(Self::Frame, <O as Signal>::Frame) -> F,
    O: Signal,
    F: Frame,

A signal that maps one set of frames to another.

fn add_amp<S>(self, other: S) -> AddAmp<Self, S>where
    Self: Sized,
    S: Signal,
    <S as Signal>::Frame: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Signed, NumChannels = <Self::Frame as Frame>::NumChannels>,

Provides an iterator that yields the sum of the frames yielded by both other and self in lock-step.

fn mul_amp<S>(self, other: S) -> MulAmp<Self, S>where
    Self: Sized,
    S: Signal,
    <S as Signal>::Frame: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Float, NumChannels = <Self::Frame as Frame>::NumChannels>,

Provides an iterator that yields the product of the frames yielded by both other and self in lock-step.

fn offset_amp(
    self,
    offset: <<Self::Frame as Frame>::Sample as Sample>::Signed
) -> OffsetAmp<Self>where
    Self: Sized,

Provides an iterator that offsets the amplitude of every channel in each frame of the signal by some sample value and yields the resulting frames.

fn scale_amp(
    self,
    amp: <<Self::Frame as Frame>::Sample as Sample>::Float
) -> ScaleAmp<Self>where
    Self: Sized,

Produces an Iterator that scales the amplitude of the sample of each channel in every Frame yielded by self by the given amplitude.

fn offset_amp_per_channel<F>(self, amp_frame: F) -> OffsetAmpPerChannel<Self, F>where
    Self: Sized,
    F: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Signed, NumChannels = <Self::Frame as Frame>::NumChannels>,

Produces a new Signal that offsets the amplitude of every Frame in self by the respective amplitudes in each channel of the given amp_frame.

fn scale_amp_per_channel<F>(self, amp_frame: F) -> ScaleAmpPerChannel<Self, F>where
    Self: Sized,
    F: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Float, NumChannels = <Self::Frame as Frame>::NumChannels>,

Produces a new Signal that scales the amplitude of every Frame in self by the respective amplitudes in each channel of the given amp_frame.

fn mul_hz<M, I>(self, interpolator: I, mul_per_frame: M) -> MulHz<Self, M, I>where
    Self: Sized,
    M: Signal<Frame = f64>,
    I: Interpolator,

Multiplies the rate at which frames of self are yielded by the given signal.

fn from_hz_to_hz<I>(
    self,
    interpolator: I,
    source_hz: f64,
    target_hz: f64
) -> Converter<Self, I>where
    Self: Sized,
    I: Interpolator,

Converts the rate at which frames of the Signal are yielded using interpolation.

fn scale_hz<I>(self, interpolator: I, multi: f64) -> Converter<Self, I>where
    Self: Sized,
    I: Interpolator,

Multiplies the rate at which frames of the Signal are yielded by the given value.

fn delay(self, n_frames: usize) -> Delay<Self>where
    Self: Sized,

Delays the Signal by the given number of frames.

fn into_interleaved_samples(self) -> IntoInterleavedSamples<Self>where
    Self: Sized,

Converts a Signal into a type that yields the interleaved Samples.

fn clip_amp(
    self,
    thresh: <<Self::Frame as Frame>::Sample as Sample>::Signed
) -> ClipAmp<Self>where
    Self: Sized,

Clips the amplitude of each channel in each Frame yielded by self to the given threshold amplitude.

fn inspect<F>(self, inspect: F) -> Inspect<Self, F>where
    Self: Sized,
    F: FnMut(&Self::Frame),

Create a new Signal that calls the enclosing function on each iteration.

fn fork<S>(self, ring_buffer: Bounded<S>) -> Fork<Self, S>where
    Self: Sized,
    S: SliceMut<Element = Self::Frame>,

Forks Self into two signals that produce the same frames.

fn take(self, n: usize) -> Take<Self>where
    Self: Sized,

Converts the Signal into an Iterator that will yield the given number for Frames before returning None.

fn until_exhausted(self) -> UntilExhausted<Self>where
    Self: Sized,

Converts the Signal into an Iterator yielding frames until the signal.is_exhausted() returns true.

fn buffered<S>(self, ring_buffer: Bounded<S>) -> Buffered<Self, S>where
    Self: Sized,
    S: Slice<Element = Self::Frame> + SliceMut,

Buffers the signal using the given ring buffer.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Borrows a Signal rather than consuming it.