Python Reference#

class vortex.Logger#
class vortex.Range#
contains(self: vortex.Range, arg0: float) bool#
copy(self: vortex.Range) vortex.Range#
property length#
property max#
property min#
static symmetric(arg0: float) vortex.Range#
vortex.get_console_logger(name: str, level: int = 2) vortex.Logger#
vortex.get_python_logger(name: str, scope: str = 'vortex') vortex.Logger#
class vortex.acquire.AlazarAcquisition#

Acquire data using an AlazarTech digitizer.

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

__NOTE__

This component supports preloading with the engine.

property config#
Type

AlazarConfig

Copy of the active configuration.

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

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

configAlazarConfig

New configuration to apply.

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

Acquire the buffer and return the number of acquired records.

buffernumpy.ndarray[numpy.uint16]

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

idint

Number to associate with the buffer for logging purposes.

int

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

RuntimeError

If the acquisition fails.

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

Acquire the buffer asynchronously and execute the callback when complete.

__CAUTION__

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

buffernumpy.ndarray[numpy.uint16]

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

callbackCallable[[int, Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

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

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

property running#
start(self: vortex.acquire.AlazarAcquisition) None#

Start the acquisition.

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

Stop the acquisition.

__CAUTION__

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

class vortex.acquire.AlazarConfig#

Base: NullAcquisitionConfig

Configuration object for AlazarAcquisition.

property acquire_timeout#
Type

datetime.timedelta

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

property bytes_per_multisample#
Type

int

property channel_mask#
Type

int

Bitmask of channels configured for acquisition. Read-only.

property channels_per_sample#
Type

int

Number of channels that comprise each sample.

property clock#
Type

InternalClock | ExternalClock

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

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

Create a copy of this configuration.

AlazarConfig

The copy.

property device#
Type

AlazarDevice

Alazar device for acquisition. Defaults to AlazarDevice().

property inputs#
Type

List[Input]

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

property options#
Type

List[AuxIOTriggerOut | AuxIOClockOut | AuxIOPacerOut | OCTIgnoreBadClock]

List of acquisition options. Default is empty.

property recommended_minimum_records_per_block#
Type

int

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

property records_per_block#
Type

int

Number of records in each acquired buffer or block.

property resampling#
Type

numpy.ndarray[int]

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

property samples_per_record#
Type

int

Number of samples per record.

property samples_per_second#
Type

int

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

RuntimeError

if samples_per_second_is_known is False.

property samples_per_second_is_known#
Type

bool

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

property shape#
Type

List[int[3]]

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

property stop_on_error#
Type

bool

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

property trigger#
Type

SingleExternalTrigger | DualExternalTrigger

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.AlazarDevice#

Representation of an Alazar device identifier.

property board_index#
Type

int

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

copy(self: vortex.acquire.AlazarDevice) vortex.acquire.AlazarDevice#
property system_index#
Type

int

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

class vortex.acquire.AlazarFFTAcquisition#

Base: AlazarAcquisition

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

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

__NOTE__

This component supports preloading with the engine.

property config#
Type

AlazarFFTConfig

Copy of the active configuration.

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

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

configAlazarFFTConfig

New configuration to apply.

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

Acquire the buffer and return the number of acquired records.

buffernumpy.ndarray[numpy.uint16]

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

idint

Number to associate with the buffer for logging purposes.

int

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

RuntimeError

If the acquisition fails.

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

Acquire the buffer asynchronously and execute the callback when complete.

__CAUTION__

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

buffernumpy.ndarray[numpy.uint16]

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

callbackCallable[[int, Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

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

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

property running#
start(self: vortex.acquire.AlazarFFTAcquisition) None#

Start the acquisition.

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

Stop the acquisition.

__CAUTION__

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

class vortex.acquire.AlazarFFTConfig#

Base: AlazarConfig

Configuration object for AlazarFFTAcquisition.

property acquire_timeout#
Type

datetime.timedelta

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

property ascans_per_block#
Type

int

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

property background#
Type

numpy.ndarray[numpy.uint16]

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

property bytes_per_multisample#
Type

int

property channel_mask#
Type

int

Bitmask of channels configured for acquisition. Read-only.

property channels_per_sample#
Type

int

Number of channels that comprise each sample.

property clock#
Type

InternalClock | ExternalClock

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

copy(*args, **kwargs)#

Overloaded function.

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

Create a copy of this configuration.

AlazarFFTConfig

The copy.

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

Create a copy of this configuration.

AlazarFFTConfig

The copy.

property device#
Type

AlazarDevice

Alazar device for acquisition. Defaults to AlazarDevice().

property fft_length#
Type

int

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

property include_time_domain#
Type

bool

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

property inputs#
Type

List[Input]

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

property options#
Type

List[AuxIOTriggerOut | AuxIOClockOut | AuxIOPacerOut | OCTIgnoreBadClock]

List of acquisition options. Default is empty.

property recommended_minimum_records_per_block#
Type

int

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

property records_per_block#
Type

int

Number of records in each acquired buffer or block.

property resampling#
Type

numpy.ndarray[int]

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

property samples_per_ascan#
Type

int

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

property samples_per_record#
Type

int

Number of samples per record.

property samples_per_second#
Type

int

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

RuntimeError

if samples_per_second_is_known is False.

property samples_per_second_is_known#
Type

bool

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

property shape#
Type

List[int[3]]

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

property spectral_filter#
Type

numpy.ndarray[numpy.complex64]

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

property stop_on_error#
Type

bool

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

property trigger#
Type

SingleExternalTrigger | DualExternalTrigger

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.AuxIOClockOut#

Pass the clock through the auxillary I/O port.

copy(self: vortex.acquire.AuxIOClockOut) vortex.acquire.AuxIOClockOut#
class vortex.acquire.AuxIOPacerOut#

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

copy(self: vortex.acquire.AuxIOPacerOut) vortex.acquire.AuxIOPacerOut#
property divider#
Type

int

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

class vortex.acquire.AuxIOTriggerOut#

Pass the trigger through the auxillary I/O port.

copy(self: vortex.acquire.AuxIOTriggerOut) vortex.acquire.AuxIOTriggerOut#
class vortex.acquire.DualExternalTrigger#

Configure a dual external trigger.

property coupling#
Type

Coupling

Coupling for trigger input.

property delay_samples#
Type

int

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

property initial_slope#
Type

TriggerSlope

Polarity of the initial trigger.

property level_ratios#
Type

List[float[2]]

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

property range_millivolts#
Type

int

Trigger input range, specified in millivolts.

class vortex.acquire.ExternalClock#

Configure an external clock source.

copy(self: vortex.acquire.ExternalClock) vortex.acquire.ExternalClock#
property coupling#
Type

Coupling

Coupling for clock input.

property dual#
Type

bool

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

property edge#
Type

ClockEdge

Edge on which to trigger the clock.

property level_ratio#
Type

float

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

class vortex.acquire.FileAcquisition#

Acquire data from a file.

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

__NOTE__

This component supports preloading with the engine.

property config#
Type

FileAcquisitionConfig

Copy of the active configuration.

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

Initialize the acquisition using the supplied configuration.

configFileAcquisitionConfig

New configuration to apply.

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

Acquire the buffer and return the number of acquired records.

buffernumpy.ndarray[numpy.uint16]

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

idint

Number to associate with the buffer for logging purposes.

int

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

RuntimeError

If the acquisition fails.

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

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

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

Start the acquisition, and open the source file.

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

Stop the acquisition, and close the source file.

class vortex.acquire.FileAcquisitionConfig#

Base: NullAcquisitionConfig

Configuration object for FileAcquisition.

property channels_per_sample#
Type

int

Number of channels that comprise each sample.

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

Return a copy of this configuration.

FileAcquisitionConfig

The copy.

property loop#
Type

bool

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

property path#
Type

str

Path to file that backs the acquisition.

property records_per_block#
Type

int

Number of records in each acquired buffer or block.

property samples_per_record#
Type

int

Number of samples per record.

property shape#
Type

List[int[3]]

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.Input#

Configure an input channel.

property bytes_per_sample#
Type

int

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

property channel#
Type

Channel

Channel to receive this configuration.

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

Copy this object.

Input

The copy.

property coupling#
Type

Coupling

Coupling for channel input.

property impedance_ohms#
Type

int

Channel input impedance, specified in Ohms.

property range_millivolts#
Type

int

Channel input range, specified in millivolts.

class vortex.acquire.InternalClock#

Configure an internal clock source.

copy(self: vortex.acquire.InternalClock) vortex.acquire.InternalClock#
property samples_per_second#
Type

int

Number of samples per second to configure for the internal clock

class vortex.acquire.NullAcquisition#

Perform no acquisition.

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

__NOTE__

This component supports preloading with the engine.

property config#
Type

NullAcquisitionConfig

Copy of the active configuration.

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

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

configNullAcquisitionConfig

New configuration to apply.

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

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

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire.

idint

Number to associate with the buffer for logging purposes.

int

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

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

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

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

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

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

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

class vortex.acquire.NullAcquisitionConfig#

Configuration object for NullAcquisition.

property channels_per_sample#
Type

int

Number of channels that comprise each sample.

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

Create a copy of this configuration.

NullAcquisitionConfig

The copy.

property records_per_block#
Type

int

Number of records in each acquired buffer or block.

property samples_per_record#
Type

int

Number of samples per record.

property shape#
Type

List[int[3]]

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.acquire.OCTIgnoreBadClock#

Activate the OCT ignore bad clock feature.

property bad_seconds#
Type

float

Bad clock duration, specified in seconds.

copy(self: vortex.acquire.OCTIgnoreBadClock) vortex.acquire.OCTIgnoreBadClock#
property good_seconds#
Type

float

Good clock duration, specified in seconds.

class vortex.acquire.SingleExternalTrigger#

Configure a single external trigger.

property coupling#
Type

Coupling

Coupling for trigger input.

property delay_samples#
Type

int

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

property level_ratio#
Type

float

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

property range_millivolts#
Type

int

Trigger input range, specified in millivolts.

property slope#
Type

TriggerSlope

Polarity of trigger signal.

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

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

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

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

class vortex.engine.AscanHDF5StackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.AscanStackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.AscanStreamEndpoint#
property storage#
class vortex.engine.Block#
class StreamIndex#

Members:

Counter

GalvoTarget

SampleTarget

GalvoActual

SampleActual

Strobes

Counter = <StreamIndex.Counter: 0>#
GalvoActual = <StreamIndex.GalvoActual: 3>#
GalvoTarget = <StreamIndex.GalvoTarget: 1>#
SampleActual = <StreamIndex.SampleActual: 4>#
SampleTarget = <StreamIndex.SampleTarget: 2>#
Strobes = <StreamIndex.Strobes: 5>#
property name#
property value#
property counter#
property galvo_actual#
property galvo_target#
property id#
property length#
property markers#
property sample#
property sample_actual#
property sample_target#
property strobes#
property timestamp#
class vortex.engine.BroctStorageEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.BufferStrategy#

Members:

Block

Segment

Volume

Block = <BufferStrategy.Block: 0>#
Segment = <BufferStrategy.Segment: 1>#
Volume = <BufferStrategy.Volume: 2>#
property name#
property value#
class vortex.engine.CounterHDF5StackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.CounterStackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.CounterStackHostTensorEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.Engine#

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

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

class Event#

Members:

Launch

Start

Run

Stop

Complete

Shutdown

Exit

Error

Abort

Abort = <Event.Abort: 8>#
Complete = <Event.Complete: 4>#
Error = <Event.Error: 7>#
Exit = <Event.Exit: 6>#
Launch = <Event.Launch: 0>#
Run = <Event.Run: 2>#
Shutdown = <Event.Shutdown: 5>#
Start = <Event.Start: 1>#
Stop = <Event.Stop: 3>#
property name#
property value#
property config#
Type

EngineConfig

Copy of the active configuration.

property done#
Type

bool

Return True if the engine is stopped and False otherwise.

__WARNING__

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

property event_callback#
Type

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

Callback to receive status events from the engine.

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

Initialize the engine using the supplied configuration.

configEngineConfig

New configuration to apply.

property job_callback#
Type

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

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

__CAUTION__

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

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

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

property scan_queue#
Type

ScanQueue

Access the engine’s scan queue.

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

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

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

Query the engine status.

EngineStatus

The current status of the engine.

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

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

RuntimeError

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

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

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

RuntimeError

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

wait_for(self: vortex.engine.Engine, timeout: float) bool#
class vortex.engine.EngineConfig#

Configuration object for Engine.

add_acquisition(self: vortex.engine.EngineConfig, acquisition: object, processors: sequence, preload: bool = True, master: bool = True) None#
add_formatter(self: vortex.engine.EngineConfig, arg0: object, arg1: sequence) None#
add_io(self: vortex.engine.EngineConfig, io: object, preload: bool = True, master: bool = False, lead_samples: int = 0) None#
add_processor(self: vortex.engine.EngineConfig, arg0: object, arg1: sequence) None#
property blocks_to_acquire#
Type

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

property blocks_to_allocate#
Type

int

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

copy(self: vortex.engine.EngineConfig) vortex.engine.EngineConfig#
property galvo_input_channels#
Type

int

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

property galvo_output_channels#
Type

int

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

property post_scan_records#
Type

int

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

property preload_count#
Type

int

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

property records_per_block#
Type

int

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

property scanner_warp#
Type

[NoWarp | AngularWarp | TelecentricWarp]

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

property strobes#
Type

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

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

__WARNING__

This method is not fully implemented yet.

class vortex.engine.EngineStatus#
property active#
property block_utilization#
copy(self: vortex.engine.EngineStatus) vortex.engine.EngineStatus#
property dispatch_completion#
property dispatched_blocks#
property inflight_blocks#
class vortex.engine.EventStrobe#
property delay#
property duration#
property flags#
property line#
property polarity#
class vortex.engine.GalvoActualHDF5StackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.GalvoActualStackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.GalvoActualStackHostTensorEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.JobTiming#
property acquire#
property create#
property format#
property process#
property recycle#
property scan#
property service#
class vortex.engine.MarkerLogStorage#
property storage#
class vortex.engine.NullEndpoint#
class vortex.engine.Polarity#

Members:

Low

High

High = <Polarity.High: 1>#
Low = <Polarity.Low: 0>#
property name#
property value#
class vortex.engine.PositionDeviceTensorEndpointInt8#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.RadialDeviceTensorEndpointInt8#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.SampleStrobe#
property divisor#
property duration#
property line#
property phase#
property polarity#
class vortex.engine.ScanQueue#

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

class Event#

Members:

Start

Finish

Interrupt

Abort

Abort = <Event.Abort: 3>#
Finish = <Event.Finish: 1>#
Interrupt = <Event.Interrupt: 2>#
Start = <Event.Start: 0>#
property name#
property value#
class OnlineScanQueue#
append(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

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

append(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

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

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

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

property empty_callback#
Type

Callable[[OnlineScanQueue], None]

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

__ATTENTION__

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

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

Overloaded function.

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

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

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

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

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

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

reset(*args, **kwargs)#

Overloaded function.

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

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

class vortex.engine.ScanStrobe#
property delay#
property duration#
property flags#
property line#
property polarity#
class vortex.engine.SegmentStrobe#
property delay#
property duration#
property flags#
property line#
property polarity#
class vortex.engine.SessionStatus#
property allocated#
property available#
property dispatched#
property inflight#
property limit#
property progress#
property utilization#
class vortex.engine.Source#
property clock_edges_seconds#
property clock_rising_edges_per_trigger#
copy(self: vortex.engine.Source) vortex.engine.Source#
property duty_cycle#
property has_clock#
property imaging_depth_meters#
property triggers_per_second#
class vortex.engine.SpectraHDF5StackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.SpectraPositionDeviceTensorEndpointUInt16#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.SpectraRadialDeviceTensorEndpointUInt16#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.SpectraStackDeviceTensorEndpointUInt16#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.SpectraStackEndpoint#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property storage#
property update_callback#
property volume_callback#
class vortex.engine.SpectraStackHostTensorEndpointUInt16#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.SpectraStackTensorEndpointUInt16#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.SpectraStreamEndpoint#
property storage#
class vortex.engine.StackDeviceTensorEndpointInt8#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.StackHostTensorEndpointInt8#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property stream#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.StackTensorEndpointInt8#
property aggregate_segment_callback#
property event_callback#
property executor#
property scan_callback#
property segment_callback#
property tensor#
property update_callback#
property volume_callback#
class vortex.engine.StreamDumpStorage#
property storage#
class vortex.engine.StrobeList#
append(self: List[Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]], x: Union[vortex.engine.SampleStrobe, vortex.engine.SegmentStrobe, vortex.engine.VolumeStrobe, vortex.engine.ScanStrobe, vortex.engine.EventStrobe]) None#

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

class vortex.engine.VolumeStrobe#
property delay#
property duration#
property flags#
property line#
property polarity#
vortex.engine.acquire_alazar_clock(source: vortex.engine.Source, acquire_config: vortex.acquire.AlazarConfig, clock_channel: vortex.driver.alazar.Channel, log: vortex.Logger = None) Tuple[int, numpy.ndarray[numpy.uint16]]#
vortex.engine.compute_resampling(*args, **kwargs)#

Overloaded function.

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

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

vortex.engine.cycle(arg0: sequence) vortex::engine::engine_config_t<vortex::engine::block_t<unsigned short,signed char,double,unsigned int>,std::variant<vortex::scan::warp::none_t,vortex::scan::warp::angular_t,vortex::scan::warp::telecentric_t> >::cycle_t#
vortex.engine.dispersion_phasor(arg0: int, arg1: List[float[2]]) numpy.ndarray[numpy.complex128]#
vortex.engine.divide(arg0: sequence) vortex::engine::engine_config_t<vortex::engine::block_t<unsigned short,signed char,double,unsigned int>,std::variant<vortex::scan::warp::none_t,vortex::scan::warp::angular_t,vortex::scan::warp::telecentric_t> >::divide_t#
vortex.engine.find_rising_edges(*args, **kwargs)#

Overloaded function.

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

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

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

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

class vortex.format.BroctFormatExecutor#
class vortex.format.Copy#
property block_offset#
property buffer_record#
property buffer_segment#
property count#
property reverse#
class vortex.format.FinishScan#
property sample#
property scan_index#
class vortex.format.FinishSegment#
property sample#
property scan_index#
property segment_index_buffer#
property volume_index#
class vortex.format.FinishVolume#
property sample#
property scan_index#
property volume_index#
class vortex.format.FormatPlan#
append(self: vortex.format.FormatPlan, x: Union[vortex.format.Copy, vortex.format.Resize, vortex.format.FinishSegment, vortex.format.FinishVolume, vortex.format.FinishScan, vortex::format::action::event]) None#

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

class vortex.format.FormatPlanner#
property config#
initialize(self: vortex.format.FormatPlanner, arg0: vortex.format.FormatPlannerConfig) None#
property records_per_segment#
reset(self: vortex.format.FormatPlanner) None#
property segments_per_volume#
class vortex.format.FormatPlannerConfig#
property adapt_shape#
copy(self: vortex.format.FormatPlannerConfig) vortex.format.FormatPlannerConfig#
property mask#
property records_per_segment#
property segments_per_volume#
property shape#
property strip_inactive#
class vortex.format.LinearTransform#
copy(self: vortex.format.LinearTransform) vortex.format.LinearTransform#
property offset#
property scale#
class vortex.format.NullSlice#
copy(self: vortex.format.NullSlice) vortex.format.NullSlice#
class vortex.format.NullTransform#
copy(self: vortex.format.NullTransform) vortex.format.NullTransform#
class vortex.format.PositionFormatExecutor#
property config#
format(*args, **kwargs)#

Overloaded function.

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

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

initialize(self: vortex.format.PositionFormatExecutor, arg0: vortex.format.PositionFormatExecutorConfig) None#
class vortex.format.PositionFormatExecutorConfig#
property channels#
copy(self: vortex.format.PositionFormatExecutorConfig) vortex.format.PositionFormatExecutorConfig#
property erase_after_volume#
property sample_slice#
property sample_transform#
set(self: vortex.format.PositionFormatExecutorConfig, pitch: List[float[2]] = [1.0, 1.0], offset: List[float[2]] = [0.0, 0.0], angle: float = 0) None#
property transform#
property use_target_position#
class vortex.format.RadialFormatExecutor#
property config#
format(*args, **kwargs)#

Overloaded function.

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

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

initialize(self: vortex.format.RadialFormatExecutor, arg0: vortex.format.RadialFormatExecutorConfig) None#
class vortex.format.RadialFormatExecutorConfig#
property angular_extent#
copy(self: vortex.format.RadialFormatExecutorConfig) vortex.format.RadialFormatExecutorConfig#
property erase_after_volume#
property radial_extent#
property radial_records_per_segment#
property radial_segments_per_volume#
property radial_shape#
property sample_slice#
property sample_transform#
property segment_rt_extent#
property volume_xy_extent#
property x_extent#
property y_extent#
class vortex.format.Resize#
property records_per_segment#
property segments_per_volume#
property shape#
class vortex.format.SimpleSlice#
copy(self: vortex.format.SimpleSlice) vortex.format.SimpleSlice#
count(self: vortex.format.SimpleSlice) int#
property start#
property step#
property stop#
class vortex.format.StackFormatExecutor#
property config#
initialize(self: vortex.format.StackFormatExecutor, arg0: vortex.format.StackFormatExecutorConfig) None#
class vortex.format.StackFormatExecutorConfig#
copy(self: vortex.format.StackFormatExecutorConfig) vortex.format.StackFormatExecutorConfig#
property erase_after_volume#
property sample_slice#
property sample_transform#
class vortex.io.AnalogVoltageInput#
property channel#
copy(self: vortex.io.AnalogVoltageInput) vortex.io.AnalogVoltageInput#
property limits#
property logical_units_per_physical_unit#
property port_name#
property stream#
property terminal#
class vortex.io.AnalogVoltageOutput#
property channel#
copy(self: vortex.io.AnalogVoltageOutput) vortex.io.AnalogVoltageOutput#
property limits#
property logical_units_per_physical_unit#
property port_name#
property stream#
class vortex.io.DAQmxConfig#
property blocks_to_buffer#
property channels#
property clock#
copy(self: vortex.io.DAQmxConfig) vortex.io.DAQmxConfig#
property name#
property readwrite_timeout#
property samples_per_block#
property samples_per_second#
property stop_on_error#
validate(self: vortex.io.DAQmxConfig) None#
class vortex.io.DAQmxConfigClock#
copy(self: vortex.io.DAQmxConfigClock) vortex.io.DAQmxConfigClock#
property divisor#
property edge#
property source#
class vortex.io.DAQmxIO#
property config#
initialize(self: vortex.io.DAQmxIO, arg0: vortex.io.DAQmxConfig) None#
prepare(self: vortex.io.DAQmxIO) None#
property running#
start(self: vortex.io.DAQmxIO) None#
stop(self: vortex.io.DAQmxIO) None#
class vortex.io.DigitalInput#
property channel#
copy(self: vortex.io.DigitalInput) vortex.io.DigitalInput#
property line_name#
max_bits = 32#
property stream#
class vortex.io.DigitalOutput#
property channel#
copy(self: vortex.io.DigitalOutput) vortex.io.DigitalOutput#
property line_name#
max_bits = 32#
property stream#
class vortex.io.NullConfig#
copy(self: vortex.io.NullConfig) vortex.io.NullConfig#
validate(self: vortex.io.NullConfig) None#
class vortex.io.NullIO#
property config#
initialize(self: vortex.io.NullIO, arg0: vortex.io.NullConfig) None#
prepare(self: vortex.io.NullIO) None#
start(self: vortex.io.NullIO) None#
stop(self: vortex.io.NullIO) None#
class vortex.io.VectorChannel#
append(self: vortex.io.VectorChannel, x: Union[vortex::io::channel::analog_voltage_input_t, vortex::io::channel::analog_voltage_output_t, vortex::io::channel::digital_input_t, vortex::io::channel::digital_output_t]) None#

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

class vortex.marker.ActiveLines#
property sample#
class vortex.marker.Event#
property flags#
property id#
property sample#
class vortex.marker.Flags#
static all() vortex.marker.Flags#
clear(*args, **kwargs)#

Overloaded function.

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

Clears all bits

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

Clears indicated bit

copy(self: vortex.marker.Flags) vortex.marker.Flags#
property max_unique#
static none() vortex.marker.Flags#
set(*args, **kwargs)#

Overloaded function.

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

Sets all bits

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

Sets indicated bit

property value#
class vortex.marker.FlagsList#
append(self: vortex.marker.FlagsList, x: vortex.marker.Flags) None#

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

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

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

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

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

class vortex.marker.ScanBoundary#
property flags#
property sample#
property sequence#
property volume_count_hint#
class vortex.marker.SegmentBoundary#
property flags#
property index_in_volume#
property record_count_hint#
property reversed#
property sample#
property sequence#
class vortex.marker.VolumeBoundary#
property flags#
property index_in_scan#
property reversed#
property sample#
property segment_count_hint#
property sequence#
class vortex.memory.CpuTensorFloat32#
clear(self: vortex.memory.CpuTensorFloat32) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CpuTensorFloat32, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CpuTensorFloat32) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CpuTensorFloat64#
clear(self: vortex.memory.CpuTensorFloat64) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CpuTensorFloat64, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CpuTensorFloat64) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CpuTensorInt8#
clear(self: vortex.memory.CpuTensorInt8) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CpuTensorInt8, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CpuTensorInt8) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CpuTensorUInt16#
clear(self: vortex.memory.CpuTensorUInt16) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CpuTensorUInt16, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CpuTensorUInt16) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CpuTensorUInt64#
clear(self: vortex.memory.CpuTensorUInt64) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CpuTensorUInt64, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CpuTensorUInt64) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaDeviceTensorFloat32#
clear(self: vortex.memory.CudaDeviceTensorFloat32) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaDeviceTensorFloat32, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaDeviceTensorFloat32) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaDeviceTensorFloat64#
clear(self: vortex.memory.CudaDeviceTensorFloat64) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaDeviceTensorFloat64, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaDeviceTensorFloat64) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaDeviceTensorInt8#
clear(self: vortex.memory.CudaDeviceTensorInt8) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaDeviceTensorInt8, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaDeviceTensorInt8) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaDeviceTensorUInt16#
clear(self: vortex.memory.CudaDeviceTensorUInt16) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaDeviceTensorUInt16, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaDeviceTensorUInt16) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaDeviceTensorUInt64#
clear(self: vortex.memory.CudaDeviceTensorUInt64) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaDeviceTensorUInt64, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaDeviceTensorUInt64) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaHostTensorFloat32#
clear(self: vortex.memory.CudaHostTensorFloat32) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaHostTensorFloat32, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaHostTensorFloat32) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaHostTensorFloat64#
clear(self: vortex.memory.CudaHostTensorFloat64) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaHostTensorFloat64, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaHostTensorFloat64) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaHostTensorInt8#
clear(self: vortex.memory.CudaHostTensorInt8) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaHostTensorInt8, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaHostTensorInt8) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaHostTensorUInt16#
clear(self: vortex.memory.CudaHostTensorUInt16) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaHostTensorUInt16, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaHostTensorUInt16) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.memory.CudaHostTensorUInt64#
clear(self: vortex.memory.CudaHostTensorUInt64) None#
property count#
property data#
property dimension#
property dtype#
resize(self: vortex.memory.CudaHostTensorUInt64, shape: List[int]) None#
property shape#
shrink(self: vortex.memory.CudaHostTensorUInt64) None#
property size_in_bytes#
property stride#
property stride_in_bytes#
property underlying_size_in_bytes#
property valid#
class vortex.process.CUDAProcessor#

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

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

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

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

  • reducing the window of the rolling average, and

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

