Pattern

Pattern は, 各振動子の位相と振幅をデバイスへ送るコマンド. 位相と振幅は別々のバッファで渡す.

API

Rust

Pattern::new(&phases, intensities);

Pattern::with_bank(bank, &phases, intensities);

Pattern {
    bank,
    phases: &phases,
    intensities: intensities.into(),
    transition_mode,
};

Pattern::new は書き込み先バンクを PatternBank::B0 とする. 別バンクへ書く場合は Pattern::with_bank(bank, phases, intensities) を使う.

Python

Pattern(phases, intensities)

Pattern(phases, intensities, bank=bank)

Pattern(
    phases,
    intensities,
    bank=bank,
    transition_mode=transition_mode,
)

Pattern は書き込み先バンクをデフォルトで PatternBank.B0 とする. 別バンクへ書く場合は Pattern(phases, intensities, bank=bank) を使う.

C#

new Pattern(phases, intensities);

new Pattern(bank, phases, intensities);

new Pattern(
    bank: bank,
    phases: phases,
    intensities: intensities,
    transitionMode: transitionMode
);

new Pattern(phases, intensities) は書き込み先バンクを PatternBank.B0 とする. 別バンクへ書く場合は new Pattern(bank, phases, intensities) を使う.

フィールド	型	デフォルト	説明
bank	PatternBank	PatternBank::B0	書き込み先・再生対象のバンク
phases	&[Vec<Phase>]	—	デバイスごとの位相
intensities	PatternIntensity	—	振幅 (Intensity の一様値, または &[Vec<Intensity>] のデバイスごとのバッファ)
transition_mode	TransitionMode	TransitionMode::Immediate	バンク切替時の遷移挙動

patternの計算には幾つかのヘルパ関数が用意されている.

等価な低レベルコマンド

Pattern は WritePatternBuffer + ConfigPattern + ActivatePatternBank の 3 つと等価である. ただし Pattern 自体はこの 3 つを融合した 1 フレームで送られる. 以下は Pattern { bank, phases, intensities } と等価な組み合わせである.

バンクへ書き込むだけで切り替えない (後で ActivatePatternBank を送る) 場合は, Pattern ではなく WritePatternBuffer + ConfigPattern を直接送る.

Rust

WritePatternBuffer::new(bank, 0, patterns, intensities);
ConfigPattern {
    bank,
    config: SamplingConfig::new(NonZeroU16::MAX),
    size: 1,
    loop_behavior: LoopBehavior::Infinite,
};
ActivatePatternBank {
    bank,
    transition_mode,
};

Python

WritePatternBuffer(
    bank=bank,
    start_index=0,
    patterns=[phases],
    intensities=intensities,
)
ConfigPattern(
    bank=bank,
    config=SamplingConfig(0xFFFF),
    size=1,
    loop_behavior=LoopBehavior.Infinite,
)
ActivatePatternBank(
    bank=bank,
    transition_mode=transition_mode,
)

C#

new WritePatternBuffer(
    bank: bank,
    startIndex: 0,
    patterns: new[] { phases },
    intensities: intensities
);
new ConfigPattern(
    bank: bank,
    config: new SamplingConfig(ushort.MaxValue),
    size: 1,
    loopBehavior: LoopBehavior.Infinite
);
new ActivatePatternBank(
    bank: bank,
    transitionMode: transitionMode
);

Example

Rust

use autd3_rs::commands::{Clear, Pattern, Synchronize};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{m, mm, s};
use autd3_rs::value::Intensity;
use autd3_rs::Client;
use autd3_rs::udp::TransportOption;
use autd3_rs_pattern::{focus, wavelength};

let geometry = Geometry::new(vec![Autd3::default()]);
let option = TransportOption::default();
let mut client = Client::open(&geometry, &option).await?;
client.send(Clear).await?;
client.send(Synchronize).await?;

let mut phases = geometry.phase_buffer();
focus(
    &geometry,
    geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm),
    wavelength(340.0 * m / s),
    &mut phases,
);

client.send(Pattern::new(&phases, Intensity::MAX)).await?;

Python

import asyncio

from autd3 import Client, TransportOption
from autd3.commands import Clear, Pattern, Synchronize
from autd3.geometry import Autd3, Geometry, offset
from autd3.units import m, mm, s
from autd3.value import Intensity
from autd3_pattern import focus, wavelength


async def main() -> None:
    geometry = Geometry([Autd3()])
    with await Client.open(geometry, TransportOption()) as client:
        await client.send(Clear())
        await client.send(Synchronize())

        phases = geometry.phase_buffer()
        focus(
            geometry,
            geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm),
            wavelength(340 * m / s),
            phases,
        )

        await client.send(Pattern(phases, Intensity.MAX))


asyncio.run(main())

C#

using System.Threading.Tasks;
using AUTD3;
using static AUTD3.Units;

var geometry = new Geometry(new[] { new Autd3() });
using var client = await Client.OpenAsync(geometry, new TransportOption());
await client.SendAsync(new Clear());
await client.SendAsync(new Synchronize());

var phases = geometry.PhaseBuffer();
Pattern.Focus(
    geometry,
    geometry.Center + Offset(0.0f * mm, 0.0f * mm, 150.0f * mm),
    Pattern.Wavelength(340.0f * m / s),
    phases
);

await client.SendAsync(new Pattern(phases, Intensity.Max));