Deteksi Tepi OpenCV dengan Python dengan cv2.Canny()

Pengantar

Deteksi tepi adalah sesuatu yang kami lakukan secara alami, tetapi tidak semudah menentukan aturan untuk komputer. Sementara berbagai metode telah dirancang, metode memerintah dikembangkan oleh John F. Canny pada tahun 1986, dan dengan tepat dinamai metode Canny.

Ini cepat, cukup kuat, dan berfungsi sebaik mungkin untuk jenis tekniknya. Di akhir panduan, Anda akan mengetahui cara melakukan deteksi tepi waktu nyata pada video, dan menghasilkan sesuatu seperti:

Deteksi Tepi Canny

Apa itu metode Canny? Ini terdiri dari empat operasi yang berbeda:

• Penghalusan Gaussian
• Gradien komputasi
• Supresi Non-Maks
• Ambang Batas Histeresis

Penghalusan Gaussian digunakan sebagai langkah pertama untuk "menyetrika" gambar input, dan melunakkan noise, membuat hasil akhir jauh lebih bersih.

Gradien gambar telah digunakan dalam aplikasi sebelumnya untuk deteksi tepi. Terutama, filter Sobel dan Scharr mengandalkan gradien gambar. Filter Sobel bermuara pada dua kernel (Gx dan Gy), dimana Gx mendeteksi perubahan horizontal, sementara Gy mendeteksi perubahan vertikal:

G

x

=

[

-
1

0

+
1

-
2

0

+
2

-
1

0

+
1

]

G

y

=

[

-
1

-
2

-
1

0

0

0

+
1

+
2

+
1

]

Saat Anda menggesernya di atas gambar, mereka masing-masing akan "mengambil" (menekankan) garis dalam orientasinya masing-masing. Kernel Scharr bekerja dengan cara yang sama, dengan nilai yang berbeda:

G

x

=

[

+
3

0

-
3

+
10

0

-
10

+
3

0

-
3

]

G

y

=

[

+
3

+
10

+
3

0

0

0

-
3

-
10

-
3

]

Filter ini, setelah dililitkan pada gambar, akan menghasilkan peta fitur:

Kredit gambar: Davidwkennedy

Untuk peta fitur ini, Anda dapat menghitung besaran gradien dan orientasi gradien – yaitu seberapa kuat perubahan itu (seberapa besar kemungkinan bahwa sesuatu adalah keunggulan) dan ke arah mana perubahan itu mengarah. Karena Gy menunjukkan perubahan vertikal (Y-gradien), dan Gx menunjukkan perubahan horizontal (X-gradien) – Anda dapat menghitung besarnya hanya dengan menerapkan teorema Pythagoras, untuk mendapatkan hipotenusa segitiga yang dibentuk oleh "kiri" dan arah "benar":

$$
{G} ={akar {{{G} _{x}}^{2}+{{G} _{y}}^{2}}}
$$

Dengan menggunakan magnitudo dan orientasi, Anda dapat menghasilkan gambar dengan tepi yang disorot:

Kredit gambar: Davidwkennedy

Namun – Anda dapat melihat seberapa banyak suara yang juga ditangkap dari tekstur batu bata! Gradien gambar sangat sensitif terhadap noise. Inilah sebabnya mengapa filter Sobel dan Scharr digunakan sebagai komponen, tetapi bukan satu-satunya pendekatan dalam metode Canny. Pemulusan Gaussian membantu di sini juga.

Supresi Non-Maks

Masalah yang terlihat dengan filter Sobel adalah tepinya tidak terlalu jelas. Ini tidak seperti seseorang mengambil pensil dan menggambar garis untuk membuat lineart dari gambar. Tepinya biasanya tidak begitu jelas dalam gambar, karena cahaya berdifusi secara bertahap. Namun, kita dapat menemukan garis yang sama di tepinya, dan menekan sisa piksel di sekitarnya, menghasilkan garis pemisah yang bersih dan tipis. Ini dikenal sebagai Non-Max Supression! Piksel non-maks (yang lebih kecil dari yang kami bandingkan di bidang lokal kecil, seperti kernel 3x3) ditekan. Konsep ini berlaku untuk lebih banyak tugas daripada ini, tetapi mari kita ikat ke konteks ini untuk saat ini.

Ambang Batas Histeresis

Banyak non-tepi dapat dan kemungkinan akan dievaluasi sebagai tepi, karena kondisi pencahayaan, bahan dalam gambar, dll. Karena berbagai alasan kesalahan perhitungan ini terjadi – sulit untuk membuat evaluasi otomatis tentang apa itu tepi dan bukan tepi. 't. Anda dapat membatasi gradien, dan hanya menyertakan yang lebih kuat, dengan asumsi bahwa tepi "asli" lebih intens daripada tepi "palsu".