All other changes will likely require a buffer reallocation.

configCUDAProcessorConfig

New configuration to apply.

property config#
Type

CUDAProcessorConfig

Copy of the current configuration.

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

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

configCUDAProcessorConfig

New configuration to apply.

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

Process the next buffer.

input_buffercupy.ndarray[cupy.uint16]

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

output_buffercupy.ndarray[cupy.int8]

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

idint

Number to associate with the buffer for logging purposes.

append_historybool

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

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

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

__CAUTION__

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

input_buffercupy.ndarray[cupy.uint16]

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

output_buffercupy.ndarray[cupy.int8]

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

callbackCallable[[Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

append_historybool

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

class vortex.process.CUDAProcessorConfig#

Base: CPUProcessorConfig

Configuration object for CUDAProcessor.

property ascans_per_block#
Type

int

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

property average_window#
Type

int

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

__NOTE__

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

__WARNING__

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

property channel#
Type

int

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

__NOTE__

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

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

Create a copy of this configuration.

CUDAProcessorConfig

The copy.

property device#
Type

int

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

property enable_ifft#
Type

bool

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

__NOTE__

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

property enable_log10#

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

property input_shape#
Type

List[int[3]]

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

property output_shape#
Type

List[int[3]]

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

property records_per_block#
Type

int

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

property resampling_samples#
Type

numpy.ndarray[numpy.float32]

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

property samples_per_ascan#
Type

int

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

property samples_per_record#
Type

int

Number of samples per record.

property slots#
Type

int

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

property spectral_filter#
Type

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

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.process.CopyProcessor#

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

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

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

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

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

__DANGER__

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

configCopyProcessorConfig

New configuration to apply.

property config#
Type

CopyProcessorConfig

Copy of the active configuration.

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

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

configCopyProcessorConfig

New configuration to apply.

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

Process the next buffer.

input_buffernumpy.ndarray[numpy.uint16]

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

output_buffernumpy.ndarray[numpy.int8]

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

idint

Number to associate with the buffer for logging purposes.

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

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

__CAUTION__

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

input_buffernumpy.ndarray[numpy.uint16]

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

output_buffernumpy.ndarray[numpy.int8]

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

callbackCallable[[Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

class vortex.process.CopyProcessorConfig#

Base: NullProcessorConfig

Configuration object for CopyProcessor.

property ascans_per_block#
Type

int

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

property channel#
copy(self: vortex.process.CopyProcessorConfig) vortex.process.CopyProcessorConfig#

Create a copy of this configuration.

CopyProcessorConfig

The copy.

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

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

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

property input_shape#
Type

List[int[3]]

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

property output_shape#
Type

List[int[3]]

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

property records_per_block#
Type

int

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

property sample_slice#
Type

[NullSlice | SimpleSlice]

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

property sample_transform#
Type

[NullTransform | LinearTransform ]

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

property samples_per_ascan#
Type

int

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

property samples_per_record#
Type

int

Number of samples per record.

property slots#
Type

int

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

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

class vortex.process.NullProcessor#

Perform no processing.

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

property config#
Type

NullProcessorConfig

Copy of the active configuration.

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

Configuration object for NullProcessor.

property ascans_per_block#
Type

int

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

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

Create a copy of this configuration.

NullProcessorConfig

The copy.

property input_shape#
Type

List[int[3]]

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

property output_shape#
Type

List[int[3]]

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

property records_per_block#
Type

int

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

property samples_per_ascan#
Type

int

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

property samples_per_record#
Type

int

Number of samples per record.

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

Check the configuration for errors.

RuntimeError

If the configuration is invalid.

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

SegmentedScanConfig

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

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

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

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

next(*args, **kwargs)#

Overloaded function.

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

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

prepare(*args, **kwargs)#

Overloaded function.

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

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

countOptional[int]

Number of samples to buffer.

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

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

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)#

Overloaded function.

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns

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

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

Prepare the scan and return all markers.

Returns

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

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

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.FreeformScanConfig#

Base: SegmentedScanConfig

Configuration object for FreeformScan.

property bypass_limits_check#
Type

bool

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

property channels_per_sample#
Type

int

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

property consolidate#
Type

bool

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

copy(self: vortex.scan.FreeformScanConfig) vortex.scan.FreeformScanConfig#
property inactive_policy#
Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

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

property limits#
Type

List[Limits]

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

property loop#
Type

bool

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

property pattern#
property samples_per_second#
Type

int

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

property sampling_interval#
Type

float

Interval between samples computed from samples_per_second. Read-only.

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

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

class vortex.scan.Limits#

Dynamics limits for a single axis.

property acceleration#
Type

float

Absolute value of velocity limit.

copy(self: vortex.scan.Limits) vortex.scan.Limits#
property position#
Type

Range

Upper and lower positions bounds.

property velocity#
Type

float

Absolute value of velocity limit.

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

SegmentedScanConfig

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

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

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

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

next(*args, **kwargs)#

Overloaded function.

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

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

prepare(*args, **kwargs)#

Overloaded function.

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

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

countOptional[int]

Number of samples to buffer.

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

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

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)#

Overloaded function.

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns

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

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

Prepare the scan and return all markers.

Returns

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

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

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RadialScanConfig#

Bases: RadialWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RadialScan.

All members are inherited.

property angle#
property ascans_per_bscan#
property bidirectional_segments#
property bidirectional_volumes#
property bscan_extent#
property bscans_per_volume#
property bypass_limits_check#
Type

bool

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

property channels_per_sample#
Type

int

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

property consolidate#
Type

bool

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

copy(*args, **kwargs)#

Overloaded function.

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

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

property extents#
property flags#
property inactive_policy#
Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

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

property limits#
Type

List[Limits]

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

property loop#
Type

bool

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

property offset#
property samples_per_second#
Type

int

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

property samples_per_segment#
property sampling_interval#
Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent#
property segments_per_volume#
set_aiming(self: vortex.scan.RadialScanConfig) None#
set_evenly_spaced(self: vortex.scan.RadialScanConfig, arg0: int) None#
set_half_evenly_spaced(self: vortex.scan.RadialScanConfig, arg0: int) None#
property shape#
to_pattern(*args, **kwargs)#

Overloaded function.

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

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

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

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RadialScanConfig) numpy.ndarray[numpy.float64]#
property volume_extent#
property warp#
class vortex.scan.RadialWaypoints#

Base: XYWaypoints

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

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

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

property angle#
Type

float

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

property ascans_per_bscan#
Type

int

Alias for samples_per_segment

property bscan_extent#
Type

Range

Alias for segment_extent.

property bscans_per_volume#
Type

int

Alias for segments_per_volume.

property extents#
Type

list[Range]

Scan extents as [volume_extent, segment_extent].

property offset#
Type

tuple[float]

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

property samples_per_segment#
Type

int

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

property segment_extent#
Type

Range

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

property segments_per_volume#
Type

int

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

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

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

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

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

nint

Number of segments to use.

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

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

nint

Number of segments to use.

property shape#
Type

list[int]

Scan shape as [segments_per_volume, samples_per_segment].

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

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

Returns

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

property volume_extent#
Type

Range

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

property warp#
Type

[NoWarp | AngularWarp | TelecentricWarp]

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

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

SegmentedScanConfig

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

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

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

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

next(*args, **kwargs)#

Overloaded function.

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

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

prepare(*args, **kwargs)#

Overloaded function.

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

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

countOptional[int]

Number of samples to buffer.

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

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

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)#

