stream

Module: stream.client

FuryStreamClient(showm, *[, ...])	This obj is responsible to create a StreamClient.
FuryStreamInteraction(showm, *[, ...])	This obj.
callback_stream_client(stream_client)	This callback is used to update the image inside of the ImageManager instance
interaction_callback(circular_queue, showm, ...)	This callback is used to invoke vtk interaction events reading those events from the provided circular_queue instance

Module: stream.constants

_CQUEUE_EVENT_IDs
_CQUEUE_INDEX_INFO
_CQUEUE

Module: stream.server

Module: stream.server.async_app

pcs	set() -> new empty set object set(iterable) -> new set object
set_weel(data, circular_queue)
set_mouse(data, circular_queue)
set_mouse_click(data, circular_queue)	3 | LeftButtonPressEvent 4 | LeftButtonReleaseEvent 5 | MiddleButtonPressEvent 6 | MiddleButtonReleaseEvent 7 | RightButtonPressEvent 8 | RightButtonReleaseEvent
get_app(*[, rtc_server, folder, ...])

Module: stream.server.main

RTCServer(image_buffer_manager)	This Obj it's responsible to create the VideoStream for the WebRTCServer
web_server_raw_array(*[, image_buffers, ...])	This will create a streaming webserver running on the given port and host using RawArrays.
web_server(*[, image_buffer_names, ...])	This will create a streaming webserver running on the given port and host using SharedMemory.

Module: stream.tools

GenericMultiDimensionalBuffer(*[, max_size, ...])	This implements a abstract (generic) multidimensional buffer.
RawArrayMultiDimensionalBuffer(max_size, *)	This implements a multidimensional buffer with RawArray.
SharedMemMultiDimensionalBuffer(max_size, *)	This implements a generic multidimensional buffer with SharedMemory.
GenericCircularQueue(*[, max_size, ...])	This implements a generic circular queue which works with shared memory resources.
ArrayCircularQueue(*[, max_size, dimension, ...])	This implements a MultiDimensional Queue which works with Arrays and RawArrays.
SharedMemCircularQueue(*[, max_size, ...])	This implements a MultiDimensional Queue which works with SharedMemory.
GenericImageBufferManager(*[, ...])	This implements a abstract (generic) ImageBufferManager with the n-buffer technique.
RawArrayImageBufferManager(*[, ...])	This implements an ImageBufferManager using RawArrays.
SharedMemImageBufferManager(*[, ...])	This implements an ImageBufferManager using the SharedMemory approach.
IntervalTimerThreading(seconds, callback, ...)	Implements a object with the same behavior of setInterval from Js
IntervalTimer(seconds, callback, *args, **kwargs)	A object that creates a timer that calls a function periodically.
remove_shm_from_resource_tracker()	Monkey-patch multiprocessing.resource_tracker so SharedMemory won't be tracked

Module: stream.widget

Widget(showm, *[, ms_stream, ...])	This Obj it's able execute the fury streaming system using the SharedMemory object from Python multiprocessing.
check_port_is_available(host, port)	Check if a given port it's available

FuryStreamClient

class fury.stream.client.FuryStreamClient(showm, *, max_window_size=None, use_raw_array=True, whithout_iren_start=False, num_buffers=2)

Bases: object

This obj is responsible to create a StreamClient.

cleanup()

Release the shared memory resources if necessary.

start(*, ms=0, use_asyncio=False)

Start the stream client.

Parameters:

msfloat, optional

positive number. This update the image buffer using a interval of ms milliseconds. If ms is 0 then the stream client will update the buffer after every Render event.

use_asynciobool, optional

If False then the stream client will update the image using a threading technique.

stop()

Stop the stream client.

FuryStreamInteraction

class fury.stream.client.FuryStreamInteraction(showm, *, max_queue_size=50, use_raw_array=True, whithout_iren_start=False)

Bases: object

This obj. is responsible to manage the user interaction

cleanup()

Release the shared memory resources if necessary.

start(*, ms=3, use_asyncio=False)

Start the stream interaction client.

Parameters:

msfloat, optional

positive number greater than zero.

use_asynciobool, optional

If False then the interaction will be performed in a separate thread.

stop()

Stop the stream interaction client.

callback_stream_client

fury.stream.client.callback_stream_client(stream_client)

This callback is used to update the image inside of the ImageManager instance

Parameters:

stream_clientStreamClient

interaction_callback

fury.stream.client.interaction_callback(circular_queue, showm, iren, render_after)

This callback is used to invoke vtk interaction events reading those events from the provided circular_queue instance

Parameters:

circular_queueCircularQueue

showmShowmManager

irenvtkInteractor

render_afterbool, optional

If the render method should be called after an dequeue

_CQUEUE_EVENT_IDs

fury.stream.constants._CQUEUE_EVENT_IDs

