Processeur#

Le paquet cdl.core.gui.processor fournit les objets processeur pour les signaux et les images.

Les objets processeur sont le pont entre les modules de calcul (dans cdl.computation) et les modules GUI (dans cdl.core.gui). Ils sont utilisés pour appeler les fonctions de calcul et pour mettre à jour l’interface utilisateur depuis l’intérieur des objets de panneau de données.

Lors de la mise en œuvre d’une fonction de traitement dans DataLab, les étapes sont généralement les suivantes :

Ajout d’une action dans le module cdl.core.gui.actionhandler pour déclencher la fonction de traitement depuis l’interface utilisateur (par exemple, un élément de menu ou un bouton de barre d’outils).
Implémentation de la fonction de calcul dans le module cdl.computation (qui appellerait éventuellement l’algorithme du module cdl.algorithms).
Implémentation de la méthode de l’objet processeur dans ce paquet pour appeler la fonction de calcul et éventuellement mettre à jour l’interface utilisateur.

Les objets processeur sont organisés en sous-modules en fonction de leur objectif.

Les sous-modules suivants sont disponibles :

cdl.core.gui.processor.base: Fonctions de traitement communes
cdl.core.gui.processor.signal: Fonctions de traitement de signaux
cdl.core.gui.processor.image: Fonctions de traitement d’images

Fonctions communes#

class cdl.core.gui.processor.base.Worker[source]#

Travailleur de traitement parallèle, pour exécuter des tâches de longue durée dans un processus séparé

static create_pool() → None[source]#: Créer un pool de traitement parallèle

static terminate_pool(wait: bool = False) → None[source]#

Terminer le pool de traitement parallèle.

Paramètres:: wait – wait for all tasks to finish. Defaults to False.

restart_pool() → None[source]#: Terminate and recreate the pool

run(func: Callable, args: tuple[Any]) → None[source]#

Run computation.

Paramètres:

func – function to run
args – arguments

close() → None[source]#: Close worker: close pool properly and wait for all tasks to finish

is_computation_finished() → bool[source]#

Return True if computation is finished.

Renvoie:: True if computation is finished
Type renvoyé:: bool

get_result() → CompOut[source]#

Return computation result.

Renvoie:: computation result
Type renvoyé:: CompOut

cdl.core.gui.processor.base.is_pairwise_mode() → bool[source]#

Return True if operation mode is pairwise.

Renvoie:: True if operation mode is pairwise
Type renvoyé:: bool

class cdl.core.gui.processor.base.BaseProcessor(panel: SignalPanel | ImagePanel, plotwidget: PlotWidget)[source]#

Object handling data processing: operations, processing, analysis.

Paramètres:

panel – panel
plotwidget – plot widget

close()[source]#: Close processor properly

set_process_isolation_enabled(enabled: bool) → None[source]#

Set process isolation enabled.

Paramètres:: enabled – enabled

has_param_defaults(paramclass: type[DataSet]) → bool[source]#

Return True if parameter defaults are available.

Paramètres:: paramclass – parameter class
Renvoie:: True if parameter defaults are available
Type renvoyé:: bool

update_param_defaults(param: DataSet) → None[source]#

Update parameter defaults.

Paramètres:: param – parameters

init_param(param: DataSet, paramclass: type[DataSet], title: str, comment: str | None = None) → tuple[bool, DataSet][source]#

Initialize processing parameters.

Paramètres:

param – parameter
paramclass – parameter class
title – title
comment – comment

Renvoie:

Tuple (edit, param) where edit is True if parameters have been edited, False otherwise.

Compute 11 function: 1 object in → 1 object out.

Paramètres:

func – function
param – parameter
paramclass – parameter class
title – title
comment – comment
edit – edit parameters

compute_1n(funcs: list[Callable] | Callable, params: list | None = None, title: str | None = None, edit: bool | None = None) → None[source]#

Compute 1n function: 1 object in → n objects out.

Paramètres:

funcs – list of functions
params – list of parameters
title – title
edit – edit parameters

handle_output(compout: CompOut, context: str, progress: QW.QProgressDialog) → SignalObj | ImageObj | ResultShape | ResultProperties | None[source]#