Overloaded function.

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns

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

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

Prepare the scan and return all markers.

Returns

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

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

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RasterScanConfig#

Bases: RasterWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RasterScan.

All members are inherited.

property angle#
property ascans_per_bscan#
property bidirectional_segments#
property bidirectional_volumes#
property bscan_extent#
property bscans_per_volume#
property bypass_limits_check#
Type

bool

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

property channels_per_sample#
Type

int

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

property consolidate#
Type

bool

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

copy(*args, **kwargs)#

Overloaded function.

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

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

property extents#
property flags#
property inactive_policy#
Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

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

property limits#
Type

List[Limits]

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

property loop#
Type

bool

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

property offset#
property samples_per_second#
Type

int

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

property samples_per_segment#
property sampling_interval#
Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent#
property segments_per_volume#
property shape#
to_pattern(*args, **kwargs)#

Overloaded function.

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

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

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

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RasterScanConfig) numpy.ndarray[numpy.float64]#
property volume_extent#
property warp#
class vortex.scan.RasterWaypoints#

Base: XYWaypoints

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

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

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

property angle#
Type

float

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

property ascans_per_bscan#
Type

int

Alias for samples_per_segment

property bscan_extent#
Type

Range

Alias for segment_extent.

property bscans_per_volume#
Type

int

