Opencv kullanarak gerçek hayattaki nesne algılama - canlı videodaki nesneleri algılama

Python OpenCV'yi pencerelere kurmaya başladık ve şu ana kadar Python kullanarak bazı temel görüntü işleme, görüntü bölümleme ve nesne algılama yaptık.

• Python OpenCV'ye Başlarken: Kurulum ve Temel Görüntü İşleme
• Python OpenCV'de Görüntü Manipülasyonları (Bölüm 1)
• OpenCV'de Görüntü Manipülasyonları (Bölüm-2)
• OpenCV kullanarak Görüntü Segmentasyonu - Bir görüntünün belirli Alanlarını Çıkarma

Ayrıca, farklı algoritmalar kullanılarak her nesne için bazı temel noktaların tanımlandığı Nesne Algılama için çeşitli yöntemler ve algoritmalar hakkında bilgi edindik. Bu eğitimde, gerçek hayattaki nesneleri tespit etmek için bu algoritmaları kullanacağız, burada tespit için SIFT ve ORB kullanacağız.

SIFT kullanarak nesne algılama

Burada nesne tespiti, canlı web kamerası akışı kullanılarak yapılacaktır, bu nedenle nesneyi tanırsa, bulunan objet'ten bahsedecektir. Kodda ana kısım, SIFT dedektörü olarak adlandırılan fonksiyon tarafından oynanır, işlemlerin çoğu bu fonksiyon tarafından yapılır.

Ve kodun diğer yarısında, web kamerası akışını açarak başlıyoruz, ardından görüntü şablonunu, yani programın gerçekte web kamerası akışına baktığı referans görüntüyü yüklüyoruz.

Daha sonra, sürekli Sonsuz yardımıyla kamerası akışından görüntü yakalama sırasında döngü ve ardından web çerçevenin karşılık gelen yüksekliğini ve genişliğini yakalama ve daha sonra daha sonra (ROI), kutu bölgenin parametrelerini tanımlar ki burada nesnemiz, web kamerası çerçevesinin karşılık gelen yüksekliğini ve genişliğini alarak sığabilir. Daha sonra yukarıda tanımladığımız ROI parametrelerinden dikdörtgeni çiziyoruz. Son olarak dikdörtgeni kırpın ve kodun SWIFT algılayıcı kısmına besleyin.

Artık SIFT algılayıcısının temelde iki girişi var, biri kırpılmış görüntü ve diğeri daha önce tanımladığımız görüntü şablonu ve sonra bize bazı eşleşmeler sağlıyor, bu nedenle eşleşmeler temelde kırpılan görüntüde benzer nesnelerin veya anahtar noktaların sayısı ve hedef görüntü. Daha sonra eşleşmeler için bir eşik değeri belirleriz, eğer eşleşme değeri eşik değerinden büyükse, ekranımıza bulunan yeşil renkli ROI dikdörtgenine sahip görüntüyü koyarız.

Şimdi kodun ana kısmına, SIFT dedektörü olarak adlandırılan fonksiyona geri dönelim, girişi iki görüntü olarak alıyor, biri nesneyi aradığı görüntü, diğeri ise eşleştirmeye çalıştığımız nesnedir. to (resim şablonu). Daha sonra, ilk görüntüyü gri ölçeklendirin ve görüntü şablonunu ikinci görüntü olarak tanımlayın. Daha sonra bir SIFT detektör nesnesi oluşturuyoruz ve anahtar noktaları tespit etmek ve tanımlayıcıları hesaplamak için OpenCV SIFT tespit ve hesaplama fonksiyonunu çalıştırıyoruz, tanımlayıcılar temelde anahtar noktalar hakkındaki bilgileri depolayan vektörlerdir ve eşleştirmeyi yaptığımız için gerçekten önemlidir. görüntülerin tanımlayıcıları arasında.

Ve sonra FLANN tabanlı eşleştiriciyi tanımlayın, arkasındaki eşleştirme matematik teorisine girmeyeceğiz, ancak bu konuda Google'ı kolayca yapabilirsiniz. Öncelikle kdtree indeksini sıfır olarak tanımlayıp daha sonra indeks ve arama parametrelerini sözlük formatında ayarlayıp, kullanacağımız KDTREE algoritmasını ve kullanacağımız ağaç sayısını tanımlıyoruz, daha çok ağaç biz kullanıyoruz karmaşıklaştıkça ve yavaşlıyor. Ve arama parametresinde, temelde tamamlayacağı eşleşme sayısı olan kontrollerin sayısını tanımlayın.

