Algorithmes (cdl.algorithms)#

Ce paquet contient les algorithmes utilisés par le projet DataLab. Ces algorithmes opèrent directement sur des tableaux NumPy et sont conçus pour être utilisés dans le pipeline DataLab, mais peuvent également être utilisés indépendamment.

Voir aussi

Le module cdl.algorithms est le point d’entrée principal pour les algorithmes DataLab lors de la manipulation de tableaux NumPy. Voir le module cdl.computation pour les algorithmes qui opèrent directement sur les objets DataLab (c’est-à-dire cdl.obj.SignalObj et cdl.obj.ImageObj).

Les algorithmes sont organisés en sous-paquets en fonction de leur objectif. Les sous-paquets suivants sont disponibles :

Algorithmes de traitement du signal#

cdl.algorithms.signal.normalize(yin: ndarray, parameter: Literal['maximum', 'amplitude', 'area', 'energy', 'rms'] = 'maximum') → ndarray[source]#

Normaliser le tableau d’entrée à un paramètre donné.

Paramètres:

  • yin – Tableau d’entrée

  • parameter – Paramètre de normalisation. Par défaut : « maximum »

Renvoie:

Tableau normalisé

cdl.algorithms.signal.fft1d(x: ndarray, y: ndarray, shift: bool = True) → tuple[ndarray, ndarray][source]#

Calculer la FFT sur les données X,Y.

Paramètres:

  • x – Données X

  • y – Données Y

  • shift – Décaler la fréquence nulle vers le centre du spectre. Par défaut : True.

Renvoie:

Données X, Y (tuple)

cdl.algorithms.signal.ifft1d(x: ndarray, y: ndarray, shift: bool = True) → tuple[ndarray, ndarray][source]#

Calculer la iFFT sur les données X,Y.

Paramètres:

  • x – Données X

  • y – Données Y

  • shift – Décaler la fréquence nulle vers le centre du spectre. Par défaut : True.

Renvoie:

Données X, Y (tuple)

cdl.algorithms.signal.magnitude_spectrum(x: ndarray, y: ndarray, log_scale: bool = False) → tuple[ndarray, ndarray][source]#

Calculer le spectre de magnitude.

Paramètres:

  • x – Données X

  • y – Données Y

  • log_scale – Utiliser une échelle logarithmique. Par défaut : False.

Renvoie:

Spectre de magnitude (données X, Y)

cdl.algorithms.signal.phase_spectrum(x: ndarray, y: ndarray) → tuple[ndarray, ndarray][source]#

Calculer le spectre de phase.

Paramètres:

  • x – Données X

  • y – Données Y

Renvoie:

Spectre de phase en degrés (données X, Y)

cdl.algorithms.signal.psd(x: ndarray, y: ndarray, log_scale: bool = False) → tuple[ndarray, ndarray][source]#

Calculer la densité spectrale de puissance (PSD), en utilisant la méthode de Welch.

Paramètres:

  • x – Données X

  • y – Données Y

  • log_scale – Utiliser une échelle logarithmique. Par défaut : False.

Renvoie:

Données X, Y (tuple)

Type renvoyé:

Power Spectral Density (PSD)

cdl.algorithms.signal.sort_frequencies(x: ndarray, y: ndarray) → ndarray[source]#

Trier à partir des données X,Y en calculant FFT(y).

Paramètres:

  • x – Données X

  • y – Données Y

Renvoie:

Fréquences triées par ordre croissant

cdl.algorithms.signal.peak_indices(y, thres: float = 0.3, min_dist: int = 1, thres_abs: bool = False) → ndarray[source]#

Routine de détection de pics.

Recherche l’index numérique des pics dans y en prenant sa première différence d’ordre. En utilisant les paramètres thres et min_dist, il est possible de réduire le nombre de pics détectés. y doit être signé.

Paramètres:

  • y (ndarray (signed)) – Données d’amplitude 1D à rechercher pour les pics.

  • thres (float between [0., 1.]) – Seuil normalisé. Seuls les pics dont l’amplitude est supérieure au seuil seront détectés.

  • min_dist (int) – Distance minimale entre chaque pic détecté. Le pic avec l’amplitude la plus élevée est préféré pour satisfaire cette contrainte.

  • thres_abs (boolean) – Si True, la valeur thres sera interprétée comme une valeur absolue, au lieu d’un seuil normalisé.

Renvoie:

Tableau contenant les index numériques des pics qui ont été détectés

Type renvoyé:

ndarray

cdl.algorithms.signal.xpeak(x: ndarray, y: ndarray) → float[source]#

