- Pengesanan objek menggunakan SIFT
- Pengesanan objek menggunakan ORB
- Histogram Gradien Berorientasi (HOG)
- Histogram Gradien Berorientasi (HOG), Langkah demi Langkah:
- Pengelaskan lata lata
- Pengesanan wajah & mata
- Pengesanan Muka dan Mata secara langsung
- Tuning Cascade Classifiers
- Pengesanan Kereta dan Pejalan Kaki dalam video
Kami bermula dengan memasang python OpenCV pada windows dan setakat ini telah melakukan beberapa pemprosesan gambar asas, segmentasi gambar dan pengesanan objek menggunakan Python, yang dibahas dalam tutorial berikut:
- Bermula dengan Python OpenCV: Pemasangan dan Pemprosesan Imej Asas
- Manipulasi Imej di Python OpenCV (Bahagian 1)
- Manipulasi Imej dalam OpenCV (Bahagian-2)
- Segmentasi Imej menggunakan OpenCV - Mengekstrak Kawasan tertentu dari gambar
Kami juga belajar mengenai pelbagai kaedah dan algoritma untuk Pengesanan Objek di mana beberapa perkara penting dikenal pasti untuk setiap objek menggunakan algoritma yang berbeza. Dalam tutorial ini kita akan menggunakan algoritma tersebut untuk mengesan objek kehidupan sebenar, di sini kita akan menggunakan SIFT dan ORB untuk pengesanan.
Pengesanan objek menggunakan SIFT
Di sini pengesanan objek akan dilakukan menggunakan aliran webcam langsung, jadi jika mengenali objek itu akan menyebut objet yang dijumpai. Dalam kod bahagian utama dimainkan oleh fungsi yang disebut sebagai pengesan SIFT, kebanyakan pemprosesan dilakukan oleh fungsi ini.
Dan pada separuh kod yang lain, kita mulai dengan membuka aliran kamera web, kemudian memuatkan templat gambar, iaitu gambar rujukan, itulah program yang sebenarnya dilihat melalui aliran kamera web.
Seterusnya, kami terus menangkap gambar dari aliran kamera web dengan bantuan loop sementara tanpa had, dan kemudian menangkap ketinggian dan lebar bingkai webcam yang sesuai, dan setelah itu tentukan parameter kotak kawasan minat (ROI) di mana objek kita boleh muat dengan mengambil ketinggian dan lebar bingkai webcam yang sesuai. Dan kemudian kami menarik segi empat tepat dari parameter ROI yang telah kami tetapkan di atas. Kemudian akhirnya potong segi empat tepat dan masukkan ke bahagian pengesan SWIFT kod.
Sekarang pengesan SIFT pada dasarnya mempunyai dua input, satu adalah gambar yang dipangkas dan yang lain adalah templat gambar yang kami tentukan sebelumnya dan kemudian memberi kami beberapa padanan, jadi padanan pada dasarnya adalah jumlah objek atau titik kekunci yang serupa pada gambar yang dipotong dan gambar sasaran. Kemudian kami menentukan nilai ambang untuk pertandingan, jika nilai pertandingan lebih besar dari ambang batas, kami meletakkan gambar yang terdapat di layar kami dengan warna hijau segi empat tepat ROI.
Sekarang mari kita kembali ke bahagian utama kod, fungsi yang disebut sebagai pengesan SIFT, ia memerlukan input kerana dua gambar satu adalah gambar di mana ia mencari objek dan yang lain adalah objek yang kita cuba padankan ke (templat gambar). Kemudian kelabu skala gambar pertama dan tentukan templat gambar sebagai gambar kedua. Kemudian kami membuat objek pengesan SIFT dan menjalankan fungsi mengesan dan mengira OpenCV SIFT, untuk mengesan titik kekunci dan menghitung deskriptor, deskriptor pada dasarnya adalah vektor yang menyimpan maklumat mengenai titik kekunci, dan sangat penting kerana kita melakukan pemadanan antara perihal gambar.
Dan kemudian tentukan pemadan berdasarkan FLANN, kami tidak akan membahas teori matematik pemadan di belakangnya, tetapi anda boleh dengan mudah Google mengenainya. Pertama, tentukan kdtree indeks ke sifar dan kemudian kita tetapkan parameter indeks dan carian dalam format kamus, kita hanya menentukan algoritma yang akan kita gunakan iaitu KDTREE, dan jumlah pokok yang akan kita gunakan, semakin banyak pokok kita menggunakan yang lebih rumit dan lambat. Dan dalam parameter carian tentukan jumlah cek, yang pada dasarnya adalah jumlah perlawanan yang akan diselesaikan.
Dan kemudian buat objek pemadan berdasarkan FLANN kami dengan memuatkan parameter yang kami tetapkan sebelumnya yang merupakan parameter indeks dan parameter carian dan berdasarkan ini buat pencocokan berdasarkan FLANN kami, yang merupakan pencocokan KNN di mana KNN adalah tetangga terdekat K, pada dasarnya ia adalah cara di mana kami mencari pemadan dan penerangan terdekat dan kami melakukan pemadanan dengan pemalar pemula. Sekarang pemadan berasaskan FLANN ini mengembalikan jumlah perlawanan yang kami dapat.
Pencocokan berdasarkan FLANN hanyalah perkiraan, untuk meningkatkan ketepatan pemadan berdasarkan FLANN, kami melakukan ujian nisbah Lowe dan apa yang dilakukannya ialah mencari perlawanan dari pemadan berasaskan knn flann dan menentukan beberapa parameter matrik yang jaraknya di sini, untuk jarak mana adalah fungsi numpy, dan setelah memenuhi kriteria, tambahkan pertandingan ke pertandingan yang baik dan kembalikan pertandingan yang baik yang dijumpai, dan oleh itu aliran video langsung memberitahu jumlah perlawanan yang terdapat di sudut layar.
Sekarang mari kita lihat kod untuk keterangan di atas:
import CV2 import numpy sebagai np def sift_detector (new_image, image_template): # Fungsi yang membandingkan imej input kepada template # Ia kemudian mengembalikan bilangan menapis perlawanan antara mereka image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Buat Objek pengesan SIFT #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # Dapatkan titik kekunci dan deskriptor menggunakan titik kekunci SIFT_1, deskriptor_1 = sift.detectAndCompute (image1, None) keypoints_2, deskriptor_2 = sift.detectAnd Tiada) # Tentukan parameter untuk Flann Matcher kami FLANN_INDEX_KDTREE = 0 index_params =ict (algoritma = FLANN_INDEX_KDTREE, pokok = 3) search_params = dict (checks = 100) # Buat objek Flann Matcher flann = cv2.FlannBasedMatcher (index_params, search_params) # Dapatkan perlawanan menggunakan Kaedah K-Nearest Neighbor # hasilnya 'matchs' adalah jumlah padanan serupa yang terdapat dalam kedua-dua perlawanan gambar = flann.knnMatch (deskriptor_1, deskriptor_2, k = 2) # Simpan padanan yang baik menggunakan ujian nisbah Lowe good_matches = untuk m, n dalam perlawanan: jika m.distance <0.7 * n.distance: good_matches.append (m) return len (good_matches) cap = cv2.VideoCapture (0) # Muatkan templat gambar kami, ini adalah gambar rujukan kami image_template = cv2.imread ('phone.jpg', 0) sementara True: # Dapatkan gambar kamera web ret, frame = cap.read () # Dapatkan ketinggian dan lebar bingkai webcam tinggi, lebar = frame.shape # Tentukan Dimensi Kotak ROI top_left_x = int (lebar / 3) top_left_y = int ((tinggi / 2) + (tinggi / 4)) bottom_right_x = int ((lebar / 3) * 2) bottom_right_y = int ((tinggi / 2) - (tinggi / 4)) # Lukis tetingkap segi empat tepat untuk kawasan minat kita cv2. segiempat (bingkai, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Tetingkap pemotongan pemerhatian yang kita tentukan di atas dipotong = bingkai # Balik bingkai orientasi mendatar bingkai = cv2.flip (bingkai, 1) # Dapatkan bilangan perlawanan SIFT yang sesuai = sift_detector (dipotong, gambar_template) # Paparkan rentetan status yang menunjukkan no semasa. of match cv2.putText (frame, str (match), (450,450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # Ambang kami untuk menunjukkan deteciton objek # Kami menggunakan 10 sejak pengesan SIFT mengembalikan sedikit positif ambang = 10 # Sekiranya padanan melebihi ambang kami maka objek telah dikesan jika sepadan> ambang: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (bingkai, 'Object Found', (50,50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Object Detector using SIFT', frame) if cv2.waitKey (1) == 13: # 13 adalah cap pemecah Enter Key. Rilis () cv2.destroyAllWindows ()
Pengesanan objek menggunakan ORB
Pengesanan objek menggunakan SIFT cukup keren dan tepat, kerana menghasilkan banyak padanan yang tepat berdasarkan titik kekunci, namun dipatenkan dan menjadikannya sukar untuk menggunakannya untuk aplikasi komersial, jalan keluarnya adalah algoritma ORB untuk pengesanan objek.
Sama dengan kaedah pengesanan objek oleh SIFT di mana kami membahagikan program kepada dua bahagian, yang sama akan diikuti di sini.
Pertama, kita menentukan fungsi ORB_detector yang mengambil dua input satu adalah gambar aliran langsung yang berasal dari kamera web dan yang lain adalah templat gambar berdasarkan yang mana kita akan sesuai dengan gambar kita. Kemudian kami skala skala gambar webcam kami dan kemudian menginisialisasi pengesan ORB kami, dan kami menetapkannya di sini pada 1000 titik utama dan skala skala 1.2. anda boleh bermain-main dengan parameter ini dengan mudah, kemudian mengesan titik kekunci (kp) dan deskriptor (des) untuk kedua-dua gambar dan parameter kedua yang kami tetapkan dalam fungsi deteksiANDCompute adalah TIADA, ia meminta penggunaan topeng gambar atau tidak dan kita menafikannya di sini.
Kemudian pindah ke pengesan sebelum ini kita telah menggunakan matcher berasaskan FLANN, tetapi di sini kita akan menggunakan BFMatcher dan di dalam BFMatcher kita menentukan dua parameter satu adalah NORM_HAMMING dan yang lain adalah crossCheck yang nilainya BENAR.
Kemudian hitung perlawanan yang sesuai antara kedua-dua gambar tersebut dengan menggunakan deskriptor yang ditentukan di atas, yang secara keseluruhan mengembalikan jumlah perlawanan kerana perlawanan ini tidak menghampiri dan oleh itu tidak perlu melakukan ujian nisbah Lowe, sebaliknya kami menyusun pertandingan berdasarkan jarak, sekurang-kurangnya jarak lebih banyak perlawanan lebih baik (di sini jarak bermaksud jarak antara titik), dan pada akhirnya kita mengembalikan jumlah pertandingan menggunakan fungsi panjang.
Dan dalam fungsi utama kami menetapkan ambang ke nilai yang jauh lebih tinggi, kerana pengesan bola menghasilkan banyak bunyi.
Sekarang mari kita lihat kod untuk pengesanan berdasarkan ORB
import cv2 import numpy sebagai np def ORB_detector (new_image, image_template): # Fungsi yang membandingkan imej input dengan templat # Ia kemudian mengembalikan bilangan padanan ORB di antara mereka image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) # Buat pengesan ORB dengan 1000 titik kekunci dengan faktor piramid penskalaan 1.2 orb = cv2.ORB_create (1000, 1.2) # Mengesan titik kekunci gambar asal (kp1, des1) = orb.detectAndCompute (gambar1, Tiada) # Mengesan titik kekunci gambar berputar (kp2, des2) = orb.detectAndCompute (image_template, None) # Buat matcher # Perhatikan kita tidak lagi menggunakan Flannbasing matching bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # Lakukan padanan perlawanan = bf.match (des1, des2) # Susun perlawanan berdasarkan jarak. Kurangnya jarak # adalah lebih baik perlawanan = disusun (perlawanan, key = lambda val: val.distance) pulangan len (perlawanan) cap = cv2.VideoCapture (0) # Muatkan template imej kami, ini adalah kami imej rujukan image_template = cv2.imread ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) sementara Benar: # Dapatkan gambar kamera web ret, frame = cap.read () # Dapatkan ketinggian dan lebar tinggi bingkai kamera web , width = frame.shape # Tentukan Dimensi Kotak ROI (Perhatikan beberapa perkara ini mesti berada di luar gelung) top_left_x = int (lebar / 3) top_left_y = int ((tinggi / 2) + (tinggi / 4)) bawah_kanan_x = int ((lebar / 3) * 2) bawah_kanan_y = int ((tinggi / 2) - (tinggi / 4)) # Lukis tetingkap segi empat tepat untuk kami wilayah minat cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Tetingkap tanaman pemerhatian yang kami tetapkan di atas dipotong = bingkai # Balik bingkai orientasi mendatar bingkai = cv2.flip (bingkai, 1) # Dapatkan bilangan padanan perlawanan ORB = ORB_detector (dipotong, image_template) # Paparkan rentetan status yang menunjukkan no semasa. of match output_string = "Matches =" + str ( match) cv2.putText (bingkai, output_string, (50,450), cv2.FONT_HERSHEY_COMPLEX, 2, (250,0,150), 2) # Ambang kami untuk menunjukkan deteciton objek # Untuk gambar baru atau keadaan kilat, anda mungkin perlu sedikit bereksperimen # Catatan: Pengesan ORB untuk mendapatkan 1000 perlawanan teratas, 350 pada dasarnya adalah ambang minimum pertandingan 35% = 250 # Sekiranya pertandingan melebihi kami ambang maka objek telah dikesan jika sepadan> ambang: cv2.rectangle (bingkai, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (bingkai, 'Object Found', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Object Detector using ORB', frame) if cv2.waitKey (1) == 13: # 13 adalah topi pemecah Enter Key .release () cv2.destroyAllWindows ()
Histogram Gradien Berorientasi (HOG)
Sekarang mari kita bincangkan perihal yang berbeza iaitu Histogram of Oriented Gradients (HOG's).
HOG adalah deskriptor yang sangat menarik dan berguna dan ia digunakan secara meluas dan berjaya untuk mengesan objek, seperti yang dilihat sebelumnya sebagai deskriptor gambar seperti SIFT dan ORB di mana kita harus mengira titik kekunci dan kemudian harus menghitung deskriptor dari titik kekunci tersebut, HOG melakukan proses itu berbeza. Ia mewakili objek sebagai vektor satu ciri berbanding satu set vektor ciri di mana masing-masing mewakili segmen gambar. Ini bermaksud kita mempunyai satu ciri vektor untuk keseluruhan gambar.
Ia dikira oleh pengesan tetingkap gelongsor di atas gambar, di mana penerangan HOG adalah dikira untuk setiap kedudukan. Dan kemudian setiap kedudukan digabungkan untuk satu vektor ciri.
Seperti SIFT skala gambar disesuaikan dengan piramida.
Sebelum ini kami telah menggunakan pemadan seperti FLANN dan BFMatcher, tetapi HOG melakukannya secara berbeza dengan bantuan pengklasifikasi SVM (mesin vektor sokongan), di mana setiap deskriptor HOG yang dihitung diberi makan kepada pengklasifikasi SVM untuk menentukan sama ada objek itu dijumpai atau tidak.
Inilah pautan ke Kertas Hebat oleh Dalal & Triggs mengenai penggunaan HOG untuk Pengesanan Manusia:
Histogram Gradien Berorientasi (HOG), Langkah demi Langkah:
Memahami HOG mungkin agak rumit, tetapi di sini kita hanya akan menangani teori HOG tanpa perlu mendalami matematik yang berkaitan dengannya.
Oleh itu, mari kita ambil gambar ini sedikit piksel, dan di sudut atas terdapat kotak piksel 8x8 di sini, jadi di kotak ini kita menghitung vektor kecerunan atau orientasi tepi pada setiap piksel. Oleh itu, dalam kotak ini kita mengira vektor kecerunan gambar piksel di dalam kotak (ia adalah arah atau aliran intensiti gambar itu sendiri), dan ini menghasilkan vektor kecerunan 64 (8 x 8) yang kemudian diwakili sebagai histogram. Oleh itu, bayangkan histogram yang mewakili setiap vektor kecerunan. Jadi jika semua titik atau intensiti berbohong dalam satu arah, histogram untuk arah itu katakan 45 darjah, histogram akan mencapai puncak pada 45 darjah.
Oleh itu, apa yang kita lakukan sekarang ialah kita membelah setiap sel menjadi tong sudut, di mana setiap tong sepadan dengan arah kecerunan (mis. X, y) Dalam kertas Dalal dan Triggs, mereka menggunakan 9 tong sampah 0-180 ° (20 ° setiap tong sampah). Ini berkesan mengurangkan 64 vektor kepada hanya 9 nilai. Oleh itu, apa yang telah kita lakukan adalah mengurangkan ukuran tetapi menyimpan semua maklumat penting yang diperlukan.
Langkah seterusnya dalam mengira babi adalah normalisasi, kita menormalkan kecerunan untuk memastikan perubahan terhadap perubahan pencahayaan iaitu Kecerahan dan Kontras.
Dalam gambar ini, nilai intensiti ditunjukkan di segi empat sama mengikut arah masing-masing dan semuanya mempunyai perbezaan 50 antara satu sama lain
∆ H = 50, Δ v = 50; │Δ│ = √50 2 +50 = 70.72, 70.72 / 100 = 0.707
Kami membahagikan vektor dengan magnitud kecerunan yang kami dapat 0.707 untuk semua, ini adalah normalisasi.
Begitu juga, jika kita mengubah intensiti atau mengubah kontras kita mendapat nilai di bawah.
∆ H = 50, Δ v = 50; │Δ│ = √50 2 +50 = 70.72, 70.72 / 100 = 0.707; Δ H = 100, Δ v = 100; │Δ│ = √100 2 +100 = 141.42, 141.42 / 100 = 1.41
Normalisasi tidak berlaku pada tingkat sel, sebaliknya terjadi pada tingkat blok, jadi di sini blok pada dasarnya adalah sekelompok 4 sel, ini mengambil kira blok bersebelahan sehingga menormalkan sambil mempertimbangkan segmen gambar yang lebih besar.
Sekarang mari kita lihat kodnya
import numpy as np import cv2 import matplotlib.pyplot as plt # Load image then grayscale image = cv2.imread ('elephant.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) # Show Image original cv2.imshow (' Input Image ', image) cv2.waitKey (0) # menentukan parameter, ukuran sel dan ukuran blok # hxw dalam piksel sel_size = (8, 8) # hxw dalam sel block_size = (2, 2) # bilangan tong orientasi nbins = 9 # Menggunakan HOG Descriptor OpenCV # winSize adalah ukuran gambar yang dipotong menjadi kelipatan dari ukuran sel babi = cv2.HOGDescriptor (_winSize = (grey.shape // cell_size * cell_size, grey.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) # Buat bentuk numpy untuk membuat hog_features n_cells = (gray.shape // cell_size, gray.shape // cell_size) # Kami mengindeks blok mengikut baris terlebih dahulu. # hog_feats sekarang mengandungi amplitud kecerunan untuk setiap arah, # untuk setiap sel kumpulannya untuk setiap kumpulan. Pengindeksan dilakukan mengikut baris kemudian lajur. hog_feats = hog.compute (kelabu). bentuk semula (n_cells - block_size + 1, n_cells - block_size + 1, block_size, block_size, nbins).transpose ((1, 0, 2, 3, 4)) # Buat susunan gradien kami dengan dimensi nbin untuk menyimpan gradien orientasi kecerunan = np.zeros ((n_cells, n_cells, nbins)) # Buat susunan dimensi cell_count = np.full ((n_cells, n_cells, 1), 0, dtype = int) # Blok Normalisasi untuk off_y dalam jarak (block_size): untuk off_x dalam range (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 # Purata kecerunan gradien / = cell_count # Plot HOGs menggunakan Matplotlib # angle adalah 360 / nbins * color_bins direction = 5 plt.pcolor (gradients) plt.gca (). invert_yaxis () plt.gca (). set_aspect ('same', adjustable = 'box') plt.colorbar () plt.show () cv2.destroyAllWindows ()
Gambar menunjukkan bagaimana gambar input dilambangkan sebagai representasi HOG.
Pengelaskan lata lata
Seperti yang telah dibincangkan sebelumnya, kita dapat mengekstrak ciri dari gambar dan menggunakan ciri tersebut untuk mengklasifikasikan atau mengesan objek.
Apa itu Pengelasan Cascade HAAR?
Kaedah pengesanan objek yang memasukkan ciri Haar ke dalam rangkaian pengklasifikasi (lata) untuk mengenal pasti objek dalam gambar. Mereka dilatih untuk mengenal pasti satu jenis objek, namun kita dapat menggunakan beberapa daripadanya secara selari misalnya mengesan mata dan wajah bersama.
Pengelaskan HAAR Menerangkan:
Pengelaskan HAAR dilatih menggunakan banyak gambar positif (iaitu gambar dengan objek yang ada) dan
gambar negatif (iaitu gambar tanpa objek hadir).
Setelah memperoleh gambar tersebut, kami kemudian mengekstrak ciri menggunakan tingkap gelongsor dari blok segi empat tepat. Ciri-ciri ini (ciri HAAR) dinilai satu dan dikira dengan mengurangkan jumlah intensiti piksel di bawah segiempat putih dari segi empat tepat hitam.
Walau bagaimanapun, ini adalah jumlah pengiraan yang tidak masuk akal, walaupun untuk tetingkap asas 24 x 24 piksel (180,000 ciri dihasilkan).
Oleh itu, para penyelidik membuat kaedah yang dipanggil Integral Images yang menghitungnya dengan empat rujukan susunan. Namun, mereka masih mempunyai 180,000 ciri dan sebahagian besar daripadanya tidak menambah nilai sebenarnya.
Meningkatkan kemudian digunakan untuk menentukan ciri-ciri yang paling bermaklumat, dengan AdaBoost Freund & Schapire dan ia menjumpai kebanyakan ciri maklumat dalam gambar. Meningkatkan adalah proses di mana kita menggunakan pengkelasan lemah untuk membina pengkelasan yang kuat, hanya dengan memberikan hukuman yang lebih berat pada klasifikasi yang salah. Mengurangkan 180,000 ciri menjadi 6000, yang masih banyak ciri.
Dalam 6000 ciri tersebut, beberapa akan lebih bermaklumat daripada yang lain. Oleh itu, jika kita menggunakan ciri yang paling bermaklumat untuk memeriksa terlebih dahulu sama ada kawasan tersebut berpotensi memiliki wajah (positif palsu tidak akan menjadi masalah besar). Melakukannya menghilangkan keperluan untuk mengira semua 6000 ciri sekaligus. Konsep ini disebut Cascade of Classifiers - untuk pengesanan wajah, kaedah Viola Jones menggunakan 38 tahap.
Pengesanan wajah & mata
Oleh itu, setelah memperoleh beberapa pengetahuan teoritis mengenai lata HAAR, kita akhirnya akan melaksanakannya, untuk menjadikan perkara-perkara yang jelas kita akan memecahkan pelajaran secara berperingkat, pertama kita akan mengesan muka depan selepas itu kita akan bergerak untuk mengesan muka depan dengan mata dan akhirnya kita akan melakukan pengesanan secara langsung wajah dan mata melalui kamera web.
Jadi untuk ini kita akan menggunakan pengkelasan pra-terlatih yang telah disediakan oleh OpenCV sebagai fail.xml, xml bermaksud bahasa markup yang dapat diperluas, bahasa ini digunakan untuk menyimpan sejumlah besar data, anda bahkan boleh membina pangkalan data di atasnya.
Anda boleh mendapatkan akses pengelasan ini di pautan ini .
Pengesanan wajah
Mari cuba untuk pengesanan muka depan, anda boleh mendapatkan akses untuk lata pengesan muka depan di sini. Cukup ekstrak fail zip untuk mendapatkan fail xml.
import numpy sebagai np import cv2 # Kami mengarahkan fungsi CascadeClassifier OpenCV ke tempat # classifier kami (format fail XML) disimpan, ingat untuk menyimpan kod dan pengklasifikasi dalam folder yang sama face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # Load gambar kami kemudian ubahnya menjadi gambar skala kelabu = cv2.imread ('Trump.jpg') kelabu = cv2.cvtColor (gambar, cv2.COLOR_BGR2GRAY) # Pengelas kami mengembalikan ROI wajah yang dikesan sebagai tuple # Ia menyimpan kiri atas koordinat dan koordinat kanan bawah # ia mengembalikan senarai senarai, yang merupakan lokasi pelbagai wajah yang dikesan. wajah = face_cascade.detectMultiScale (kelabu, 1.3, 5) # Apabila tidak ada wajah yang terdeteksi, face_classifier kembali dan tuple kosong jika wajah (): cetak ("Tidak ada wajah yang dijumpai") # Kami melakukan iterasi melalui tatasusunan wajah kita dan lukiskan sebuah segi empat tepat # di atas setiap wajah di wajah untuk (x, y, w, h) di muka: cv2. segi empat tepat (gambar, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('Deteksi Wajah', gambar) cv2.waitKey (0) cv2.destroyAllWindows ()
Sekarang mari kita gabungkan pengesanan wajah dan mata, anda boleh mendapatkan akses untuk lata pengesan mata dalam fail zip yang sama.
import numpy sebagai np import cv2 face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') img = cv2.imread ('Trump.jpg') cg = cg cv2.COLOR_BGR2GRAY) face = face_classifier.detectMultiScale (grey, 1.3, 5) # Apabila tiada wajah yang dikesan, face_classifier kembali dan kosong tuple jika wajah (): print ("No Face Found") untuk (x, y, w, h) di muka: cv2. segi empat tepat (img, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('img', img) roi_gray = grey roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) cv2.waitKey (0) untuk (mis., ey, ew, eh) pada mata: 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)
Jadi kod ini sama seperti kod untuk pengesanan wajah, tetapi di sini kami telah menambahkan pelindung mata dan kaedah untuk mengesannya, seperti yang anda lihat, kami telah memilih versi wajah berwarna kelabu sebagai parameter untuk deteksiMultiScale untuk mata, yang membawa kita kepada pengurangan pengiraan kerana kita hanya akan mengesan mata di kawasan itu sahaja.
Pengesanan Muka dan Mata secara langsung
Jadi sehingga kini kami telah melakukan pengesanan wajah dan mata, sekarang mari kita lakukan yang sama dengan aliran video langsung dari kamera web. Dalam ini kita akan melakukan pengesanan wajah dan mata yang sama tetapi kali ini kita akan melakukannya untuk siaran langsung dari kamera web. Di kebanyakan aplikasi, anda akan melihat wajah anda diserlahkan dengan kotak di sekelilingnya, tetapi di sini kami telah melakukan sesuatu yang berbeza sehingga anda dapat melihat wajah anda terpotong dan mata hanya dapat dikenali.
Oleh itu, di sini kita mengimport pengkelasan wajah dan mata, dan menentukan fungsi untuk melakukan semua proses untuk pengesanan wajah dan mata. Dan selepas itu memulakan aliran webcam dan memanggil fungsi detektor wajah untuk mengesan wajah dan mata. Parameter yang kami tetapkan di dalam fungsi detektor wajah adalah gambar berterusan dari aliran web cam langsung
import cv2 import numpy sebagai np face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') def face_detector (img, size = 0.5): # ubah abu-abu (img, cv2.COLOR_BGR2GRAY) face = face_classifier.detectMultiScale (grey, 1.3, 5) if face is (): return img for (x, y, w, h) di wajah: x = x - 50 w = w + 50 y = y - 50 h = h + 50 cv2. segi empat tepat (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = abu-abu roi_color = mata img = eye_classifier.detectMultiScale (roi_gray) untuk (mis., ey, ew, eh) pada mata: 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) sementara True: ret, frame = cap.read () cv2.imshow ('Our Face Extractor', face_detector (frame)) if cv2.waitKey (1) == 13: # 13 adalah topi pemecahan Enter Key.release () cv2.destroyAllWindows ()
Tuning Cascade Classifiers
Parameter yang ditentukan di dalam deteksiMultiScale selain gambar input mempunyai kepentingan berikut
Pengelas kami. detectMultiScale (gambar input, Faktor Skala, Jiran Min)
- Faktor Skala Menentukan berapa banyak kita mengurangkan ukuran gambar setiap kali kita membuat skala. Contohnya dalam pengesanan wajah kita biasanya menggunakan 1.3. Ini bermakna kita mengurangkan gambar sebanyak 30% setiap kali skala. Nilai yang lebih kecil, seperti 1.05 akan memakan masa lebih lama untuk dikira, tetapi akan meningkatkan kadar pengesanan.
- Jiran Min Menentukan bilangan jiran yang harus dimiliki setiap tetingkap untuk menganggapnya sebagai pengesanan positif. Biasanya ditetapkan antara 3-6. Ia bertindak sebagai tetapan kepekaan, nilai rendah kadang-kadang akan mengesan beberapa wajah di satu muka. Nilai yang tinggi akan memastikan positif yang tidak betul, tetapi anda mungkin akan kehilangan beberapa wajah.
Pengesanan Kereta dan Pejalan Kaki dalam video
Sekarang kita akan mengesan pejalan kaki dan kereta dalam video menggunakan lata HAAR, tetapi sekiranya tidak ada video yang dimuat dan menyusun kod tanpa ralat, anda perlu mengikuti langkah-langkah berikut:
Sekiranya tidak ada video yang dimuatkan setelah menjalankan kod, anda mungkin perlu menyalin opencv_ffmpeg.dl kami dari : opencv \ source \ 3rdparty \ ffmpeg untuk menampalnya di mana python anda dipasang misalnya C: \ Anaconda2
Setelah disalin, anda perlu menamakan semula fail mengikut versi OpenCV yang anda gunakan.eg jika anda menggunakan OpenCV 2.4.13 kemudian namakan semula fail tersebut sebagai: opencv_ffmpeg2413_64.dll atau opencv_ffmpeg2413.dll (jika anda menggunakan mesin X86) opencv_ffmpeg310_64.dll atau opencv_ffmpeg310.dll (jika anda menggunakan mesin X86)
Untuk mengetahui di mana python.exe anda dipasang, jalankan kedua baris kod ini, ia akan mencetak lokasi di mana python dipasang.
import cetakan sys (sys.executable)
Sekiranya anda berjaya melakukan langkah-langkah ini, mari beralih ke kod untuk pengesanan pejalan kaki, Anda boleh mempunyai lata untuk pengesanan pejalan kaki dan dari fail zip yang dilampirkan di sini.
import cv2 import numpy sebagai np # Buat pengelas badan kita body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # Mulakan tangkapan video untuk fail video, di sini kita menggunakan fail video di mana pejalan kaki akan dikesan cap = cv2.VideoCapture ('walking.avi') # Gelung setelah video berjaya dimuat semasa cap.isOpened (): # Membaca setiap bingkai ret video , frame = cap.read () # di sini kita mengubah ukuran bingkai, hingga separuh dari ukurannya, kami lakukan untuk mempercepat klasifikasi # kerana gambar yang lebih besar mempunyai lebih banyak tetingkap untuk diluncurkan, jadi secara keseluruhan kami mengurangkan resolusi #daripada separuh itulah yang ditunjukkan oleh 0.5, dan kami juga menggunakan kaedah interpolasi lebih cepat iaitu #interlinear frame = cv2.resize (frame, None, fx = 0.5, fy = 0.5, interpolation = cv2.INTER_LINEAR) kelabu = cv2. cvtColor (frame, cv2.COLOR_BGR2GRAY) # Lulus bingkai ke badan pengelasan badan kita = body_classifier.detectMultiScale (grey, 1.2, 3) # Ekstrak kotak pengikat untuk mana-mana badan yang dikenal pasti (x, y, w, h) dalam badan: cv2 segi empat tepat (bingkai, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Pedestrians', frame) if cv2.waitKey (1) == 13: # 13 adalah cap pemecah Enter Key. Rilis () cv2.destroyAllWindows ()
Setelah berjaya mengesan pejalan kaki dalam video, mari beralih ke kod untuk Pengesanan kereta, Anda boleh mempunyai lata untuk pengesanan pejalan kaki dari sini.
import cv2 import time import numpy as np # Buat pengelas badan kita car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # Mulakan tangkapan video untuk cap fail video = cv2.VideoCapture ('cars.avi') # Gelung setelah video berjaya dimuat semasa cap.isOpened (): time.sleep (.05) # Baca bingkai pertama ret, bingkai = cap.read () kelabu = cv2.cvtColor (bingkai, cv2.COLOR_BGR2GRAY) # Lulus bingkai ke kereta pengelasan kereta kami = car_classifier.detectMultiScale (kelabu, 1.4, 2) # Ekstrak kotak pengikat untuk mana-mana badan yang dikenal pasti (x, y, w, h) di dalam kereta: cv2. segi empat (bingkai, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Cars', frame) if cv2.waitKey (1) == 13: # 13 adalah cap pemecah Enter Key.release () cv2.destroyAllWindows ()
Anda perhatikan bahawa kami telah menambahkan waktu.sleep (.05) , ini hanya kelewatan dalam kadar bingkai sehingga anda dapat mengesahkan bahawa semua kereta dikenal pasti dengan betul, atau anda dapat membuangnya dengan mudah hanya dengan menambahkan label komen padanya.
Artikel ini dirujuk dari Master Computer Vision ™ OpenCV4 di Python dengan kursus Deep Learning on Udemy, yang dibuat oleh Rajeev Ratan, berlangganan untuk mengetahui lebih lanjut mengenai Computer Vision dan Python.