Support de Cours Class MPSI 2 & 3
1/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
Partie 1 – NumPy : le cœur du calcul numérique
1.1 Création de tableaux (ndarray)
Fonction Rôle Exemple extrait de classe
[Link]([...]) Tableau 1D/2D à partir d’une liste A = [Link]([[2,3],[54,True]])
[Link](début, fin, pas) Suite arithmétique (intervalle semi-ouvert [début, fin[) B = [Link](10, 20, 0.5)
[Link](début, fin, n) n points uniformément répartis (intervalle fermé [début, fin]) X = [Link](1, 10, 100)
[Link]((m,n)) Matrice remplie de 1 A = [Link]((n,n))
[Link]((m,n)) Matrice remplie de 0 A = [Link]((4,4))
[Link](n, k=...) Matrice avec une diagonale de 1 ; k décale la diagonale [Link](4, k=-1) (sous-diagonale)
[Link](n) Matrice identité (diagonale principale) 3 * [Link](2)
[Link]([...]) Matrice diagonale à partir d’une liste [Link]([1,2,3,4])
Point de vigilance : arange et linspace ne donnent pas le même résultat de fin : - [Link](10, 20, 0.5) s’arrête avant 20. -
[Link](10, 19.5, 20) atteint exactement 19.5.
Type des éléments (dtype) :
A = [Link]([2, 3, 54, True], dtype=int) # force la conversion
A = [Link]([3, 2, 1], dtype=complex) # 3.+0.j, 2.+0.j, 1.+0.j
print([Link]) # affiche le type interne
1.2 Informations et propriétés d’un tableau
a = [Link]([[1, 2, 3, 4], [5, 6, 7, 8]])
print([Link]) # (2, 4) → tuple (lignes, colonnes)
print([Link]) # 2 → nombre de dimensions
print([Link]) # 8 → nombre total d'éléments
print(2 in a) # True → appartenance (testé sur le tableau aplati)
print([Link]()) # [1, 6] → diagonale principale
Support de Cours Class MPSI 2 & 3
2/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
Statistiques rapides (terme à terme ou globales) :
[Link]() # somme de tous les éléments
[Link]() # moyenne
[Link]() / [Link]() # extrema
[Link]() # indice (dans le tableau aplati) du minimum
[Link]() # indice du maximum
1.3 Opérations sur les tableaux
Arithmétique élémentaire (vectorisée)
Toutes les opérations +, -, *, /, ** se font terme à terme (broadcasting).
3 * [Link](2) # multiplication scalaire
A + [Link]((2,2)) # addition terme à terme
# ATTENTION : * n'est PAS le produit matriciel
Produit scalaire & matriciel
# Produit scalaire (vecteurs)
[Link]([Link]([1, 2]), [Link]([3, 4])) # 11
# Produit matriciel (opérateur moderne « @ » ou [Link])
A = [Link]([[0, -1], [1, 0]]) ; B = [Link]([[2], [1]])
C = A @ B # ou [Link](A, B) ➔ Résultat : [[-1], [2]]
Opérations logiques (masques booléens)
a = [Link]([[2, -6], [1, 3]])
mask = (a > 1) # tableau de booléens
print([Link]()) # False → tous True ?
print([Link]()) # True → au moins un True ?
# Sélection d'éléments
print(a[a >= 6]) # array([6, 9]) → filtrage direct
Support de Cours Class MPSI 2 & 3
3/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
1.4 Manipulation de la forme
a = [Link]([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
[Link]((3, 4)) # 3 lignes, 4 colonnes : Redimensionnement (le nombre total d'éléments doit être conservé)
[Link]() # array([1,2,3,...,12]) ➔ Aplatir en 1D
[Link]() # ou a.T ➔ Transposition
1.5 Copie de tableau (piège classique)
a = [Link]([[1, 2], [3, 4]])
b = a # b pointe vers LE MÊME objet
b[0, 0] = 999 # a est aussi modifié !
# Solution : copie indépendante
c = [Link]() # c est un nouveau tableau en mémoire
1.6 Accès, modification et slicing (sous-tableaux)
a = [Link]([1, 2, 3, 4])
ligne = a[0] # Extraction de la première ligne → array([1,0,0,0])
colonne = a[:, 2] # Extraction de la troisième colonne → array([0,0,3,0])
plage = a[0:3, 1:] # Extraction des lignes 0 à 2, colonnes 1 à fin
# Modification par slice
a[:, 1] = 9 # toute la colonne 1 devient 9
a[:2, -2:] = 7 # coins supérieur-droite = 7
1.7 Algèbre linéaire ([Link])
A = [Link]([[1/3, 0], [0, 3]])
[Link](A) # Déterminant → 1.0
[Link](A) # Inverse → [[3, 0], [0, 1/3]]
[Link]([3, 4]) # Norme euclidienne → 5.0
# Valeurs & vecteurs propres
val, vec = [Link](A) # val : valeurs propres (array) | vec : vecteurs propres normés en COLONNES
T = [Link](A) # ou [Link]() # (somme diagonale)
Erreur fréquente : [Link] lève LinAlgError: Singular matrix si le déterminant est nul (matrice non inversible).
Support de Cours Class MPSI 2 & 3
4/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
Partie 2 – Matplotlib : visualisation scientifique
2.1 Tracé de base ([Link])
import numpy as np
import [Link] as plt
X = [Link](-[Link], [Link], 50)
Y = [Link](X) ; Z = [Link](X)
[Link](X, Y, '--', color='red', label="sin(x)", lw=2)
[Link](X, Z, label="cos(x)") # style par défaut
[Link]("Fonctions trigonométriques")
[Link](loc="upper left") # ou "lower left", etc.
[Link]() # quadrillage
[Link]()
Paramètres essentiels de [Link] : - color ou c : "red", "tab:olive", "#FF5733" - linewidth ou lw : épaisseur du trait -
linestyle : "-" (solide), "--" (tirets), "-.", ":" - marker : "o", "s" (carré), "^" (triangle), "D" (losange), "x", "*" -
markeredgewidth : épaisseur du contour du marqueur
2.2 Divers types de tracés vus en classe
Fonction Rendu Exemple de classe
[Link]() Ligne continue [Link](X, Y, "-Dg", color="red")
[Link]() Nuage de points [Link](X, Z, color="magenta", lw=2)
[Link]() Diagramme en barres [Link](X, Y, linewidth=2)
[Link]() Bâtons (lollipop) [Link](X, Z)
Support de Cours Class MPSI 2 & 3
5/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
2.3 Subplots (figures multiples)
Méthode [Link] (interface rapide)
# [Link](nrows, ncols, index)
[Link](2, 3, 1) # grille 2×3, case n°1
[Link](x, y1)
[Link](2, 3, (1, 2)) # case 1 ET 2 fusionnées (tuple)
[Link](x, y2)
[Link](2, 3, 3) ; [Link](x, y3)
[Link](2, 1, 2) ; [Link](x, y4)# ligne inférieure entière (cases 4,5,6 fusionnées sur 2×3)
Méthode objet [Link] (plus rigoureuse)
fig, ax = [Link](2, 2) # grille 2×2 d'objets Axes
ax[0, 0].plot(X, Y) ; ax[0, 0].set_title("Sinus")
ax[1, 1].set(xlim=(0, 8), xticks=[Link](1, 8),
ylim=(0, 8), yticks=[Link](1, 8))
2.4 Personnalisation avancée des axes
[Link](1.0, 11.0) # bornes en x
[Link](-1.0, 120.0) # bornes en y
[Link]([Link](1, 11, 21)) # graduations personnalisées
[Link]([Link](-1, 1.1, 0.2))
2.5 Sauvegarde et rendu
[Link]("mon_graphique.png", dpi=300) # haute résolution
[Link]("[Link]", dpi=300) # format JPEG accepté
[Link]() # affichage interactif
Ordre important : savefig doit être appelé avant show() si vous utilisez certains backends, sinon le fichier peut être vide.
Support de Cours Class MPSI 2 & 3
6/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
2.6 Tracés 3D
fig, ax = [Link](subplot_kw={"projection": "3d"})
[Link](X, Y, Z, "-o", color="blue", lw=2) ; [Link]()
Partie 3 – Traitement d’images par tableau
3.1 Lecture / Écriture d’images
import [Link] as plt
import numpy as np
# Chargement → tableau NumPy de type uint8 (H, L, 3) ou (H, L, 4)
img = [Link]("[Link]") ; im = [Link](img, dtype=np.uint8)
print([Link]) # (hauteur, largeur, profondeur) ex: (1080, 1920, 3)
# Sauvegarde
[Link]("[Link]", im)
Structure interne : - im[i, j] → pixel à la ligne i, colonne j - im[i, j, 0] → composante R (rouge) - im[i, j, 1] → composante
G (vert) - im[i, j, 2] → composante B (bleu) - Les valeurs sont dans [0, 255] pour uint8.
3.2 Transformations géométriques (par slicing)
h, w, d = [Link]
oldRegion = im[100:-100, 100:-100]# Recadrage (crop) : retire 100 px de chaque bord
im = im[::-1, :, :] # Flip vertical (miroir horizontal) : inverse l'ordre des lignes
im = im[:, ::-1, : ] # Flip horizontal (miroir vertical)
im = [Link]((1, 0, 2)) # Transposition (rotation 90° + flip) : échange lignes et colonnes
im = 255 – im # Inversion des couleurs (négatif)
Support de Cours Class MPSI 2 & 3
7/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
3.3 Transformations de couleur
Niveaux de gris (méthode rapide – moyenne)
# Méthode 1 : moyenne des 3 canaux
avg = [Link](axis=2, dtype=int) # tableau 2D (H, L)
img_gris = [Link](avg, 3, axis=1).reshape([Link])
# ou simplement : [Link](avg, cmap='gray')
Niveaux de gris (méthode pondérée – luminance)
# Méthode 2 : pondération physiologique (meilleure perception)
weights = [Link]([0.299, 0.587, 0.114])
gris = [Link](im[..., :3], weights).astype(np.uint8)
Filtrage d’un canal RGB
# Garder uniquement le rouge
imR = [Link]() ; imR[:, :, 1 : ] = 0 # annule le vert et le bleu
# Saturer un canal
im[:, :, 0] = 255 # rouge à fond sur toute l'image
Détection de couleur dominante (exemple vu en classe)
for i in range(h):
for j in range(w):
r, g, b = im[i, j]
if not (r > 1.1*b and r > 1.1*g): # si ce n'est pas "rouge"
avg = (int(r)+int(g)+int(b))//3
im[i, j] = [avg, avg, avg] # griser le pixel
3.4 Convolution 2D (cœur du filtrage)
Le principe vu en classe : pour chaque pixel, on multiplie son voisinage par un noyau (kernel) et on somme.
Support de Cours Class MPSI 2 & 3
8/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
def convolve2d(image, kernel):
output = np.zeros_like(image) ; kh, kw = [Link] ; pad_h, pad_w = kh // 2, kw // 2
padded = [Link](image, ((pad_h, pad_h), (pad_w, pad_w)), mode='edge')
for y in range([Link][0]):
for x in range([Link][1]):
region = padded[y:y+kh, x:x+kw]
output[y, x] = [Link](region * kernel)
return output
Noyaux classiques :
Filtre Noyau 3×3 Effet
Moyenne (box blur) [Link]((k,k))/(k*k) Flou uniforme
Laplacien [[0,1,0],[1,-4,1],[0,1,0]] Détection de contours (zones de fort changement d’intensité)
Sobel X [[-1,0,1],[-2,0,2],[-1,0,1]] Contours verticaux
Sobel Y [[1,2,1],[0,0,0],[-1,-2,-1]] Contours horizontaux
3.5 Flou (blur) – application locale
def blur_region(img, x1, y1, x2, y2, kernel_size=5):
region = img[y1:y2, x1:x2].copy() ; pad = kernel_size // 2
blurred_region = np.zeros_like(region)
for y in range(pad, [Link][0]-pad):
for x in range(pad, [Link][1]-pad):
voisinage = region[y-pad:y+pad+1, x-pad:x+pad+1]
blurred_region[y, x] = [Link](axis=(0,1))
img_blur = [Link]()
img_blur[y1:y2, x1:x2] = blurred_region
return img_blur
Support de Cours Class MPSI 2 & 3
9/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
3.6 Détection de contours (Sobel)
sobel_x = [Link]([[-1,0,1], [-2,0,2], [-1,0,1]]) ; sobel_y = [Link]([[ 1, 2, 1], [ 0, 0, 0], [-1,-2,-1]])
grad_x = convolve2d(gray_img, sobel_x) ; grad_y = convolve2d(gray_img, sobel_y)
magnitude = [Link](grad_x**2 + grad_y**2)
# Seuillage pour obtenir une image binaire
contours = (magnitude > 50).astype(np.uint8) * 255
3.7 Détection de flou (métrique de netteté)
Principe : une image nette possède beaucoup de contours (variance élevée du Laplacien). Une image floue a une variance faible.
def is_blurred(gray_img, threshold=100):
kernel = [Link]([[0, 1, 0],
[1, -4, 1],
[0, 1, 0]])
laplacian = convolve2d(gray_img, kernel)
return [Link](laplacian) < threshold # True si floue
Fiche réflexe – Erreurs classiques à l’examen
Erreur Conséquence Correction
b = a (sans .copy()) b modifie aussi a b = [Link]()
[Link](10, 20, 0.5) pensé fermé manque la dernière valeur utiliser linspace pour une borne exacte
A * B pour matrices produit terme à terme utiliser A @ B ou [Link](A,B)
[Link]() avant savefig fichier vide inverser l’ordre
Oublier dtype=np.uint8 après calcul valeurs hors [0,255] ou type float [Link](img, 0, 255).astype(np.uint8)
Confondre h, w et w, h dans le slice forme inversée img[y1:y2, x1:x2] : lignes puis colonnes
Modifier im sans copie destruction de l’original im2 = [Link]() avant traitement
Support de Cours Class MPSI 2 & 3
10/10
~numpy, matplotlib et traitement d’images – Pr. M. Naoum
Index des fonctions du programme
NumPy – Création & Manipulation
[Link], [Link], [Link], [Link], [Link], [Link], [Link], [Link], .shape, .reshape, .flatten,
.transpose, .copy, .fill, [Link]
NumPy – Calcul & Logique
+, -, *, /, @, [Link], np.logical_and, np.logical_or, np.logical_not, >, <, ==, .all(), .any(), .sum(), .mean(), .min(),
.max(), .argmin(), .argmax()
NumPy – Algèbre linéaire ([Link])
[Link], [Link], [Link], [Link], [Link]
Matplotlib – Tracés
[Link], [Link], [Link], [Link], [Link], [Link], [Link], [Link], [Link], [Link], [Link],
[Link], [Link], [Link]
Traitement d’images
[Link], [Link], slicing [:, :], 255 - im, .mean(axis=2), [Link], .reshape, .transpose, .copy, [Link],
convolution manuelle, noyaux Sobel / Laplace / moyenne
Bonne révision ! Ce support couvre l’intégralité des exemples étudiés en séance. Pour s’entraîner efficacement, il est
recommandé de reproduire les scripts [Link], matplot_intro_mpsi.py et mpsi_Image_processing.py sans
regarder la correction, puis de comparer.