Thresholding bekerja dengan cara yang sama seperti biasanya – jika gradien berada di bawah ambang batas bawah, hapus (nol), dan jika di atas ambang batas atas yang diberikan, pertahankan. Segala sesuatu di antara batas bawah dan batas atas berada di "zona abu-abu". Jika ada tepi di antara ambang batas terhubung ke a tepi definitif (yang di atas ambang batas) – mereka juga dianggap sebagai tepi. Jika mereka tidak terhubung, kemungkinan besar mereka adalah tiruan dari tepi yang salah perhitungan.

Itu ambang batas histeresis! Akibatnya, ini membantu membersihkan hasil akhir dan menghilangkan tepi palsu, tergantung pada apa yang Anda klasifikasikan sebagai tepi palsu. Untuk menemukan nilai ambang batas yang baik, Anda biasanya akan bereksperimen dengan batas bawah dan atas yang berbeda untuk ambang batas, atau menggunakan metode otomatis seperti metode Otsu atau metode Segitiga.

Mari kita memuat gambar ke dalam dan skala abu-abu (Canny, seperti Sobel/Scharr membutuhkan gambar untuk skala abu-abu):

import cv2
import matplotlib.pyplot as plt

img = cv2.imread('finger.jpg', cv2.IMREAD_GRAYSCALE)
img_blur = cv2.GaussianBlur(img, (3,3), 0)

plt.imshow(img_blur, cmap='gray')

Gambar close-up jari akan berfungsi sebagai tempat pengujian yang baik untuk deteksi tepi – tidak mudah membedakan sidik jari dari gambar, tetapi kami dapat memperkirakannya.

Deteksi Tepi pada Gambar dengan cv2.Canny()

Algoritma Canny dapat diterapkan menggunakan OpenCV's Canny() Metode:

cv2.Canny(input_img, lower_bound, upper_bound)

Menemukan keseimbangan yang tepat antara batas bawah dan batas atas bisa jadi rumit. Jika keduanya rendah – Anda akan memiliki sedikit tepi. Jika batas bawah rendah dan batas atas tinggi – Anda akan mengalami kebisingan. Jika keduanya tinggi dan dekat satu sama lain – Anda akan memiliki sedikit tepi. Tempat yang tepat memiliki celah yang cukup di antara batas, dan memilikinya pada skala yang tepat. Percobaan!

Gambar masukan akan diburamkan dengan metode Canny, tetapi seringkali, Anda akan mendapat manfaat dari pengaburannya sebelum itu masuk juga. Metode ini menerapkan keburaman Gaussian 5×5 ke input sebelum melakukan operasi lainnya, tetapi bahkan dengan keburaman ini, beberapa noise masih dapat meresap, jadi kami telah memburamkan gambar sebelum memasukkannya ke dalam algoritme:

edge = cv2.Canny(img_blur, 20, 30)

fig, ax = plt.subplots(1, 2, figsize=(18, 6), dpi=150)
ax[0].imshow(img, cmap='gray')
ax[1].imshow(edge, cmap='gray')

Ini menghasilkan:

Nilai-nilai 20 dan 30 di sini tidak sewenang-wenang – Saya telah menguji metode pada berbagai parameter, dan memilih satu set yang tampaknya menghasilkan hasil yang layak. Bisakah kita mencoba mengotomatiskan ini?

Ambang Batas Otomatis untuk cv2.Canny()?

Bisakah Anda menemukan satu set nilai ambang batas yang optimal? Ya, tapi itu tidak selalu berhasil. Anda dapat membuat perhitungan Anda sendiri untuk beberapa nilai bagus, dan kemudian menyesuaikan rentang dengan a sigma sekitar ambang itu:

lower_bound = (1-sigma)*threshold
upper_bound = (1+sigma)*threshold

Ketika sigma, dikatakan, 0.33 – batasnya adalah 0.66*threshold dan 1.33*threshold, memungkinkan kisaran ~1/3 di sekitarnya. Padahal, menemukan threshold adalah apa yang lebih sulit. OpenCV memberi kita metode Otsu (berfungsi bagus untuk gambar bi-modal) dan metode Segitiga. Mari kita coba keduanya, serta mengambil median sederhana dari nilai piksel sebagai opsi ketiga:

otsu_thresh, _ = cv2.threshold(img_blur, 0, 255, cv2.THRESH_OTSU)
triangle_thresh, _ = cv2.threshold(img_blur, 0, 255, cv2.THRESH_TRIANGLE)
manual_thresh = np.median(img_blur)

