Questo articolo è stato pubblicato nell'ambito del Blogathon sulla scienza dei dati
OpenCV è una libreria utilizzata per applicazioni di visione artificiale. Con l'aiuto di OpenCV, possiamo creare un numero enorme di applicazioni che funzionano meglio in tempo reale. Viene utilizzato principalmente per l'elaborazione di immagini e video.
Puoi ottenere maggiori informazioni su OpenCV qui (https://opencv.org/)
Insieme a OpenCV, useremo la libreria MediaPipe.
MediaPipe
MediaPipe è un framework che viene utilizzato principalmente per creare audio, video o dati di serie temporali. Con l'aiuto del framework MediaPipe, possiamo costruire pipeline davvero impressionanti per diverse funzioni di elaborazione dei media.
Alcune delle principali applicazioni di MediaPipe.
- Tracciamento multi-mano
- Riconoscimento facciale
- Rilevamento e tracciamento di oggetti
- Objectron: rilevamento e tracciamento di oggetti 3D
- Capovolgimento automatico: pipeline di ritaglio video automatico, eccetera.
Modelo de hito de mano
Fondamentalmente, MediaPipe utilizza un modello di rilevamento del palmo a colpo singolo e, una volta fatto, esegue una precisa localizzazione del punto chiave di 21 Coordinate 3D del palmo nella regione della mano rilevata.
La pipeline MediaPipe utilizza più modelli, come un modello di rilevamento del palmo che restituisce un riquadro di delimitazione orientato alla mano dall'intera immagine. La regione dell'immagine ritagliata viene inviata a un modello di riferimento palmare definito dal rilevatore di palmo e restituisce i punti chiave del palmare 3D ad alta fedeltà.
Ora implementiamo il modello di tracciamento della mano.
Installa i moduli necessari
-> pip instalar opencv-python
-> pip install mediapipe
Primo, Verifichiamo il funzionamento della webcam.
importa cv2
tempo di importazione
cap = cv2.VideoCapture(0)
pTime = 0
mentre vero:
successo, img = cap.read()
imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
cTime = tempo.tempo()
fps = 1 / (cTime - pTime)
pTime = cTime
cv2.putText(img, f'FPS:{int(fps)}', (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
cv2.imshow("Test", img)
cv2.waitKey(1))
Il codice sopra mostrerà un popup se c'è una webcam collegata al tuo PC e mostra anche i fotogrammi al secondo (fps) nell'angolo in alto a sinistra della finestra di output.
Ora iniziamo l'implementazione. Importa i moduli necessari e inizializza le variabili necessarie.
importa cv2 importa mediapipe come mp tempo di importazione
cap = cv2.VideoCapture(0)
mpHands = mp.solutions.hands
mani = mpHands.Hands(static_image_mode=Falso,
max_num_hands=2,
min_detection_confidence=0,5,
min_tracking_confidence=0,5)
mpDraw = mp.solutions.drawing_utils
pTime = 0
cTempo = 0
Nel frammento di codice sopra, dichiariamo un oggetto chiamato “mani” a partire dal mp.solutions.hand per rilevare le mani, predefinito, se guardi dentro la classe “Mani()“, Il numero di lancette da rilevare è impostato su 2, la confidenza minima di rilevamento è impostata su 0.5 e la confidenza minima di tracciamento è impostata su 0.5. E useremo mpDraw per disegnare i punti chiave.
Ora scriviamo un ciclo while per eseguire il nostro codice.
mentre vero:
successo, img = cap.read()
imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
risultati = mani.processo(imgRGB)
#Stampa(risultati.multi_hand_landmarks)
if results.multi_hand_landmarks:
per handLms in results.multi_hand_landmarks:
per identità, lm in enumerare(handLms.punto di riferimento):
#Stampa(ID,lm)
h, w, c = img.forma
cx, cy = int(lm.x *w), int(lm.y*h)
#se id ==0:
cv2.circle(img, (cx,cy), 3, (255,0,255), cv2.FILLED)
mpDraw.draw_landmarks(img, handLms, mpHands.HAND_CONNECTIONS)
cTime = tempo.tempo()
fps = 1/(cTime-pTime)
pTime = cTime
cv2.putText(img,str(int(fps)), (10,70), cv2.FONT_HERSHEY_PLAIN, 3, (255,0,255), 3)
cv2.imshow("Immagine", img)
cv2.waitKey(1)
Qui, nel codice sopra, leggiamo i frame della webcam e convertiamo l'immagine in RGB. Quindi rileviamo le mani nel telaio con l'aiuto di “mani.processo () " funzione. Una volta rilevate le mani, individueremo i punti chiave e quindi evidenzieremo i punti nei punti chiave utilizzando cv2.circle, e collega i punti chiave usando mpDraw.draw_landmarks.
Il codice completo è riportato di seguito
importa cv2 importa mediapipe come mp tempo di importazione
cap = cv2.VideoCapture(0)
mpHands = mp.solutions.hands
mani = mpHands.Hands(static_image_mode=Falso,
max_num_hands=2,
min_detection_confidence=0,5,
min_tracking_confidence=0,5)
mpDraw = mp.solutions.drawing_utils
pTime = 0
cTempo = 0
mentre vero:
successo, img = cap.read()
imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
risultati = mani.processo(imgRGB)
#Stampa(risultati.multi_hand_landmarks)
if results.multi_hand_landmarks:
per handLms in results.multi_hand_landmarks:
per identità, lm in enumerare(handLms.punto di riferimento):
#Stampa(ID,lm)
h, w, c = img.forma
cx, cy = int(lm.x *w), int(lm.y*h)
#se id ==0:
cv2.circle(img, (cx,cy), 3, (255,0,255), cv2.FILLED)
mpDraw.draw_landmarks(img, handLms, mpHands.HAND_CONNECTIONS)
cTime = tempo.tempo()
fps = 1/(cTime-pTime)
pTime = cTime
cv2.putText(img,str(int(fps)), (10,70), cv2.FONT_HERSHEY_PLAIN, 3, (255,0,255), 3)
cv2.imshow("Immagine", img)
cv2.waitKey(1)
L'uscita è:
Ora creiamo un modulo di tracciamento delle mani, così possiamo usarlo in altri progetti.
Crea un nuovo file Python. Primo, creiamo una classe chiamata rilevatore di mani con due funzioni membro su di esso, chiama trovamani e trovaPosizione.
La funzione trovamani accetterà un'immagine RGB e rileverà la mano nella cornice e localizzerà i punti chiave e disegnerà i punti di riferimento, la funzione trovaPosizione ti darà la posizione della mano insieme all'identificazione.
Dopo, la funzione principale in cui inizializziamo il nostro modulo e scriviamo anche un ciclo while per eseguire il modello. Qui puoi importare questa configurazione o il modulo in qualsiasi altro progetto correlato.
Il codice completo è riportato di seguito
importa cv2 importa mediapipe come mp tempo di importazione
classe handDetector():
def __init__(se stesso, modalità = falso, maxHands = 2, rilevamentoCon = 0.5, trackCon = 0.5):
self.mode = modalità
self.maxHands = maxHands
auto.rilevamentoCon = rilevamentoCon
self.trackCon = trackCon
self.mpHands = mp.solutions.hands
self.hands = self.mpHands.Hands(self.mode, self.maxMani, auto.rilevamentoCon, self.trackCon)
self.mpDraw = mp.solutions.drawing_utils
def trovaMani(se stesso,img, pareggio = vero):
imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
self.risultati = self.hands.process(imgRGB)
# Stampa(risultati.multi_hand_landmarks)
if self.results.multi_hand_landmarks:
per handLms in self.results.multi_hand_landmarks:
se disegna:
self.mpDraw.draw_landmarks(img, handLms, self.mpHands.HAND_CONNECTIONS)
ritorna img
def trovaPosizione(se stesso, img, manoNo = 0, pareggio = vero):
lmlist = []
if self.results.multi_hand_landmarks:
myHand = self.results.multi_hand_landmarks[manoNo]
per identità, lm in enumerare(myHand.landmark):
h, w, c = img.forma
cx, cy = int(lm.x * w), int(lm.y * h)
lmlist.append([ID, cx, cy])
se disegna:
cv2.circle(img, (cx, cy), 3, (255, 0, 255), cv2.FILLED)
ritorna l'elenco
def principale():
pTime = 0
cTempo = 0
cap = cv2.VideoCapture(0)
rivelatore = manoDetector()
mentre vero:
successo, img = cap.read()
img = detector.findHands(img)
lmlist = detector.findPosition(img)
se len(elenco) != 0:
Stampa(elenco[4])
cTime = tempo.tempo()
fps = 1 / (cTime - pTime)
pTime = cTime
cv2.putText(img, str(int(fps)), (10, 70), cv2.FONT_HERSHEY_PLAIN, 3, (255, 0, 255), 3)
cv2.imshow("Immagine", img)
cv2.waitKey(1)
se __nome__ == "__principale__":
principale()
L'output sarà lo stesso mostrato sopra insieme alle posizioni delle mani tracciate.
È disponibile anche il codice completo qui.
Riferimento:
https://www.youtube.com/watch?v=NZde8Xt78Iw
https://google.github.io/mediapipe/
Me LinkedIn
Grazie.
Il supporto mostrato in questo articolo non è di proprietà di DataPeaker e viene utilizzato a discrezione dell'autore.
