Computation (`cdl.computation`)#

This package contains the computation functions used by the DataLab project. Those functions operate directly on DataLab objects (i.e. cdl.obj.SignalObj and cdl.obj.ImageObj) and are designed to be used in the DataLab pipeline, but can be used independently as well.

Voir aussi

The cdl.computation package is the main entry point for the DataLab computation functions when manipulating DataLab objects. See the cdl.algorithms package for algorithms that operate directly on NumPy arrays.

Each computation module defines a set of computation objects, that is, functions that implement processing features and classes that implement the corresponding parameters (in the form of guidata.dataset.datatypes.Dataset subclasses). The computation functions takes a DataLab object (e.g. cdl.obj.SignalObj) and a parameter object (e.g. cdl.param.MovingAverageParam) as input and return a DataLab object as output (the result of the computation). The parameter object is used to configure the computation function (e.g. the size of the moving average window).

In DataLab overall architecture, the purpose of this package is to provide the computation functions that are used by the cdl.core.gui.processor module, based on the algorithms defined in the cdl.algorithms module and on the data model defined in the cdl.obj (or cdl.core.model) module.

The computation modules are organized in subpackages according to their purpose. The following subpackages are available:

cdl.computation.base: Common processing features
cdl.computation.signal: Signal processing features
cdl.computation.image: Image processing features

Common processing features#

class cdl.computation.base.ArithmeticParam[source]#

Arithmetic parameters

operator#

Opérateur. Sélection unique parmi : “+”, “-”, “×”, “/”. Par défaut : “+”.

Type:: guidata.dataset.dataitems.ChoiceItem

factor#

Facteur. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

constant#

Constante. Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

operation#

Opération. Par défaut : “”.

Type:: guidata.dataset.dataitems.StringItem

restore_dtype#

Résultat. Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(operator: str, factor: float, constant: float, operation: str, restore_dtype: bool) → cdl.computation.base.ArithmeticParam#

Renvoie une nouvelle instance de ArithmeticParam avec les champs initialisés aux valeurs données.

Paramètres:

operator (str) – Opérateur. Sélection unique parmi : “+”, “-”, “×”, “/”. Par défaut : “+”.
factor (float) – Facteur. Par défaut : 1.0.
constant (float) – Constante. Par défaut : 0.0.
operation (str) – Opération. Par défaut : “”.
restore_dtype (bool) – Résultat. Par défaut : True.

Renvoie:

Nouvelle instance de ArithmeticParam.

get_operation() → str[source]#: Return the operation string

update_operation(_item, _value)[source]#: Update the operation item

class cdl.computation.base.GaussianParam[source]#

Gaussian filter parameters

sigma#

σ. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(sigma: float) → cdl.computation.base.GaussianParam#

Renvoie une nouvelle instance de GaussianParam avec les champs initialisés aux valeurs données.

Paramètres:: sigma (float) – σ. Par défaut : 1.0.
Renvoie:: Nouvelle instance de GaussianParam.

class cdl.computation.base.MovingAverageParam[source]#

Moving average parameters

n#

Taille de la fenêtre glissante. Entier supérieur à 1. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

mode#

Mode du filtre : - “reflect” : réfléchir les données à la frontière - “constant” : remplir avec une valeur constante - “nearest” : remplir avec la valeur la plus proche - “mirror” : réfléchir les données à la frontière avec les données elles-mêmes - “wrap” : frontière circulaire. Sélection unique parmi : “reflect”, “constant”, “nearest”, “mirror”, “wrap”. Par défaut : “reflect”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(n: int, mode: str) → cdl.computation.base.MovingAverageParam#

Renvoie une nouvelle instance de MovingAverageParam avec les champs initialisés aux valeurs données.

Paramètres:

n (int) – Taille de la fenêtre glissante. Entier supérieur à 1. Par défaut : 3.
mode (str) – Mode du filtre : - “reflect” : réfléchir les données à la frontière - “constant” : remplir avec une valeur constante - “nearest” : remplir avec la valeur la plus proche - “mirror” : réfléchir les données à la frontière avec les données elles-mêmes - “wrap” : frontière circulaire. Sélection unique parmi : “reflect”, “constant”, “nearest”, “mirror”, “wrap”. Par défaut : “reflect”.

Renvoie:

Nouvelle instance de MovingAverageParam.

class cdl.computation.base.MovingMedianParam[source]#

Moving median parameters

n#

Taille de la fenêtre glissante. Entier supérieur à 1, impair. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

mode#

Mode du filtre : - “reflect” : réfléchir les données à la frontière - “constant” : remplir avec une valeur constante - “nearest” : remplir avec la valeur la plus proche - “mirror” : réfléchir les données à la frontière avec les données elles-mêmes - “wrap” : frontière circulaire. Sélection unique parmi : “reflect”, “constant”, “nearest”, “mirror”, “wrap”. Par défaut : “nearest”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(n: int, mode: str) → cdl.computation.base.MovingMedianParam#

Renvoie une nouvelle instance de MovingMedianParam avec les champs initialisés aux valeurs données.

Paramètres:

n (int) – Taille de la fenêtre glissante. Entier supérieur à 1, impair. Par défaut : 3.
mode (str) – Mode du filtre : - “reflect” : réfléchir les données à la frontière - “constant” : remplir avec une valeur constante - “nearest” : remplir avec la valeur la plus proche - “mirror” : réfléchir les données à la frontière avec les données elles-mêmes - “wrap” : frontière circulaire. Sélection unique parmi : “reflect”, “constant”, “nearest”, “mirror”, “wrap”. Par défaut : “nearest”.

Renvoie:

Nouvelle instance de MovingMedianParam.

class cdl.computation.base.ClipParam[source]#

Data clipping parameters

lower#

Borne inférieure d’écrêtage. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

upper#

Borne supérieure d’écrêtage. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(lower: float, upper: float) → cdl.computation.base.ClipParam#

Renvoie une nouvelle instance de ClipParam avec les champs initialisés aux valeurs données.

Paramètres:

lower (float) – Borne inférieure d’écrêtage. Par défaut : None.
upper (float) – Borne supérieure d’écrêtage. Par défaut : None.

Renvoie:

Nouvelle instance de ClipParam.

class cdl.computation.base.NormalizeParam[source]#

Normalize parameters

method#

Normaliser par rapport à. Sélection unique parmi : “maximum”, “amplitude”, “area”, “energy”, “rms”. Par défaut : “maximum”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(method: str) → cdl.computation.base.NormalizeParam#

Renvoie une nouvelle instance de NormalizeParam avec les champs initialisés aux valeurs données.

Paramètres:: method (str) – Normaliser par rapport à. Sélection unique parmi : “maximum”, “amplitude”, “area”, “energy”, “rms”. Par défaut : “maximum”.
Renvoie:: Nouvelle instance de NormalizeParam.

class cdl.computation.base.HistogramParam[source]#

Histogram parameters

bins#

Nombre de classes. Entier supérieur à 1. Par défaut : 256.

Type:: guidata.dataset.dataitems.IntItem

lower#

Limite inférieure. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

upper#

Limite supérieure. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(bins: int, lower: float, upper: float) → cdl.computation.base.HistogramParam#

Renvoie une nouvelle instance de HistogramParam avec les champs initialisés aux valeurs données.

Paramètres:

bins (int) – Nombre de classes. Entier supérieur à 1. Par défaut : 256.
lower (float) – Limite inférieure. Par défaut : None.
upper (float) – Limite supérieure. Par défaut : None.

Renvoie:

Nouvelle instance de HistogramParam.

get_suffix(data: ndarray) → str[source]#

Return suffix for the histogram computation

Paramètres:: data – data array

class cdl.computation.base.FFTParam[source]#

FFT parameters

shift#

Décaler la fréquence nulle au centre. Par défaut : None.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(shift: bool) → cdl.computation.base.FFTParam#

Renvoie une nouvelle instance de FFTParam avec les champs initialisés aux valeurs données.

Paramètres:: shift (bool) – Décaler la fréquence nulle au centre. Par défaut : None.
Renvoie:: Nouvelle instance de FFTParam.

class cdl.computation.base.SpectrumParam[source]#

Spectrum parameters

log#

Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(log: bool) → cdl.computation.base.SpectrumParam#

Renvoie une nouvelle instance de SpectrumParam avec les champs initialisés aux valeurs données.

Paramètres:: log (bool) – Par défaut : False.
Renvoie:: Nouvelle instance de SpectrumParam.

class cdl.computation.base.ConstantParam[source]#

Parameter used to set a constant value to used in operations

value#

Constante. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(value: float) → cdl.computation.base.ConstantParam#

Renvoie une nouvelle instance de ConstantParam avec les champs initialisés aux valeurs données.

Paramètres:: value (float) – Constante. Par défaut : None.
Renvoie:: Nouvelle instance de ConstantParam.

cdl.computation.base.dst_11(src: SignalObj | ImageObj, name: str, suffix: str | None = None) → SignalObj | ImageObj[source]#

Create a result object, as returned by the callback function of the cdl.core.gui.processor.base.BaseProcessor.compute_11() method

Paramètres:

src – source signal or image object
name – name of the function. If provided, the title of the result object will be {name}({src.short_id})|{suffix}), unless the name is a single character, in which case the title will be {src.short_id}{name}{suffix} where name is an operator and suffix is the other term of the operation.
suffix – suffix to add to the title. Optional.

Renvoie:

Result signal or image object

cdl.computation.base.dst_n1n(src1: SignalObj | ImageObj, src2: SignalObj | ImageObj, name: str, suffix: str | None = None) → SignalObj | ImageObj[source]#

Create a result object, as returned by the callback function of the cdl.core.gui.processor.base.BaseProcessor.compute_n1n() method

Paramètres:

src1 – input signal or image object
src2 – input signal or image object
name – name of the processing function

Renvoie:

Output signal or image object

cdl.computation.base.new_signal_result(src: SignalObj | ImageObj, name: str, suffix: str | None = None, units: tuple[str, str] | None = None, labels: tuple[str, str] | None = None) → SignalObj[source]#

Create new signal object as a result of a compute_11 function

As opposed to the dst_11 functions, this function creates a new signal object without copying the original object metadata, except for the « source » entry.

Paramètres:

src – input signal or image object
name – name of the processing function
suffix – suffix to add to the title
units – units of the output signal
labels – labels of the output signal

Renvoie:

Output signal object

cdl.computation.base.calc_resultproperties(title: str, obj: SignalObj | ImageObj, labeledfuncs: dict[str, Callable]) → ResultProperties[source]#

Calculate result properties by executing a computation function on a signal/image object.

Paramètres:

title – title of the result properties
obj – signal or image object
labeledfuncs – dictionary of labeled computation functions. The keys are the labels of the computation functions and the values are the functions themselves (each function must take a single argument - which is the data of the ROI or the whole signal/image - and return a float)

Renvoie:

Result properties object

Signal processing features#

cdl.computation.signal.restore_data_outside_roi(dst: SignalObj, src: SignalObj) → None[source]#

Restore data outside the Region Of Interest (ROI) of the input signal after a computation, only if the input signal has a ROI, and if the output signal has the same ROI as the input signal, and if the data types are the same, and if the shapes are the same. Otherwise, do nothing.

Paramètres:

dst – destination signal object
src – source signal object

class cdl.computation.signal.Wrap11Func(func: Callable, *args: Any, **kwargs: Any)[source]#

Wrap a 1 array → 1 array function (the simple case of y1 = f(y0)) to produce a 1 signal → 1 signal function, which can be used inside DataLab’s infrastructure to perform computations with cdl.core.gui.processor.signal.SignalProcessor.

This wrapping mechanism using a class is necessary for the resulted function to be pickable by the multiprocessing module.

The instance of this wrapper is callable and returns a cdl.obj.SignalObj object.

Exemple

>>> import numpy as np
>>> from cdl.computation.signal import Wrap11Func
>>> import cdl.obj
>>> def square(y):
...     return y**2
>>> compute_square = Wrap11Func(square)
>>> x = np.linspace(0, 10, 100)
>>> y = np.sin(x)
>>> sig0 = cdl.obj.create_signal("Example", x, y)
>>> sig1 = compute_square(sig0)

Paramètres:

func – 1 array → 1 array function
*args – Additional positional arguments to pass to the function
**kwargs – Additional keyword arguments to pass to the function

cdl.computation.signal.compute_addition(dst: SignalObj, src: SignalObj) → SignalObj[source]#

Add dst and src signals and return dst signal modified in place

Paramètres:

dst – destination signal
src – source signal

Renvoie:

Modified dst signal (modified in place)

cdl.computation.signal.compute_product(dst: SignalObj, src: SignalObj) → SignalObj[source]#

Multiply dst and src signals and return dst signal modified in place

Paramètres:

dst – destination signal
src – source signal

Renvoie:

Modified dst signal (modified in place)

cdl.computation.signal.compute_addition_constant(src: SignalObj, p: ConstantParam) → SignalObj[source]#

Add dst and a constant value and return a the new result signal object

Paramètres:

src – input signal object
p – constant value

Renvoie:

Result signal object src + p.value (new object)

cdl.computation.signal.compute_difference_constant(src: SignalObj, p: ConstantParam) → SignalObj[source]#

Subtract a constant value from a signal

Paramètres:

src – input signal object
p – constant value

Renvoie:

Result signal object src - p.value (new object)

cdl.computation.signal.compute_product_constant(src: SignalObj, p: ConstantParam) → SignalObj[source]#

Multiply dst by a constant value and return the new result signal object

Paramètres:

src – input signal object
p – constant value

Renvoie:

Result signal object src * p.value (new object)

cdl.computation.signal.compute_division_constant(src: SignalObj, p: ConstantParam) → SignalObj[source]#

Divide a signal by a constant value

Paramètres:

src – input signal object
p – constant value

Renvoie:

Result signal object src / p.value (new object)

cdl.computation.signal.compute_arithmetic(src1: SignalObj, src2: SignalObj, p: ArithmeticParam) → SignalObj[source]#

Perform arithmetic operation on two signals