Retourne la position X du pic par défaut (en supposant un seul pic).

Paramètres:

  • x – Données X

  • y – Données Y

Renvoie:

Position X du pic

cdl.algorithms.signal.interpolate(x: ndarray, y: ndarray, xnew: ndarray, method: Literal['linear', 'spline', 'quadratic', 'cubic', 'barycentric', 'pchip'], fill_value: float | None = None) → ndarray[source]#

Interpoler les données.

Paramètres:

  • x – Données X

  • y – Données Y

  • xnew – Nouvelles données X

  • method – Méthode d’interpolation

  • fill_value – Valeur de remplissage. Par défaut : None. Cette valeur est utilisée pour remplir les points demandés en dehors de la plage de données X. Elle n’est utilisée que si l’argument de méthode est “linear”, “cubic” ou “pchip”.

Renvoie:

Données Y interpolées

cdl.algorithms.signal.windowing(y: ndarray, method: Literal['barthann', 'bartlett', 'blackman', 'blackman-harris', 'bohman', 'boxcar', 'cosine', 'exponential', 'flat-top', 'hamming', 'hanning', 'lanczos', 'nuttall', 'parzen', 'rectangular', 'taylor', 'tukey', 'kaiser', 'gaussian'] = 'hamming', alpha: float = 0.5, beta: float = 14.0, sigma: float = 7.0) → ndarray[source]#

Appliquer une fenêtre aux données d’entrée.

Paramètres:

  • x – Données X

  • y – Données Y

  • method – Fonction de fenêtrage. Par défaut : « hamming ».

  • alpha – Paramètre de la fenêtre de Tukey. Par défaut : 0.5.

  • beta – Paramètre de la fenêtre de Kaiser. Par défaut : 14.0.

  • sigma – Paramètre de la fenêtre gaussienne. Par défaut : 7.0.

Renvoie:

Données Y fenêtrées

class cdl.algorithms.signal.FitModel[source]#

Classe de base du modèle de régression

abstract classmethod func(x, amp, sigma, x0, y0)[source]#

Retourne la fonction de régression

classmethod get_amp_from_amplitude(amplitude, sigma)[source]#

Retourne amp à partir de l’amplitude de la fonction et de sigma

classmethod amplitude(amp, sigma)[source]#

Retourne l’amplitude de la fonction

abstract classmethod fwhm(amp, sigma)[source]#

Retourne la LMH de la fonction

classmethod half_max_segment(amp, sigma, x0, y0)[source]#

Retourne les coordonnées du segment pour l’intersection y=half-maximum

class cdl.algorithms.signal.GaussianModel[source]#

Modèle de régression gaussien à 1 dimension

classmethod func(x, amp, sigma, x0, y0)[source]#

Retourne la fonction de régression

classmethod get_amp_from_amplitude(amplitude, sigma)[source]#

Retourne amp à partir de l’amplitude de la fonction et de sigma

classmethod amplitude(amp, sigma)[source]#

Retourne l’amplitude de la fonction

classmethod fwhm(amp, sigma)[source]#

Retourne la LMH de la fonction

class cdl.algorithms.signal.LorentzianModel[source]#

Modèle de régression lorentzien à 1 dimension

classmethod func(x, amp, sigma, x0, y0)[source]#

Retourne la fonction de régression

classmethod get_amp_from_amplitude(amplitude, sigma)[source]#

Retourne amp à partir de l’amplitude de la fonction et de sigma

classmethod amplitude(amp, sigma)[source]#

Retourne l’amplitude de la fonction

classmethod fwhm(amp, sigma)[source]#

Retourne la LMH de la fonction

class cdl.algorithms.signal.VoigtModel[source]#

Modèle de régression Voigt à 1 dimension

classmethod func(x, amp, sigma, x0, y0)[source]#

Retourne la fonction de régression

classmethod fwhm(amp, sigma)[source]#

Retourne la LMH de la fonction

cdl.algorithms.signal.find_zero_crossings(y: ndarray) → ndarray[source]#

Find the left indices of the zero-crossing intervals in the given array.

Paramètres:

y – Tableau d’entrée.

Renvoie:

An array of indices where zero-crossings occur.

cdl.algorithms.signal.find_x_at_value(x: ndarray, y: ndarray, value: float) → ndarray[source]#

Rechercher la valeur x où la valeur y est la plus proche de la valeur donnée en utilisant une interpolation linéaire pour déduire la valeur x précise.

Paramètres:

  • x – Données X

  • y – Données Y

  • value – Valeur à rechercher

