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

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

Return True if operation mode is pairwise.

Returns:: True if operation mode is pairwise
Return type:: bool

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.

Note

In pairwise mode, the function is executed on each pair of objects, so the logic is different:

N(>=1) objects + N objects in → N objects out

In other words, the n1n function in single operand mode becomes a nnn function in pairwise mode.

Examples: subtract, divide

Parameters:

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

abstractmethod 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).

Parameters:: extract – If True, ROI is extracted from data. Defaults to False.
Returns:: ROI object or None if ROI dialog has been canceled.

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

abstractmethod 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

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_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()