Python Reference

class vortex.Logger

class vortex.Range

contains(self: vortex.Range, arg0: float) → bool

copy(self: vortex.Range) → vortex.Range

property length

property max

property min

static symmetric(arg0: float) → vortex.Range

vortex.get_console_logger(name: str, level: int = 2) → vortex.Logger

vortex.get_python_logger(name: str, scope: str = 'vortex') → vortex.Logger

class vortex.acquire.AlazarAcquisition

Acquire data using an AlazarTech digitizer.

Once prepare() is called, the acquisition may be started and stopped as many times as necessary.

__NOTE__

This component supports preloading with the engine.

property config

Type

AlazarConfig

Copy of the active configuration.

initialize(self: vortex.acquire.AlazarAcquisition, config: vortex.acquire.AlazarConfig) → None

Initialize the acquisition using the supplied configuration. The Alazar card is fully configured when this method returns.

configAlazarConfig

New configuration to apply.

next(self: vortex.acquire.AlazarAcquisition, buffer: numpy.ndarray[numpy.uint16], id: int = 0) → int

Acquire the buffer and return the number of acquired records.

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire, with shape that matches self.config.shape.

idint

Number to associate with the buffer for logging purposes.

int

The number of records acquired. If the number acquired is less than the number requested, the acquisition is complete.

RuntimeError

If the acquisition fails.

next_async(self: vortex.acquire.AlazarAcquisition, buffer: numpy.ndarray[numpy.uint16], callback: Callable[[int, std::exception_ptr], None], id: int = 0) → None

Acquire the buffer asynchronously and execute the callback when complete.

__CAUTION__

The callback may be executed in the calling thread before this method returns if an error occurs while queueing the background acquisition.

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire, with shape that matches self.config.shape.

callbackCallable[[int, Exception], None]

Callback to execute when buffer is filled. The callback receives two arguments, the number of records acquired and any exception which occurred during the acquisition. If the number of records acquired is less than the number requested, the acquisition is complete.

idint

Number to associate with the buffer for logging purposes.

prepare(self: vortex.acquire.AlazarAcquisition) → None

Prepare to imminently start the acquisition. The Alazar card is armed for capture.

property running

start(self: vortex.acquire.AlazarAcquisition) → None

Start the acquisition.

stop(self: vortex.acquire.AlazarAcquisition) → None

Stop the acquisition.

__CAUTION__

Asynchronously acquired buffers that completed before the acquisition was stopped may continue to result after this method returns.

class vortex.acquire.AlazarConfig

Base: NullAcquisitionConfig

Configuration object for AlazarAcquisition.

property acquire_timeout

Type

datetime.timedelta

Timeout for the acquisition of each block. Defaults to timedelta(seconds=1).

property bytes_per_multisample

Type

int

property channel_mask

Type

int

Bitmask of channels configured for acquisition. Read-only.

property channels_per_sample

Type

int

Number of channels that comprise each sample.

property clock

Type

InternalClock | ExternalClock

Internal or external clock configuration. Defaults to InternalClock().

copy(self: vortex.acquire.AlazarConfig) → vortex.acquire.AlazarConfig

Create a copy of this configuration.

AlazarConfig

The copy.

property device

Type

AlazarDevice

Alazar device for acquisition. Defaults to AlazarDevice().

property inputs

Type

List[Input]

List of input configurations for each channel acquire. Default is empty.

property options

Type

List[AuxIOTriggerOut | AuxIOClockOut | AuxIOPacerOut | OCTIgnoreBadClock]

List of acquisition options. Default is empty.

property recommended_minimum_records_per_block

Type

int

Minimum recommended records per block for the configured Alazar digitizer. Read-only.

property records_per_block

Type

int

Number of records in each acquired buffer or block.

property resampling

Type

numpy.ndarray[int]

Zero-based index of samples to keep in each record. All other samples are removed from the record. This can be used to perform resampling with nearest-neighbor interpolation. Number of samples to keep must match the number of samples per record. Set to an empty array ([]) to disable resampling. Disabled by default.

property samples_per_record

Type

int

Number of samples per record.

property samples_per_second

Type

int

Number of samples per second for internally-clocked acquisitions. Read-only.

RuntimeError

if samples_per_second_is_known is False.

property samples_per_second_is_known

Type

bool

True if samples_per_second is specified in the configuration (e.g., vortex.acquire.InternalClock) and False otherwise. Read-only.

property shape

Type

List[int[3]]

Required shape of output buffers. Returns a list of [records_per_block, samples_per_record, channels_per_sample]. Read-only.

property stop_on_error

Type

bool

Automatically stop the acquisition when an error occurs. Default is `True.

property trigger

Type

SingleExternalTrigger | DualExternalTrigger

Single or dual trigger configuration. Defaults to SingleExternalTrigger().

validate(self: vortex.acquire.AlazarConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.AlazarDevice

Representation of an Alazar device identifier.

property board_index

Type

int

Index of board within Alazar system The first board has index 1.

copy(self: vortex.acquire.AlazarDevice) → vortex.acquire.AlazarDevice

property system_index

Type

int

Index of Alazar system. The first system has index 1.

class vortex.acquire.AlazarFFTAcquisition

Base: AlazarAcquisition

Acquire data using an AlazarTech digitizer with the on-board FPGA configured for FFT computation.

This class may be used to simultaneously acquire the raw and FFT data using the include_time_domain option. In this case, both the raw and FFT data are combined into a single record.

__NOTE__

This component supports preloading with the engine.

property config

Type

AlazarFFTConfig

Copy of the active configuration.

initialize(self: vortex.acquire.AlazarFFTAcquisition, config: vortex.acquire.AlazarFFTConfig) → None

Initialize the acquisition using the supplied configuration. The Alazar card is fully configured when this method returns.

configAlazarFFTConfig

New configuration to apply.

next(self: vortex.acquire.AlazarFFTAcquisition, buffer: numpy.ndarray[numpy.uint16], id: int = 0) → int

Acquire the buffer and return the number of acquired records.

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire, with shape that matches self.config.shape.

idint

Number to associate with the buffer for logging purposes.

int

The number of records acquired. If the number acquired is less than the number requested, the acquisition is complete.

RuntimeError

If the acquisition fails.

next_async(self: vortex.acquire.AlazarFFTAcquisition, buffer: numpy.ndarray[numpy.uint16], callback: Callable[[int, std::exception_ptr], None], id: int = 0) → None

Acquire the buffer asynchronously and execute the callback when complete.

__CAUTION__

The callback may be executed in the calling thread before this method returns if an error occurs while queueing the background acquisition.

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire, with shape that matches self.config.shape.

callbackCallable[[int, Exception], None]

Callback to execute when buffer is filled. The callback receives two arguments, the number of records acquired and any exception which occurred during the acquisition. If the number of records acquired is less than the number requested, the acquisition is complete.

idint

Number to associate with the buffer for logging purposes.

prepare(self: vortex.acquire.AlazarFFTAcquisition) → None

Prepare to imminently start the acquisition. The Alazar card is armed for capture.

property running

start(self: vortex.acquire.AlazarFFTAcquisition) → None

Start the acquisition.

stop(self: vortex.acquire.AlazarFFTAcquisition) → None

Stop the acquisition.

__CAUTION__

Asynchronously acquired buffers that completed before the acquisition was stopped may continue to result after this method returns.

class vortex.acquire.AlazarFFTConfig

Base: AlazarConfig

Configuration object for AlazarFFTAcquisition.

property acquire_timeout

Type

datetime.timedelta

Timeout for the acquisition of each block. Defaults to timedelta(seconds=1).

property ascans_per_block

Type

int

Number of A-scans per block which is identical to number of records per blocks. Provided for API consistency only.

property background

Type

numpy.ndarray[numpy.uint16]

Background record to subtract. Set to empty array([]) to disable. Disabled by default.

property bytes_per_multisample

Type

int

property channel_mask

Type

int

Bitmask of channels configured for acquisition. Read-only.

property channels_per_sample

Type

int

Number of channels that comprise each sample.

property clock

Type

InternalClock | ExternalClock

Internal or external clock configuration. Defaults to InternalClock().

copy(*args, **kwargs)

Overloaded function.

1. copy(self: vortex.acquire.AlazarFFTConfig) -> vortex.acquire.AlazarFFTConfig

Create a copy of this configuration.

AlazarFFTConfig

The copy.

2. copy(self: vortex.acquire.AlazarFFTConfig) -> vortex.acquire.AlazarFFTConfig

Create a copy of this configuration.

AlazarFFTConfig

The copy.

property device

Type

AlazarDevice

Alazar device for acquisition. Defaults to AlazarDevice().

property fft_length

Type

int

Length of on-board FFT to perform. Records are zero-padded to reach this length. Must be larger than samples per record and must be a power of 2.

property include_time_domain

Type

bool

Append time domain data to the output FFT record. Requires a pointer cast to access since different data types are combined into single record. Defaults to False.

property inputs

Type

List[Input]

List of input configurations for each channel acquire. Default is empty.

property options

Type

List[AuxIOTriggerOut | AuxIOClockOut | AuxIOPacerOut | OCTIgnoreBadClock]

List of acquisition options. Default is empty.

property recommended_minimum_records_per_block

Type

int

Minimum recommended records per block for the configured Alazar digitizer. Read-only.

property records_per_block

Type

int

Number of records in each acquired buffer or block.

property resampling

Type

numpy.ndarray[int]

Zero-based index of samples to keep in each record. All other samples are removed from the record. This can be used to perform resampling with nearest-neighbor interpolation. Number of samples to keep must match the number of samples per record. Set to an empty array ([]) to disable resampling. Disabled by default.

property samples_per_ascan

Type

int

Number of samples per the output A-scan, which may differ from samples per record depending on FFT settings. Read-only.

property samples_per_record

Type

int

Number of samples per record.

property samples_per_second

Type

int

Number of samples per second for internally-clocked acquisitions. Read-only.

RuntimeError

if samples_per_second_is_known is False.

property samples_per_second_is_known

Type

bool

True if samples_per_second is specified in the configuration (e.g., vortex.acquire.InternalClock) and False otherwise. Read-only.

property shape

Type

List[int[3]]

Required shape of output buffers. Returns a list of [records_per_block, samples_per_record, channels_per_sample]. Read-only.

property spectral_filter

Type

numpy.ndarray[numpy.complex64]

Spectral filter to apply before the FFT. Must have the same length as FFT. Set to empty array ([]) to disable. Disabled by default.

property stop_on_error

Type

bool

Automatically stop the acquisition when an error occurs. Default is `True.

property trigger

Type

SingleExternalTrigger | DualExternalTrigger

Single or dual trigger configuration. Defaults to SingleExternalTrigger().

