WritePatternCompressed

WritePatternCompressed is the compressed version of WritePatternBuffer. It is a low-level command that writes multiple Patterns into a single frame by sending only the phase information. The intensity is a single intensity value shared by every transducer and every Pattern.

API

Rust

WritePatternCompressed {
    bank,
    index,
    format,
    intensity,
    patterns,
};

Python

WritePatternCompressed(
    bank=bank,
    index=index,
    format=format,
    intensity=intensity,
    patterns=patterns,
)

C#

new WritePatternCompressed(
    bank: bank,
    index: index,
    format: format,
    intensity: intensity,
    patterns: patterns
);

Field	Type	Description
bank	PatternBank	Destination bank
index	usize	Start index for writing within the bank
format	PatternCompression	Compression format (see below)
intensity	Intensity	Intensity shared by every transducer and Pattern
patterns	[Option<&[Vec<Phase>]>; 4]	Sequence of phases to write

PatternCompression

Variant	Patterns per frame	Description
PhaseFull	2	Sends the phase at full resolution (8 bit)
PhaseHalf	4	Sends the phase at half resolution (4 bit)

Example

An example of compressing 4 Patterns into a single command with PhaseHalf and playing them as STM with ConfigPattern + ChangePatternBank.

Rust

use autd3_rs::commands::{
    ChangePatternBank, ConfigPattern, PatternCompression, StmConfig, WritePatternCompressed,
};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{Hz, m, mm, s};
use autd3_rs::value::{Intensity, LoopBehavior, PatternBank, TransitionMode};
use autd3_rs::{Client, ClientConfig};
use autd3_rs_link_nop::Nop;
use autd3_rs_pattern::{focus, wavelength};

let geometry = Geometry::new(vec![Autd3::default()]);
let client = Client::open(&geometry, Nop, ClientConfig::default()).await?;

let wavelength = wavelength(340.0 * m / s);
let patterns = [-30.0f32, -10.0, 10.0, 30.0]
    .iter()
    .map(|&x| {
        let mut buffer = geometry.phase_buffer();
        focus(
            &geometry,
            geometry.center() + offset(x * mm, 0.0 * mm, 150.0 * mm),
            wavelength,
            &mut buffer,
        );
        buffer
    })
    .collect::<Vec<_>>();

let bank = PatternBank::B0;

let mut builder = client.datagram_builder();
builder.push(WritePatternCompressed {
    bank,
    index: 0,
    format: PatternCompression::PhaseHalf,
    intensity: Intensity::MAX,
    patterns: [
        Some(&patterns[0][..]),
        Some(&patterns[1][..]),
        Some(&patterns[2][..]),
        Some(&patterns[3][..]),
    ],
});
builder.push(ConfigPattern {
    bank,
    config: StmConfig::new(1.0 * Hz).into_sampling_config(patterns.len()),
    size: patterns.len(),
    loop_behavior: LoopBehavior::Infinite,
});
builder.push(ChangePatternBank {
    bank,
    transition_mode: TransitionMode::Immediate,
});
let frames = builder.build()?;
for frame in &frames {
    client.send_checked(frame).await?;
}

client.close().await?;

Python

import asyncio

import numpy as np

from autd3 import Client, ClientConfig
from autd3.commands import ChangePatternBank, ConfigPattern, PatternCompression, StmConfig, WritePatternCompressed
from autd3.geometry import Autd3, Geometry
from autd3.units import Hz, m, s
from autd3.value import Intensity, LoopBehavior, PatternBank, TransitionMode
from autd3_link_nop import Nop
from autd3_pattern import focus
from autd3_pattern import wavelength as calc_wavelength


async def main() -> None:
    geometry = Geometry([Autd3([0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0])])
    async with await Client.open(geometry, Nop(), ClientConfig()) as client:
        wavelength = calc_wavelength(340 * m / s)
        patterns = []
        for x in (-30.0, -10.0, 10.0, 30.0):
            buffer = geometry.phase_buffer()
            focus(
                geometry,
                geometry.center() + np.array([x, 0.0, 150.0]),
                wavelength,
                buffer,
            )
            patterns.append(buffer)

        bank = PatternBank.B0

        builder = client.datagram_builder()
        builder.push(
            WritePatternCompressed(
                bank=bank,
                index=0,
                format=PatternCompression.PhaseHalf,
                intensity=Intensity.MAX,
                patterns=patterns,
            )
        )
        builder.push(
            ConfigPattern(
                bank=bank,
                config=StmConfig(1.0 * Hz).into_sampling_config(len(patterns)),
                size=len(patterns),
                loop_behavior=LoopBehavior.Infinite,
            )
        )
        builder.push(
            ChangePatternBank(
                bank=bank,
                transition_mode=TransitionMode.Immediate,
            )
        )
        frames = builder.build()
        for frame in frames:
            await client.send_checked(frame)


asyncio.run(main())

C#

using System.Numerics;
using System.Threading.Tasks;
using AUTD3;
using AUTD3.Link;
using Nop = AUTD3.Link.Nop;
using static AUTD3.Units;

var geometry = new Geometry(new[] { new Autd3(Vector3.Zero) });
await using var client = await Client.OpenAsync(geometry, new Nop(), new ClientConfig());

var wavelength = Pattern.Wavelength(340.0f * m / s);
var offsets = new[] { -30.0f, -10.0f, 10.0f, 30.0f };
var patterns = new PhaseBuffer[offsets.Length];
for (var i = 0; i < offsets.Length; i++)
{
    var buffer = geometry.PhaseBuffer();
    Pattern.Focus(
        geometry,
        geometry.Center + new Vector3(offsets[i], 0.0f, 150.0f),
        wavelength,
        buffer
    );
    patterns[i] = buffer;
}

var bank = PatternBank.B0;

var builder = client.DatagramBuilder();
builder.Push(new WritePatternCompressed(
    bank: bank,
    index: 0,
    format: PatternCompression.PhaseHalf,
    intensity: Intensity.Max,
    patterns: patterns
));
builder.Push(new ConfigPattern(
    bank: bank,
    config: new StmConfig(1.0f * Hz).IntoSamplingConfig(patterns.Length),
    size: (uint)patterns.Length,
    loopBehavior: LoopBehavior.Infinite
));
builder.Push(new ChangePatternBank(
    bank: bank,
    transitionMode: TransitionMode.Immediate
));
var frames = builder.Build();
foreach (var frame in frames)
{
    await client.SendCheckedAsync(frame);
}