Handle computation output: if error, display error message, if warning, display warning message.

Paramètres:

compout – computation output
context – context (e.g. « Computing: Gaussian filter »)
progress – progress dialog

Renvoie:

a signal or image object, or a result shape object,: or None if error

Type renvoyé:

Output object

Compute 10 function: 1 object in → 0 object out (the result of this method is stored in original object’s metadata).

Paramètres:

func – function to execute
param – parameters. Defaults to None.
paramclass – parameters class. Defaults to None.
title – title of progress bar. Defaults to None.
comment – comment. Defaults to None.
edit – if True, edit parameters. Defaults to None.

Renvoie:

object uuid, values: ResultShape or: ResultProperties objects)

Type renvoyé:

Dictionary of results (keys

Compute n1 function: N(>=2) objects in → 1 object out.

Paramètres:

name – name of function
func – function to execute
param – parameters. Defaults to None.
paramclass – parameters class. Defaults to None.
title – title of progress bar. Defaults to None.
comment – comment. Defaults to None.
func_objs – function to execute on objects. Defaults to None.
edit – if True, edit parameters. Defaults to None.

Compute n1n function: N(>=1) objects + 1 object in → N objects out.

Examples: subtract, divide

Paramètres:

obj2 – second object (or list of objects in case of pairwise operation mode)
obj2_name – name of second object
func – function to execute
param – parameters. Defaults to None.
paramclass – parameters class. Defaults to None.
title – title of progress bar. Defaults to None.
comment – comment. Defaults to None.
edit – if True, edit parameters. Defaults to None.

abstract compute_arithmetic(obj2: Obj | None = None, param: ArithmeticParam | None = None) → None[source]#: Compute arithmetic operation

abstract compute_sum() → None[source]#: Compute sum

abstract compute_normalize(param: NormalizeParam | None = None) → None[source]#: Normalize data

abstract compute_average() → None[source]#: Compute average

abstract compute_product() → None[source]#: Compute product

abstract compute_difference(obj2: Obj | list[Obj] | None = None) → None[source]#: Compute difference

abstract compute_quadratic_difference(obj2: Obj | list[Obj] | None = None) → None[source]#: Compute quadratic difference

abstract compute_division(obj2: Obj | list[Obj] | None = None) → None[source]#: Compute division

abstract compute_swap_axes() → None[source]#: Swap data axes

abstract compute_inverse() → None[source]#: Compute inverse

abstract compute_abs() → None[source]#: Compute absolute value

abstract compute_re() → None[source]#: Compute real part

abstract compute_im() → None[source]#: Compute imaginary part

abstract compute_astype() → None[source]#: Convert data type

abstract compute_log10() → None[source]#: Compute Log10

abstract compute_exp() → None[source]#: Compute exponential

abstract compute_calibration(param=None) → None[source]#: Compute data linear calibration

abstract compute_clip(param: ClipParam | None = None) → None[source]#: Compute maximum data clipping

abstract compute_gaussian_filter(param: GaussianParam | None = None) → None[source]#: Compute gaussian filter

abstract compute_moving_average(param: MovingAverageParam | None = None) → None[source]#: Compute moving average

abstract compute_moving_median(param: MovingMedianParam | None = None) → None[source]#: Compute moving median

abstract compute_wiener() → None[source]#: Compute Wiener filter

abstract compute_fft() → None[source]#: Compute iFFT

abstract compute_ifft() → None[source]#: Compute FFT

abstract compute_addition_constant(param: ConstantParam) → None[source]#: Compute sum with a constant

abstract compute_difference_constant(param: ConstantParam) → None[source]#: Compute difference with a constant

abstract compute_product_constant(param: ConstantParam) → None[source]#: Compute product with a constant

abstract compute_division_constant(param: ConstantParam) → None[source]#: Compute division by a constant

compute_roi_extraction(roi: TypeROI | None = None) → None[source]#

Extract Region Of Interest (ROI) from data with:

cdl.computation.image.extract_single_roi() for single ROI
cdl.computation.image.extract_multiple_roi() for multiple ROIs

edit_regions_of_interest(extract: bool = False) → TypeROI | None[source]#

Define Region Of Interest (ROI).

Paramètres:: extract – If True, ROI is extracted from data. Defaults to False.
Renvoie:: ROI object or None if ROI dialog has been canceled.

delete_regions_of_interest() → None[source]#: Delete Regions Of Interest

abstract compute_stats() → dict[str, ResultShape][source]#: Compute data statistics

Signal processing features#

class cdl.core.gui.processor.signal.SignalProcessor(panel: SignalPanel | ImagePanel, plotwidget: PlotWidget)[source]#

Object handling signal processing: operations, processing, analysis

compute_sum() → None[source]#: Compute sum with cdl.computation.signal.compute_addition()

compute_addition_constant(param: ConstantParam | None = None) → None[source]#: Compute sum with a constant with cdl.computation.signal.compute_addition_constant()

compute_average() → None[source]#: Compute average with cdl.computation.signal.compute_addition() and divide by the number of signals

compute_product() → None[source]#: Compute product with cdl.computation.signal.compute_product()

compute_product_constant(param: ConstantParam | None = None) → None[source]#: Compute product with a constant with cdl.computation.signal.compute_product_constant()

compute_swap_axes() → None[source]#: Swap data axes with cdl.computation.signal.compute_swap_axes()

compute_inverse() → None[source]#: Compute inverse

compute_abs() → None[source]#: Compute absolute value with cdl.computation.signal.compute_abs()

compute_re() → None[source]#: Compute real part with cdl.computation.signal.compute_re()

compute_im() → None[source]#: Compute imaginary part with cdl.computation.signal.compute_im()

compute_astype(param: DataTypeSParam | None = None) → None[source]#: Convert data type with cdl.computation.signal.compute_astype()

compute_log10() → None[source]#: Compute Log10 with cdl.computation.signal.compute_log10()

compute_exp() → None[source]#: Compute Log10 with cdl.computation.signal.compute_exp()

compute_sqrt() → None[source]#: Compute square root with cdl.computation.signal.compute_sqrt()

compute_power(param: PowerParam | None = None) → None[source]#: Compute power with cdl.computation.signal.compute_power()

compute_arithmetic(obj2: SignalObj | None = None, param: ArithmeticParam | None = None) → None[source]#: Compute arithmetic operation between two signals with cdl.computation.signal.compute_arithmetic()

compute_difference(obj2: SignalObj | list[SignalObj] | None = None) → None[source]#: Compute difference between two signals with cdl.computation.signal.compute_difference()

compute_difference_constant(param: ConstantParam | None = None) → None[source]#: Compute difference with a constant with cdl.computation.signal.compute_difference_constant()

compute_quadratic_difference(obj2: SignalObj | list[SignalObj] | None = None) → None[source]#: Compute quadratic difference between two signals with cdl.computation.signal.compute_quadratic_difference()

compute_division(obj2: SignalObj | list[SignalObj] | None = None) → None[source]#: Compute division between two signals with cdl.computation.signal.compute_division()

compute_division_constant(param: ConstantParam | None = None) → None[source]#: Compute division by a constant with cdl.computation.signal.compute_division_constant()

compute_peak_detection(param: PeakDetectionParam | None = None) → None[source]#: Detect peaks from data with cdl.computation.signal.compute_peak_detection()

compute_reverse_x() → None[source]#: Reverse X axis with cdl.computation.signal.compute_reverse_x()

compute_cartesian2polar(param: AngleUnitParam | None = None) → None[source]#: Convert cartesian to polar coordinates with cdl.computation.signal.compute_cartesian2polar()

compute_polar2cartesian(param: AngleUnitParam | None = None) → None[source]#: Convert polar to cartesian coordinates with cdl.computation.signal.compute_polar2cartesian().

compute_normalize(param: NormalizeParam | None = None) → None[source]#: Normalize data with cdl.computation.signal.compute_normalize()

compute_derivative() → None[source]#: Compute derivative with cdl.computation.signal.compute_derivative()

compute_integral() → None[source]#: Compute integral with cdl.computation.signal.compute_integral()

compute_calibration(param: XYCalibrateParam | None = None) → None[source]#: Compute data linear calibration with cdl.computation.signal.compute_calibration()

compute_clip(param: ClipParam | None = None) → None[source]#: Compute maximum data clipping with cdl.computation.signal.compute_clip()

compute_offset_correction(param: ROI1DParam | None = None) → None[source]#: Compute offset correction with cdl.computation.signal.compute_offset_correction()

compute_gaussian_filter(param: GaussianParam | None = None) → None[source]#: Compute gaussian filter with cdl.computation.signal.compute_gaussian_filter()

compute_moving_average(param: MovingAverageParam | None = None) → None[source]#: Compute moving average with cdl.computation.signal.compute_moving_average()

compute_moving_median(param: MovingMedianParam | None = None) → None[source]#: Compute moving median with cdl.computation.signal.compute_moving_median()

compute_wiener() → None[source]#: Compute Wiener filter with cdl.computation.signal.compute_wiener()

compute_lowpass(param: LowPassFilterParam | None = None) → None[source]#: Compute high-pass filter with cdl.computation.signal.compute_filter()

compute_highpass(param: HighPassFilterParam | None = None) → None[source]#: Compute high-pass filter with cdl.computation.signal.compute_filter()

compute_bandpass(param: BandPassFilterParam | None = None) → None[source]#: Compute band-pass filter with cdl.computation.signal.compute_filter()

compute_bandstop(param: BandStopFilterParam | None = None) → None[source]#: Compute band-stop filter with cdl.computation.signal.compute_filter()

compute_fft(param: FFTParam | None = None) → None[source]#: Compute FFT with cdl.computation.signal.compute_fft()

compute_ifft(param: FFTParam | None = None) → None[source]#: Compute iFFT with cdl.computation.signal.compute_ifft()

compute_magnitude_spectrum(param: SpectrumParam | None = None) → None[source]#: Compute magnitude spectrum with cdl.computation.signal.compute_magnitude_spectrum()

compute_phase_spectrum() → None[source]#: Compute phase spectrum with cdl.computation.signal.compute_phase_spectrum()

compute_psd(param: SpectrumParam | None = None) → None[source]#: Compute power spectral density with cdl.computation.signal.compute_psd()

compute_interpolation(obj2: SignalObj | None = None, param: InterpolationParam | None = None)[source]#: Compute interpolation with cdl.computation.signal.compute_interpolation()

compute_resampling(param: ResamplingParam | None = None)[source]#: Compute resampling with cdl.computation.signal.compute_resampling()

compute_detrending(param: DetrendingParam | None = None)[source]#: Compute detrending with cdl.computation.signal.compute_detrending()

compute_convolution(obj2: SignalObj | None = None) → None[source]#: Compute convolution with cdl.computation.signal.compute_convolution()

compute_windowing(param: WindowingParam | None = None) → None[source]#: Compute windowing with cdl.computation.signal.compute_windowing()

compute_allan_variance(param: AllanVarianceParam | None = None) → None[source]#: Compute Allan variance with cdl.computation.signal.compute_allan_variance()

compute_allan_deviation(param: AllanVarianceParam | None = None) → None[source]#: Compute Allan deviation with cdl.computation.signal.compute_allan_deviation()

compute_overlapping_allan_variance(param: AllanVarianceParam | None = None) → None[source]#: Compute overlapping Allan variance with cdl.computation.signal.compute_overlapping_allan_variance()

compute_modified_allan_variance(param: AllanVarianceParam | None = None) → None[source]#: Compute modified Allan variance with cdl.computation.signal.compute_modified_allan_variance()

compute_hadamard_variance(param: AllanVarianceParam | None = None) → None[source]#: Compute Hadamard variance with cdl.computation.signal.compute_hadamard_variance()

compute_total_variance(param: AllanVarianceParam | None = None) → None[source]#: Compute total variance with cdl.computation.signal.compute_total_variance()

compute_time_deviation(param: AllanVarianceParam | None = None) → None[source]#: Compute time deviation with cdl.computation.signal.compute_time_deviation()

compute_all_stability(param: AllanVarianceParam | None = None) → None[source]#

Compute all stability analysis features using the following functions:

compute_polyfit(param: PolynomialFitParam | None = None) → None[source]#: Compute polynomial fitting curve

compute_fit(title: str, fitdlgfunc: Callable) → None[source]#

Compute fitting curve using an interactive dialog

Paramètres:

title – Title of the dialog
fitdlgfunc – Fitting dialog function

compute_multigaussianfit() → None[source]#: Compute multi-Gaussian fitting curve using an interactive dialog

compute_fwhm(param: FWHMParam | None = None) → dict[str, ResultShape][source]#: Compute FWHM with cdl.computation.signal.compute_fwhm()

compute_fw1e2() → dict[str, ResultShape][source]#: Compute FW at 1/e² with cdl.computation.signal.compute_fw1e2()

compute_stats() → dict[str, ResultProperties][source]#: Compute data statistics with cdl.computation.signal.compute_stats()

compute_histogram(param: HistogramParam | None = None) → dict[str, ResultShape][source]#: Compute histogram with cdl.computation.signal.compute_histogram()

compute_contrast() → dict[str, ResultProperties][source]#: Compute contrast with cdl.computation.signal.compute_contrast()

compute_x_at_minmax() → dict[str, ResultProperties][source]#: Compute x at min/max with cdl.computation.signal.compute_x_at_minmax()

compute_x_at_y(param: FindAbscissaParam | None = None) → dict[str, ResultProperties][source]#: Compute x at y with cdl.computation.signal.compute_x_at_y().

compute_sampling_rate_period() → dict[str, ResultProperties][source]#: Compute sampling rate and period (mean and std) with cdl.computation.signal.compute_sampling_rate_period()

compute_bandwidth_3db() → None[source]#: Compute bandwidth at -3dB with cdl.computation.signal.compute_bandwidth_3db()

compute_dynamic_parameters(param: DynamicParam | None = None) → dict[str, ResultProperties][source]#: Compute Dynamic Parameters (ENOB, SINAD, THD, SFDR, SNR) with cdl.computation.signal.compute_dynamic_parameters()

Image processing features#

class cdl.core.gui.processor.image.ImageProcessor(panel: SignalPanel | ImagePanel, plotwidget: PlotWidget)[source]#

Object handling image processing: operations, processing, analysis

compute_normalize(param: NormalizeParam | None = None) → None[source]#: Normalize data with cdl.computation.image.compute_normalize()

compute_sum() → None[source]#: Compute sum with cdl.computation.image.compute_addition()

compute_addition_constant(param: ConstantParam | None = None) → None[source]#: Compute sum with a constant using cdl.computation.image.compute_addition_constant()

compute_average() → None[source]#: Compute average with cdl.computation.image.compute_addition() and dividing by the number of images

compute_product() → None[source]#: Compute product with cdl.computation.image.compute_product()

compute_product_constant(param: ConstantParam | None = None) → None[source]#: Compute product with a constant using cdl.computation.image.compute_product_constant()

compute_logp1(param: LogP1Param | None = None) → None[source]#: Compute base 10 logarithm using cdl.computation.image.compute_logp1()

compute_rotate(param: RotateParam | None = None) → None[source]#: Rotate data arbitrarily using cdl.computation.image.compute_rotate()

compute_rotate90() → None[source]#: Rotate data 90° with cdl.computation.image.compute_rotate90()

compute_rotate270() → None[source]#: Rotate data 270° with cdl.computation.image.compute_rotate270()

compute_fliph() → None[source]#: Flip data horizontally using cdl.computation.image.compute_fliph()

compute_flipv() → None[source]#: Flip data vertically with cdl.computation.image.compute_flipv()

distribute_on_grid(param: GridParam | None = None) → None[source]#: Distribute images on a grid

reset_positions() → None[source]#: Reset image positions

compute_resize(param: ResizeParam | None = None) → None[source]#: Resize image with cdl.computation.image.compute_resize()

compute_binning(param: BinningParam | None = None) → None[source]#: Binning image with cdl.computation.image.compute_binning()

compute_line_profile(param: LineProfileParam | None = None) → None[source]#: Compute profile along a vertical or horizontal line with cdl.computation.image.compute_line_profile()

compute_segment_profile(param: SegmentProfileParam | None = None)[source]#: Compute profile along a segment with cdl.computation.image.compute_segment_profile()

compute_average_profile(param: AverageProfileParam | None = None) → None[source]#: Compute average profile with cdl.computation.image.compute_average_profile()

compute_radial_profile(param: RadialProfileParam | None = None) → None[source]#: Compute radial profile with cdl.computation.image.compute_radial_profile()

compute_histogram(param: HistogramParam | None = None) → None[source]#: Compute histogram with cdl.computation.image.compute_histogram()

compute_swap_axes() → None[source]#: Swap data axes with cdl.computation.image.compute_swap_axes().

compute_inverse() → None[source]#: Compute inverse

compute_abs() → None[source]#: Compute absolute value with cdl.computation.image.compute_abs()

compute_re() → None[source]#: Compute real part with cdl.computation.image.compute_re()

compute_im() → None[source]#: Compute imaginary part with cdl.computation.image.compute_im()

compute_astype(param: DataTypeIParam | None = None) → None[source]#: Convert data type with cdl.computation.image.compute_astype()

compute_log10() → None[source]#: Compute Log10 with cdl.computation.image.compute_log10()

compute_exp() → None[source]#: Compute Log10 with cdl.computation.image.compute_exp()

compute_arithmetic(obj2: ImageObj | None = None, param: ArithmeticParam | None = None) → None[source]#: Compute arithmetic operation between two images with cdl.computation.image.compute_arithmetic()

compute_difference(obj2: ImageObj | list[ImageObj] | None = None) → None[source]#: Compute difference between two images with cdl.computation.image.compute_difference()

compute_difference_constant(param: ConstantParam | None = None) → None[source]#: Compute difference with a constant with cdl.computation.image.compute_difference_constant()

compute_quadratic_difference(obj2: ImageObj | list[ImageObj] | None = None) → None[source]#: Compute quadratic difference between two images with cdl.computation.image.compute_quadratic_difference()

compute_division(obj2: ImageObj | list[ImageObj] | None = None) → None[source]#: Compute division between two images with cdl.computation.image.compute_division()

compute_division_constant(param: ConstantParam | None = None) → None[source]#: Compute division by a constant with cdl.computation.image.compute_division_constant()

compute_flatfield(obj2: ImageObj | None = None, param: FlatFieldParam | None = None) → None[source]#: Compute flat field correction with cdl.computation.image.compute_flatfield()

compute_calibration(param: ZCalibrateParam | None = None) → None[source]#: Compute data linear calibration with cdl.computation.image.compute_calibration()

compute_clip(param: ClipParam | None = None) → None[source]#: Compute maximum data clipping with cdl.computation.image.compute_clip()

compute_offset_correction(param: ROI2DParam | None = None) → None[source]#: Compute offset correction with cdl.computation.image.compute_offset_correction()

compute_gaussian_filter(param: GaussianParam | None = None) → None[source]#: Compute gaussian filter with cdl.computation.image.compute_gaussian_filter()

compute_moving_average(param: MovingAverageParam | None = None) → None[source]#: Compute moving average with cdl.computation.image.compute_moving_average()

compute_moving_median(param: MovingMedianParam | None = None) → None[source]#: Compute moving median with cdl.computation.image.compute_moving_median()

compute_wiener() → None[source]#: Compute Wiener filter with cdl.computation.image.compute_wiener()

compute_fft(param: FFTParam | None = None) → None[source]#: Compute FFT with cdl.computation.image.compute_fft()

compute_ifft(param: FFTParam | None = None) → None[source]#: Compute iFFT with cdl.computation.image.compute_ifft()

compute_magnitude_spectrum(param: SpectrumParam | None = None) → None[source]#: Compute magnitude spectrum with cdl.computation.image.compute_magnitude_spectrum()

compute_phase_spectrum() → None[source]#: Compute phase spectrum with cdl.computation.image.compute_phase_spectrum()

compute_psd(param: SpectrumParam | None = None) → None[source]#: Compute Power Spectral Density (PSD) with cdl.computation.image.compute_psd()

compute_butterworth(param: ButterworthParam | None = None) → None[source]#: Compute Butterworth filter with cdl.computation.image.compute_butterworth()

compute_threshold(param: ThresholdParam | None = None) → None[source]#: Compute parametric threshold with cdl.computation.image.threshold.compute_threshold()

compute_threshold_isodata() → None[source]#: Compute threshold using Isodata algorithm with cdl.computation.image.threshold.compute_threshold_isodata()

compute_threshold_li() → None[source]#: Compute threshold using Li algorithm with cdl.computation.image.threshold.compute_threshold_li()

compute_threshold_mean() → None[source]#: Compute threshold using Mean algorithm with cdl.computation.image.threshold.compute_threshold_mean()

compute_threshold_minimum() → None[source]#: Compute threshold using Minimum algorithm with cdl.computation.image.threshold.compute_threshold_minimum()

compute_threshold_otsu() → None[source]#: Compute threshold using Otsu algorithm with cdl.computation.image.threshold.compute_threshold_otsu()

compute_threshold_triangle() → None[source]#: Compute threshold using Triangle algorithm with cdl.computation.image.threshold.compute_threshold_triangle()

compute_threshold_yen() → None[source]#: Compute threshold using Yen algorithm with cdl.computation.image.threshold.compute_threshold_yen()

compute_all_threshold() → None[source]#

Compute all threshold algorithms using the following functions:

compute_adjust_gamma(param: AdjustGammaParam | None = None) → None[source]#: Compute gamma correction with cdl.computation.image.exposure.compute_adjust_gamma()

compute_adjust_log(param: AdjustLogParam | None = None) → None[source]#: Compute log correction with cdl.computation.image.exposure.compute_adjust_log()

compute_adjust_sigmoid(param: AdjustSigmoidParam | None = None) → None[source]#: Compute sigmoid correction with cdl.computation.image.exposure.compute_adjust_sigmoid()

compute_rescale_intensity(param: RescaleIntensityParam | None = None) → None[source]#: Rescale image intensity levels with :py:func`cdl.computation.image.exposure.compute_rescale_intensity`

compute_equalize_hist(param: EqualizeHistParam | None = None) → None[source]#: Histogram equalization with cdl.computation.image.exposure.compute_equalize_hist()

compute_equalize_adapthist(param: EqualizeAdaptHistParam | None = None) → None[source]#: Adaptive histogram equalization with cdl.computation.image.exposure.compute_equalize_adapthist()

compute_denoise_tv(param: DenoiseTVParam | None = None) → None[source]#: Compute Total Variation denoising with cdl.computation.image.restoration.compute_denoise_tv()

compute_denoise_bilateral(param: DenoiseBilateralParam | None = None) → None[source]#: Compute bilateral filter denoising with cdl.computation.image.restoration.compute_denoise_bilateral()

compute_denoise_wavelet(param: DenoiseWaveletParam | None = None) → None[source]#: Compute Wavelet denoising with cdl.computation.image.restoration.compute_denoise_wavelet()

compute_denoise_tophat(param: MorphologyParam | None = None) → None[source]#: Denoise using White Top-Hat with cdl.computation.image.restoration.compute_denoise_tophat()

compute_all_denoise(params: list | None = None) → None[source]#

Compute all denoising filters using the following functions:

compute_white_tophat(param: MorphologyParam | None = None) → None[source]#: Compute White Top-Hat with cdl.computation.image.morphology.compute_white_tophat()

compute_black_tophat(param: MorphologyParam | None = None) → None[source]#: Compute Black Top-Hat with cdl.computation.image.morphology.compute_black_tophat()

compute_erosion(param: MorphologyParam | None = None) → None[source]#: Compute Erosion with cdl.computation.image.morphology.compute_erosion()

compute_dilation(param: MorphologyParam | None = None) → None[source]#: Compute Dilation with cdl.computation.image.morphology.compute_dilation()

compute_opening(param: MorphologyParam | None = None) → None[source]#: Compute morphological opening with cdl.computation.image.morphology.compute_opening()

compute_closing(param: MorphologyParam | None = None) → None[source]#: Compute morphological closing with cdl.computation.image.morphology.compute_closing()

compute_all_morphology(param: MorphologyParam | None = None) → None[source]#

Compute all morphology filters using the following functions:

compute_canny(param: CannyParam | None = None) → None[source]#: Compute Canny filter with cdl.computation.image.edges.compute_canny()

compute_roberts() → None[source]#: Compute Roberts filter with cdl.computation.image.edges.compute_roberts()

compute_prewitt() → None[source]#: Compute Prewitt filter with cdl.computation.image.edges.compute_prewitt()

compute_prewitt_h() → None[source]#: Compute Prewitt filter (horizontal) with cdl.computation.image.edges.compute_prewitt_h()

compute_prewitt_v() → None[source]#: Compute Prewitt filter (vertical) with cdl.computation.image.edges.compute_prewitt_v()

compute_sobel() → None[source]#: Compute Sobel filter with cdl.computation.image.edges.compute_sobel()

compute_sobel_h() → None[source]#: Compute Sobel filter (horizontal) with cdl.computation.image.edges.compute_sobel_h()

compute_sobel_v() → None[source]#: Compute Sobel filter (vertical) with cdl.computation.image.edges.compute_sobel_v()

compute_scharr() → None[source]#: Compute Scharr filter with cdl.computation.image.edges.compute_scharr()

compute_scharr_h() → None[source]#: Compute Scharr filter (horizontal) with cdl.computation.image.edges.compute_scharr_h()

compute_scharr_v() → None[source]#: Compute Scharr filter (vertical) with cdl.computation.image.edges.compute_scharr_v()

compute_farid() → None[source]#: Compute Farid filter with cdl.computation.image.edges.compute_farid()

compute_farid_h() → None[source]#: Compute Farid filter (horizontal) with cdl.computation.image.edges.compute_farid_h()

compute_farid_v() → None[source]#: Compute Farid filter (vertical) with cdl.computation.image.edges.compute_farid_v()

compute_laplace() → None[source]#: Compute Laplace filter with cdl.computation.image.edges.compute_laplace()

compute_all_edges() → None[source]#

Compute all edges filters using the following functions:

compute_stats() → dict[str, ResultProperties][source]#: Compute data statistics with cdl.computation.image.compute_stats()

compute_centroid() → dict[str, ResultShape][source]#: Compute image centroid with cdl.computation.image.compute_centroid()

compute_enclosing_circle() → dict[str, ResultShape][source]#: Compute minimum enclosing circle with cdl.computation.image.compute_enclosing_circle()

compute_peak_detection(param: Peak2DDetectionParam | None = None) → dict[str, ResultShape][source]#: Compute 2D peak detection with cdl.computation.image.compute_peak_detection()

compute_contour_shape(param: ContourShapeParam | None = None) → dict[str, ResultShape][source]#: Compute contour shape fit with cdl.computation.image.detection.compute_contour_shape()

compute_hough_circle_peaks(param: HoughCircleParam | None = None) → dict[str, ResultShape][source]#: Compute peak detection based on a circle Hough transform with cdl.computation.image.compute_hough_circle_peaks()

compute_blob_dog(param: BlobDOGParam | None = None) → dict[str, ResultShape][source]#: Compute blob detection using Difference of Gaussian method with cdl.computation.image.detection.compute_blob_dog()

compute_blob_doh(param: BlobDOHParam | None = None) → dict[str, ResultShape][source]#: Compute blob detection using Determinant of Hessian method with cdl.computation.image.detection.compute_blob_doh()

compute_blob_log(param: BlobLOGParam | None = None) → dict[str, ResultShape][source]#: Compute blob detection using Laplacian of Gaussian method with cdl.computation.image.detection.compute_blob_log()

compute_blob_opencv(param: BlobOpenCVParam | None = None) → dict[str, ResultShape][source]#: Compute blob detection using OpenCV with cdl.computation.image.detection.compute_blob_opencv()