validate(self: vortex.acquire.AlazarFFTConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.AuxIOClockOut

Pass the clock through the auxillary I/O port.

copy(self: vortex.acquire.AuxIOClockOut) → vortex.acquire.AuxIOClockOut

class vortex.acquire.AuxIOPacerOut

Pass the clock through the auxillary I/O port after a divider.

copy(self: vortex.acquire.AuxIOPacerOut) → vortex.acquire.AuxIOPacerOut

property divider

Type

int

Divider for clock, with minimum value of 2. The clock frequency is divided by this value to determine the pacer frequency.

class vortex.acquire.AuxIOTriggerOut

Pass the trigger through the auxillary I/O port.

copy(self: vortex.acquire.AuxIOTriggerOut) → vortex.acquire.AuxIOTriggerOut

class vortex.acquire.DualExternalTrigger

Configure a dual external trigger.

property coupling

Type

Coupling

Coupling for trigger input.

property delay_samples

Type

int

Number of samples to skip following a trigger event before acquiring a record. Non-negative.

property initial_slope

Type

TriggerSlope

Polarity of the initial trigger.

property level_ratios

Type

List[float[2]]

A pair of signal level thresholds in range [0, 1] at which trigger events are detected.

property range_millivolts

Type

int

Trigger input range, specified in millivolts.

class vortex.acquire.ExternalClock

Configure an external clock source.

copy(self: vortex.acquire.ExternalClock) → vortex.acquire.ExternalClock

property coupling

Type

Coupling

Coupling for clock input.

property dual

Type

bool

Trigger on both rising and falling clock edges if True. Otherwise, trigger only on edge set by edge.

property edge

Type

ClockEdge

Edge on which to trigger the clock.

property level_ratio

Type

float

Signal level threshold in range [0, 1] at which a clock edge is detected.

class vortex.acquire.FileAcquisition

Acquire data from a file.

Data is read from the file and returned in the requested shape. The file is read as raw bytes with no datatype or alignment considerations. File looping for infinite acquisitions is possible. This class is intended primarily for testing or offline post-processing.

__NOTE__

This component supports preloading with the engine.

property config

Type

FileAcquisitionConfig

Copy of the active configuration.

initialize(self: vortex.acquire.FileAcquisition, config: vortex::acquire::file_config_t) → None

Initialize the acquisition using the supplied configuration.

configFileAcquisitionConfig

New configuration to apply.

next(self: vortex.acquire.FileAcquisition, buffer: numpy.ndarray[numpy.uint16], id: int = 0) → int

Acquire the buffer and return the number of acquired records.

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire, with shape that matches self.config.shape.

idint

Number to associate with the buffer for logging purposes.

int

The number of records acquired. If the number acquired is less than the number requested, the acquisition is complete.

RuntimeError

If the acquisition fails.

prepare(self: vortex.acquire.FileAcquisition) → None

Prepare to imminently start the acquisition. Present for API uniformity, but calling is unnecessary.

start(self: vortex.acquire.FileAcquisition) → None

Start the acquisition, and open the source file.

stop(self: vortex.acquire.FileAcquisition) → None

Stop the acquisition, and close the source file.

class vortex.acquire.FileAcquisitionConfig

Base: NullAcquisitionConfig

Configuration object for FileAcquisition.

property channels_per_sample

Type

int

Number of channels that comprise each sample.

copy(self: vortex.acquire.FileAcquisitionConfig) → vortex.acquire.FileAcquisitionConfig

Return a copy of this configuration.

FileAcquisitionConfig

The copy.

property loop

Type

bool

Loop the file to provide an infinite acquisition. Otherwise, the acquisition ends when the end of file is reached.

property path

Type

str

Path to file that backs the acquisition.

property records_per_block

Type

int

Number of records in each acquired buffer or block.

property samples_per_record

Type

int

Number of samples per record.

property shape

Type

List[int[3]]

Required shape of output buffers. Returns a list of [records_per_block, samples_per_record, channels_per_sample]. Read-only.

validate(self: vortex.acquire.FileAcquisitionConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.Input

Configure an input channel.

property bytes_per_sample

Type

int

Number of bytes per sample acquired for this input. Read-only.

property channel

Type

Channel

Channel to receive this configuration.

copy(self: vortex.acquire.Input) → vortex.acquire.Input

Copy this object.

Input

The copy.

property coupling

Type

Coupling

Coupling for channel input.

property impedance_ohms

Type

int

Channel input impedance, specified in Ohms.

property range_millivolts

Type

int

Channel input range, specified in millivolts.

class vortex.acquire.InternalClock

Configure an internal clock source.

copy(self: vortex.acquire.InternalClock) → vortex.acquire.InternalClock

property samples_per_second

Type

int

Number of samples per second to configure for the internal clock

class vortex.acquire.NullAcquisition

Perform no acquisition.

This class is provided as an engine placeholder for testing or mocking. The only necessary configuration is the expected output shape.

__NOTE__

This component supports preloading with the engine.

property config

Type

NullAcquisitionConfig

Copy of the active configuration.

initialize(self: vortex.acquire.NullAcquisition, config: vortex::acquire::null_config_t) → None

Initialize the acquisition using the supplied configuration. Present for API uniformity but calling is necessary only if the configuration is accessed elsewhere.

configNullAcquisitionConfig

New configuration to apply.

next(self: vortex.acquire.NullAcquisition, buffer: numpy.ndarray[numpy.uint16], id: int = 0) → int

Acquire the next buffer. Always successfully acquires buffer.shape[0] records.

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire.

idint

Number to associate with the buffer for logging purposes.

int

The number of records acquired. The number of records is always matches buffer.shape[0].

prepare(self: vortex.acquire.NullAcquisition) → None

Prepare to imminently start the acquisition. Present for API uniformity, but calling is unnecessary.

start(self: vortex.acquire.NullAcquisition) → None

Start the acquisition. Present for API uniformity, but calling is unnecessary.

stop(self: vortex.acquire.NullAcquisition) → None

Stop the acquisition. Present for API uniformity, but calling is unnecessary.

class vortex.acquire.NullAcquisitionConfig

Configuration object for NullAcquisition.

property channels_per_sample

Type

int

Number of channels that comprise each sample.

copy(self: vortex.acquire.NullAcquisitionConfig) → vortex.acquire.NullAcquisitionConfig

Create a copy of this configuration.

NullAcquisitionConfig

The copy.

property records_per_block

Type

int

Number of records in each acquired buffer or block.

property samples_per_record

Type

int

Number of samples per record.

property shape

Type

List[int[3]]

Required shape of output buffers. Returns a list of [records_per_block, samples_per_record, channels_per_sample]. Read-only.

validate(self: vortex.acquire.NullAcquisitionConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.OCTIgnoreBadClock

Activate the OCT ignore bad clock feature.

property bad_seconds

Type

float

Bad clock duration, specified in seconds.

copy(self: vortex.acquire.OCTIgnoreBadClock) → vortex.acquire.OCTIgnoreBadClock

property good_seconds

Type

float

Good clock duration, specified in seconds.

class vortex.acquire.SingleExternalTrigger

Configure a single external trigger.

property coupling

Type

Coupling

Coupling for trigger input.

property delay_samples

Type

int

Number of samples to skip following a trigger event before acquiring a record. Non-negative.

property level_ratio

Type

float

Signal level threshold in range [0, 1] at which a trigger event is detected.

property range_millivolts

Type

int

Trigger input range, specified in millivolts.

property slope

Type

TriggerSlope

Polarity of trigger signal.

class vortex.acquire.VectorInput

append(self: vortex.acquire.VectorInput, x: vortex::acquire::input_t) → None

Add an item to the end of the list

clear(self: vortex.acquire.VectorInput) → None

Clear the contents

count(self: vortex.acquire.VectorInput, x: vortex::acquire::input_t) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: vortex.acquire.VectorInput, L: vortex.acquire.VectorInput) -> None

Extend the list by appending all the items in the given list

2. extend(self: vortex.acquire.VectorInput, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: vortex.acquire.VectorInput, i: int, x: vortex::acquire::input_t) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: vortex.acquire.VectorInput) -> vortex::acquire::input_t

Remove and return the last item

2. pop(self: vortex.acquire.VectorInput, i: int) -> vortex::acquire::input_t

Remove and return the item at index i

remove(self: vortex.acquire.VectorInput, x: vortex::acquire::input_t) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.acquire.VectorOption

append(self: vortex.acquire.VectorOption, x: Union[vortex::acquire::option::auxio_trigger_out_t, vortex::acquire::option::auxio_clock_out_t, vortex::acquire::option::auxio_pacer_out_t, vortex::acquire::option::oct_ignore_bad_clock_t]) → None

Add an item to the end of the list

clear(self: vortex.acquire.VectorOption) → None

Clear the contents

count(self: vortex.acquire.VectorOption, x: Union[vortex::acquire::option::auxio_trigger_out_t, vortex::acquire::option::auxio_clock_out_t, vortex::acquire::option::auxio_pacer_out_t, vortex::acquire::option::oct_ignore_bad_clock_t]) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: vortex.acquire.VectorOption, L: vortex.acquire.VectorOption) -> None

Extend the list by appending all the items in the given list

2. extend(self: vortex.acquire.VectorOption, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: vortex.acquire.VectorOption, i: int, x: Union[vortex::acquire::option::auxio_trigger_out_t, vortex::acquire::option::auxio_clock_out_t, vortex::acquire::option::auxio_pacer_out_t, vortex::acquire::option::oct_ignore_bad_clock_t]) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: vortex.acquire.VectorOption) -> Union[vortex::acquire::option::auxio_trigger_out_t, vortex::acquire::option::auxio_clock_out_t, vortex::acquire::option::auxio_pacer_out_t, vortex::acquire::option::oct_ignore_bad_clock_t]

Remove and return the last item

2. pop(self: vortex.acquire.VectorOption, i: int) -> Union[vortex::acquire::option::auxio_trigger_out_t, vortex::acquire::option::auxio_clock_out_t, vortex::acquire::option::auxio_pacer_out_t, vortex::acquire::option::oct_ignore_bad_clock_t]

Remove and return the item at index i

remove(self: vortex.acquire.VectorOption, x: Union[vortex::acquire::option::auxio_trigger_out_t, vortex::acquire::option::auxio_clock_out_t, vortex::acquire::option::auxio_pacer_out_t, vortex::acquire::option::oct_ignore_bad_clock_t]) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.engine.AscanHDF5StackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.AscanStackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.AscanStreamEndpoint

property storage

class vortex.engine.Block

class StreamIndex

Members:

Counter

GalvoTarget

SampleTarget

GalvoActual

SampleActual

Strobes

Counter = <StreamIndex.Counter: 0>

GalvoActual = <StreamIndex.GalvoActual: 3>

GalvoTarget = <StreamIndex.GalvoTarget: 1>

SampleActual = <StreamIndex.SampleActual: 4>

SampleTarget = <StreamIndex.SampleTarget: 2>

Strobes = <StreamIndex.Strobes: 5>

property name

property value

property counter

property galvo_actual

property galvo_target

property id

property length

property markers

property sample

property sample_actual

property sample_target

property strobes

property timestamp

class vortex.engine.BroctStorageEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.BufferStrategy

Members:

Block

Segment

Volume

Block = <BufferStrategy.Block: 0>

Segment = <BufferStrategy.Segment: 1>

Volume = <BufferStrategy.Volume: 2>

property name

property value

class vortex.engine.CounterHDF5StackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.CounterStackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.CounterStackHostTensorEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.Engine

A real-time engine that moves data through an acquisition, processing, and formatting pipeline.

Once the pipeline is configured, the engine can operate the pipeline in multiple sessions, bounded by start() and stop() calls. The session is active until the scan_queue becomes empty, EngineConfig.blocks_to_acquire have been acquired, stop() is called, or an error occurs.

class Event

Members:

Launch

Start

Run

Stop

Complete

Shutdown

Exit

Error

Abort

Abort = <Event.Abort: 8>

Complete = <Event.Complete: 4>

Error = <Event.Error: 7>

Exit = <Event.Exit: 6>

Launch = <Event.Launch: 0>

Run = <Event.Run: 2>

Shutdown = <Event.Shutdown: 5>

Start = <Event.Start: 1>

Stop = <Event.Stop: 3>

property name

property value

property config

Type

EngineConfig

Copy of the active configuration.

property done

Type

bool

Return True if the engine is stopped and False otherwise.

__WARNING__

This property will return True until stop() is called. Do no rely on this property to determine if the engine has exited.

property event_callback

Type

Callable[[Engine.Event, Exception], None]

Callback to receive status events from the engine.

initialize(self: vortex.engine.Engine, arg0: vortex.engine.EngineConfig) → None

Initialize the engine using the supplied configuration.

configEngineConfig

New configuration to apply.

property job_callback

Type

Callable[[int, EngineStatus, JobTiming], None]

Callback to receive status and timing information for each block when it exits the pipeline.

__CAUTION__

Avoid computationally expensive tasks in this callback or the session may shut down prematurely due to delayed block recycling.

prepare(self: vortex.engine.Engine) → None

Prepare to start the engine. The engine allocates all blocks, assigns and allocates transfer buffers, and notifies endpoints to allocate their internal buffers, if needed.

property scan_queue

Type

ScanQueue

Access the engine’s scan queue.

start(self: vortex.engine.Engine) → None

Start a new session with the engine. Acquisition and IO components are preloaded, if applicable, and started. Every call of this method must be paired with a call to stop() at a later time.

status(self: vortex.engine.Engine) → vortex.engine.EngineStatus

Query the engine status.

EngineStatus

The current status of the engine.

stop(self: vortex.engine.Engine) → None

Request that the engine shut down and wait for it to do so. This method must be called for every call to start().

RuntimeError

If any error occurred to shut down the engine prematurely. This is guaranteed to be the first of such errors in case a cascade of errors occurs.

wait(self: vortex.engine.Engine) → None

Wait for the active session to complete. This method will block indefinitely.

RuntimeError

If any error occurred to shut down the session prematurely. This is guaranteed to be the first of such errors in case a cascade of errors occurs.

wait_for(self: vortex.engine.Engine, timeout: float) → bool

class vortex.engine.EngineConfig

Configuration object for Engine.

add_acquisition(self: vortex.engine.EngineConfig, acquisition: object, processors: sequence, preload: bool = True, master: bool = True) → None

add_formatter(self: vortex.engine.EngineConfig, arg0: object, arg1: sequence) → None

add_io(self: vortex.engine.EngineConfig, io: object, preload: bool = True, master: bool = False, lead_samples: int = 0) → None

add_processor(self: vortex.engine.EngineConfig, arg0: object, arg1: sequence) → None

property blocks_to_acquire

Type

The total acquisition duration as measured in blocks. Set to 0 for an indefinite acquisition, which ends only when the last scan reports that it is complete. Default is 0.

property blocks_to_allocate

Type

int

Number of blocks to pre-allocate prior to starting the session. This determines the maximum session duration or size that can be buffered in memory. The maximum buffered duration in records is the product of blocks_to_allocate and records_per_block. Default is 4.

copy(self: vortex.engine.EngineConfig) → vortex.engine.EngineConfig

property galvo_input_channels

Type

int

Number of input channels to allocate for galvo waveforms. Default is 2.

property galvo_output_channels

Type

int

Number of output channels to allocate for galvo waveforms. Default is 2.

property post_scan_records

Type

int

The number of records to acquire after the last scan reports that is is complete. This is useful if hardware latencies cause the final samples of the scan to physically occur after the acquisition would have otherwise ended. Default is 0.

property preload_count

Type

int

