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

Acquire data from a file.

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

__NOTE__

This component supports preloading with the engine.

property config
Type:

FileAcquisitionConfig

Copy of the active configuration.

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

Initialize the acquisition using the supplied configuration.

Parameters

configFileAcquisitionConfig

New configuration to apply.

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

Acquire the buffer and return the number of acquired records.

Parameters

buffernumpy.ndarray[numpy.uint16]

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

idint

Number to associate with the buffer for logging purposes.

Returns

int

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

Raises

RuntimeError

If the acquisition fails.

prepare(self: vortex.acquire.FileAcquisition) None

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

start(self: vortex.acquire.FileAcquisition) None

Start the acquisition, and open the source file.

stop(self: vortex.acquire.FileAcquisition) None

Stop the acquisition, and close the source file.

class vortex.acquire.FileAcquisitionConfig

Base: NullAcquisitionConfig

Configuration object for FileAcquisition.

property channels_per_sample
Type:

int

Number of channels that comprise each sample.

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

Return a copy of this configuration.

Returns

FileAcquisitionConfig

The copy.

property loop
Type:

bool

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

property path
Type:

str

Path to file that backs the acquisition.

property records_per_block
Type:

int

Number of records in each acquired buffer or block.

property samples_per_record
Type:

int

Number of samples per record.

property shape
Type:

List[int[3]]

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

validate(self: vortex.acquire.FileAcquisitionConfig) None

Check the configuration for errors.

Raises

RuntimeError

If the configuration is invalid.

class vortex.acquire.NullAcquisition

Perform no acquisition.

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

__NOTE__

This component supports preloading with the engine.

property config
Type:

NullAcquisitionConfig

Copy of the active configuration.

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

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

Parameters

configNullAcquisitionConfig

New configuration to apply.

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

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

Parameters

buffernumpy.ndarray[numpy.uint16]

The buffer to acquire.

idint

Number to associate with the buffer for logging purposes.

Returns

int

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

prepare(self: vortex.acquire.NullAcquisition) None

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

start(self: vortex.acquire.NullAcquisition) None

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

stop(self: vortex.acquire.NullAcquisition) None

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

class vortex.acquire.NullAcquisitionConfig

Configuration object for NullAcquisition.

property channels_per_sample
Type:

int

Number of channels that comprise each sample.

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

Create a copy of this configuration.

Returns

NullAcquisitionConfig

The copy.

property records_per_block
Type:

int

Number of records in each acquired buffer or block.

property samples_per_record
Type:

int

Number of samples per record.

property shape
Type:

List[int[3]]

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

validate(self: vortex.acquire.NullAcquisitionConfig) None

Check the configuration for errors.

Raises

RuntimeError

If the configuration is invalid.

class vortex.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.AscanSpiralDeviceTensorEndpointInt8
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.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 aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.Block
class StreamIndex

Members:

Counter

GalvoTarget

SampleTarget

GalvoActual

SampleActual

Strobes

Counter = <StreamIndex.Counter: 0>
GalvoActual = <StreamIndex.GalvoActual: 3>
GalvoTarget = <StreamIndex.GalvoTarget: 1>
SampleActual = <StreamIndex.SampleActual: 4>
SampleTarget = <StreamIndex.SampleTarget: 2>
Strobes = <StreamIndex.Strobes: 5>
property name
property value
property counter
property galvo_actual
property galvo_target
property id
property length
property markers
property sample
property sample_actual
property sample_target
property strobes
property timestamp
class vortex.engine.BroctStorageEndpoint
property aggregate_segment_callback
property 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.CounterStreamEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.Engine

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

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

class Event

Members:

Launch

Start

Run

Stop

Complete

Shutdown

Exit

Error

Abort

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

EngineConfig

Copy of the active configuration.

property done
Type:

bool

Return True if the engine is stopped and False otherwise.

__WARNING__

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

property event_callback
Type:

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

Callback to receive status events from the engine.

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

Initialize the engine using the supplied configuration.

Parameters

configEngineConfig

New configuration to apply.

property job_callback
Type:

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

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

__CAUTION__

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

