Reference

imfusion

imfusion - ImFusion SDK for Medical Imaging

This module provides Python bindings for the C++ ImFusion libraries.

class imfusion.Algorithm

Bases: BaseAlgorithm

Base class for Algorithms.

An Algorithm accepts certain Data as input and performs some computation on it.

Example for an algorithm that takes exactly one image and prints its name:

>>> class MyAlgorithm(Algorithm):
...     def __init__(self, image):
...         super().__init__()
...         self.image = image
...
...     @classmethod
...     def convert_input(cls, data):
...         images = data.images()
...         if len(images) == 1 and len(data) == 1:
...             return [images[0]]
...         raise IncompatibleError('Requires exactly one image')
...
...     def compute(self):
...         print(self.image.name)

In order to make an Algorithm available to the ImFusion Suite (i.e. the context menu when right-clicking on selected data), it has to be registered to the ApplicationController:

>>> imfusion.register_algorithm('Python.MyAlgorithm','My Algorithm', MyAlgorithm)  # DOCTEST: +skip

If the Algorithm is created through the ImFusion Suite, the convert_input() method is called to determine if the Algorithm is compatible with the desired input data. If this method does not raise an exception, the Algorithm is initialized with the data returned by convert_input(). The implementation is similar to this:

try:
    input = MyAlgorithm.convert_input(some_data)
    return MyAlgorithm(*input)
except IncompatibleError:
    return None

The Algorithm class also provides default implementations for the configuration() and configure() methods that automatically serialize attributes created with add_param().

__init__(self: BaseAlgorithm) → None

add_param(name, value, attributes='')

Add a new parameter to the object.

The parameter is available as a new attribute with the given name and value. The attribute will be configured automatically.

>>> class MyAlgorithm(Algorithm):
...     def __init__(self):
...         super().__init__()
...         self.add_param('x', 5)
>>> a = MyAlgorithm()
>>> a.x
5

configuration(self: Configurable) → Properties

configure(self: Configurable, properties: Properties) → None

classmethod convert_input(data: List[Data]) → List[Data]

Convert the given DataList to a valid input for the algorithm.

Must be overridden in derived classes. Raise an IncompatibleError if the given data does not exactly match the required input of the algorithm. Should return a list, a dict or a generator.

output(): Return the output generated by the previous call to compute(). The returned type must be a list of Data objects! The default implementation returns an empty list.

class imfusion.Annotation

Bases: pybind11_object

class AnnotationType

Bases: pybind11_object

Members:

CIRCLE

LINE

POINT

POLY_LINE

RECTANGLE

CIRCLE = <AnnotationType.CIRCLE: 0>

LINE = <AnnotationType.LINE: 1>

POINT = <AnnotationType.POINT: 2>

POLY_LINE = <AnnotationType.POLY_LINE: 3>

RECTANGLE = <AnnotationType.RECTANGLE: 4>

__init__(self: AnnotationType, value: int) → None

property name

property value

CIRCLE = <AnnotationType.CIRCLE: 0>

LINE = <AnnotationType.LINE: 1>

POINT = <AnnotationType.POINT: 2>

POLY_LINE = <AnnotationType.POLY_LINE: 3>

RECTANGLE = <AnnotationType.RECTANGLE: 4>

__init__(*args, **kwargs)

property color: Color of the annotation as a normalized RGB tuple.

property editable: Whether the annotation can be manipulated by the user.

property label_text

property label_visible

property line_width

property max_points

The maximum amount of points this annotation supports.

A -1 indicates that this annotation supports any number of points.

property name

on_editing_finished(self: Annotation, callback: object) → SignalConnection

Register a callback which is call when the annotation is fully defined by the user.

The callback must not require any arguments.

>>> a = imfusion.app.annotation_model.create_annotation(imfusion.Annotation.LINE)
>>> def callback():
...     printf("All points are defined:", a.points)
>>> a.on_editing_finished(callback)
>>> a.start_editing()

on_points_changed(self: Annotation, callback: object) → SignalConnection

Register a callback which is call when any of the points change position.

The callback must not require any arguments.

>>> a = imfusion.app.annotation_model.create_annotation(imfusion.Annotation.LINE)
>>> def callback():
...     printf("Points changed to", a.points)
>>> a.on_points_changed(callback)
>>> a.start_editing()

property points: The points which define the annotation in world coordinates.

start_editing(self: Annotation) → None

Start interactive placement of the annotation.

This can currently only be called once.

property type

Return the type of this annotation.

Return None if this type is only partially supported from Python.

property visible

class imfusion.AnnotationModel

Bases: pybind11_object

__init__(*args, **kwargs)

property annotations

create_annotation(self: AnnotationModel, arg0: AnnotationType) → Annotation

class imfusion.ApplicationController

Bases: pybind11_object

A ApplicationController instance serves as the center of the ImFusionSDK.

It provides an OpenGL context, a DataModel, executes algorithms and more. While multiple instances are possible, in general there is only one instance.

__init__(*args, **kwargs)

add_algorithm(self: ApplicationController, id: str, data: list = [], properties: Properties = None) → object

Add the algorithm with the given name to the application.