Renvoie:

Valeur X où la valeur Y est la plus proche de la valeur donnée (tableau vide si aucun zéro n’est trouvé)

cdl.algorithms.signal.bandwidth(data: ndarray, level: float = 3.0) → tuple[float, float, float, float][source]#

Calculer la largeur de bande du signal à un niveau donné.

Paramètres:

  • data – Données X,Y

  • level – Niveau en dB auquel la largeur de bande est calculée. Par défaut : 3.0.

Renvoie:

coordonnées du segment

Type renvoyé:

Bandwidth of the signal at the given level

cdl.algorithms.signal.contrast(y: ndarray) → float[source]#

Calculer le contraste

Paramètres:

y – Tableau d’entrée

Renvoie:

Contraste

cdl.algorithms.signal.sinusoidal_model(x: ndarray, a: float, f: float, phi: float, offset: float) → ndarray[source]#

Fonction de modèle sinusoïdal.

cdl.algorithms.signal.sinusoidal_fit(x: ndarray, y: ndarray) → tuple[tuple[float, float, float, float], float][source]#

Adapter un modèle sinusoïdal aux données d’entrée.

Paramètres:

  • x – Données X

  • y – Données Y

Renvoie:

Un tuple contenant les paramètres d’ajustement (amplitude, fréquence, phase, décalage) et les résidus

cdl.algorithms.signal.sinus_frequency(x: ndarray, y: ndarray) → float[source]#

Calculer la fréquence d’un signal sinusoïdal.

Paramètres:

  • x – données x du signal

  • y – données y du signal

Renvoie:

Fréquence du signal sinusoïdal

cdl.algorithms.signal.enob(x: ndarray, y: ndarray, full_scale: float = 1.0) → float[source]#

Calculer le nombre effectif de bits (ENOB).

Paramètres:

  • x – données x du signal

  • y – données y du signal

  • full_scale – Pleine échelle (V). Par défaut : 1.0.

Renvoie:

Nombre effectif de bits (ENOB)

cdl.algorithms.signal.sinad(x: ndarray, y: ndarray, full_scale: float = 1.0, unit: Literal['dBc', 'dBFS'] = 'dBc') → float[source]#

Calculer le rapport signal/bruit et distorsion (SINAD).

Paramètres:

  • x – données x du signal

  • y – données y du signal

  • full_scale – Pleine échelle (V). Par défaut : 1.0.

  • unit – Unité des données d’entrée. Les valeurs valides sont “dBc” et “dBFS”. Par défaut : “dBc”.

Renvoie:

Rapport signal/bruit et distorsion (SINAD)

cdl.algorithms.signal.thd(x: ndarray, y: ndarray, full_scale: float = 1.0, unit: Literal['dBc', 'dBFS'] = 'dBc', nb_harm: int = 5) → float[source]#

Calculer la distorsion harmonique totale (THD).

Paramètres:

  • x – données x du signal

  • y – données y du signal

  • full_scale – Pleine échelle (V). Par défaut : 1.0.

  • unit – Unité des données d’entrée. Les valeurs valides sont “dBc” et “dBFS”. Par défaut : “dBc”.

  • nb_harm – Nombre d’harmoniques à considérer. Par défaut : 5.

Renvoie:

Distorsion harmonique totale (THD)

cdl.algorithms.signal.sfdr(x: ndarray, y: ndarray, full_scale: float = 1.0, unit: Literal['dBc', 'dBFS'] = 'dBc') → float[source]#

Calculer la plage dynamique sans spurious (SFDR).

Paramètres:

  • x – données x du signal

  • y – données y du signal

  • full_scale – Pleine échelle (V). Par défaut : 1.0.

  • unit – Unité des données d’entrée. Les valeurs valides sont “dBc” et “dBFS”. Par défaut : “dBc”.

Renvoie:

Plage dynamique sans spurious (SFDR)

cdl.algorithms.signal.snr(x: ndarray, y: ndarray, full_scale: float = 1.0, unit: Literal['dBc', 'dBFS'] = 'dBc') → float[source]#

Calculer le rapport signal/bruit (SNR).

Paramètres:

  • x – données x du signal

  • y – données y du signal

  • full_scale – Pleine échelle (V). Par défaut : 1.0.

  • unit – Unité des données d’entrée. Les valeurs valides sont “dBc” et “dBFS”. Par défaut : “dBc”.

Renvoie:

Rapport signal/bruit (SNR)

cdl.algorithms.signal.sampling_period(x: ndarray) → float[source]#

Calculer la période d’échantillonnage