Number of blocks to commit to the hardware drivers prior to starting the session. This determines how far in advance the engine is generating signals and scheduling buffers for acquisition. Once the engine starts, the engine will never have more that this number of blocks pending for acquisition. The product of preload_count and records_per_block determines the number of records required for new inputs (e.g., scan pattern changes) to propagate through the pipeline. Default is 2.

property records_per_block

Type

int

Number of records (spectra or A-scans) in a block. Each block represents a slice of time, as determined by the number of records acquired per second. Default is 1000.

property scanner_warp

Type

[NoWarp | AngularWarp | TelecentricWarp]

Scan warp to generate the sample waveforms from the galvo waveforms. Default is NoWarp.

property strobes

Type

List[SampleStrobe | SegmentStrobe | VolumeStrobe | ScanStrobe | EventStrobe]

Scan pattern-derived strobes to generate for output. Default is [SampleStrobe(0, 2), SampleStrobe(1, 1000), SampleStrobe(2, 1000, Polarity.Low), SegmentStrobe(3), VolumeStrobe(4)].

validate(self: vortex.engine.EngineConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

__WARNING__

This method is not fully implemented yet.

class vortex.engine.EngineStatus

property active

property block_utilization

copy(self: vortex.engine.EngineStatus) → vortex.engine.EngineStatus

property dispatch_completion

property dispatched_blocks

property inflight_blocks

class vortex.engine.EventStrobe

property delay

property duration

property flags

property line

property polarity

class vortex.engine.GalvoActualHDF5StackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.GalvoActualStackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.GalvoActualStackHostTensorEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.JobTiming

property acquire

property create

property format

property process

property recycle

property scan

property service

class vortex.engine.MarkerLogStorage

property storage

class vortex.engine.NullEndpoint

class vortex.engine.Polarity

Members:

Low

High

High = <Polarity.High: 1>

Low = <Polarity.Low: 0>

property name

property value

class vortex.engine.PositionDeviceTensorEndpointInt8

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.RadialDeviceTensorEndpointInt8

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.SampleStrobe

property divisor

property duration

property line

property phase

property polarity

class vortex.engine.ScanQueue

A queue of scans to execute with the engine. When the scan queue is empty, the engine initiates a graceful shutdown.

class Event

Members:

Start

Finish

Interrupt

Abort

Abort = <Event.Abort: 3>

Finish = <Event.Finish: 1>

Interrupt = <Event.Interrupt: 2>

Start = <Event.Start: 0>

property name

property value

class OnlineScanQueue

append(*args, **kwargs)

Overloaded function.

1. append(self: vortex.engine.ScanQueue.OnlineScanQueue, scan: vortex.scan.RasterScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

2. append(self: vortex.engine.ScanQueue.OnlineScanQueue, scan: vortex.scan.RepeatedRasterScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

3. append(self: vortex.engine.ScanQueue.OnlineScanQueue, scan: vortex.scan.RadialScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

4. append(self: vortex.engine.ScanQueue.OnlineScanQueue, scan: vortex.scan.RepeatedRadialScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

5. append(self: vortex.engine.ScanQueue.OnlineScanQueue, scan: vortex.scan.SpiralScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

6. append(self: vortex.engine.ScanQueue.OnlineScanQueue, scan: vortex.scan.FreeformScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

append(*args, **kwargs)

Overloaded function.

1. append(self: vortex.engine.ScanQueue, scan: vortex.scan.RasterScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

2. append(self: vortex.engine.ScanQueue, scan: vortex.scan.RepeatedRasterScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

3. append(self: vortex.engine.ScanQueue, scan: vortex.scan.RadialScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

4. append(self: vortex.engine.ScanQueue, scan: vortex.scan.RepeatedRadialScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

5. append(self: vortex.engine.ScanQueue, scan: vortex.scan.SpiralScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

6. append(self: vortex.engine.ScanQueue, scan: vortex.scan.FreeformScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

clear(self: vortex.engine.ScanQueue) → None

Clears the scan queue but maintains internal scan state (e.g., last position and velocity).

property empty_callback

Type

Callable[[OnlineScanQueue], None]

Callback to execute when the scan queue is empty but before the engine initiates a graceful shutdown. This represents the last opportunity to prolong the session. The callback receives a single argument of OnlineScanQueue which exposes a single OnlineScanQueue.append() method to provide a thread-safe mechanism to append another scan. This method is identical in operation to ScanQueue.append(). If no scan is appended, the engine will initiate a graceful shutdown immediately after the callback returns.

__ATTENTION__

Any attempt to call a method of the ScanQueue during this callback will lead to deadlock. Only call methods of the OnlineScanQueue provided as the callback’s argument.

generate(self: vortex.engine.ScanQueue, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64], zero_order_hold: bool = True) → Tuple[int, int]

interrupt(*args, **kwargs)

Overloaded function.

1. interrupt(self: vortex.engine.ScanQueue, scan: vortex.scan.RasterScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

2. interrupt(self: vortex.engine.ScanQueue, scan: vortex.scan.RepeatedRasterScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

3. interrupt(self: vortex.engine.ScanQueue, scan: vortex.scan.RadialScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

4. interrupt(self: vortex.engine.ScanQueue, scan: vortex.scan.RepeatedRadialScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

5. interrupt(self: vortex.engine.ScanQueue, scan: vortex.scan.SpiralScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

6. interrupt(self: vortex.engine.ScanQueue, scan: vortex.scan.FreeformScan, callback: Callable[[int, vortex::engine::scan_queue_t<double,std::variant<vortex::marker::scan_boundary,vortex::marker::volume_boundary,vortex::marker::segment_boundary,vortex::marker::active_lines,vortex::marker::inactive_lines,vortex::marker::event> >::event_t], None] = None, marker: vortex.marker.ScanBoundary = ScanBoundary(sample=0, sequence=0, volume_count_hint=0, flags=Flags(value=0xffffffffffffffff))) -> None

reset(*args, **kwargs)

Overloaded function.

1. reset(self: vortex.engine.ScanQueue) -> None

2. reset(self: vortex.engine.ScanQueue, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64]) -> None

class vortex.engine.ScanStrobe

property delay

property duration

property flags

property line

property polarity

class vortex.engine.SegmentStrobe

property delay

property duration

property flags

property line

property polarity

class vortex.engine.SessionStatus

property allocated

property available

property dispatched

property inflight

property limit

property progress

property utilization

class vortex.engine.Source

property clock_edges_seconds

property clock_rising_edges_per_trigger

copy(self: vortex.engine.Source) → vortex.engine.Source

property duty_cycle

property has_clock

property imaging_depth_meters

property triggers_per_second

class vortex.engine.SpectraHDF5StackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.SpectraPositionDeviceTensorEndpointUInt16

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.SpectraRadialDeviceTensorEndpointUInt16

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.SpectraStackDeviceTensorEndpointUInt16

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.SpectraStackEndpoint

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property storage

property update_callback

property volume_callback

class vortex.engine.SpectraStackHostTensorEndpointUInt16

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.SpectraStackTensorEndpointUInt16

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property tensor

property update_callback

property volume_callback

class vortex.engine.SpectraStreamEndpoint

property storage

class vortex.engine.StackDeviceTensorEndpointInt8

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.StackHostTensorEndpointInt8

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property stream

property tensor

property update_callback

property volume_callback

class vortex.engine.StackTensorEndpointInt8

property aggregate_segment_callback

property event_callback

property executor

property scan_callback

property segment_callback

property tensor

property update_callback

property volume_callback

class vortex.engine.StreamDumpStorage

property storage

class vortex.engine.StrobeList

append(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], x: Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]) → None

Add an item to the end of the list

clear(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]]) → None

Clear the contents

count(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], x: Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], L: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]]) -> None

Extend the list by appending all the items in the given list

2. extend(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], i: int, x: Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]]) -> Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]

Remove and return the last item

2. pop(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], i: int) -> Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]

Remove and return the item at index i

remove(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], x: Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.engine.VolumeStrobe

property delay

property duration

property flags

property line

property polarity

vortex.engine.acquire_alazar_clock(source: vortex.engine.Source, acquire_config: vortex.acquire.AlazarConfig, clock_channel: vortex.driver.alazar.Channel, log: vortex.Logger = None) → Tuple[int, numpy.ndarray[numpy.uint16]]

vortex.engine.compute_resampling(*args, **kwargs)

Overloaded function.

1. compute_resampling(arg0: vortex::engine::source_t<double>, arg1: int, arg2: int) -> numpy.ndarray[numpy.float64]

2. compute_resampling(arg0: vortex::engine::source_t<double>, arg1: int, arg2: int, arg3: int) -> numpy.ndarray[numpy.float64]

vortex.engine.cycle(arg0: sequence) → vortex::engine::engine_config_t<vortex::engine::block_t<unsigned short,signed char,double,unsigned int>,std::variant<vortex::scan::warp::none_t,vortex::scan::warp::angular_t,vortex::scan::warp::telecentric_t> >::cycle_t

vortex.engine.dispersion_phasor(arg0: int, arg1: List[float[2]]) → numpy.ndarray[numpy.complex128]

vortex.engine.divide(arg0: sequence) → vortex::engine::engine_config_t<vortex::engine::block_t<unsigned short,signed char,double,unsigned int>,std::variant<vortex::scan::warp::none_t,vortex::scan::warp::angular_t,vortex::scan::warp::telecentric_t> >::divide_t

vortex.engine.find_rising_edges(*args, **kwargs)

Overloaded function.

1. find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int) -> numpy.ndarray[numpy.float64]

2. find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int, arg2: int) -> numpy.ndarray[numpy.float64]

3. find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int) -> numpy.ndarray[numpy.float64]

4. find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int, arg2: int) -> numpy.ndarray[numpy.float64]

class vortex.format.BroctFormatExecutor

class vortex.format.Copy

property block_offset

property buffer_record

property buffer_segment

property count

property reverse

class vortex.format.FinishScan

property sample

property scan_index

class vortex.format.FinishSegment

property sample

property scan_index

property segment_index_buffer

property volume_index

class vortex.format.FinishVolume

property sample

property scan_index

property volume_index

class vortex.format.FormatPlan

append(self: vortex.format.FormatPlan, x: Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]) → None

Add an item to the end of the list

clear(self: vortex.format.FormatPlan) → None

Clear the contents

count(self: vortex.format.FormatPlan, x: Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: vortex.format.FormatPlan, L: vortex.format.FormatPlan) -> None

Extend the list by appending all the items in the given list

2. extend(self: vortex.format.FormatPlan, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: vortex.format.FormatPlan, i: int, x: Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: vortex.format.FormatPlan) -> Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]

Remove and return the last item

2. pop(self: vortex.format.FormatPlan, i: int) -> Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]

Remove and return the item at index i

