การตรวจจับขอบ OpenCV ใน Python ด้วย cv2.Canny()

บทนำ

การตรวจจับขอบเป็นสิ่งที่เราทำโดยธรรมชาติ แต่ไม่ใช่เรื่องง่ายเมื่อพูดถึงการกำหนดกฎสำหรับคอมพิวเตอร์ แม้ว่าจะมีการคิดค้นวิธีการต่างๆ ขึ้น แต่วิธีการครองราชย์ได้รับการพัฒนาโดย John F. Canny ในปี 1986 และได้รับการตั้งชื่อว่าวิธี Canny อย่างเหมาะสม

มันเร็ว แข็งแกร่งพอสมควร และทำงานได้ดีที่สุดเท่าที่จะทำได้สำหรับประเภทของเทคนิคที่เป็นอยู่ ในตอนท้ายของคู่มือนี้ คุณจะทราบวิธีการตรวจหาขอบแบบเรียลไทม์ในวิดีโอ และสร้างบางสิ่งในลักษณะดังต่อไปนี้

การตรวจจับขอบ Canny

วิธี Canny คืออะไร? ประกอบด้วยการดำเนินการที่แตกต่างกันสี่ประการ:

• เกาส์เนียนเรียบ
• การคำนวณการไล่ระดับสี
• การปราบปรามที่ไม่ใช่สูงสุด
• เกณฑ์ฮิสเทรีซิส

เกาส์เนียนเรียบ ใช้เป็นขั้นตอนแรกในการ "รีดออก" ภาพที่นำเข้า และทำให้สัญญาณรบกวนอ่อนลง ทำให้เอาต์พุตสุดท้ายสะอาดขึ้นมาก

การไล่ระดับภาพ มีการใช้งานในแอปพลิเคชันก่อนหน้านี้สำหรับการตรวจจับขอบ ที่โดดเด่นที่สุดคือฟิลเตอร์ Sobel และ Scharr อาศัยการไล่ระดับสีของภาพ ตัวกรอง Sobel เดือดลงไปสองเมล็ด (Gx และ Gy) ที่ไหน Gx ตรวจจับการเปลี่ยนแปลงในแนวนอนในขณะที่ Gy ตรวจจับการเปลี่ยนแปลงในแนวตั้ง:

G

x

=

[

-
1

0

+
1

-
2

0

+
2

-
1

0

+
1

]

G

y

=

[

-
1

-
2

-
1

0

0

0

+
1

+
2

+
1

]

เมื่อคุณเลื่อนพวกเขาไปเหนือรูปภาพ แต่ละคนจะ "หยิบ" (เน้น) เส้นในทิศทางตามลำดับ เมล็ด Scharr ทำงานในลักษณะเดียวกันโดยมีค่าต่างกัน:

G

x

=

[

+
3

0

-
3

+
10

0

-
10

+
3

0

-
3

]

G

y

=

[

+
3

+
10

+
3

0

0

0

-
3

-
10

-
3

]

ตัวกรองเหล่านี้ เมื่อรวมเข้ากับรูปภาพแล้ว จะสร้างแผนที่คุณลักษณะ:

เครดิตภาพ: Davidwkennedy

สำหรับแผนที่คุณสมบัติเหล่านี้ คุณสามารถคำนวณ ขนาดการไล่ระดับสี และ การวางแนวการไล่ระดับสี – เช่น การเปลี่ยนแปลงนั้นรุนแรงเพียงใด (มีแนวโน้มว่าบางสิ่งจะเป็นขอบ) และการเปลี่ยนแปลงนั้นชี้ไปในทิศทางใด เนื่องจาก Gy หมายถึงการเปลี่ยนแปลงในแนวตั้ง (การไล่ระดับสี Y) และ Gx หมายถึงการเปลี่ยนแปลงในแนวนอน (การไล่ระดับสี X) – คุณสามารถคำนวณขนาดได้โดยเพียงแค่ใช้ทฤษฎีบทพีทาโกรัส เพื่อให้ได้ด้านตรงข้ามมุมฉากของสามเหลี่ยมที่เกิดจาก "ซ้าย" และ ทิศทาง "ถูกต้อง":

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

การใช้ขนาดและการวางแนว คุณสามารถสร้างภาพที่เน้นขอบได้:

เครดิตภาพ: Davidwkennedy