The algorithm will only be created if it is compatible with the given data. The optional Properties object will be used to configure the algorithm. Returns the created algorithm or None if no compatible algorithm could be found.

>>> app.add_algorithm("Create Synthetic Data", [])  
<imfusion._bindings.BaseAlgorithm object at ...>

property algorithms: Return a list of all open algorithms.

property annotation_model

close_all(self: ApplicationController) → None: Delete all algorithms and datasets. Make sure to not reference any deleted objects after calling this!

property data_model

property display

execute_algorithm(self: ApplicationController, id: str, data: list = [], properties: Properties = None) → list

Execute the algorithm with the given name and returns its output.

The algorithm will only be executed if it is compatible with the given data. The optional Properties object will be used to configure the algorithm before executing it. Any data created by the algorithm is added to the DataModel before being returned.

load_workspace(self: ApplicationController, path: str, **kwargs) → bool: Loads a workspace file and returns True if the loading was successful. Placeholders can be specified as keyword arguments, for example: >>> app.load_workspace(“path/to/workspace.iws”, sweep=sweep, case=case)

open(self: ApplicationController, path: str) → list: Tries to open the given filepath as data. If successful the data is added to DataModel and returned. Otherwise raises a FileNotFoundError.

remove_algorithm(self: ApplicationController, algorithm: BaseAlgorithm) → None: Remove and deletes the given algorithm from the application. Don’t reference the given algorithm afterwards!

save_workspace(self: ApplicationController, path: str) → bool: Saves current workspace to a iws file

select_data(*args, **kwargs)

Overloaded function.

select_data(self: imfusion._bindings.ApplicationController, arg0: imfusion._bindings.Data) -> None
select_data(self: imfusion._bindings.ApplicationController, arg0: imfusion._bindings.DataList) -> None
select_data(self: imfusion._bindings.ApplicationController, arg0: list) -> None

property selected_data

update_display(self: ApplicationController) → None

class imfusion.BaseAlgorithm

Bases: Configurable

Low-level base class for all algorithms.