remove(self: vortex.format.FormatPlan, x: Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.format.FormatPlanner

property config

initialize(self: vortex.format.FormatPlanner, arg0: vortex.format.FormatPlannerConfig) → None

property records_per_segment

reset(self: vortex.format.FormatPlanner) → None

property segments_per_volume

class vortex.format.FormatPlannerConfig

property adapt_shape

copy(self: vortex.format.FormatPlannerConfig) → vortex.format.FormatPlannerConfig

property mask

property records_per_segment

property segments_per_volume

property shape

property strip_inactive

class vortex.format.LinearTransform

copy(self: vortex.format.LinearTransform) → vortex.format.LinearTransform

property offset

property scale

class vortex.format.NullSlice

copy(self: vortex.format.NullSlice) → vortex.format.NullSlice

class vortex.format.NullTransform

copy(self: vortex.format.NullTransform) → vortex.format.NullTransform

class vortex.format.PositionFormatExecutor

property config

format(*args, **kwargs)

Overloaded function.

1. format(self: vortex.format.PositionFormatExecutor, volume_buffer: cupy.ndarray[cupy.int8], sample_target: cupy.ndarray[cupy.float64], sample_actual: cupy.ndarray[cupy.float64], segment_buffer: cupy.ndarray[cupy.int8], segment_index: int, record_index: int = 0, reverse: bool = False) -> None

2. format(self: vortex.format.PositionFormatExecutor, volume_buffer: cupy.ndarray[cupy.int8], sample_target: cupy.ndarray[cupy.float64], sample_actual: cupy.ndarray[cupy.float64], segment_buffer: cupy.ndarray[cupy.float32], segment_index: int, record_index: int = 0, reverse: bool = False) -> None

initialize(self: vortex.format.PositionFormatExecutor, arg0: vortex.format.PositionFormatExecutorConfig) → None

class vortex.format.PositionFormatExecutorConfig

property channels

copy(self: vortex.format.PositionFormatExecutorConfig) → vortex.format.PositionFormatExecutorConfig

property erase_after_volume

property sample_slice

property sample_transform

set(self: vortex.format.PositionFormatExecutorConfig, pitch: List[float[2]] = [1.0, 1.0], offset: List[float[2]] = [0.0, 0.0], angle: float = 0) → None

property transform

property use_target_position

class vortex.format.RadialFormatExecutor

property config

format(*args, **kwargs)

Overloaded function.

1. format(self: vortex.format.RadialFormatExecutor, volume_buffer: cupy.ndarray[cupy.int8], segment_buffer: cupy.ndarray[cupy.int8], segment_index: int, record_index: int = 0, reverse: bool = False) -> None

2. format(self: vortex.format.RadialFormatExecutor, volume_buffer: cupy.ndarray[cupy.int8], segment_buffer: cupy.ndarray[cupy.float32], segment_index: int, record_index: int = 0, reverse: bool = False) -> None

initialize(self: vortex.format.RadialFormatExecutor, arg0: vortex.format.RadialFormatExecutorConfig) → None

class vortex.format.RadialFormatExecutorConfig

property angular_extent

copy(self: vortex.format.RadialFormatExecutorConfig) → vortex.format.RadialFormatExecutorConfig

property erase_after_volume

property radial_extent

property radial_records_per_segment

property radial_segments_per_volume

property radial_shape

property sample_slice

property sample_transform

property segment_rt_extent

property volume_xy_extent

property x_extent

property y_extent

class vortex.format.Resize

property records_per_segment

property segments_per_volume

property shape

class vortex.format.SimpleSlice

copy(self: vortex.format.SimpleSlice) → vortex.format.SimpleSlice

count(self: vortex.format.SimpleSlice) → int

property start

property step

property stop

class vortex.format.StackFormatExecutor

property config

initialize(self: vortex.format.StackFormatExecutor, arg0: vortex.format.StackFormatExecutorConfig) → None

class vortex.format.StackFormatExecutorConfig

copy(self: vortex.format.StackFormatExecutorConfig) → vortex.format.StackFormatExecutorConfig

property erase_after_volume

property sample_slice

property sample_transform

class vortex.io.AnalogVoltageInput

property channel

copy(self: vortex.io.AnalogVoltageInput) → vortex.io.AnalogVoltageInput

property limits

property logical_units_per_physical_unit

property port_name

property stream

property terminal

class vortex.io.AnalogVoltageOutput

property channel

copy(self: vortex.io.AnalogVoltageOutput) → vortex.io.AnalogVoltageOutput

property limits

property logical_units_per_physical_unit

property port_name

property stream

class vortex.io.DAQmxConfig

property blocks_to_buffer

property channels

property clock

copy(self: vortex.io.DAQmxConfig) → vortex.io.DAQmxConfig

property name

property readwrite_timeout

property samples_per_block

property samples_per_second

property stop_on_error

validate(self: vortex.io.DAQmxConfig) → None

class vortex.io.DAQmxConfigClock

copy(self: vortex.io.DAQmxConfigClock) → vortex.io.DAQmxConfigClock

property divisor

property edge

property source

class vortex.io.DAQmxIO

property config

initialize(self: vortex.io.DAQmxIO, arg0: vortex.io.DAQmxConfig) → None

prepare(self: vortex.io.DAQmxIO) → None

property running

start(self: vortex.io.DAQmxIO) → None

stop(self: vortex.io.DAQmxIO) → None

class vortex.io.DigitalInput

property channel

copy(self: vortex.io.DigitalInput) → vortex.io.DigitalInput

property line_name

max_bits = 32

property stream

class vortex.io.DigitalOutput

property channel

copy(self: vortex.io.DigitalOutput) → vortex.io.DigitalOutput

property line_name

max_bits = 32

property stream

class vortex.io.NullConfig

copy(self: vortex.io.NullConfig) → vortex.io.NullConfig

validate(self: vortex.io.NullConfig) → None

class vortex.io.NullIO

property config

initialize(self: vortex.io.NullIO, arg0: vortex.io.NullConfig) → None

prepare(self: vortex.io.NullIO) → None

start(self: vortex.io.NullIO) → None

stop(self: vortex.io.NullIO) → None

class vortex.io.VectorChannel

append(self: vortex.io.VectorChannel, x: Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]) → None

Add an item to the end of the list

clear(self: vortex.io.VectorChannel) → None

Clear the contents

count(self: vortex.io.VectorChannel, x: Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: vortex.io.VectorChannel, L: vortex.io.VectorChannel) -> None

Extend the list by appending all the items in the given list

2. extend(self: vortex.io.VectorChannel, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: vortex.io.VectorChannel, i: int, x: Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: vortex.io.VectorChannel) -> Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]

Remove and return the last item

2. pop(self: vortex.io.VectorChannel, i: int) -> Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]

Remove and return the item at index i

remove(self: vortex.io.VectorChannel, x: Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.marker.ActiveLines

property sample

class vortex.marker.Event

property flags

property id

property sample

class vortex.marker.Flags

static all() → vortex.marker.Flags

clear(*args, **kwargs)

Overloaded function.

1. clear(self: vortex.marker.Flags) -> None

Clears all bits

2. clear(self: vortex.marker.Flags, arg0: int) -> None

Clears indicated bit

copy(self: vortex.marker.Flags) → vortex.marker.Flags

property max_unique

static none() → vortex.marker.Flags

set(*args, **kwargs)

Overloaded function.

1. set(self: vortex.marker.Flags) -> None

Sets all bits

2. set(self: vortex.marker.Flags, arg0: int) -> None

Sets indicated bit

property value

class vortex.marker.FlagsList

append(self: vortex.marker.FlagsList, x: vortex.marker.Flags) → None

Add an item to the end of the list

clear(self: vortex.marker.FlagsList) → None

Clear the contents

count(self: vortex.marker.FlagsList, x: vortex.marker.Flags) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: vortex.marker.FlagsList, L: vortex.marker.FlagsList) -> None

Extend the list by appending all the items in the given list

2. extend(self: vortex.marker.FlagsList, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: vortex.marker.FlagsList, i: int, x: vortex.marker.Flags) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: vortex.marker.FlagsList) -> vortex.marker.Flags

Remove and return the last item

2. pop(self: vortex.marker.FlagsList, i: int) -> vortex.marker.Flags

Remove and return the item at index i

remove(self: vortex.marker.FlagsList, x: vortex.marker.Flags) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.marker.InactiveLines

property sample

class vortex.marker.MarkerList

append(self: vortex.marker.MarkerList, x: Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]) → None

Add an item to the end of the list

clear(self: vortex.marker.MarkerList) → None

Clear the contents

count(self: vortex.marker.MarkerList, x: Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]) → int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

1. extend(self: vortex.marker.MarkerList, L: vortex.marker.MarkerList) -> None

Extend the list by appending all the items in the given list

2. extend(self: vortex.marker.MarkerList, L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: vortex.marker.MarkerList, i: int, x: Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: vortex.marker.MarkerList) -> Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]

Remove and return the last item

2. pop(self: vortex.marker.MarkerList, i: int) -> Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]

Remove and return the item at index i

remove(self: vortex.marker.MarkerList, x: Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]) → None

Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.marker.ScanBoundary

property flags

property sample

property sequence

property volume_count_hint

class vortex.marker.SegmentBoundary

property flags

property index_in_volume

property record_count_hint

property reversed

property sample

property sequence

class vortex.marker.VolumeBoundary

property flags

property index_in_scan

property reversed

property sample

property segment_count_hint

property sequence

class vortex.memory.CpuTensorFloat32

clear(self: vortex.memory.CpuTensorFloat32) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CpuTensorFloat32, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CpuTensorFloat32) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CpuTensorFloat64

clear(self: vortex.memory.CpuTensorFloat64) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CpuTensorFloat64, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CpuTensorFloat64) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CpuTensorInt8

clear(self: vortex.memory.CpuTensorInt8) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CpuTensorInt8, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CpuTensorInt8) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CpuTensorUInt16

clear(self: vortex.memory.CpuTensorUInt16) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CpuTensorUInt16, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CpuTensorUInt16) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CpuTensorUInt64

clear(self: vortex.memory.CpuTensorUInt64) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CpuTensorUInt64, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CpuTensorUInt64) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaDeviceTensorFloat32

clear(self: vortex.memory.CudaDeviceTensorFloat32) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaDeviceTensorFloat32, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaDeviceTensorFloat32) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaDeviceTensorFloat64

clear(self: vortex.memory.CudaDeviceTensorFloat64) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaDeviceTensorFloat64, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaDeviceTensorFloat64) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaDeviceTensorInt8

clear(self: vortex.memory.CudaDeviceTensorInt8) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaDeviceTensorInt8, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaDeviceTensorInt8) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaDeviceTensorUInt16

clear(self: vortex.memory.CudaDeviceTensorUInt16) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaDeviceTensorUInt16, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaDeviceTensorUInt16) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaDeviceTensorUInt64

clear(self: vortex.memory.CudaDeviceTensorUInt64) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaDeviceTensorUInt64, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaDeviceTensorUInt64) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaHostTensorFloat32

clear(self: vortex.memory.CudaHostTensorFloat32) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaHostTensorFloat32, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaHostTensorFloat32) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaHostTensorFloat64

clear(self: vortex.memory.CudaHostTensorFloat64) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaHostTensorFloat64, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaHostTensorFloat64) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaHostTensorInt8

clear(self: vortex.memory.CudaHostTensorInt8) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaHostTensorInt8, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaHostTensorInt8) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaHostTensorUInt16

clear(self: vortex.memory.CudaHostTensorUInt16) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaHostTensorUInt16, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaHostTensorUInt16) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.memory.CudaHostTensorUInt64

clear(self: vortex.memory.CudaHostTensorUInt64) → None

property count

property data

property dimension

property dtype

resize(self: vortex.memory.CudaHostTensorUInt64, shape: List[int]) → None

property shape

shrink(self: vortex.memory.CudaHostTensorUInt64) → None

property size_in_bytes

property stride

property stride_in_bytes

property underlying_size_in_bytes

property valid

class vortex.process.CUDAProcessor

Perform OCT processing with averaging, resampling by linear interpolation, spectral filtering, and FFT on a CUDA-capable GPU.

change(self: vortex.process.CUDAProcessor, config: vortex.process.CUDAProcessorConfig) → None

Change the processor configuration. May be called while a block is currently processing. If the change requires buffer reallocation, the pipeline is stalled and record history for the rolling average may be lost. Changes that require no buffer reallocation and take effect immediately are

• disabling any processing step (e.g., resampling or FFT),

• reducing the window of the rolling average, and

• altering a non-empty spectral filter or resampling vector without increasing its length.

All other changes will likely require a buffer reallocation.

configCUDAProcessorConfig

New configuration to apply.

property config

Type

CUDAProcessorConfig

Copy of the current configuration.

initialize(self: vortex.process.CUDAProcessor, config: vortex.process.CUDAProcessorConfig) → None

Initialize the processor using the supplied configuration. All necessary internal buffers are allocated when this method returns.

configCUDAProcessorConfig

New configuration to apply.

next(self: vortex.process.CUDAProcessor, input_buffer: cupy.ndarray[cupy.uint16], output_buffer: cupy.ndarray[cupy.int8], id: int = 0, append_history: bool = True) → None

Process the next buffer.

input_buffercupy.ndarray[cupy.uint16]

The input buffer, with shape that matches self.config.input_shape.

output_buffercupy.ndarray[cupy.int8]

The output buffer, with shape that matches self.config.output_shape.

idint

Number to associate with the buffer for logging purposes.

append_historybool

Include the raw spectra from this input buffer in the rolling average.

next_async(self: vortex.process.CUDAProcessor, input_buffer: cupy.ndarray[cupy.uint16], output_buffer: cupy.ndarray[cupy.int8], callback: Callable[[std::exception_ptr], None], id: int = 0, append_history: bool = True) → None

Process the next buffer asynchronously and execute the callback when complete.

__CAUTION__

The callback may be executed in the calling thread before this method returns if an error occurs while queueing the background acquisition.

input_buffercupy.ndarray[cupy.uint16]

The input buffer, with shape that matches self.config.input_shape.

output_buffercupy.ndarray[cupy.int8]

The output buffer, with shape that matches self.config.output_shape.

callbackCallable[[Exception], None]

Callback to execute when buffer is processed. The callback receives as an argument any exception which occurred during processing.

idint

Number to associate with the buffer for logging purposes.

append_historybool

Include the raw spectra from this input buffer in the rolling average.

class vortex.process.CUDAProcessorConfig

Base: CPUProcessorConfig

Configuration object for CUDAProcessor.

property ascans_per_block

Type

int

Number of A-scans in each acquired buffer or block. Identical to records_per_block.

property average_window

Type

int

Length \(M\) of rolling average window in records/A-scans for background subtraction. Disable background subtraction by setting to 0. Disabled by default.

__NOTE__

Record/A-scan history includes both active and inactive records.

__WARNING__

Record/A-scan history is stored internally within the processor to allow average_window to exceed records_per_block. Create a new processor to discard this history.

property channel

Type

int

Index of channel to select for processing. Used only by engine.

__NOTE__

This property is likely to be moved from the processor configuration to the engine configuration in the future.

copy(self: vortex.process.CUDAProcessorConfig) → vortex.process.CUDAProcessorConfig

Create a copy of this configuration.

CUDAProcessorConfig

The copy.

property device

Type

int

Index of CUDA device to use for processing. Defaults to index 0.

property enable_ifft

Type

bool

Enable the FFT for OCT processing with length \(N\) determined by samples_per_ascan. When enabled, the FFT is multiplied by the normalization factor of \(1 / N\). When disabled, the squared complex magnitude is performed instead and no normalization factor is applied. Enabled by default.

__NOTE__

If FFT normalization is not desired, scale the spectral filter by \(N\) to cancel out the normalization factor.