Paramètres:

src1 – source signal 1
src2 – source signal 2
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_difference(src1: SignalObj, src2: SignalObj) → SignalObj[source]#

Compute difference between two signals

Note

If uncertainty is available, it is propagated.

Paramètres:

src1 – source signal 1
src2 – source signal 2

Renvoie:

Result signal object src1 - src2

cdl.computation.signal.compute_quadratic_difference(src1: SignalObj, src2: SignalObj) → SignalObj[source]#

Compute quadratic difference between two signals

Note

If uncertainty is available, it is propagated.

Paramètres:

src1 – source signal 1
src2 – source signal 2

Renvoie:

Result signal object (src1 - src2) / sqrt(2.0)

cdl.computation.signal.compute_division(src1: SignalObj, src2: SignalObj) → SignalObj[source]#

Compute division between two signals

Paramètres:

src1 – source signal 1
src2 – source signal 2

Renvoie:

Result signal object src1 / src2

cdl.computation.signal.extract_multiple_roi(src: SignalObj, group: DataSetGroup) → SignalObj[source]#

Extract multiple regions of interest from data

Paramètres:

src – source signal
group – group of parameters

Renvoie:

Signal with multiple regions of interest

cdl.computation.signal.extract_single_roi(src: SignalObj, p: ROI1DParam) → SignalObj[source]#

Extract single region of interest from data

Paramètres:

src – source signal
p – ROI parameters

Renvoie:

Signal with single region of interest

cdl.computation.signal.compute_swap_axes(src: SignalObj) → SignalObj[source]#

Swap axes

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_inverse(src: SignalObj) → SignalObj[source]#

Compute inverse with numpy.invert

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_abs(src: SignalObj) → SignalObj[source]#

Compute absolute value with numpy.absolute

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_re(src: SignalObj) → SignalObj[source]#

Compute real part with numpy.real()

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_im(src: SignalObj) → SignalObj[source]#

Compute imaginary part with numpy.imag()

Paramètres:: src – source signal
Renvoie:: Result signal object

class cdl.computation.signal.DataTypeSParam[source]#

Convert signal data type parameters

dtype_str#

Type de données de destination. Type de données de l’image générée. Sélection unique parmi : “float32”, “float64”, “complex128”. Par défaut : “float32”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(dtype_str: str) → cdl.computation.signal.DataTypeSParam#

Renvoie une nouvelle instance de DataTypeSParam avec les champs initialisés aux valeurs données.

Paramètres:: dtype_str (str) – Type de données de destination. Type de données de l’image générée. Sélection unique parmi : “float32”, “float64”, “complex128”. Par défaut : “float32”.
Renvoie:: Nouvelle instance de DataTypeSParam.

cdl.computation.signal.compute_astype(src: SignalObj, p: DataTypeSParam) → SignalObj[source]#

Convert data type with numpy.astype()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_log10(src: SignalObj) → SignalObj[source]#

Compute Log10 with numpy.log10

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_exp(src: SignalObj) → SignalObj[source]#

Compute exponential with numpy.exp

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_sqrt(src: SignalObj) → SignalObj[source]#

Compute square root with numpy.sqrt

Paramètres:: src – source signal
Renvoie:: Result signal object

class cdl.computation.signal.PowerParam[source]#

Power parameters

power#

Puissance. Par défaut : 2.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(power: float) → cdl.computation.signal.PowerParam#

Renvoie une nouvelle instance de PowerParam avec les champs initialisés aux valeurs données.

Paramètres:: power (float) – Puissance. Par défaut : 2.0.
Renvoie:: Nouvelle instance de PowerParam.

cdl.computation.signal.compute_power(src: SignalObj, p: PowerParam) → SignalObj[source]#

Compute power with numpy.power

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

class cdl.computation.signal.PeakDetectionParam[source]#

Peak detection parameters

threshold#

Seuil. Entier compris entre 0 et 100, unité : %. Par défaut : 30.

Type:: guidata.dataset.dataitems.IntItem

min_dist#

Distance minimale. Entier supérieur à 1, unité : points. Par défaut : 1.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(threshold: int, min_dist: int) → cdl.computation.signal.PeakDetectionParam#

Renvoie une nouvelle instance de PeakDetectionParam avec les champs initialisés aux valeurs données.

Paramètres:

threshold (int) – Seuil. Entier compris entre 0 et 100, unité : %. Par défaut : 30.
min_dist (int) – Distance minimale. Entier supérieur à 1, unité : points. Par défaut : 1.

Renvoie:

Nouvelle instance de PeakDetectionParam.

cdl.computation.signal.compute_peak_detection(src: SignalObj, p: PeakDetectionParam) → SignalObj[source]#

Peak detection with cdl.algorithms.signal.peak_indices()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_normalize(src: SignalObj, p: NormalizeParam) → SignalObj[source]#

Normalize data with cdl.algorithms.signal.normalize()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_derivative(src: SignalObj) → SignalObj[source]#

Compute derivative with numpy.gradient()

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_integral(src: SignalObj) → SignalObj[source]#

Compute integral with scipy.integrate.cumulative_trapezoid()

Paramètres:: src – source signal
Renvoie:: Result signal object

class cdl.computation.signal.XYCalibrateParam[source]#

Signal calibration parameters

axis#

Étalonner. Sélection unique parmi : “x”, “y”. Par défaut : “y”.

Type:: guidata.dataset.dataitems.ChoiceItem

a#

Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

b#

Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(axis: str, a: float, b: float) → cdl.computation.signal.XYCalibrateParam#

Renvoie une nouvelle instance de XYCalibrateParam avec les champs initialisés aux valeurs données.

Paramètres:

axis (str) – Étalonner. Sélection unique parmi : “x”, “y”. Par défaut : “y”.
a (float) – Par défaut : 1.0.
b (float) – Par défaut : 0.0.

Renvoie:

Nouvelle instance de XYCalibrateParam.

cdl.computation.signal.compute_calibration(src: SignalObj, p: XYCalibrateParam) → SignalObj[source]#

Compute linear calibration

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_clip(src: SignalObj, p: ClipParam) → SignalObj[source]#

Compute maximum data clipping with numpy.clip()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_offset_correction(src: SignalObj, p: ROI1DParam) → SignalObj[source]#

Correct offset: subtract the mean value of the signal in the specified range (baseline correction)

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_gaussian_filter(src: SignalObj, p: GaussianParam) → SignalObj[source]#

Compute gaussian filter with scipy.ndimage.gaussian_filter()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_moving_average(src: SignalObj, p: MovingAverageParam) → SignalObj[source]#

Compute moving average with scipy.ndimage.uniform_filter()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_moving_median(src: SignalObj, p: MovingMedianParam) → SignalObj[source]#

Compute moving median with scipy.ndimage.median_filter()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_wiener(src: SignalObj) → SignalObj[source]#

Compute Wiener filter with scipy.signal.wiener()

Paramètres:: src – source signal
Renvoie:: Result signal object

class cdl.computation.signal.FilterType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]#: Filter types

class cdl.computation.signal.BaseHighLowBandParam[source]#

Base class for high-pass, low-pass, band-pass and band-stop filters

method#

Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.

Type:: guidata.dataset.dataitems.ChoiceItem

order#

Ordre du filtre. Entier supérieur à 1. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

f_cut0#

Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

f_cut1#

Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

rp#

Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

rs#

Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, order: int, f_cut0: float, f_cut1: float, rp: float, rs: float) → cdl.computation.signal.BaseHighLowBandParam#

Renvoie une nouvelle instance de BaseHighLowBandParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.
order (int) – Ordre du filtre. Entier supérieur à 1. Par défaut : 3.
f_cut0 (float) – Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
f_cut1 (float) – Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
rp (float) – Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.
rs (float) – Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Renvoie:

Nouvelle instance de BaseHighLowBandParam.

static get_nyquist_frequency(obj: SignalObj) → float[source]#

Return the Nyquist frequency of a signal object

Paramètres:: obj – signal object

update_from_signal(obj: SignalObj) → None[source]#

Update the filter parameters from a signal object

Paramètres:: obj – signal object

get_filter_params(obj: SignalObj) → tuple[float | str, float | str][source]#

Return the filter parameters (a and b) as a tuple. These parameters are used in the scipy.signal filter functions (eg. scipy.signal.filtfilt).

Paramètres:: obj – signal object
Renvoie:: filter parameters
Type renvoyé:: tuple

class cdl.computation.signal.LowPassFilterParam[source]#

Low-pass filter parameters

method#

Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.

Type:: guidata.dataset.dataitems.ChoiceItem

order#

Ordre du filtre. Entier supérieur à 1. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

f_cut0#

Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

f_cut1#

Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

rp#

Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

rs#

Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, order: int, f_cut0: float, f_cut1: float, rp: float, rs: float) → cdl.computation.signal.LowPassFilterParam#

Renvoie une nouvelle instance de LowPassFilterParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.
order (int) – Ordre du filtre. Entier supérieur à 1. Par défaut : 3.
f_cut0 (float) – Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
f_cut1 (float) – Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
rp (float) – Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.
rs (float) – Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Renvoie:

Nouvelle instance de LowPassFilterParam.

class cdl.computation.signal.HighPassFilterParam[source]#

High-pass filter parameters

method#

Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.

Type:: guidata.dataset.dataitems.ChoiceItem

order#

Ordre du filtre. Entier supérieur à 1. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

f_cut0#

Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

f_cut1#

Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

rp#

Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

rs#

Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, order: int, f_cut0: float, f_cut1: float, rp: float, rs: float) → cdl.computation.signal.HighPassFilterParam#

Renvoie une nouvelle instance de HighPassFilterParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.
order (int) – Ordre du filtre. Entier supérieur à 1. Par défaut : 3.
f_cut0 (float) – Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
f_cut1 (float) – Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
rp (float) – Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.
rs (float) – Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Renvoie:

Nouvelle instance de HighPassFilterParam.

class cdl.computation.signal.BandPassFilterParam[source]#

Band-pass filter parameters

method#

Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.

Type:: guidata.dataset.dataitems.ChoiceItem

order#

Ordre du filtre. Entier supérieur à 1. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

f_cut0#

Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

f_cut1#

Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

rp#

Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

rs#

Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, order: int, f_cut0: float, f_cut1: float, rp: float, rs: float) → cdl.computation.signal.BandPassFilterParam#

Renvoie une nouvelle instance de BandPassFilterParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.
order (int) – Ordre du filtre. Entier supérieur à 1. Par défaut : 3.
f_cut0 (float) – Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
f_cut1 (float) – Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
rp (float) – Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.
rs (float) – Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Renvoie:

Nouvelle instance de BandPassFilterParam.

class cdl.computation.signal.BandStopFilterParam[source]#

Band-stop filter parameters

method#

Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.

Type:: guidata.dataset.dataitems.ChoiceItem

order#

Ordre du filtre. Entier supérieur à 1. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

f_cut0#

Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

f_cut1#

Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

rp#

Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

rs#

Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, order: int, f_cut0: float, f_cut1: float, rp: float, rs: float) → cdl.computation.signal.BandStopFilterParam#

Renvoie une nouvelle instance de BandStopFilterParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode de filtrage. Sélection unique parmi : “bessel”, “butter”, “cheby1”, “cheby2”, “ellip”. Par défaut : “bessel”.
order (int) – Ordre du filtre. Entier supérieur à 1. Par défaut : 3.
f_cut0 (float) – Fréquence de coupure basse. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
f_cut1 (float) – Fréquence de coupure haute. Flottant supérieur à 0, non nul, unité : hz. Par défaut : None.
rp (float) – Ondulation de la bande passante. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.
rs (float) – Atténuation de la bande d’arrêt. Flottant supérieur à 0, non nul, unité : db. Par défaut : 1.

Renvoie:

Nouvelle instance de BandStopFilterParam.

cdl.computation.signal.compute_filter(src: SignalObj, p: BaseHighLowBandParam) → SignalObj[source]#

Compute frequency filter (low-pass, high-pass, band-pass, band-stop), with scipy.signal.filtfilt()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_fft(src: SignalObj, p: FFTParam | None = None) → SignalObj[source]#

Compute FFT with cdl.algorithms.signal.fft1d()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_ifft(src: SignalObj, p: FFTParam | None = None) → SignalObj[source]#

Compute iFFT with cdl.algorithms.signal.ifft1d()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_magnitude_spectrum(src: SignalObj, p: SpectrumParam | None = None) → SignalObj[source]#

Compute magnitude spectrum with cdl.algorithms.signal.magnitude_spectrum()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_phase_spectrum(src: SignalObj) → SignalObj[source]#

Compute phase spectrum with cdl.algorithms.signal.phase_spectrum()

Paramètres:: src – source signal
Renvoie:: Result signal object

cdl.computation.signal.compute_psd(src: SignalObj, p: SpectrumParam | None = None) → SignalObj[source]#

Compute power spectral density with cdl.algorithms.signal.psd()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

class cdl.computation.signal.PolynomialFitParam[source]#

Polynomial fitting parameters

degree#

Degré. Entier compris entre 1 et 10. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(degree: int) → cdl.computation.signal.PolynomialFitParam#

Renvoie une nouvelle instance de PolynomialFitParam avec les champs initialisés aux valeurs données.

Paramètres:: degree (int) – Degré. Entier compris entre 1 et 10. Par défaut : 3.
Renvoie:: Nouvelle instance de PolynomialFitParam.

cdl.computation.signal.compute_histogram(src: SignalObj, p: HistogramParam) → SignalObj[source]#

Compute histogram with numpy.histogram()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

class cdl.computation.signal.InterpolationParam[source]#

Interpolation parameters

method#

Méthode d’interpolation. Sélection unique parmi : “linear”, “spline”, “quadratic”, “cubic”, “barycentric”, “pchip”. Par défaut : “linear”.

Type:: guidata.dataset.dataitems.ChoiceItem

fill_value#

Valeur de remplissage. Valeur à utiliser pour les points en dehors du domaine d’interpolation (utilisé uniquement avec les méthodes linéaire, cubique et pchip). Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, fill_value: float) → cdl.computation.signal.InterpolationParam#