อย่างไรก็ตาม – คุณสามารถดูได้ว่ามีเสียงรบกวนมากน้อยเพียงใดจากการเทอิฐ! การไล่ระดับสีของภาพมีความไวต่อสัญญาณรบกวนมาก นี่คือเหตุผลที่ใช้ตัวกรอง Sobel และ Scharr เป็นส่วนประกอบ แต่ไม่ใช่วิธีเดียวในวิธีของ Canny การปรับให้เรียบแบบเกาส์เซียนก็ช่วยได้เช่นกัน

การปราบปรามที่ไม่ใช่สูงสุด

ปัญหาที่สังเกตได้ของตัวกรอง Sobel คือขอบไม่ชัดเจน ไม่ใช่ว่ามีใครเอาดินสอมาขีดเส้นเพื่อสร้างเส้นตรงของภาพ โดยปกติแล้ว ขอบภาพจะไม่คมชัดนัก เนื่องจากแสงจะค่อยๆ กระจายออกไป อย่างไรก็ตาม เราสามารถหาเส้นร่วมที่ขอบ และลดพิกเซลที่เหลือรอบๆ เส้นนั้น ทำให้ได้เส้นแบ่งที่สะอาดและบางแทน สิ่งนี้เรียกว่า Non-Max Supression! พิกเซลที่ไม่ใช่พิกเซลสูงสุด (พิกเซลที่เล็กกว่าพิกเซลที่เรากำลังเปรียบเทียบในฟิลด์ขนาดเล็กในพื้นที่ เช่น เคอร์เนล 3×3) จะถูกระงับ แนวคิดนี้ใช้ได้กับงานมากกว่านี้ แต่ให้รวมเข้ากับบริบทนี้ก่อน

เกณฑ์ฮิสเทรีซิส

ขอบที่ไม่ใช่ขอบจำนวนมากสามารถถูกประเมินเป็นขอบได้ เนื่องจากสภาพแสง วัสดุในภาพ ฯลฯ เนื่องจากสาเหตุหลายประการ การคำนวณผิดพลาดเหล่านี้จึงเกิดขึ้น เป็นการยากที่จะประเมินโดยอัตโนมัติว่าขอบคืออะไรและไม่ใช่ ท. คุณสามารถกำหนดเกณฑ์การไล่ระดับสีและรวมเฉพาะส่วนที่เข้มกว่าเท่านั้น โดยสมมติว่าขอบ "ของจริง" จะเข้มกว่าขอบ "ของปลอม"

เกณฑ์ทำงานในลักษณะเดียวกับปกติมาก – หากการไล่ระดับสีต่ำกว่าเกณฑ์ที่ต่ำกว่า ให้เอาออก (ลบเป็นศูนย์) และหากอยู่เหนือเกณฑ์สูงสุดที่กำหนด ให้เก็บไว้ ทุกอย่างที่อยู่ระหว่างขอบล่างและขอบบนจะอยู่ใน "โซนสีเทา" หากขอบใด ๆ ระหว่างธรณีประตูเชื่อมต่อกับ a ขอบสุดท้าย (อยู่เหนือธรณีประตู) – ถือว่าเป็นขอบเช่นกัน หากไม่ได้เชื่อมต่อกัน ก็มีแนวโน้มว่าจะมีขอบที่คำนวณผิด

นั่นคือขีดจำกัดฮิสเทรีซิส! ผลที่ได้คือช่วยล้างผลลัพธ์สุดท้ายและลบขอบเท็จขึ้นอยู่กับสิ่งที่คุณจัดว่าเป็นขอบเท็จ ในการหาค่าเกณฑ์ที่ดี โดยทั่วไป คุณจะต้องทดสอบกับขอบเขตล่างและบนที่แตกต่างกันสำหรับเกณฑ์ หรือใช้วิธีการอัตโนมัติ เช่น วิธีของโอสึ หรือวิธีสามเหลี่ยม

มาโหลดรูปภาพและสเกลสีเทากัน (Canny เหมือนกับที่ Sobel/Scharr ต้องการให้รูปภาพเป็นสีเทา):

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')

ภาพระยะใกล้ของนิ้วจะเป็นพื้นที่ทดสอบที่ดีสำหรับการตรวจจับขอบ ไม่ใช่เรื่องง่ายที่จะแยกแยะลายนิ้วมือจากภาพ แต่เราสามารถประมาณหนึ่งลายนิ้วมือได้

การตรวจจับขอบบนรูปภาพด้วย cv2.Canny()

อัลกอริทึมของ Canny สามารถใช้ได้โดยใช้ OpenCV's Canny() วิธี:

cv2.Canny(input_img, lower_bound, upper_bound)

การหาสมดุลที่เหมาะสมระหว่างขอบล่างและขอบบนอาจเป็นเรื่องยาก ถ้าทั้งคู่ต่ำ – คุณจะมีขอบน้อย หากขอบล่างต่ำและขอบบนสูง - คุณจะมีสัญญาณรบกวน หากทั้งคู่สูงและอยู่ใกล้กัน – คุณจะมีขอบเล็กน้อย จุดที่ถูกต้องมีช่องว่างเพียงพอระหว่างขอบเขตและมีขอบเขตที่เหมาะสม การทดลอง!

ภาพที่ป้อนจะเบลอด้วยวิธี Canny แต่บ่อยครั้งคุณจะได้ประโยชน์จากการเบลอภาพ ก่อน มันเข้าไปด้วย วิธีนี้ใช้การเบลอแบบเกาส์เซียน 5 × 5 กับอินพุตก่อนที่จะดำเนินการที่เหลือ แต่ถึงแม้จะเบลอนี้ ก็ยังมีสัญญาณรบกวนบางส่วนที่สามารถซึมผ่านได้ เราจึงเบลอภาพก่อนที่จะป้อนลงในอัลกอริทึม:

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')

ผลลัพธ์นี้ใน:

ค่าของ 20 และ 30 นี่ไม่ใช่กฎเกณฑ์ – ฉันได้ทดสอบวิธีการกับพารามิเตอร์ต่างๆ และเลือกชุดที่ดูเหมือนจะให้ผลลัพธ์ที่ดี เราลองทำให้สิ่งนี้เป็นอัตโนมัติได้ไหม

เกณฑ์อัตโนมัติสำหรับ cv2.Canny()?

คุณสามารถหาชุดค่าเกณฑ์ที่เหมาะสมที่สุดได้หรือไม่? ใช่ แต่ก็ไม่ได้ผลเสมอไป คุณสามารถคำนวณค่าที่ดีได้เอง แล้วปรับช่วงด้วย a sigma รอบเกณฑ์นั้น:

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

เมื่อ sigmaกล่าวคือ 0.33 – ขอบเขตจะเป็น 0.66*threshold และ 1.33*thresholdอนุญาตให้มีช่วง ~ 1/3 รอบ ๆ แม้ว่าการค้นหา threshold คือสิ่งที่ยากกว่า OpenCV ให้วิธีการของ Otsu แก่เรา (ใช้งานได้ดีกับรูปภาพแบบไบโมดอล) และวิธีสามเหลี่ยม มาลองใช้ทั้งสองอย่างกัน และใช้ค่ามัธยฐานอย่างง่ายของค่าพิกเซลเป็นตัวเลือกที่สาม:

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}")

ผลลัพธ์นี้ใน:

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

เหล่านี้ค่อนข้างแตกต่างกัน! จากค่าที่เราเคยเห็นมาก่อน เราสามารถคาดการณ์ว่าเมธอด Triangle จะทำงานได้ดีที่สุดที่นี่ เกณฑ์ที่กำหนดเองนั้นไม่ค่อยได้รับการแจ้ง เนื่องจากใช้เฉพาะค่าพิกเซลมัธยฐาน และจบลงด้วยการมีเกณฑ์ฐานที่สูงซึ่งจะถูกคูณเพิ่มเติมเป็นช่วงกว้างสำหรับรูปภาพนี้ วิธีการของ Otsu ทนทุกข์ทรมานน้อยกว่านี้ แต่ก็ยังทนทุกข์ทรมานอยู่

ถ้าเราเรียกใช้ Canny() เมธอดที่มีช่วงขีดจำกัดเหล่านี้:

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')

ผลลัพธ์นี้ใน:

วิธีสามเหลี่ยมทำงานได้ดีที่นี่! ซึ่งไม่รับประกันว่าจะทำงานได้ดีในกรณีอื่นๆ เช่นกัน

การตรวจจับขอบตามเวลาจริงในวิดีโอด้วย cv2.Canny()

สุดท้าย มาลองใช้ Canny edge detection กับวิดีโอแบบเรียลไทม์กันเถอะ! เราจะแสดงวิดีโอที่กำลังประมวลผล (แต่ละเฟรมเมื่อเสร็จแล้ว) โดยใช้ cv2.imshow() ซึ่งแสดงหน้าต่างที่มีกรอบที่เราต้องการแสดง แม้ว่าเราจะบันทึกวิดีโอลงในไฟล์ MP4 ที่สามารถตรวจสอบและแชร์ได้ในภายหลัง