Paramètres:

x – Données X

Renvoie:

Période d’échantillonnage

cdl.algorithms.signal.sampling_rate(x: ndarray) → float[source]#

Calculer le taux d’échantillonnage moyen

Paramètres:

x – Données X

Renvoie:

Taux d’échantillonnage

cdl.algorithms.signal.fwhm(data: ndarray, method: Literal['zero-crossing', 'gauss', 'lorentz', 'voigt'] = 'zero-crossing', xmin: float | None = None, xmax: float | None = None) → tuple[float, float, float, float][source]#

Calculer la largeur totale à mi-hauteur (FWHM) des données d’entrée

Paramètres:

  • data – Données X,Y

  • method – Méthode de calcul. Deux types de méthodes sont pris en charge : une méthode de croisement à zéro et des méthodes d’ajustement (basées sur divers modèles : Gauss, Lorentz, Voigt). Par défaut : « zero-crossing ».

  • xmin – Borne X inférieure pour l’ajustement. Par défaut : None (pas de borne inférieure, c’est-à-dire que l’ajustement commence à partir du premier point).

  • xmax – Borne X supérieure pour l’ajustement. Par défaut : None (pas de borne supérieure, c’est-à-dire que l’ajustement se termine au dernier point)

Renvoie:

Coordonnées du segment LMH

cdl.algorithms.signal.fw1e2(data: ndarray) → tuple[float, float, float, float][source]#

Calculer la largeur totale à 1/e² des données d’entrée (en utilisant un ajustement de modèle gaussien).

Paramètres:

data – Données X,Y

Renvoie:

Coordonnées du segment LMH à 1/e²