Renvoie une nouvelle instance de InterpolationParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode d’interpolation. Sélection unique parmi : “linear”, “spline”, “quadratic”, “cubic”, “barycentric”, “pchip”. Par défaut : “linear”.
fill_value (float) – Valeur de remplissage. Valeur à utiliser pour les points en dehors du domaine d’interpolation (utilisé uniquement avec les méthodes linéaire, cubique et pchip). Par défaut : None.

Renvoie:

Nouvelle instance de InterpolationParam.

cdl.computation.signal.compute_interpolation(src1: SignalObj, src2: SignalObj, p: InterpolationParam) → SignalObj[source]#

Interpolate data with cdl.algorithms.signal.interpolate()

Paramètres:

src1 – source signal 1
src2 – source signal 2
p – parameters

Renvoie:

Result signal object

class cdl.computation.signal.ResamplingParam[source]#

Resample parameters

method#

Méthode d’interpolation. Sélection unique parmi : “linear”, “spline”, “quadratic”, “cubic”, “barycentric”, “pchip”. Par défaut : “linear”.

Type:: guidata.dataset.dataitems.ChoiceItem

fill_value#

Valeur de remplissage. Valeur à utiliser pour les points en dehors du domaine d’interpolation (utilisé uniquement avec les méthodes linéaire, cubique et pchip). Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

xmin#

X_min. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

xmax#

X_max. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

mode#

Sélection unique parmi : “dx”, “nbpts”. Par défaut : “nbpts”.

Type:: guidata.dataset.dataitems.ChoiceItem

dx#

ΔX. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

nbpts#

Nombre de points. Par défaut : None.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(method: str, fill_value: float, xmin: float, xmax: float, mode: str, dx: float, nbpts: int) → cdl.computation.signal.ResamplingParam#

Renvoie une nouvelle instance de ResamplingParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode d’interpolation. Sélection unique parmi : “linear”, “spline”, “quadratic”, “cubic”, “barycentric”, “pchip”. Par défaut : “linear”.
fill_value (float) – Valeur de remplissage. Valeur à utiliser pour les points en dehors du domaine d’interpolation (utilisé uniquement avec les méthodes linéaire, cubique et pchip). Par défaut : None.
xmin (float) – X_min. Par défaut : None.
xmax (float) – X_max. Par défaut : None.
mode (str) – Sélection unique parmi : “dx”, “nbpts”. Par défaut : “nbpts”.
dx (float) – ΔX. Par défaut : None.
nbpts (int) – Nombre de points. Par défaut : None.

Renvoie:

Nouvelle instance de ResamplingParam.

cdl.computation.signal.compute_resampling(src: SignalObj, p: ResamplingParam) → SignalObj[source]#

Resample data with cdl.algorithms.signal.interpolate()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

class cdl.computation.signal.DetrendingParam[source]#

Detrending parameters

method#

Méthode d’élimation de la tendance. Sélection unique parmi : “linear”, “constant”. Par défaut : “linear”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(method: str) → cdl.computation.signal.DetrendingParam#

Renvoie une nouvelle instance de DetrendingParam avec les champs initialisés aux valeurs données.

Paramètres:: method (str) – Méthode d’élimation de la tendance. Sélection unique parmi : “linear”, “constant”. Par défaut : “linear”.
Renvoie:: Nouvelle instance de DetrendingParam.

cdl.computation.signal.compute_detrending(src: SignalObj, p: DetrendingParam) → SignalObj[source]#

Detrend data with scipy.signal.detrend()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_convolution(src1: SignalObj, src2: SignalObj) → SignalObj[source]#

Compute convolution of two signals with scipy.signal.convolve()

Paramètres:

src1 – source signal 1
src2 – source signal 2

Renvoie:

Result signal object

class cdl.computation.signal.WindowingParam[source]#

Windowing parameters

method#

Méthode. Sélection unique parmi : “barthann”, “bartlett”, “blackman”, “blackman-harris”, “bohman”, “boxcar”, “cosine”, “exponential”, “flat-top”, “gaussian”, “hamming”, “hanning”, “kaiser”, “lanczos”, “nuttall”, “parzen”, “rectangular”, “taylor”, “tukey”. Par défaut : “hamming”.

Type:: guidata.dataset.dataitems.ChoiceItem

alpha#

Paramètre de forme de la fonction de fenêtrage de tukey. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

beta#

Paramètre de forme de la fonction de fenêtrage de kaiser. Par défaut : 14.0.

Type:: guidata.dataset.dataitems.FloatItem

sigma#

Paramètre de forme de la fonction de fenêtrage gaussienne. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, alpha: float, beta: float, sigma: float) → cdl.computation.signal.WindowingParam#

Renvoie une nouvelle instance de WindowingParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode. Sélection unique parmi : “barthann”, “bartlett”, “blackman”, “blackman-harris”, “bohman”, “boxcar”, “cosine”, “exponential”, “flat-top”, “gaussian”, “hamming”, “hanning”, “kaiser”, “lanczos”, “nuttall”, “parzen”, “rectangular”, “taylor”, “tukey”. Par défaut : “hamming”.
alpha (float) – Paramètre de forme de la fonction de fenêtrage de tukey. Par défaut : 0.5.
beta (float) – Paramètre de forme de la fonction de fenêtrage de kaiser. Par défaut : 14.0.
sigma (float) – Paramètre de forme de la fonction de fenêtrage gaussienne. Par défaut : 0.5.

Renvoie:

Nouvelle instance de WindowingParam.

cdl.computation.signal.compute_windowing(src: SignalObj, p: WindowingParam) → SignalObj[source]#

Compute windowing (available methods: hamming, hanning, bartlett, blackman, tukey, rectangular) with cdl.algorithms.signal.windowing()

Paramètres:

dst – destination signal
src – source signal

Renvoie:

Result signal object

cdl.computation.signal.compute_reverse_x(src: SignalObj) → SignalObj[source]#

Reverse x-axis

Paramètres:: src – source signal
Renvoie:: Result signal object

class cdl.computation.signal.AngleUnitParam[source]#

Choice of angle unit.

unit#

Unité de l’angle. Sélection unique parmi : “rad”, “deg”. Par défaut : “rad”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(unit: str) → cdl.computation.signal.AngleUnitParam#

Renvoie une nouvelle instance de AngleUnitParam avec les champs initialisés aux valeurs données.

Paramètres:: unit (str) – Unité de l’angle. Sélection unique parmi : “rad”, “deg”. Par défaut : “rad”.
Renvoie:: Nouvelle instance de AngleUnitParam.

cdl.computation.signal.compute_cartesian2polar(src: SignalObj, p: AngleUnitParam) → SignalObj[source]#

Convert cartesian coordinates to polar coordinates with cdl.algorithms.coordinates.cartesian2polar().

Paramètres:

src – Source signal.
p – Parameters.

Renvoie:

Result signal object.

cdl.computation.signal.compute_polar2cartesian(src: SignalObj, p: AngleUnitParam) → SignalObj[source]#

Convert polar coordinates to cartesian coordinates with cdl.algorithms.coordinates.polar2cartesian().

Paramètres:

src – Source signal.
p – Parameters.

Renvoie:

Result signal object.

Note

This function assumes that the x-axis represents the radius and the y-axis represents the angle. Negative values are not allowed for the radius, and will be clipped to 0 (a warning will be raised).

class cdl.computation.signal.AllanVarianceParam[source]#

Allan variance parameters

max_tau#

Max τ. Entier supérieur à 1, unité : pts. Par défaut : 100.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(max_tau: int) → cdl.computation.signal.AllanVarianceParam#

Renvoie une nouvelle instance de AllanVarianceParam avec les champs initialisés aux valeurs données.

Paramètres:: max_tau (int) – Max τ. Entier supérieur à 1, unité : pts. Par défaut : 100.
Renvoie:: Nouvelle instance de AllanVarianceParam.

