Python Reference¶

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) → spdlog::logger¶

vortex.get_file_logger(name: str, filename: str, level: int = 2) → spdlog::logger¶

vortex.get_python_logger(name: str, scope: str = 'vortex', level: int = 1) → spdlog::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 board¶

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.

Parameters¶

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.

Parameters¶

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.

Returns¶

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

Raises¶

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.

Parameters¶

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.

Returns¶

AlazarConfig: The copy.

property device¶

Type:: AlazarDevice

Alazar device for acquisition. Defaults to AlazarDevice().

property inputs¶

Type:: List[alazar.Input]

List of input configurations for each channel to 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.

Raises¶

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.alazar.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.

Raises¶

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 board¶

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.

Parameters¶

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.

Parameters¶

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.

Returns¶

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

Raises¶

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.

Parameters¶

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. Must have the same length as a record. 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.

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

Create a copy of this configuration.

Returns¶

AlazarFFTConfig: The copy.

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

Create a copy of this configuration.

Returns¶

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[alazar.Input]

List of input configurations for each channel to 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]

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.

Raises¶

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.alazar.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.

Raises¶

RuntimeError: If the configuration is invalid.

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.

Parameters¶

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.

Parameters¶

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.

Returns¶

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

Raises¶

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.

Returns¶

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.

Raises¶

RuntimeError: If the configuration is invalid.

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.

Parameters¶

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.

Parameters¶

buffernumpy.ndarray[numpy.uint16]: The buffer to acquire.
idint: Number to associate with the buffer for logging purposes.

Returns¶

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.

Returns¶

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.

Raises¶

RuntimeError: If the configuration is invalid.

class vortex.acquire.TeledyneAcquisition¶

Acquire data using a Teledyne SP Devices digitizer using the ADQAPI.

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

__NOTE__

This component does not support preloading with the engine.

__ATTENTION__

This component uses zero-copy memory operations that require memory reserved for direct memory access (DMA). This memory is frequently in short supply, especially as memory fragmentation worsens with system uptime. Engine pipelines using this component may require smaller and/or fewer blocks. Restarting the computer to reduce memory fragmentation may improve performance.

Linux

Linux by default limits DMA buffers to 4 MiB in size. When configuring the engine, block sizing parameters must satisfy ascans_per_block * samples_per_ascan * 2 < 4194304. Otherwise, the Teledyne configuration will fail. In practice, since A-scan length is a hardware property, ascans_per_block is limited to a few hundred A-scans. Consider using hugepages with enable_hugepages to avoid this issue.

property board_handle¶

property config¶

Type:: TeledyneConfig

Copy of the active configuration.

initialize(self: vortex.acquire.TeledyneAcquisition, config: vortex.acquire.TeledyneConfig) → None¶

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

Parameters¶

configTeledyneConfig: New configuration to apply.

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

Acquire the buffer and return the number of acquired records.

__ATTENTION__

Although the buffer data type is 16-bit unsigned integer for compatibility, the data stored within the buffer is actually signed.

Parameters¶

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.

Returns¶

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

Raises¶

RuntimeError: If the acquisition fails.

next_async(self: vortex.acquire.TeledyneAcquisition, 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.

__ATTENTION__

Although the buffer data type is 16-bit unsigned integer for compatibility, the data stored within buffers is actually signed.

Parameters¶

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.TeledyneAcquisition) → None¶: This method has no effect for Teledyne cards.

property running¶

start(self: vortex.acquire.TeledyneAcquisition) → None¶: Start the acquisition.

stop(self: vortex.acquire.TeledyneAcquisition) → 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.TeledyneConfig¶

Base: NullAcquisitionConfig

Configuration object for TeledyneAcquisition.

property acquire_timeout¶

Type:: datetime.timedelta

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

property background¶

Type:: numpy.ndarray[numpy.uint16]

Background record to subtract. Must have the same length as a record. Set to empty array ([]) to disable. Disabled by default.

__NOTE__

This feature requires the FWOCT_ firmware.

property channel_mask¶

property channels_per_sample¶

Type:: int

Number of channels that comprise each sample.

property clock¶

Type:: Clock

Clock configuration. Defaults to Clock().

property clock_delay_samples¶

Type:: float