Alias for segments_per_volume.

property extents#
Type

list[Range]

Scan extents as [volume_extent, segment_extent].

property offset#
Type

tuple[float]

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

property samples_per_segment#
Type

int

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

property segment_extent#
Type

Range

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

property segments_per_volume#
Type

int

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

property shape#
Type

list[int]

Scan shape as [segments_per_volume, samples_per_segment].

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

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

Returns

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

property volume_extent#
Type

Range

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

property warp#
Type

[NoWarp | AngularWarp | TelecentricWarp]

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

class vortex.scan.RepeatFlags#
copy(self: vortex.scan.RepeatFlags) vortex.scan.RepeatFlags#
property flags#
class vortex.scan.RepeatOrder#
copy(self: vortex.scan.RepeatOrder) vortex.scan.RepeatOrder#
property flags#
class vortex.scan.RepeatPack#
copy(self: vortex.scan.RepeatPack) vortex.scan.RepeatPack#
property flags#
class vortex.scan.RepeatedPattern#

Repeat segments with specified repetition count and period.

property bidirectional_segments#
Type

bool

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

__CAUTION__

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

__SEEALSO__

copy(self: vortex.scan.RepeatedPattern) vortex.scan.RepeatedPattern#
property repeat_count#
Type

int

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

property repeat_period#
Type

