6.16. Courbes et intégration

Les pages mathématiques ont couvert les opérations qui prennent un tableau en entrée et produisent un tableau (ou un scalaire) en sortie – arithmétique, réductions, diffusion. Cette page couvre une classe différente d’opérations : celles qui traitent le tableau comme une fonction échantillonnée et posent des questions sur la fonction elle-même. Interpoler entre échantillons, ajuster une courbe sur eux, intégrer sous eux, les convoluer avec un autre tampon.

Toutes acceptent des entrées ndarray et renvoient soit un scalaire flottant soit un ndarray de flottants.

6.16.1. Interpolation

interp() effectue une interpolation linéaire unidimensionnelle. xp est un tableau 1-D de valeurs indépendantes croissant de manière monotone ; fp est l’ensemble correspondant de valeurs dépendantes ; x est l’endroit où l’interpolant doit être évalué

xp = np.array([0.0, 1.0, 2.0, 3.0])
fp = np.array([10.0, 20.0, 25.0, 30.0])
x  = np.array([0.5, 1.5, 2.5])

np.interp(x, xp, fp)
# array([15.0, 22.5, 27.5])

En dehors de la plage [xp[0], xp[-1]], le résultat est écrêté à fp[0] et fp[-1] respectivement ; les mots-clés left= et right= remplacent ces extrémités.

Utilisé sur la caméra pour remapper une table d’étalonnage vers des positions d’échantillon arbitraires – une table température-tension d’une thermistance, une courbe de réponse de pixel non linéaire, une table de correspondance gamma par canal. Un seul appel de bibliothèque, un seul passage sur les entrées, aucune boucle Python.

6.16.2. Ajustement et évaluation polynomiaux

polyfit() ajuste un polynôme de degré deg aux points de données (x, y) par moindres carrés et renvoie les coefficients (le plus haut degré en premier)

x = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
y = np.array([0.0, 1.1, 3.9, 9.1, 15.8])

coeffs = np.polyfit(x, y, 2)
# array([1.0, 0.0, 0.0])  (approximately)

Lorsque x est omis, range(len(y)) est utilisé – utile pour ajuster rapidement un polynôme à un tampon échantillonné régulièrement sans axe x associé

np.polyfit(y, 2)

polyval() évalue le polynôme dont les coefficients sont p en x. L’entrée x peut être un scalaire (renvoie un flottant) ou un ndarray (renvoie un ndarray)

p = np.polyfit(x, y, 2)
fitted = np.polyval(p, x)

L’association naturelle consiste à appeler polyfit une seule fois au moment de l’étalonnage, à stocker les coefficients, puis à appeler polyval pour évaluer la courbe résultante à chaque trame. L’étape d’évaluation du polynôme représente une poignée d’opérations flottantes par échantillon, ce qui est peu coûteux même sur les plus petites caméras.

6.16.3. Convolution

convolve() renvoie la convolution linéaire discrète de longueur complète de deux tableaux 1-D. Seul le mode full est implémenté ; la longueur de sortie est len(a) + len(v) - 1. Découpez le résultat pour obtenir le même effet que les modes same et valid qu’offre le numpy de bureau

a = np.array([1.0, 2.0, 3.0])
v = np.array([0.5, 0.5])

np.convolve(a, v)
# array([0.5, 1.5, 2.5, 1.5])

Utile pour les filtres FIR courts et les noyaux de lissage (boîte, triangle, gaussien) où la mise en place d’une chaîne SOS serait excessive. Le temps d’exécution est proportionnel au produit des longueurs des deux tableaux – convenable pour des noyaux courts mais devenant rapidement plus coûteux qu’une convolution par FFT pour les longs.

6.16.4. Intégration trapézoïdale

trapz() intègre une fonction échantillonnée par la règle trapézoïdale composite

x = np.linspace(0, np.pi, num=128)
y = np.sin(x)
np.trapz(y, x)             # ~ 2.0

Passez dx= lorsque l’espacement des échantillons est uniforme et que seul le pas importe ; passez x= lorsque les échantillons ne sont pas régulièrement espacés. C’est l’appel approprié pour intégrer des données de capteur déjà acquises, lorsque la forme analytique n’est pas disponible.

Pour des données d’échantillon à bande limitée (un tampon audio après un filtre anti-repliement, par exemple), la règle trapézoïdale converge comme le carré du nombre d’échantillons, ce qui signifie que doubler la longueur du tampon réduit l’erreur d’un facteur quatre.

Lorsque l’intégrande n’est pas un tampon d’échantillons mais une fonction Python que l’application peut évaluer en des points arbitraires, une famille différente de solveurs est l’appel approprié.