Number of samples, positive or negative, to delay the k-clock signal relative to the OCT signal. Non-integer numbers of samples are allowed. Set to 0 to disable. Defaults to 0.

__NOTE__

This feature requires the FWOCT_ firmware.

property clock_edges¶

Type:: vortex.acquire.teledyne.ClockEdges

Which k-clock edges to consider when resampling. Defaults to Rising.

Tip

When resampling_factor of more than 2 is required, it is recommended to use Both for clock_delay_samples and reduce the resampling factor by a factor of 2.

__NOTE__

This feature requires the FWOCT_ firmware.

copy(self: vortex.acquire.TeledyneConfig) → vortex.acquire.TeledyneConfig¶

Create a copy of this configuration.

Returns¶

NullAcquisitionConfig: The copy.

property enable_fwoct¶

Type:: bool

Activate features that require FWOCT_ firmware when True and disable them when False. If False and FWOCT_ is detected, FWOCT_ is configured in passthrough mode. Default is False.

Note

FWOCT_ version 8 or higher is required for full feature support.

property enable_hugepages¶

Type:: bool

On Linux, allocate transfer buggers using hugepages when enabled. This can greatly increase the available memory for buffers. Default is False.

__ATTENTION__

This option is experimental. Memory allocated through hugepages may not be freed when the Python interpreter exits.

__WARNING__

On Windows, this option will raise an exception when enabled.

property fft_mode¶

Type:: vortex.acquire.teledyne.FFTMode

Output mode for the on-board FFT. Default is Disabled.

Important

Using an OCT processor is still recommended when enabling the FFT. Use the enable_ifft, enable_square, enable_log10, and enable_magnitude to avoid repeat processing.

__NOTE__

This feature requires the FWOCT_ firmware.

property inputs¶

Type:: List[teledyne.Input]

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

property periodic_trigger_frequency¶

Type:: float

Trigger frequency for when Periodic is the trigger source. Defaults to 10000.

property records_per_block¶

Type:: int

Number of records in each acquired buffer or block.

property resampling_factor¶

Type:: float

Scale factor for k-clock resampling using the on-board FPGA. That is, a value of 2 will upsample each record by a factor of 2. Non-integer resamplings are allowed. Set to 0 to disable resampling. Defaults to 0.

__NOTE__

This feature requires the FWOCT_ firmware.

property sample_skip_factor¶

Type:: int

Downsample samples within a record by the given factor. A value of 1 skips no samples. Defaults to 1.

property samples_per_record¶

Type:: int

Number of samples per record.

property samples_per_second¶

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 a record. Set to empty array ([]) to disable. Disabled by default.

__NOTE__

This feature requires the FWOCT_ firmware.

property test_pattern_signal¶

Type:: bool

Use the test pattern signal as the acquisition source. Defaults to False.

property trigger_offset_samples¶

Type:: int

Number of samples to skip after a trigger before acquiring a record. Defaults to 0.

property trigger_skip_factor¶

Type:: int

Downsample triggers by the given factor. A value of 1 skips no triggers. Defaults to 1.

property trigger_source¶

Type:: TriggerSource

Source for the acquisition trigger. Defaults to PortTrig.

property trigger_sync_passthrough¶

Type:: bool

Emit a pulse on the sync port on each trigger. This is useful for synchronizing external hardware, such as I/O cards. Defaults to True.

Important

Configure to False to use the test pattern generator.

validate(*args, **kwargs)¶

Overloaded function.

validate(self: vortex.acquire.TeledyneConfig) -> None

Check the configuration for errors.

Raises¶

RuntimeError: If the configuration is invalid.

validate(self: vortex.acquire.TeledyneConfig) -> None

Check the configuration for errors.

Raises¶

RuntimeError: If the configuration is invalid.

class vortex.engine.AscanHDF5StackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.AscanSpiralDeviceTensorEndpointInt8¶

property aggregate_segment_callback¶

property block_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.AscanStackEndpoint¶

property aggregate_segment_callback¶

property block_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 aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

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 block_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 block_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 block_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 block_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.CounterStreamEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

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.

Parameters¶

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.

shutdown(self: vortex.engine.Engine, interrupt: bool = False) → None¶

Request that the engine shut down without waiting for it do so. A call to stop() is still required before then engine can be started again.

Parameters¶