int

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

property repeat_strategy#
Type

[RepeatOrder | RepeatPack | RepeatFlags]

The strategy for handling repeated segments in memory.

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

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

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

Default is RepeatPack().

to_pattern(*args, **kwargs)#

Overloaded function.

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

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

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

SegmentedScanConfig

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

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

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

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

next(*args, **kwargs)#

Overloaded function.

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

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

prepare(*args, **kwargs)#

Overloaded function.

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

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

countOptional[int]

Number of samples to buffer.

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

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

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)#

Overloaded function.

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns

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

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

Prepare the scan and return all markers.

Returns

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

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

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RepeatedRadialScanConfig#

Bases: RepeatedRadialWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RepeatedRadialScan.

All members are inherited.

property angle#
property ascans_per_bscan#
property bidirectional_segments#
property bscan_extent#
property bscans_per_volume#
property bypass_limits_check#
Type

bool

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

property channels_per_sample#
Type

int

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

property consolidate#
Type

bool

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

copy(*args, **kwargs)#

Overloaded function.

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

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

property extents#
property inactive_policy#
Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

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

property limits#
Type

List[Limits]

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

property loop#
Type

bool

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

property offset#
property repeat_count#
property repeat_period#
property repeat_strategy#
property samples_per_second#
Type

int

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