def get_range(threshold, sigma=0.33):
    return (1-sigma) * threshold, (1+sigma) * threshold

otsu_thresh = get_range(otsu_thresh)
triangle_thresh = get_range(triangle_thresh)
manual_thresh = get_range(manual_thresh)

print(f"Otsu's Threshold: {otsu_thresh} nTriangle Threshold: {triangle_thresh} nManual Threshold: {manual_thresh}")

Ini menghasilkan:

Otsu's Threshold: (70.35, 139.65) 
Triangle Threshold: (17.419999999999998, 34.58) 
Manual Threshold: (105.18999999999998, 208.81)

Ini sangat berbeda! Dari nilai yang telah kita lihat sebelumnya, kita dapat mengantisipasi bahwa metode Segitiga bekerja paling baik di sini. Ambang manual tidak terlalu diinformasikan, karena hanya mengambil nilai piksel median, dan akhirnya memiliki ambang dasar tinggi yang selanjutnya dikalikan menjadi rentang lebar untuk gambar ini. Metode Otsu kurang menderita dari ini, tetapi tetap menderita.

Jika kita menjalankan Canny() metode dengan rentang ambang ini:

edge_otsu = cv2.Canny(img_blur, *otsu_thresh)
edge_triangle = cv2.Canny(img_blur, *triangle_thresh)
edge_manual = cv2.Canny(img_blur, *manual_thresh)

fig, ax = plt.subplots(1, 3, figsize=(18, 6), dpi=150)
ax[0].imshow(edge_otsu, cmap='gray')
ax[1].imshow(edge_triangle, cmap='gray')
ax[2].imshow(edge_manual, cmap='gray')

Ini menghasilkan:

Metode Segitiga bekerja cukup baik di sini! Ini bukan jaminan bahwa itu akan bekerja dengan baik dalam kasus lain juga.

Deteksi Tepi Waktu Nyata pada Video dengan cv2.Canny()

Terakhir, mari terapkan deteksi tepi Canny ke video secara real-time! Kami akan menampilkan video yang sedang diproses (setiap frame selesai) menggunakan cv2.imshow() yang menampilkan jendela dengan bingkai yang ingin kita tampilkan. Meskipun demikian, kami juga akan menyimpan video ke dalam file MP4 yang nantinya dapat diperiksa dan dibagikan.

Untuk memuat video menggunakan OpenCV, kami menggunakan VideoCapture() metode. Jika kita lewat 0 – itu akan merekam dari webcam saat ini, sehingga Anda dapat menjalankan kode di webcam Anda juga! Jika Anda memasukkan nama file, itu akan memuat file:

def edge_detection_video(filename):
    cap = cv2.VideoCapture(filename)
    
    fourcc = cv2.VideoWriter_fourcc(*'MP4V')
    out = cv2.VideoWriter('output.mp4', fourcc, 30.0, (int(cap.get(3)), int(cap.get(4))), isColor=False)
    
    while cap.isOpened():
        (ret, frame) = cap.read()
        if ret == True:
            frame = cv2.GaussianBlur(frame, (3, 3), 0)
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            edge = cv2.Canny(frame, 50, 100)
            out.write(edge)
            cv2.imshow('Edge detection', edge)
        else:
            break

        if cv2.waitKey(10) & 0xFF == ord('q'):
            break

    cap.release()
    out.release()
    cv2.destroyAllWindows()

edge_detection_video('secret_video.mp4')

Grafik VideoWriter menerima beberapa parameter – nama file keluaran, FourCC (empat kode codec, yang menunjukkan codec yang digunakan untuk mengkodekan video), framerate dan resolusi sebagai tuple. Untuk tidak menebak atau mengubah ukuran video – kami telah menggunakan lebar dan tinggi video asli, diperoleh melalui VideoCapture instance yang berisi data tentang video itu sendiri, seperti lebar, tinggi, jumlah total bingkai, dll.

Saat tangkapan dibuka, kami mencoba membaca bingkai berikutnya dengan cap.read(), yang mengembalikan kode hasil dan bingkai berikutnya. Kode hasilnya adalah True or False, yang menunjukkan adanya bingkai berikutnya atau kekurangannya. Hanya ketika ada bingkai, kami akan mencoba memprosesnya lebih lanjut, jika tidak, kami akan memutus loop. Untuk setiap frame yang valid, kami menjalankannya melalui gaussian blur, mengubahnya menjadi skala abu-abu, menjalankan cv2.Canny() di atasnya dan tulis menggunakan VideoWriter ke disk, dan ditampilkan menggunakan cv2.imshow() untuk tampilan langsung.