cdl.algorithms.signal.allan_variance(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Allan variance for given time and measurement values at specified tau values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Allan deviation time values

Renvoie:

Allan variance values

cdl.algorithms.signal.allan_deviation(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Allan deviation for given time and measurement values at specified tau values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Allan deviation time values

Renvoie:

Allan deviation values

cdl.algorithms.signal.overlapping_allan_variance(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Overlapping Allan variance for given time and measurement values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Allan deviation time values

Renvoie:

Overlapping Allan variance values

cdl.algorithms.signal.modified_allan_variance(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Modified Allan variance for given time and measurement values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Modified Allan deviation time values

Renvoie:

Modified Allan variance values

cdl.algorithms.signal.hadamard_variance(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Hadamard variance for given time and measurement values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Hadamard deviation time values

Renvoie:

Hadamard variance values

cdl.algorithms.signal.total_variance(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Total variance for given time and measurement values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Total variance time values

Renvoie:

Total variance values

cdl.algorithms.signal.time_deviation(x: ndarray, y: ndarray, tau_values: ndarray) → ndarray[source]#

Calculate the Time Deviation (TDEV) for given time and measurement values.

Paramètres:

  • x – Tableau des temps

  • y – Measured values array

  • tau_values – Time deviation time values

Renvoie:

Time deviation values

Algorithmes de traitement d’image#

cdl.algorithms.image.scale_data_to_min_max(data: ndarray, zmin: float | int, zmax: float | int) → ndarray[source]#

Mettre à l’échelle le tableau data pour s’adapter à la plage dynamique [zmin, zmax]

Paramètres:

  • data – Données d’entrée

  • zmin – Valeur minimale des données de sortie

  • zmax – Valeur maximale des données de sortie

Renvoie:

Données mises à l’échelle

cdl.algorithms.image.normalize(data: ndarray, parameter: Literal['maximum', 'amplitude', 'area', 'energy', 'rms'] = 'maximum') → ndarray[source]#

Normaliser le tableau d’entrée à un paramètre donné.

Paramètres:

  • data – Données d’entrée

  • parameter – Paramètre de normalisation (par défaut : « maximum »)

Renvoie:

Tableau normalisé

cdl.algorithms.image.fft2d(z: ndarray, shift: bool = True) → ndarray[source]#

Calculer la FFT du tableau complexe z

Paramètres:

  • z – Données d’entrée

  • shift – Décaler la fréquence nulle vers le centre (par défaut : True)

Renvoie:

FFT des données d’entrée

cdl.algorithms.image.ifft2d(z: ndarray, shift: bool = True) → ndarray[source]#

Calculer la FFT inverse du tableau complexe z

Paramètres:

  • z – Données d’entrée

  • shift – Décaler la fréquence nulle vers le centre (par défaut : True)

Renvoie:

FFT inverse des données d’entrée

cdl.algorithms.image.magnitude_spectrum(z: ndarray, log_scale: bool = False) → ndarray[source]#

Calculer le spectre de magnitude du tableau complexe z

Paramètres:

  • z – Données d’entrée

  • log_scale – Utiliser une échelle logarithmique (par défaut : False)

Renvoie:

Spectre de magnitude des données d’entrée

cdl.algorithms.image.phase_spectrum(z: ndarray) → ndarray[source]#

Calculer le spectre de phase du tableau complexe z

Paramètres:

z – Données d’entrée

Renvoie:

Spectre de phase des données d’entrée (en degrés)

cdl.algorithms.image.psd(z: ndarray, log_scale: bool = False) → ndarray[source]#

Calculer la densité spectrale de puissance du tableau complexe z

Paramètres:

  • z – Données d’entrée

  • log_scale – Utiliser une échelle logarithmique (par défaut : False)

Renvoie:

Densité spectrale de puissance des données d’entrée

cdl.algorithms.image.binning(data: ndarray, sx: int, sy: int, operation: Literal['sum', 'average', 'median', 'min', 'max'], dtype=None) → ndarray[source]#

Effectuer le binning des pixels de l’image

Paramètres:

  • data – Données d’entrée

  • sx – Binning le long de x (nombre de pixels à biner ensemble)

  • sy – Binning le long de y (nombre de pixels à biner ensemble)

  • operation – Opération de binning

  • dtype – Type de données de sortie (par défaut : None, c’est-à-dire identique à l’entrée)

Renvoie:

Données binnées

cdl.algorithms.image.flatfield(rawdata: ndarray, flatdata: ndarray, threshold: float | None = None) → ndarray[source]#

Calculer la correction du champ plat

Paramètres:

  • rawdata – Données brutes

  • flatdata – Données de champ plat

  • threshold – Seuil de correction du champ plat (par défaut : None)

Renvoie:

Données corrigées du champ plat

cdl.algorithms.image.get_centroid_fourier(data: ndarray) → tuple[float, float][source]#

Retourne le centre de gravité de l’image en utilisant l’algorithme de Fourier

Paramètres:

data – Données d’entrée

Renvoie:

Coordonnées du centre de gravité (ligne, colonne)

cdl.algorithms.image.get_absolute_level(data: ndarray, level: float) → float[source]#

Retourne le niveau absolu

Paramètres:

  • data – Données d’entrée

  • level – Niveau relatif (0.0 à 1.0)

Renvoie:

Niveau absolu

cdl.algorithms.image.get_enclosing_circle(data: ndarray, level: float = 0.5) → tuple[int, int, float][source]#

Retourne (x, y, rayon) pour le contour du cercle contenant les valeurs d’image au-dessus du niveau relatif du seuil (.5 signifie FWHM)

Paramètres:

  • data – Données d’entrée

  • level – Niveau relatif (par défaut : 0.5)

Renvoie:

Un tuple (x, y, rayon)

Lève:

ValueError – Aucun contour n’a été trouvé

cdl.algorithms.image.get_radial_profile(data: ndarray, center: tuple[int, int]) → tuple[ndarray, ndarray][source]#

Retourne le profil radial des données d’image

Paramètres:

  • data – Tableau d’entrée (2D)

  • center – Coordonnées du centre du profil (x, y)

Renvoie:

Profil radial (X, Y) où X est la distance du centre (tableau 1D) et Y est la valeur moyenne des pixels à cette distance (tableau 1D)

cdl.algorithms.image.distance_matrix(coords: list) → ndarray[source]#

Retourne la matrice de distance à partir des coordonnées

Paramètres:

coords – Liste des coordonnées

Renvoie:

Matrice de distance

cdl.algorithms.image.get_2d_peaks_coords(data: ndarray, size: int | None = None, level: float = 0.5) → ndarray[source]#

Détecte les pics dans les données d’image, retourne les coordonnées.

Si la taille du voisinage est None, la valeur par défaut est la plus élevée entre 50 pixels et le 1/40ème de la plus petite dimension de l’image.

Le niveau de seuil de détection est relatif à la différence entre les valeurs maximales et minimales des données.

Paramètres:

  • data – Données d’entrée

  • size – Taille du voisinage (par défaut : None)

  • level – Niveau relatif (par défaut : 0.5)

Renvoie:

Coordonnées des pics

cdl.algorithms.image.get_contour_shapes(data: ndarray | MaskedArray, shape: Literal['circle', 'ellipse', 'polygon'] = 'ellipse', level: float = 0.5) → ndarray[source]#

Trouve les contours de valeur iso dans un tableau 2D, au-dessus du niveau relatif (.5 signifie FWHM), puis ajuste les contours avec la forme (“ellipse” ou “cercle”)

Paramètres:

  • data – Données d’entrée

  • shape – Forme à ajuster. Par défaut : “ellipse”

  • level – Niveau relatif (par défaut : 0.5)

Renvoie:

Coordonnées des formes

cdl.algorithms.image.get_hough_circle_peaks(data: ndarray, min_radius: float | None = None, max_radius: float | None = None, nb_radius: int | None = None, min_distance: int = 1) → ndarray[source]#

Détecte les pics dans l’image à partir de la transformée de Hough du cercle, retourne les coordonnées du cercle.

Paramètres:

  • data – Données d’entrée

  • min_radius – Rayon minimum (par défaut : None)

  • max_radius – Rayon maximum (par défaut : None)

  • nb_radius – Nombre de rayons (par défaut : None)

  • min_distance – Distance minimale entre les cercles (par défaut : 1)

Renvoie:

Coordonnées des cercles

cdl.algorithms.image.find_blobs_dog(data: ndarray, min_sigma: float = 1, max_sigma: float = 30, overlap: float = 0.5, threshold_rel: float = 0.2, exclude_border: bool = True) → ndarray[source]#

Recherche les taches dans l’image en niveaux de gris donnée en utilisant la méthode de différence de Gauss (DoG).

Paramètres:

  • data – L’image d’entrée en niveaux de gris.

  • min_sigma – Le rayon minimum de la tache en pixels.

  • max_sigma – Le rayon maximum de la tache en pixels.

  • overlap – Le chevauchement minimum entre deux taches en pixels. Par exemple, si deux taches sont détectées avec des rayons de 10 et 12 respectivement, et que le chevauchement est défini sur 0,5, alors la zone de la plus petite tache sera ignorée et seule la zone de la plus grande tache sera retournée.

  • threshold_rel – La limite inférieure absolue pour les maxima de l’espace d’échelle. Les maxima locaux plus petits que threshold_rel sont ignorés. Réduisez ceci pour détecter les taches avec moins d’intensité.

  • exclude_border – Si True, exclure les taches de la détection si elles sont trop proches du bord de l’image. La taille de la bordure est min_sigma.

Renvoie:

Coordonnées des taches

cdl.algorithms.image.find_blobs_doh(data: ndarray, min_sigma: float = 1, max_sigma: float = 30, overlap: float = 0.5, log_scale: bool = False, threshold_rel: float = 0.2) → ndarray[source]#

Recherche les taches dans l’image en niveaux de gris donnée en utilisant la méthode du déterminant de Hessian (DoH).

Paramètres:

  • data – L’image d’entrée en niveaux de gris.

  • min_sigma – Le rayon minimum de la tache en pixels.

  • max_sigma – Le rayon maximum de la tache en pixels.

  • overlap – Le chevauchement minimum entre deux taches en pixels. Par exemple, si deux taches sont détectées avec des rayons de 10 et 12 respectivement, et que le chevauchement est défini sur 0,5, alors la zone de la plus petite tache sera ignorée et seule la zone de la plus grande tache sera retournée.

  • log_scale – Si True, le rayon de chaque tache est retourné comme sqrt(sigma) pour chaque tache détectée.

  • threshold_rel – La limite inférieure absolue pour les maxima de l’espace d’échelle. Les maxima locaux plus petits que threshold_rel sont ignorés. Réduisez ceci pour détecter les taches avec moins d’intensité.

Renvoie:

Coordonnées des taches

cdl.algorithms.image.find_blobs_log(data: ndarray, min_sigma: float = 1, max_sigma: float = 30, overlap: float = 0.5, log_scale: bool = False, threshold_rel: float = 0.2, exclude_border: bool = True) → ndarray[source]#

Recherche les taches dans l’image en niveaux de gris donnée en utilisant la méthode du Laplacien de Gauss (LoG).

Paramètres:

  • data – L’image d’entrée en niveaux de gris.

  • min_sigma – Le rayon minimum de la tache en pixels.

  • max_sigma – Le rayon maximum de la tache en pixels.

  • overlap – Le chevauchement minimum entre deux taches en pixels. Par exemple, si deux taches sont détectées avec des rayons de 10 et 12 respectivement, et que le chevauchement est défini sur 0,5, alors la zone de la plus petite tache sera ignorée et seule la zone de la plus grande tache sera retournée.

  • log_scale – Si True, le rayon de chaque tache est retourné comme sqrt(sigma) pour chaque tache détectée.

  • threshold_rel – La limite inférieure absolue pour les maxima de l’espace d’échelle. Les maxima locaux plus petits que threshold_rel sont ignorés. Réduisez ceci pour détecter les taches avec moins d’intensité.

  • exclude_border – Si True, exclure les taches de la détection si elles sont trop proches du bord de l’image. La taille de la bordure est min_sigma.

Renvoie:

Coordonnées des taches

cdl.algorithms.image.remove_overlapping_disks(coords: ndarray) → ndarray[source]#

Supprimer les disques qui se chevauchent parmi les coordonnées

Paramètres:

coords – Les coordonnées des disques

Renvoie:

Les coordonnées des disques avec les disques qui se chevauchent supprimés

cdl.algorithms.image.find_blobs_opencv(data: ndarray, min_threshold: float | None = None, max_threshold: float | None = None, min_repeatability: int | None = None, min_dist_between_blobs: float | None = None, filter_by_color: bool | None = None, blob_color: int | None = None, filter_by_area: bool | None = None, min_area: float | None = None, max_area: float | None = None, filter_by_circularity: bool | None = None, min_circularity: float | None = None, max_circularity: float | None = None, filter_by_inertia: bool | None = None, min_inertia_ratio: float | None = None, max_inertia_ratio: float | None = None, filter_by_convexity: bool | None = None, min_convexity: float | None = None, max_convexity: float | None = None) → ndarray[source]#

Recherche les taches dans l’image en niveaux de gris donnée en utilisant le détecteur de taches simples d’OpenCV.

Paramètres:

  • data – L’image d’entrée en niveaux de gris.

  • min_threshold – L’intensité minimale de la tache.

  • max_threshold – L’intensité maximale de la tache.

  • min_repeatability – Le nombre minimum de fois qu’une tache est détectée avant qu’elle ne soit signalée.

  • min_dist_between_blobs – La distance minimale entre les taches.

  • filter_by_color – Si True, les taches sont filtrées par couleur.

  • blob_color – La couleur des taches à filtrer par.

  • filter_by_area – Si True, les taches sont filtrées par zone.

  • min_area – La zone minimale de la tache.

  • max_area – La zone maximale de la tache.

  • filter_by_circularity – Si True, les taches sont filtrées par circularité.

  • min_circularity – La circularité minimale de la tache.

  • max_circularity – La circularité maximale de la tache.

  • filter_by_inertia – Si True, les taches sont filtrées par inertie.

  • min_inertia_ratio – Le rapport d’inertie minimale de la tache.

  • max_inertia_ratio – Le rapport d’inertie maximale de la tache.

  • filter_by_convexity – Si True, les taches sont filtrées par convexité.

  • min_convexity – La convexité minimale de la tache.

  • max_convexity – La convexité maximale de la tache.

Renvoie:

Coordonnées des taches

Algorithmes de conversion de type de données#

cdl.algorithms.datatypes.is_integer_dtype(dtype: dtype) → bool[source]#

Retourne True si le type de données est un type entier

Paramètres:

dtype – Type de données à vérifier

Renvoie:

True si le type de données est un type entier

cdl.algorithms.datatypes.is_complex_dtype(dtype: dtype) → bool[source]#

Retourne True si le type de données est un type complexe

Paramètres:

dtype – Type de données à vérifier

Renvoie:

True si le type de données est un type complexe

cdl.algorithms.datatypes.clip_astype(data: ndarray, dtype: dtype) → ndarray[source]#

Convert array to a new data type, after having clipped values to the new data type’s range if it is an integer type. If data type is not integer, this is equivalent to data.astype(dtype).

Paramètres:

  • data – Array to convert

  • dtype – Type de données après conversion

Renvoie:

Array converted to new data type

Algorithmes de conversion de coordonnées#

cdl.algorithms.coordinates.circle_to_diameter(xc: float, yc: float, r: float) → tuple[float, float, float, float][source]#

Convertit le centre et le rayon du cercle en coordonnées de diamètre X

Paramètres:

  • xc – Abscisse du centre du cercle

  • yc – Ordonnée du centre du cercle

  • r – Rayon du cercle

Renvoie:

Coordonnées de diamètre X du cercle

Type renvoyé:

tuple

cdl.algorithms.coordinates.array_circle_to_diameter(data: ndarray) → ndarray[source]#

Convertit le centre et le rayon du cercle en coordonnées de diamètre X (version tableau)

Paramètres:

data – Centre et rayon du cercle, sous la forme d’un tableau 2D (N, 3)

Renvoie:

Coordonnées de diamètre X du cercle, sous la forme d’un tableau 2D (N, 4)

cdl.algorithms.coordinates.circle_to_center_radius(x0: float, y0: float, x1: float, y1: float) → tuple[float, float, float][source]#

Convertit les coordonnées de diamètre X du cercle en centre et rayon

Paramètres:

  • x0 – Abscisse de début de diamètre du cercle

  • y0 – Ordonnée de début de diamètre du cercle

  • x1 – Abscisse de fin de diamètre du cercle

  • y1 – Ordonnée de fin de diamètre du cercle

Renvoie:

Centre et rayon du cercle

Type renvoyé:

tuple

cdl.algorithms.coordinates.array_circle_to_center_radius(data: ndarray) → ndarray[source]#

Convertit les coordonnées de diamètre X du cercle en centre et rayon (version tableau)

Paramètres:

data – Coordonnées de diamètre X du cercle, sous la forme d’un tableau 2D (N, 4)

Renvoie:

Centre et rayon du cercle, sous la forme d’un tableau 2D (N, 3)

cdl.algorithms.coordinates.ellipse_to_diameters(xc: float, yc: float, a: float, b: float, theta: float) → tuple[float, float, float, float, float, float, float, float][source]#

Convertit le centre, les axes et l’angle de l’ellipse en coordonnées de diamètres X/Y

Paramètres:

  • xc – Abscisse du centre de l’ellipse

  • yc – Ordonnée du centre de l’ellipse

  • a – Demi grand axe de l’ellipse

  • b – Demi petit axe de l’ellipse

  • theta – Angle de l’ellipse

Renvoie:

Coordonnées des diamètres X/Y (grands/petits axes) de l’ellipse

cdl.algorithms.coordinates.array_ellipse_to_diameters(data: ndarray) → ndarray[source]#

Convertit le centre, les axes et l’angle de l’ellipse en coordonnées de diamètres X/Y (version tableau)

Paramètres:

data – Centre, axes et angle de l’ellipse, sous la forme d’un tableau 2D (N, 5)

Renvoie:

Coordonnées des diamètres X/Y de l’ellipse (grands/petits axes), sous la forme d’un tableau 2D (N, 8)

cdl.algorithms.coordinates.ellipse_to_center_axes_angle(x0: float, y0: float, x1: float, y1: float, x2: float, y2: float, x3: float, y3: float) → tuple[float, float, float, float, float][source]#

Convertit les coordonnées de diamètres X/Y de l’ellipse en centre, axes et angle

Paramètres:

  • x0 – abscisse de début du grand axe

  • y0 – ordonnée de début du grand axe

  • x1 – abscisse de fin du grand axe

  • y1 – ordonnée de fin du grand axe

  • x2 – abscisse de début du petit axe

  • y2 – ordonnée de début du petit axe

  • x3 – abscisse de fin du petit axe

  • y3 – ordonnée de fin du petit axe

Renvoie:

Centre, axes et angle de l’ellipse

cdl.algorithms.coordinates.array_ellipse_to_center_axes_angle(data: ndarray) → ndarray[source]#

Convertit les coordonnées de diamètres X/Y de l’ellipse en centre, axes et angle (version tableau)

Paramètres:

data – Coordonnées de diamètres X/Y de l’ellipse, sous la forme d’un tableau 2D (N, 8)

Renvoie:

Centre, axes et angle de l’ellipse, sous la forme d’un tableau 2D (N, 5)

cdl.algorithms.coordinates.cartesian2polar(x: ndarray, y: ndarray, unit: Literal['rad', 'deg'] = 'rad') → tuple[ndarray, ndarray][source]#

Convertit les coordonnées de diamètre X du cercle en centre et rayon

Paramètres:

  • x – Cartesian x-coordinate.

  • y – Cartesian y-coordinate.

  • unit – Unit of the angle (“rad” or “deg”).

Renvoie:

Polar coordinates (r, theta) where r is the radius and theta is the angle.

cdl.algorithms.coordinates.polar2cartesian(r: ndarray, theta: ndarray, unit: Literal['rad', 'deg'] = 'rad') → tuple[ndarray, ndarray][source]#

Convert polar coordinates to Cartesian coordinates.

Paramètres:

  • r – Polar radius.

  • theta – Polar angle.

  • unit – Unit of the angle (“rad” or “deg”).

Renvoie:

Cartesian coordinates (x, y) where x is the x-coordinate and y is the y-coordinate.

Note

Negative radius values are not supported. They will be set to 0.

Sur cette page