property samples_per_segment#
property sampling_interval#
Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent#
property segments_per_volume#
set_aiming(self: vortex.scan.RepeatedRadialScanConfig) None#
set_evenly_spaced(self: vortex.scan.RepeatedRadialScanConfig, arg0: int) None#
set_half_evenly_spaced(self: vortex.scan.RepeatedRadialScanConfig, arg0: int) None#
property shape#
to_pattern(*args, **kwargs)#

Overloaded function.

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

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

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

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RepeatedRadialScanConfig) numpy.ndarray[numpy.float64]#
property volume_extent#
property warp#
class vortex.scan.RepeatedRasterScan#
change(self: vortex.scan.RepeatedRasterScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::raster_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::repeated_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __int64, unsigned char> > >, restart: bool = False, event_id: int = 0) None#
property config#
Type

SegmentedScanConfig

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

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

Initialize the scan using the supplied configuration.

configSegmentedScanConfig

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

next(*args, **kwargs)#

Overloaded function.

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

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

prepare(*args, **kwargs)#

Overloaded function.

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

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

countOptional[int]

Number of samples to buffer.

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

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

countOptional[int]

Number of samples to buffer.

restart(*args, **kwargs)#

Overloaded function.

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

__NOTE__

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

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns

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

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

Prepare the scan and return all markers.

