fourier

fourier generates an amplitude modulation synthesized from multiple sine-wave components. Each component is computed in the same way as sine, and they are summed into a single waveform.

API

Rust

fourier(&components, &option, &mut dst)?;

Python

fourier(components, option, dst)

C#

Modulation.Fourier(components, option, dst);

Parameter	Type	Description
components	&[SineComponent<S>]	array of sine-wave components to synthesize
option	&FourierOption	additional options (see below)
dst	&mut Vec<u8>	output buffer

Each SineComponent is a pair of a frequency freq and a SineOption. The sampling_config of all components must be identical, otherwise an error occurs. The length of the synthesized waveform is the least common multiple of the periods of the components.

Each sample is the sum of all components multiplied by a scale (scale_factor), plus an offset (offset).

SineComponent

Field	Type	Description
freq	Freq<u32> etc.	frequency of the component
option	SineOption	per-component sine Option

Rust

SineComponent {
    freq: 100 * Hz,
    option: SineOption::default(),
};

Python

SineComponent(
    100.0 * Hz,
    SineOption(),
)

C#

new SineComponent(
    100 * Hz,
    new SineOption()
);

FourierOption

Rust

FourierOption {
    scale_factor,
    clamp,
    offset,
}

Python

FourierOption(
    scale_factor,
    clamp,
    offset,
)

C#

new FourierOption(
    scaleFactor,
    clamp,
    offset
)

Field	Type	Default	Description
scale_factor	Option<f32>	None	scale applied to the synthesized value. If None, the reciprocal of the number of components
clamp	bool	false	whether to clamp out-of-range values to [0, 255]
offset	u8	0	DC offset added after synthesis

Example

Rust

use autd3_rs::units::Hz;
use autd3_rs_modulation::{FourierOption, SineComponent, SineOption, fourier};

let mut dst = Vec::new();

fourier(
    &[SineComponent {
        freq: 100 * Hz,
        option: SineOption::default(),
    }],
    &FourierOption {
        scale_factor: None,
        clamp: false,
        offset: 0x00,
    },
    &mut dst,
)?;

Python

from autd3.units import Hz
from autd3_modulation import (
    FourierOption,
    SineComponent,
    SineOption,
    fourier,
    modulation_buffer,
)

dst = modulation_buffer()

fourier(
    [
        SineComponent(
            freq=100 * Hz,
            option=SineOption(),
        )
    ],
    FourierOption(
        scale_factor=None,
        clamp=False,
        offset=0x00,
    ),
    dst,
)

C#

using AUTD3;
using static AUTD3.Units;

var dst = Modulation.ModulationBuffer();

Modulation.Fourier(
    new[]
    {
        new SineComponent(
            100 * Hz,
            new SineOption()
        ),
    },
    new FourierOption(
        scaleFactor: null,
        clamp: false,
        offset: 0x00
    ),
    dst
);