Opencv-objecten volgen: 3 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Detectie van bewegende objecten is een techniek die wordt gebruikt in computervisie en beeldverwerking. Meerdere opeenvolgende frames van een video worden op verschillende manieren vergeleken om te bepalen of er een bewegend object is gedetecteerd.

Detectie van bewegende objecten is gebruikt voor een breed scala aan toepassingen, zoals videobewaking, activiteitsherkenning, bewaking van de toestand van de weg, veiligheid op luchthavens, bewaking van bescherming langs zeegrenzen en dergelijke.

Detectie van bewegende objecten is het herkennen van de fysieke beweging van een object op een bepaalde plaats of regio.[2] Door segmentatie tussen bewegende objecten en een stationair gebied of gebied te bewerkstelligen, zou de beweging van bewegende objecten kunnen worden gevolgd en dus later kunnen worden geanalyseerd. Om dit te bereiken, moet u ervan uitgaan dat een video een structuur is die is opgebouwd uit enkele frames. Detectie van bewegende objecten is het vinden van bewegende doelen op de voorgrond, hetzij in elk videoframe, hetzij alleen wanneer het bewegende doel voor het eerst in de video verschijnt.

Ik ga de combinatie Opnecv en Python gebruiken om de objecten te detecteren en te volgen op basis van de kleur

Stap 1: Een rechthoek tekenen op het herkende object

als uw pc geen python of opencv heeft, volg dan onderstaande instructies:

hier is de python-code:

import cv2import numpy als np

cap = cv2. VideoCapture(0)

terwijl waar:

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

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

upper_yellow = np.array([40, 255, 255])

yellow_mask = cv2.inRange(hsv, lower_yellow, upper_yellow)

(_, contouren, _) = cv2.findContours(yellow_mask, cv2. RETR_TREE, cv2. CHAIN_APPROX_SIMPLE)

voor contour in contouren:

area = cv2.contourArea(contour)

als (gebied > 800):

x, y, w, h = cv2.boundingRect(contour) frame = cv2.rechthoek(frame, (x, y), (x+w, y+h), (0, 0, 255), 10)

cv2.imshow("volgen", frame)

k = cv2.waitKey(5) & 0XFF

als k == 27: pauze

cv2.destroyAllWindows()

cap.release()

Stap 2: Traceer het pad waarin het object is verplaatst

om het pad te volgen:

voor i in range(1, len(center_points)): b = willekeurig.randint(230, 255) g = willekeurig.randint(100, 255) r = willekeurig.randint(100, 255) if 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)

Stap 3: Integratie van beide codes

ik ga de beide code integreren

import cv2import numpy als np willekeurig importeren uit collecties import deque

cap = cv2. VideoCapture(1)

# Om alle punten bij te houden waar het object center_points = deque() heeft bezocht

terwijl waar:

# Lees en spiegel frame _, frame = cap.read() frame = cv2.flip(frame, 1)

# Vervaag het kader een beetje

blur_frame = cv2. Gaussiaans vervagen(frame, (7, 7), 0)

# Converteer van BGR naar HSV-kleurformaat

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

# Definieer het onderste en bovenste bereik van de hsv-kleur om te detecteren. Blauw hier

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

# Maak een elliptische kernel

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

# Opening morph (erosie gevolgd door dilatatie)

mask = cv2.morphologyEx(masker, cv2. MORPH_OPEN, kernel)

# Vind alle contouren

contouren, hiërarchie = cv2.findContours(mask.copy(), cv2. RETR_LIST, cv2. CHAIN_APPROX_SIMPLE)[-2:]

als len(contouren) > 0:

# Zoek de grootste contour grootste_contour = max(contours, key=cv2.contourArea)

# Vind het middelpunt van de contour en teken een gevulde cirkel

momenten = cv2.moments(grootste_contour) center_of_contour = (int(momenten['m10'] / momenten['m00']), int(momenten['m01'] / momenten['m00'])) cv2.circle(frame, center_of_contour, 5, (0, 0, 255), -1)

# Begrens de contour met cirkel

ellips = cv2.fitEllipse(grootste_contour) cv2.ellipse(frame, ellips, (0, 255, 255), 2)

# Sla het middelpunt van de contour op zodat we een lijn volgen die het volgt

center_points.appendleft(center_of_contour)

# Trek een lijn vanuit de middelpunten van de contour

voor i in range(1, len(center_points)): b = willekeurig.randint(230, 255) g = willekeurig.randint(100, 255) r = willekeurig.randint(100, 255) if 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('origineel', frame)

cv2.imshow('masker', masker)

k = cv2.waitKey(5) & 0xFF

als k == 27: pauze

cv2.destroyAllWindows()

cap.release()