Analyse des rainures de pneu avec l'intelligence artificielle en Python !

L'analyse de la bande de roulement des pneus est une tâche cruciale pour identifier l'usure et garantir la sécurité, en particulier dans les véhicules qui parcourent de longues distances. Grâce à l'intelligence artificielle (IA) et à Python, nous pouvons automatiser ce processus de manière rapide et précise. Ici, nous montrons comment un modèle de réseau neuronal convolutif (CNN), basé sur l'architecture VGG16, classe les pneus en « neufs » ou « d'occasion », tandis qu'OpenCV permet d'analyser les images pour mesurer la profondeur de la bande de roulement.

Technologies utilisées

• Python :
  Langage de programmation populaire pour l'IA et l'apprentissage automatique, notamment pour ses bibliothèques avancées.

• OpenCV :
  Utilisé pour traiter les images, détecter les contours et mesurer la surface de la bande de roulement des pneus.

• TensorFlow et Keras :
  Bibliothèques d'apprentissage profond. Nous utilisons Keras pour travailler avec le modèle VGG16, un CNN pré-entraîné pour la reconnaissance d'images.

• Matplotlib :
  Bibliothèque pour la visualisation de données et la création de graphiques, rendant les résultats de classification plus interprétables.

Code :

1. Charger et prétraiter les images :
Les images de pneus sont téléchargées et redimensionnées dans un format standard (150 x 150 pixels) requis pour la saisie du modèle. Ce redimensionnement maintient le rapport hauteur/largeur et normalise les valeurs de pixels entre 0 et 1 pour faciliter le traitement du modèle.

import cv2
import numpy as np
from tensorflow.keras.applications.vgg16 import preprocess_input

def process_image(image_path, target_size=(150, 150)):
    image = cv2.imread(image_path)
    if image is None:
        print(f"Erro ao carregar a imagem: {image_path}. Verifique o caminho e a integridade do arquivo.")
        return None, None

    image_resized = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)
    image_array = np.array(image_resized) / 255.0  
    image_array = np.expand_dims(image_array, axis=0)
    image_preprocessed = preprocess_input(image_array)

    return image_resized, image_preprocessed

2. Classification avec le modèle entraîné :
Nous avons chargé un modèle de réseau neuronal convolutif pré-entraîné, qui a été affiné pour classer les pneus comme « neufs » ou « utilisés ». Ce modèle fournit un score de confiance qui indique la probabilité qu'un pneu soit neuf.

from tensorflow.keras.models import load_model

model = load_model('pneu_classificador.keras')
prediction = model.predict(image_preprocessed)

3. Analyse de contour pour la profondeur de rainure :
La détection de la profondeur des rainures est réalisée à l'aide de techniques de vision par ordinateur. L'image en niveaux de gris passe par un filtre de flou et une détection des bords Canny, qui permet d'identifier les contours des rainures. On calcule ensuite la surface totale des contours, ce qui permet d'estimer l'usure.

def detect_tread_depth(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, 30, 100)
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    total_area = sum(cv2.contourArea(c) for c in contours if cv2.contourArea(c) > 100)
    return total_area

4. Visualisation et analyse des résultats :
Après avoir classé et analysé chaque pneu, les résultats sont affichés avec Matplotlib. Nous avons comparé le score de confiance de classification et la zone de sillon détectée dans chaque image.

import matplotlib.pyplot as plt

confidence_scores = []
total_area_green_values = []
predicted_classes = []

for image_file in os.listdir(ver_dir):
    image_path = os.path.join(ver_dir, image_file)
    image_resized, image_preprocessed = process_image(image_path)
    if image_preprocessed is not None:
        prediction = model.predict(image_preprocessed)
        confidence_score = prediction[0][0]
        total_area_green = detect_tread_depth(image_resized)

        predicted_class = "novo" if total_area_green > 500 else "usado"
        confidence_scores.append(confidence_score)
        total_area_green_values.append(total_area_green)
        predicted_classes.append(predicted_class)

        plt.imshow(cv2.cvtColor(image_resized, cv2.COLOR_BGR2RGB))
        plt.title(f"Pneu {predicted_class} (Área: {total_area_green:.2f}, Confiança: {confidence_score:.2f})")
        plt.axis('off')
        plt.show()

fig, axs = plt.subplots(2, 1, figsize=(10, 10))

axs[0].bar(os.listdir(ver_dir), confidence_scores, color='skyblue')
axs[0].set_title('Confiança na Classificação')
axs[0].set_ylim(0, 1)
axs[0].tick_params(axis='x', rotation=45)

axs[1].bar(os.listdir(ver_dir), total_area_green_values, color='lightgreen')
axs[1].set_title('Área Verde Detectada')
axs[1].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.show()

Ce projet montre comment il est possible d'automatiser l'analyse de l'usure des pneus à l'aide de l'IA et de la vision par ordinateur, ce qui permet d'obtenir une classification précise et rapide. L'architecture VGG16 et l'utilisation d'OpenCV sont essentielles pour combiner la précision du modèle de réseau neuronal avec l'analyse visuelle des sillons. Ce système peut être étendu pour une surveillance continue des flottes de véhicules, contribuant ainsi à réduire les accidents et à optimiser la gestion des pneus.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!