ในการโหลดวิดีโอโดยใช้ OpenCV เราใช้ VideoCapture() กระบวนการ. ถ้าเราผ่านเข้า 0 – มันจะบันทึกจากเว็บแคมปัจจุบัน ดังนั้นคุณสามารถเรียกใช้รหัสบนเว็บแคมของคุณได้เช่นกัน! หากคุณส่งผ่านชื่อไฟล์ มันจะโหลดไฟล์:

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')

พื้นที่ VideoWriter ยอมรับพารามิเตอร์หลายตัว – ชื่อไฟล์เอาท์พุต, FourCC (โค้ดโค้ดสี่ตัว แสดงถึงตัวแปลงสัญญาณที่ใช้ในการเข้ารหัสวิดีโอ) อัตราเฟรมและความละเอียดเป็นทูเพิล เพื่อไม่ให้เดาหรือปรับขนาดวิดีโอ – เราใช้ความกว้างและความสูงของวิดีโอต้นฉบับซึ่งได้มาจาก VideoCapture ที่มีข้อมูลเกี่ยวกับตัววิดีโอ เช่น ความกว้าง ความสูง จำนวนเฟรมทั้งหมด เป็นต้น

ระหว่างเปิดแคป เราก็พยายามอ่านเฟรมต่อไปด้วย cap.read()ซึ่งส่งคืนรหัสผลลัพธ์และเฟรมถัดไป รหัสผลลัพธ์คือ True or Falseแสดงว่ามีเฟรมถัดไปหรือไม่มีเฟรมดังกล่าว เมื่อมีเฟรมเท่านั้น เราจะพยายามประมวลผลต่อไป มิฉะนั้น เราจะทำลายลูป สำหรับแต่ละเฟรมที่ถูกต้อง เราจะรันมันผ่านการเบลอแบบเกาส์เซียน แปลงเป็นระดับสีเทา รัน cv2.Canny() บนมันและเขียนโดยใช้ VideoWriter ลงดิสก์และแสดงผลโดยใช้ cv2.imshow() สำหรับการดูสด

สุดท้าย เราปล่อยตัวบันทึกและตัวเขียนวิดีโอ เนื่องจากทั้งคู่กำลังทำงานกับไฟล์บนดิสก์ และทำลายหน้าต่างที่มีอยู่ทั้งหมด

เมื่อคุณรันเมธอดด้วย a secret_video.mp4 อินพุต – คุณจะเห็นหน้าต่างป๊อปอัปและเมื่อเสร็จสิ้น ไฟล์ในไดเร็กทอรีการทำงานของคุณ:

สรุป

ในคู่มือนี้ เราได้มาดูวิธีการทำงานของการตรวจจับขอบ Canny และส่วนประกอบต่างๆ เช่น การทำให้เรียบแบบเกาส์เซียน ฟิลเตอร์ Sobel และการไล่ระดับภาพ สุดท้าย เราได้สำรวจวิธีการสำหรับการค้นหาช่วงเกณฑ์อัตโนมัติสำหรับการตรวจจับขอบ Canny ด้วย cv2.Canny()และใช้เทคนิคนี้กับวิดีโอ โดยให้การตรวจจับขอบแบบเรียลไทม์และบันทึกผลลัพธ์ลงในไฟล์วิดีโอ

ก้าวต่อไป – การเรียนรู้เชิงลึกเชิงปฏิบัติสำหรับคอมพิวเตอร์วิทัศน์

ธรรมชาติที่อยากรู้อยากเห็นของคุณทำให้คุณต้องการไปต่อหรือไม่? เราขอแนะนำให้ตรวจสอบของเรา คอร์ส: “การเรียนรู้เชิงลึกเชิงปฏิบัติสำหรับคอมพิวเตอร์วิทัศน์ด้วย Python”.

หลักสูตร Computer Vision อื่น?

เราจะไม่ทำการจำแนกตัวเลข MNIST หรือแฟชั่น MNIST พวกเขาทำหน้าที่ส่วนของตนเมื่อนานมาแล้ว ทรัพยากรการเรียนรู้จำนวนมากเกินไปมุ่งเน้นไปที่ชุดข้อมูลพื้นฐานและสถาปัตยกรรมพื้นฐาน ก่อนปล่อยให้สถาปัตยกรรมกล่องดำขั้นสูงรับภาระด้านประสิทธิภาพ