cdl.computation.signal.compute_allan_variance(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Allan variance with cdl.algorithms.signal.allan_variance()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_allan_deviation(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Allan deviation with cdl.algorithms.signal.allan_deviation()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_overlapping_allan_variance(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Overlapping Allan variance.

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_modified_allan_variance(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Modified Allan variance.

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_hadamard_variance(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Hadamard variance.

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_total_variance(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Total variance.

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.compute_time_deviation(src: SignalObj, p: AllanVarianceParam) → SignalObj[source]#

Compute Time Deviation (TDEV).

Paramètres:

src – source signal
p – parameters

Renvoie:

Result signal object

cdl.computation.signal.calc_resultshape(title: str, shape: Literal['rectangle', 'circle', 'ellipse', 'segment', 'marker', 'point', 'polygon'], obj: SignalObj, func: Callable, *args: Any, add_label: bool = False) → ResultShape | None[source]#

Calculate result shape by executing a computation function on a signal object, taking into account the signal ROIs.

Paramètres:

title – result title
shape – result shape kind
obj – input image object
func – computation function
*args – computation function arguments
add_label – if True, add a label item (and the geometrical shape) to plot (default to False)

Renvoie:

Result shape object or None if no result is found

Avertissement

The computation function must take either a single argument (the data) or multiple arguments (the data followed by the computation parameters).

Moreover, the computation function must return a 1D NumPy array (or a list, or a tuple) containing the result of the computation.

class cdl.computation.signal.FWHMParam[source]#

FWHM parameters

method#

Méthode. Sélection unique parmi : “zero-crossing”, “gauss”, “lorentz”, “voigt”. Par défaut : “zero-crossing”.

Type:: guidata.dataset.dataitems.ChoiceItem

xmin#

X_MIN. Borne x inférieure (vide pour aucune limite, c’est-à-dire le début du signal). Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

xmax#

X_MAX. Borne x supérieure (vide pour aucune limite, c’est-à-dire la fin du signal). Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(method: str, xmin: float, xmax: float) → cdl.computation.signal.FWHMParam#

Renvoie une nouvelle instance de FWHMParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode. Sélection unique parmi : “zero-crossing”, “gauss”, “lorentz”, “voigt”. Par défaut : “zero-crossing”.
xmin (float) – X_MIN. Borne x inférieure (vide pour aucune limite, c’est-à-dire le début du signal). Par défaut : None.
xmax (float) – X_MAX. Borne x supérieure (vide pour aucune limite, c’est-à-dire la fin du signal). Par défaut : None.

Renvoie:

Nouvelle instance de FWHMParam.

cdl.computation.signal.compute_fwhm(obj: SignalObj, param: FWHMParam) → ResultShape | None[source]#

Compute FWHM with cdl.algorithms.signal.fwhm()

Paramètres:

obj – source signal
param – parameters

Renvoie:

Segment coordinates

cdl.computation.signal.compute_fw1e2(obj: SignalObj) → ResultShape | None[source]#

Compute FW at 1/e² with cdl.algorithms.signal.fw1e2()

Paramètres:: obj – source signal
Renvoie:: Segment coordinates

class cdl.computation.signal.FindAbscissaParam[source]#

Parameter dataset for abscissa finding

y#

Coordonnées. Par défaut : 0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(y: float) → cdl.computation.signal.FindAbscissaParam#

Renvoie une nouvelle instance de FindAbscissaParam avec les champs initialisés aux valeurs données.

Paramètres:: y (float) – Coordonnées. Par défaut : 0.
Renvoie:: Nouvelle instance de FindAbscissaParam.

cdl.computation.signal.compute_x_at_y(obj: SignalObj, p: FindAbscissaParam) → ResultProperties[source]#

Compute the smallest x-value at a given y-value for a signal object.

Paramètres:

obj – The signal object containing x and y data.
p – The parameter dataset for finding the abscissa.

Renvoie:

An object containing the x-value.

cdl.computation.signal.compute_stats(obj: SignalObj) → ResultProperties[source]#

Compute statistics on a signal

Paramètres:: obj – source signal
Renvoie:: Result properties object

cdl.computation.signal.compute_bandwidth_3db(obj: SignalObj) → ResultProperties[source]#

Compute bandwidth at -3 dB with cdl.algorithms.signal.bandwidth()

Paramètres:: obj – source signal
Renvoie:: Result properties with bandwidth

class cdl.computation.signal.DynamicParam[source]#

Parameters for dynamic range computation (ENOB, SNR, SINAD, THD, SFDR)

full_scale#

Pleine échelle. Flottant supérieur à 0.0, unité : v. Par défaut : 0.16.

Type:: guidata.dataset.dataitems.FloatItem

unit#

Unité. Unité pour sinad. Sélection unique parmi : “dBc”, “dBFS”. Par défaut : “dBc”.

Type:: guidata.dataset.dataitems.ChoiceItem

nb_harm#

Nombre d’harmoniques. Nombre d’harmoniques à considérer pour le thd. Entier supérieur à 1. Par défaut : 5.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(full_scale: float, unit: str, nb_harm: int) → cdl.computation.signal.DynamicParam#

Renvoie une nouvelle instance de DynamicParam avec les champs initialisés aux valeurs données.

Paramètres:

full_scale (float) – Pleine échelle. Flottant supérieur à 0.0, unité : v. Par défaut : 0.16.
unit (str) – Unité. Unité pour sinad. Sélection unique parmi : “dBc”, “dBFS”. Par défaut : “dBc”.
nb_harm (int) – Nombre d’harmoniques. Nombre d’harmoniques à considérer pour le thd. Entier supérieur à 1. Par défaut : 5.

Renvoie:

Nouvelle instance de DynamicParam.

cdl.computation.signal.compute_dynamic_parameters(src: SignalObj, p: DynamicParam) → ResultProperties[source]#

Compute Dynamic parameters using the following functions:

Freq: cdl.algorithms.signal.sinus_frequency()
ENOB: cdl.algorithms.signal.enob()
SNR: cdl.algorithms.signal.snr()
SINAD: cdl.algorithms.signal.sinad()
THD: cdl.algorithms.signal.thd()
SFDR: cdl.algorithms.signal.sfdr()

Paramètres:

src – source signal
p – parameters

Renvoie:

Result properties with ENOB, SNR, SINAD, THD, SFDR

cdl.computation.signal.compute_sampling_rate_period(obj: SignalObj) → ResultProperties[source]#

Compute sampling rate and period using the following functions:

Paramètres:: obj – source signal
Renvoie:: Result properties with sampling rate and period

cdl.computation.signal.compute_contrast(obj: SignalObj) → ResultProperties[source]#: Compute contrast with cdl.algorithms.signal.contrast()

cdl.computation.signal.compute_x_at_minmax(obj: SignalObj) → ResultProperties[source]#

Compute the smallest argument at the minima and the smallest argument at the maxima.

Paramètres:: obj – The signal object.
Renvoie:: An object containing the x-values at the minima and the maxima.

Image processing features#

Base image processing features#

cdl.computation.image.restore_data_outside_roi(dst: ImageObj, src: ImageObj) → None[source]#

Restore data outside the Region Of Interest (ROI) of the input image after a computation, only if the input image has a ROI, and if the output image has the same ROI as the input image, and if the data types are compatible, and if the shapes are the same. Otherwise, do nothing.

Paramètres:

dst – output image object
src – input image object

class cdl.computation.image.Wrap11Func(func: Callable, *args: Any, **kwargs: Any)[source]#

Wrap a 1 array → 1 array function to produce a 1 image → 1 image function, which can be used inside DataLab’s infrastructure to perform computations with cdl.core.gui.processor.image.ImageProcessor.

This wrapping mechanism using a class is necessary for the resulted function to be pickable by the multiprocessing module.

The instance of this wrapper is callable and returns a cdl.obj.ImageObj object.

Exemple

>>> import numpy as np
>>> from cdl.computation.image import Wrap11Func
>>> import cdl.obj
>>> def add_noise(data):
...     return data + np.random.random(data.shape)
>>> compute_add_noise = Wrap11Func(add_noise)
>>> data= np.ones((100, 100))
>>> ima0 = cdl.obj.create_image("Example", data)
>>> ima1 = compute_add_noise(ima0)

Paramètres:

func – 1 array → 1 array function
*args – Additional positional arguments to pass to the function
**kwargs – Additional keyword arguments to pass to the function

cdl.computation.image.dst_11_signal(src: ImageObj, name: str, suffix: str | None = None) → SignalObj[source]#

Create a result signal object, as returned by the callback function of the cdl.core.gui.processor.base.BaseProcessor.compute_11() method

Paramètres:

src – input image object
name – name of the processing function

Renvoie:

Output signal object

cdl.computation.image.compute_addition(dst: ImageObj, src: ImageObj) → ImageObj[source]#

Add dst and src images and return dst image modified in place

Paramètres:

dst – output image object
src – input image object

Renvoie:

Output image object (modified in place)

cdl.computation.image.compute_product(dst: ImageObj, src: ImageObj) → ImageObj[source]#

Multiply dst and src images and return dst image modified in place

Paramètres:

dst – output image object
src – input image object

Renvoie:

Output image object (modified in place)

cdl.computation.image.compute_addition_constant(src: ImageObj, p: ConstantParam) → ImageObj[source]#

Add dst and a constant value and return the new result image object

Paramètres:

src – input image object
p – constant value

Renvoie:

Result image object src + p.value (new object)

cdl.computation.image.compute_difference_constant(src: ImageObj, p: ConstantParam) → ImageObj[source]#

Subtract a constant value from an image and return the new result image object

Paramètres:

src – input image object
p – constant value

Renvoie:

Result image object src - p.value (new object)

cdl.computation.image.compute_product_constant(src: ImageObj, p: ConstantParam) → ImageObj[source]#

Multiply dst by a constant value and return the new result image object

Paramètres:

src – input image object
p – constant value

Renvoie:

Result image object src * p.value (new object)

cdl.computation.image.compute_division_constant(src: ImageObj, p: ConstantParam) → ImageObj[source]#

Divide an image by a constant value and return the new result image object

Paramètres:

src – input image object
p – constant value

Renvoie:

Result image object src / p.value (new object)

cdl.computation.image.compute_arithmetic(src1: ImageObj, src2: ImageObj, p: ArithmeticParam) → ImageObj[source]#

Compute arithmetic operation on two images

Paramètres:

src1 – input image object
src2 – input image object
p – arithmetic parameters

Renvoie:

Result image object

cdl.computation.image.compute_difference(src1: ImageObj, src2: ImageObj) → ImageObj[source]#

Compute difference between two images

Paramètres:

src1 – input image object
src2 – input image object

Renvoie:

Result image object src1 - src2 (new object)

cdl.computation.image.compute_quadratic_difference(src1: ImageObj, src2: ImageObj) → ImageObj[source]#

Compute quadratic difference between two images

Paramètres:

src1 – input image object
src2 – input image object

Renvoie:

Result image object (src1 - src2) / sqrt(2.0) (new object)

cdl.computation.image.compute_division(src1: ImageObj, src2: ImageObj) → ImageObj[source]#

Compute division between two images

Paramètres:

src1 – input image object
src2 – input image object

Renvoie:

Result image object src1 / src2 (new object)

class cdl.computation.image.FlatFieldParam[source]#

Flat-field parameters

threshold#

Seuil. Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(threshold: float) → cdl.computation.image.FlatFieldParam#

Renvoie une nouvelle instance de FlatFieldParam avec les champs initialisés aux valeurs données.

Paramètres:: threshold (float) – Seuil. Par défaut : 0.0.
Renvoie:: Nouvelle instance de FlatFieldParam.

cdl.computation.image.compute_flatfield(src1: ImageObj, src2: ImageObj, p: FlatFieldParam) → ImageObj[source]#

Compute flat field correction with cdl.algorithms.image.flatfield()

Paramètres:

src1 – raw data image object
src2 – flat field image object
p – flat field parameters

Renvoie:

Output image object

cdl.computation.image.compute_normalize(src: ImageObj, p: NormalizeParam) → ImageObj[source]#

Normalize image data depending on its maximum, with cdl.algorithms.image.normalize()

Paramètres:: src – input image object
Renvoie:: Output image object

class cdl.computation.image.LogP1Param[source]#

Log10 parameters

n#

Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(n: float) → cdl.computation.image.LogP1Param#

Renvoie une nouvelle instance de LogP1Param avec les champs initialisés aux valeurs données.

Paramètres:: n (float) – Par défaut : None.
Renvoie:: Nouvelle instance de LogP1Param.

cdl.computation.image.compute_logp1(src: ImageObj, p: LogP1Param) → ImageObj[source]#

Compute log10(z+n) with numpy.log10

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.RotateParam[source]#

Rotate parameters

angle#

Angle (°). Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

mode#

Sélection unique parmi : “constant”, “nearest”, “reflect”, “wrap”. Par défaut : “constant”.

Type:: guidata.dataset.dataitems.ChoiceItem

cval#

Valeur utilisée pour les points situés en dehors des frontières de l’image d’origine (si le mode est “constant”). Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

reshape#

Redimensionner l’image de destination de sorte qu’elle puisse contenir la totalité de l’image source. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

prefilter#

Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

order#

Ordre. Ordre de l’interpolation de type spline. Entier compris entre 0 et 5. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(angle: float, mode: str, cval: float, reshape: bool, prefilter: bool, order: int) → cdl.computation.image.RotateParam#

Renvoie une nouvelle instance de RotateParam avec les champs initialisés aux valeurs données.

Paramètres:

angle (float) – Angle (°). Par défaut : None.
mode (str) – Sélection unique parmi : “constant”, “nearest”, “reflect”, “wrap”. Par défaut : “constant”.
cval (float) – Valeur utilisée pour les points situés en dehors des frontières de l’image d’origine (si le mode est “constant”). Par défaut : 0.0.
reshape (bool) – Redimensionner l’image de destination de sorte qu’elle puisse contenir la totalité de l’image source. Par défaut : False.
prefilter (bool) – Par défaut : True.
order (int) – Ordre. Ordre de l’interpolation de type spline. Entier compris entre 0 et 5. Par défaut : 3.

Renvoie:

Nouvelle instance de RotateParam.

cdl.computation.image.rotate_obj_coords(angle: float, obj: ImageObj, orig: ImageObj, coords: ndarray) → None[source]#

Apply rotation to coords associated to image obj

Paramètres:

angle – rotation angle (in degrees)
obj – image object
orig – original image object
coords – coordinates to rotate

Renvoie:

Output data

cdl.computation.image.rotate_obj_alpha(obj: ImageObj, orig: ImageObj, coords: ndarray, p: RotateParam) → None[source]#: Apply rotation to coords associated to image obj

cdl.computation.image.compute_rotate(src: ImageObj, p: RotateParam) → ImageObj[source]#

Rotate data with scipy.ndimage.rotate()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.rotate_obj_90(dst: ImageObj, src: ImageObj, coords: ndarray) → None[source]#: Apply rotation to coords associated to image obj

cdl.computation.image.compute_rotate90(src: ImageObj) → ImageObj[source]#

Rotate data 90° with numpy.rot90()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.rotate_obj_270(dst: ImageObj, src: ImageObj, coords: ndarray) → None[source]#: Apply rotation to coords associated to image obj

cdl.computation.image.compute_rotate270(src: ImageObj) → ImageObj[source]#

Rotate data 270° with numpy.rot90()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.hflip_coords(dst: ImageObj, src: ImageObj, coords: ndarray) → None[source]#: Apply HFlip to coords

cdl.computation.image.compute_fliph(src: ImageObj) → ImageObj[source]#

Flip data horizontally with numpy.fliplr()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.vflip_coords(dst: ImageObj, src: ImageObj, coords: ndarray) → None[source]#: Apply VFlip to coords

cdl.computation.image.compute_flipv(src: ImageObj) → ImageObj[source]#

Flip data vertically with numpy.flipud()

Paramètres:: src – input image object
Renvoie:: Output image object

class cdl.computation.image.GridParam[source]#

Grid parameters

direction#

Distribuer selon les. Sélection unique parmi : “col”, “row”. Par défaut : “col”.

Type:: guidata.dataset.dataitems.ChoiceItem

cols#

Colonnes. Entier, non nul. Par défaut : 1.

Type:: guidata.dataset.dataitems.IntItem

rows#

Lignes. Entier, non nul. Par défaut : 1.

Type:: guidata.dataset.dataitems.IntItem

colspac#

Espace entre chaque colonne. Flottant supérieur à 0.0. Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

rowspac#

Espace entre chaque ligne. Flottant supérieur à 0.0. Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(direction: str, cols: int, rows: int, colspac: float, rowspac: float) → cdl.computation.image.GridParam#

Renvoie une nouvelle instance de GridParam avec les champs initialisés aux valeurs données.

Paramètres:

direction (str) – Distribuer selon les. Sélection unique parmi : “col”, “row”. Par défaut : “col”.
cols (int) – Colonnes. Entier, non nul. Par défaut : 1.
rows (int) – Lignes. Entier, non nul. Par défaut : 1.
colspac (float) – Espace entre chaque colonne. Flottant supérieur à 0.0. Par défaut : 0.0.
rowspac (float) – Espace entre chaque ligne. Flottant supérieur à 0.0. Par défaut : 0.0.

Renvoie:

Nouvelle instance de GridParam.

class cdl.computation.image.ResizeParam[source]#

Resize parameters

zoom#

Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

mode#

Sélection unique parmi : “constant”, “nearest”, “reflect”, “wrap”. Par défaut : “constant”.

Type:: guidata.dataset.dataitems.ChoiceItem

cval#

Valeur utilisée pour les points situés en dehors des frontières de l’image d’origine (si le mode est “constant”). Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

prefilter#

Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

order#

Ordre. Ordre de l’interpolation de type spline. Entier compris entre 0 et 5. Par défaut : 3.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(zoom: float, mode: str, cval: float, prefilter: bool, order: int) → cdl.computation.image.ResizeParam#

Renvoie une nouvelle instance de ResizeParam avec les champs initialisés aux valeurs données.

Paramètres:

zoom (float) – Par défaut : None.
mode (str) – Sélection unique parmi : “constant”, “nearest”, “reflect”, “wrap”. Par défaut : “constant”.
cval (float) – Valeur utilisée pour les points situés en dehors des frontières de l’image d’origine (si le mode est “constant”). Par défaut : 0.0.
prefilter (bool) – Par défaut : True.
order (int) – Ordre. Ordre de l’interpolation de type spline. Entier compris entre 0 et 5. Par défaut : 3.

Renvoie:

Nouvelle instance de ResizeParam.

cdl.computation.image.compute_resize(src: ImageObj, p: ResizeParam) → ImageObj[source]#

Zooming function with scipy.ndimage.zoom()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.BinningParam[source]#

Binning parameters

sx#

Nombre de pixels (X). Nombre de pixels adjacents à regrouper le long de l’axe des x. Entier supérieur à 2. Par défaut : 2.

Type:: guidata.dataset.dataitems.IntItem

sy#

Nombre de pixels (Y). Nombre de pixels adjacents à regrouper le long de l’axe des y. Entier supérieur à 2. Par défaut : 2.

Type:: guidata.dataset.dataitems.IntItem

operation#

Opération. Sélection unique parmi : “sum”, “average”, “median”, “min”, “max”. Par défaut : “sum”.

Type:: guidata.dataset.dataitems.ChoiceItem

dtype_str#

Type de données. Type de données de l’image générée. Sélection unique parmi : “dtype”, “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “dtype”.

Type:: guidata.dataset.dataitems.ChoiceItem

change_pixel_size#

Modification de la taille des pixels de sorte que les dimensions de l’images restent les mêmes après l’opération. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(sx: int, sy: int, operation: str, dtype_str: str, change_pixel_size: bool) → cdl.computation.image.BinningParam#

Renvoie une nouvelle instance de BinningParam avec les champs initialisés aux valeurs données.

Paramètres:

sx (int) – Nombre de pixels (X). Nombre de pixels adjacents à regrouper le long de l’axe des x. Entier supérieur à 2. Par défaut : 2.
sy (int) – Nombre de pixels (Y). Nombre de pixels adjacents à regrouper le long de l’axe des y. Entier supérieur à 2. Par défaut : 2.
operation (str) – Opération. Sélection unique parmi : “sum”, “average”, “median”, “min”, “max”. Par défaut : “sum”.
dtype_str (str) – Type de données. Type de données de l’image générée. Sélection unique parmi : “dtype”, “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “dtype”.
change_pixel_size (bool) – Modification de la taille des pixels de sorte que les dimensions de l’images restent les mêmes après l’opération. Par défaut : False.

Renvoie:

Nouvelle instance de BinningParam.

cdl.computation.image.compute_binning(src: ImageObj, param: BinningParam) → ImageObj[source]#

Binning function on data with cdl.algorithms.image.binning()

Paramètres:

src – input image object
param – parameters

Renvoie:

Output image object

cdl.computation.image.extract_multiple_roi(src: ImageObj, group: DataSetGroup) → ImageObj[source]#

Extract multiple regions of interest from data

Paramètres:

src – input image object
group – parameters defining the regions of interest

Renvoie:

Output image object

cdl.computation.image.extract_single_roi(src: ImageObj, p: ROI2DParam) → ImageObj[source]#

Extract single ROI

Paramètres:

src – input image object
p – ROI parameters

Renvoie:

Output image object

class cdl.computation.image.LineProfileParam[source]#

Horizontal or vertical profile parameters

direction#

Sélection unique parmi : “horizontal”, “vertical”. Par défaut : “horizontal”.

Type:: guidata.dataset.dataitems.ChoiceItem

row#

Ligne. Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

col#

Colonne. Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(direction: str, row: int, col: int) → cdl.computation.image.LineProfileParam#

Renvoie une nouvelle instance de LineProfileParam avec les champs initialisés aux valeurs données.

Paramètres:

direction (str) – Sélection unique parmi : “horizontal”, “vertical”. Par défaut : “horizontal”.
row (int) – Ligne. Entier supérieur à 0. Par défaut : 0.
col (int) – Colonne. Entier supérieur à 0. Par défaut : 0.

Renvoie:

Nouvelle instance de LineProfileParam.

cdl.computation.image.compute_line_profile(src: ImageObj, p: LineProfileParam) → SignalObj[source]#

Compute horizontal or vertical profile

Paramètres:

src – input image object
p – parameters

Renvoie:

Signal object with the profile

class cdl.computation.image.SegmentProfileParam[source]#

Segment profile parameters

row1#

Ligne (début). Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

col1#

Colonne (début). Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

row2#

Ligne (fin). Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

col2#

Colonne (fin). Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(row1: int, col1: int, row2: int, col2: int) → cdl.computation.image.SegmentProfileParam#

Renvoie une nouvelle instance de SegmentProfileParam avec les champs initialisés aux valeurs données.

Paramètres:

row1 (int) – Ligne (début). Entier supérieur à 0. Par défaut : 0.
col1 (int) – Colonne (début). Entier supérieur à 0. Par défaut : 0.
row2 (int) – Ligne (fin). Entier supérieur à 0. Par défaut : 0.
col2 (int) – Colonne (fin). Entier supérieur à 0. Par défaut : 0.

Renvoie:

Nouvelle instance de SegmentProfileParam.

cdl.computation.image.compute_segment_profile(src: ImageObj, p: SegmentProfileParam) → SignalObj[source]#

Compute segment profile

Paramètres:

src – input image object
p – parameters

Renvoie:

Signal object with the segment profile

class cdl.computation.image.AverageProfileParam[source]#

Average horizontal or vertical profile parameters

direction#

Sélection unique parmi : “horizontal”, “vertical”. Par défaut : “horizontal”.

Type:: guidata.dataset.dataitems.ChoiceItem

row1#

Ligne 1. Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

row2#

Ligne 2. Entier supérieur à -1. Par défaut : -1.

Type:: guidata.dataset.dataitems.IntItem

col1#

Colonne 1. Entier supérieur à 0. Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

col2#

Colonne 2. Entier supérieur à -1. Par défaut : -1.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(direction: str, row1: int, row2: int, col1: int, col2: int) → cdl.computation.image.AverageProfileParam#

Renvoie une nouvelle instance de AverageProfileParam avec les champs initialisés aux valeurs données.

Paramètres:

direction (str) – Sélection unique parmi : “horizontal”, “vertical”. Par défaut : “horizontal”.
row1 (int) – Ligne 1. Entier supérieur à 0. Par défaut : 0.
row2 (int) – Ligne 2. Entier supérieur à -1. Par défaut : -1.
col1 (int) – Colonne 1. Entier supérieur à 0. Par défaut : 0.
col2 (int) – Colonne 2. Entier supérieur à -1. Par défaut : -1.

Renvoie:

Nouvelle instance de AverageProfileParam.

cdl.computation.image.compute_average_profile(src: ImageObj, p: AverageProfileParam) → SignalObj[source]#

Compute horizontal or vertical average profile

Paramètres:

src – input image object
p – parameters

Renvoie:

Signal object with the average profile

class cdl.computation.image.RadialProfileParam[source]#

Radial profile parameters

center#

Position du centre. Sélection unique parmi : “centroid”, “center”, “user”. Par défaut : “centroid”.

Type:: guidata.dataset.dataitems.ChoiceItem

x0#

X_Centre. Flottant, unité : pixel. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

y0#

X_Centre. Flottant, unité : pixel. Par défaut : None.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(center: str, x0: float, y0: float) → cdl.computation.image.RadialProfileParam#

Renvoie une nouvelle instance de RadialProfileParam avec les champs initialisés aux valeurs données.

Paramètres:

center (str) – Position du centre. Sélection unique parmi : “centroid”, “center”, “user”. Par défaut : “centroid”.
x0 (float) – X_Centre. Flottant, unité : pixel. Par défaut : None.
y0 (float) – X_Centre. Flottant, unité : pixel. Par défaut : None.

Renvoie:

Nouvelle instance de RadialProfileParam.

update_from_image(obj: ImageObj) → None[source]#: Update parameters from image

choice_callback(item, value)[source]#: Callback for choice item

cdl.computation.image.compute_radial_profile(src: ImageObj, p: RadialProfileParam) → SignalObj[source]#

Compute radial profile around the centroid with cdl.algorithms.image.get_radial_profile()

Paramètres:

src – input image object
p – parameters

Renvoie:

Signal object with the radial profile

cdl.computation.image.compute_histogram(src: ImageObj, p: HistogramParam) → SignalObj[source]#

Compute histogram of the image data, with numpy.histogram()

Paramètres:

src – input image object
p – parameters

Renvoie:

Signal object with the histogram

cdl.computation.image.compute_swap_axes(src: ImageObj) → ImageObj[source]#

Swap image axes with numpy.transpose()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.compute_inverse(src: ImageObj) → ImageObj[source]#

Compute the inverse of an image and return the new result image object

Paramètres:: src – input image object
Renvoie:: Result image object 1 / src (new object)

cdl.computation.image.compute_abs(src: ImageObj) → ImageObj[source]#

Compute absolute value with numpy.absolute

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.compute_re(src: ImageObj) → ImageObj[source]#

Compute real part with numpy.real()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.compute_im(src: ImageObj) → ImageObj[source]#

Compute imaginary part with numpy.imag()

Paramètres:: src – input image object
Renvoie:: Output image object

class cdl.computation.image.DataTypeIParam[source]#

Convert image data type parameters

dtype_str#

Type de données de destination. Type de données de l’image générée. Sélection unique parmi : “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “float32”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(dtype_str: str) → cdl.computation.image.DataTypeIParam#

Renvoie une nouvelle instance de DataTypeIParam avec les champs initialisés aux valeurs données.

Paramètres:: dtype_str (str) – Type de données de destination. Type de données de l’image générée. Sélection unique parmi : “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “float32”.
Renvoie:: Nouvelle instance de DataTypeIParam.

cdl.computation.image.compute_astype(src: ImageObj, p: DataTypeIParam) → ImageObj[source]#

Convert image data type with cdl.algorithms.datatypes.clip_astype()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_log10(src: ImageObj) → ImageObj[source]#

Compute log10 with numpy.log10

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.compute_exp(src: ImageObj) → ImageObj[source]#

Compute exponential with numpy.exp

Paramètres:: src – input image object
Renvoie:: Output image object

class cdl.computation.image.ZCalibrateParam[source]#

Image linear calibration parameters

a#

Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

b#

Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(a: float, b: float) → cdl.computation.image.ZCalibrateParam#

Renvoie une nouvelle instance de ZCalibrateParam avec les champs initialisés aux valeurs données.

Paramètres:

a (float) – Par défaut : 1.0.
b (float) – Par défaut : 0.0.

Renvoie:

Nouvelle instance de ZCalibrateParam.

cdl.computation.image.compute_calibration(src: ImageObj, p: ZCalibrateParam) → ImageObj[source]#

Compute linear calibration

Paramètres:

src – input image object
p – calibration parameters

Renvoie:

Output image object

cdl.computation.image.compute_clip(src: ImageObj, p: ClipParam) → ImageObj[source]#

Apply clipping with numpy.clip()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_offset_correction(src: ImageObj, p: ROI2DParam) → ImageObj[source]#

Apply offset correction

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_gaussian_filter(src: ImageObj, p: GaussianParam) → ImageObj[source]#

Compute gaussian filter with scipy.ndimage.gaussian_filter()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_moving_average(src: ImageObj, p: MovingAverageParam) → ImageObj[source]#

Compute moving average with scipy.ndimage.uniform_filter()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_moving_median(src: ImageObj, p: MovingMedianParam) → ImageObj[source]#

Compute moving median with scipy.ndimage.median_filter()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_wiener(src: ImageObj) → ImageObj[source]#

Compute Wiener filter with scipy.signal.wiener()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.compute_fft(src: ImageObj, p: FFTParam | None = None) → ImageObj[source]#

Compute FFT with cdl.algorithms.image.fft2d()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_ifft(src: ImageObj, p: FFTParam | None = None) → ImageObj[source]#

Compute inverse FFT with cdl.algorithms.image.ifft2d()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_magnitude_spectrum(src: ImageObj, p: SpectrumParam | None = None) → ImageObj[source]#

Compute magnitude spectrum with cdl.algorithms.image.magnitude_spectrum()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.compute_phase_spectrum(src: ImageObj) → ImageObj[source]#

Compute phase spectrum with cdl.algorithms.image.phase_spectrum()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.compute_psd(src: ImageObj, p: SpectrumParam | None = None) → ImageObj[source]#

Compute power spectral density with cdl.algorithms.image.psd()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.ButterworthParam[source]#

Butterworth filter parameters

cut_off#

Fréquence de coupure relative. Fréquence de coupure relative. Flottant compris entre 0.0 et 0.5. Par défaut : 0.005.

Type:: guidata.dataset.dataitems.FloatItem

high_pass#

Si vrai, appliquer un filtre passe-haut au lieu d’un filtre passe-bas. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

order#

Ordre. Ordre du filtre de butterworth. Entier supérieur à 1. Par défaut : 2.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(cut_off: float, high_pass: bool, order: int) → cdl.computation.image.ButterworthParam#

Renvoie une nouvelle instance de ButterworthParam avec les champs initialisés aux valeurs données.

Paramètres:

cut_off (float) – Fréquence de coupure relative. Fréquence de coupure relative. Flottant compris entre 0.0 et 0.5. Par défaut : 0.005.
high_pass (bool) – Si vrai, appliquer un filtre passe-haut au lieu d’un filtre passe-bas. Par défaut : False.
order (int) – Ordre. Ordre du filtre de butterworth. Entier supérieur à 1. Par défaut : 2.

Renvoie:

Nouvelle instance de ButterworthParam.

cdl.computation.image.compute_butterworth(src: ImageObj, p: ButterworthParam) → ImageObj[source]#

Compute Butterworth filter with skimage.filters.butterworth()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.calc_resultshape(title: str, shape: Literal['rectangle', 'circle', 'ellipse', 'segment', 'marker', 'point', 'polygon'], obj: ImageObj, func: Callable, *args: Any, add_label: bool = False) → ResultShape | None[source]#

Calculate result shape by executing a computation function on an image object, taking into account the image origin (x0, y0), scale (dx, dy) and ROIs.

Paramètres:

title – result title
shape – result shape kind
obj – input image object
func – computation function
*args – computation function arguments
add_label – if True, add a label item (and the geometrical shape) to plot (default to False)

Renvoie:

Result shape object or None if no result is found

Avertissement

The computation function must take either a single argument (the data) or multiple arguments (the data followed by the computation parameters).

Moreover, the computation function must return a single value or a NumPy array containing the result of the computation. This array contains the coordinates of points, polygons, circles or ellipses in the form [[x, y], …], or [[x0, y0, x1, y1, …], …], or [[x0, y0, r], …], or [[x0, y0, a, b, theta], …].

cdl.computation.image.get_centroid_coords(data: ndarray) → ndarray[source]#

Return centroid coordinates with cdl.algorithms.image.get_centroid_fourier()

Paramètres:: data – input data
Renvoie:: Centroid coordinates

cdl.computation.image.compute_centroid(image: ImageObj) → ResultShape | None[source]#

Compute centroid with cdl.algorithms.image.get_centroid_fourier()

Paramètres:: image – input image
Renvoie:: Centroid coordinates

cdl.computation.image.get_enclosing_circle_coords(data: ndarray) → ndarray[source]#

Return diameter coords for the circle contour enclosing image values above threshold (FWHM)

Paramètres:: data – input data
Renvoie:: Diameter coords

cdl.computation.image.compute_enclosing_circle(image: ImageObj) → ResultShape | None[source]#

Compute minimum enclosing circle with cdl.algorithms.image.get_enclosing_circle()

Paramètres:: image – input image
Renvoie:: Diameter coords

class cdl.computation.image.HoughCircleParam[source]#

Circle Hough transform parameters

min_radius#

Rayon_min. Entier supérieur à 0, non nul, unité : pixels. Par défaut : None.

Type:: guidata.dataset.dataitems.IntItem

max_radius#

Rayon_max. Entier supérieur à 0, non nul, unité : pixels. Par défaut : None.

Type:: guidata.dataset.dataitems.IntItem

min_distance#

Distance minimale. Entier supérieur à 0. Par défaut : None.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(min_radius: int, max_radius: int, min_distance: int) → cdl.computation.image.HoughCircleParam#

Renvoie une nouvelle instance de HoughCircleParam avec les champs initialisés aux valeurs données.

Paramètres:

min_radius (int) – Rayon_min. Entier supérieur à 0, non nul, unité : pixels. Par défaut : None.
max_radius (int) – Rayon_max. Entier supérieur à 0, non nul, unité : pixels. Par défaut : None.
min_distance (int) – Distance minimale. Entier supérieur à 0. Par défaut : None.

Renvoie:

Nouvelle instance de HoughCircleParam.

cdl.computation.image.compute_hough_circle_peaks(image: ImageObj, p: HoughCircleParam) → ResultShape | None[source]#

Compute Hough circles with cdl.algorithms.image.get_hough_circle_peaks()

Paramètres:

image – input image
p – parameters

Renvoie:

Circle coordinates

cdl.computation.image.compute_stats(obj: ImageObj) → ResultProperties[source]#

Compute statistics on an image

Paramètres:: obj – input image object
Renvoie:: Result properties

Threshold features#

Threshold computation module#

class cdl.computation.image.threshold.ThresholdParam[source]#

Histogram threshold parameters

method#

Méthode de seuillage. Sélection unique parmi : “manual”, “isodata”, “li”, “mean”, “minimum”, “otsu”, “triangle”, “yen”. Par défaut : “manual”.

Type:: guidata.dataset.dataitems.ChoiceItem

bins#

Nombre de classes. Entier supérieur à 1. Par défaut : 256.

Type:: guidata.dataset.dataitems.IntItem

value#

Valeur de seuil. Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

operation#

Opération. Sélection unique parmi : “>”, “<”. Par défaut : “>”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(method: str, bins: int, value: float, operation: str) → cdl.computation.image.threshold.ThresholdParam#

Renvoie une nouvelle instance de ThresholdParam avec les champs initialisés aux valeurs données.

Paramètres:

method (str) – Méthode de seuillage. Sélection unique parmi : “manual”, “isodata”, “li”, “mean”, “minimum”, “otsu”, “triangle”, “yen”. Par défaut : “manual”.
bins (int) – Nombre de classes. Entier supérieur à 1. Par défaut : 256.
value (float) – Valeur de seuil. Par défaut : 0.0.
operation (str) – Opération. Sélection unique parmi : “>”, “<”. Par défaut : “>”.

Renvoie:

Nouvelle instance de ThresholdParam.

cdl.computation.image.threshold.compute_threshold(src: ImageObj, p: ThresholdParam) → ImageObj[source]#

Compute the threshold, using one of the available algorithms:

Manual: a fixed threshold value
ISODATA: skimage.filters.threshold_isodata()
Li: skimage.filters.threshold_li()
Mean: skimage.filters.threshold_mean()
Minimum: skimage.filters.threshold_minimum()
Otsu: skimage.filters.threshold_otsu()
Triangle: skimage.filters.threshold_triangle()
Yen: skimage.filters.threshold_yen()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.threshold.compute_threshold_isodata(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Isodata algorithm with default parameters, see skimage.filters.threshold_isodata()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.threshold.compute_threshold_li(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Li algorithm with default parameters, see skimage.filters.threshold_li()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.threshold.compute_threshold_mean(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Mean algorithm, see skimage.filters.threshold_mean()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.threshold.compute_threshold_minimum(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Minimum algorithm with default parameters, see skimage.filters.threshold_minimum()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.threshold.compute_threshold_otsu(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Otsu algorithm with default parameters, see skimage.filters.threshold_otsu()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.threshold.compute_threshold_triangle(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Triangle algorithm with default parameters, see skimage.filters.threshold_triangle()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.threshold.compute_threshold_yen(src: ImageObj) → ImageObj[source]#

Compute the threshold using the Yen algorithm with default parameters, see skimage.filters.threshold_yen()

Paramètres:: src – input image object
Renvoie:: Output image object

Exposure correction features#

Exposure computation module#

class cdl.computation.image.exposure.AdjustGammaParam[source]#

Gamma adjustment parameters

gamma#

Facteur de correction gamma (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

gain#

Facteur de gain (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(gamma: float, gain: float) → cdl.computation.image.exposure.AdjustGammaParam#

Renvoie une nouvelle instance de AdjustGammaParam avec les champs initialisés aux valeurs données.

Paramètres:

gamma (float) – Facteur de correction gamma (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 1.0.
gain (float) – Facteur de gain (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 1.0.

Renvoie:

Nouvelle instance de AdjustGammaParam.

cdl.computation.image.exposure.compute_adjust_gamma(src: ImageObj, p: AdjustGammaParam) → ImageObj[source]#

Gamma correction with skimage.exposure.adjust_gamma()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.exposure.AdjustLogParam[source]#

Logarithmic adjustment parameters

gain#

Facteur de gain (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

inv#

Si vrai, appliquer une transformation logarithmique inverse. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(gain: float, inv: bool) → cdl.computation.image.exposure.AdjustLogParam#

Renvoie une nouvelle instance de AdjustLogParam avec les champs initialisés aux valeurs données.

Paramètres:

gain (float) – Facteur de gain (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 1.0.
inv (bool) – Si vrai, appliquer une transformation logarithmique inverse. Par défaut : False.

Renvoie:

Nouvelle instance de AdjustLogParam.

cdl.computation.image.exposure.compute_adjust_log(src: ImageObj, p: AdjustLogParam) → ImageObj[source]#

Compute log correction with skimage.exposure.adjust_log()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.exposure.AdjustSigmoidParam[source]#

Sigmoid adjustment parameters

cutoff#

Valeur de coupure (plus la valeur est élevée, plus le contraste est important). Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

gain#

Facteur de gain (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 10.0.

Type:: guidata.dataset.dataitems.FloatItem

inv#

Si vrai, appliquer une transformation sigmoïde inverse. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(cutoff: float, gain: float, inv: bool) → cdl.computation.image.exposure.AdjustSigmoidParam#

Renvoie une nouvelle instance de AdjustSigmoidParam avec les champs initialisés aux valeurs données.

Paramètres:

cutoff (float) – Valeur de coupure (plus la valeur est élevée, plus le contraste est important). Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.
gain (float) – Facteur de gain (plus la valeur est élevée, plus le contraste est important). Flottant supérieur à 0.0. Par défaut : 10.0.
inv (bool) – Si vrai, appliquer une transformation sigmoïde inverse. Par défaut : False.

Renvoie:

Nouvelle instance de AdjustSigmoidParam.

cdl.computation.image.exposure.compute_adjust_sigmoid(src: ImageObj, p: AdjustSigmoidParam) → ImageObj[source]#

Compute sigmoid correction with skimage.exposure.adjust_sigmoid()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.exposure.RescaleIntensityParam[source]#

Intensity rescaling parameters

in_range#

Echelle de niveaux en entrée. Valeurs min/max d’intensité de l’image en entrée (“image” correspond aux niveaux min/max de l’image en entrée, “dtype” correspond aux valeurs min/max du type de données de l’image). Sélection unique parmi : “image”, “dtype”, “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “image”.

Type:: guidata.dataset.dataitems.ChoiceItem

out_range#

Echelle de niveaux en sortie. Valeurs min/max d’intensité de l’image en sortie (“image” correspond aux niveaux min/max de l’image en entrée, “dtype” correspond aux valeurs min/max du type de données de l’image). Sélection unique parmi : “image”, “dtype”, “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “dtype”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(in_range: str, out_range: str) → cdl.computation.image.exposure.RescaleIntensityParam#

Renvoie une nouvelle instance de RescaleIntensityParam avec les champs initialisés aux valeurs données.

Paramètres:

in_range (str) – Echelle de niveaux en entrée. Valeurs min/max d’intensité de l’image en entrée (“image” correspond aux niveaux min/max de l’image en entrée, “dtype” correspond aux valeurs min/max du type de données de l’image). Sélection unique parmi : “image”, “dtype”, “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “image”.
out_range (str) – Echelle de niveaux en sortie. Valeurs min/max d’intensité de l’image en sortie (“image” correspond aux niveaux min/max de l’image en entrée, “dtype” correspond aux valeurs min/max du type de données de l’image). Sélection unique parmi : “image”, “dtype”, “float32”, “float64”, “complex128”, “uint8”, “int16”, “uint16”, “int32”. Par défaut : “dtype”.

Renvoie:

Nouvelle instance de RescaleIntensityParam.

cdl.computation.image.exposure.compute_rescale_intensity(src: ImageObj, p: RescaleIntensityParam) → ImageObj[source]#

Rescale image intensity levels with skimage.exposure.rescale_intensity()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.exposure.EqualizeHistParam[source]#

Histogram equalization parameters

nbins#

Nombre de classes. Nombre de classes de l’histogramme des niveaux de l’image. Entier supérieur à 1. Par défaut : 256.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(nbins: int) → cdl.computation.image.exposure.EqualizeHistParam#

Renvoie une nouvelle instance de EqualizeHistParam avec les champs initialisés aux valeurs données.

Paramètres:: nbins (int) – Nombre de classes. Nombre de classes de l’histogramme des niveaux de l’image. Entier supérieur à 1. Par défaut : 256.
Renvoie:: Nouvelle instance de EqualizeHistParam.

cdl.computation.image.exposure.compute_equalize_hist(src: ImageObj, p: EqualizeHistParam) → ImageObj[source]#

Histogram equalization with skimage.exposure.equalize_hist()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.exposure.EqualizeAdaptHistParam[source]#

Adaptive histogram equalization parameters

nbins#

Nombre de classes. Nombre de classes de l’histogramme des niveaux de l’image. Entier supérieur à 1. Par défaut : 256.

Type:: guidata.dataset.dataitems.IntItem

clip_limit#

Écrêtage limite. Valeur d’écrêtage (plus la valeur est élevée, plus le contraste est important). Flottant compris entre 0.0 et 1.0. Par défaut : 0.01.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(nbins: int, clip_limit: float) → cdl.computation.image.exposure.EqualizeAdaptHistParam#

Renvoie une nouvelle instance de EqualizeAdaptHistParam avec les champs initialisés aux valeurs données.

Paramètres:

nbins (int) – Nombre de classes. Nombre de classes de l’histogramme des niveaux de l’image. Entier supérieur à 1. Par défaut : 256.
clip_limit (float) – Écrêtage limite. Valeur d’écrêtage (plus la valeur est élevée, plus le contraste est important). Flottant compris entre 0.0 et 1.0. Par défaut : 0.01.

Renvoie:

Nouvelle instance de EqualizeAdaptHistParam.

cdl.computation.image.exposure.compute_equalize_adapthist(src: ImageObj, p: EqualizeAdaptHistParam) → ImageObj[source]#

Adaptive histogram equalization with skimage.exposure.equalize_adapthist()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

Restoration features#

Restoration computation module#

class cdl.computation.image.restoration.DenoiseTVParam[source]#

Total Variation denoising parameters

weight#

Poids de débruitage. Plus le poids est élevé, plus le débruitage est fort (aux dépens de la fidélité des données). Flottant supérieur à 0, non nul. Par défaut : 0.1.

Type:: guidata.dataset.dataitems.FloatItem

eps#

Epsilon. Différence relative de la valeur de la fonction de coût qui détermine le critère d’arrêt de l’algorithme. Ce dernier s’arrête lorsque : (e_(n-1) - e_n) < eps * e_0. Flottant supérieur à 0, non nul. Par défaut : 0.0002.

Type:: guidata.dataset.dataitems.FloatItem

max_num_iter#

Nb. max. d’itérations. Nombre maximal d’itérations utilisé pour l’optimisation. Entier supérieur à 0, non nul. Par défaut : 200.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(weight: float, eps: float, max_num_iter: int) → cdl.computation.image.restoration.DenoiseTVParam#

Renvoie une nouvelle instance de DenoiseTVParam avec les champs initialisés aux valeurs données.

Paramètres:

weight (float) – Poids de débruitage. Plus le poids est élevé, plus le débruitage est fort (aux dépens de la fidélité des données). Flottant supérieur à 0, non nul. Par défaut : 0.1.
eps (float) – Epsilon. Différence relative de la valeur de la fonction de coût qui détermine le critère d’arrêt de l’algorithme. Ce dernier s’arrête lorsque : (e_(n-1) - e_n) < eps * e_0. Flottant supérieur à 0, non nul. Par défaut : 0.0002.
max_num_iter (int) – Nb. max. d’itérations. Nombre maximal d’itérations utilisé pour l’optimisation. Entier supérieur à 0, non nul. Par défaut : 200.

Renvoie:

Nouvelle instance de DenoiseTVParam.

cdl.computation.image.restoration.compute_denoise_tv(src: ImageObj, p: DenoiseTVParam) → ImageObj[source]#

Compute Total Variation denoising with skimage.restoration.denoise_tv_chambolle()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.restoration.DenoiseBilateralParam[source]#

Bilateral filter denoising parameters

sigma_spatial#

σ_spatial. Ecart-type dans le domaine spatial. Une valeur élevée a pour effet de moyenner des pixels séparés par de grandes distances. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

mode#

Sélection unique parmi : “constant”, “edge”, “symmetric”, “reflect”, “wrap”. Par défaut : “constant”.

Type:: guidata.dataset.dataitems.ChoiceItem

cval#

Valeur de remplissage en dehors des bornes de l’image (en mode constant). Par défaut : 0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(sigma_spatial: float, mode: str, cval: float) → cdl.computation.image.restoration.DenoiseBilateralParam#

Renvoie une nouvelle instance de DenoiseBilateralParam avec les champs initialisés aux valeurs données.

Paramètres:

sigma_spatial (float) – σ_spatial. Ecart-type dans le domaine spatial. Une valeur élevée a pour effet de moyenner des pixels séparés par de grandes distances. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.
mode (str) – Sélection unique parmi : “constant”, “edge”, “symmetric”, “reflect”, “wrap”. Par défaut : “constant”.
cval (float) – Valeur de remplissage en dehors des bornes de l’image (en mode constant). Par défaut : 0.

Renvoie:

Nouvelle instance de DenoiseBilateralParam.

cdl.computation.image.restoration.compute_denoise_bilateral(src: ImageObj, p: DenoiseBilateralParam) → ImageObj[source]#

Compute bilateral filter denoising with skimage.restoration.denoise_bilateral()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

class cdl.computation.image.restoration.DenoiseWaveletParam[source]#

Wavelet denoising parameters

wavelet#

Ondelette. Sélection unique parmi : “bior1.1”, “bior1.3”, “bior1.5”, “bior2.2”, “bior2.4”, “bior2.6”, “bior2.8”, “bior3.1”, “bior3.3”, “bior3.5”, “bior3.7”, “bior3.9”, “bior4.4”, “bior5.5”, “bior6.8”, “cgau1”, “cgau2”, “cgau3”, “cgau4”, “cgau5”, “cgau6”, “cgau7”, “cgau8”, “cmor”, “coif1”, “coif2”, “coif3”, “coif4”, “coif5”, “coif6”, “coif7”, “coif8”, “coif9”, “coif10”, “coif11”, “coif12”, “coif13”, “coif14”, “coif15”, “coif16”, “coif17”, “db1”, “db2”, “db3”, “db4”, “db5”, “db6”, “db7”, “db8”, “db9”, “db10”, “db11”, “db12”, “db13”, “db14”, “db15”, “db16”, “db17”, “db18”, “db19”, “db20”, “db21”, “db22”, “db23”, “db24”, “db25”, “db26”, “db27”, “db28”, “db29”, “db30”, “db31”, “db32”, “db33”, “db34”, “db35”, “db36”, “db37”, “db38”, “dmey”, “fbsp”, “gaus1”, “gaus2”, “gaus3”, “gaus4”, “gaus5”, “gaus6”, “gaus7”, “gaus8”, “haar”, “mexh”, “morl”, “rbio1.1”, “rbio1.3”, “rbio1.5”, “rbio2.2”, “rbio2.4”, “rbio2.6”, “rbio2.8”, “rbio3.1”, “rbio3.3”, “rbio3.5”, “rbio3.7”, “rbio3.9”, “rbio4.4”, “rbio5.5”, “rbio6.8”, “shan”, “sym2”, “sym3”, “sym4”, “sym5”, “sym6”, “sym7”, “sym8”, “sym9”, “sym10”, “sym11”, “sym12”, “sym13”, “sym14”, “sym15”, “sym16”, “sym17”, “sym18”, “sym19”, “sym20”. Par défaut : “sym9”.

Type:: guidata.dataset.dataitems.ChoiceItem

mode#

Sélection unique parmi : “soft”, “hard”. Par défaut : “soft”.

Type:: guidata.dataset.dataitems.ChoiceItem

method#

Méthode. Sélection unique parmi : “BayesShrink”, “VisuShrink”. Par défaut : “VisuShrink”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(wavelet: str, mode: str, method: str) → cdl.computation.image.restoration.DenoiseWaveletParam#

Renvoie une nouvelle instance de DenoiseWaveletParam avec les champs initialisés aux valeurs données.

Paramètres:

wavelet (str) – Ondelette. Sélection unique parmi : “bior1.1”, “bior1.3”, “bior1.5”, “bior2.2”, “bior2.4”, “bior2.6”, “bior2.8”, “bior3.1”, “bior3.3”, “bior3.5”, “bior3.7”, “bior3.9”, “bior4.4”, “bior5.5”, “bior6.8”, “cgau1”, “cgau2”, “cgau3”, “cgau4”, “cgau5”, “cgau6”, “cgau7”, “cgau8”, “cmor”, “coif1”, “coif2”, “coif3”, “coif4”, “coif5”, “coif6”, “coif7”, “coif8”, “coif9”, “coif10”, “coif11”, “coif12”, “coif13”, “coif14”, “coif15”, “coif16”, “coif17”, “db1”, “db2”, “db3”, “db4”, “db5”, “db6”, “db7”, “db8”, “db9”, “db10”, “db11”, “db12”, “db13”, “db14”, “db15”, “db16”, “db17”, “db18”, “db19”, “db20”, “db21”, “db22”, “db23”, “db24”, “db25”, “db26”, “db27”, “db28”, “db29”, “db30”, “db31”, “db32”, “db33”, “db34”, “db35”, “db36”, “db37”, “db38”, “dmey”, “fbsp”, “gaus1”, “gaus2”, “gaus3”, “gaus4”, “gaus5”, “gaus6”, “gaus7”, “gaus8”, “haar”, “mexh”, “morl”, “rbio1.1”, “rbio1.3”, “rbio1.5”, “rbio2.2”, “rbio2.4”, “rbio2.6”, “rbio2.8”, “rbio3.1”, “rbio3.3”, “rbio3.5”, “rbio3.7”, “rbio3.9”, “rbio4.4”, “rbio5.5”, “rbio6.8”, “shan”, “sym2”, “sym3”, “sym4”, “sym5”, “sym6”, “sym7”, “sym8”, “sym9”, “sym10”, “sym11”, “sym12”, “sym13”, “sym14”, “sym15”, “sym16”, “sym17”, “sym18”, “sym19”, “sym20”. Par défaut : “sym9”.
mode (str) – Sélection unique parmi : “soft”, “hard”. Par défaut : “soft”.
method (str) – Méthode. Sélection unique parmi : “BayesShrink”, “VisuShrink”. Par défaut : “VisuShrink”.

Renvoie:

Nouvelle instance de DenoiseWaveletParam.

cdl.computation.image.restoration.compute_denoise_wavelet(src: ImageObj, p: DenoiseWaveletParam) → ImageObj[source]#

Compute Wavelet denoising with skimage.restoration.denoise_wavelet()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.restoration.compute_denoise_tophat(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Denoise using White Top-Hat with skimage.morphology.white_tophat()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

Morphological features#

Morphology computation module#

class cdl.computation.image.morphology.MorphologyParam[source]#

White Top-Hat parameters

radius#

Rayon. Rayon de l’ouverture circulaire (disque). Entier supérieur à 1. Par défaut : 1.

Type:: guidata.dataset.dataitems.IntItem

classmethod create(radius: int) → cdl.computation.image.morphology.MorphologyParam#

Renvoie une nouvelle instance de MorphologyParam avec les champs initialisés aux valeurs données.

Paramètres:: radius (int) – Rayon. Rayon de l’ouverture circulaire (disque). Entier supérieur à 1. Par défaut : 1.
Renvoie:: Nouvelle instance de MorphologyParam.

cdl.computation.image.morphology.compute_white_tophat(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Compute White Top-Hat with skimage.morphology.white_tophat()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.morphology.compute_black_tophat(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Compute Black Top-Hat with skimage.morphology.black_tophat()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.morphology.compute_erosion(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Compute Erosion with skimage.morphology.erosion()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.morphology.compute_dilation(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Compute Dilation with skimage.morphology.dilation()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.morphology.compute_opening(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Compute morphological opening with skimage.morphology.opening()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.morphology.compute_closing(src: ImageObj, p: MorphologyParam) → ImageObj[source]#

Compute morphological closing with skimage.morphology.closing()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

Edge detection features#

Edges computation module#

class cdl.computation.image.edges.CannyParam[source]#

Canny filter parameters

sigma#

Ecart-type du filtrage gaussien. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

low_threshold#

Seuil bas. Borne inférieure pour le seuillage par hystérésis (liaison des contours). Flottant supérieur à 0. Par défaut : 0.1.

Type:: guidata.dataset.dataitems.FloatItem

high_threshold#

Seuil haut. Borne supérieure pour le seuillage par hystérésis (liaison des contours). Flottant supérieur à 0. Par défaut : 0.9.

Type:: guidata.dataset.dataitems.FloatItem

use_quantiles#

Interprète les seuils bas et haut en tant que quantiles des niveaux des contours, au lieu de valeurs absolues des contours. Si le réglage est actif, alors les seuils doivent être compris entre 0 et 1. Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

mode#

Sélection unique parmi : “reflect”, “constant”, “nearest”, “mirror”, “wrap”. Par défaut : “constant”.

Type:: guidata.dataset.dataitems.ChoiceItem

cval#

Valeur de remplissage si le mode est constant. Par défaut : 0.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(sigma: float, low_threshold: float, high_threshold: float, use_quantiles: bool, mode: str, cval: float) → cdl.computation.image.edges.CannyParam#

Renvoie une nouvelle instance de CannyParam avec les champs initialisés aux valeurs données.

Paramètres:

sigma (float) – Ecart-type du filtrage gaussien. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.
low_threshold (float) – Seuil bas. Borne inférieure pour le seuillage par hystérésis (liaison des contours). Flottant supérieur à 0. Par défaut : 0.1.
high_threshold (float) – Seuil haut. Borne supérieure pour le seuillage par hystérésis (liaison des contours). Flottant supérieur à 0. Par défaut : 0.9.
use_quantiles (bool) – Interprète les seuils bas et haut en tant que quantiles des niveaux des contours, au lieu de valeurs absolues des contours. Si le réglage est actif, alors les seuils doivent être compris entre 0 et 1. Par défaut : True.
mode (str) – Sélection unique parmi : “reflect”, “constant”, “nearest”, “mirror”, “wrap”. Par défaut : “constant”.
cval (float) – Valeur de remplissage si le mode est constant. Par défaut : 0.0.

Renvoie:

Nouvelle instance de CannyParam.

cdl.computation.image.edges.compute_canny(src: ImageObj, p: CannyParam) → ImageObj[source]#

Compute Canny filter with skimage.feature.canny()

Paramètres:

src – input image object
p – parameters

Renvoie:

Output image object

cdl.computation.image.edges.compute_roberts(src: ImageObj) → ImageObj[source]#

Compute Roberts filter with skimage.filters.roberts()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_prewitt(src: ImageObj) → ImageObj[source]#

Compute Prewitt filter with skimage.filters.prewitt()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_prewitt_h(src: ImageObj) → ImageObj[source]#

Compute horizontal Prewitt filter with skimage.filters.prewitt_h()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_prewitt_v(src: ImageObj) → ImageObj[source]#

Compute vertical Prewitt filter with skimage.filters.prewitt_v()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_sobel(src: ImageObj) → ImageObj[source]#

Compute Sobel filter with skimage.filters.sobel()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_sobel_h(src: ImageObj) → ImageObj[source]#

Compute horizontal Sobel filter with skimage.filters.sobel_h()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_sobel_v(src: ImageObj) → ImageObj[source]#

Compute vertical Sobel filter with skimage.filters.sobel_v()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_scharr(src: ImageObj) → ImageObj[source]#

Compute Scharr filter with skimage.filters.scharr()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_scharr_h(src: ImageObj) → ImageObj[source]#

Compute horizontal Scharr filter with skimage.filters.scharr_h()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_scharr_v(src: ImageObj) → ImageObj[source]#

Compute vertical Scharr filter with skimage.filters.scharr_v()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_farid(src: ImageObj) → ImageObj[source]#

Compute Farid filter with skimage.filters.farid()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_farid_h(src: ImageObj) → ImageObj[source]#

Compute horizontal Farid filter with skimage.filters.farid_h()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_farid_v(src: ImageObj) → ImageObj[source]#

Compute vertical Farid filter with skimage.filters.farid_v()

Paramètres:: src – input image object
Renvoie:: Output image object

cdl.computation.image.edges.compute_laplace(src: ImageObj) → ImageObj[source]#

Compute Laplace filter with skimage.filters.laplace()

Paramètres:: src – input image object
Renvoie:: Output image object

Detection features#

Blob detection computation module#

class cdl.computation.image.detection.GenericDetectionParam[source]#

Generic detection parameters

threshold#

Seuil relatif. Seuil de détection, relatif à la différence entre le maximum et le minimum des données de l’image. Flottant compris entre 0.1 et 0.9. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(threshold: float) → cdl.computation.image.detection.GenericDetectionParam#

Renvoie une nouvelle instance de GenericDetectionParam avec les champs initialisés aux valeurs données.

Paramètres:: threshold (float) – Seuil relatif. Seuil de détection, relatif à la différence entre le maximum et le minimum des données de l’image. Flottant compris entre 0.1 et 0.9. Par défaut : 0.5.
Renvoie:: Nouvelle instance de GenericDetectionParam.

class cdl.computation.image.detection.Peak2DDetectionParam[source]#

Peak detection parameters

threshold#

Seuil relatif. Seuil de détection, relatif à la différence entre le maximum et le minimum des données de l’image. Flottant compris entre 0.1 et 0.9. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

size#

Taille du voisinage. Taille de la fenêtre glissante utilisée dans l’algorithme de filtrage maximum/minimum. Entier supérieur à 1, unité : pixels. Par défaut : 10.

Type:: guidata.dataset.dataitems.IntItem

create_rois#

Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(threshold: float, size: int, create_rois: bool) → cdl.computation.image.detection.Peak2DDetectionParam#

Renvoie une nouvelle instance de Peak2DDetectionParam avec les champs initialisés aux valeurs données.

Paramètres:

threshold (float) – Seuil relatif. Seuil de détection, relatif à la différence entre le maximum et le minimum des données de l’image. Flottant compris entre 0.1 et 0.9. Par défaut : 0.5.
size (int) – Taille du voisinage. Taille de la fenêtre glissante utilisée dans l’algorithme de filtrage maximum/minimum. Entier supérieur à 1, unité : pixels. Par défaut : 10.
create_rois (bool) – Par défaut : True.

Renvoie:

Nouvelle instance de Peak2DDetectionParam.

cdl.computation.image.detection.compute_peak_detection(image: ImageObj, p: Peak2DDetectionParam) → ResultShape | None[source]#

Compute 2D peak detection with cdl.algorithms.image.get_2d_peaks_coords()

Paramètres:

imageOutput – input image
p – parameters

Renvoie:

Peak coordinates

class cdl.computation.image.detection.ContourShapeParam[source]#

Contour shape parameters

threshold#

Seuil relatif. Seuil de détection, relatif à la différence entre le maximum et le minimum des données de l’image. Flottant compris entre 0.1 et 0.9. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

shape#

Forme. Sélection unique parmi : “ellipse”, “circle”, “polygon”. Par défaut : “ellipse”.

Type:: guidata.dataset.dataitems.ChoiceItem

classmethod create(threshold: float, shape: str) → cdl.computation.image.detection.ContourShapeParam#

Renvoie une nouvelle instance de ContourShapeParam avec les champs initialisés aux valeurs données.

Paramètres:

threshold (float) – Seuil relatif. Seuil de détection, relatif à la différence entre le maximum et le minimum des données de l’image. Flottant compris entre 0.1 et 0.9. Par défaut : 0.5.
shape (str) – Forme. Sélection unique parmi : “ellipse”, “circle”, “polygon”. Par défaut : “ellipse”.

Renvoie:

Nouvelle instance de ContourShapeParam.

cdl.computation.image.detection.compute_contour_shape(image: ImageObj, p: ContourShapeParam) → ResultShape | None[source]#: Compute contour shape fit with cdl.algorithms.image.get_contour_shapes()

class cdl.computation.image.detection.BaseBlobParam[source]#

Base class for blob detection parameters

min_sigma#

σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

max_sigma#

σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.

Type:: guidata.dataset.dataitems.FloatItem

threshold_rel#

Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.

Type:: guidata.dataset.dataitems.FloatItem

overlap#

Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(min_sigma: float, max_sigma: float, threshold_rel: float, overlap: float) → cdl.computation.image.detection.BaseBlobParam#

Renvoie une nouvelle instance de BaseBlobParam avec les champs initialisés aux valeurs données.

Paramètres:

min_sigma (float) – σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.
max_sigma (float) – σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.
threshold_rel (float) – Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.
overlap (float) – Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.

Renvoie:

Nouvelle instance de BaseBlobParam.

class cdl.computation.image.detection.BlobDOGParam[source]#

Blob detection using Difference of Gaussian method

min_sigma#

σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

max_sigma#

σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.

Type:: guidata.dataset.dataitems.FloatItem

threshold_rel#

Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.

Type:: guidata.dataset.dataitems.FloatItem

overlap#

Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

exclude_border#

Si le réglage est actif, exclure les taches de la bordure de l’image. Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(min_sigma: float, max_sigma: float, threshold_rel: float, overlap: float, exclude_border: bool) → cdl.computation.image.detection.BlobDOGParam#

Renvoie une nouvelle instance de BlobDOGParam avec les champs initialisés aux valeurs données.

Paramètres:

min_sigma (float) – σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.
max_sigma (float) – σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.
threshold_rel (float) – Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.
overlap (float) – Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.
exclude_border (bool) – Si le réglage est actif, exclure les taches de la bordure de l’image. Par défaut : True.

Renvoie:

Nouvelle instance de BlobDOGParam.

cdl.computation.image.detection.compute_blob_dog(image: ImageObj, p: BlobDOGParam) → ResultShape | None[source]#

Compute blobs using Difference of Gaussian method with cdl.algorithms.image.find_blobs_dog()

Paramètres:

imageOutput – input image
p – parameters

Renvoie:

Blobs coordinates

class cdl.computation.image.detection.BlobDOHParam[source]#

Blob detection using Determinant of Hessian method

min_sigma#

σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

max_sigma#

σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.

Type:: guidata.dataset.dataitems.FloatItem

threshold_rel#

Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.

Type:: guidata.dataset.dataitems.FloatItem

overlap#

Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

log_scale#

Les valeurs intermédiaires d’écart-type peuvent être interpolées selon une échelle linéaire ou logarithmique. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(min_sigma: float, max_sigma: float, threshold_rel: float, overlap: float, log_scale: bool) → cdl.computation.image.detection.BlobDOHParam#

Renvoie une nouvelle instance de BlobDOHParam avec les champs initialisés aux valeurs données.

Paramètres:

min_sigma (float) – σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.
max_sigma (float) – σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.
threshold_rel (float) – Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.
overlap (float) – Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.
log_scale (bool) – Les valeurs intermédiaires d’écart-type peuvent être interpolées selon une échelle linéaire ou logarithmique. Par défaut : False.

Renvoie:

Nouvelle instance de BlobDOHParam.

cdl.computation.image.detection.compute_blob_doh(image: ImageObj, p: BlobDOHParam) → ResultShape | None[source]#

Compute blobs using Determinant of Hessian method with cdl.algorithms.image.find_blobs_doh()

Paramètres:

imageOutput – input image
p – parameters

Renvoie:

Blobs coordinates

class cdl.computation.image.detection.BlobLOGParam[source]#

Blob detection using Laplacian of Gaussian method

min_sigma#

σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

max_sigma#

σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.

Type:: guidata.dataset.dataitems.FloatItem

threshold_rel#

Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.

Type:: guidata.dataset.dataitems.FloatItem

overlap#

Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.

Type:: guidata.dataset.dataitems.FloatItem

log_scale#

Les valeurs intermédiaires d’écart-type peuvent être interpolées selon une échelle linéaire ou logarithmique. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

exclude_border#

Si le réglage est actif, exclure les taches de la bordure de l’image. Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

classmethod create(min_sigma: float, max_sigma: float, threshold_rel: float, overlap: float, log_scale: bool, exclude_border: bool) → cdl.computation.image.detection.BlobLOGParam#

Renvoie une nouvelle instance de BlobLOGParam avec les champs initialisés aux valeurs données.

Paramètres:

min_sigma (float) – σ_min. L’écart-type minimal pour le noyau gaussien. Cette valeur doit être faible pour détecter de petites taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 1.0.
max_sigma (float) – σ_max. L’écart-type maximal pour le noyau gaussien. Cette valeur doit être élevée pour détecter de grandes taches. Flottant supérieur à 0, non nul, unité : pixels. Par défaut : 30.0.
threshold_rel (float) – Seuil relatif. Intensité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.2.
overlap (float) – Recouvrement. Si deux taches ont un taux de recouvrement supérieur à ce seuil, alors la plus petite tache est éliminée. Flottant compris entre 0.0 et 1.0. Par défaut : 0.5.
log_scale (bool) – Les valeurs intermédiaires d’écart-type peuvent être interpolées selon une échelle linéaire ou logarithmique. Par défaut : False.
exclude_border (bool) – Si le réglage est actif, exclure les taches de la bordure de l’image. Par défaut : True.

Renvoie:

Nouvelle instance de BlobLOGParam.

cdl.computation.image.detection.compute_blob_log(image: ImageObj, p: BlobLOGParam) → ResultShape | None[source]#

Compute blobs using Laplacian of Gaussian method with cdl.algorithms.image.find_blobs_log()

Paramètres:

imageOutput – input image
p – parameters

Renvoie:

Blobs coordinates

class cdl.computation.image.detection.BlobOpenCVParam[source]#

Blob detection using OpenCV

min_threshold#

Seuil min. Le seuil minimum entre les maxima et minima locaux. Ce paramètre n’affecte pas la qualité des taches, mais seulement leur nombre. Un seuil bas donne un nombre plus important de taches. Flottant supérieur à 0.0. Par défaut : 10.0.

Type:: guidata.dataset.dataitems.FloatItem

max_threshold#

Seuil max. Le seuil maximum entre les maxima et minima locaux. Ce paramètre n’affecte pas la qualité des taches, mais seulement leur nombre. Un seuil bas donne un nombre plus important de taches. Flottant supérieur à 0.0. Par défaut : 200.0.

Type:: guidata.dataset.dataitems.FloatItem

min_repeatability#

Répétabilité min. Le nombre minimum de fois qu’une tache doit être détectée dans une séquence d’images pour être considérée valide. Entier supérieur à 1. Par défaut : 2.

Type:: guidata.dataset.dataitems.IntItem

min_dist_between_blobs#

Distance min. entre taches. La distance minimale entre deux taches. Si deux taches sont détectées à une distance inférieure à celle-ci, alors la plus petite tache est éliminée. Flottant supérieur à 0.0, non nul. Par défaut : 10.0.

Type:: guidata.dataset.dataitems.FloatItem

filter_by_color#

Si vrai, l’image est filtrée par couleur au lieu d’intensité. Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

blob_color#

Couleur de la tache. La couleur des taches à détecter (0 pour les taches foncées, 255 pour les taches claires). Par défaut : 0.

Type:: guidata.dataset.dataitems.IntItem

filter_by_area#

Si vrai, l’image est filtrée par l’aire des taches. Par défaut : True.

Type:: guidata.dataset.dataitems.BoolItem

min_area#

Aire min. L’aire minimale des taches. Flottant supérieur à 0.0. Par défaut : 25.0.

Type:: guidata.dataset.dataitems.FloatItem

max_area#

Aire max. L’aire maximale des taches. Flottant supérieur à 0.0. Par défaut : 500.0.

Type:: guidata.dataset.dataitems.FloatItem

filter_by_circularity#

Si vrai, l’image est filtrée par la circularité des taches. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

min_circularity#

Circularité min. La circularité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.8.

Type:: guidata.dataset.dataitems.FloatItem

max_circularity#

Circularité max. La circularité maximale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

filter_by_inertia#

Si vrai, l’image est filtrée par l’inertie des taches. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

min_inertia_ratio#

Ratio d’inertie min. Le ratio d’inertie minimal des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.6.

Type:: guidata.dataset.dataitems.FloatItem

max_inertia_ratio#

Ratio d’inertie max. Le ratio d’inertie maximal des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

filter_by_convexity#

Si vrai, l’image est filtrée par la convexité des taches. Par défaut : False.

Type:: guidata.dataset.dataitems.BoolItem

min_convexity#

Convexité min. La convexité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.8.

Type:: guidata.dataset.dataitems.FloatItem

max_convexity#

Convexité max. La convexité maximale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 1.0.

Type:: guidata.dataset.dataitems.FloatItem

classmethod create(min_threshold: float, max_threshold: float, min_repeatability: int, min_dist_between_blobs: float, filter_by_color: bool, blob_color: int, filter_by_area: bool, min_area: float, max_area: float, filter_by_circularity: bool, min_circularity: float, max_circularity: float, filter_by_inertia: bool, min_inertia_ratio: float, max_inertia_ratio: float, filter_by_convexity: bool, min_convexity: float, max_convexity: float) → cdl.computation.image.detection.BlobOpenCVParam#

Renvoie une nouvelle instance de BlobOpenCVParam avec les champs initialisés aux valeurs données.

Paramètres:

min_threshold (float) – Seuil min. Le seuil minimum entre les maxima et minima locaux. Ce paramètre n’affecte pas la qualité des taches, mais seulement leur nombre. Un seuil bas donne un nombre plus important de taches. Flottant supérieur à 0.0. Par défaut : 10.0.
max_threshold (float) – Seuil max. Le seuil maximum entre les maxima et minima locaux. Ce paramètre n’affecte pas la qualité des taches, mais seulement leur nombre. Un seuil bas donne un nombre plus important de taches. Flottant supérieur à 0.0. Par défaut : 200.0.
min_repeatability (int) – Répétabilité min. Le nombre minimum de fois qu’une tache doit être détectée dans une séquence d’images pour être considérée valide. Entier supérieur à 1. Par défaut : 2.
min_dist_between_blobs (float) – Distance min. entre taches. La distance minimale entre deux taches. Si deux taches sont détectées à une distance inférieure à celle-ci, alors la plus petite tache est éliminée. Flottant supérieur à 0.0, non nul. Par défaut : 10.0.
filter_by_color (bool) – Si vrai, l’image est filtrée par couleur au lieu d’intensité. Par défaut : True.
blob_color (int) – Couleur de la tache. La couleur des taches à détecter (0 pour les taches foncées, 255 pour les taches claires). Par défaut : 0.
filter_by_area (bool) – Si vrai, l’image est filtrée par l’aire des taches. Par défaut : True.
min_area (float) – Aire min. L’aire minimale des taches. Flottant supérieur à 0.0. Par défaut : 25.0.
max_area (float) – Aire max. L’aire maximale des taches. Flottant supérieur à 0.0. Par défaut : 500.0.
filter_by_circularity (bool) – Si vrai, l’image est filtrée par la circularité des taches. Par défaut : False.
min_circularity (float) – Circularité min. La circularité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.8.
max_circularity (float) – Circularité max. La circularité maximale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 1.0.
filter_by_inertia (bool) – Si vrai, l’image est filtrée par l’inertie des taches. Par défaut : False.
min_inertia_ratio (float) – Ratio d’inertie min. Le ratio d’inertie minimal des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.6.
max_inertia_ratio (float) – Ratio d’inertie max. Le ratio d’inertie maximal des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 1.0.
filter_by_convexity (bool) – Si vrai, l’image est filtrée par la convexité des taches. Par défaut : False.
min_convexity (float) – Convexité min. La convexité minimale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 0.8.
max_convexity (float) – Convexité max. La convexité maximale des taches. Flottant compris entre 0.0 et 1.0. Par défaut : 1.0.

Renvoie:

Nouvelle instance de BlobOpenCVParam.

cdl.computation.image.detection.compute_blob_opencv(image: ImageObj, p: BlobOpenCVParam) → ResultShape | None[source]#

Compute blobs using OpenCV with cdl.algorithms.image.find_blobs_opencv()

Paramètres:

imageOutput – input image
p – parameters

Renvoie:

Blobs coordinates

Computation (cdl.computation)#

Common processing features#

Signal processing features#

Image processing features#

Base image processing features#

Threshold features#

Threshold computation module#

Exposure correction features#

Exposure computation module#

Restoration features#

Restoration computation module#

Morphological features#

Morphology computation module#

Edge detection features#

Edges computation module#

Detection features#

Blob detection computation module#

Computation (`cdl.computation`)#