Processor#

The cdl.core.gui.processor package provides the processor objects for signals and images.

Processor objects are the bridge between the computation modules (in cdl.computation) and the GUI modules (in cdl.core.gui). They are used to call the computation functions and to update the GUI from inside the data panel objects.

When implementing a processing feature in DataLab, the steps are usually the following:

Add an action in the cdl.core.gui.actionhandler module to trigger the processing feature from the GUI (e.g. a menu item or a toolbar button).
Implement the computation function in the cdl.computation module (that would eventually call the algorithm from the cdl.algorithms module).
Implement the processor object method in this package to call the computation function and eventually update the GUI.

The processor objects are organized in submodules according to their purpose.

The following submodules are available:

cdl.core.gui.processor.base: Common processing features
cdl.core.gui.processor.signal: Signal processing features
cdl.core.gui.processor.image: Image processing features

Common features#

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

Multiprocessing worker, to run long-running tasks in a separate process

static create_pool() → None[source]#: Create multiprocessing pool

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

Terminate multiprocessing pool.

Parameters:: 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.

Parameters:

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.

Returns:: True if computation is finished
Return type:: bool

get_result() → CompOut[source]#

Return computation result.

Returns:: computation result
Return type:: CompOut

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

Object handling data processing: operations, processing, analysis.

Parameters:

panel – panel
plotwidget – plot widget

close()[source]#: Close processor properly

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

Set process isolation enabled.

Parameters:: enabled – enabled

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

Return True if parameter defaults are available.

Parameters:: paramclass – parameter class
Returns:: True if parameter defaults are available
Return type:: bool

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

Update parameter defaults.

Parameters:: param – parameters

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

Initialize processing parameters.

Parameters:

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

Returns:

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

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

Parameters:

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.

Parameters:

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.

Parameters:

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

Returns:

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

Return type:

Output object

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

Parameters:

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.

Returns:

object uuid, values: ResultShape or: ResultProperties objects)

Return type:

Dictionary of results (keys

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

Parameters:

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

Parameters:

obj2 – second object
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 | None = None) → None[source]#: Compute difference

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

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

abstract compute_roi_extraction(param=None) → None[source]#: Extract Region Of Interest (ROI) from data

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

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

edit_regions_of_interest(extract: bool = False, singleobj: bool | None = None, add_roi: bool = False) → ROIDataParam | None[source]#

Define Region Of Interest (ROI).

Parameters:

extract – If True, ROI is extracted from data. Defaults to False.
singleobj – If True, ROI is extracted from first selected object only. If False, ROI is extracted from all selected objects. If None, ROI is extracted from all selected objects only if they all have the same ROI. Defaults to None.
add_roi – If True, add ROI to data immediately after opening the ROI editor. Defaults to False.

Returns:

ROI data parameters 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_roi_extraction(param: ROIDataParam | None = None) → None[source]#

Extract Region Of Interest (ROI) from data with:

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

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

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 | 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 | None = None) → None[source]#: Compute quadratic difference between two signals with cdl.computation.signal.compute_quadratic_difference()

compute_division(obj2: 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_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_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

Parameters:

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_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_roi_extraction(param: ROIDataParam | 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

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_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 | 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 | None = None) → None[source]#: Compute quadratic difference between two images with cdl.computation.image.compute_quadratic_difference()

compute_division(obj2: 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()