prepare(self: vortex.engine.Engine) None

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

property scan_queue
Type:

ScanQueue

Access the engine’s scan queue.

start(self: vortex.engine.Engine) None

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

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

Query the engine status.

Returns

EngineStatus

The current status of the engine.

stop(self: vortex.engine.Engine) None

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

Raises

RuntimeError

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

wait(self: vortex.engine.Engine) None

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

Raises

RuntimeError

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

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

Configuration object for Engine.

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

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

property blocks_to_allocate
Type:

int

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

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

int

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

property galvo_output_channels
Type:

int

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

property lead_marker
Type:

ScanBoundary

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

property lead_strobes
Type:

int

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

property post_scan_records
Type:

int

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

property preload_count
Type:

int

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

property records_per_block
Type:

int

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

property scanner_warp
Type:

[NoWarp | AngularWarp | TelecentricWarp]

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

property strobes
Type:

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

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

validate(self: vortex.engine.EngineConfig) None

Check the configuration for errors.

Raises

RuntimeError

If the configuration is invalid.

__WARNING__

This method is not fully implemented yet.

class vortex.engine.EngineStatus
property active
property block_utilization
copy(self: vortex.engine.EngineStatus) vortex.engine.EngineStatus
property dispatch_completion
property dispatched_blocks
property inflight_blocks
class vortex.engine.EventStrobe
property delay
property duration
property flags
property line
property polarity
class vortex.engine.GalvoActualHDF5StackEndpoint
property aggregate_segment_callback
property 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.GalvoActualStreamEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.GalvoTargetHDF5StackEndpoint
property aggregate_segment_callback
property event_callback
property executor
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.GalvoTargetStackEndpoint
property aggregate_segment_callback
property event_callback
property executor
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.GalvoTargetStreamEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.JobTiming
property acquire
property create
property format
property process
property recycle
property scan
property service
class vortex.engine.MarkerLogStorage
property storage
class vortex.engine.NullEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property update_callback
property volume_callback
class vortex.engine.Polarity

Members:

Low

High

High = <Polarity.High: 1>
Low = <Polarity.Low: 0>
property name
property value
class vortex.engine.PositionDeviceTensorEndpointInt8
property aggregate_segment_callback
property 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.SampleActualHDF5StackEndpoint
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.SampleActualStackEndpoint
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.SampleActualStreamEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.SampleStrobe
property divisor
property duration
property line
property phase
property polarity
class vortex.engine.SampleTargetHDF5StackEndpoint
property aggregate_segment_callback
property event_callback
property executor
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.SampleTargetStackEndpoint
property aggregate_segment_callback
property event_callback
property executor
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.SampleTargetStreamEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.ScanQueue

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

class Event

Members:

Start

Finish

Interrupt

Abort

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

Overloaded function.

  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.SpectraSpiralDeviceTensorEndpointUInt16
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 aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.StackDeviceTensorEndpointInt8
property aggregate_segment_callback
property 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[vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe], x: vortex.engine.SampleStrobe | vortex.engine.SegmentStrobe | vortex.engine.VolumeStrobe | vortex.engine.ScanStrobe | vortex.engine.EventStrobe) None

Add an item to the end of the list

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

Clear the contents

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

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

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

Insert an item at a given position.

pop(*args, **kwargs)

Overloaded function.

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

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

class vortex.engine.StrobesHDF5StackEndpoint
property aggregate_segment_callback
property event_callback
property executor
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.StrobesStackEndpoint
property aggregate_segment_callback
property event_callback
property executor
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.StrobesStreamEndpoint
property aggregate_segment_callback
property event_callback
property scan_callback
property segment_callback
property storage
property update_callback
property volume_callback
class vortex.engine.VolumeStrobe
property delay
property duration
property flags
property line
property polarity
vortex.engine.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 flip_reversed
property mask
property records_per_segment
property segments_per_volume
property shape
property strip_inactive
class vortex.format.LinearTransform
copy(self: vortex.format.LinearTransform) vortex.format.LinearTransform
property offset
property scale
class vortex.format.NullSlice
copy(self: vortex.format.NullSlice) vortex.format.NullSlice
class vortex.format.NullTransform
copy(self: vortex.format.NullTransform) vortex.format.NullTransform
class vortex.format.PositionFormatExecutor
property config
format(*args, **kwargs)

