This content originally appeared on DEV Community and was authored by Alexandre Justen Filho
A análise de sulcos de pneus é uma tarefa crucial para identificar o desgaste e garantir a segurança, especialmente em veículos que percorrem longas distâncias. Com o uso de Inteligência Artificial (IA) e Python, podemos automatizar esse processo de maneira rápida e precisa. Aqui, mostramos como um modelo de rede neural convolucional (CNN), baseado na arquitetura VGG16, classifica pneus em "novos" ou "usados", enquanto o OpenCV ajuda a analisar as imagens para medir a profundidade dos sulcos.
Tecnologias Usadas
Python:
Linguagem de programação popular para IA e Machine Learning, especialmente por suas bibliotecas avançadas.OpenCV:
Usado para processar as imagens, detectar contornos e medir a área dos sulcos dos pneus.TensorFlow e Keras:
Bibliotecas de aprendizado profundo. Utilizamos o Keras para trabalhar com o modelo VGG16, uma CNN pré-treinada para reconhecimento de imagens.Matplotlib:
Biblioteca para visualização de dados e criação de gráficos, tornando os resultados da classificação mais interpretáveis.
Código:
1. Carregar e Pré-processar as Imagens:
As imagens dos pneus são carregadas e redimensionadas para um formato padrão (150x150 pixels) necessário para a entrada do modelo. Esse redimensionamento mantém a proporção e normaliza os valores dos pixels entre 0 e 1 para facilitar o processamento pelo modelo.
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. Classificação com o Modelo Treinado:
Carregamos um modelo de rede neural convolucional pré-treinado, que foi ajustado para classificar pneus como "novos" ou "usados". Esse modelo fornece uma pontuação de confiança que indica a probabilidade de um pneu ser novo.
from tensorflow.keras.models import load_model
model = load_model('pneu_classificador.keras')
prediction = model.predict(image_preprocessed)
3. Análise dos Contornos para Profundidade de Sulco:
A detecção da profundidade do sulco é realizada com técnicas de visão computacional. A imagem em escala de cinza passa por um filtro de borrão e pela detecção de bordas com Canny, o que ajuda a identificar contornos dos sulcos. Em seguida, calculamos a área total dos contornos, o que nos permite estimar o desgaste.
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. Visualização e Análise de Resultados:
Após a classificação e análise de cada pneu, os resultados são exibidos com Matplotlib. Comparamos a pontuação de confiança da classificação e a área dos sulcos detectada em cada imagem.
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()
Esse meu projeto demonstra como é possível automatizar a análise do desgaste de pneus utilizando IA e visão computacional, resultando em uma classificação precisa e rápida. A arquitetura VGG16 e o uso de OpenCV são fundamentais para combinar a precisão do modelo de rede neural com a análise visual dos sulcos. Esse sistema pode ser expandido para monitoramento contínuo em frotas de veículos, ajudando a reduzir acidentes e otimizar o gerenciamento de pneus.
This content originally appeared on DEV Community and was authored by Alexandre Justen Filho
Alexandre Justen Filho | Sciencx (2024-10-30T21:16:09+00:00) Análise de Sulco de Pneus com Inteligência Artificial em Python!. Retrieved from https://www.scien.cx/2024/10/30/analise-de-sulco-de-pneus-com-inteligencia-artificial-em-python/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.