property enable_log10

Enable the application of \(log_{10}(...)\) after the FFT. Enabled by default.

property input_shape

Type

List[int[3]]

Required shape of input buffers. Returns list of [ records_per_block, samples_per_record, 1 ]. Read-only.

property output_shape

Type

List[int[3]]

Required shape of output buffers. Returns list of [ ascans_per_block, samples_per_ascan, 1]. Read-only.

property records_per_block

Type

int

Number of records in each input buffer or block. Identical to ascans_per_block.

property resampling_samples

Type

numpy.ndarray[numpy.float32]

Optional positions at which to resample the raw spectra prior FFT. The number of resampled positions determines samples_per_record. Valid positions are in the range [0, samples_per_record]. Set to an empty array ([]) to disable resampling. Disabled by default.

property samples_per_ascan

Type

int

Number of samples per A-scan. Returns either samples_per_record or the length of resampling_samples, if the latter is available. Read-only.

property samples_per_record

Type

int

Number of samples per record.

property slots

Type

int

Number of parallel CUDA streams to use for processing. Recommended minimum is 2 slots to facilitate pipelining of successive blocks. For GPUs with sufficient compute resources, increasing the number of slots could enable parallel computation. Defaults to 2.

property spectral_filter

Type

numpy.ndarray[numpy.float32 | numpy.complex64]

Optional spectral filter to multiply with the spectra after resampling but before the FFT. Must have shape compatible with [ samples_per_ascan ]; that is, the spectral filter should match the length of the output A-scan, not the input record. Set to an empty array ([]) to disable spectral filtering. Disabled by default.

validate(self: vortex.process.CUDAProcessorConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.process.CopyProcessor

Copy data from input to output buffers with optional slicing (\(s[n]\)) and linear transformation (\(a\) and \(b\)).

\[y[i,j,k] = a + b x[i,s[j],k]\]

OCT processing is not performed. This processor is intended primarily for acquisitions that provide processed OCT data, such as AlazarFFTAcquisition. Computation is performed on the CPU.

change(self: vortex.process.CopyProcessor, config: vortex.process.CopyProcessorConfig) → None

Change the processor configuration. All configuration options may be changed, but changes to CopyProcessorConfig.slots will not have an effect.

__DANGER__

It is not safe to call this method while a block is currently processing.

configCopyProcessorConfig

New configuration to apply.

property config

Type

CopyProcessorConfig

Copy of the active configuration.

initialize(self: vortex.process.CopyProcessor, config: vortex.process.CopyProcessorConfig) → None

Initialize the processor using the supplied configuration. All necessary internal buffers are allocated when this method returns.

configCopyProcessorConfig

New configuration to apply.

next(self: vortex.process.CopyProcessor, input_buffer: numpy.ndarray[numpy.uint16], output_buffer: numpy.ndarray[numpy.int8], id: int = 0) → None

Process the next buffer.

input_buffernumpy.ndarray[numpy.uint16]

The input buffer, with shape that matches self.config.input_shape.

output_buffernumpy.ndarray[numpy.int8]

The output buffer, with shape that matches self.config.output_shape.

idint

Number to associate with the buffer for logging purposes.

next_async(self: vortex.process.CopyProcessor, input_buffer: numpy.ndarray[numpy.uint16], output_buffer: numpy.ndarray[numpy.int8], callback: Callable[[std::exception_ptr], None], id: int = 0) → None

Process the next buffer asynchronously and execute the callback when complete.

__CAUTION__

The callback may be executed in the calling thread before this method returns if an error occurs while queueing the background acquisition.

input_buffernumpy.ndarray[numpy.uint16]

The input buffer, with shape that matches self.config.input_shape.

output_buffernumpy.ndarray[numpy.int8]

The output buffer, with shape that matches self.config.output_shape.

callbackCallable[[Exception], None]

Callback to execute when buffer is processed. The callback receives as an argument any exception which occurred during processing.

idint

Number to associate with the buffer for logging purposes.

class vortex.process.CopyProcessorConfig

Base: NullProcessorConfig

Configuration object for CopyProcessor.

property ascans_per_block

Type

int

Number of A-scans in each acquired buffer or block. Identical to records_per_block.

property channel

copy(self: vortex.process.CopyProcessorConfig) → vortex.process.CopyProcessorConfig

Create a copy of this configuration.

CopyProcessorConfig

The copy.

hat{x}[i,j,k] = x[i,j,k] - frac{1}{M} sum_{l=0}^{M-1}{ x[i - l,j,k] } ,

z[i,j,k] = big(r[j] - lfloor r[j] rfloorbig) hat{x}big[i, lfloor r[j] rfloor, k big] + big(lceil r[j] rceil - r[j] big) hat{x}big[i, lceil r[j] rceil, k big] ,

y[i,j,k] = log_{10} left| frac{1}{N} mathcal{F}^{-1} big{ h[:,j,:] z[i,j,k] big} right|^2

property input_shape

Type

List[int[3]]

Required shape of input buffers. Returns list of [ records_per_block, samples_per_record, 1 ]. Read-only.

property output_shape

Type

List[int[3]]

Required shape of output buffers. Returns list of [ ascans_per_block, samples_per_ascan, 1]. Read-only.

property records_per_block

Type

int

Number of records in each input buffer or block. Identical to ascans_per_block.

property sample_slice

Type

[NullSlice | SimpleSlice]

Optional slicing operation \(s[n]\) to apply along each record/A-scan. Defaults to NullSlice().

property sample_transform

Type

[NullTransform | LinearTransform ]

Optional linear transformation \(a\) and \(b\) applied to each sample during copy. Defaults to NullTransform().

property samples_per_ascan

Type

int

Number of samples per A-scan. Returns either samples_per_record or the length of resampling_samples, if the latter is available. Read-only.

property samples_per_record

Type

int

Number of samples per record.

property slots

Type

int

Number of parallel processing pipelines. Adjust to achieve the desired CPU utilization for machines with high hardware concurrency. Recommended minimum is 2 slots to facilitate pipelining of successive blocks. The copy itself parallelized across all CPU cores; this field only affects pipeline-level parallelism. Defaults to 2.

validate(self: vortex.process.CopyProcessorConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.process.NullProcessor

Perform no processing.

This class is provided as an engine placeholder for testing or mocking. No operation is performed on the input or output buffers.

property config

Type

NullProcessorConfig

Copy of the active configuration.

initialize(self: vortex.process.NullProcessor, config: vortex.process.NullProcessorConfig) → None

class vortex.process.NullProcessorConfig

Configuration object for NullProcessor.

property ascans_per_block

Type

int

Number of A-scans in each acquired buffer or block. Identical to records_per_block.

copy(self: vortex.process.NullProcessorConfig) → vortex.process.NullProcessorConfig

Create a copy of this configuration.

NullProcessorConfig

The copy.

property input_shape

Type

List[int[3]]

Required shape of input buffers. Returns list of [ records_per_block, samples_per_record, 1 ]. Read-only.

property output_shape

Type

List[int[3]]

Required shape of output buffers. Returns list of [ ascans_per_block, samples_per_ascan, 1]. Read-only.

property records_per_block

Type

int

Number of records in each input buffer or block. Identical to ascans_per_block.

property samples_per_ascan

Type

int

Number of samples per A-scan. Returns either samples_per_record or the length of resampling_samples, if the latter is available. Read-only.

property samples_per_record

Type

int

Number of samples per record.

validate(self: vortex.process.NullProcessorConfig) → None

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.scan.FreeformScan

change(self: vortex.scan.FreeformScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::null_waypoints_t<double>, vortex::scan::manual_pattern_t<double, std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event> > >, restart: bool = False, event_id: int = 0) → None

property config

Type

SegmentedScanConfig

Copy of the active configuration. Type corresponds to the derived class.

initialize(self: vortex.scan.FreeformScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::null_waypoints_t<double>, vortex::scan::manual_pattern_t<double, std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event> > >) → None

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

New configuration to apply. Type must match the derived scan type.

next(*args, **kwargs)

Overloaded function.

1. next(self: vortex.scan.FreeformScan, buffer: numpy.ndarray[numpy.float64]) -> Tuple[int, vortex.marker.MarkerList]

2. next(self: vortex.scan.FreeformScan, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64]) -> int

prepare(*args, **kwargs)

Overloaded function.

1. prepare(self: vortex.scan.FreeformScan) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

2. prepare(self: vortex.scan.FreeformScan, count: int) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)

Overloaded function.

1. restart(self: vortex.scan.FreeformScan) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

2. restart(self: vortex.scan.FreeformScan, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64], include_start: bool) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

scan_buffer(self: vortex.scan.FreeformScan) → numpy.ndarray[numpy.float64]

Prepare the scan and return the complete scan waveform for all channels.

Returns

numpy.ndarray[float] – Scan waveforms generated at the given sampling rate. Each row is a sample, and each column is a channel.

scan_markers(self: vortex.scan.FreeformScan) → vortex.marker.MarkerList

Prepare the scan and return all markers.

Returns

List[ScanBoundary | VolumeBoundary | SegmentBoundary | ActiveLines | InactiveLines | Event] – List of all markers in the scan, sorted by sequence number.

scan_segments(self: vortex.scan.FreeformScan) → List[vortex.scan.Segment]

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.FreeformScanConfig

Base: SegmentedScanConfig

Configuration object for FreeformScan.

property bypass_limits_check

Type

bool

If False, check that the scan pattern satisfies position, velocity, and acceleration limits. If True, skip this check. This check does not apply to generated inactive segments. Default is False.

property channels_per_sample

Type

int

Number of channels per sample. Default is 2 for a 2D scan pattern.

property consolidate

Type

bool

Optimize internal scan buffers once the scan has looped once. Default is False.

copy(self: vortex.scan.FreeformScanConfig) → vortex.scan.FreeformScanConfig

property inactive_policy

Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

Policy to use for generating inactive segments. Default is MinimumDynamicLimited().

property limits

Type

List[Limits]

Dynamics limits for each channel of the scan. These are used for limit checks and inactive segment policies. Default is [Limits(position=(-12.5, 12.5), velocity=8e3, acceleration=5e6)]*2.

property loop

Type

bool

Restart the scan after it completes. This produces an infinite scan pattern. Default is True.

property pattern

property samples_per_second

Type

int

Number of samples per second for the scan. This is used to ensure that dynamic limits are met. Default is 100_000.

property sampling_interval

Type

float

Interval between samples computed from samples_per_second. Read-only.

to_segments(self: vortex.scan.FreeformScanConfig) → List[vortex.scan.Segment]

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

class vortex.scan.Limits

Dynamics limits for a single axis.

property acceleration

Type

float

Absolute value of velocity limit.

copy(self: vortex.scan.Limits) → vortex.scan.Limits

property position

Type

Range

Upper and lower positions bounds.

property velocity

Type

float

Absolute value of velocity limit.

class vortex.scan.RadialScan

change(self: vortex.scan.RadialScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::radial_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >, restart: bool = False, event_id: int = 0) → None

property config

Type

SegmentedScanConfig

Copy of the active configuration. Type corresponds to the derived class.

initialize(self: vortex.scan.RadialScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::radial_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >) → None

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

New configuration to apply. Type must match the derived scan type.

next(*args, **kwargs)

Overloaded function.

1. next(self: vortex.scan.RadialScan, buffer: numpy.ndarray[numpy.float64]) -> Tuple[int, vortex.marker.MarkerList]

2. next(self: vortex.scan.RadialScan, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64]) -> int

prepare(*args, **kwargs)

Overloaded function.

1. prepare(self: vortex.scan.RadialScan) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

2. prepare(self: vortex.scan.RadialScan, count: int) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)

Overloaded function.

1. restart(self: vortex.scan.RadialScan) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

2. restart(self: vortex.scan.RadialScan, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64], include_start: bool) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

scan_buffer(self: vortex.scan.RadialScan) → numpy.ndarray[numpy.float64]

Prepare the scan and return the complete scan waveform for all channels.

Returns

numpy.ndarray[float] – Scan waveforms generated at the given sampling rate. Each row is a sample, and each column is a channel.

scan_markers(self: vortex.scan.RadialScan) → vortex.marker.MarkerList

Prepare the scan and return all markers.

Returns

List[ScanBoundary | VolumeBoundary | SegmentBoundary | ActiveLines | InactiveLines | Event] – List of all markers in the scan, sorted by sequence number.

scan_segments(self: vortex.scan.RadialScan) → List[vortex.scan.Segment]

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RadialScanConfig

Bases: RadialWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RadialScan.

All members are inherited.

property angle

property ascans_per_bscan

property bidirectional_segments

property bidirectional_volumes

property bscan_extent

property bscans_per_volume

property bypass_limits_check

Type

bool

If False, check that the scan pattern satisfies position, velocity, and acceleration limits. If True, skip this check. This check does not apply to generated inactive segments. Default is False.

property channels_per_sample

Type

int

Number of channels per sample. Default is 2 for a 2D scan pattern.

property consolidate

Type

bool

Optimize internal scan buffers once the scan has looped once. Default is False.

copy(*args, **kwargs)

Overloaded function.

1. copy(self: vortex.scan.RadialScanConfig) -> vortex.scan.RadialScanConfig