Overloaded function.

  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

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

initialize(self: vortex.format.PositionFormatExecutor, arg0: vortex.format.PositionFormatExecutorConfig) None
class vortex.format.PositionFormatExecutorConfig
property channels
copy(self: vortex.format.PositionFormatExecutorConfig) vortex.format.PositionFormatExecutorConfig
property erase_after_volume
property sample_slice
property sample_transform
set(self: vortex.format.PositionFormatExecutorConfig, pitch: 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

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

initialize(self: vortex.format.RadialFormatExecutor, arg0: vortex.format.RadialFormatExecutorConfig) None
class vortex.format.RadialFormatExecutorConfig
property angular_extent
copy(self: vortex.format.RadialFormatExecutorConfig) vortex.format.RadialFormatExecutorConfig
property erase_after_volume
property radial_extent
property radial_records_per_segment
property radial_segments_per_volume
property radial_shape
property sample_slice
property sample_transform
property segment_rt_extent
property volume_xy_extent
property x_extent
property y_extent
class vortex.format.Resize
property records_per_segment
property segments_per_volume
property shape
class vortex.format.SimpleSlice
copy(self: vortex.format.SimpleSlice) vortex.format.SimpleSlice
count(self: vortex.format.SimpleSlice) int
property start
property step
property stop
class vortex.format.SpiralFormatExecutor
property config
format(*args, **kwargs)

Overloaded function.

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

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

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

initialize(self: vortex.format.SpiralFormatExecutor, arg0: vortex.format.SpiralFormatExecutorConfig) None
class vortex.format.SpiralFormatExecutorConfig
copy(self: vortex.format.SpiralFormatExecutorConfig) vortex.format.SpiralFormatExecutorConfig
property erase_after_volume
property radial_extent
property rings_per_spiral
property sample_slice
property sample_transform
property samples_per_spiral
property segment_extent
property spiral_shape
property spiral_velocity
property volume_xy_extent
property x_extent
property y_extent
class vortex.format.StackFormatExecutor
property config
initialize(self: vortex.format.StackFormatExecutor, arg0: vortex.format.StackFormatExecutorConfig) None
class vortex.format.StackFormatExecutorConfig
copy(self: vortex.format.StackFormatExecutorConfig) vortex.format.StackFormatExecutorConfig
property erase_after_volume
property sample_slice
property sample_transform
class vortex.io.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.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: vortex.marker.ScanBoundary | vortex.marker.VolumeBoundary | vortex.marker.SegmentBoundary | vortex.marker.ActiveLines | vortex.marker.InactiveLines | vortex.marker.Event) None

Add an item to the end of the list

clear(self: vortex.marker.MarkerList) None

Clear the contents

count(self: vortex.marker.MarkerList, x: vortex.marker.ScanBoundary | vortex.marker.VolumeBoundary | vortex.marker.SegmentBoundary | vortex.marker.ActiveLines | vortex.marker.InactiveLines | vortex.marker.Event) int

Return the number of times x appears in the list

extend(*args, **kwargs)

Overloaded function.

  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: 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: vortex.marker.ScanBoundary | vortex.marker.VolumeBoundary | vortex.marker.SegmentBoundary | vortex.marker.ActiveLines | vortex.marker.InactiveLines | vortex.marker.Event) None

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

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

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

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

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

Parameters

configCPUProcessorConfig

New configuration to apply.

property config
Type:

CPUProcessorConfig

Copy of the active configuration.

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

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

Parameters

configCPUProcessorConfig

New configuration to apply.

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

Process the next buffer.

Parameters

input_buffernumpy.ndarray[numpy.uint16]

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

output_buffernumpy.ndarray[numpy.int8]

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

idint

Number to associate with the buffer for logging purposes.

append_historybool

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

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

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

__CAUTION__

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

Parameters

input_buffernumpy.ndarray[numpy.uint16]

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

