Deteksi Jalur Melengkung

Cerita

Pengantar

Dalam skenario mengemudi apa pun, garis lajur merupakan komponen penting untuk menunjukkan arus lalu lintas dan di mana kendaraan harus mengemudi. Ini juga merupakan titik awal yang baik ketika mengembangkan mobil self-driving! Membangun proyek deteksi jalur sebelumnya, saya telah menerapkan sistem deteksi jalur melengkung yang bekerja jauh lebih baik, dan lebih tangguh untuk lingkungan yang menantang.

Sistem deteksi jalur ditulis dengan Python menggunakan pustaka OpenCV. Berikut alur pemrosesan gambar saat ini:

• Koreksi Distorsi

• Perspektif Warp

• Pemfilteran Sobel

• Deteksi Puncak Histogram

• Penelusuran Jendela Geser

• Pemasangan Kurva

• Hamparan Jalur Terdeteksi

• Terapkan ke Video

Keterbatasan Sistem Sebelumnya

Dalam proyek deteksi jalur saya sebelumnya, saya telah mengembangkan sistem deteksi jalur yang sangat sederhana yang dapat mendeteksi garis jalur lurus dalam sebuah gambar. Ini bekerja dengan baik dalam kondisi sempurna, namun gagal mendeteksi jalur melengkung secara akurat, dan tidak tahan terhadap penghalang dan bayangan. Versi ini meningkatkan kedua keterbatasan ini.

Koreksi Distorsi

Lensa kamera mendistorsi cahaya yang masuk untuk memfokuskannya pada sensor kamera. Meskipun ini sangat berguna untuk memungkinkan kita menangkap gambar lingkungan kita, mereka sering kali menghasilkan distorsi cahaya yang sedikit tidak akurat. Hal ini dapat mengakibatkan pengukuran yang tidak akurat dalam aplikasi visi komputer. Namun, kita dapat dengan mudah memperbaiki distorsi ini.

Bagaimana Anda melakukannya? Anda dapat mengkalibrasi gambar Anda terhadap objek yang diketahui, dan menghasilkan model distorsi yang memperhitungkan distorsi lensa.

Objek ini sering berupa kotak-kotak asimetris, mirip dengan yang di bawah ini:

kalibrasi checkerboard (OpenCV Docs)

Kamera yang digunakan dalam video uji digunakan untuk mengambil 20 gambar checkerboard, yang digunakan untuk menghasilkan model distorsi. Kita mulai dengan mengonversi gambar menjadi skala abu-abu, lalu menerapkan fungsi cv2.findChessboardCorners() . Kita sudah tahu bahwa papan catur ini adalah objek 2 dimensi dengan garis lurus eksklusif, jadi kita dapat menerapkan beberapa transformasi ke sudut yang terdeteksi untuk menyelaraskannya dengan benar. Saya menggunakan cv2.CalibrateCamera() untuk mendapatkan koefisien distorsi dan matriks kamera. Kamera telah dikalibrasi!

Kemudian, Anda dapat menggunakan cv2.undistort() untuk memperbaiki sisa data masukan Anda. Anda dapat melihat perbedaan antara gambar asli kotak-kotak dan gambar yang dikoreksi di bawah ini:

Koreksi distorsi diterapkan pada gambar yang berisi papan catur kalibrasi.

Berikut kode persis yang saya gunakan untuk ini:

def undistort_img():
# Siapkan titik objek 0,0,0 … 8,5,0
obj_pts =np.zeros((6*9,3), np.float32)
obj_pts[:,:2] =np.mgrid[0:9, 0:6].T.reshape(-1,2)
# Menyimpan semua titik objek &titik img dari semua gambar
objpoints =[]
imgpoints =[]
# Dapatkan direktori untuk semua gambar kalibrasi
images =glob.glob('camera_cal/*.jpg')
untuk indx, fname di enumerate (gambar):
img =cv2.imread(fname)
abu-abu =cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, sudut =cv2.findChessboardCorners(abu-abu, (9,6 ), Tidak ada)
if ret ==Benar:
objpoints.append(obj_pts)
imgpoints.append(corners)
# Uji tidak terdistorsi pada img
img_size =( img.shape[1], img.shape[0])
# Kalibrasi kamera
ret, mtx, dist, rvecs, tvecs =cv2.calibrateCamera(objpoints, imgpoints, img_size, None,None)
dst =cv2.undistort(img, mtx, dist, None, mtx)
# Simpan kalibrasi kamera untuk digunakan nanti
dist_pickle ={}
dist_pickle['mtx'] =mtx
dist_pickle['dist' ] =dist
pickle.dump( dist_pickle, open('camera_cal/cal_pickle.p', 'wb') )
def undistort(img, cal_dir='camera_cal/cal_pickle.p'):
#cv2.imwrite('camera_cal/test_cal.jpg', dst)
dengan open(cal_dir, mode='rb') sebagai f:
file =pickle.load(f) mtx =file ['mtx']
dist =file['dist']
dst =cv2.undistort(img, mtx, dist, Tidak ada, mtx)
kembalikan dst
undistort_img()
img =cv2.imread('camera_cal/calibration1.jpg')
dst =undistort(img) # Gambar tidak terdistorsi