This interface mirrors the C++ interface very closely. Instances of this class are returned when you create an Algorithm that exists in the C++ SDK, either through add_algorithm() or :meth:~imfusion.create_algorithm`.

If you want to implement your own Algorithms from Python see Algorithm instead.

ERROR = <Status.ERROR: 1>

INCOMPLETE_INPUT = <Status.INCOMPLETE_INPUT: 3>

INVALID_INPUT = <Status.INVALID_INPUT: 2>

OUT_OF_MEMORY_GPU = <Status.OUT_OF_MEMORY_GPU: 5>

OUT_OF_MEMORY_HOST = <Status.OUT_OF_MEMORY_HOST: 4>

SUCCESS = <Status.SUCCESS: 0>

class Status

Bases: pybind11_object

Members:

UNKNOWN

SUCCESS

ERROR

INVALID_INPUT

INCOMPLETE_INPUT

OUT_OF_MEMORY_HOST

OUT_OF_MEMORY_GPU

UNSUPPORTED_GPU

UNKNOWN_ACTION

USER

ERROR = <Status.ERROR: 1>

INCOMPLETE_INPUT = <Status.INCOMPLETE_INPUT: 3>

INVALID_INPUT = <Status.INVALID_INPUT: 2>

OUT_OF_MEMORY_GPU = <Status.OUT_OF_MEMORY_GPU: 5>

OUT_OF_MEMORY_HOST = <Status.OUT_OF_MEMORY_HOST: 4>

SUCCESS = <Status.SUCCESS: 0>

UNKNOWN = <Status.UNKNOWN: -1>

UNKNOWN_ACTION = <Status.UNKNOWN_ACTION: 7>

UNSUPPORTED_GPU = <Status.UNSUPPORTED_GPU: 6>

USER = <Status.USER: 1000>

__init__(self: Status, value: int) → None

property name

property value

UNKNOWN = <Status.UNKNOWN: -1>

UNKNOWN_ACTION = <Status.UNKNOWN_ACTION: 7>

UNSUPPORTED_GPU = <Status.UNSUPPORTED_GPU: 6>

USER = <Status.USER: 1000>

__init__(self: BaseAlgorithm) → None

property actions

compute(self: BaseAlgorithm) → None

property id

property input

property name

output(self: BaseAlgorithm) → list

output_annotations(self: BaseAlgorithm) → List[Annotation]

run_action(self: BaseAlgorithm, name: str) → Status

property status

class imfusion.Configurable

Bases: pybind11_object

__init__(*args, **kwargs)

configuration(self: Configurable) → Properties

configure(self: Configurable, properties: Properties) → None

configure_defaults(self: Configurable) → None

class imfusion.ConsoleController

Bases: ApplicationController

ApplicationController without a UI interface.

This class is not available in the embedded Python interpreter in the ImFusionSuite.

__init__(self: ConsoleController, name: str = 'ImFusion Python Module') → None

class imfusion.CroppingMask

Bases: Mask

Simple axis-aligned cropping mask with optional roundness.

class RoundDims

Bases: pybind11_object

Members:

XY

YZ

XZ

XYZ

XY = <RoundDims.XY: 0>

XYZ = <RoundDims.XYZ: 3>

XZ = <RoundDims.XZ: 2>

YZ = <RoundDims.YZ: 1>

__init__(self: RoundDims, value: int) → None

property name

property value

XY = <RoundDims.XY: 0>

XYZ = <RoundDims.XYZ: 3>

XZ = <RoundDims.XZ: 2>

YZ = <RoundDims.YZ: 1>

__init__(self: CroppingMask, dimensions: ndarray[numpy.int32[3, 1]]) → None

property border: Number of pixels cropped away

property inverted: Whether the mask is inverted

property roundness: Roundness in percent (100 means an ellipse, 0 a rectangle)

property roundness_dims: Which dimensions the roundness parameter should be applied

class imfusion.Data

Bases: pybind11_object

class Kind

Bases: pybind11_object

Members:

UNKNOWN

IMAGE

VOLUME

IMAGE_SET

VOLUME_SET

IMAGE_STREAM

VOLUME_STREAM

POINT_SET

SURFACE

LIVE_TRACKING_STREAM

TRACKING_DATA

IMAGE = <Kind.IMAGE: 1>

IMAGE_SET = <Kind.IMAGE_SET: 3>

IMAGE_STREAM = <Kind.IMAGE_STREAM: 5>

LIVE_TRACKING_STREAM = <Kind.LIVE_TRACKING_STREAM: 9>

POINT_SET = <Kind.POINT_SET: 7>

SURFACE = <Kind.SURFACE: 8>

TRACKING_DATA = <Kind.TRACKING_DATA: 10>

UNKNOWN = <Kind.UNKNOWN: 0>

VOLUME = <Kind.VOLUME: 2>

VOLUME_SET = <Kind.VOLUME_SET: 4>

VOLUME_STREAM = <Kind.VOLUME_STREAM: 6>

__init__(self: Kind, value: int) → None

property name

property value

class Modality

Bases: pybind11_object

Members:

NA

XRAY

CT

MRI

ULTRASOUND

VIDEO

NM

OCT

LABEL

CT = <Modality.CT: 2>

LABEL = <Modality.LABEL: 8>

MRI = <Modality.MRI: 3>

NA = <Modality.NA: 0>

NM = <Modality.NM: 6>

OCT = <Modality.OCT: 7>

ULTRASOUND = <Modality.ULTRASOUND: 4>

VIDEO = <Modality.VIDEO: 5>

XRAY = <Modality.XRAY: 1>

__init__(self: Modality, value: int) → None

property name

property value

__init__(*args, **kwargs)

property components

property kind

property name

class imfusion.DataComponent

Bases: pybind11_object

Data components provide a way to generically attach custom information to Data.

Data and StreamData are the two main classes that hold a list of data components, allowing custom information (for example optional data or configuration settings) to be attached to instances of these classes. Data components are meant to be used for information that is bound to a specific Data instance and that can not be represented by the usual ImFusion data types.

Data components should implement the Configurable methods, in order to support generic (de)serialization.

Note

Data components are supposed to act as generic storage for custom information. When subclassing DataComponent, you should not implement any heavy evaluation logic since this is the domain of Algorithms or other classes accessing the DataComponents.

Example

class MyComponent(imfusion.DataComponent, factory_name="my_component"):
        def __init__(self, a):
                imfusion.DataComponent.__init__(self)
                self.a = a

        @property
        def a(self):
                return self._a

        @a.setter
        def a(self, value):
                if value and not isinstance(value, str):
                        raise TypeError('`a` must be of type `str`')
                self._a = value

        def configure(self, properties: imfusion.Properties) -> None:
                self.a = str(properties['a'])

        def configuration(self) -> imfusion.Properties:
                return imfusion.Properties({'a': self.a})

        def __eq__(self, other: 'MyComponent') -> bool:
                return self.a == other.a

__init__(self: DataComponent) → None

configuration(self: DataComponent) → Properties

configure(self: DataComponent, properties: Properties) → None

property id: Returns a unique string identifier for this type of data component

class imfusion.DataComponentBase

Bases: Configurable

__init__(*args, **kwargs)

class imfusion.DataComponentList

Bases: pybind11_object

A list of DataComponent. The list contains properties for specific DataComponent types. Each DataComponent type can only occur once.

__getitem__(*args, **kwargs)

Overloaded function.

__getitem__(self: imfusion._bindings.DataComponentList, index: int) -> object
__getitem__(self: imfusion._bindings.DataComponentList, indices: List[int]) -> List[object]
__getitem__(self: imfusion._bindings.DataComponentList, slice: slice) -> List[object]
__getitem__(self: imfusion._bindings.DataComponentList, id: str) -> object

__init__(*args, **kwargs)

add(*args, **kwargs)

Overloaded function.

add(self: imfusion._bindings.DataComponentList, component: imfusion._bindings.DataComponent) -> object

Adds the component to the component list and returns a reference to the copy.

add(self: imfusion._bindings.DataComponentList, arg0: imfusion._bindings.ImageInfoDataComponent) -> imfusion._bindings.DataComponentBase