Daha sonra dizin parametreleri ve arama parametreleri olan daha önce tanımladığımız parametreyi yükleyerek FLANN tabanlı eşleştirici nesnemizi oluşturun ve buna dayanarak KNN'nin K-en yakın komşu olduğu bir KNN eşleştiricisi olan FLANN tabanlı eşleştiricimizi oluşturun, temelde En yakın eşleştiricileri ve tanımlayıcıları ararız ve eşleştirme işlemini başlatma sabiti k ile yaparız. Şimdi bu FLANN tabanlı eşleştirici, aldığımız eşleşme sayısını döndürüyor.

FLANN tabanlı eşleştirme yalnızca bir yaklaşımdır, bu nedenle FLANN tabanlı eşleştiricinin doğruluğunu artırmak için bir Lowe oran testi gerçekleştiririz ve yaptığı şey, knn flann tabanlı eşleştiriciden eşleşmeleri arar ve burada mesafe olan bazı matrik parametreleri tanımlar., hangi mesafe için uyuşmazlık bir işlevdir ve kriterleri karşıladığında, eşleşmeleri iyi eşleşmelere ekler ve bulunan iyi eşleşmeleri döndürür ve böylece canlı video akışı ekranın köşesinde bulunan eşleşme sayısını söyler.

Şimdi yukarıdaki açıklama için koda bakalım:

cv2 içe aktar np def sift_detector (yeni_image, resim_şablonu) olarak içe aktarım : # Girdi görüntüsünü şablonla karşılaştıran işlev # Daha sonra aralarındaki SIFT eşleşmelerinin sayısını döndürür image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Oluştur SIFT algılayıcı nesnesi #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # SIFT keypoints_1, descriptors_1 = sift.detectAndCompute (image1, None) keypoints_2, descriptors_2 = sift.detompectAndCute ( image1, None) Yok) # Flann Eşleştiricimiz için parametreleri tanımlayın FLANN_INDEX_KDTREE = 0 index_params = dict (algoritma = FLANN_INDEX_KDTREE, ağaçlar = 3) search_params = dict (checks = 100) # Flann Matcher nesnesini oluşturun flann = cv2.FlannBasedMatcher (index_params, search_params) # K-En Yakın Komşu Yöntemini kullanarak eşleşmeleri elde edin # sonuç 'eşleşmeler' her iki görüntü eşleşmesinde bulunan benzer eşleşmelerin sayısıdır = flann.knnMatch (descriptors_1, descriptors_2, k = 2) # Lowe oran testini kullanarak iyi eşleşmeleri saklayın good_matches = for m, n in match : if m.distance <0.7 * n.distance: good_matches.append (m) return len (good_matches) cap = cv2.VideoCapture (0) # Resim şablonumuzu yükleyin, bu bizim referans resmimiz image_template = cv2.imread ('phone.jpg', 0) True iken: # Web kamerası resimleri alın ret, frame = cap.read () # Web kamerası çerçeve yüksekliğinin yüksekliğini ve genişliğini alın , genişlik = frame.shape # ROI Kutu Boyutlarını Tanımlayın top_left_x = int (genişlik / 3) top_left_y = int ((yükseklik / 2) + (yükseklik / 4)) bottom_right_x = int ((genişlik / 3) * 2) bottom_right_y = int ((yükseklik / 2) - (yükseklik / 4)) # İlgi bölgemiz için dikdörtgen pencere çizin cv2.rectangle (çerçeve, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Yukarıda tanımladığımız gözlem penceresi kırpma penceresi = çerçeve # Çerçeve yönünü yatay olarak çevir çerçeve = cv2.flip (çerçeve, 1) # SIFT eşleşmelerinin sayısını al = sift_detector (kırpılmış, image_template) # Mevcut numarayı gösteren durum dizesini görüntüleyin. eşleşme sayısı cv2.putText (çerçeve, str (eşleşmeler), (450,450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # Nesne algılamasını göstermek için eşik değerimiz # SIFT algılayıcısı küçük yanlış konumlar döndürdüğü için 10 kullanıyoruz eşik = 10 # Eşleşmeler eşiğimizi aşarsa, nesne > eşik ile eşleşirse tespit edilmiştir : cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, 'Nesne Bulundu', (50,50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('SIFT kullanan Nesne Dedektörü', çerçeve) eğer cv2.waitKey (1) == 13: # 13 Enter Key break cap.release () cv2.destroyAllWindows ()

ORB kullanarak nesne algılama

