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 fixed at the maximum (255).

API

Rust

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

Python

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

C#

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

Field	Type	Description
bank	PatternBank	Destination bank
index	usize	Start index for writing within the bank
format	PatternCompression	Compression format (see below)
patterns	[Option<&[Vec<Emission>]>; 4]	Sequence of Patterns 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::{LoopBehavior, PatternBank, TransitionMode};
use autd3_rs::{Client, ClientConfig};
use autd3_rs_link_nop::Nop;
use autd3_rs_pattern::{FocusOption, 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.pattern_buffer();
        focus(
            &geometry,
            geometry.center() + offset(x * mm, 0.0 * mm, 150.0 * mm),
            wavelength,
            &FocusOption::default(),
            &mut buffer,
        );
        buffer
    })
    .collect::<Vec<_>>();

let bank = PatternBank::B0;

let mut builder = client.datagram_builder();
builder.push(WritePatternCompressed {
    bank,
    index: 0,
    format: PatternCompression::PhaseHalf,
    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 LoopBehavior, PatternBank, TransitionMode
from autd3_link_nop import Nop
from autd3_pattern import FocusOption, focus, wavelength


async def main() -> None:
    geometry = Geometry([Autd3([0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0])])
    client = await Client.open(geometry, Nop(), ClientConfig())

    center = geometry.center() + np.array([0.0, 0.0, 150.0])
    wl = wavelength(340 * m / s)
    patterns = []
    for x in (-30.0, -10.0, 10.0, 30.0):
        buffer = geometry.pattern_buffer()
        focus(
            geometry,
            center + np.array([x, 0.0, 0.0]),
            wl,
            FocusOption(),
            buffer,
        )
        patterns.append(buffer)

    bank = PatternBank.B0

    builder = client.datagram_builder()
    builder.push(
        WritePatternCompressed(
            bank=bank,
            index=0,
            format=PatternCompression.PhaseHalf,
            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)

    await client.close()


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) });
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 PatternBuffer[offsets.Length];
for (var i = 0; i < offsets.Length; i++)
{
    var buffer = geometry.PatternBuffer();
    Pattern.Focus(
        geometry,
        geometry.Center + new Vector3(offsets[i], 0.0f, 150.0f),
        wavelength,
        new FocusOption(),
        buffer
    );
    patterns[i] = buffer;
}

var bank = PatternBank.B0;

var builder = client.DatagramBuilder();
builder.Push(new WritePatternCompressed(
    bank: bank,
    index: 0,
    format: PatternCompression.PhaseHalf,
    patterns: patterns
));
builder.Push(new ConfigPattern(
    bank: bank,
    config: new SamplingConfig(patterns.Length * Hz),
    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);
}

await client.CloseAsync();