2. copy(self: vortex.scan.RadialScanConfig) -> vortex.scan.RadialScanConfig

property extents

property flags

property inactive_policy

Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

Policy to use for generating inactive segments. Default is MinimumDynamicLimited().

property limits

Type

List[Limits]

Dynamics limits for each channel of the scan. These are used for limit checks and inactive segment policies. Default is [Limits(position=(-12.5, 12.5), velocity=8e3, acceleration=5e6)]*2.

property loop

Type

bool

Restart the scan after it completes. This produces an infinite scan pattern. Default is True.

property offset

property samples_per_second

Type

int

Number of samples per second for the scan. This is used to ensure that dynamic limits are met. Default is 100_000.

property samples_per_segment

property sampling_interval

Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent

property segments_per_volume

set_aiming(self: vortex.scan.RadialScanConfig) → None

set_evenly_spaced(self: vortex.scan.RadialScanConfig, arg0: int) → None

set_half_evenly_spaced(self: vortex.scan.RadialScanConfig, arg0: int) → None

property shape

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.RadialScanConfig, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.RadialScanConfig, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

to_segments(self: vortex.scan.RadialScanConfig) → List[vortex.scan.Segment]

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RadialScanConfig) → numpy.ndarray[numpy.float64]

property volume_extent

property warp

class vortex.scan.RadialWaypoints

Base: XYWaypoints

Generate waypoints on a \(n \times m\) polar grid with \(n\) segments per volume and \(m\) samples per segment. The volume direction is along the positive the \(\theta\)-axis whereas the segment or B-scan direction is along the positive \(r\)-axis. The physical extents of the waypoints have no required units and may be interpreted as linear (e.g., millimeters) or angular (e.g., radians or degrees). The waypoint positions \(W_{ij} = (x_i, y_j)\) as described mathematically below.

\[\begin{split}\begin{align} u_i &= \left(\frac{i}{n - 1}\right) \theta_\mathrm{min} + \left(1 - \frac{i}{n-1}\right) \theta_\mathrm{max} & v_j &= \left(\frac{j}{m - 1}\right) r_\mathrm{min} + \left(1 - \frac{j}{m-1}\right) r_\mathrm{max} \\ x_i &= v_i \cos ( u_i + \theta ) + x_o & y_j &= v_j \sin ( u_j + \theta ) + y_o \end{align}\end{split}\]

The parameters that define \(W_{ij}\) are adjusted via the the following properties and those inherited from XYWaypoints.

property angle

Type

float

Counter-clockwise rotation \(\theta\) about the scan origin (offset) in radians. Default is 0.

property ascans_per_bscan

Type

int

Alias for samples_per_segment

property bscan_extent

Type

Range

Alias for segment_extent.

property bscans_per_volume

Type

int

Alias for segments_per_volume.

property extents

Type

list[Range]

Scan extents as [volume_extent, segment_extent].

property offset

Type

tuple[float]

Offset \((x_o, y_o)\) of the scan origin in \(x\) and \(y\), respectively. Default is (0, 0).

property samples_per_segment

Type

int

Number of samples \(m\) within each segment. Default is 100.

property segment_extent

Type

Range

Unitless minimum \(r_\mathrm{min}\) and maximum \(r_\mathrm{max}\) position of each segment. To flip the segment direction, set a negative maximum and a positive minimum. No requirement for symmetry. Default is Range(-2, 2).

property segments_per_volume

Type

int

Number of segments \(n\) in each volume. Default is 100.

set_aiming(self: vortex.scan.RadialWaypoints) → None

Adjust volume_extent and segments_per_volume to yield two orthogonal segments. Internally calls set_half_evenly_spaced() with n = 2.

set_evenly_spaced(self: vortex.scan.RadialWaypoints, arg0: int) → None

Adjust volume_extent and segments_per_volume yield n evenly spaced segments over 360 degrees, omitting the final segment.

nint

Number of segments to use.

set_half_evenly_spaced(self: vortex.scan.RadialWaypoints, arg0: int) → None

Adjust volume_extent and segments_per_volume yield n evenly spaced segments over 180 degrees, omitting the final segment. For segments that span the origin, this yields a scan that covers the full circle without overlap.

nint

Number of segments to use.

property shape

Type

list[int]

Scan shape as [segments_per_volume, samples_per_segment].

to_waypoints(self: vortex.scan.RadialWaypoints) → numpy.ndarray[numpy.float64]

Generate an \(n \times m \times 2\) grid of waypoints \(W_{ij} = (x_i, y_i)\) for \(i \in [0, n-1]\) and \(j \in [0, m-1]\). The specific waypoint positions are determined by the base class.

Returns

numpy.ndarray[numpy.float64] – The waypoints 3D array with shape [segments_per_volume, samples_per_segment, 2], where the channels are \(x\) and \(y\) positions.

property volume_extent

Type

Range

Unitless minimum \(\theta_\mathrm{min}\) and maximum \(\theta_\mathrm{max}\) position of each volume. To flip the volume direction, set a negative maximum and a positive minimum. No requirement for symmetry. Default is Range(0, pi).

property warp

Type

[NoWarp | AngularWarp | TelecentricWarp]

Warp to apply to waypoints, which may transform the units of the scan waypoints. Default is NoWarp().

class vortex.scan.RasterScan

change(self: vortex.scan.RasterScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::raster_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >, restart: bool = False, event_id: int = 0) → None

property config

Type

SegmentedScanConfig

Copy of the active configuration. Type corresponds to the derived class.

initialize(self: vortex.scan.RasterScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::raster_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >) → None

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

New configuration to apply. Type must match the derived scan type.

next(*args, **kwargs)

Overloaded function.

1. next(self: vortex.scan.RasterScan, buffer: numpy.ndarray[numpy.float64]) -> Tuple[int, vortex.marker.MarkerList]

2. next(self: vortex.scan.RasterScan, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64]) -> int

prepare(*args, **kwargs)

Overloaded function.

1. prepare(self: vortex.scan.RasterScan) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

2. prepare(self: vortex.scan.RasterScan, count: int) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)

Overloaded function.

1. restart(self: vortex.scan.RasterScan) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

2. restart(self: vortex.scan.RasterScan, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64], include_start: bool) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

scan_buffer(self: vortex.scan.RasterScan) → numpy.ndarray[numpy.float64]

Prepare the scan and return the complete scan waveform for all channels.

Returns

numpy.ndarray[float] – Scan waveforms generated at the given sampling rate. Each row is a sample, and each column is a channel.

scan_markers(self: vortex.scan.RasterScan) → vortex.marker.MarkerList

Prepare the scan and return all markers.

Returns

List[ScanBoundary | VolumeBoundary | SegmentBoundary | ActiveLines | InactiveLines | Event] – List of all markers in the scan, sorted by sequence number.

scan_segments(self: vortex.scan.RasterScan) → List[vortex.scan.Segment]

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RasterScanConfig

Bases: RasterWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RasterScan.

All members are inherited.

property angle

property ascans_per_bscan

property bidirectional_segments

property bidirectional_volumes

property bscan_extent

property bscans_per_volume

property bypass_limits_check

Type

bool

If False, check that the scan pattern satisfies position, velocity, and acceleration limits. If True, skip this check. This check does not apply to generated inactive segments. Default is False.

property channels_per_sample

Type

int

Number of channels per sample. Default is 2 for a 2D scan pattern.

property consolidate

Type

bool

Optimize internal scan buffers once the scan has looped once. Default is False.

copy(*args, **kwargs)

Overloaded function.

1. copy(self: vortex.scan.RasterScanConfig) -> vortex.scan.RasterScanConfig

2. copy(self: vortex.scan.RasterScanConfig) -> vortex.scan.RasterScanConfig

property extents

property flags

property inactive_policy

Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

Policy to use for generating inactive segments. Default is MinimumDynamicLimited().

property limits

Type

List[Limits]

Dynamics limits for each channel of the scan. These are used for limit checks and inactive segment policies. Default is [Limits(position=(-12.5, 12.5), velocity=8e3, acceleration=5e6)]*2.

property loop

Type

bool

Restart the scan after it completes. This produces an infinite scan pattern. Default is True.

property offset

property samples_per_second

Type

int

Number of samples per second for the scan. This is used to ensure that dynamic limits are met. Default is 100_000.

property samples_per_segment

property sampling_interval

Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent

property segments_per_volume

property shape

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.RasterScanConfig, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.RasterScanConfig, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

to_segments(self: vortex.scan.RasterScanConfig) → List[vortex.scan.Segment]

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RasterScanConfig) → numpy.ndarray[numpy.float64]

property volume_extent

property warp

class vortex.scan.RasterWaypoints

Base: XYWaypoints

Generate waypoints on a \(n \times m\) rectangular grid with \(n\) segments per volume and \(m\) samples per segment. The volume direction is along the positive the \(x\)-axis whereas the segment or B-scan direction is along the positive \(y\)-axis. The physical extents of the waypoints have no required units and may be interpreted as linear (e.g., millimeters) or angular (e.g., radians or degrees). The waypoint positions \(W_{ij} = (x_i, y_j)\) as described mathematically below.

\[\begin{split}\begin{align} u_i &= \left(\frac{i}{n - 1}\right) x_\mathrm{min} + \left(1 - \frac{i}{n-1}\right) x_\mathrm{max} & v_j &= \left(\frac{j}{m - 1}\right) y_\mathrm{min} + \left(1 - \frac{j}{m-1}\right) y_\mathrm{max} \\ x_i &= u_i \cos \theta - v_i \sin \theta + x_o & y_j &= u_j \sin \theta + v_j \cos \theta + y_o \end{align}\end{split}\]

The parameters that define \(W_{ij}\) are adjusted via the the following properties and those inherited from XYWaypoints.

property angle

Type

float

Counter-clockwise rotation \(\theta\) about the scan origin (offset) in radians. Default is 0.

property ascans_per_bscan

Type

int

Alias for samples_per_segment

property bscan_extent

Type

Range

Alias for segment_extent.

property bscans_per_volume

Type

int

Alias for segments_per_volume.

property extents

Type

list[Range]

Scan extents as [volume_extent, segment_extent].

property offset

Type

tuple[float]

Offset \((x_o, y_o)\) of the scan origin in \(x\) and \(y\), respectively. Default is (0, 0).

property samples_per_segment

Type

int

Number of samples \(m\) within each segment. Default is 100.

property segment_extent

Type

Range

Unitless minimum \(y_\mathrm{min}\) and maximum \(y_\mathrm{max}\) position of each segment. To flip the segment direction, set a negative maximum and a positive minimum. No requirement for symmetry. Default is Range(-2, 2).

property segments_per_volume

Type

int

Number of segments \(n\) in each volume. Default is 100.

property shape

Type

list[int]

Scan shape as [segments_per_volume, samples_per_segment].

to_waypoints(self: vortex.scan.RasterWaypoints) → numpy.ndarray[numpy.float64]

Generate an \(n \times m \times 2\) grid of waypoints \(W_{ij} = (x_i, y_i)\) for \(i \in [0, n-1]\) and \(j \in [0, m-1]\). The specific waypoint positions are determined by the base class.

Returns

numpy.ndarray[numpy.float64] – The waypoints 3D array with shape [segments_per_volume, samples_per_segment, 2], where the channels are \(x\) and \(y\) positions.

property volume_extent

Type

Range

Unitless minimum \(x_\mathrm{min}\) and maximum \(x_\mathrm{max}\) position of each volume. To flip the volume direction, set a negative maximum and a positive minimum. No requirement for symmetry. Default is Range(-1, 1).

property warp

Type

[NoWarp | AngularWarp | TelecentricWarp]

Warp to apply to waypoints, which may transform the units of the scan waypoints. Default is NoWarp().

class vortex.scan.RepeatFlags

copy(self: vortex.scan.RepeatFlags) → vortex.scan.RepeatFlags

property flags

class vortex.scan.RepeatOrder

copy(self: vortex.scan.RepeatOrder) → vortex.scan.RepeatOrder

property flags

class vortex.scan.RepeatPack

copy(self: vortex.scan.RepeatPack) → vortex.scan.RepeatPack

property flags

class vortex.scan.RepeatedPattern

Repeat segments with specified repetition count and period.

property bidirectional_segments

Type

bool

If True, flip the direction of every odd-indexed segment. Odd-indexed segments are marked as reversed for unflipping during formatting. If False, maintain the direction of each segment. Default is False.

__CAUTION__

An odd repeat period will cause repetitions of a given segment to alternate directions.

__SEEALSO__

See Repeated Scan with Bidirectional Segments for an example.

copy(self: vortex.scan.RepeatedPattern) → vortex.scan.RepeatedPattern

property repeat_count

Type

int

Number of times to repeat each segment. Default is 3.

property repeat_period

Type

int

Number of segments to execute in order before repeating. Default is 2.

property repeat_strategy

Type

[RepeatOrder | RepeatPack | RepeatFlags]

The strategy for handling repeated segments in memory.

• RepeatOrder: Scan is performed ABCABCABC and is stored in memory as ABCABCABC.

• RepeatPack: Scan is performed ABCABCABC but is stored in memory as AAABBBCCC.

• RepeatFlags: Each repeat is marked with different flags, allowing the user to route them to different processing.

