On étudie le verdissement des endives en fonction des longueurs d'ondes pour notre TIPE. On voudrait un graphique avec le nombre de pixel en fonction de l'intensité de vert.
PB:- le vert dépend aussi des autres composantes rouge et bleue
- si on essaye de seuiller sur IMAGEJ les ombres de l'endive sont aussi compté
On a essayé python et ImageJ sans succès. On prend toute solution pour le traitement d'images
Merci aux âmes charitables qui nous aideront.♥♥

import cv2
import numpy as np
import matplotlib.pyplot as plt
from skimage import color

1. Charger l'image

image = cv2.imread('chemin_vers_votre_image.jpg')

1. Convertir de BGR à RGB (OpenCV charge en BGR par défaut)

image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

1. 1. Créer un masque pour isoler l'endive et exclure l'arrière-plan
2. Convertir en HSV pour un meilleur seuillage

image_hsv = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2HSV)

1. Définir les bornes pour la détection de l'endive (à ajuster selon vos images)

lower_bound = np.array([0, 0, 100]) # Valeurs HSV minimales
upper_bound = np.array([180, 70, 255]) # Valeurs HSV maximales
mask = cv2.inRange(image_hsv, lower_bound, upper_bound)

1. Appliquer le masque pour obtenir uniquement l'endive

endive_only = cv2.bitwise_and(image_rgb, image_rgb, mask=mask)

1. 2. Extraire l'intensité de vert indépendamment des autres composantes
2. Conversion en espace LAB où 'a' représente l'axe vert-rouge

image_lab = color.rgb2lab(endive_only)

1. Extrait le canal 'a' (négatif = vert, positif = rouge)

green_red_channel = image_lab[:,:,1]

1. Inverser pour que les valeurs plus élevées représentent plus de vert

green_intensity = -1 * green_red_channel

1. Normaliser entre 0 et 255

green_intensity = np.clip(green_intensity, 0, None) # Éliminer les valeurs négatives
green_intensity_normalized = ((green_intensity - green_intensity.min()) /
(green_intensity.max() - green_intensity.min())) * 255

1. 3. Créer l'histogramme des intensités de vert (seulement pour les pixels de l'endive)

flat_green = green_intensity_normalized[mask > 0].flatten()
hist, bins = np.histogram(flat_green, bins=256, range=(0, 256))

1. 4. Visualiser les résultats

plt.figure(figsize=(15, 10))

1. Image originale

plt.subplot(2, 2, 1)
plt.imshow(image_rgb)
plt.title('Image originale')
plt.axis('off')

1. Masque de l'endive

plt.subplot(2, 2, 2)
plt.imshow(mask, cmap='gray')
plt.title('Masque de l\'endive')
plt.axis('off')

1. Intensité de vert

plt.subplot(2, 2, 3)
plt.imshow(green_intensity_normalized, cmap='Greens')
plt.title('Intensité de vert')
plt.axis('off')

1. Histogramme

plt.subplot(2, 2, 4)
plt.bar(bins[:-1], hist, width=1, color='green')
plt.title('Nombre de pixels en fonction de l\'intensité de vert')
plt.xlabel('Intensité de vert (0-255)')
plt.ylabel('Nombre de pixels')

plt.tight_layout()
plt.savefig('resultats_verdissement_endive.png', dpi=300)
plt.show()

Attention c'est une réponse IA.

Utilisation de l'espace colorimétrique LAB: Le canal 'a' dans cet espace représente l'axe vert-rouge indépendamment de la luminosité, ce qui aide à isoler la composante verte sans être influencé par les ombres.
Création d'un masque: Pour isoler l'endive de l'arrière-plan et ne mesurer que les pixels pertinents.
Normalisation: Pour obtenir une mesure cohérente de l'intensité du vert.

Vous devrez ajuster les paramètres lower_bound et upper_bound du masque en fonction de vos images spécifiques. Si vous avez des images de référence ou un arrière-plan standardisé, le masquage devrait fonctionner de manière fiable.