Terakhir, kami merilis capture dan video writer, karena keduanya bekerja dengan file di disk, dan menghancurkan semua jendela yang ada.

Saat Anda menjalankan metode dengan a secret_video.mp4 input – Anda akan melihat jendela pop up dan setelah selesai, file di direktori kerja Anda:

Kesimpulan

Dalam panduan ini, kita telah melihat cara kerja deteksi tepi Canny, dan bagian-bagian penyusunnya – pemulusan gaussian, filter Sobel dan gradien gambar, Non-Max Supression, dan Hysteresis Thresholding. Akhirnya, kami telah menjelajahi metode untuk pencarian rentang ambang batas otomatis untuk deteksi tepi Canny dengan cv2.Canny(), dan menerapkan teknik pada video, menyediakan deteksi tepi waktu nyata dan menyimpan hasilnya dalam file video.

Melangkah Lebih Jauh – Pembelajaran Mendalam Praktis untuk Visi Komputer

Sifat ingin tahu Anda membuat Anda ingin melangkah lebih jauh? Kami merekomendasikan untuk memeriksa kami Kelas: “Pembelajaran Mendalam Praktis untuk Visi Komputer dengan Python”.

Kursus Computer Vision lainnya?

Kami tidak akan melakukan klasifikasi digit MNIST atau mode MNIST. Mereka melayani bagian mereka sejak lama. Terlalu banyak sumber belajar yang berfokus pada kumpulan data dasar dan arsitektur dasar sebelum membiarkan arsitektur kotak hitam tingkat lanjut memikul beban kinerja.

Kami ingin fokus pada demistifikasi, kepraktisan, pemahaman, intuisi dan proyek nyata. Mau belajar bagaimana Anda dapat membuat perbedaan? Kami akan membawa Anda dalam perjalanan dari cara otak kami memproses gambar hingga menulis pengklasifikasi pembelajaran mendalam tingkat penelitian untuk kanker payudara hingga jaringan pembelajaran mendalam yang "berhalusinasi", mengajari Anda prinsip dan teori melalui kerja praktik, membekali Anda dengan pengetahuan dan alat untuk menjadi ahli dalam menerapkan pembelajaran mendalam untuk memecahkan visi komputer.

Apa yang ada di dalam?

• Prinsip pertama visi dan bagaimana komputer dapat diajarkan untuk "melihat"
• Berbagai tugas dan aplikasi visi komputer
• Alat perdagangan yang akan membuat pekerjaan Anda lebih mudah
• Menemukan, membuat, dan memanfaatkan kumpulan data untuk visi komputer
• Teori dan penerapan Jaringan Saraf Konvolusi
• Menangani pergeseran domain, kejadian bersama, dan bias lainnya dalam kumpulan data
• Transfer Belajar dan memanfaatkan waktu pelatihan dan sumber daya komputasi orang lain untuk keuntungan Anda
• Membangun dan melatih pengklasifikasi kanker payudara yang canggih
• Bagaimana menerapkan dosis skeptisisme yang sehat untuk mengarusutamakan gagasan dan memahami implikasi dari teknik yang diadopsi secara luas
• Memvisualisasikan "ruang konsep" ConvNet menggunakan t-SNE dan PCA
• Studi kasus tentang bagaimana perusahaan menggunakan teknik visi komputer untuk mencapai hasil yang lebih baik
• Evaluasi model yang tepat, visualisasi ruang laten dan mengidentifikasi perhatian model
• Melakukan penelitian domain, memproses kumpulan data Anda sendiri, dan membuat pengujian model
• Arsitektur mutakhir, perkembangan ide, apa yang membuatnya unik dan bagaimana menerapkannya
• KerasCV – perpustakaan WIP untuk menciptakan saluran pipa dan model yang canggih
• Cara mengurai dan membaca makalah dan menerapkannya sendiri
• Memilih model tergantung pada aplikasi Anda
• Membuat pipeline machine learning ujung ke ujung
• Lanskap dan intuisi pada deteksi objek dengan R-CNN, RetinaNet, SSD, dan YOLO yang Lebih Cepat
• Instance dan segmentasi semantik
• Pengenalan Objek Real-Time dengan YOLOv5
• Melatih Detektor Objek YOLOv5
• Bekerja dengan Transformers menggunakan KerasNLP (perpustakaan WIP kekuatan industri)
• Mengintegrasikan Transformer dengan ConvNets untuk menghasilkan keterangan gambar
• Deepdream
• Optimalisasi model Deep Learning untuk visi komputer