_CQUEUE_INDEX_INFO

fury.stream.constants._CQUEUE_INDEX_INFO

_CQUEUE

fury.stream.constants._CQUEUE

pcs

fury.stream.server.async_app.pcs

set() -> new empty set object set(iterable) -> new set object

Build an unordered collection of unique elements.

set_weel

fury.stream.server.async_app.set_weel(data, circular_queue)

set_mouse

fury.stream.server.async_app.set_mouse(data, circular_queue)

set_mouse_click

fury.stream.server.async_app.set_mouse_click(data, circular_queue)

3 | LeftButtonPressEvent 4 | LeftButtonReleaseEvent 5 | MiddleButtonPressEvent 6 | MiddleButtonReleaseEvent 7 | RightButtonPressEvent 8 | RightButtonReleaseEvent

get_app

fury.stream.server.async_app.get_app(*, rtc_server=None, folder=None, circular_queue=None, image_buffer_manager=None, provides_mjpeg=False, broadcast=True)

RTCServer

class fury.stream.server.main.RTCServer(image_buffer_manager)

Bases: object

This Obj it’s responsible to create the VideoStream for the WebRTCServer

async recv()

Return a VideoFrame to be used in the WebRTC Server

The frame will be created using the image stored in the shared memory

Returns:

frameVideoFrame

release()

Release the RTCServer

web_server_raw_array

fury.stream.server.main.web_server_raw_array(*, image_buffers=None, info_buffer=None, queue_head_tail_buffer=None, queue_buffer=None, port=8000, host='localhost', provides_mjpeg=True, provides_webrtc=True, ms_jpeg=16, run_app=True)

This will create a streaming webserver running on the given port and host using RawArrays.

Parameters:

image_bufferslist of buffers

A list of buffers with each one containing a frame.

info_bufferbuffer

A buffer with the information about the current frame to be streamed and the respective sizes

queue_head_tail_bufferbuffer

If buffer is passed than this Obj will read a a already created RawArray.

queue_bufferbuffer

If queue_buffer is passed than this Obj will read a a already created RawArray containing the user interactions events stored in the queue_buffer.

portint, optional

Port to be used by the aiohttp server

hoststr, optional, default localhost

host to be used by the aiohttp server

provides_mjpegbool, default True

If a MJPEG streaming should be available. If True you can consume that through host:port/video/mjpeg or if you want to interact you can consume that through your browser http://host:port?encoding=mjpeg

provides_webrtcbool, default True

If a WebRTC streaming should be available. http://host:port

ms_jpegfloat, optional

This it’s used only if the MJPEG will be used. The ms_jpeg represents the amount of milliseconds between to consecutive calls of the jpeg encoding.

run_appbool, default True

This will run the aiohttp application. The False condition is used just to be able to test the server.

web_server

fury.stream.server.main.web_server(*, image_buffer_names=None, info_buffer_name=None, queue_head_tail_buffer_name=None, queue_buffer_name=None, port=8000, host='localhost', provides_mjpeg=True, provides_webrtc=True, avoid_unlink_shared_mem=True, ms_jpeg=16, run_app=True)

This will create a streaming webserver running on the given port and host using SharedMemory.

Parameters:

image_buffers_namelist of str

A list of buffers with each one containing a frame.

info_buffer_namestr

A buffer with the information about the current frame to be streamed and the respective sizes

queue_head_tail_buffer_namestr, optional

If buffer is passed than this Obj will read a a already created RawArray.

buffer_namestr, optional

If queue_buffer is passed than this Obj will read a a already created RawArray containing the user interactions events stored in the queue_buffer.

portint, optional

Port to be used by the aiohttp server

hoststr, optional, default localhost

host to be used by the aiohttp server

provides_mjpegbool, default True

If a MJPEG streaming should be available. If True you can consume that through host:port/video/mjpeg or if you want to interact you can consume that through your browser http://host:port?encoding=mjpeg

provides_webrtcbool, default True

If a WebRTC streaming should be available. http://host:port

avoid_unlink_shared_membool, default False

If True, then this will apply a monkey-patch solution to a python>=3.8 core bug

ms_jpegfloat, optional

This it’s used only if the MJPEG will be used. The ms_jpeg represents the amount of milliseconds between to consecutive calls of the jpeg encoding.

run_appbool, default True

This will run the aiohttp application. The False condition is used just to be able to test the server.

GenericMultiDimensionalBuffer

class fury.stream.tools.GenericMultiDimensionalBuffer(*, max_size=None, dimension=8)

Bases: ABC

This implements a abstract (generic) multidimensional buffer.

property buffer

abstract cleanup()

abstract create_mem_resource()

get_start_end(idx)

abstract load_mem_resource()

RawArrayMultiDimensionalBuffer

class fury.stream.tools.RawArrayMultiDimensionalBuffer(max_size, *, dimension=4, buffer=None)