interruptbool: If True, abort any dispatched blocks. If False, wait for dispatched blocks to complete before exiting.

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.

Returns¶

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().

Raises¶

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.

Raises¶

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 lead_marker¶

Type:: ScanBoundary

Scan boundary marker inserted for leading samples. The primary purpose of this option is to apply Flags to the leading samples for stream-based storage endpoints, such as AscanStreamEndpoint. Default is ScanBoundary(0, 0, 0, 0x00).

property lead_strobes¶

Type:: int

Value for the strobe output when generating leading samples. Default is 0.

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.

Raises¶

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 block_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 block_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 block_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.GalvoActualStreamEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.GalvoTargetHDF5StackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.GalvoTargetStackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.GalvoTargetStreamEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

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¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property update_callback¶

property volume_callback¶

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 block_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 block_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.SampleActualHDF5StackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.SampleActualStackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.SampleActualStreamEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.SampleStrobe¶

property divisor¶

property duration¶

property line¶

property phase¶

property polarity¶

class vortex.engine.SampleTargetHDF5StackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.SampleTargetStackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.SampleTargetStreamEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

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.

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
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
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
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
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
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.

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
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
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
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
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
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.

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
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
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
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
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
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.

reset(self: vortex.engine.ScanQueue) -> None
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 block_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 block_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 block_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.SpectraSpiralDeviceTensorEndpointUInt16¶

property aggregate_segment_callback¶

property block_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 block_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 block_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 block_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 block_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 aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.StackDeviceTensorEndpointInt8¶

property aggregate_segment_callback¶

property block_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 block_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 block_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[vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe], x: 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[vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe]) → None¶: Clear the contents

count(self: list[vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe], x: 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.

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

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[vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe], i: int, x: 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.

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

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[vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe], x: 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.StrobesHDF5StackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.StrobesStackEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property executor¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

class vortex.engine.StrobesStreamEndpoint¶

property aggregate_segment_callback¶

property block_segment_callback¶

property event_callback¶

property scan_callback¶

property segment_callback¶

property storage¶

property update_callback¶

property volume_callback¶

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.acquire.alazar.Channel, log: vortex.log.Logger = None) → tuple[int, numpy.ndarray[numpy.uint16]]¶

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

Overloaded function.