Fungsi yang digunakan untuk ini juga dapat ditemukan di Notebook Jupyter di bawah Kode bagian.

Berikut adalah koreksi distorsi yang diterapkan pada gambar jalan. Anda mungkin tidak dapat melihat sedikit perbedaan, tetapi hal itu dapat berdampak besar pada pemrosesan gambar.

Koreksi distorsi diterapkan pada adegan mengemudi

Perspektif Warp

Mendeteksi jalur melengkung di ruang kamera tidaklah mudah. Bagaimana jika kita bisa mendapatkan pandangan mata burung dari jalur? Itu bisa dilakukan dengan menerapkan transformasi perspektif pada gambar. Berikut tampilannya:

Perspektif gambar melengkung

Perhatikan sesuatu? Dengan mengasumsikan bahwa lajur berada pada permukaan 2D yang datar, kita dapat memasukkan polinomial yang dapat secara akurat mewakili lajur dalam ruang lajur! Bukankah itu keren?

Anda dapat menerapkan transformasi ini ke gambar apa pun menggunakan fungsi cv2.getPerspectiveTransform() untuk mendapatkan matriks transformasi, dan cv2.warpPerspective() untuk menerapkannya ke gambar. Berikut kode yang saya gunakan untuk ini:

def perspektif_warp(img,
dst_size=(1280,720),
src=np.float32([(0.43,0.65),(0.58,0.65),(0.1,1),(1,1 )]),
dst=np.float32([(0,0), (1, 0), (0,1), (1,1)])):
img_size =np. float32([(img.shape[1],img.shape[0])])
src =src* img_size
# Untuk titik tujuan, saya seenaknya memilih beberapa titik yang akan
# cocok untuk menampilkan hasil lengkung kita
# lagi, tidak tepat, tetapi cukup dekat untuk tujuan kita
dst =dst * np.float32(dst_size)
# Mengingat src dan dst poin , hitung matriks transformasi perspektif
M =cv2.getPerspectiveTransform(src, dst)
# Warp gambar menggunakan OpenCV warpPerspective()
warped =cv2.warpPerspective(img, M, dst_size)
kembali melengkung

Penyaringan Sobel

Pada versi sebelumnya, saya telah memfilter garis jalur menggunakan warna. Namun, ini tidak selalu merupakan pilihan terbaik. Jika jalan menggunakan beton berwarna terang sebagai pengganti aspal, jalan dengan mudah melewati filter warna, dan pipa akan melihatnya sebagai garis jalur putih. Tidak bagus.

Sebagai gantinya, kita dapat menggunakan metode yang mirip dengan detektor tepi kita, kali ini untuk memfilter jalan. Garis lajur biasanya memiliki kontras yang tinggi dengan jalan, jadi kami dapat menggunakan ini untuk keuntungan kami. The Canny detektor tepi yang sebelumnya digunakan di versi 1 menggunakan Operator Sobel untuk mendapatkan gradien fungsi gambar. Dokumentasi OpenCV memiliki penjelasan fantastis tentang cara kerjanya. Kami akan menggunakan ini untuk mendeteksi area dengan kontras tinggi untuk menyaring marka jalur dan mengabaikan jalan.

Kami masih akan menggunakan HLS Colorspace lagi, kali ini untuk mendeteksi perubahan Saturasi dan Lightness. Operator sobel diterapkan ke dua saluran ini, dan kami mengekstrak gradien sehubungan dengan sumbu x, dan menambahkan piksel yang melewati ambang gradien kami ke matriks biner yang mewakili piksel dalam gambar kami. Begini tampilannya di ruang kamera dan ruang lajur:

Perhatikan bahwa bagian gambar yang jauh dari kamera tidak dapat mempertahankan kualitasnya dengan baik. Karena keterbatasan resolusi kamera, data dari objek yang lebih jauh sangat kabur dan berisik. Kita tidak perlu fokus pada keseluruhan gambar, jadi kita bisa menggunakan sebagian saja. Berikut tampilan gambar yang akan kita gunakan:

Deteksi Puncak Histogram

Kami akan menerapkan algoritme khusus yang disebut Geser Jendela Algoritme untuk mendeteksi garis jalur kami. Namun, sebelum kita dapat menerapkannya, kita perlu menentukan titik awal yang baik untuk algoritma. Ini bekerja dengan baik jika dimulai di tempat di mana ada piksel jalur, tetapi bagaimana kita bisa mendeteksi lokasi piksel jalur ini di tempat pertama? Ini sebenarnya sangat sederhana!

Kami akan mendapatkan histogram gambar sehubungan dengan sumbu X. Setiap bagian dari histogram di bawah ini menampilkan berapa banyak piksel putih di setiap kolom gambar. Kami kemudian mengambil puncak tertinggi dari setiap sisi gambar, satu untuk setiap garis jalur. Berikut adalah tampilan histogram, di sebelah gambar biner:

Pencarian Jendela Geser

Algoritme jendela geser akan digunakan untuk membedakan antara batas lajur kiri dan kanan sehingga kita dapat memasukkan dua kurva berbeda yang mewakili batas lajur.

Baca Selengkapnya Detail:Deteksi Jalur Melengkung