Default is RepeatPack().

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.RepeatedPattern, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.RepeatedPattern, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

class vortex.scan.RepeatedRadialScan

change(self: vortex.scan.RepeatedRadialScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::radial_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::repeated_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >, restart: bool = False, event_id: int = 0) → None

property config

Type

SegmentedScanConfig

Copy of the active configuration. Type corresponds to the derived class.

initialize(self: vortex.scan.RepeatedRadialScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::radial_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::repeated_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >) → None

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

New configuration to apply. Type must match the derived scan type.

next(*args, **kwargs)

Overloaded function.

1. next(self: vortex.scan.RepeatedRadialScan, buffer: numpy.ndarray[numpy.float64]) -> Tuple[int, vortex.marker.MarkerList]

2. next(self: vortex.scan.RepeatedRadialScan, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64]) -> int

prepare(*args, **kwargs)

Overloaded function.

1. prepare(self: vortex.scan.RepeatedRadialScan) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

2. prepare(self: vortex.scan.RepeatedRadialScan, count: int) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)

Overloaded function.

1. restart(self: vortex.scan.RepeatedRadialScan) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

2. restart(self: vortex.scan.RepeatedRadialScan, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64], include_start: bool) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

scan_buffer(self: vortex.scan.RepeatedRadialScan) → numpy.ndarray[numpy.float64]

Prepare the scan and return the complete scan waveform for all channels.

Returns

numpy.ndarray[float] – Scan waveforms generated at the given sampling rate. Each row is a sample, and each column is a channel.

scan_markers(self: vortex.scan.RepeatedRadialScan) → vortex.marker.MarkerList

Prepare the scan and return all markers.

Returns

List[ScanBoundary | VolumeBoundary | SegmentBoundary | ActiveLines | InactiveLines | Event] – List of all markers in the scan, sorted by sequence number.

scan_segments(self: vortex.scan.RepeatedRadialScan) → List[vortex.scan.Segment]

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RepeatedRadialScanConfig

Bases: RepeatedRadialWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RepeatedRadialScan.

All members are inherited.

property angle

property ascans_per_bscan

property bidirectional_segments

property bscan_extent

property bscans_per_volume

property bypass_limits_check

Type

bool

If False, check that the scan pattern satisfies position, velocity, and acceleration limits. If True, skip this check. This check does not apply to generated inactive segments. Default is False.

property channels_per_sample

Type

int

Number of channels per sample. Default is 2 for a 2D scan pattern.

property consolidate

Type

bool

Optimize internal scan buffers once the scan has looped once. Default is False.

copy(*args, **kwargs)

Overloaded function.

1. copy(self: vortex.scan.RepeatedRadialScanConfig) -> vortex.scan.RepeatedRadialScanConfig

2. copy(self: vortex.scan.RepeatedRadialScanConfig) -> vortex.scan.RepeatedRadialScanConfig

property extents

property inactive_policy

Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

Policy to use for generating inactive segments. Default is MinimumDynamicLimited().

property limits

Type

List[Limits]

Dynamics limits for each channel of the scan. These are used for limit checks and inactive segment policies. Default is [Limits(position=(-12.5, 12.5), velocity=8e3, acceleration=5e6)]*2.

property loop

Type

bool

Restart the scan after it completes. This produces an infinite scan pattern. Default is True.

property offset

property repeat_count

property repeat_period

property repeat_strategy

property samples_per_second

Type

int

Number of samples per second for the scan. This is used to ensure that dynamic limits are met. Default is 100_000.

property samples_per_segment

property sampling_interval

Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent

property segments_per_volume

set_aiming(self: vortex.scan.RepeatedRadialScanConfig) → None

set_evenly_spaced(self: vortex.scan.RepeatedRadialScanConfig, arg0: int) → None

set_half_evenly_spaced(self: vortex.scan.RepeatedRadialScanConfig, arg0: int) → None

property shape

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.RepeatedRadialScanConfig, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.RepeatedRadialScanConfig, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

to_segments(self: vortex.scan.RepeatedRadialScanConfig) → List[vortex.scan.Segment]

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RepeatedRadialScanConfig) → numpy.ndarray[numpy.float64]

property volume_extent

property warp

class vortex.scan.RepeatedRasterScan

change(self: vortex.scan.RepeatedRasterScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::raster_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::repeated_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >, restart: bool = False, event_id: int = 0) → None

property config

Type

SegmentedScanConfig

Copy of the active configuration. Type corresponds to the derived class.

initialize(self: vortex.scan.RepeatedRasterScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::raster_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::repeated_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >) → None

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

New configuration to apply. Type must match the derived scan type.

next(*args, **kwargs)

Overloaded function.

1. next(self: vortex.scan.RepeatedRasterScan, buffer: numpy.ndarray[numpy.float64]) -> Tuple[int, vortex.marker.MarkerList]

2. next(self: vortex.scan.RepeatedRasterScan, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64]) -> int

prepare(*args, **kwargs)

Overloaded function.

1. prepare(self: vortex.scan.RepeatedRasterScan) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

2. prepare(self: vortex.scan.RepeatedRasterScan, count: int) -> None

Buffer and consolidate the complete scan for rapid generation. If count is specified, buffer at minimum the requested number of samples. Otherwise, buffer the complete scan. Consolidation will be performed if enabled and the scan becomes fully buffered.

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)

Overloaded function.

1. restart(self: vortex.scan.RepeatedRasterScan) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

2. restart(self: vortex.scan.RepeatedRasterScan, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64], include_start: bool) -> None

Reset the scan internal state to the given sample, position, and velocity. Subsequent calls for pattern generation will include a pre-scan inactive segment from this state to the first active segment.

__NOTE__

Specify no arguments or all arguments. If no arguments are specified, the scan resets to the origin at rest.

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

If True, generate a sample at this new state. If False, do not generate a starting sample, such as when another scan has already produced it.

scan_buffer(self: vortex.scan.RepeatedRasterScan) → numpy.ndarray[numpy.float64]

Prepare the scan and return the complete scan waveform for all channels.

Returns

numpy.ndarray[float] – Scan waveforms generated at the given sampling rate. Each row is a sample, and each column is a channel.

scan_markers(self: vortex.scan.RepeatedRasterScan) → vortex.marker.MarkerList

Prepare the scan and return all markers.

Returns

List[ScanBoundary | VolumeBoundary | SegmentBoundary | ActiveLines | InactiveLines | Event] – List of all markers in the scan, sorted by sequence number.

scan_segments(self: vortex.scan.RepeatedRasterScan) → List[vortex.scan.Segment]

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RepeatedRasterScanConfig

Bases: RasterWaypoints, RepeatedPattern, SegmentedScanConfig

Configuration object for RepeatedRasterScan.

All members are inherited.

property angle

property ascans_per_bscan

property bidirectional_segments

property bscan_extent

property bscans_per_volume

property bypass_limits_check

Type

bool

If False, check that the scan pattern satisfies position, velocity, and acceleration limits. If True, skip this check. This check does not apply to generated inactive segments. Default is False.

property channels_per_sample

Type

int

Number of channels per sample. Default is 2 for a 2D scan pattern.

property consolidate

Type

bool

Optimize internal scan buffers once the scan has looped once. Default is False.

copy(*args, **kwargs)

Overloaded function.

1. copy(self: vortex.scan.RepeatedRasterScanConfig) -> vortex.scan.RepeatedRasterScanConfig

2. copy(self: vortex.scan.RepeatedRasterScanConfig) -> vortex.scan.RepeatedRasterScanConfig

property extents

property inactive_policy

Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

Policy to use for generating inactive segments. Default is MinimumDynamicLimited().

property limits

Type

List[Limits]

Dynamics limits for each channel of the scan. These are used for limit checks and inactive segment policies. Default is [Limits(position=(-12.5, 12.5), velocity=8e3, acceleration=5e6)]*2.

property loop

Type

bool

Restart the scan after it completes. This produces an infinite scan pattern. Default is True.

property offset

property repeat_count

property repeat_period

property repeat_strategy

property samples_per_second

Type

int

Number of samples per second for the scan. This is used to ensure that dynamic limits are met. Default is 100_000.

property samples_per_segment

property sampling_interval

Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent

property segments_per_volume

property shape

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.RepeatedRasterScanConfig, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.RepeatedRasterScanConfig, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

to_segments(self: vortex.scan.RepeatedRasterScanConfig) → List[vortex.scan.Segment]

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RepeatedRasterScanConfig) → numpy.ndarray[numpy.float64]

property volume_extent

property warp

class vortex.scan.Segment

An active segment as part of a SegmentedScan.

copy(self: vortex.scan.Segment) → vortex.scan.Segment

property entry_position

Type

numpy.ndarray[float]

Accessor for the first sample position. Read only.

entry_velocity(self: vortex.scan.Segment, samples_per_second: int) → numpy.ndarray[numpy.float64]

Approximate the scan velocity at the first sample using the specified sampling rate and the first finite difference.

samples_per_secondfloat

Sampling rate for the velocity calculation.

Returns

numpy.ndarray[float] – The calculated velocity.

property exit_position

Type

numpy.ndarray[float]

Accessor for the last sample position. Read only.

exit_velocity(self: vortex.scan.Segment, samples_per_second: int) → numpy.ndarray[numpy.float64]

Approximate the scan velocity at the last sample using the specified sampling rate and the first finite difference.

samples_per_secondfloat

Sampling rate for the velocity calculation.

Returns

numpy.ndarray[float] – The calculated velocity.

property markers

Type

List[ScanBoundary | VolumeBoundary | SegmentBoundary | ActiveLines | InactiveLines | Event]

List of markers associated with this segment.

property position

Type

numpy.ndarray[float]

An ordered sequence of each sample positions in this segment. The positions are specified as a 2D array where each row is a position and each column is a channel. For example, a 2D segment with N positions has shape [N, 2]. The number of channels must match that of the associated SegmentedScan.

class vortex.scan.SegmentList

append(self: List[vortex.scan.Segment], x: vortex.scan.Segment) → None

Add an item to the end of the list

clear(self: List[vortex.scan.Segment]) → None

Clear the contents

extend(*args, **kwargs)

Overloaded function.

1. extend(self: List[vortex.scan.Segment], L: List[vortex.scan.Segment]) -> None

Extend the list by appending all the items in the given list

2. extend(self: List[vortex.scan.Segment], L: Iterable) -> None

Extend the list by appending all the items in the given list

insert(self: List[vortex.scan.Segment], i: int, x: vortex.scan.Segment) → None

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

1. pop(self: List[vortex.scan.Segment]) -> vortex.scan.Segment

Remove and return the last item

2. pop(self: List[vortex.scan.Segment], i: int) -> vortex.scan.Segment

Remove and return the item at index i

class vortex.scan.SequentialPattern

Visit segments in sequential order with optional bidirectionality.

property bidirectional_segments

Type

bool

If True, flip the direction of every odd-indexed segment. Odd-indexed segments are marked as reversed for unflipping during formatting. If False, maintain the direction of each segment. Default is False.

property bidirectional_volumes

Type

bool

If True, produce a scan with one volume with the segments in order followed by a second volume using the reverse segment order. The second volume’s segments are marked with the physically-based destination index for reordering during formatting. If False, produce a scan with one volume with he segments in order. Default is False.

copy(self: vortex.scan.SequentialPattern) → vortex.scan.SequentialPattern

property flags

Type

Flags

The flags to apply to these segments. Default is Flags().

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.SequentialPattern, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.SequentialPattern, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

class vortex.scan.SpiralScan

change(self: vortex.scan.SpiralScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::spiral_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >, restart: bool = False, event_id: int = 0) → None

property config

initialize(self: vortex.scan.SpiralScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::spiral_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >) → None

next(*args, **kwargs)

Overloaded function.

1. next(self: vortex.scan.SpiralScan, buffer: numpy.ndarray[numpy.float64]) -> Tuple[int, vortex.marker.MarkerList]

2. next(self: vortex.scan.SpiralScan, markers: vortex.marker.MarkerList, buffer: numpy.ndarray[numpy.float64]) -> int

prepare(*args, **kwargs)

Overloaded function.

1. prepare(self: vortex.scan.SpiralScan) -> None

2. prepare(self: vortex.scan.SpiralScan, count: int) -> None

restart(*args, **kwargs)

Overloaded function.

1. restart(self: vortex.scan.SpiralScan) -> None

2. restart(self: vortex.scan.SpiralScan, sample: int, position: numpy.ndarray[numpy.float64], velocity: numpy.ndarray[numpy.float64], include_start: bool) -> None

scan_buffer(self: vortex.scan.SpiralScan) → numpy.ndarray[numpy.float64]

scan_markers(self: vortex.scan.SpiralScan) → vortex.marker.MarkerList

scan_segments(self: vortex.scan.SpiralScan) → List[vortex.scan.Segment]

class vortex.scan.SpiralScanConfig

property acceleration_limit

property angle

property angular_velocity

property ascans_per_bscan

property bidirectional_segments

property bidirectional_volumes

property bscan_extent

property bscans_per_volume

property bypass_limits_check

property channels_per_sample

property consolidate

copy(*args, **kwargs)

Overloaded function.