SIFT kullanarak nesne tespiti oldukça havalı ve doğrudur, çünkü anahtar noktalara göre çok doğru sayıda eşleşme üretir, ancak patentlidir ve ticari uygulamalarda kullanılmasını zorlaştırır, bunun diğer yolu ORB algoritmasıdır. nesne algılama için.

Programı iki bölüme ayırdığımız SIFT ile nesne algılama yöntemine benzer şekilde, burada da aynısı izlenecektir.

İlk olarak, iki girdi alan ORB_detector fonksiyonunu, biri web kamerasından gelen canlı akış görüntüsü, diğeri ise bizim görselimizle eşleştireceğimiz görüntü şablonunu tanımlıyoruz. Ardından web kamerası resmimizi gri tonlamalıyız ve ardından ORB dedektörümüzü başlatıyoruz ve burada 1000 anahtar noktaya ve 1.2'lik ölçeklendirme parametresine ayarlıyoruz. Bu parametrelerle kolayca oynayabilir, daha sonra hem görüntüler için anahtar noktaları (kp) ve tanımlayıcıları (des) algılayabilir hem de detectANDCompute işlevinde tanımladığımız ikinci parametre HİÇBİRİ, görüntü maskesi kullanılıp kullanılmayacağını soruyor ve burada inkar ediyoruz.

Sonra daha önce FLANN tabanlı eşleştiriciyi kullanıyorduk, ancak burada BFMatcher kullanacağız ve BFMatcher içinde biri NORM_HAMMING ve diğeri TRUE olan crossCheck olmak üzere iki parametre tanımlayacağız.

Daha sonra, yukarıda tanımlanan tanımlayıcıları kullanarak bu iki resim arasındaki eşleşmeleri hesaplayın; bu eşleşmeler yaklaşık değildir ve bu nedenle Lowe oran testini yapmaya gerek olmadığından, eşleşmelerin sayısını verir, bunun yerine eşleşmeleri mesafeye göre sıralarız., en azından maç ne kadar fazla mesafe o kadar iyidir (burada mesafe, noktalar arasındaki mesafe demektir) ve sonunda, uzunluk fonksiyonunu kullanarak maç sayısını döndürürüz.

Ve ana işlevde eşiği çok daha yüksek bir değere ayarladık, çünkü orb detektörü çok fazla gürültü üretti.

Şimdi ORB tabanlı tespit için koda bakalım

import cv2 np def olarak import numpy ORB_detector (new_image, image_template): # Girdi imajını şablonla karşılaştıran fonksiyon # Daha sonra aralarındaki ORB eşleşmelerinin sayısını döndürür image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) # ORB detektörü oluştur Ölçek piramit faktörü 1,2 orb = cv2.ORB_create (1000, 1,2) # Orijinal görüntünün anahtar noktalarını tespit edin (kp1, des1) = orb.detectAndCompute (image1, None) # Döndürülmüş görüntünün anahtar noktalarını tespit edin (kp2, des2) = orb.detectAndCompute (image_template, None) # Eşleştirici oluştur # Artık Flann tabanlı eşleştirmeyi kullanmadığımıza dikkat edin bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # Eşleşmeleri yap = bf.match (des1, des2) # Eşleşmeleri mesafeye göre sıralayın. En az mesafe # daha iyi eşleşir = sıralı (eşleşmeler, anahtar = lambda val: değer. Mesafe) dönüş uzunluğu (eşleşmeler) cap = cv2.VideoCapture (0) # Resim şablonumuzu yükleyin, bu bizim referans resmimiz image_template = cv2.imread ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) while True: # Web kamerası görüntülerini alın ret, frame = cap.read () # Web kamerası çerçeve yüksekliğinin yüksekliğini ve genişliğini alın , width = frame.shape # ROI Kutu Boyutlarını Tanımlayın (Bunlardan bazılarının döngünün dışında olması gerektiğini unutmayın) top_left_x = int (genişlik / 3) top_left_y = int ((yükseklik / 2) + (yükseklik / 4)) bottom_right_x = int ((genişlik / 3) * 2) bottom_right_y = int ((yükseklik / 2) - (yükseklik / 4)) # Bizim için dikdörtgen pencere çizin. ilgi bölgesi cv2.rectangle (çerçeve, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Kırpılmış yukarıda tanımladığımız gözlem penceresi kırpma = çerçeve # Çerçeve yönünü yatay olarak çevir çerçeve = cv2.flip (çerçeve, 1) # ORB eşleşmelerinin sayısını al = ORB_detector (cropped, image_template) # Mevcut no. eşleşme sayısı output_string = "Matches =" + str (eşleşir) cv2.putText (çerçeve, output_string, (50,450), cv2.FONT_HERSHEY_COMPLEX, 2, (250,0,150), 2) # Nesne algılamayı belirtme eşiğimiz # Yeni görüntüler veya aydınlatma koşulları için biraz denemeniz gerekebilir # Not: En iyi 1000 eşleşmeyi elde etmek için ORB algılayıcısı, 350 aslında minimum% 35 eşleşme eşiğidir = 250 # Eşleşmeler, eşik sonra nesne > eşikle eşleşirse tespit edilmiştir : cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, 'Object Found', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('ORB kullanan Nesne Dedektörü', çerçeve) eğer cv2.waitKey (1) == 13: # 13 Enter Key break başlığı ise.release () cv2.destroyAllWindows ()