compute_resampling(arg0: vortex::engine::source_t<double>, arg1: int, arg2: int) -> numpy.ndarray[numpy.float64]
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: Annotated[list[float], FixedSize(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.

find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int) -> numpy.ndarray[numpy.float64]
find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int, arg2: int) -> numpy.ndarray[numpy.float64]
find_rising_edges(arg0: numpy.ndarray[numpy.float64], arg1: int) -> numpy.ndarray[numpy.float64]
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.

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

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

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.

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

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 flip_reversed¶

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.

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
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
format(self: vortex.format.PositionFormatExecutor, volume_buffer: cupy.ndarray[cupy.uint16], sample_target: cupy.ndarray[cupy.float64], sample_actual: cupy.ndarray[cupy.float64], segment_buffer: cupy.ndarray[cupy.uint16], 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: Annotated[list[float], FixedSize(2)] = [1.0, 1.0], offset: Annotated[list[float], FixedSize(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.

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
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
format(self: vortex.format.RadialFormatExecutor, volume_buffer: cupy.ndarray[cupy.uint16], segment_buffer: cupy.ndarray[cupy.uint16], 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.SpiralFormatExecutor¶

property config¶

format(*args, **kwargs)¶

Overloaded function.

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

initialize(self: vortex.format.SpiralFormatExecutor, arg0: vortex.format.SpiralFormatExecutorConfig) → None¶

class vortex.format.SpiralFormatExecutorConfig¶

copy(self: vortex.format.SpiralFormatExecutorConfig) → vortex.format.SpiralFormatExecutorConfig¶

property erase_after_volume¶

property radial_extent¶

property rings_per_spiral¶

property sample_slice¶

property sample_transform¶

property samples_per_spiral¶

property segment_extent¶

property spiral_shape¶

property spiral_velocity¶

property volume_xy_extent¶

property x_extent¶

property y_extent¶

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.AlazarIO¶

property config¶

initialize(self: vortex.io.AlazarIO, arg0: vortex.io.AlazarIOConfig) → None¶

next(self: vortex.io.AlazarIO, count: int, streams: tuple[numpy.ndarray[numpy.uint64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.uint32]], id: int = 0) → None¶

next_async(self: vortex.io.AlazarIO, count: int, streams: tuple[numpy.ndarray[numpy.uint64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.uint32]], callback: Callable[[int, std::exception_ptr], None], id: int = 0) → None¶

prepare(self: vortex.io.AlazarIO) → None¶

property running¶

start(self: vortex.io.AlazarIO) → None¶

stop(self: vortex.io.AlazarIO, force: bool = False) → None¶

class vortex.io.AlazarIOConfig¶

property analog_output_channels¶

property blocks_to_buffer¶

copy(self: vortex.io.AlazarIOConfig) → vortex.io.AlazarIOConfig¶

property divisor¶

property samples_per_block¶

property stop_on_error¶

validate(self: vortex.io.AlazarIOConfig) → None¶

class vortex.io.DAQmxConfig¶

property blocks_to_buffer¶

property channels¶

property clock¶

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

property name¶

property persistent_task¶

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¶

next(self: vortex.io.DAQmxIO, count: int, streams: tuple[numpy.ndarray[numpy.uint64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.uint32]], id: int = 0) → None¶

next_async(self: vortex.io.DAQmxIO, count: int, streams: tuple[numpy.ndarray[numpy.uint64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.uint32]], callback: Callable[[int, std::__exception_ptr::exception_ptr], None], id: int = 0) → None¶

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

property running¶

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

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

class vortex.io.MachDSPIO¶

property config¶

initialize(self: vortex.io.MachDSPIO, arg0: vortex.io.MachDSPIOConfig) → None¶

next(self: vortex.io.MachDSPIO, count: int, streams: tuple[numpy.ndarray[numpy.uint64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.uint32]], id: int = 0) → None¶

next_async(self: vortex.io.MachDSPIO, count: int, streams: tuple[numpy.ndarray[numpy.uint64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.uint32]], callback: Callable[[int, std::__exception_ptr::exception_ptr], None], id: int = 0) → None¶

prepare(self: vortex.io.MachDSPIO) → None¶

property running¶

start(self: vortex.io.MachDSPIO) → None¶

stop(self: vortex.io.MachDSPIO) → None¶

class vortex.io.MachDSPIOConfig¶

property aux_divisor¶

property baud_rate¶

property blocks_to_buffer¶

copy(self: vortex.io.MachDSPIOConfig) → vortex.io.MachDSPIOConfig¶

property input_channels¶

property output_channels¶

property port¶

property readwrite_timeout¶

property sample_divisor¶

property samples_per_block¶

property stop_on_error¶

property trigger_rising_edge¶

validate(self: vortex.io.MachDSPIOConfig) → None¶

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¶

vortex.log.ConsoleSink¶: alias of StdErrSink

class vortex.log.FileSink¶

Base: Sink

A sink that formats log records to a file.

change(self: vortex.log.FileSink, filename: str, truncate: bool = False) → None¶

Change the file path of the sink.

__NOTE__

This method is thread-safe.

Parameters¶

filename : str

The new file path.

truncate : bool

Erase the new file upon opening it if True.

property filename¶

Type:: str

Path of file to store log output. Read-only.

flush(self: vortex.log.FileSink) → None¶: Ensure all log records have completed processing.

property level¶

Type:: int

Severity level for log records undergo processing.

set_pattern(self: vortex.log.FileSink, arg0: str) → None¶

Set the formatting pattern for this sink. See Logger.set_pattern.

__NOTE__

Calling Logger.set_pattern propagates the new pattern to all attached sinks, overwriting any local changes by this method.

class vortex.log.Logger¶

Loggers create records and then route them to associated sinks.

add_sink(self: vortex.log.Logger, arg0: vortex.log.Sink) → None¶

Attach a sink to this logger. Attaching a sink that is already attached has no effect.

__CAUTION__

This method is not thread-safe. Do not call this method when a log record might be emitted (e.g., when the engine is running) or while manipulating the list of attached sinks elsewhere.

Parameters¶

sink : vortex.log.Sink

The sink to attach.

clone(self: vortex.log.Logger, name: str) → vortex.log.Logger¶

Copy the current logger. This logger and its copy have the same sinks attached.

Parameters¶

name : str

Name of the copied logger.

return vortex.log.Logger:: The copy.

critical(self: vortex.log.Logger, msg: str) → None¶: Log a message at the critical level.

Parameters¶

msg : str

Message to log.

debug(self: vortex.log.Logger, msg: str) → None¶: Log a message at the debug level.

Parameters¶

msg : str

Message to log.

error(self: vortex.log.Logger, msg: str) → None¶: Log a message at the error level.

Parameters¶

msg : str

Message to log.

flush(self: vortex.log.Logger) → None¶: Flush all attached sinks.

info(self: vortex.log.Logger, msg: str) → None¶: Log a message at the info level.

Parameters¶

msg : str

Message to log.

property level¶

Type:: int

Severity level for events to produce a record.

log(self: vortex.log.Logger, level: int, msg: str) → None¶

Emit a log record with the given severity level. See spdlog’s source for further details.

Level	Value
trace	0
debug	1
info	2
warn	3
error	4
critical	5
off	6

Parameters¶

level : int

Severity level of the message.

msg : str

Message to log.

property name¶

Type:: str

Name of this logger. Read only.

remove_sink(self: vortex.log.Logger, arg0: vortex.log.Sink) → None¶

Remove a sink from this logger. Removing a sink that is not attached has no effect.

__CAUTION__

This method is not thread-safe. Do not call this method when a log record might be emitted (e.g., when the engine is running) or while manipulating the list of attached sinks elsewhere.

set_pattern(self: vortex.log.Logger, arg0: str, arg1: spdlog::pattern_time_type) → None¶: Change the pattern for this logger. The pattern is applied to all attached sinks as well. See the spdlog reference for pattern fields. The default pattern is d-%b-%Y %H:%M:%S.%f] %-10n %^(%L) %v%$.

Parameters¶

pattern : str

The new pattern.

property sinks¶

Type:: [vortex.log.Sink]

List of attached sinks. Read-only.

__CAUTION__

This property is not thread-safe. Do not read this property when adding or removing sinks elsewhere.

trace(self: vortex.log.Logger, msg: str) → None¶: Log a message at the trace level.

Parameters¶

msg : str

Message to log.

warn(self: vortex.log.Logger, msg: str) → None¶: Log a message at the warn level.

Parameters¶

msg : str

Message to log.

class vortex.log.PythonSink¶

Base: Sink

A sink that injects log records into the Python logging system. Internally, this sink creates and caches a Python logging.Logger of the appropriate name and forwards logging.LogRecords to logging.Logger.handle(). Severity levels are translated from spdlog to Python after by multiplying their numeric value by multiplying by 10. The log scope is the name of the Logger.

spdlog		Python
Level	Value	Level	Value
trace	0	NOTSET	0
debug	1	DEBUG	10
info	2	INFO	20
warn	3	WARNING	30
error	4	ERROR	40
critical	5	CRITICAL	50
off	6

__ATTENTION__

Avoid configuring this sink to accept high-frequency log output (e.g., trace-level) as this may degrade logging or application performance.

__NOTE__

It is most efficient to create a single application-wide PythonSink since this avoid duplication of Python logging.Loggers.

These functions are inefficient for larger applications since a new, independent sink is created each call. Larger applications should instead prefer to create sinks manually and attach all required loggers.

In earlier undocumented versions, these functions returned previously-created loggers if a logger of the same name was requested. This is no longer the case since a new logger and sink pair is created during each call.

flush(self: vortex.log.PythonSink) → None¶: Ensure all log records have completed processing.

property level¶

Type:: int

Severity level for log records undergo processing.

set_pattern(self: vortex.log.PythonSink, arg0: str) → None¶

Set the formatting pattern for this sink. See Logger.set_pattern.

__NOTE__

Calling Logger.set_pattern propagates the new pattern to all attached sinks, overwriting any local changes by this method.

class vortex.log.Sink¶: Abstract base class for all sinks.

class vortex.log.SinkList¶

append(self: list[spdlog::sinks::sink], x: spdlog::sinks::sink) → None¶: Add an item to the end of the list

clear(self: list[spdlog::sinks::sink]) → None¶: Clear the contents

count(self: list[spdlog::sinks::sink], x: spdlog::sinks::sink) → int¶: Return the number of times x appears in the list

extend(*args, **kwargs)¶

Overloaded function.

extend(self: list[spdlog::sinks::sink], L: list[spdlog::sinks::sink]) -> None

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

extend(self: list[spdlog::sinks::sink], L: Iterable) -> None

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

insert(self: list[spdlog::sinks::sink], i: int, x: spdlog::sinks::sink) → None¶: Insert an item at a given position.

pop(*args, **kwargs)¶

Overloaded function.

pop(self: list[spdlog::sinks::sink]) -> spdlog::sinks::sink

Remove and return the last item

pop(self: list[spdlog::sinks::sink], i: int) -> spdlog::sinks::sink

Remove and return the item at index i

remove(self: list[spdlog::sinks::sink], x: spdlog::sinks::sink) → None¶: Remove the first item from the list whose value is x. It is an error if there is no such item.

class vortex.log.StdErrSink¶

Base: Sink

A sink that formats log records to standard error.

All members are inherited.

flush(self: vortex.log.StdErrSink) → None¶: Ensure all log records have completed processing.

property level¶

Type:: int

Severity level for log records undergo processing.

set_pattern(self: vortex.log.StdErrSink, arg0: str) → None¶

Set the formatting pattern for this sink. See Logger.set_pattern.

__NOTE__

Calling Logger.set_pattern propagates the new pattern to all attached sinks, overwriting any local changes by this method.

class vortex.log.StdOutSink¶

Base: Sink

A sink that formats log records to standard out.

All members are inherited.

flush(self: vortex.log.StdOutSink) → None¶: Ensure all log records have completed processing.

property level¶

Type:: int

Severity level for log records undergo processing.

set_pattern(self: vortex.log.StdOutSink, arg0: str) → None¶

Set the formatting pattern for this sink. See Logger.set_pattern.

__NOTE__

Calling Logger.set_pattern propagates the new pattern to all attached sinks, overwriting any local changes by this method.

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.

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

Clears all bits

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.

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

Sets all bits

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.

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

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

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.

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

Remove and return the last item

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: 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: 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.

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

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

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: 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.

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

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: 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 device¶

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 device¶

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 device¶

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 device¶

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 device¶

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.CPUProcessor¶

Perform OCT processing with averaging, resampling by linear interpolation, spectral filtering, and FFT on the CPU.

change(self: vortex.process.CPUProcessor, config: vortex.process.CPUProcessorConfig) → None¶

Change the processor configuration. If the change requires buffer reallocation, the pipeline is stalled and record history for the rolling average may be lost. May be called while a block is currently processing.

Parameters¶

configCPUProcessorConfig: New configuration to apply.

property config¶

Type:: CPUProcessorConfig

Copy of the active configuration.

initialize(self: vortex.process.CPUProcessor, config: vortex.process.CPUProcessorConfig) → None¶

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

Parameters¶

configCPUProcessorConfig: New configuration to apply.

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

Process the next buffer.

Parameters¶

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.
append_historybool: Include the raw spectra from this input buffer in the rolling average.

next_async(self: vortex.process.CPUProcessor, input_buffer: numpy.ndarray[numpy.uint16], output_buffer: numpy.ndarray[numpy.int8], callback: Callable[[std::__exception_ptr::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.

Parameters¶

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.
append_historybool: Include the raw spectra from this input buffer in the rolling average.

class vortex.process.CPUProcessorConfig¶

Base: NullProcessorConfig

Configuration object for CPUProcessor.

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.

property channels_per_sample¶

copy(self: vortex.process.CPUProcessorConfig) → vortex.process.CPUProcessorConfig¶

Create a copy of this configuration.

Returns¶

CPUProcessorConfig: The copy.

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 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¶

Type:: bool

Enable the application of $l o g_{10} (. . .)$ to the complex magnitude. Enabled by default.

property enable_magnitude¶

Type:: bool

Enable returning the complex magnitude after square and log operations. When enabled, the processor output is complex magnitude. When disabled, the processor output is the real part only. Enabled by default.

property enable_square¶

Type:: bool

Enabling squaring of the complex magnitude after the FFT. When enabled, the processor output is power. When disabled, the processor output is amplitude. 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 levels¶

Type:: Optional[Range]

When set, rescale values within [levels.min, levels.max] to the full range of the output data type. This is helpful for quantization when the output data type has a small dynamic range. When unset, cast values to the output data type directly. Unset by default.

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 processing pipelines. Adjust to achieve the desired CPU utilization for machines with high hardware concurrency. Recommended minimum is 2-4 slots to facilitate pipelining of successive blocks but higher numbers will likely yield better throughput. Each processing step is individually parallelized across all CPU cores; this field only affects pipeline-level parallelism. 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.CPUProcessorConfig) → None¶

Check the configuration for errors.

Raises¶

RuntimeError: If the configuration is invalid.

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.

Parameters¶

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.

Parameters¶

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.

Parameters¶

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::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.

Parameters¶

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.

property channels_per_sample¶

property clock_channel¶

Type:: Optional[int]

Index of k-clock channel for dynamic resampling. Enables k-clock resampling on a per A-scan basis with set to a non-None value. Defaults to None.

__NOTE__

Dynamic resampling is only supported when the cuda_dynamic_resampling feature is present. This requires CUDA 11 or higher.

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

Create a copy of this configuration.

Returns¶

CUDAProcessorConfig: The copy.

property device¶

Type:: int

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

property enable_ifft¶

Type:: bool

__NOTE__: If FFT normalization is not desired, scale the spectral filter by $N$ to cancel out the normalization factor.

property enable_log10¶

Type:: bool

Enable the application of $l o g_{10} (. . .)$ to the complex magnitude. Enabled by default.

property enable_magnitude¶

Type:: bool

property enable_square¶

Type:: bool

Enabling squaring of the complex magnitude after the FFT. When enabled, the processor output is power. When disabled, the processor output is amplitude. 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 interpret_as_signed¶

Type:: bool

Interpret the input data as signed data instead of unsigned data. Relevant only for Python where data types are pre-specified. Defaults to False.

property levels¶

Type:: Optional[Range]

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]

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]

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

Check the configuration for errors.

Raises¶

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.

Parameters¶

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.

Parameters¶

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.

Parameters¶

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::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.

Parameters¶

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¶

property channels_per_sample¶

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

Create a copy of this configuration.

Returns¶

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(lceil r[j] rceil - r[j] big) hat{x}big[i, lfloor r[j] rfloor, k big] + big(r[j] - lfloor r[j] rfloorbig) 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.

Raises¶

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.

property channels_per_sample¶

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

Create a copy of this configuration.

Returns¶

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.

Raises¶

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.

Parameters¶

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

next(*args, **kwargs)¶

Overloaded function.

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

prepare(*args, **kwargs)¶

Overloaded function.

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.

Parameters¶

countOptional[int]: Number of samples to buffer.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

restart(*args, **kwargs)¶

Overloaded function.

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.

Parameters¶

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.

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

__NOTE__

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

Parameters¶

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 long, 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 long, unsigned char> > >) → None¶

Initialize the scan using the supplied configuration.

Parameters¶

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

next(*args, **kwargs)¶

Overloaded function.

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

prepare(*args, **kwargs)¶

Overloaded function.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

restart(*args, **kwargs)¶

Overloaded function.

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

__NOTE__

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

Parameters¶

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.

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

__NOTE__

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

Parameters¶

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

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.

copy(self: vortex.scan.RadialScanConfig) -> vortex.scan.RadialScanConfig
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.

to_pattern(self: vortex.scan.RadialScanConfig, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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 $θ$ -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_{i j} = (x_{i}, y_{j})$ as described mathematically below.

\begin{array}{r} \begin{aligned} u_{i} & = (\frac{i}{n - 1}) θ_{\min} + (1 - \frac{i}{n - 1}) θ_{\max} & v_{j} & = (\frac{j}{m - 1}) r_{\min} + (1 - \frac{j}{m - 1}) r_{\max} \\ x_{i} & = v_{i} \cos (u_{i} + θ) + x_{o} & y_{j} & = v_{j} \sin (u_{j} + θ) + y_{o} \end{aligned} \end{array}

The parameters that define $W_{i j}$ are adjusted via the the following properties and those inherited from XYWaypoints.

property angle¶

Type:: float

Counter-clockwise rotation $θ$ 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_{\min}$ and maximum $r_{\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.

Parameters¶

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.

Parameters¶

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_{i j} = (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 $θ_{\min}$ and maximum $θ_{\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 long, 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 long, unsigned char> > >) → None¶

Initialize the scan using the supplied configuration.

Parameters¶

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

next(*args, **kwargs)¶

Overloaded function.

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

prepare(*args, **kwargs)¶

Overloaded function.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

restart(*args, **kwargs)¶

Overloaded function.

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

__NOTE__

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

Parameters¶

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.

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

__NOTE__

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

Parameters¶

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

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.

copy(self: vortex.scan.RasterScanConfig) -> vortex.scan.RasterScanConfig
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.

to_pattern(self: vortex.scan.RasterScanConfig, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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_{i j} = (x_{i}, y_{j})$ as described mathematically below.

\begin{array}{r} \begin{aligned} u_{i} & = (\frac{i}{n - 1}) x_{\min} + (1 - \frac{i}{n - 1}) x_{\max} & v_{j} & = (\frac{j}{m - 1}) y_{\min} + (1 - \frac{j}{m - 1}) y_{\max} \\ x_{i} & = u_{i} \cos θ - v_{i} \sin θ + x_{o} & y_{j} & = u_{j} \sin θ + v_{j} \cos θ + y_{o} \end{aligned} \end{array}

The parameters that define $W_{i j}$ are adjusted via the the following properties and those inherited from XYWaypoints.

property angle¶

Type:: float

Counter-clockwise rotation $θ$ 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_{\min}$ and maximum $y_{\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_{i j} = (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_{\min}$ and maximum $x_{\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.

to_pattern(self: vortex.scan.RepeatedPattern, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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 long, 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 long, unsigned char> > >) → None¶

Initialize the scan using the supplied configuration.

Parameters¶

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

next(*args, **kwargs)¶

Overloaded function.

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

prepare(*args, **kwargs)¶

Overloaded function.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

restart(*args, **kwargs)¶

Overloaded function.

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

__NOTE__

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

Parameters¶

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.

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

__NOTE__

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

Parameters¶

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

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.

copy(self: vortex.scan.RepeatedRadialScanConfig) -> vortex.scan.RepeatedRadialScanConfig
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.

to_pattern(self: vortex.scan.RepeatedRadialScanConfig, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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 long, 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 long, unsigned char> > >) → None¶

Initialize the scan using the supplied configuration.

Parameters¶

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

next(*args, **kwargs)¶

Overloaded function.

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

prepare(*args, **kwargs)¶

Overloaded function.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

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

Parameters¶

countOptional[int]: Number of samples to buffer.

restart(*args, **kwargs)¶

Overloaded function.

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

__NOTE__

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

Parameters¶

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.

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

__NOTE__

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

Parameters¶

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

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.

copy(self: vortex.scan.RepeatedRasterScanConfig) -> vortex.scan.RepeatedRasterScanConfig
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.

to_pattern(self: vortex.scan.RepeatedRasterScanConfig, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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.

Parameters¶

samples_per_secondfloat: Sampling rate for the velocity calculation.

return 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.

Parameters¶

samples_per_secondfloat: Sampling rate for the velocity calculation.

return 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.

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

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

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.

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

Remove and return the last item

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

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.

to_pattern(self: vortex.scan.SequentialPattern, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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 long, 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 long, unsigned char> > >) → None¶

next(*args, **kwargs)¶

Overloaded function.

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

prepare(*args, **kwargs)¶

Overloaded function.

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

restart(*args, **kwargs)¶

Overloaded function.

restart(self: vortex.scan.SpiralScan) -> None
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.

copy(self: vortex.scan.SpiralScanConfig) -> vortex.scan.SpiralScanConfig
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.

to_pattern(self: vortex.scan.SpiralScanConfig, arg0: numpy.ndarray[numpy.float64]) -> list[vortex.scan.Segment]
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¶

property ready¶

write(self: vortex.storage.MarkerLog, arg0: list[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

NumPy

MATLAB

NRRD

NIfTI

Empty = <SimpleStackHeader.Empty: 0>¶

MATLAB = <SimpleStackHeader.MATLAB: 2>¶

NIfTI = <SimpleStackHeader.NIfTI: 4>¶

NRRD = <SimpleStackHeader.NRRD: 3>¶

NumPy = <SimpleStackHeader.NumPy: 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

Empty = <SimpleStreamHeader.Empty: 0>¶

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¶