Returns

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

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

Return a list of segments in this scan.

Returns

List[Segment] – The scan segments.

class vortex.scan.RepeatedRasterScanConfig#

Bases: RasterWaypoints, RepeatedPattern, SegmentedScanConfig

Configuration object for RepeatedRasterScan.

All members are inherited.

property angle#
property ascans_per_bscan#
property bidirectional_segments#
property bscan_extent#
property bscans_per_volume#
property bypass_limits_check#
Type

bool

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

property channels_per_sample#
Type

int

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

property consolidate#
Type

bool

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

copy(*args, **kwargs)#

Overloaded function.

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

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

property extents#
property inactive_policy#
Type

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

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

property limits#
Type

List[Limits]

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

property loop#
Type

bool

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

property offset#
property repeat_count#
property repeat_period#
property repeat_strategy#
property samples_per_second#
Type

int

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

property samples_per_segment#
property sampling_interval#
Type

float

Interval between samples computed from samples_per_second. Read-only.

property segment_extent#
property segments_per_volume#
property shape#
to_pattern(*args, **kwargs)#

Overloaded function.

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

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

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

Generate the segments described by this configuration.

Returns

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

to_waypoints(self: vortex.scan.RepeatedRasterScanConfig) numpy.ndarray[numpy.float64]#
property volume_extent#
property warp#
class vortex.scan.Segment#