Bases: GenericMultiDimensionalBuffer

This implements a multidimensional buffer with RawArray.

cleanup()

create_mem_resource()

load_mem_resource()

SharedMemMultiDimensionalBuffer

class fury.stream.tools.SharedMemMultiDimensionalBuffer(max_size, *, dimension=4, buffer_name=None)

Bases: GenericMultiDimensionalBuffer

This implements a generic multidimensional buffer with SharedMemory.

cleanup()

create_mem_resource()

load_mem_resource()

GenericCircularQueue

class fury.stream.tools.GenericCircularQueue(*, max_size=None, dimension=8, use_shared_mem=False, buffer=None, buffer_name=None)

Bases: ABC

This implements a generic circular queue which works with shared memory resources.

abstract cleanup()

abstract create_mem_resource()

abstract dequeue()

abstract enqueue(data)

property head

abstract load_mem_resource()

set_head_tail(head, tail, lock=1)

property tail

ArrayCircularQueue

class fury.stream.tools.ArrayCircularQueue(*, max_size=10, dimension=6, head_tail_buffer=None, buffer=None)

Bases: GenericCircularQueue

This implements a MultiDimensional Queue which works with Arrays and RawArrays.

cleanup()

create_mem_resource()

dequeue()

enqueue(data)

load_mem_resource()

SharedMemCircularQueue

class fury.stream.tools.SharedMemCircularQueue(*, max_size=10, dimension=6, head_tail_buffer_name=None, buffer_name=None)

Bases: GenericCircularQueue

This implements a MultiDimensional Queue which works with SharedMemory.

cleanup()

create_mem_resource()

dequeue()

enqueue(data)

is_unlocked()

load_mem_resource()

lock()

unlock()

GenericImageBufferManager

class fury.stream.tools.GenericImageBufferManager(*, max_window_size=None, num_buffers=2, use_shared_mem=False)

Bases: ABC

This implements a abstract (generic) ImageBufferManager with the n-buffer technique.

async_get_jpeg(*, ms=33)

property buffer_index

abstract cleanup()

abstract create_mem_resource()

get_current_frame()

Get the current frame from the buffer.

get_jpeg()

Returns a jpeg image from the buffer.

Returns:

bytes: jpeg image.

abstract load_mem_resource()

property next_buffer_index

write_into(w, h, np_arr)

RawArrayImageBufferManager

class fury.stream.tools.RawArrayImageBufferManager(*, max_window_size=(100, 100), num_buffers=2, image_buffers=None, info_buffer=None)

Bases: GenericImageBufferManager

This implements an ImageBufferManager using RawArrays.

cleanup()

create_mem_resource()

load_mem_resource()

SharedMemImageBufferManager

class fury.stream.tools.SharedMemImageBufferManager(*, max_window_size=(100, 100), num_buffers=2, image_buffer_names=None, info_buffer_name=None)

Bases: GenericImageBufferManager

This implements an ImageBufferManager using the SharedMemory approach.

cleanup()

Release the resources used by the Shared Memory Manager

create_mem_resource()

load_mem_resource()

IntervalTimerThreading

class fury.stream.tools.IntervalTimerThreading(seconds, callback, *args, **kwargs)

Bases: object

Implements a object with the same behavior of setInterval from Js

start()

Start the timer

stop()

Stop the timer

IntervalTimer

class fury.stream.tools.IntervalTimer(seconds, callback, *args, **kwargs)

Bases: object

A object that creates a timer that calls a function periodically.

start()

Start the timer

stop()

Stop the timer

remove_shm_from_resource_tracker

fury.stream.tools.remove_shm_from_resource_tracker()

Monkey-patch multiprocessing.resource_tracker so SharedMemory won’t be tracked

Notes

More details at: https://bugs.python.org/issue38119

Widget

class fury.stream.widget.Widget(showm, *, ms_stream=33, ms_interaction=33, host='localhost', port=None, encoding='mjpeg', ms_jpeg=33, queue_size=20)

Bases: object

This Obj it’s able execute the fury streaming system using the SharedMemory object from Python multiprocessing.

cleanup()

Release the shared memory

property command_string

Return the command string to start the server

Returns:

command_stringstr

display(*, height=150)

Start the server and display the url in an iframe

return_iframe(*, height=200)

Return the jupyter div iframe used to show the stream

run_command()

Evaluate the command string to start the server

start(*, use_asyncio=False)

Start the fury client and the interaction client and return the url

Parameters:

use_asynciobool, optional

If should use the asyncio version of the server. Default is False.

stop()

Stop the streaming server and release the shared memory

property url

Return the url to access the server

check_port_is_available

fury.stream.widget.check_port_is_available(host, port)

Check if a given port it’s available

Parameters:

hoststr

portint

Returns:

availablebool