Yönlendirilmiş Gradyanların Histogramı (HOG'lar)

Şimdi farklı bir tanımlayıcıdan bahsedelim, Histogram of Oriented Gradients (HOG's).

HOG'lar oldukça havalı ve kullanışlı tanımlayıcılardır ve daha önce anahtar noktaları hesaplamamız ve ardından tanımlayıcıları bu anahtar noktalardan hesaplamamız gereken SIFT ve ORB gibi görüntü tanımlayıcılarında görüldüğü gibi nesne algılama için yaygın ve başarılı bir şekilde kullanılırlar, HOG'lar bu işlemi yapar farklı. Bu , tek bir özellik vektörü olarak nesneleri temsil her görüntünün bir parçasını temsil eder nitelik vektörleri bir dizi karşı. Bu, görüntünün tamamı için tek vektör özelliğimiz olduğu anlamına gelir.

HOG tanımlayıcısının her konum için hesaplandığı bir görüntü üzerinde kayan bir pencere detektörü ile hesaplanır. Ve sonra her konum tek bir özellik vektörü için birleştirilir.

SIFT gibi, görüntünün ölçeği piramit ile ayarlanır.

Daha önce FLANN ve BFMatcher gibi eşleştiriciler kullanıyorduk, ancak HOG'lar bunu SVM (destek vektör makinesi) sınıflandırıcılarının yardımıyla farklı bir şekilde yapıyor; burada hesaplanan her HOG tanımlayıcısı, nesnenin bulunup bulunmadığını belirlemek için bir SVM sınıflandırıcısına besleniyor.

Dalal & Triggs tarafından HOGs for Human Detection kullanımıyla ilgili bir Great Paper bağlantısı:

Yönlendirilmiş Gradyanların (HOG'lar) Histogramı, Adım Adım:

HOG'ları anlamak oldukça karmaşık olabilir, ancak burada, onunla ilgili matematiğin derinliklerine inmeden sadece HOG teorisiyle ilgileneceğiz.

Şimdi bu resmi biraz pikselleştirelim ve üst köşede 8x8 piksellik bir kutu var, bu yüzden bu kutuda her pikseldeki gradyan vektörünü veya kenar yönelimlerini hesaplıyoruz. Yani bu kutuda, kutu içindeki piksellerin görüntü gradyan vektörünü hesapladığımız anlamına gelir (bunlar görüntü yoğunluğunun kendisinin yönü veya akışıdır) ve bu, daha sonra histogram olarak temsil edilen 64 (8 x 8) gradyan vektörü oluşturur.. Her gradyan vektörünü temsil eden bir histogram hayal edin. Dolayısıyla, tüm noktalar veya yoğunluklar tek bir yönde uzandıysa, bu yön için histogram 45 derece diyelim, histogram 45 derecede tepe noktasına sahip olacaktır.

Şimdi yaptığımız şey, her hücreyi açısal bölmelere ayırmaktır, burada her bölme bir gradyan yönüne karşılık gelir (örneğin, x, y). Dalal ve Triggs kağıdında, 9 bölme 0-180 ° (her bölme 20 °) kullandılar. Bu, 64 vektörü etkili bir şekilde 9 değere düşürür. Yani yaptığımız şey boyutu küçültmek, ancak gerekli olan tüm önemli bilgileri saklamak oldu.

Domuzların hesaplanmasındaki bir sonraki adım normalizasyondur, ışık değişimlerine, yani Parlaklık ve Kontrast'a değişmezliği sağlamak için gradyanları normalleştiririz.

Bu görüntüde yoğunluk değerleri ilgili yöne göre karede gösterilmiş olup, hepsi birbiri arasında 50 fark vardır.

∆ _H = 50, ∆ _v = 50; │∆│ = √50 ² +50 = 70.72, 70.72 / 100 = 0.707

Vektörleri, tümü için 0.707 elde ettiğimiz gradyan büyüklüklerine böleriz, bu normalizasyondur.

Benzer şekilde, yoğunluğu değiştirirsek veya kontrastı değiştirirsek aşağıdaki değerleri elde ederiz.

∆ _H = 50, ∆ _v = 50; │∆│ = √50 ² +50 = 70.72, 70.72 / 100 = 0.707; ∆ _H = 100, ∆ _v = 100; │∆│ = √100 ² +100 = 141.42, 141.42 / 100 = 1.41

Normalleştirme bir hücre seviyesinde gerçekleşmez, bunun yerine bir blok seviyesinde gerçekleşir, bu yüzden burada bloklar temelde 4 hücreden oluşan bir gruptur, bu, görüntünün daha büyük bölümlerini dikkate alarak normalleştirilen komşu blokları hesaba katar.

Şimdi koda bakalım

numpy'yi np olarak içe aktar cv2 içe aktar matplotlib.pyplot plt olarak içe aktar # Görüntüyü ve ardından gri tonlamalı görüntüyü yükle = cv2.imread ('elephant.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) # Orijinal Resmi Göster cv2.imshow (' Girdi Görüntüsü ', görüntü) cv2.waitKey (0) #Piksel cinsinden parametreleri, hücre boyutunu ve blok boyutunu # hxw tanımlama cell_size = (8, 8) # hxw hücrelerde block_size = (2, 2) # oryantasyon kutusu sayısı nbins = 9 # OpenCV'nin HOG Tanımlayıcısını Kullanma # winSize, hücre boyutunun bir katına kırpılan görüntünün boyutudur hog = cv2.HOGDescriptor (_winSize = (gray.shape // hücre_size * hücre_boyutu, gray.shape // cell_size * cell_size), _blockSize = (block_size * cell_size, block_size * cell_size), _blockStride = (cell_size, cell_size), _cellSize = (cell_size, cell_size), _nbins = nbins) # Kullandığımız numpy dizi şekli oluştur hog_features oluşturmak için n_cells = (gray.shape // hücre_size, gray.shape // hücre_size) # Blokları önce satırlara göre indeksleriz. # hog_feats artık her yön için gradyan genliklerini, # her grup için grubunun her hücresini içeriyor . İndeksleme satırlara ve sütunlara göre yapılır. hog_feats = hog.compute (gri).reshape (n_cells - block_size + 1, n_cells - block_size + 1, block_size, block_size, nbins).transpose ((1, 0, 2, 3, 4)) # Gradyan yönelimlerini saklamak için nbin boyutlarıyla gradyan dizimizi oluşturun = np.zeros ((n_cells, n_cells, nbins)) # Boyutlar dizisi oluşturun cell_count = np.full ((n_cells, n_cells, 1), 0, dtype = int) # Aralıkta off_y için Blok Normalleştirme (block_size): aralıktaki off_x için (block_size): gradients - block_size + off_y + 1, off_x: n_cells - block_size + off_x + 1] + = \ hog_feats cell_count - block_size + off_y + 1, off_x: n_cells - block_size + off_x + 1] + = 1 # Ortalama gradyan gradyanları / = cell_count # Matplotlib kullanarak HOG'ları çizin # açı 360 / nbins * yön color_bins = 5 plt.pcolor (gradyanlar) plt.gca (). invert_yaxis () plt.gca (). set_aspect ('eşit', ayarlanabilir = 'kutu') plt.colorbar () plt.show () cv2.destroyAllWindows ()

Resim, giriş görüntüsünün HOG temsili olarak nasıl temsil edildiğini gösterir.

HAAR kademeli sınıflandırıcılar

Daha önce tartışıldığı gibi, bir görüntüden özellikler çıkarabilir ve bu özellikleri nesneleri sınıflandırmak veya tespit etmek için kullanabiliriz.

HAAR Kademeli Sınıflandırıcılar nedir?

Bir görüntüdeki nesneleri tanımlamak için Haar özelliklerini bir dizi sınıflandırıcıya (kademeli) giren bir nesne algılama yöntemi. Bir tür nesneyi tanımlamak için eğitilmişlerdir, ancak bunlardan birkaçını paralel olarak kullanabiliriz, örneğin gözleri ve yüzleri birlikte algılama.

HAAR sınıflandırıcıları Açıklandı:

HAAR Sınıflandırıcılar, çok sayıda pozitif görüntü (yani nesnenin bulunduğu görüntüler) ve

negatif görüntüler (yani nesne bulunmayan görüntüler) kullanılarak eğitilir.

Bu görüntüleri elde ettikten sonra , dikdörtgen blokların kayan pencerelerini kullanarak özellikleri çıkarıyoruz. Bu özellikler (HAAR özellikleri) tek değerlidir ve siyah dikdörtgenlerden beyaz dikdörtgenlerin altındaki piksel yoğunluklarının toplamının çıkarılmasıyla hesaplanır.

Ancak bu, 24 x 24 piksellik (180.000 özellik oluşturulmuş) bir temel pencere için bile saçma bir hesaplama sayısıdır.

Bu yüzden araştırmacılar, bunu dört dizi referansıyla hesaplayan İntegral Görüntüler adlı bir yöntem geliştirdiler. Ancak yine de 180.000 özelliğe sahiplerdi ve çoğunun gerçek bir değeri yoktu.

Arttırılması sonra Freund Schapire en en bilgilendirici özellikleri belirlemek için kullanılmıştır AdaBoost ve görüntüdeki en bilgilendirici özellikler bulundu. Güçlendirme, basitçe yanlış sınıflandırmalara daha ağır cezalar atayarak güçlü sınıflandırıcılar oluşturmak için zayıf sınıflandırıcılar kullandığımız bir süreçtir. Hala biraz özellik olan 180.000 özelliği 6000'e düşürmek.

Bu 6000 özellikte bazıları diğerlerinden daha bilgilendirici olacak. Öyleyse, öncelikle bölgenin potansiyel olarak bir yüze sahip olup olmadığını kontrol etmek için en bilgilendirici özellikleri kullanırsak (yanlış pozitifler önemli olmayacaktır). Bunu yapmak, aynı anda 6000 özelliğin tümünü hesaplama ihtiyacını ortadan kaldırır. Bu kavrama Sınıflandırıcıların Kademesi denir - yüz algılama için Viola Jones yöntemi 38 aşama kullandı.

Yüz ve Göz algılama

Bu yüzden, HAAR kademeleri hakkında biraz teorik bilgi edindikten sonra, nihayet onu uygulayacağız, böylece her şeyi oldukça netleştirmek için dersleri parçalara ayıracağız, önce ön yüzü tespit edeceğiz, ondan sonra ön yüzü tespit etmek için hareket edeceğiz. gözler ve nihayet web kamerası aracılığıyla yüz ve gözlerin canlı tespiti yapardık.

Bunun için OpenCV tarafından.xml dosyaları olarak sağlanan önceden eğitilmiş sınıflandırıcıları kullanacağız, xml genişletilebilir biçimlendirme dili anlamına gelir, bu dil büyük miktarda veriyi depolamak için kullanılır, hatta bir veritabanı bile oluşturabilirsiniz.

Bu sınıflandırıcılara bu bağlantıdan erişebilirsiniz .

Yüz tanıma

Önden yüz algılamayı deneyelim, buradan ön yüz algılayıcısının kademesine erişebilirsiniz. Xml dosyasını almak için sadece zip dosyasını çıkartın.

numpy olarak np import cv2 # OpenCV'nin CascadeClassifier fonksiyonunu # sınıflandırıcımızın (XML dosya formatı) depolandığı yere işaret ediyoruz , kodu ve sınıflandırıcıyı aynı klasörde tutmayı unutmayın face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # Load imajımız sonra gri tonlama dönüştürmek resmin = cv2.imread ('Trump.jpg') gri = cv2.cvtColor (resim, cv2.COLOR_BGR2GRAY) # bizim sınıflandırıcı tuple olarak algılanan yüzün ROI'sini döndürür üst sol depolayan # koordinat ve sağ alt koordinatlar # tespit edilen farklı yüzlerin konumu olan listelerin listesini döndürür. faces = face_cascade.detectMultiScale (gri, 1.3, 5) # Hiçbir yüz algılanmadığında, face_classifier döner ve yüzler () ise boş tuple : print ("Yüz bulunamadı") # Yüzler dizimizi yineleriz ve yüzlerdeki her yüzün üzerine bir dikdörtgen çizeriz # (x, y, w, h) yüzlerde: cv2.rectangle (image, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('Face Detection', image) cv2.waitKey (0) cv2.destroyAllWindows ()

Şimdi yüz ve göz algılamayı bir araya getirelim, göz dedektörü kademesine aynı zip dosyasında erişebilirsiniz.

np ithal numpy içe cv2 face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') img = cv2.imread ('Trump.jpg') gri = cv2.cvtColor (img cv2.COLOR_BGR2GRAY) = face_classifier.detectMultiScale (gri, 1.3, 5) dönük bir yüz fark # face_classifier döner ve boş tuple yüzleri ise, (): baskı () "Hayır Yüz Gösterilen" , h, w (x, y,) yüzlerde: cv2.rectangle (img, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('img', img) roi_gray = gray roi_color = img gözler = eye_classifier.detectMultiScale (roi_gray) cv2.waitKey (0 ) gözlerde (ex, ey, ew, eh) için: cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,255,0), 2) cv2.imshow ('img', img) cv2.waitKey (0) cv2.destroyAllWindows () cv2.waitKey (0)

Dolayısıyla bu kod, yüz algılama kodu ile aynıdır, ancak burada, göz basamakları ve bunları saptamak için bir yöntem ekledik, görebileceğiniz gibi, algılamak için, DetectionMultiScale parametresi olarak yüzün Gri ölçekli versiyonunu seçtik . sadece gözlerimizi sadece o bölgede tespit edeceğimiz için bizi hesaplamadaki azalmaya götüren gözler.

Canlı Yüz ve Göz algılama

Şimdiye kadar yüz ve göz algılama yaptık, şimdi aynısını web kamerasından canlı video akışı ile uygulayalım. Bunda aynı yüz ve göz algılamasını yapacağız ama bu sefer bunu web kamerasından canlı yayın için yapacağız. Uygulamanın çoğunda, yüzünüzün etrafında bir kutu ile vurgulanmış olduğunu görürdünüz, ancak burada farklı bir şey yaptık, yüzünüzün kırpılmış olduğunu ve gözlerin yalnızca bunun içinde tanımlanacağını gördük.

Yani burada hem yüz hem de göz sınıflandırıcıyı içe aktarıyoruz ve yüz ve göz algılama için tüm işlemleri yapmak için bir işlev tanımlıyoruz. Bundan sonra web kamerası akışı başladı ve yüzün ve gözlerin algılanması için yüz algılama işlevini çağırdı. Yüz dedektörü işlevinin içinde tanımladığımız parametre, canlı web kamerası akışından gelen sürekli görüntülerdir.

içe cv2 np ithal numpy face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') def face_detector (img boyutu = 0.5): # dönüştürme görüntü gri için gri = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) yüzler = face_classifier.detectMultiScale (gri, 1.3, 5) eğer yüzler () ise: yüzlerdeki (x, y, w, h) için img döndür : x = x - 50 w = w + 50 y = y - 50 h = h + 50 cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = gray roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) gözlerde (ex, ey, ew, eh) için: cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (0,0,255), 2) roi_color = cv2.flip (roi_color, 1) return roi_color cap = cv2.VideoCapture (0) True: ret, frame = cap.read () cv2.imshow ('Our Face Extractor', face_detector (frame)) eğer cv2.waitKey (1) == 13: # 13 Enter Key break cap.release () cv2.destroyAllWindows ()

Kademeli Sınıflandırıcıları Ayarlama

DetectionMultiScale içerisinde girdi görüntüsü dışında tanımlanan parametreler aşağıdaki anlama sahiptir

Sınıflandırıcımız. DetectionMultiScale (giriş görüntüsü, Ölçek Faktörü, Min Komşular)

• Ölçek Faktörü Her ölçeklendirdiğimizde görüntü boyutunu ne kadar küçülteceğimizi belirtir. Örneğin, yüz tanımada genellikle 1.3 kullanırız. Bu, görüntüyü her ölçeklendiğinde% 30 küçülttüğümüz anlamına gelir. 1.05 gibi daha küçük değerlerin hesaplanması daha uzun sürer, ancak algılama oranını artırır.

• Min Neighbors Pozitif bir tespit olarak kabul edilebilmesi için her potansiyel pencerenin sahip olması gereken komşu sayısını belirtir. Tipik olarak 3-6 arasında ayarlanır. Hassasiyet ayarı görevi görür, düşük değerler bazen tek bir yüz üzerindeki birden çok yüzü algılar. Yüksek değerler yanlış pozitiflerin daha az olmasını sağlar, ancak bazı yüzleri gözden kaçırabilirsiniz.

Videolarda Araba ve Yaya Algılama

Şimdi HAAR basamaklarını kullanarak videolarda yaya ve arabaları tespit edeceğiz, ancak hiçbir video yüklenmiyorsa ve hata olmadan kod derlemesi yapılıyorsa aşağıdaki adımları izlemeniz gerekir:

Kodu çalıştırdıktan sonra herhangi bir video yüklenmezse, opencv_ffmpeg.dl dosyamızı python'unuzun kurulu olduğu yere yapıştırmak için : opencv \ sources \ 3rdparty \ ffmpeg'den kopyalamanız gerekebilir, örneğin C: \ Anaconda2

Kopyalandıktan sonra dosyayı, kullandığınız OpenCV sürümüne göre yeniden adlandırmanız gerekir. Örneğin, OpenCV 2.4.13 kullanıyorsanız, dosyayı şu şekilde yeniden adlandırın: opencv_ffmpeg2413_64.dll veya opencv_ffmpeg2413.dll (eğer bir X86 makinesi kullanarak) opencv_ffmpeg310_64.dll veya opencv_ffmpeg310.dll (bir X86 makinesi kullanıyorsanız)

Python.exe'nin nereye yüklendiğini bulmak için, sadece bu iki satırlık kodu çalıştırın, python'un kurulu olduğu konumu yazdırır.

import sys print (sys.executable)

Şimdi bu adımları başarılı bir şekilde gerçekleştirdiyseniz, yaya algılama koduna geçelim , Basamaklı yaya algılama ve buraya eklenen zip dosyasından alabilirsiniz.

import cv2 np olarak içe aktarım # Vücut sınıflandırıcımızı oluştur body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # Video dosyası için video yakalama başlat, burada yayaların tespit edileceği video dosyasını kullanıyoruz cap = cv2.VideoCapture ('walking.avi') # Cap.isOpened () iken video başarıyla yüklendiğinde bir kez döngü yap: # Videonun her karesini okuyor ret, frame = cap.read () # burada çerçeveyi yarı boyutuna yeniden boyutlandırıyoruz, sınıflandırmayı hızlandırmak için yapıyoruz # daha büyük resimlerin kaydırılacak çok daha fazla penceresi var, bu nedenle genel olarak çözünürlüğü azaltıyoruz #of videonun yarısı, 0.5'in gösterdiği şeydir ve ayrıca #interlinear frame = cv2.resize (frame, None, fx = 0.5, fy = 0.5, interpolation = cv2.INTER_LINEAR) gray = cv2 olan daha hızlı enterpolasyon yöntemini kullanıyoruz . cvtColor (çerçeve, cv2.COLOR_BGR2GRAY) # Çerçeveyi vücut sınıflandırıcı gövdelerimize iletin = body_classifier.detectMultiScale (gri, 1.2, 3) # Gövdelerde (x, y, w, h) için tanımlanan tüm gövdeler için sınırlayıcı kutuları çıkarın : cv2. dikdörtgen (çerçeve, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Yayalar', çerçeve) eğer cv2.waitKey (1) == 13: # 13 Anahtar sonu cap.release () cv2.destroyAllWindows () Girin

Videoda yayayı başarılı bir şekilde tespit ettikten sonra, Araç algılama koduna geçelim, buradan yaya algılama için kademeye sahip olabilirsiniz.

ithalat cv2 ithalat süresi np olarak ithalat numpy vücudumuzu sınıflandırıcı oluşturma # car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # video dosyası için bir video yakalama başlatma kap = cv2.VideoCapture ('cars.avi') videosu başarıyla bir kez # Döngü yüklenen ederken cap.isOpened (): time.sleep (.05) Okunan # ilk kare ret, kare = cap.read () gri = cv2.cvtColor (çerçeve, cv2.COLOR_BGR2GRAY) bizim araba sınıflandırıcı için # Geçiş çerçeve arabalar = car_classifier.detectMultiScale (gri, 1.4, 2) # Arabalarda (x, y, w, h) için tanımlanan herhangi bir gövde için sınırlayıcı kutuları çıkarın : cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Arabalar', çerçeve) eğer cv2.waitKey (1) == 13: # 13 Enter Anahtar kesme cap.release () cv2.destroyAllWindows () ise

Time.sleep (.05) eklediğimizi fark ettiniz, bu sadece kare hızında bir gecikmedir, bu nedenle tüm araçların doğru şekilde tanımlandığını onaylayabilir veya sadece bir yorum etiketi ekleyerek kolayca kaldırabilirsiniz.

Bu makale, Rajeev Ratan tarafından oluşturulan Udemy'deki Derin Öğrenme ile Python'da Master Computer Vision ™ OpenCV4 kursundan alınmıştır, Computer Vision ve Python hakkında daha fazla bilgi edinmek için bu makaleye abone olun.