output_buffernumpy.ndarray[numpy.int8]

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

callbackCallable[[Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

append_historybool

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

class vortex.process.CPUProcessorConfig

Base: NullProcessorConfig

Configuration object for CPUProcessor.

property ascans_per_block
Type:

int

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

property average_window
Type:

int

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

__NOTE__

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

__WARNING__

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

property channel
Type:

int

Index of channel to select for processing.

property channels_per_sample
copy(self: vortex.process.CPUProcessorConfig) vortex.process.CPUProcessorConfig

Create a copy of this configuration.

Returns

CPUProcessorConfig

The copy.

property enable_ifft
Type:

bool

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

__NOTE__

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

property enable_log10

Enable the application of \(log_{10}(...)\) to the complex magnitude. Enabled by default.

property enable_square

Enabling squaring of the complex magnitude after the FFT. When enabled, the processor output is power. When disabled, the processor output is amplitude. Enabled by default.

property input_shape
Type:

List[int[3]]

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

property output_shape
Type:

List[int[3]]

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

property records_per_block
Type:

int

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

property resampling_samples
Type:

numpy.ndarray[numpy.float32]

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

property samples_per_ascan
Type:

int

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

property samples_per_record
Type:

int

Number of samples per record.

property slots
Type:

int

Number of parallel processing pipelines. Adjust to achieve the desired CPU utilization for machines with high hardware concurrency. Recommended minimum is 2-4 slots to facilitate pipelining of successive blocks but higher numbers will likely yield better throughput. Each processing step is individually parallelized across all CPU cores; this field only affects pipeline-level parallelism. Defaults to 2.

property spectral_filter
Type:

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

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

validate(self: vortex.process.CPUProcessorConfig) None

Check the configuration for errors.

Raises

RuntimeError

If the configuration is invalid.

class vortex.process.CUDAProcessor

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

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

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

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

  • reducing the window of the rolling average, and

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

All other changes will likely require a buffer reallocation.

Parameters

configCUDAProcessorConfig

New configuration to apply.

property config
Type:

CUDAProcessorConfig

Copy of the current configuration.

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

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

Parameters

configCUDAProcessorConfig

New configuration to apply.

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

Process the next buffer.

Parameters

input_buffercupy.ndarray[cupy.uint16]

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

output_buffercupy.ndarray[cupy.int8]

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

idint

Number to associate with the buffer for logging purposes.

append_historybool

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

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

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

__CAUTION__

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

Parameters

input_buffercupy.ndarray[cupy.uint16]

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

output_buffercupy.ndarray[cupy.int8]

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

callbackCallable[[Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

append_historybool

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

class vortex.process.CUDAProcessorConfig

Base: CPUProcessorConfig

Configuration object for CUDAProcessor.

property ascans_per_block
Type:

int

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

property average_window
Type:

int

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

__NOTE__

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

__WARNING__

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

property channel
Type:

int

Index of channel to select for processing.

property channels_per_sample
property clock_channel
Type:

Optional[int]

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

__NOTE__

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

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

Create a copy of this configuration.

Returns

CUDAProcessorConfig

The copy.

property device
Type:

int

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

property enable_ifft
Type:

bool

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

__NOTE__

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

property enable_log10

Enable the application of \(log_{10}(...)\) to the complex magnitude. Enabled by default.

property enable_square

Enabling squaring of the complex magnitude after the FFT. When enabled, the processor output is power. When disabled, the processor output is amplitude. Enabled by default.

property input_shape
Type:

List[int[3]]

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

property interpret_as_signed
Type:

bool

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

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

Raises

RuntimeError

If the configuration is invalid.

class vortex.process.CopyProcessor

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

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

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

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

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

__DANGER__

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

Parameters

configCopyProcessorConfig

New configuration to apply.

property config
Type:

CopyProcessorConfig

Copy of the active configuration.

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

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

Parameters

configCopyProcessorConfig

New configuration to apply.

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

Process the next buffer.

Parameters

input_buffernumpy.ndarray[numpy.uint16]

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

output_buffernumpy.ndarray[numpy.int8]

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

idint

Number to associate with the buffer for logging purposes.

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

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

__CAUTION__

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

Parameters

input_buffernumpy.ndarray[numpy.uint16]

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

output_buffernumpy.ndarray[numpy.int8]

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

callbackCallable[[Exception], None]

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

idint

Number to associate with the buffer for logging purposes.

class vortex.process.CopyProcessorConfig

Base: NullProcessorConfig

Configuration object for CopyProcessor.

property ascans_per_block
Type:

int

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

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

Create a copy of this configuration.

Returns

CopyProcessorConfig

The copy.

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

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

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

property input_shape
Type:

List[int[3]]

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

property output_shape
Type:

List[int[3]]

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

property records_per_block
Type:

int

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

property sample_slice
Type:

[NullSlice | SimpleSlice]

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

property sample_transform
Type:

[NullTransform | LinearTransform ]

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

property samples_per_ascan
Type:

int

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

property samples_per_record
Type:

int

Number of samples per record.

property slots
Type:

int

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

validate(self: vortex.process.CopyProcessorConfig) None

Check the configuration for errors.

Raises

RuntimeError

If the configuration is invalid.

class vortex.process.NullProcessor

Perform no processing.

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

property config
Type:

NullProcessorConfig

Copy of the active configuration.

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

Configuration object for NullProcessor.

property ascans_per_block
Type:

int

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

property channels_per_sample
copy(self: vortex.process.NullProcessorConfig) vortex.process.NullProcessorConfig

Create a copy of this configuration.

Returns

NullProcessorConfig

The copy.

property input_shape
Type:

List[int[3]]

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

property output_shape
Type:

List[int[3]]

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

property records_per_block
Type:

int

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

property samples_per_ascan
Type:

int

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

property samples_per_record
Type:

int

Number of samples per record.

validate(self: vortex.process.NullProcessorConfig) None

Check the configuration for errors.

Raises

RuntimeError

If the configuration is invalid.

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

SegmentedScanConfig

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

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

Initialize the scan using the supplied configuration.

Parameters

configSegmentedScanConfig

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

next(*args, **kwargs)

Overloaded function.

  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.

Parameters

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.

Parameters

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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

  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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns:

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

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

Prepare the scan and return all markers.

Returns:

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

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

Return a list of segments in this scan.

Returns:

List[Segment] – The scan segments.

class vortex.scan.FreeformScanConfig

Base: SegmentedScanConfig

Configuration object for FreeformScan.

property bypass_limits_check
Type:

bool

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

property channels_per_sample
Type:

int

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

property consolidate
Type:

bool

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

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

[MinimumDynamicLimited | FixedDynamicLimited | FixedLinear]

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

property limits
Type:

List[Limits]

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

property loop
Type:

bool

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

property pattern
property samples_per_second
Type:

int

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

property sampling_interval
Type:

float

Interval between samples computed from samples_per_second. Read-only.

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

Generate the segments described by this configuration.

Returns:

List[Segment] – The pattern segments.

__SEEALSO__

See Interleave Different Scans for an example application.

class vortex.scan.Limits

Dynamics limits for a single axis.

property acceleration
Type:

float

Absolute value of velocity limit.

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

Range

Upper and lower positions bounds.

property velocity
Type:

float

Absolute value of velocity limit.

class vortex.scan.RadialScan
change(self: vortex.scan.RadialScan, config: vortex::scan::detail::patterned_config_factory_t<double, std::variant<vortex::scan::inactive_policy::minimum_dynamic_limited_t, vortex::scan::inactive_policy::fixed_dynamic_limited_t, vortex::scan::inactive_policy::fixed_linear_t>, vortex::scan::radial_waypoints_t<double, std::variant<vortex::scan::warp::none_t, vortex::scan::warp::angular_t, vortex::scan::warp::telecentric_t> >, vortex::scan::sequential_pattern_t<std::variant<vortex::marker::scan_boundary, vortex::marker::volume_boundary, vortex::marker::segment_boundary, vortex::marker::active_lines, vortex::marker::inactive_lines, vortex::marker::event>, vortex::marker::flags_t<unsigned __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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

  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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns:

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

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

Prepare the scan and return all markers.

Returns:

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

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

Return a list of segments in this scan.

Returns:

List[Segment] – The scan segments.

class vortex.scan.RadialScanConfig

Bases: RadialWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RadialScan.

All members are inherited.

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

bool

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.

Parameters

nint

Number of segments to use.

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

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

Parameters

nint

Number of segments to use.

property shape
Type:

list[int]

Scan shape as [segments_per_volume, samples_per_segment].

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

Generate an \(n \times m \times 2\) grid of waypoints \(W_{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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

  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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns:

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

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

Prepare the scan and return all markers.

Returns:

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

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

Return a list of segments in this scan.

Returns:

List[Segment] – The scan segments.

class vortex.scan.RasterScanConfig

Bases: RasterWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RasterScan.

All members are inherited.

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

bool

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

  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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns:

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

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

Prepare the scan and return all markers.

Returns:

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

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

Return a list of segments in this scan.

Returns:

List[Segment] – The scan segments.

class vortex.scan.RepeatedRadialScanConfig

Bases: RepeatedRadialWaypoints, SequentialPattern, SegmentedScanConfig

Configuration object for RepeatedRadialScan.

All members are inherited.

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

bool

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.

Parameters

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.

Parameters

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.

Parameters

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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

  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.

Parameters

sampleint

New sample time.

positionnumpy.ndarray[float]

New position for all channels.

velocitynumpy.ndarray[float]

New velocity for all channels.

include_startbool

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

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

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

Returns:

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

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

Prepare the scan and return all markers.

Returns:

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

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

Return a list of segments in this scan.

Returns:

List[Segment] – The scan segments.

class vortex.scan.RepeatedRasterScanConfig

Bases: RasterWaypoints, RepeatedPattern, SegmentedScanConfig

Configuration object for RepeatedRasterScan.

All members are inherited.

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

bool

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.

Parameters

samples_per_secondfloat

Sampling rate for the velocity calculation.

return numpy.ndarray[float]:

The calculated velocity.

property exit_position
Type:

numpy.ndarray[float]

Accessor for the last sample position. Read only.

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

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

Parameters

samples_per_secondfloat

Sampling rate for the velocity calculation.

return numpy.ndarray[float]:

The calculated velocity.

property markers
Type:

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

List of markers associated with this segment.

property position
Type:

numpy.ndarray[float]

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

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

Add an item to the end of the list

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

Clear the contents

extend(*args, **kwargs)

Overloaded function.

  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
property angle
property angular_velocity
property ascans_per_bscan
property bscan_extent
property bscans_per_volume
property extents
property inner_radius
property linear_velocity
property offset
property outer_radius
property radial_pitch
property rings_per_spiral
property samples_per_segment
property segment_extent
property segments_per_volume
set_hybrid(self: vortex.scan.SpiralWaypoints, arg0: int) None
set_isotropic(self: vortex.scan.SpiralWaypoints, arg0: int) None
property shape
to_waypoints(self: vortex.scan.SpiralWaypoints) numpy.ndarray[numpy.float64]
property volume_extent
property warp
class vortex.storage.BroctScan

Members:

rectangular

bscan

aiming

mscan

radial

ascan

speckle

mixed

xfast_yfast

xfast_yfast_speckle

spiral

aiming = <BroctScan.aiming: 2>
ascan = <BroctScan.ascan: 5>
bscan = <BroctScan.bscan: 1>
mixed = <BroctScan.mixed: 7>
mscan = <BroctScan.mscan: 3>
property name
radial = <BroctScan.radial: 4>
rectangular = <BroctScan.rectangular: 0>
speckle = <BroctScan.speckle: 6>
spiral = <BroctScan.spiral: 10>
property value
xfast_yfast = <BroctScan.xfast_yfast: 8>
xfast_yfast_speckle = <BroctScan.xfast_yfast_speckle: 9>
class vortex.storage.BroctStorage
advance_volume(self: vortex.storage.BroctStorage, allocate: bool = True) None