EITData

eitprocessing.datahandling.eitdata ¶

EITData `dataclass` ¶

EITData(
    path: str | Path | list[Path | str],
    nframes: int,
    time: ndarray,
    sample_frequency: float,
    vendor: Vendor,
    label: str | None = None,
    description: str = "",
    name: str | None = None,
    suppress_simulated_warning: InitVar[bool] = False,
    *,
    pixel_impedance: ndarray
)

Container for EIT impedance data.

This class holds the pixel impedance from an EIT measurement, as well as metadata describing the measurement. The class is meant to hold data from (part of) a singular continuous measurement.

This class can't be initialized directly. Instead, use load_eit_data(<path>, vendor=<vendor>) to load data from disk.

PARAMETER	DESCRIPTION
`path`	The path of list of paths of the source from which data was derived. TYPE: `str \| Path \| list[Path \| str]`
`nframes`	Number of frames. TYPE: `int`
`time`	The time of each frame (since start measurement). TYPE: `ndarray`
`sample_frequency`	The (average) frequency at which the frames are collected, in Hz. TYPE: `float`
`vendor`	The vendor of the device the data was collected with. TYPE: `Vendor`
`label`	Computer readable label identifying this dataset. TYPE: `str \| None` DEFAULT: `None`
`name`	Human readable name for the data. TYPE: `str \| None` DEFAULT: `None`
`pixel_impedance`	Impedance values for each pixel at each frame. TYPE: `ndarray`

framerate `property` ¶

framerate: float

Deprecated alias to sample_frequency.

t `property` ¶

t: TimeIndexer

Slicing an object using the time axis instead of indices.

Example:

>>> sequence = load_eit_data(<path>, ...)
>>> time_slice1 = sequence.t[tp_start:tp_end]
>>> time_slice2 = sequence.select_by_time(tp_start, tp_end)
>>> time_slice1 == time_slice2
True

ensure_path_list `staticmethod` ¶

ensure_path_list(path: str | Path | list[str | Path]) -> list[Path]

Return the path or paths as a list.

The path of any EITData object can be a single str/Path or a list of str/Path objects. This method returns a list of Path objects given either a str/Path or list of str/Paths.

get_summed_impedance ¶

get_summed_impedance(
    *, return_label: str | None = None, **return_kwargs
) -> ContinuousData

Return a ContinuousData-object with the same time axis and summed pixel values over time.

PARAMETER	DESCRIPTION
`return_label`	The label of the returned object; defaults to 'summed ' where '' is the label of TYPE: `str \| None` DEFAULT: `None`
`**return_kwargs`	Keyword arguments for the creation of the returned object. DEFAULT: `{}`

calculate_global_impedance ¶

calculate_global_impedance() -> ndarray

Return the global impedance, i.e. the sum of all included pixels at each frame.

select_by_time ¶

select_by_time(
    start_time: float | None = None,
    end_time: float | None = None,
    start_inclusive: bool = False,
    end_inclusive: bool = False,
    label: str | None = None,
) -> Self

Get a shortened copy of the object, starting from start_time and ending at end_time.

Given a start and end time stamp (i.e. its value, not its index), return a slice of the original object, which must contain a time axis.

PARAMETER	DESCRIPTION
`start_time`	first time point to include. Defaults to first frame of sequence. TYPE: `float \| None` DEFAULT: `None`
`end_time`	last time point. Defaults to last frame of sequence. TYPE: `float \| None` DEFAULT: `None`
`start_inclusive`	`True`), end_inclusive (default `False`): these arguments control the behavior if the given time stamp does not match exactly with an existing time stamp of the input. if `True`: the given time stamp will be inside the sliced object. if `False`: the given time stamp will be outside the sliced object. TYPE: `default` DEFAULT: `False`
`label`	Description. Defaults to None, which will create a label based on the original object label and the frames by which it is sliced. TYPE: `str \| None` DEFAULT: `None`

RAISES	DESCRIPTION
`TypeError`	if `self` does not contain a `time` attribute.
`ValueError`	if time stamps are not sorted.

RETURNS	DESCRIPTION
`Self`	A shortened copy of the object.

select_by_index ¶

select_by_index(
    start: int | None = None,
    end: int | None = None,
    newlabel: str | None = None,
) -> Self

De facto implementation of the __getitem__ function.

This function can also be called directly to add a label to the sliced object. Otherwise a default label describing the slice and original object is attached.

isequivalent ¶

isequivalent(other: Self, raise_: bool = False) -> bool

Test whether the data structure between two objects are equivalent.

Equivalence, in this case means that objects are compatible e.g. to be merged. Data content can vary, but e.g. the category of data (e.g. airway pressure, flow, tidal volume) and unit, etc., must match.

PARAMETER	DESCRIPTION
`other`	object that will be compared to self. TYPE: `Self`
`raise_`	sets this method's behavior in case of non-equivalence. If True, an `EquivalenceError` is raised, otherwise `False` is returned. TYPE: `bool` DEFAULT: `False`

RAISES	DESCRIPTION
`EquivalenceError`	if `raise_ == True` and the objects are not

RETURNS	DESCRIPTION
`bool`	bool describing result of equivalence comparison.

deepcopy ¶

deepcopy() -> Self

Return a deep copy of the object.

Vendor ¶

Enum indicating the vendor (manufacturer) of the source EIT device.