เราต้องการที่จะมุ่งเน้นไปที่ การทำให้ลึกลับ, การปฏิบัติจริง, ความเข้าใจ, ปรีชา และ โครงการจริง. ต้องการเรียน อย่างไร คุณสามารถสร้างความแตกต่าง? เราจะพาคุณเดินทางตั้งแต่วิธีที่สมองของเราประมวลผลภาพไปจนถึงการเขียนตัวแยกประเภทการเรียนรู้เชิงลึกระดับการวิจัยสำหรับมะเร็งเต้านม ไปจนถึงเครือข่ายการเรียนรู้เชิงลึกที่ "หลอน" สอนหลักการและทฤษฎีแก่คุณผ่านการทำงานจริง เพื่อให้คุณมี ความรู้และเครื่องมือในการเป็นผู้เชี่ยวชาญในการประยุกต์ใช้การเรียนรู้เชิงลึกเพื่อแก้ปัญหาคอมพิวเตอร์วิทัศน์

อะไรอยู่ข้างใน?

• หลักการมองเห็นเบื้องต้นและวิธีการสอนคอมพิวเตอร์ให้ “มองเห็น”
• งานต่างๆ และการประยุกต์ใช้คอมพิวเตอร์วิทัศน์
• เครื่องมือการค้าที่จะทำให้งานของคุณง่ายขึ้น
• การค้นหา การสร้าง และการใช้ชุดข้อมูลสำหรับคอมพิวเตอร์วิทัศน์
• ทฤษฎีและการประยุกต์ใช้ Convolutional Neural Networks
• การจัดการการเปลี่ยนแปลงโดเมน การเกิดขึ้นร่วม และอคติอื่นๆ ในชุดข้อมูล
• ถ่ายทอดการเรียนรู้และใช้เวลาฝึกอบรมและทรัพยากรการคำนวณของผู้อื่นเพื่อประโยชน์ของคุณ
• การสร้างและฝึกอบรมผู้จำแนกมะเร็งเต้านมที่ล้ำสมัย
• วิธีการใช้ความสงสัยที่ดีต่อสุขภาพกับแนวคิดกระแสหลักและทำความเข้าใจกับความหมายของเทคนิคที่นำมาใช้กันอย่างแพร่หลาย
• การแสดงภาพ "พื้นที่แนวคิด" ของ ConvNet โดยใช้ t-SNE และ PCA
• กรณีศึกษาวิธีที่บริษัทต่างๆ ใช้เทคนิคการมองเห็นด้วยคอมพิวเตอร์เพื่อให้ได้ผลลัพธ์ที่ดีขึ้น
• การประเมินแบบจำลองที่เหมาะสม การสร้างภาพพื้นที่แฝง และการระบุความสนใจของแบบจำลอง
• ดำเนินการวิจัยโดเมน ประมวลผลชุดข้อมูลของคุณเอง และสร้างการทดสอบแบบจำลอง
• สถาปัตยกรรมล้ำสมัย ความก้าวหน้าของแนวคิด สิ่งที่ทำให้มีเอกลักษณ์เฉพาะตัว และวิธีนำไปใช้
• KerasCV – ไลบรารี WIP สำหรับสร้างไปป์ไลน์และโมเดลที่ทันสมัย
• วิธีแยกวิเคราะห์และอ่านเอกสารและนำไปใช้เอง
• การเลือกรุ่นขึ้นอยู่กับการใช้งานของคุณ
• การสร้างไปป์ไลน์การเรียนรู้ของเครื่องแบบ end-to-end
• ภูมิทัศน์และสัญชาตญาณในการตรวจจับวัตถุด้วย R-CNN ที่เร็วกว่า, RetinaNets, SSD และ YOLO
• การแบ่งกลุ่มตัวอย่างและความหมาย
• การจดจำวัตถุแบบเรียลไทม์ด้วย YOLOv5
• การฝึกอบรมเครื่องตรวจจับวัตถุ YOLOv5
• การทำงานกับ Transformers โดยใช้ KerasNLP (ไลบรารี WIP ที่มีความแข็งแกร่งในอุตสาหกรรม)
• การรวม Transformers เข้ากับ ConvNets เพื่อสร้างคำบรรยายภาพ
• Deepdream
• การเพิ่มประสิทธิภาพโมเดล Deep Learning สำหรับคอมพิวเตอร์วิทัศน์