Rastreamento de objeto Opencv: 3 etapas

2025 Autor: John Day | [email protected]. Última modificação: 2025-01-23 15:03

A detecção de objetos em movimento é uma técnica usada em visão computacional e processamento de imagens. Vários quadros consecutivos de um vídeo são comparados por vários métodos para determinar se algum objeto em movimento é detectado.

A detecção de objetos em movimento tem sido usada para uma ampla gama de aplicações, como vigilância por vídeo, reconhecimento de atividades, monitoramento de condições de estradas, segurança de aeroportos, monitoramento de proteção ao longo da fronteira marítima e etc.

A detecção de objetos em movimento é reconhecer o movimento físico de um objeto em um determinado lugar ou região. [2] Ao atuar a segmentação entre os objetos em movimento e a área ou região estacionária, o movimento dos objetos em movimento poderia ser rastreado e, portanto, analisado posteriormente. Para conseguir isso, considere que um vídeo é uma estrutura construída sobre quadros únicos, a detecção de objeto em movimento é encontrar o (s) alvo (s) móvel (is) em primeiro plano, em cada quadro de vídeo ou apenas quando o alvo em movimento mostra a primeira aparição no vídeo.

Vou usar a combinação Opnecv e Python para detectar e rastrear os objetos com base na cor

Etapa 1: desenhando um retângulo no objeto reconhecido

se o seu pc não tem python ou opencv, siga as instruções abaixo

aqui está o código python:

import cv2import numpy como np

cap = cv2. VideoCapture (0)

enquanto verdadeiro:

_, frame = cap.read () hsv = cv2.cvtColor (frame, cv2. COLOR_BGR2HSV)

amarelo_inferior = np.array ([20, 110, 110])

amarelo superior = np.array ([40, 255, 255])

amarela_mascara = cv2.inRange (hsv, inferior_amarelo, superior_amarelo)

(_, contornos, _) = cv2.findContours (amarelo_mascara, cv2. RETR_TREE, cv2. CHAIN_APPROX_SIMPLE)

para contorno em contornos:

area = cv2.contourArea (contour)

se (área> 800):

x, y, w, h = cv2.boundingRect (contorno) quadro = cv2.rectangle (quadro, (x, y), (x + w, y + h), (0, 0, 255), 10)

cv2.imshow ("rastreamento", quadro)

k = cv2.waitKey (5) & 0XFF

se k == 27: quebrar

cv2.destroyAllWindows ()

cap.release ()

Etapa 2: trace o caminho no qual o objeto foi movido

para rastrear o caminho:

para i no intervalo (1, len (pontos_centrais)): b = random.randint (230, 255) g = random.randint (100, 255) r = random.randint (100, 255) se math.sqrt (((center_points [i - 1] [0] - center_points [0]) ** 2) + ((center_points [i - 1] [1] - center_points [1]) ** 2)) <= 50: cv2.line (frame, center_points [i - 1], center_points , (b, g, r), 4)

Etapa 3: Integrando Ambos os Códigos

vou integrar os dois o código

importar cv2import numpy como np importar aleatório de coleções import deque

cap = cv2. VideoCapture (1)

# Para manter o controle de todos os pontos onde o objeto visitou center_points = deque ()

enquanto verdadeiro:

# Ler e virar quadro _, quadro = cap.read () quadro = cv2.flip (quadro, 1)

# Desfoque um pouco a moldura

blur_frame = cv2. GaussianBlur (frame, (7, 7), 0)

# Converter do formato de cor BGR para HSV

hsv = cv2.cvtColor (blur_frame, cv2. COLOR_BGR2HSV)

# Defina a faixa inferior e superior da cor hsv a ser detectada. Azul aqui

lower_blue = np.array ([100, 50, 50]) upper_blue = np.array ([140, 255, 255]) máscara = cv2.inRange (hsv, lower_blue, upper_blue)

# Faça um kernel elíptico

kernel = cv2.getStructuringElement (cv2. MORPH_ELLIPSE, (15, 15))

# Morfologia de abertura (erosão seguida de dilatação)

máscara = cv2.morphologyEx (máscara, cv2. MORPH_OPEN, kernel)

# Encontre todos os contornos

contours, hierarchy = cv2.findContours (mask.copy (), cv2. RETR_LIST, cv2. CHAIN_APPROX_SIMPLE) [- 2:]

se len (contornos)> 0:

# Encontre o maior contorno maior_contour = max (contours, key = cv2.contourArea)

# Encontre o centro do contorno e desenhe um círculo preenchido

momentos = cv2.moments (maior_contorno) centre_of_contour = (int (momentos ['m10'] / momentos ['m00']), int (momentos ['m01'] / momentos ['m00'])) cv2.circle (quadro, centre_of_contour, 5, (0, 0, 255), -1)

# Limite o contorno com um círculo

elipse = cv2.fitEllipse (maior_contorno) cv2.ellipse (quadro, elipse, (0, 255, 255), 2)

# Salve o centro do contorno para que possamos traçar a linha de rastreamento

center_points.appendleft (centre_of_contour)

# Desenhe uma linha a partir dos pontos centrais do contorno

para i no intervalo (1, len (pontos_centrais)): b = random.randint (230, 255) g = random.randint (100, 255) r = random.randint (100, 255) se math.sqrt (((center_points [i - 1] [0] - center_points [0]) ** 2) + ((center_points [i - 1] [1] - center_points [1]) ** 2)) <= 50: cv2.line (frame, center_points [i - 1], center_points , (b, g, r), 4)

cv2.imshow ('original', quadro)

cv2.imshow ('máscara', máscara)

k = cv2.waitKey (5) & 0xFF

se k == 27: quebrar

cv2.destroyAllWindows ()

cap.release ()