1. copy(self: vortex.scan.SpiralScanConfig) -> vortex.scan.SpiralScanConfig

2. copy(self: vortex.scan.SpiralScanConfig) -> vortex.scan.SpiralScanConfig

property extents

property flags

property inactive_policy

property inner_radius

property limits

property linear_velocity

property loop

property offset

property outer_radius

property radial_pitch

property rings_per_spiral

property samples_per_second

property samples_per_segment

property sampling_interval

property segment_extent

property segments_per_volume

set_hybrid(self: vortex.scan.SpiralScanConfig, arg0: int) → None

set_isotropic(self: vortex.scan.SpiralScanConfig, arg0: int) → None

property shape

to_pattern(*args, **kwargs)

Overloaded function.

1. to_pattern(self: vortex.scan.SpiralScanConfig, arg0: numpy.ndarray[numpy.float64]) -> List[vortex.scan.Segment]

2. to_pattern(self: vortex.scan.SpiralScanConfig, arg0: List[numpy.ndarray[numpy.float64]]) -> List[vortex.scan.Segment]

to_segments(self: vortex.scan.SpiralScanConfig) → List[vortex.scan.Segment]

to_waypoints(self: vortex.scan.SpiralScanConfig) → numpy.ndarray[numpy.float64]

property volume_extent

property warp

class vortex.scan.SpiralWaypoints

property acceleration_limit

property angle

property angular_velocity

property ascans_per_bscan

property bscan_extent

property bscans_per_volume

property extents

property inner_radius

property linear_velocity

property offset

property outer_radius

property radial_pitch

property rings_per_spiral

property samples_per_segment

property segment_extent

property segments_per_volume

set_hybrid(self: vortex.scan.SpiralWaypoints, arg0: int) → None

set_isotropic(self: vortex.scan.SpiralWaypoints, arg0: int) → None

property shape

to_waypoints(self: vortex.scan.SpiralWaypoints) → numpy.ndarray[numpy.float64]

property volume_extent

property warp

class vortex.storage.BroctScan

Members:

rectangular

bscan

aiming

mscan

radial

ascan

speckle

mixed

xfast_yfast

xfast_yfast_speckle

spiral

aiming = <BroctScan.aiming: 2>

ascan = <BroctScan.ascan: 5>

bscan = <BroctScan.bscan: 1>

mixed = <BroctScan.mixed: 7>

mscan = <BroctScan.mscan: 3>

property name

radial = <BroctScan.radial: 4>

rectangular = <BroctScan.rectangular: 0>

speckle = <BroctScan.speckle: 6>

spiral = <BroctScan.spiral: 10>

property value

xfast_yfast = <BroctScan.xfast_yfast: 8>

xfast_yfast_speckle = <BroctScan.xfast_yfast_speckle: 9>

class vortex.storage.BroctStorage

advance_volume(self: vortex.storage.BroctStorage, allocate: bool = True) → None

close(self: vortex.storage.BroctStorage) → None

property config

open(self: vortex.storage.BroctStorage, arg0: vortex::storage::broct_storage_config_t) → None

seek(self: vortex.storage.BroctStorage, arg0: int, arg1: int) → None

write_bscan(self: vortex.storage.BroctStorage, index: int, data: numpy.ndarray[numpy.int8]) → None

write_multi_bscan(self: vortex.storage.BroctStorage, index: int, data: numpy.ndarray[numpy.int8]) → None

write_volume(self: vortex.storage.BroctStorage, data: numpy.ndarray[numpy.int8]) → None

class vortex.storage.BroctStorageConfig

property ascans_per_bscan

property broct_bscan_shape

property broct_volume_shape

property bscans_per_volume

property buffering

copy(self: vortex.storage.BroctStorageConfig) → vortex.storage.BroctStorageConfig

property dimensions

property notes

property path

property samples_per_ascan

property scan_type

property shape

class vortex.storage.HDF5StackConfig

property ascans_per_bscan

property bscan_shape

property bscans_per_volume

property channels_per_sample

property compression_level

copy(self: vortex.storage.HDF5StackConfig) → vortex.storage.HDF5StackConfig

property header

property path

property samples_per_ascan

property shape

property volume_shape

class vortex.storage.HDF5StackFloat64

advance_volume(self: vortex.storage.HDF5StackFloat64, allocate: bool = True) → None

close(self: vortex.storage.HDF5StackFloat64) → None

property config

open(self: vortex.storage.HDF5StackFloat64, arg0: vortex.storage.HDF5StackConfig) → None

property ready

write_multi_bscan(self: vortex.storage.HDF5StackFloat64, index: int, data: numpy.ndarray[numpy.float64]) → None

write_partial_bscan(self: vortex.storage.HDF5StackFloat64, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.float64]) → None

write_volume(self: vortex.storage.HDF5StackFloat64, data: numpy.ndarray[numpy.float64]) → None

class vortex.storage.HDF5StackHeader

Members:

Empty

MATLAB

Empty = <HDF5StackHeader.Empty: 0>

MATLAB = <HDF5StackHeader.MATLAB: 1>

property name

property value

class vortex.storage.HDF5StackInt8

advance_volume(self: vortex.storage.HDF5StackInt8, allocate: bool = True) → None

close(self: vortex.storage.HDF5StackInt8) → None

property config

open(self: vortex.storage.HDF5StackInt8, arg0: vortex.storage.HDF5StackConfig) → None

property ready

write_multi_bscan(self: vortex.storage.HDF5StackInt8, index: int, data: numpy.ndarray[numpy.int8]) → None

write_partial_bscan(self: vortex.storage.HDF5StackInt8, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.int8]) → None

write_volume(self: vortex.storage.HDF5StackInt8, data: numpy.ndarray[numpy.int8]) → None

class vortex.storage.HDF5StackUInt16

advance_volume(self: vortex.storage.HDF5StackUInt16, allocate: bool = True) → None

close(self: vortex.storage.HDF5StackUInt16) → None

property config

open(self: vortex.storage.HDF5StackUInt16, arg0: vortex.storage.HDF5StackConfig) → None

property ready

write_multi_bscan(self: vortex.storage.HDF5StackUInt16, index: int, data: numpy.ndarray[numpy.uint16]) → None

write_partial_bscan(self: vortex.storage.HDF5StackUInt16, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.uint16]) → None

write_volume(self: vortex.storage.HDF5StackUInt16, data: numpy.ndarray[numpy.uint16]) → None

class vortex.storage.HDF5StackUInt64

advance_volume(self: vortex.storage.HDF5StackUInt64, allocate: bool = True) → None

close(self: vortex.storage.HDF5StackUInt64) → None

property config

open(self: vortex.storage.HDF5StackUInt64, arg0: vortex.storage.HDF5StackConfig) → None

property ready

write_multi_bscan(self: vortex.storage.HDF5StackUInt64, index: int, data: numpy.ndarray[numpy.uint64]) → None

write_partial_bscan(self: vortex.storage.HDF5StackUInt64, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.uint64]) → None

write_volume(self: vortex.storage.HDF5StackUInt64, data: numpy.ndarray[numpy.uint64]) → None

class vortex.storage.MarkerLog

close(self: vortex.storage.MarkerLog) → None

property config

open(self: vortex.storage.MarkerLog, arg0: vortex::storage::marker_log_config_t) → None

write(self: vortex.storage.MarkerLog, arg0: List[Union[vortex.marker.ScanBoundary, vortex.marker.VolumeBoundary, vortex.marker.SegmentBoundary, vortex.marker.ActiveLines, vortex.marker.InactiveLines, vortex.marker.Event]]) → None

class vortex.storage.MarkerLogConfig

property binary

property buffering

copy(self: vortex.storage.MarkerLogConfig) → vortex.storage.MarkerLogConfig

property path

class vortex.storage.SimpleStackConfig

property ascans_per_bscan

property bscan_shape

property bscans_per_volume

property buffering

copy(self: vortex.storage.SimpleStackConfig) → vortex.storage.SimpleStackConfig

property header

property path

property samples_per_ascan

property shape

property volume_shape

class vortex.storage.SimpleStackFloat64

advance_volume(self: vortex.storage.SimpleStackFloat64, allocate: bool = True) → None

close(self: vortex.storage.SimpleStackFloat64) → None

property config

open(self: vortex.storage.SimpleStackFloat64, arg0: vortex.storage.SimpleStackConfig) → None

property ready

seek(self: vortex.storage.SimpleStackFloat64, volume_index: int, bscan_index: int) → None

write_multi_bscan(self: vortex.storage.SimpleStackFloat64, index: int, data: numpy.ndarray[numpy.float64]) → None

write_partial_bscan(self: vortex.storage.SimpleStackFloat64, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.float64]) → None

write_volume(self: vortex.storage.SimpleStackFloat64, data: numpy.ndarray[numpy.float64]) → None

class vortex.storage.SimpleStackHeader

Members:

Empty

Raw

NumPy

MATLAB

Empty = <SimpleStackHeader.Empty: 0>

MATLAB = <SimpleStackHeader.MATLAB: 3>

NumPy = <SimpleStackHeader.NumPy: 2>

Raw = <SimpleStackHeader.Raw: 1>

property name

property value

class vortex.storage.SimpleStackInt8

advance_volume(self: vortex.storage.SimpleStackInt8, allocate: bool = True) → None

close(self: vortex.storage.SimpleStackInt8) → None

property config

open(self: vortex.storage.SimpleStackInt8, arg0: vortex.storage.SimpleStackConfig) → None

property ready

seek(self: vortex.storage.SimpleStackInt8, volume_index: int, bscan_index: int) → None

write_multi_bscan(self: vortex.storage.SimpleStackInt8, index: int, data: numpy.ndarray[numpy.int8]) → None

write_partial_bscan(self: vortex.storage.SimpleStackInt8, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.int8]) → None

write_volume(self: vortex.storage.SimpleStackInt8, data: numpy.ndarray[numpy.int8]) → None

class vortex.storage.SimpleStackUInt16

advance_volume(self: vortex.storage.SimpleStackUInt16, allocate: bool = True) → None

close(self: vortex.storage.SimpleStackUInt16) → None

property config

open(self: vortex.storage.SimpleStackUInt16, arg0: vortex.storage.SimpleStackConfig) → None

property ready

seek(self: vortex.storage.SimpleStackUInt16, volume_index: int, bscan_index: int) → None

write_multi_bscan(self: vortex.storage.SimpleStackUInt16, index: int, data: numpy.ndarray[numpy.uint16]) → None

write_partial_bscan(self: vortex.storage.SimpleStackUInt16, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.uint16]) → None

write_volume(self: vortex.storage.SimpleStackUInt16, data: numpy.ndarray[numpy.uint16]) → None

class vortex.storage.SimpleStackUInt64

advance_volume(self: vortex.storage.SimpleStackUInt64, allocate: bool = True) → None

close(self: vortex.storage.SimpleStackUInt64) → None

property config

open(self: vortex.storage.SimpleStackUInt64, arg0: vortex.storage.SimpleStackConfig) → None

property ready

seek(self: vortex.storage.SimpleStackUInt64, volume_index: int, bscan_index: int) → None

write_multi_bscan(self: vortex.storage.SimpleStackUInt64, index: int, data: numpy.ndarray[numpy.uint64]) → None

write_partial_bscan(self: vortex.storage.SimpleStackUInt64, bscan_index: int, ascan_index: int, data: numpy.ndarray[numpy.uint64]) → None

write_volume(self: vortex.storage.SimpleStackUInt64, data: numpy.ndarray[numpy.uint64]) → None

class vortex.storage.SimpleStreamConfig

property buffering

copy(self: vortex.storage.SimpleStreamConfig) → vortex.storage.SimpleStreamConfig

property header

property path

class vortex.storage.SimpleStreamFloat64

close(self: vortex.storage.SimpleStreamFloat64) → None

property config

open(self: vortex.storage.SimpleStreamFloat64, arg0: vortex.storage.SimpleStreamConfig) → None

property ready

class vortex.storage.SimpleStreamHeader

Members:

Empty

Raw

Empty = <SimpleStreamHeader.Empty: 0>

Raw = <SimpleStreamHeader.Raw: 1>

property name

property value

class vortex.storage.SimpleStreamInt8

close(self: vortex.storage.SimpleStreamInt8) → None

property config

open(self: vortex.storage.SimpleStreamInt8, arg0: vortex.storage.SimpleStreamConfig) → None

property ready

class vortex.storage.SimpleStreamUInt16

close(self: vortex.storage.SimpleStreamUInt16) → None

property config

open(self: vortex.storage.SimpleStreamUInt16, arg0: vortex.storage.SimpleStreamConfig) → None

property ready

class vortex.storage.SimpleStreamUInt64

close(self: vortex.storage.SimpleStreamUInt64) → None

property config

open(self: vortex.storage.SimpleStreamUInt64, arg0: vortex.storage.SimpleStreamConfig) → None

property ready

class vortex.storage.StreamDump

close(self: vortex.storage.StreamDump) → None

property config

open(self: vortex.storage.StreamDump, arg0: vortex::storage::stream_dump_config_t) → None

property ready

class vortex.storage.StreamDumpConfig

property buffering

copy(self: vortex.storage.StreamDumpConfig) → vortex.storage.StreamDumpConfig

property divisor

property path

property stream