An active segment as part of a SegmentedScan.

copy(self: vortex.scan.Segment) vortex.scan.Segment#
property entry_position#
Type

numpy.ndarray[float]

Accessor for the first sample position. Read only.

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

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

samples_per_secondfloat

Sampling rate for the velocity calculation.

Returns

numpy.ndarray[float] – The calculated velocity.

property exit_position#
Type

numpy.ndarray[float]

Accessor for the last sample position. Read only.

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

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

samples_per_secondfloat

Sampling rate for the velocity calculation.

Returns

numpy.ndarray[float] – The calculated velocity.

property markers#
Type

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

List of markers associated with this segment.

property position#
Type

numpy.ndarray[float]

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

class vortex.scan.SegmentList#
append(self: List[vortex.scan.Segment], x: vortex.scan.Segment) None#

Add an item to the end of the list

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

Clear the contents

extend(*args, **kwargs)#

Overloaded function.

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

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

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

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

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

Insert an item at a given position.

pop(*args, **kwargs)#

Overloaded function.

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

Remove and return the last item

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

Remove and return the item at index i

class vortex.scan.SequentialPattern#

Visit segments in sequential order with optional bidirectionality.

property bidirectional_segments#
Type

bool

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

property bidirectional_volumes#
Type

bool

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

copy(self: vortex.scan.SequentialPattern) vortex.scan.SequentialPattern#
property flags#
Type

Flags

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

to_pattern(*args, **kwargs)#

Overloaded function.

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

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

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

Overloaded function.

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

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

prepare(*args, **kwargs)#

Overloaded function.

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

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

restart(*args, **kwargs)#

Overloaded function.

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

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

scan_buffer(self: vortex.scan.SpiralScan) numpy.ndarray[numpy.float64]#
scan_markers(self: vortex.scan.SpiralScan) vortex.marker.MarkerList#
scan_segments(self: vortex.scan.SpiralScan) List[vortex.scan.Segment]#
class vortex.scan.SpiralScanConfig#
property acceleration_limit#
property angle#
property angular_velocity#
property ascans_per_bscan#
property bidirectional_segments#
property bidirectional_volumes#
property bscan_extent#
property bscans_per_volume#
property bypass_limits_check#
property channels_per_sample#
property consolidate#
copy(*args, **kwargs)#

Overloaded function.

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

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

property extents#
property flags#
property inactive_policy#
property inner_radius#
property limits#
property linear_velocity#
property loop#
property offset#
property outer_radius#
property radial_pitch#
property rings_per_spiral#
property samples_per_second#
property samples_per_segment#
property sampling_interval#
property segment_extent#
property segments_per_volume#
set_hybrid(self: vortex.scan.SpiralScanConfig, arg0: int) None#
set_isotropic(self: vortex.scan.SpiralScanConfig, arg0: int) None#
property shape#
to_pattern(*args, **kwargs)#

Overloaded function.

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

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

to_segments(self: vortex.scan.SpiralScanConfig) List[vortex.scan.Segment]#
to_waypoints(self: vortex.scan.SpiralScanConfig) numpy.ndarray[numpy.float64]#
property volume_extent#
property warp#
class vortex.scan.SpiralWaypoints#
property acceleration_limit#</